feat: business_unit partitioning for agenda, goals, cc_tasks (#20)

Adds a per-BU partition key so operators running multiple verticals
(e.g. Stackbilt + FoodFiles) can scope agenda views, goal runs, and
task queues without forking AEGIS into separate instances.

Backwards-compatible additive change:
- New column business_unit TEXT NOT NULL DEFAULT 'stackbilt' on
  agent_agenda, agent_goals, cc_tasks
- New indexes: idx_agenda_bu, idx_goals_bu, idx_cc_tasks_bu
- All existing rows + callers default to 'stackbilt' — no breakage

API surface:
- addAgendaItem, addGoal: trailing optional businessUnit parameter
- getActiveAgendaItems, getActiveGoals: optional businessUnit filter
- MCP tools (aegis_agenda, aegis_list_goals, aegis_list_cc_tasks,
  aegis_add_agenda, aegis_add_goal, aegis_create_cc_task): accept
  optional business_unit arg
- REST GET /api/cc-tasks: accepts ?business_unit=X query param
- REST POST /api/cc-tasks: accepts business_unit in body
- Agenda dedup check now scopes candidate matching to same BU

Tests:
- New tests/business-unit.test.ts: 10 tests covering default + custom BU,
  filtered queries, dedup scoping, DEFAULT_BUSINESS_UNIT export
- Updated tests/mcp.test.ts: 6 handler tests assert new call signatures

Prod D1 migration applied (203 agenda + 15 goals + 562 cc_tasks rows
backfilled to 'stackbilt', 3 new indexes).

Closes #20.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

web/schema.sql

@@ -102,7 +102,8 @@ CREATE TABLE IF NOT EXISTS agent_agenda (
   priority TEXT NOT NULL DEFAULT 'medium' CHECK (priority IN ('low', 'medium', 'high')),
   status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'done', 'dismissed')),
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
-  resolved_at TEXT
+  resolved_at TEXT,
+  business_unit TEXT NOT NULL DEFAULT 'stackbilt'  -- partition key for multi-BU operators
 );
 
 -- ─── Autonomous Goals (#14) ────────────────────────────────────
@@ -119,7 +120,8 @@ CREATE TABLE IF NOT EXISTS agent_goals (
   next_run_at TEXT,
   completed_at TEXT,
   run_count INTEGER NOT NULL DEFAULT 0,
-  context_json TEXT
+  context_json TEXT,
+  business_unit TEXT NOT NULL DEFAULT 'stackbilt'  -- partition key for multi-BU operators
 );
 
 CREATE TABLE IF NOT EXISTS agent_actions (
@@ -179,8 +181,10 @@ CREATE INDEX IF NOT EXISTS idx_procedural_status ON procedural_memory(status);
 CREATE INDEX IF NOT EXISTS idx_heartbeat_created ON heartbeat_results(created_at);
 CREATE INDEX IF NOT EXISTS idx_agenda_status ON agent_agenda(status);
 CREATE INDEX IF NOT EXISTS idx_agenda_priority ON agent_agenda(priority);
+CREATE INDEX IF NOT EXISTS idx_agenda_bu ON agent_agenda(business_unit, status);
 CREATE INDEX IF NOT EXISTS idx_goals_status ON agent_goals(status);
 CREATE INDEX IF NOT EXISTS idx_goals_next_run ON agent_goals(next_run_at);
+CREATE INDEX IF NOT EXISTS idx_goals_bu ON agent_goals(business_unit, status);
 CREATE INDEX IF NOT EXISTS idx_actions_goal ON agent_actions(goal_id);
 CREATE INDEX IF NOT EXISTS idx_actions_created ON agent_actions(created_at);
 
@@ -291,12 +295,14 @@ CREATE TABLE IF NOT EXISTS cc_tasks (
   pr_url TEXT,                                   -- GitHub PR URL if one was created
   utility_json TEXT,                              -- PR utility scoring: {impact, novelty, signals[]}
   github_issue_repo TEXT,                        -- source issue repo (e.g. 'my-org/aegis')
-  github_issue_number INTEGER                    -- source issue number (repo-scoped)
+  github_issue_number INTEGER,                   -- source issue number (repo-scoped)
+  business_unit TEXT NOT NULL DEFAULT 'stackbilt' -- partition key for multi-BU operators
 );
 
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_status ON cc_tasks(status, priority);
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_depends ON cc_tasks(depends_on);
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_created ON cc_tasks(created_at);
+CREATE INDEX IF NOT EXISTS idx_cc_tasks_bu ON cc_tasks(business_unit, status);
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_authority ON cc_tasks(authority);
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_gh_issue ON cc_tasks(github_issue_repo, github_issue_number);
 CREATE INDEX IF NOT EXISTS idx_cc_tasks_failure_kind ON cc_tasks(failure_kind, completed_at);

web/src/kernel/memory/agenda.ts

@@ -27,8 +27,11 @@ export interface AgendaItem {
   status: AgendaStatus;
   created_at: string;
   resolved_at: string | null;
+  business_unit: string;
 }
 
+export const DEFAULT_BUSINESS_UNIT = 'stackbilt';
+
 // ─── Heartbeat History (#6) ──────────────────────────────────
 
 export interface HeartbeatResult {
@@ -47,10 +50,17 @@ export async function getRecentHeartbeats(db: D1Database, limit = 5): Promise<He
   return result.results as unknown as HeartbeatResult[];
 }
 
-export async function getActiveAgendaItems(db: D1Database): Promise<AgendaItem[]> {
-  const result = await db.prepare(
-    "SELECT * FROM agent_agenda WHERE status = 'active' ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 ELSE 2 END, created_at ASC"
-  ).all();
+export async function getActiveAgendaItems(
+  db: D1Database,
+  businessUnit?: string,
+): Promise<AgendaItem[]> {
+  const sql = businessUnit
+    ? "SELECT * FROM agent_agenda WHERE status = 'active' AND business_unit = ? ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 ELSE 2 END, created_at ASC"
+    : "SELECT * FROM agent_agenda WHERE status = 'active' ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'medium' THEN 1 ELSE 2 END, created_at ASC";
+  const stmt = businessUnit
+    ? db.prepare(sql).bind(businessUnit)
+    : db.prepare(sql);
+  const result = await stmt.all();
   return result.results as unknown as AgendaItem[];
 }
 
@@ -70,16 +80,19 @@ export async function addAgendaItem(
   item: string,
   context: string | undefined,
   priority: AgendaPriority,
+  businessUnit: string = DEFAULT_BUSINESS_UNIT,
 ): Promise<number> {
   // Dedup: check for existing active OR recently resolved items with similar text (#72)
   // Include items resolved within 7 days to prevent zombie re-creation loops
   // where a compliance item is re-flagged before the upstream source is updated.
   const keyPhrase = extractAgendaKeyPhrase(item);
   const words = keyPhrase.split(' ').filter(w => w.length > 3);
   if (words.length > 0) {
+    // Dedup scoped to the same business_unit — different BUs can have
+    // legitimately overlapping item text without being duplicates.
     const candidates = await db.prepare(
-      "SELECT id, item, priority, status FROM agent_agenda WHERE status = 'active' OR (status IN ('done', 'dismissed') AND resolved_at >= datetime('now', '-7 days'))"
-    ).all<{ id: number; item: string; priority: string; status: string }>();
+      "SELECT id, item, priority, status FROM agent_agenda WHERE business_unit = ? AND (status = 'active' OR (status IN ('done', 'dismissed') AND resolved_at >= datetime('now', '-7 days')))"
+    ).bind(businessUnit).all<{ id: number; item: string; priority: string; status: string }>();
 
     for (const existing of candidates.results) {
       const existingKey = extractAgendaKeyPhrase(existing.item);
@@ -102,8 +115,8 @@ export async function addAgendaItem(
   }
 
   const result = await db.prepare(
-    'INSERT INTO agent_agenda (item, context, priority) VALUES (?, ?, ?)'
-  ).bind(item, context ?? null, priority).run();
+    'INSERT INTO agent_agenda (item, context, priority, business_unit) VALUES (?, ?, ?, ?)'
+  ).bind(item, context ?? null, priority, businessUnit).run();
   return result.meta.last_row_id as number;
 }
 

web/src/kernel/memory/goals.ts

@@ -18,8 +18,11 @@ export interface AgentGoal {
   completed_at: string | null;
   run_count: number;
   context_json: string | null;
+  business_unit: string;
 }
 
+const DEFAULT_BUSINESS_UNIT = 'stackbilt';
+
 export interface AgentAction {
   id: string;
   goal_id: string | null;
@@ -34,10 +37,18 @@ export interface AgentAction {
   created_at: string;
 }
 
-export async function getActiveGoals(db: D1Database): Promise<AgentGoal[]> {
-  const result = await db.prepare(
-    "SELECT * FROM agent_goals WHERE status = 'active' ORDER BY created_at ASC"
-  ).all();
+export async function getActiveGoals(
+  db: D1Database,
+  businessUnit?: string,
+): Promise<AgentGoal[]> {
+  const stmt = businessUnit
+    ? db.prepare(
+        "SELECT * FROM agent_goals WHERE status = 'active' AND business_unit = ? ORDER BY created_at ASC"
+      ).bind(businessUnit)
+    : db.prepare(
+        "SELECT * FROM agent_goals WHERE status = 'active' ORDER BY created_at ASC"
+      );
+  const result = await stmt.all();
   return result.results as unknown as AgentGoal[];
 }
 
@@ -46,11 +57,12 @@ export async function addGoal(
   title: string,
   description?: string,
   scheduleHours = 6,
+  businessUnit: string = DEFAULT_BUSINESS_UNIT,
 ): Promise<string> {
   const id = crypto.randomUUID();
   await db.prepare(
-    'INSERT INTO agent_goals (id, title, description, schedule_hours) VALUES (?, ?, ?, ?)'
-  ).bind(id, title, description ?? null, scheduleHours).run();
+    'INSERT INTO agent_goals (id, title, description, schedule_hours, business_unit) VALUES (?, ?, ?, ?, ?)'
+  ).bind(id, title, description ?? null, scheduleHours, businessUnit).run();
   return id;
 }
 

web/src/mcp/handlers.ts

@@ -94,8 +94,9 @@ export async function toolAegisConversationHistory(args: Record<string, unknown>
   return { content: [{ type: 'text', text: JSON.stringify(messages, null, 2) }] };
 }
 
-export async function toolAegisAgenda(env: EdgeEnv): Promise<ToolResult> {
-  const items = await getActiveAgendaItems(env.db);
+export async function toolAegisAgenda(args: Record<string, unknown>, env: EdgeEnv): Promise<ToolResult> {
+  const businessUnit = typeof args.business_unit === 'string' ? args.business_unit : undefined;
+  const items = await getActiveAgendaItems(env.db, businessUnit);
   return { content: [{ type: 'text', text: JSON.stringify({ count: items.length, items }, null, 2) }] };
 }
 
@@ -216,8 +217,11 @@ export async function toolAegisAddAgenda(args: Record<string, unknown>, env: Edg
   if (!item) return { content: [{ type: 'text', text: 'Error: item is required' }], isError: true };
   const context = args.context as string | undefined;
   const priority = (args.priority as 'low' | 'medium' | 'high') ?? 'medium';
-  const id = await addAgendaItem(env.db, item, context, priority);
-  return { content: [{ type: 'text', text: `Added agenda item #${id}: "${item}" (${priority})` }] };
+  const businessUnit = (typeof args.business_unit === 'string' && args.business_unit.trim())
+    ? args.business_unit.trim()
+    : 'stackbilt';
+  const id = await addAgendaItem(env.db, item, context, priority, businessUnit);
+  return { content: [{ type: 'text', text: `Added agenda item #${id}: "${item}" (${priority}, ${businessUnit})` }] };
 }
 
 export async function toolAegisResolveAgenda(args: Record<string, unknown>, env: EdgeEnv): Promise<ToolResult> {
@@ -233,8 +237,11 @@ export async function toolAegisAddGoal(args: Record<string, unknown>, env: EdgeE
   if (!title) return { content: [{ type: 'text', text: 'Error: title is required' }], isError: true };
   const description = args.description as string | undefined;
   const scheduleHours = (args.schedule_hours as number) ?? 6;
-  const id = await addGoal(env.db, title, description, scheduleHours);
-  return { content: [{ type: 'text', text: `Created goal "${title}" (ID: ${id}, every ${scheduleHours}h)` }] };
+  const businessUnit = (typeof args.business_unit === 'string' && args.business_unit.trim())
+    ? args.business_unit.trim()
+    : 'stackbilt';
+  const id = await addGoal(env.db, title, description, scheduleHours, businessUnit);
+  return { content: [{ type: 'text', text: `Created goal "${title}" (ID: ${id}, every ${scheduleHours}h, ${businessUnit})` }] };
 }
 
 export async function toolAegisUpdateGoal(args: Record<string, unknown>, env: EdgeEnv): Promise<ToolResult> {
@@ -245,8 +252,9 @@ export async function toolAegisUpdateGoal(args: Record<string, unknown>, env: Ed
   return { content: [{ type: 'text', text: `Goal ${id} marked as ${status}` }] };
 }
 
-export async function toolAegisListGoals(env: EdgeEnv): Promise<ToolResult> {
-  const goals = await getActiveGoals(env.db);
+export async function toolAegisListGoals(args: Record<string, unknown>, env: EdgeEnv): Promise<ToolResult> {
+  const businessUnit = typeof args.business_unit === 'string' ? args.business_unit : undefined;
+  const goals = await getActiveGoals(env.db, businessUnit);
   return { content: [{ type: 'text', text: JSON.stringify({ count: goals.length, goals }, null, 2) }] };
 }
 
@@ -281,30 +289,39 @@ export async function toolAegisCreateCcTask(args: Record<string, unknown>, env:
 
   const category = validateEnum(TASK_CATEGORIES, args.category, 'feature');
   const authority = validateEnum(TASK_AUTHORITIES, args.authority, 'operator');
+  const businessUnit = (typeof args.business_unit === 'string' && args.business_unit.trim())
+    ? args.business_unit.trim()
+    : 'stackbilt';
 
   await env.db.prepare(`
-    INSERT INTO cc_tasks (id, title, repo, prompt, completion_signal, priority, depends_on, blocked_by, max_turns, created_by, authority, category)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'aegis', ?, ?)
-  `).bind(id, title.trim(), repo.trim(), prompt.trim(), completionSignal, priority, dependsOn, blockedBy ? JSON.stringify(blockedBy) : null, maxTurns, authority, category).run();
+    INSERT INTO cc_tasks (id, title, repo, prompt, completion_signal, priority, depends_on, blocked_by, max_turns, created_by, authority, category, business_unit)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'aegis', ?, ?, ?)
+  `).bind(id, title.trim(), repo.trim(), prompt.trim(), completionSignal, priority, dependsOn, blockedBy ? JSON.stringify(blockedBy) : null, maxTurns, authority, category, businessUnit).run();
 
-  return { content: [{ type: 'text', text: `Queued task "${title}" → ${repo} (ID: ${id}, priority: ${priority}, authority: ${authority}, category: ${category})` }] };
+  return { content: [{ type: 'text', text: `Queued task "${title}" → ${repo} (ID: ${id}, priority: ${priority}, authority: ${authority}, category: ${category}, business_unit: ${businessUnit})` }] };
 }
 
 export async function toolAegisListCcTasks(args: Record<string, unknown>, env: EdgeEnv): Promise<ToolResult> {
   const status = args.status as string | undefined;
+  const businessUnit = typeof args.business_unit === 'string' ? args.business_unit : undefined;
   const limit = Math.min(Math.max(1, (args.limit as number) || 20), 50);
 
-  let tasks;
-  const cols = 'id, title, repo, status, priority, authority, category, created_at, started_at, completed_at, exit_code, error, failure_kind, retryable';
+  const cols = 'id, title, repo, status, priority, authority, category, business_unit, created_at, started_at, completed_at, exit_code, error, failure_kind, retryable';
+  const conditions: string[] = [];
+  const bindings: unknown[] = [];
   if (status) {
-    tasks = await env.db.prepare(
-      `SELECT ${cols} FROM cc_tasks WHERE status = ? ORDER BY created_at DESC LIMIT ?`
-    ).bind(status, limit).all();
-  } else {
-    tasks = await env.db.prepare(
-      `SELECT ${cols} FROM cc_tasks ORDER BY created_at DESC LIMIT ?`
-    ).bind(limit).all();
+    conditions.push('status = ?');
+    bindings.push(status);
+  }
+  if (businessUnit) {
+    conditions.push('business_unit = ?');
+    bindings.push(businessUnit);
   }
+  const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+  bindings.push(limit);
+  const tasks = await env.db.prepare(
+    `SELECT ${cols} FROM cc_tasks ${where} ORDER BY created_at DESC LIMIT ?`
+  ).bind(...bindings).all();
 
   return { content: [{ type: 'text', text: JSON.stringify({ count: tasks.results.length, tasks: tasks.results }, null, 2) }] };
 }

web/src/mcp/server.ts

@@ -57,7 +57,7 @@ async function executeTool(name: string, args: Record<string, unknown>, env: Edg
     case 'aegis_chat': return toolAegisChat(args, env);
     case 'aegis_conversations': return toolAegisConversations(args, env);
     case 'aegis_conversation_history': return toolAegisConversationHistory(args, env);
-    case 'aegis_agenda': return toolAegisAgenda(env);
+    case 'aegis_agenda': return toolAegisAgenda(args, env);
     case 'aegis_health': return toolAegisHealth(env);
     case 'aegis_memory': return toolAegisMemory(args, env);
     case 'aegis_record_memory': return toolAegisRecordMemory(args, env);
@@ -66,7 +66,7 @@ async function executeTool(name: string, args: Record<string, unknown>, env: Edg
     case 'aegis_resolve_agenda': return toolAegisResolveAgenda(args, env);
     case 'aegis_add_goal': return toolAegisAddGoal(args, env);
     case 'aegis_update_goal': return toolAegisUpdateGoal(args, env);
-    case 'aegis_list_goals': return toolAegisListGoals(env);
+    case 'aegis_list_goals': return toolAegisListGoals(args, env);
     case 'aegis_cc_sessions': return toolAegisCcSessions(args, env);
     case 'aegis_create_cc_task': return toolAegisCreateCcTask(args, env);
     case 'aegis_list_cc_tasks': return toolAegisListCcTasks(args, env);

web/src/mcp/tools.ts

@@ -45,7 +45,9 @@ export const TOOLS = [
     description: 'List active AEGIS agenda items including proposed actions awaiting approval.',
     inputSchema: {
       type: 'object',
-      properties: {},
+      properties: {
+        business_unit: { type: 'string', description: 'Filter to a single business unit (e.g. "stackbilt", "foodfiles"). Omit for all.' },
+      },
     },
   },
   {
@@ -103,6 +105,7 @@ export const TOOLS = [
         item: { type: 'string', description: 'The action item — concise and actionable' },
         context: { type: 'string', description: 'Brief context: why this was added' },
         priority: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Priority level (default: medium)' },
+        business_unit: { type: 'string', description: 'Business unit this item belongs to (e.g. "stackbilt", "foodfiles"). Default: "stackbilt".' },
       },
       required: ['item'],
     },
@@ -128,6 +131,7 @@ export const TOOLS = [
         title: { type: 'string', description: 'Short goal title' },
         description: { type: 'string', description: 'What to check and what to do if action is needed' },
         schedule_hours: { type: 'number', description: 'How often to evaluate in hours (default: 6)' },
+        business_unit: { type: 'string', description: 'Business unit this goal belongs to (e.g. "stackbilt", "foodfiles"). Default: "stackbilt".' },
       },
       required: ['title'],
     },
@@ -149,7 +153,9 @@ export const TOOLS = [
     description: 'List all active AEGIS autonomous goals with schedule and run count.',
     inputSchema: {
       type: 'object',
-      properties: {},
+      properties: {
+        business_unit: { type: 'string', description: 'Filter to a single business unit (e.g. "stackbilt", "foodfiles"). Omit for all.' },
+      },
     },
   },
   {
@@ -179,6 +185,7 @@ export const TOOLS = [
         max_turns: { type: 'number', description: 'Max agentic turns for safety (default: 25)' },
         category: { type: 'string', enum: ['docs', 'tests', 'research', 'bugfix', 'feature', 'refactor', 'deploy'], description: 'Task category for governance routing (default: feature)' },
         authority: { type: 'string', enum: ['proposed', 'auto_safe', 'operator'], description: 'Authority level: operator=run immediately, auto_safe=safe auto-execute, proposed=needs approval (default: operator)' },
+        business_unit: { type: 'string', description: 'Business unit this task belongs to (e.g. "stackbilt", "foodfiles"). Default: "stackbilt".' },
       },
       required: ['title', 'repo', 'prompt'],
     },
@@ -201,6 +208,7 @@ export const TOOLS = [
       type: 'object',
       properties: {
         status: { type: 'string', enum: ['pending', 'running', 'completed', 'failed', 'cancelled'], description: 'Filter by status. Omit for all.' },
+        business_unit: { type: 'string', description: 'Filter to a single business unit (e.g. "stackbilt", "foodfiles"). Omit for all.' },
         limit: { type: 'number', description: 'Max tasks to return (default 20)' },
       },
     },