@automagik/genie 4.260331.4 → 4.260331.6

package/src/lib/wish-sync.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for Wish Sync — filesystem to PG wish indexing.
+ * Run with: bun test src/lib/wish-sync.test.ts
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getConnection } from './db.js';
+import { DB_AVAILABLE, setupTestSchema } from './test-db.js';
+import { getWish, listWishes, parseWishStatus, syncWishes } from './wish-sync.js';
+
+// ============================================================================
+// parseWishStatus (pure parsing — no DB)
+// ============================================================================
+
+describe('parseWishStatus', () => {
+  test('parses status from markdown table', () => {
+    const content = '| **Status** | APPROVED |\n| **Slug** | test |';
+    expect(parseWishStatus(content)).toBe('APPROVED');
+  });
+
+  test('parses status with extra whitespace', () => {
+    const content = '|  **Status**  |  IN_PROGRESS  |';
+    expect(parseWishStatus(content)).toBe('IN_PROGRESS');
+  });
+
+  test('returns DRAFT when no status found', () => {
+    const content = '# Some wish\n\nNo table here.';
+    expect(parseWishStatus(content)).toBe('DRAFT');
+  });
+
+  test('handles DRAFT status', () => {
+    const content = '| **Status** | DRAFT |';
+    expect(parseWishStatus(content)).toBe('DRAFT');
+  });
+});
+
+// ============================================================================
+// syncWishes + queries (DB-dependent)
+// ============================================================================
+
+describe.skipIf(!DB_AVAILABLE)('pg', () => {
+  let cleanupSchema: () => Promise<void>;
+  const TEST_DIR = '/tmp/wish-sync-test';
+  const TEST_REPO = join(TEST_DIR, 'test-repo');
+
+  async function setupTestRepo(): Promise<void> {
+    await rm(TEST_DIR, { recursive: true, force: true });
+
+    // Create a repo with two wishes
+    const wish1Dir = join(TEST_REPO, '.genie', 'wishes', 'fix-auth');
+    const wish2Dir = join(TEST_REPO, '.genie', 'wishes', 'add-search');
+    await mkdir(wish1Dir, { recursive: true });
+    await mkdir(wish2Dir, { recursive: true });
+
+    await writeFile(
+      join(wish1Dir, 'WISH.md'),
+      '# Fix Auth\n\n| Field | Value |\n|-------|-------|\n| **Status** | APPROVED |\n| **Slug** | fix-auth |\n',
+    );
+    await writeFile(
+      join(wish2Dir, 'WISH.md'),
+      '# Add Search\n\n| Field | Value |\n|-------|-------|\n| **Status** | DRAFT |\n| **Slug** | add-search |\n',
+    );
+  }
+
+  beforeAll(async () => {
+    cleanupSchema = await setupTestSchema();
+    await setupTestRepo();
+  });
+
+  afterAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await cleanupSchema();
+  });
+
+  test('syncWishes upserts wishes from a repo', async () => {
+    const count = await syncWishes(TEST_REPO);
+    expect(count).toBe(2);
+
+    // Verify they're in PG
+    const sql = await getConnection();
+    const rows = await sql`SELECT * FROM wishes WHERE repo = ${TEST_REPO} ORDER BY slug`;
+    expect(rows.length).toBe(2);
+    expect(rows[0].slug).toBe('add-search');
+    expect(rows[0].status).toBe('DRAFT');
+    expect(rows[1].slug).toBe('fix-auth');
+    expect(rows[1].status).toBe('APPROVED');
+  });
+
+  test('syncWishes is idempotent — multiple runs do not duplicate', async () => {
+    await syncWishes(TEST_REPO);
+    await syncWishes(TEST_REPO);
+
+    const sql = await getConnection();
+    const rows = await sql`SELECT * FROM wishes WHERE repo = ${TEST_REPO}`;
+    expect(rows.length).toBe(2);
+  });
+
+  test('syncWishes updates status on re-sync', async () => {
+    // Update the WISH.md status
+    const wish1Path = join(TEST_REPO, '.genie', 'wishes', 'fix-auth', 'WISH.md');
+    await writeFile(
+      wish1Path,
+      '# Fix Auth\n\n| Field | Value |\n|-------|-------|\n| **Status** | DONE |\n| **Slug** | fix-auth |\n',
+    );
+
+    await syncWishes(TEST_REPO);
+
+    const sql = await getConnection();
+    const rows = await sql`SELECT status FROM wishes WHERE slug = ${'fix-auth'} AND repo = ${TEST_REPO}`;
+    expect(rows[0].status).toBe('DONE');
+  });
+
+  test('listWishes returns all wishes', async () => {
+    const wishes = await listWishes();
+    expect(wishes.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('listWishes filters by repo', async () => {
+    const wishes = await listWishes({ repo: TEST_REPO });
+    expect(wishes.length).toBe(2);
+  });
+
+  test('listWishes filters by status', async () => {
+    const wishes = await listWishes({ status: 'DRAFT' });
+    expect(wishes.some((w) => w.slug === 'add-search')).toBe(true);
+  });
+
+  test('getWish returns a single wish', async () => {
+    const wish = await getWish('add-search', TEST_REPO);
+    expect(wish).not.toBeNull();
+    expect(wish!.slug).toBe('add-search');
+    expect(wish!.status).toBe('DRAFT');
+  });
+
+  test('getWish returns null for nonexistent wish', async () => {
+    const wish = await getWish('nonexistent', TEST_REPO);
+    expect(wish).toBeNull();
+  });
+});

package/src/lib/wish-sync.ts

@@ -0,0 +1,182 @@
+/**
+ * Wish Sync — sync .genie/wishes/ from filesystem to PG for cross-repo querying.
+ *
+ * WISH.md files are the source of truth. PG is the index.
+ * Sync is idempotent — multiple runs don't create duplicates.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { getConnection } from './db.js';
+
+const REPOS_BASE = '/home/genie/workspace/repos';
+
+// ============================================================================
+// Status Parsing
+// ============================================================================
+
+/**
+ * Parse the Status field from a WISH.md markdown table.
+ * Looks for `| **Status** | <value> |` pattern.
+ */
+export function parseWishStatus(content: string): string {
+  const match = content.match(/\|\s*\*\*Status\*\*\s*\|\s*([^|]+)/i);
+  if (match) return match[1].trim();
+  return 'DRAFT';
+}
+
+// ============================================================================
+// Filesystem Scanning
+// ============================================================================
+
+interface DiscoveredWish {
+  slug: string;
+  repo: string;
+  namespace: string;
+  status: string;
+  filePath: string;
+}
+
+/**
+ * Scan a single repo for wishes in .genie/wishes/\*\/WISH.md.
+ */
+function scanRepoWishes(repoPath: string): DiscoveredWish[] {
+  const wishesDir = join(repoPath, '.genie', 'wishes');
+  if (!existsSync(wishesDir)) return [];
+
+  const results: DiscoveredWish[] = [];
+  const namespace = basename(repoPath);
+
+  try {
+    const entries = readdirSync(wishesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const wishPath = join(wishesDir, entry.name, 'WISH.md');
+      if (!existsSync(wishPath)) continue;
+
+      try {
+        const content = readFileSync(wishPath, 'utf-8');
+        results.push({
+          slug: entry.name,
+          repo: repoPath,
+          namespace,
+          status: parseWishStatus(content),
+          filePath: wishPath,
+        });
+      } catch {
+        // Unreadable file — skip
+      }
+    }
+  } catch {
+    // Can't read wishes dir — skip
+  }
+
+  return results;
+}
+
+/**
+ * Discover all wishes across all repos in REPOS_BASE, or a single repo.
+ */
+function discoverWishes(repoPath?: string): DiscoveredWish[] {
+  if (repoPath) return scanRepoWishes(repoPath);
+
+  if (!existsSync(REPOS_BASE)) return [];
+
+  const results: DiscoveredWish[] = [];
+  try {
+    const entries = readdirSync(REPOS_BASE, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      results.push(...scanRepoWishes(join(REPOS_BASE, entry.name)));
+    }
+  } catch {
+    // Can't read repos base — return empty
+  }
+
+  return results;
+}
+
+// ============================================================================
+// PG Sync
+// ============================================================================
+
+/**
+ * Sync wishes from filesystem to PG.
+ * Upserts discovered wishes — idempotent.
+ *
+ * @param repoPath - If provided, only sync wishes from this repo. Otherwise scan all repos.
+ */
+export async function syncWishes(repoPath?: string): Promise<number> {
+  const wishes = discoverWishes(repoPath);
+  if (wishes.length === 0) return 0;
+
+  const sql = await getConnection();
+
+  for (const wish of wishes) {
+    await sql`
+      INSERT INTO wishes (slug, repo, namespace, status, file_path)
+      VALUES (${wish.slug}, ${wish.repo}, ${wish.namespace}, ${wish.status}, ${wish.filePath})
+      ON CONFLICT (slug, repo) DO UPDATE SET
+        namespace = EXCLUDED.namespace,
+        status = EXCLUDED.status,
+        file_path = EXCLUDED.file_path,
+        updated_at = now()
+    `;
+  }
+
+  return wishes.length;
+}
+
+// ============================================================================
+// Queries
+// ============================================================================
+
+interface WishRow {
+  id: number;
+  slug: string;
+  repo: string;
+  namespace: string | null;
+  status: string;
+  file_path: string;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * List wishes from PG with optional filters.
+ */
+export async function listWishes(filters?: {
+  repo?: string;
+  status?: string;
+  namespace?: string;
+}): Promise<WishRow[]> {
+  const sql = await getConnection();
+
+  if (filters?.repo && filters?.status) {
+    return sql`SELECT * FROM wishes WHERE repo = ${filters.repo} AND status = ${filters.status} ORDER BY updated_at DESC`;
+  }
+  if (filters?.repo) {
+    return sql`SELECT * FROM wishes WHERE repo = ${filters.repo} ORDER BY updated_at DESC`;
+  }
+  if (filters?.status) {
+    return sql`SELECT * FROM wishes WHERE status = ${filters.status} ORDER BY updated_at DESC`;
+  }
+  if (filters?.namespace) {
+    return sql`SELECT * FROM wishes WHERE namespace = ${filters.namespace} ORDER BY updated_at DESC`;
+  }
+
+  return sql`SELECT * FROM wishes ORDER BY updated_at DESC`;
+}
+
+/**
+ * Get a single wish by slug, optionally scoped to a repo.
+ */
+export async function getWish(slug: string, repo?: string): Promise<WishRow | null> {
+  const sql = await getConnection();
+
+  const rows = repo
+    ? await sql`SELECT * FROM wishes WHERE slug = ${slug} AND repo = ${repo} LIMIT 1`
+    : await sql`SELECT * FROM wishes WHERE slug = ${slug} ORDER BY updated_at DESC LIMIT 1`;
+
+  return rows.length > 0 ? (rows[0] as WishRow) : null;
+}

package/src/term-commands/agent/index.ts

@@ -37,4 +37,10 @@ export function registerAgentCommands(program: Command): void {
   registerAgentBrief(agent);
   registerAgentLog(agent);
   registerAgentSend(agent);
+
+  agent.on('command:*', (operands: string[]) => {
+    const cmd = operands[0];
+    const available = agent.commands.map((c) => c.name()).join(', ');
+    agent.error(`Unknown agent command '${cmd}'. Available: ${available}`);
+  });
 }

package/src/term-commands/agent/send.ts

@@ -44,6 +44,18 @@ export function registerAgentSend(parent: Command): void {
 // Hierarchy ACL
 // ============================================================================
 
+/** Check if an agent name matches the team's leader (by alias or actual name). */
+async function isTeamLeader(agentName: string, teamName: string): Promise<boolean> {
+  if (agentName === 'team-lead') return true;
+  try {
+    const teamMgr = await import('../../lib/team-manager.js');
+    const config = await teamMgr.getTeam(teamName);
+    return agentName === config?.leader;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Check hierarchy: sender can reach recipient if:
  * 1. sender is 'cli' (bypass)
@@ -74,8 +86,10 @@ async function checkHierarchy(from: string, to: string): Promise<{ allowed: bool
     // Siblings: same manager
     if (sender.reportsTo && sender.reportsTo === recipient.reportsTo) return { allowed: true };
 
-    // Team-lead can reach anyone in their team
-    if (from === 'team-lead' && sender.team && sender.team === recipient.team) return { allowed: true };
+    // Leader can reach anyone in their team
+    if (sender.team && sender.team === recipient.team && (await isTeamLeader(from, sender.team))) {
+      return { allowed: true };
+    }
 
     const manager = sender.reportsTo ?? 'your manager';
     return {

package/src/term-commands/agents.ts

@@ -38,6 +38,19 @@ import { isPaneAlive } from '../lib/tmux.js';
 // Helper Functions
 // ============================================================================
 
+/**
+ * Resolve the leader name for a team from team config.
+ * Falls back to 'team-lead' for legacy teams without a leader set.
+ */
+async function resolveTeamLeaderName(teamNameOrDefault: string): Promise<string> {
+  try {
+    const config = await teamManager.getTeam(teamNameOrDefault);
+    return config?.leader || 'team-lead';
+  } catch {
+    return 'team-lead';
+  }
+}
+
 /** Check if a process is alive by PID file. */
 function isRelayAlive(pidFile: string): boolean {
   const { readFileSync, existsSync } = require('node:fs');
@@ -79,6 +92,7 @@ async function ensureOtelRelay(team: string): Promise<boolean> {
   if (isRelayAlive(pidFile)) return true;
 
   const inboxDir = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'teams', team, 'inboxes');
+  const leaderInboxName = nativeTeams.sanitizeTeamName(await resolveTeamLeaderName(team));
   const escapedRelayDir = relayDir.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
   const escapedInboxDir = inboxDir.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
   const escapedPidFile = pidFile.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
@@ -103,7 +117,7 @@ import { join } from 'path';
 
 const RELAY_DIR = '${escapedRelayDir}';
 const INBOX_DIR = '${escapedInboxDir}';
-const INBOX = join(INBOX_DIR, 'team-lead.json');
+const INBOX = join(INBOX_DIR, '${leaderInboxName}.json');
 const PID_FILE = '${escapedPidFile}';
 const PORT = ${OTEL_RELAY_PORT};
 const SILENCE_MS = 5000;
@@ -570,7 +584,9 @@ async function notifySpawnJoin(ctx: SpawnCtx, paneId: string): Promise<void> {
     cwd: ctx.cwd,
     planModeRequired: nt.planModeRequired,
   });
-  await nativeTeams.writeNativeInbox(ctx.validated.team, 'team-lead', {
+  // Resolve the actual leader name for the inbox notification
+  const leaderName = await resolveTeamLeaderName(ctx.validated.team);
+  await nativeTeams.writeNativeInbox(ctx.validated.team, leaderName, {
     from: ctx.agentName,
     text: `Worker ${ctx.agentName} (${ctx.validated.provider}) joined team ${ctx.validated.team}. cwd: ${ctx.cwd}. Ready for tasks.`,
     summary: `${ctx.agentName} (${ctx.validated.provider}) joined`,
@@ -1430,7 +1446,10 @@ function formatGroupStatus(
  * Returns undefined if no wish context found.
  */
 export async function buildResumeContext(agent: registry.Agent): Promise<string | undefined> {
-  if (agent.role === 'team-lead' && agent.wishSlug) {
+  // Check if this agent is a leader (by role 'team-lead' or matching the team's leader name)
+  const isLeader =
+    agent.role === 'team-lead' || (agent.team && agent.role === (await resolveTeamLeaderName(agent.team)));
+  if (isLeader && agent.wishSlug) {
     try {
       const wishState = await import('../lib/wish-state.js');
       const state = await wishState.getState(agent.wishSlug, agent.repoPath);

package/src/term-commands/dir.ts

@@ -33,7 +33,6 @@ import { printSyncResult, syncAgentDirectory } from '../lib/agent-sync.js';
 import { getActor, recordAuditEvent } from '../lib/audit.js';
 import { ALL_BUILTINS } from '../lib/builtin-agents.js';
 import { contractPath } from '../lib/genie-config.js';
-import { findOmniAgent, registerAgentInOmni, resolveOmniApiUrl } from '../lib/omni-registration.js';
 
 export function registerDirNamespace(program: Command): void {
   const dir = program.command('dir').description('Agent directory management');
@@ -420,94 +419,3 @@ function printBuiltinsTable(): void {
   }
   console.log('');
 }
-
-// ============================================================================
-// Agent namespace — genie agent register
-// ============================================================================
-
-interface RegisterOptions {
-  dir: string;
-  repo?: string;
-  promptMode: string;
-  model?: string;
-  roles?: string[];
-  global?: boolean;
-  skipOmni?: boolean;
-}
-
-async function handleOmniRegistration(
-  name: string,
-  options: { model?: string; roles?: string[]; global?: boolean },
-): Promise<void> {
-  const omniUrl = await resolveOmniApiUrl();
-  if (!omniUrl) return;
-
-  console.log(`\nRegistering in Omni (${omniUrl})...`);
-
-  const existingId = await findOmniAgent(name);
-  if (existingId) {
-    console.log(`  Agent already exists in Omni: ${existingId}`);
-    await directory.edit(name, { omniAgentId: existingId }, { global: options.global });
-    console.log('  Linked existing Omni agent to directory entry.');
-    return;
-  }
-
-  const omniAgentId = await registerAgentInOmni(name, {
-    model: options.model,
-    roles: options.roles,
-  });
-  if (omniAgentId) {
-    await directory.edit(name, { omniAgentId }, { global: options.global });
-    console.log(`  Omni agent created: ${omniAgentId}`);
-    console.log('  Session isolation: per-person + per-channel');
-  }
-}
-
-async function handleAgentRegister(name: string, options: RegisterOptions): Promise<void> {
-  const promptMode = validatePromptMode(options.promptMode);
-
-  const roles = normalizeRoles(options.roles);
-  const entry = await directory.add(
-    {
-      name,
-      dir: resolvePath(options.dir),
-      repo: options.repo ? resolvePath(options.repo) : undefined,
-      promptMode,
-      model: options.model,
-      roles,
-    },
-    { global: options.global },
-  );
-
-  const scope = options.global ? 'global' : 'project';
-  console.log(`Agent "${entry.name}" registered (${scope}).`);
-  printEntry(entry);
-
-  if (!options.skipOmni) {
-    await handleOmniRegistration(name, { ...options, roles });
-  }
-}
-
-export function registerAgentNamespace(program: Command): void {
-  const agent = program.command('agent').description('Agent lifecycle management');
-
-  agent
-    .command('register <name>')
-    .description('Register an agent locally and auto-register in Omni when configured')
-    .requiredOption('--dir <path>', 'Agent folder (CWD + AGENTS.md)')
-    .option('--repo <path>', 'Default git repo (overridden by team)')
-    .option('--prompt-mode <mode>', 'Prompt mode: append or system', 'append')
-    .option('--model <model>', 'Default model (sonnet, opus, codex)')
-    .option('--roles <roles...>', 'Built-in roles this agent can orchestrate')
-    .option('--global', 'Write to global directory instead of project')
-    .option('--skip-omni', 'Skip Omni auto-registration')
-    .action(async (name: string, options: RegisterOptions) => {
-      try {
-        await handleAgentRegister(name, options);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error: ${message}`);
-        process.exit(1);
-      }
-    });
-}

package/src/term-commands/dispatch.ts

@@ -24,6 +24,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as protocolRouter from '../lib/protocol-router.js';
+import { parseWishRef, resolveWish } from '../lib/wish-resolve.js';
 import type { GroupDefinition } from '../lib/wish-state.js';
 import * as wishState from '../lib/wish-state.js';
 import { handleWorkerSpawn } from './agents.js';
@@ -291,6 +292,28 @@ function buildFallbackWaves(content: string): Wave[] {
   ];
 }
 
+// ============================================================================
+// Leader Resolution
+// ============================================================================
+
+/**
+ * Resolve the leader name for --to in dispatch prompts.
+ * Uses GENIE_TEAM to look up the team config's leader field.
+ * Falls back to 'team-lead' for legacy teams.
+ */
+async function resolveLeaderTarget(): Promise<string> {
+  const teamName = process.env.GENIE_TEAM;
+  if (!teamName) return 'team-lead';
+
+  try {
+    const teamManager = await import('../lib/team-manager.js');
+    const config = await teamManager.getTeam(teamName);
+    return config?.leader || 'team-lead';
+  } catch {
+    return 'team-lead';
+  }
+}
+
 // ============================================================================
 // Auto-Orchestration (fire-and-forget)
 // ============================================================================
@@ -333,7 +356,28 @@ export function detectWorkMode(
  * notifying the team-lead.
  */
 async function autoOrchestrateCommand(slug: string): Promise<void> {
-  const wishPath = join(process.cwd(), '.genie', 'wishes', slug, 'WISH.md');
+  let wishPath: string;
+  let actualSlug = slug;
+
+  // Check for namespace/slug format — resolve and auto-create team
+  const parsed = parseWishRef(slug);
+  if (parsed.namespace) {
+    const resolved = await resolveWish(slug);
+    wishPath = resolved.wishPath;
+    actualSlug = resolved.slug;
+
+    // Auto-create team using the resolved repo and session
+    const { handleTeamCreate } = await import('./team.js');
+    await handleTeamCreate(actualSlug, {
+      repo: resolved.repo,
+      branch: 'dev',
+      wish: actualSlug,
+      tmuxSession: resolved.session,
+    });
+    return; // handleTeamCreate spawns the leader, which runs the full lifecycle
+  }
+
+  wishPath = join(process.cwd(), '.genie', 'wishes', slug, 'WISH.md');
 
   if (!existsSync(wishPath)) {
     console.error(`❌ Wish not found: ${wishPath}`);
@@ -341,6 +385,9 @@ async function autoOrchestrateCommand(slug: string): Promise<void> {
     process.exit(1);
   }
 
+  // Best-effort: sync wish to PG index (non-blocking)
+  import('../lib/wish-sync.js').then((ws) => ws.syncWishes(process.cwd())).catch(() => {});
+
   const content = await readFile(wishPath, 'utf-8');
   const groups = parseWishGroups(content);
   const waves = parseExecutionStrategy(content);
@@ -545,7 +592,8 @@ async function workDispatchCommand(agentName: string, ref: string): Promise<void
   console.log(`   Group: ${group}`);
 
   const effectiveRole = `${agentName}-${group}`;
-  const workPrompt = `Execute Group ${group} of wish "${slug}". Your full context is in the system prompt. Read the wish at ${wishPath} if needed. Implement all deliverables, run validation, and report completion.\n\nWhen done:\n1. Run: genie done ${slug}#${group}\n2. Run: genie send 'Group ${group} complete. <summary>' --to team-lead`;
+  const leaderTarget = await resolveLeaderTarget();
+  const workPrompt = `Execute Group ${group} of wish "${slug}". Your full context is in the system prompt. Read the wish at ${wishPath} if needed. Implement all deliverables, run validation, and report completion.\n\nWhen done:\n1. Run: genie done ${slug}#${group}\n2. Run: genie send 'Group ${group} complete. <summary>' --to ${leaderTarget}`;
   await handleWorkerSpawn(agentName, {
     provider: 'claude',
     team: process.env.GENIE_TEAM ?? 'genie',
@@ -620,7 +668,8 @@ async function reviewCommand(agentName: string, ref: string): Promise<void> {
   console.log(`   Group: ${group}`);
   if (diff) console.log(`   Diff: ${diff.split('\n').length} lines`);
 
-  const reviewPrompt = `Review "${ref}". Your context and diff are in the system prompt. Evaluate against acceptance criteria and return SHIP, FIX-FIRST, or BLOCKED with severity-tagged findings.\n\nWhen done, report your verdict:\nRun: genie send '<SHIP|FIX-FIRST|BLOCKED> — <summary>' --to team-lead`;
+  const reviewLeaderTarget = await resolveLeaderTarget();
+  const reviewPrompt = `Review "${ref}". Your context and diff are in the system prompt. Evaluate against acceptance criteria and return SHIP, FIX-FIRST, or BLOCKED with severity-tagged findings.\n\nWhen done, report your verdict:\nRun: genie send '<SHIP|FIX-FIRST|BLOCKED> — <summary>' --to ${reviewLeaderTarget}`;
   await handleWorkerSpawn(agentName, {
     provider: 'claude',
     team: process.env.GENIE_TEAM ?? 'genie',