@automagik/genie 4.260331.3 → 4.260331.5

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

@@ -0,0 +1,108 @@
+/**
+ * Tests for Wish Resolution — namespace/slug parsing and path resolution.
+ * Run with: bun test src/lib/wish-resolve.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 { parseWishRef, resolveWish } from './wish-resolve.js';
+
+// ============================================================================
+// parseWishRef (pure parsing — no filesystem)
+// ============================================================================
+
+describe('parseWishRef', () => {
+  test('parses namespace/slug format', () => {
+    const ref = parseWishRef('genie/fix-tmux-session-explosion');
+    expect(ref.namespace).toBe('genie');
+    expect(ref.slug).toBe('fix-tmux-session-explosion');
+  });
+
+  test('parses bare slug without namespace', () => {
+    const ref = parseWishRef('fix-tmux-session-explosion');
+    expect(ref.namespace).toBeUndefined();
+    expect(ref.slug).toBe('fix-tmux-session-explosion');
+  });
+
+  test('trims whitespace', () => {
+    const ref = parseWishRef('  genie/slug  ');
+    expect(ref.namespace).toBe('genie');
+    expect(ref.slug).toBe('slug');
+  });
+
+  test('throws on empty string', () => {
+    expect(() => parseWishRef('')).toThrow('cannot be empty');
+    expect(() => parseWishRef('  ')).toThrow('cannot be empty');
+  });
+
+  test('throws on empty namespace', () => {
+    expect(() => parseWishRef('/slug')).toThrow('namespace is empty');
+  });
+
+  test('throws on empty slug', () => {
+    expect(() => parseWishRef('genie/')).toThrow('slug is empty');
+  });
+
+  test('throws on slug with nested slashes', () => {
+    expect(() => parseWishRef('genie/a/b')).toThrow('slug cannot contain "/"');
+  });
+});
+
+// ============================================================================
+// resolveWish (filesystem-dependent)
+// ============================================================================
+
+describe('resolveWish', () => {
+  const TEST_DIR = '/tmp/wish-resolve-test';
+  const FAKE_REPOS = join(TEST_DIR, 'repos');
+
+  beforeAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+
+    // Create a fake repo with a wish
+    const repoDir = join(FAKE_REPOS, 'myrepo');
+    const wishDir = join(repoDir, '.genie', 'wishes', 'fix-bug');
+    await mkdir(wishDir, { recursive: true });
+    await writeFile(join(wishDir, 'WISH.md'), '# Fix Bug Wish');
+
+    // Create a bare .git dir so resolveRepoSession doesn't fail
+    await mkdir(join(repoDir, '.git'), { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  test('throws for nonexistent repo namespace', async () => {
+    await expect(resolveWish('nonexistent/some-slug')).rejects.toThrow('not found at');
+  });
+
+  test('throws for nonexistent wish in valid repo', async () => {
+    // This test requires a repo at the expected REPOS_BASE location.
+    // Since we can't mock the path, we test the error message format.
+    await expect(resolveWish('nonexistent/slug')).rejects.toThrow('not found');
+  });
+
+  test('bare slug without namespace errors with helpful message', async () => {
+    // cwd won't have this wish
+    await expect(resolveWish('nonexistent-wish-slug')).rejects.toThrow('Use namespace/slug format');
+  });
+
+  test('bare slug found in cwd resolves correctly', async () => {
+    // Temporarily change cwd to a dir with a wish
+    const repoDir = join(FAKE_REPOS, 'myrepo');
+    const originalCwd = process.cwd();
+    process.chdir(repoDir);
+
+    try {
+      const result = await resolveWish('fix-bug');
+      expect(result.slug).toBe('fix-bug');
+      expect(result.repo).toBe(repoDir);
+      expect(result.wishPath).toContain('fix-bug/WISH.md');
+      expect(result.session).toBeTruthy();
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});

package/src/lib/wish-resolve.ts

@@ -0,0 +1,124 @@
+/**
+ * Wish Resolution — resolve namespace/slug references to concrete paths.
+ *
+ * Convention: `{namespace}/{slug}` where namespace = repo basename.
+ * Repos live at /home/genie/workspace/repos/{namespace}.
+ * WISH.md lives at {repo}/.genie/wishes/{slug}/WISH.md.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveRepoSession } from './tmux.js';
+
+const REPOS_BASE = '/home/genie/workspace/repos';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface WishRef {
+  namespace?: string;
+  slug: string;
+}
+
+interface ResolvedWish {
+  repo: string;
+  wishPath: string;
+  session: string;
+  slug: string;
+}
+
+// ============================================================================
+// Parsing
+// ============================================================================
+
+/**
+ * Parse a wish reference string into namespace and slug.
+ *
+ * Formats:
+ *   "namespace/slug"  → { namespace: "namespace", slug: "slug" }
+ *   "slug"            → { slug: "slug" }
+ *
+ * Only the first `/` is used as delimiter — slugs may not contain `/`.
+ */
+export function parseWishRef(ref: string): WishRef {
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    throw new Error('Wish reference cannot be empty');
+  }
+
+  const slashIndex = trimmed.indexOf('/');
+  if (slashIndex === -1) {
+    return { slug: trimmed };
+  }
+
+  const namespace = trimmed.slice(0, slashIndex);
+  const slug = trimmed.slice(slashIndex + 1);
+
+  if (!namespace) {
+    throw new Error(`Invalid wish reference "${ref}": namespace is empty`);
+  }
+  if (!slug) {
+    throw new Error(`Invalid wish reference "${ref}": slug is empty`);
+  }
+  if (slug.includes('/')) {
+    throw new Error(`Invalid wish reference "${ref}": slug cannot contain "/"`);
+  }
+
+  return { namespace, slug };
+}
+
+// ============================================================================
+// Resolution
+// ============================================================================
+
+/**
+ * Resolve a wish reference to a concrete repo path, wish path, and tmux session.
+ *
+ * @param ref - Wish reference in "namespace/slug" or "slug" format
+ * @returns Resolved wish with repo, wishPath, session, and slug
+ * @throws If repo not found, wish not found, or bare slug without namespace
+ */
+export async function resolveWish(ref: string): Promise<ResolvedWish> {
+  const parsed = parseWishRef(ref);
+
+  if (!parsed.namespace) {
+    // Bare slug — check cwd first
+    const cwdWishPath = join(process.cwd(), '.genie', 'wishes', parsed.slug, 'WISH.md');
+    if (existsSync(cwdWishPath)) {
+      const repo = process.cwd();
+      const session = await resolveRepoSession(repo);
+      return {
+        repo,
+        wishPath: cwdWishPath,
+        session,
+        slug: parsed.slug,
+      };
+    }
+
+    throw new Error(
+      `Wish "${parsed.slug}" not found in current directory. Use namespace/slug format (e.g., genie/${parsed.slug}) to specify the repo.`,
+    );
+  }
+
+  // Namespace provided — resolve repo
+  const repo = join(REPOS_BASE, parsed.namespace);
+  if (!existsSync(repo)) {
+    throw new Error(`Repository "${parsed.namespace}" not found at ${repo}. Available repos are in ${REPOS_BASE}.`);
+  }
+
+  // Verify WISH.md exists
+  const wishPath = join(repo, '.genie', 'wishes', parsed.slug, 'WISH.md');
+  if (!existsSync(wishPath)) {
+    throw new Error(`Wish "${parsed.slug}" not found in repo "${parsed.namespace}". Expected: ${wishPath}`);
+  }
+
+  const session = await resolveRepoSession(repo);
+
+  return {
+    repo,
+    wishPath,
+    session,
+    slug: parsed.slug,
+  };
+}

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/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);