@automagik/genie 4.260331.3 → 4.260331.5

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',

package/src/term-commands/msg.ts

@@ -99,6 +99,29 @@ async function findMemberByPane(teamName: string, paneId: string): Promise<strin
   }
 }
 
+// ============================================================================
+// Leader Alias Resolution
+// ============================================================================
+
+/**
+ * Resolve the 'team-lead' alias to the actual leader name for a given team context.
+ * Falls back to 'team-lead' for legacy teams without a leader set.
+ */
+async function resolveLeaderAlias(recipient: string, teamContext?: string): Promise<string> {
+  if (recipient !== 'team-lead') return recipient;
+
+  const teamManager = await getTeamManager();
+
+  // Try explicit team context first
+  const teamName = teamContext ?? process.env.GENIE_TEAM;
+  if (teamName) {
+    const config = await teamManager.getTeam(teamName);
+    if (config?.leader) return config.leader;
+  }
+
+  return 'team-lead';
+}
+
 // ============================================================================
 // Scope Checking
 // ============================================================================
@@ -124,11 +147,12 @@ export async function checkSendScope(_repoPath: string, sender: string, recipien
   return `Scope violation: "${recipient}" is not in sender's team(s): ${teamNames}`;
 }
 
-/** Build the list of teams the sender belongs to, including env-based team-lead membership. */
+/** Build the list of teams the sender belongs to, including env-based leader membership. */
 function resolveSenderTeams(teams: teamManagerTypes.TeamConfig[], sender: string): teamManagerTypes.TeamConfig[] {
   let senderTeams = teams.filter((t) => t.members.includes(sender));
 
-  if (sender === 'team-lead') {
+  // If sender is the leader (by name or 'team-lead' alias), include the leader's team
+  if (sender === 'team-lead' || teams.some((t) => t.leader === sender)) {
     const envTeam = process.env.GENIE_TEAM;
     if (envTeam) {
       const leaderTeam = teams.find((t) => t.name === envTeam);
@@ -141,9 +165,10 @@ function resolveSenderTeams(teams: teamManagerTypes.TeamConfig[], sender: string
   return senderTeams;
 }
 
-/** Check whether a recipient is reachable within a given team (direct member, team-lead, or prefixed name). */
+/** Check whether a recipient is reachable within a given team (direct member, leader, or prefixed name). */
 function isRecipientInTeam(team: teamManagerTypes.TeamConfig, recipient: string): boolean {
-  if (team.members.includes(recipient) || recipient === 'team-lead') return true;
+  // Direct member, legacy team-lead alias, or actual leader name
+  if (team.members.includes(recipient) || recipient === 'team-lead' || recipient === team.leader) return true;
   if (recipient.startsWith(`${team.name}-`)) {
     const roleOnly = recipient.slice(team.name.length + 1);
     if (team.members.includes(roleOnly)) return true;
@@ -161,9 +186,13 @@ async function findAgentTeam(_repoPath: string, agentName: string): Promise<team
   const memberTeam = teams.find((t) => t.members.includes(agentName));
   if (memberTeam) return memberTeam;
 
-  if (agentName === 'team-lead') {
+  // Match by leader name or legacy 'team-lead' alias
+  if (agentName === 'team-lead' || teams.some((t) => t.leader === agentName)) {
     const envTeam = process.env.GENIE_TEAM;
     if (envTeam) return teams.find((t) => t.name === envTeam) ?? null;
+    // Also find by leader field directly
+    const leaderTeam = teams.find((t) => t.leader === agentName);
+    if (leaderTeam) return leaderTeam;
   }
 
   return null;
@@ -430,14 +459,17 @@ async function handleSend(body: string, options: { to: string; from?: string; te
   const repoPath = process.cwd();
   const from = options.from ?? (await detectSenderIdentity(options.team));
 
-  const scopeError = await checkSendScope(repoPath, from, options.to);
+  // Resolve 'team-lead' alias to actual leader name
+  const to = await resolveLeaderAlias(options.to, options.team);
+
+  const scopeError = await checkSendScope(repoPath, from, to);
   if (scopeError) {
     console.error(`Error: ${scopeError}`);
     process.exit(1);
   }
 
   const senderActor = localActor(from);
-  const recipientActor = localActor(options.to);
+  const recipientActor = localActor(to);
 
   const conv = await ts.findOrCreateConversation({
     type: 'dm',
@@ -448,19 +480,19 @@ async function handleSend(body: string, options: { to: string; from?: string; te
   await ts.addMember(conv.id, senderActor);
   await ts.addMember(conv.id, recipientActor);
 
-  const mailboxMessage = await mailbox.send(repoPath, from, options.to, body);
+  const mailboxMessage = await mailbox.send(repoPath, from, to, body);
   const msg = await ts.sendMessage(conv.id, senderActor, body);
 
   // Emit runtime event for real-time observability (fire-and-forget)
   try {
     const { publishSubjectEvent } = await import('../lib/runtime-events.js');
-    await publishSubjectEvent(repoPath, `genie.msg.${options.to}`, {
+    await publishSubjectEvent(repoPath, `genie.msg.${to}`, {
       kind: 'message',
       agent: from,
       direction: 'out',
-      peer: options.to,
+      peer: to,
       text: body,
-      data: { messageId: msg.id, conversationId: conv.id, from, to: options.to },
+      data: { messageId: msg.id, conversationId: conv.id, from, to },
       source: 'mailbox',
     });
   } catch {
@@ -468,16 +500,16 @@ async function handleSend(body: string, options: { to: string; from?: string; te
   }
 
   // Best-effort native inbox bridge
-  const bridged = await bridgeToNativeInbox(from, options.to, body, options.team).catch((err) => {
+  const bridged = await bridgeToNativeInbox(from, to, body, options.team).catch((err) => {
     const reason = err instanceof Error ? err.message : String(err);
     console.warn(`[genie send] Native inbox bridge failed: ${reason}`);
     return false;
   });
   if (bridged) {
-    await mailbox.markDelivered(repoPath, options.to, mailboxMessage.id).catch(() => {});
+    await mailbox.markDelivered(repoPath, to, mailboxMessage.id).catch(() => {});
   }
 
-  console.log(`Message sent to "${options.to}".`);
+  console.log(`Message sent to "${to}".`);
   console.log(`  ID: ${msg.id}`);
   console.log(`  Conversation: ${conv.id}`);
 }

package/src/term-commands/state.ts

@@ -235,7 +235,27 @@ function autoKillPane(): void {
 // ============================================================================
 
 /**
- * Notify team-lead of wave or wish completion via protocol-router.
+ * Resolve the leader name and spawner for the current team context.
+ * Falls back to 'team-lead' for legacy teams.
+ */
+async function resolveNotificationTargets(): Promise<{ leader: string; spawner?: string }> {
+  const teamName = process.env.GENIE_TEAM;
+  if (!teamName) return { leader: 'team-lead' };
+
+  try {
+    const teamManager = await import('../lib/team-manager.js');
+    const config = await teamManager.getTeam(teamName);
+    return {
+      leader: config?.leader || 'team-lead',
+      spawner: config?.spawner,
+    };
+  } catch {
+    return { leader: 'team-lead' };
+  }
+}
+
+/**
+ * Notify leader (and spawner) of wave or wish completion via protocol-router.
  * Best-effort — failures are logged but do not block the done flow.
  */
 async function notifyWaveCompletion(
@@ -246,17 +266,27 @@ async function notifyWaveCompletion(
   try {
     const protocolRouter = await import('../lib/protocol-router.js');
     const repoPath = process.cwd();
+    const { leader, spawner } = await resolveNotificationTargets();
+
     const message = wishComplete
       ? `WISH COMPLETE — all groups done: [${waveResult.waveGroups.join(', ')}]. Run \`genie team done\` to clean up.`
       : `${waveResult.waveName} complete. All groups done: [${waveResult.waveGroups.join(', ')}]. Run /review or advance to next wave.`;
-    const result = await protocolRouter.sendMessage(repoPath, 'cli', 'team-lead', message);
+
+    // Notify leader
+    const result = await protocolRouter.sendMessage(repoPath, 'cli', leader, message);
     if (result && typeof result === 'object' && 'delivered' in result && !result.delivered) {
-      console.warn('   ⚠️ Wave-complete notification may not have been delivered.');
+      console.warn(`   ⚠️ Wave-complete notification to ${leader} may not have been delivered.`);
     } else {
-      console.log('   Notified team-lead of wave completion.');
+      console.log(`   Notified ${leader} of wave completion.`);
+    }
+
+    // Also notify spawner if different from leader
+    if (spawner && spawner !== leader && spawner !== 'cli') {
+      await protocolRouter.sendMessage(repoPath, 'cli', spawner, message).catch(() => {});
+      console.log(`   Notified spawner (${spawner}) of wave completion.`);
     }
   } catch {
-    console.warn('   ⚠️ Could not notify team-lead (messaging unavailable).');
+    console.warn('   ⚠️ Could not notify leader (messaging unavailable).');
   }
 }
 

package/src/term-commands/team.ts

@@ -245,7 +245,7 @@ export function registerTeamNamespace(program: Command): void {
 // Team Create Handler (extracted for cognitive complexity)
 // ============================================================================
 
-async function handleTeamCreate(
+export async function handleTeamCreate(
   name: string,
   options: { repo: string; branch: string; wish?: string; tmuxSession?: string; spawn?: boolean },
 ): Promise<void> {
@@ -328,6 +328,11 @@ async function spawnLeaderWithWish(
   config.tmuxSessionName = tmuxSession;
   await teamManager.updateTeamConfig(config.name, config);
 
+  // Set leader name = wish slug, spawner = caller identity
+  config.leader = slug;
+  config.spawner = process.env.GENIE_AGENT_NAME || 'cli';
+  await teamManager.updateTeamConfig(config.name, config);
+
   // Locate WISH.md in source repo
   const sourceWishPath = join(resolvedRepo, '.genie', 'wishes', slug, 'WISH.md');
   if (!existsSync(sourceWishPath)) {
@@ -342,17 +347,19 @@ async function spawnLeaderWithWish(
   await copyFile(sourceWishPath, destWishPath);
   console.log(`  Wish: copied ${slug}/WISH.md into worktree`);
 
-  // Hire the standard team: team-lead + engineer + reviewer + qa + fix
-  const standardTeam = ['team-lead', 'engineer', 'reviewer', 'qa', 'fix'];
+  // Hire the standard team: leader + engineer + reviewer + qa + fix
+  const leaderName = config.leader || 'team-lead';
+  const standardTeam = [leaderName, 'engineer', 'reviewer', 'qa', 'fix'];
   for (const role of standardTeam) {
     await teamManager.hireAgent(config.name, role);
   }
   console.log(`  Team: hired ${standardTeam.join(', ')}`);
 
   // Spawn leader — AGENTS.md comes from the built-in resolver, prompt delivered as initialPrompt
-  const members = standardTeam.filter((r) => r !== 'team-lead').join(', ');
-  const kickoffPrompt = `Your team is "${config.name}". Repo: ${config.repo}. Branch: ${config.name}. Worktree: ${config.worktreePath}. Wish slug: ${slug}. Your team members are: ${members} (already hired — genie work will spawn them automatically). Read the wish at .genie/wishes/${slug}/WISH.md and execute the full lifecycle autonomously.`;
-  await handleWorkerSpawn('team-lead', {
+  const members = standardTeam.filter((r) => r !== leaderName).join(', ');
+  const spawner = config.spawner || 'cli';
+  const kickoffPrompt = `Your team is "${config.name}". Repo: ${config.repo}. Branch: ${config.name}. Worktree: ${config.worktreePath}. Wish slug: ${slug}. Your team members are: ${members} (already hired — genie work will spawn them automatically). Report completion to: ${spawner} (via genie send --to ${spawner}). Read the wish at .genie/wishes/${slug}/WISH.md and execute the full lifecycle autonomously.`;
+  await handleWorkerSpawn(leaderName, {
     provider: 'claude',
     team: config.name,
     cwd: config.worktreePath,
@@ -362,9 +369,9 @@ async function spawnLeaderWithWish(
 
   // Deliver kickoff prompt via mailbox as backup (durable, queued to disk)
   const protocolRouter = await import('../lib/protocol-router.js');
-  const result = await protocolRouter.sendMessage(config.worktreePath, 'cli', 'team-lead', kickoffPrompt);
+  const result = await protocolRouter.sendMessage(config.worktreePath, 'cli', leaderName, kickoffPrompt);
   if (!result.delivered) {
-    console.warn(`⚠ Backup delivery to team-lead failed: ${result.reason ?? 'unknown'}`);
+    console.warn(`⚠ Backup delivery to ${leaderName} failed: ${result.reason ?? 'unknown'}`);
   }
   console.log('  Leader: spawned and working');
 }