@automagik/genie 4.260331.3 → 4.260331.5

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "genie",
   "name": "Genie",
   "description": "Skills, agents, and hooks for the Genie CLI terminal orchestration toolkit",
-  "version": "4.260331.3",
+  "version": "4.260331.5",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/genie",
-  "version": "4.260331.3",
+  "version": "4.260331.5",
   "description": "Collaborative terminal toolkit for human + AI workflows",
   "type": "module",
   "bin": {

package/plugins/genie/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "genie",
-  "version": "4.260331.3",
+  "version": "4.260331.5",
   "description": "Human-AI partnership for Claude Code. Share a terminal, orchestrate workers, evolve together. Brainstorm ideas, turn them into wishes, execute with /work, validate with /review, and ship as one team.",
   "author": {
     "name": "Namastex Labs"

package/plugins/genie/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genie-plugin",
-  "version": "4.260331.3",
+  "version": "4.260331.5",
   "private": true,
   "description": "Runtime dependencies for genie bundled CLIs",
   "type": "module",

package/src/db/migrations/016_team_spawner.sql

@@ -0,0 +1,5 @@
+-- 016: Team Spawner — track who created each team.
+-- Adds `spawner` column to teams table for orchestrator tracking.
+-- Idempotent: safe to re-run.
+
+ALTER TABLE teams ADD COLUMN IF NOT EXISTS spawner TEXT;

package/src/db/migrations/017_wishes_table.sql

@@ -0,0 +1,18 @@
+-- 017: Wishes table — filesystem wish index for cross-repo querying.
+-- Synced from .genie/wishes/*/WISH.md files in each repo.
+-- Idempotent: safe to re-run.
+
+CREATE TABLE IF NOT EXISTS wishes (
+  id SERIAL PRIMARY KEY,
+  slug TEXT NOT NULL,
+  repo TEXT NOT NULL,
+  namespace TEXT,
+  status TEXT DEFAULT 'DRAFT',
+  file_path TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now(),
+  updated_at TIMESTAMPTZ DEFAULT now(),
+  UNIQUE(slug, repo)
+);
+
+CREATE INDEX IF NOT EXISTS idx_wishes_status ON wishes(status);
+CREATE INDEX IF NOT EXISTS idx_wishes_namespace ON wishes(namespace) WHERE namespace IS NOT NULL;

package/src/genie-commands/session.ts

@@ -62,12 +62,22 @@ interface SessionOptions {
  * The leadSessionId is a placeholder -- CC updates it internally once started.
  * CC recognizes itself as leader because --team-name is passed without --agent-id.
  */
+async function resolveSessionLeaderName(teamName: string): Promise<string> {
+  try {
+    const { resolveLeaderName } = await import('../lib/team-manager.js');
+    return await resolveLeaderName(teamName);
+  } catch {
+    return 'team-lead'; // Fallback for legacy teams or when DB is unavailable
+  }
+}
+
 async function ensureNativeTeamForLeader(teamName: string, cwd: string): Promise<void> {
-  await ensureNativeTeam(teamName, `Genie team: ${teamName}`, 'pending');
+  const leaderName = await resolveSessionLeaderName(teamName);
+  await ensureNativeTeam(teamName, `Genie team: ${teamName}`, 'pending', leaderName);
 
   await registerNativeMember(teamName, {
     agentName: basename(cwd),
-    agentType: 'team-lead',
+    agentType: leaderName,
     color: 'blue',
     cwd,
   });
@@ -93,12 +103,14 @@ async function registerSessionInRegistry(sessionName: string, windowName: string
     const paneId = (await tmux.executeTmux(`display -t ${shellQuote(target)} -p '#{pane_id}'`)).trim();
     const now = new Date().toISOString();
     const sanitized = sanitizeTeamName(windowName);
+    const leaderName = await resolveSessionLeaderName(windowName);
+    const sanitizedLeader = sanitizeTeamName(leaderName);
     await registry.register({
-      id: `${sanitized}-team-lead`,
+      id: `${sanitized}-${sanitizedLeader}`,
       paneId,
       session: sessionName,
       team: windowName,
-      role: 'team-lead',
+      role: leaderName,
       worktree: null,
       startedAt: now,
       state: 'working',
@@ -107,11 +119,11 @@ async function registerSessionInRegistry(sessionName: string, windowName: string
       provider: 'claude',
       transport: 'tmux',
       nativeTeamEnabled: true,
-      nativeAgentId: `team-lead@${sanitized}`,
+      nativeAgentId: `${sanitizedLeader}@${sanitized}`,
     });
 
-    // Executor model: create agent identity + executor for team-lead session
-    const agentIdentity = await registry.findOrCreateAgent('team-lead', sanitized, 'team-lead');
+    // Executor model: create agent identity + executor for leader session
+    const agentIdentity = await registry.findOrCreateAgent(leaderName, sanitized, leaderName);
     await executorRegistry.terminateActiveExecutor(agentIdentity.id);
 
     let pid: number | null = null;

package/src/hooks/handlers/auto-spawn.ts

@@ -49,6 +49,17 @@ function buildSpawnArgs(template: {
   return args;
 }
 
+/** Check if the recipient is the team's actual leader (dynamic name, not 'team-lead' alias). */
+async function isRecipientLeader(recipient: string, teamName: string): Promise<boolean> {
+  try {
+    const { getTeam } = await import('../../lib/team-manager.js');
+    const config = await getTeam(teamName);
+    return !!config?.leader && recipient === config.leader;
+  } catch {
+    return false;
+  }
+}
+
 export async function autoSpawn(payload: HookPayload): Promise<HandlerResult> {
   const input = payload.tool_input;
   if (!input || input.type !== 'message') return;
@@ -59,6 +70,9 @@ export async function autoSpawn(payload: HookPayload): Promise<HandlerResult> {
   const teamName = process.env.GENIE_TEAM ?? payload.team_name;
   if (!teamName) return;
 
+  // Skip auto-spawn for the team's actual leader (not just 'team-lead' alias)
+  if (await isRecipientLeader(recipient, teamName)) return;
+
   try {
     const registryMod = await import('../../lib/agent-registry.js');
     const tmuxMod = await import('../../lib/tmux.js');

package/src/lib/agent-registry.ts

@@ -340,14 +340,28 @@ export async function removeSubPane(workerId: string, paneId: string, _registryP
   await sql`UPDATE agents SET sub_panes = ${sql.json(filtered)} WHERE id = ${workerId}`;
 }
 
+/** Resolve the dynamic leader name for a team (null if only 'team-lead' applies). */
+async function resolveDynamicLeaderName(teamName: string): Promise<string | null> {
+  try {
+    const { getTeam } = await import('./team-manager.js');
+    const config = await getTeam(teamName);
+    return config?.leader && config.leader !== 'team-lead' ? config.leader : null;
+  } catch {
+    return null; // Fallback to team-lead only
+  }
+}
+
 export async function getTeamLeadEntry(teamName: string, session?: string, repoPath?: string): Promise<Agent | null> {
   const sql = await getConnection();
   if (session) return findTeamLeadBySession(sql, teamName, session, repoPath);
   const legacyId = buildLegacyTeamLeadEntryId(teamName);
   const lr = await sql`SELECT * FROM agents WHERE id = ${legacyId}`;
   if (lr.length > 0) return rowToAgent(lr[0]);
-  const sr =
-    await sql`SELECT * FROM agents WHERE role = 'team-lead' AND team = ${teamName} ORDER BY started_at DESC LIMIT 1`;
+
+  const leaderName = await resolveDynamicLeaderName(teamName);
+  const sr = leaderName
+    ? await sql`SELECT * FROM agents WHERE (role = 'team-lead' OR role = ${leaderName}) AND team = ${teamName} ORDER BY started_at DESC LIMIT 1`
+    : await sql`SELECT * FROM agents WHERE role = 'team-lead' AND team = ${teamName} ORDER BY started_at DESC LIMIT 1`;
   return sr.length > 0 ? rowToAgent(sr[0]) : null;
 }
 
@@ -375,9 +389,15 @@ async function findTeamLeadBySession(
     const a = rowToAgent(legRows[0]);
     if (a.session === session && (!repoPath || a.repoPath === repoPath)) return a;
   }
-  const scanRows = await sql<
-    AgentRow[]
-  >`SELECT * FROM agents WHERE role = 'team-lead' AND team = ${teamName} AND session = ${session} ${repoPath ? sql`AND repo_path = ${repoPath}` : sql``} LIMIT 1`;
+
+  const leaderName = await resolveDynamicLeaderName(teamName);
+  const scanRows = leaderName
+    ? await sql<
+        AgentRow[]
+      >`SELECT * FROM agents WHERE (role = 'team-lead' OR role = ${leaderName}) AND team = ${teamName} AND session = ${session} ${repoPath ? sql`AND repo_path = ${repoPath}` : sql``} LIMIT 1`
+    : await sql<
+        AgentRow[]
+      >`SELECT * FROM agents WHERE role = 'team-lead' AND team = ${teamName} AND session = ${session} ${repoPath ? sql`AND repo_path = ${repoPath}` : sql``} LIMIT 1`;
   return scanRows.length > 0 ? rowToAgent(scanRows[0]) : null;
 }
 

package/src/lib/claude-native-teams.ts

@@ -184,6 +184,7 @@ export async function ensureNativeTeam(
   teamName: string,
   description: string,
   leadSessionId: string,
+  leaderName?: string,
 ): Promise<NativeTeamConfig> {
   const dir = teamDir(teamName);
   const inboxDir = inboxesDir(teamName);
@@ -195,11 +196,12 @@ export async function ensureNativeTeam(
   if (existing) return existing;
 
   const sanitized = sanitizeTeamName(teamName);
+  const resolvedLeader = sanitizeTeamName(leaderName ?? 'team-lead');
   const config: NativeTeamConfig = {
     name: sanitized,
     description,
     createdAt: Date.now(),
-    leadAgentId: `team-lead@${sanitized}`,
+    leadAgentId: `${resolvedLeader}@${sanitized}`,
     leadSessionId,
     members: [],
   };
@@ -387,12 +389,61 @@ export async function deleteNativeTeam(teamName: string): Promise<boolean> {
 // Inbox Scanning
 // ============================================================================
 
+/** Extract the leader inbox name from a native team config's leadAgentId. */
+function extractLeaderInboxName(config: NativeTeamConfig | null): string {
+  if (!config?.leadAgentId) return 'team-lead';
+  const atIdx = config.leadAgentId.indexOf('@');
+  return atIdx > 0 ? config.leadAgentId.slice(0, atIdx) : 'team-lead';
+}
+
+/** Scan a single team directory for unread leader inbox messages. */
+async function scanTeamInbox(
+  base: string,
+  name: string,
+): Promise<{
+  teamName: string;
+  unreadCount: number;
+  workingDir: string | null;
+  firstUnreadText: string | null;
+} | null> {
+  let config: NativeTeamConfig | null = null;
+  try {
+    const cfgContent = await readFile(join(base, name, 'config.json'), 'utf-8');
+    config = JSON.parse(cfgContent);
+  } catch {
+    // Config missing or malformed
+  }
+
+  const leaderInboxName = extractLeaderInboxName(config);
+  const inboxFile = join(base, name, 'inboxes', `${leaderInboxName}.json`);
+
+  let messages: NativeInboxMessage[];
+  try {
+    const content = await readFile(inboxFile, 'utf-8');
+    messages = JSON.parse(content);
+  } catch {
+    return null;
+  }
+
+  if (!Array.isArray(messages)) return null;
+  const unread = messages.filter((m) => m.read === false);
+  if (unread.length === 0) return null;
+
+  let workingDir: string | null = null;
+  if (config) {
+    const leadMember = config.members.find((m) => m.agentId === config?.leadAgentId || m.name === leaderInboxName);
+    if (leadMember?.cwd) workingDir = leadMember.cwd;
+  }
+
+  return { teamName: name, unreadCount: unread.length, workingDir, firstUnreadText: unread[0]?.text ?? null };
+}
+
 /**
- * List all teams that have unread messages in their team-lead inbox.
+ * List all teams that have unread messages in their leader's inbox.
  *
- * Scans `~/.claude/teams/` for teams where `inboxes/team-lead.json`
+ * Scans `~/.claude/teams/` for teams where the leader's inbox
  * contains messages with `read: false`. Returns the team name, unread
- * count, and working directory (from config.json → members → team-lead → cwd).
+ * count, and working directory (from config.json → members → leader → cwd).
  */
 export async function listTeamsWithUnreadInbox(): Promise<
   Array<{ teamName: string; unreadCount: number; workingDir: string | null; firstUnreadText: string | null }>
@@ -402,7 +453,7 @@ export async function listTeamsWithUnreadInbox(): Promise<
   try {
     teamDirs = await readdir(base);
   } catch {
-    return []; // No teams directory
+    return [];
   }
 
   const results: Array<{
@@ -413,40 +464,8 @@ export async function listTeamsWithUnreadInbox(): Promise<
   }> = [];
 
   for (const name of teamDirs) {
-    // Read inbox messages
-    const inboxFile = join(base, name, 'inboxes', 'team-lead.json');
-    let messages: NativeInboxMessage[];
-    try {
-      const content = await readFile(inboxFile, 'utf-8');
-      messages = JSON.parse(content);
-    } catch {
-      continue; // No inbox or invalid JSON
-    }
-
-    if (!Array.isArray(messages)) continue;
-
-    const unread = messages.filter((m) => m.read === false);
-    if (unread.length === 0) continue;
-
-    // Get workingDir from config.json → members → team-lead → cwd
-    let workingDir: string | null = null;
-    try {
-      const cfgContent = await readFile(join(base, name, 'config.json'), 'utf-8');
-      const config: NativeTeamConfig = JSON.parse(cfgContent);
-      const leadMember = config.members.find((m) => m.name === 'team-lead' || m.agentId.startsWith('team-lead@'));
-      if (leadMember?.cwd) {
-        workingDir = leadMember.cwd;
-      }
-    } catch {
-      // Config missing or malformed — workingDir stays null
-    }
-
-    results.push({
-      teamName: name,
-      unreadCount: unread.length,
-      workingDir,
-      firstUnreadText: unread[0]?.text ?? null,
-    });
+    const entry = await scanTeamInbox(base, name);
+    if (entry) results.push(entry);
   }
 
   return results;
@@ -550,7 +569,8 @@ async function readSessionMetadata(filePath: string): Promise<SessionMetadata> {
  */
 function rootScore(metadata: { teamName?: string; agentName?: string }): number {
   if (!metadata.teamName && !metadata.agentName) return 2;
-  if (metadata.agentName === 'team-lead') return 1;
+  // Score leader sessions higher — matches both legacy "team-lead" and dynamic leader names
+  if (metadata.agentName === 'team-lead' || (metadata.teamName && !metadata.agentName)) return 1;
   return 0;
 }
 
@@ -663,6 +683,7 @@ export async function registerAsTeamLead(
     cwd?: string;
     tmuxPaneId?: string;
     color?: string;
+    leaderName?: string;
   },
 ): Promise<{ sessionId: string; config: NativeTeamConfig }> {
   const sessionId = await discoverClaudeSessionId(opts?.cwd);
@@ -673,8 +694,10 @@ export async function registerAsTeamLead(
     );
   }
 
+  const resolvedLeaderName = opts?.leaderName ?? 'team-lead';
+
   // Create or load the native team, using the real CC session ID
-  const config = await ensureNativeTeam(teamName, `Genie team: ${teamName}`, sessionId);
+  const config = await ensureNativeTeam(teamName, `Genie team: ${teamName}`, sessionId, resolvedLeaderName);
 
   // Update leadSessionId if the team already existed with a stale ID
   if (config.leadSessionId !== sessionId) {
@@ -684,13 +707,14 @@ export async function registerAsTeamLead(
 
   // Register the leader as a member (CC expects the lead in the members array)
   const sanitized = sanitizeTeamName(teamName);
-  const leadAgentId = `team-lead@${sanitized}`;
+  const sanitizedLeader = sanitizeTeamName(resolvedLeaderName);
+  const leadAgentId = `${sanitizedLeader}@${sanitized}`;
   const existingLead = config.members.find((m) => m.agentId === leadAgentId);
 
   const resolvedPaneId = opts?.tmuxPaneId ?? process.env.TMUX_PANE;
   if (!existingLead || !existingLead.isActive) {
     await registerNativeMember(teamName, {
-      agentName: 'team-lead',
+      agentName: resolvedLeaderName,
       agentType: 'general-purpose',
       color: opts?.color ?? 'blue',
       tmuxPaneId: resolvedPaneId,
@@ -702,8 +726,8 @@ export async function registerAsTeamLead(
     await saveConfig(teamName, config);
   }
 
-  // Ensure the team-lead inbox exists
-  const inbox = inboxPath(teamName, 'team-lead');
+  // Ensure the leader's inbox exists
+  const inbox = inboxPath(teamName, resolvedLeaderName);
   if (!existsSync(inbox)) {
     await writeFile(inbox, '[]');
   }

package/src/lib/protocol-router-spawn.ts

@@ -245,7 +245,16 @@ export async function spawnWorkerFromTemplate(
       tmuxPaneId: paneId,
       cwd: repoPath,
     });
-    await nativeTeams.writeNativeInbox(team, 'team-lead', {
+    // Resolve the actual leader name for inbox notification
+    let leaderInboxTarget = 'team-lead';
+    try {
+      const { getTeam } = await import('./team-manager.js');
+      const teamConfig = await getTeam(team);
+      if (teamConfig?.leader) leaderInboxTarget = teamConfig.leader;
+    } catch {
+      // Fallback to 'team-lead' for legacy teams
+    }
+    await nativeTeams.writeNativeInbox(team, leaderInboxTarget, {
       from: agentName,
       text: `Worker ${agentName} (${template.provider}) auto-spawned${resumeSessionId ? ' with --resume' : ''}. Ready for tasks.`,
       summary: `${agentName} auto-spawned`,

package/src/lib/qa-runner.ts

@@ -435,7 +435,7 @@ async function runPreparedSpec(
       team: teamName,
       session: teamName,
       cwd: worktreePath,
-      role: 'team-lead',
+      role: 'qa',
       extraArgs: ['--append-system-prompt-file', promptFile],
       initialPrompt: `Execute the QA spec "${spec.name}" end-to-end right now. Do not stop after partial progress or a wait step. Continue until you validate the expectations, publish qa-report, and run team done. Your full instructions are in the system prompt.`,
     });

package/src/lib/team-auto-spawn.ts

@@ -111,10 +111,15 @@ export async function ensureTeamLead(teamName: string, workingDir: string): Prom
     return { created: false, session: currentSession, window: sanitizeWindowName(teamName) };
   }
 
+  // Resolve the actual leader name from team config (falls back to 'team-lead' for legacy)
+  const { getTeam } = await import('./team-manager.js');
+  const teamConfig = await getTeam(teamName);
+  const leaderName = teamConfig?.leader || 'team-lead';
+
   // Create native team structure
-  await ensureNativeTeam(teamName, `Genie team: ${teamName}`, 'pending');
+  await ensureNativeTeam(teamName, `Genie team: ${teamName}`, 'pending', leaderName);
   await registerNativeMember(teamName, {
-    agentName: 'team-lead',
+    agentName: leaderName,
     agentType: 'general-purpose',
     color: 'blue',
     cwd: workingDir,

package/src/lib/team-manager.test.ts

@@ -17,7 +17,9 @@ import {
   hireAgent,
   listMembers,
   listTeams,
+  resolveLeaderName,
   setTeamStatus,
+  updateTeamConfig,
   validateBranchName,
 } from './team-manager.js';
 import { DB_AVAILABLE, setupTestSchema } from './test-db.js';
@@ -274,6 +276,49 @@ describe.skipIf(!DB_AVAILABLE)('pg', () => {
       });
     });
 
+    describe('leader and spawner', () => {
+      test('new team gets leader and spawner when set via updateTeamConfig', async () => {
+        const config = await createTeam('feat/leader-test', TEST_REPO, 'dev');
+        config.leader = 'fix-tmux-session-explosion';
+        config.spawner = 'sofia';
+        await updateTeamConfig(config.name, config);
+
+        const updated = await getTeam('feat/leader-test');
+        expect(updated!.leader).toBe('fix-tmux-session-explosion');
+        expect(updated!.spawner).toBe('sofia');
+      });
+
+      test('resolveLeaderName returns leader for teams with leader set', async () => {
+        const config = await createTeam('feat/leader-resolve', TEST_REPO, 'dev');
+        config.leader = 'my-wish-slug';
+        await updateTeamConfig(config.name, config);
+
+        const name = await resolveLeaderName('feat/leader-resolve');
+        expect(name).toBe('my-wish-slug');
+      });
+
+      test('resolveLeaderName falls back to team-lead for legacy teams', async () => {
+        await createTeam('feat/legacy-leader', TEST_REPO, 'dev');
+        // No leader set — legacy team
+        const name = await resolveLeaderName('feat/legacy-leader');
+        expect(name).toBe('team-lead');
+      });
+
+      test('resolveLeaderName throws for nonexistent team', async () => {
+        expect(resolveLeaderName('nonexistent-team')).rejects.toThrow('not found');
+      });
+
+      test('spawner persisted in PG teams table', async () => {
+        const config = await createTeam('feat/spawner-pg', TEST_REPO, 'dev');
+        config.spawner = 'genie-pm';
+        await updateTeamConfig(config.name, config);
+
+        const sql = await getConnection();
+        const rows = await sql`SELECT spawner FROM teams WHERE name = ${'feat/spawner-pg'}`;
+        expect(rows[0].spawner).toBe('genie-pm');
+      });
+    });
+
     describe('disbandTeam', () => {
       test('removes clone directory and config from PG', async () => {
         const config = await createTeam('feat/disband-test', TEST_REPO, 'dev');

package/src/lib/team-manager.ts

@@ -57,6 +57,8 @@ export interface TeamConfig {
   tmuxSessionName?: string;
   /** Wish slug this team is working on (set via --wish). */
   wishSlug?: string;
+  /** Agent name (or 'cli') that created this team — workers report completion here. */
+  spawner?: string;
   /** ISO timestamp when the team was archived (null if not archived). */
   archivedAt?: string;
 }
@@ -92,6 +94,7 @@ interface TeamConfigRow {
   native_teams_enabled?: boolean;
   tmux_session_name?: string;
   wish_slug?: string;
+  spawner?: string;
   archived_at?: Date | string | null;
 }
 
@@ -111,6 +114,7 @@ function rowToTeamConfig(row: TeamConfigRow): TeamConfig {
   if (row.native_teams_enabled) config.nativeTeamsEnabled = row.native_teams_enabled;
   if (row.tmux_session_name) config.tmuxSessionName = row.tmux_session_name;
   if (row.wish_slug) config.wishSlug = row.wish_slug;
+  if (row.spawner) config.spawner = row.spawner;
   if (row.archived_at) {
     config.archivedAt = row.archived_at instanceof Date ? row.archived_at.toISOString() : String(row.archived_at);
   }
@@ -311,7 +315,7 @@ export async function createTeam(name: string, repo: string, baseBranch = 'dev')
     INSERT INTO teams (
       name, repo, base_branch, worktree_path, leader,
       members, status, native_team_parent_session_id,
-      native_teams_enabled, tmux_session_name, wish_slug, created_at
+      native_teams_enabled, tmux_session_name, wish_slug, spawner, created_at
     ) VALUES (
       ${config.name}, ${config.repo}, ${config.baseBranch},
       ${config.worktreePath}, ${config.leader ?? null},
@@ -319,7 +323,7 @@ export async function createTeam(name: string, repo: string, baseBranch = 'dev')
       ${config.nativeTeamParentSessionId ?? null},
       ${config.nativeTeamsEnabled ?? false},
       ${config.tmuxSessionName ?? null}, ${config.wishSlug ?? null},
-      ${config.createdAt}
+      ${config.spawner ?? null}, ${config.createdAt}
     ) ON CONFLICT (name) DO NOTHING
   `;
 
@@ -570,7 +574,8 @@ export async function updateTeamConfig(name: string, config: TeamConfig): Promis
       native_team_parent_session_id = ${config.nativeTeamParentSessionId ?? null},
       native_teams_enabled = ${config.nativeTeamsEnabled ?? false},
       tmux_session_name = ${config.tmuxSessionName ?? null},
-      wish_slug = ${config.wishSlug ?? null}
+      wish_slug = ${config.wishSlug ?? null},
+      spawner = ${config.spawner ?? null}
     WHERE name = ${name}
   `;
 }
@@ -623,6 +628,18 @@ export async function killTeamMembers(teamName: string): Promise<void> {
   }
 }
 
+/**
+ * Resolve the leader name for a team.
+ * Returns config.leader for teams that have it set, falls back to "team-lead" for legacy teams.
+ */
+export async function resolveLeaderName(teamName: string): Promise<string> {
+  const config = await getTeam(teamName);
+  if (!config) {
+    throw new Error(`Team "${teamName}" not found.`);
+  }
+  return config.leader || 'team-lead';
+}
+
 /** Set team lifecycle status. */
 export async function setTeamStatus(teamName: string, status: TeamStatus): Promise<void> {
   const sql = await getConnection();