feat(server): show ultra-mode workflow subagents on the map

Ultra mode (the Workflow tool) writes its agent transcripts one level
deeper than classic Task subagents:
  <sessionId>/subagents/workflows/wf_<runId>/agent-*.jsonl
alongside agent-*.meta.json and an orchestration journal.jsonl.

The FileWatcher now descends into subagents/workflows/<run>/ and picks
up agent-*.jsonl transcripts only (journal/meta files are skipped), so
workflow agents stream through the existing parser and appear in the
village like any other subagent. resolveSubagentLabel learns the nested
path shape so the parent transcript is still found; workflow prompts
are not in the parent, so labels fall back to the prompt's first
sentence.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: FulAppiOS

server/src/parsers/subagent-label.test.ts

@@ -116,6 +116,43 @@ describe('resolveSubagentLabel', () => {
     expect(label!.endsWith('…')).toBe(true);
   });
 
+  test('resolves labels for workflow (ultra mode) agent paths', async () => {
+    const workflowDir = join(projectDir, parentSessionId, 'subagents', 'workflows', 'wf_2ca7ddd8-324');
+    await mkdir(workflowDir, { recursive: true });
+    const workflowAgentPath = join(workflowDir, 'agent-a4f3fba033446cc4f.jsonl');
+    await writeFile(workflowAgentPath, jsonline({
+      type: 'user',
+      message: { role: 'user', content: 'You are a senior engineer writing a plan. Read the spec first.' },
+    }));
+
+    const label = await resolveSubagentLabel(workflowAgentPath);
+    expect(label).toBe('You are a senior engineer writing a plan');
+  });
+
+  test('workflow agents still match parent Agent invocations when present', async () => {
+    const workflowDir = join(projectDir, parentSessionId, 'subagents', 'workflows', 'wf_deadbeef-123');
+    await mkdir(workflowDir, { recursive: true });
+    const workflowAgentPath = join(workflowDir, 'agent-bb11cc22dd33ee44f.jsonl');
+    await writeFile(workflowAgentPath, jsonline({
+      type: 'user',
+      message: { role: 'user', content: 'Audit module Y' },
+    }));
+    await writeFile(parentPath, jsonline({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        content: [{
+          type: 'tool_use',
+          name: 'Agent',
+          input: { description: 'Audit Y', prompt: 'Audit module Y' },
+        }],
+      },
+    }));
+
+    const label = await resolveSubagentLabel(workflowAgentPath);
+    expect(label).toBe('Audit Y');
+  });
+
   test('ignores parent Agent invocations with non-matching prompt', async () => {
     await writeFile(subagentPath, jsonline({
       type: 'user',

server/src/parsers/subagent-label.ts

@@ -72,16 +72,22 @@ function matchAgentLabel(parentText: string, targetPrompt: string): string | und
 }
 
 /**
- * Given a subagent JSONL path (`.../<parentSessionId>/subagents/agent-*.jsonl`),
+ * Given a subagent JSONL path (`.../<parentSessionId>/subagents/agent-*.jsonl`,
+ * or the ultra-mode variant `.../<parentSessionId>/subagents/workflows/wf_<runId>/agent-*.jsonl`),
  * return a human-readable label by correlating the child's first user prompt
  * against the parent's `Agent` tool_use invocations. Falls back to the first
  * sentence of the subagent prompt when the parent can't be found or doesn't
- * carry an exact prompt match.
+ * carry an exact prompt match — always the case for workflow agents, whose
+ * prompts live in the Workflow script rather than in the parent transcript.
  *
  * Returns `undefined` for non-subagent paths or when nothing usable is available.
  */
 export async function resolveSubagentLabel(filePath: string): Promise<string | undefined> {
-  const subagentsDir = dirname(filePath);
+  let subagentsDir = dirname(filePath);
+  // Workflow runs nest two levels deeper: subagents/workflows/wf_<runId>/
+  if (basename(dirname(subagentsDir)) === 'workflows') {
+    subagentsDir = dirname(dirname(subagentsDir));
+  }
   if (basename(subagentsDir) !== 'subagents') return undefined;
 
   const parentSessionDir = dirname(subagentsDir);

server/src/watchers/file-watcher.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtemp, rm, mkdir, writeFile, appendFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { FileWatcher } from './file-watcher';
+
+let claudeDir: string;
+let projectDir: string;
+
+beforeEach(async () => {
+  claudeDir = await mkdtemp(join(tmpdir(), 'file-watcher-'));
+  projectDir = join(claudeDir, 'projects', 'slug');
+  await mkdir(projectDir, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(claudeDir, { recursive: true, force: true });
+});
+
+function jsonline(obj: unknown): string {
+  return `${JSON.stringify(obj)}\n`;
+}
+
+interface ScanResult {
+  newSessions: string[];
+  updates: string[];
+}
+
+function makeWatcher(): { watcher: FileWatcher; result: ScanResult } {
+  const result: ScanResult = { newSessions: [], updates: [] };
+  const watcher = new FileWatcher({
+    claudeDirs: [claudeDir],
+    onNewSession: (sessionId) => {
+      result.newSessions.push(sessionId);
+    },
+    onSessionUpdate: (sessionId) => {
+      result.updates.push(sessionId);
+    },
+  });
+  return { watcher, result };
+}
+
+describe('FileWatcher workflow (ultra mode) discovery', () => {
+  test('discovers agent JSONLs nested under subagents/workflows/wf_*/', async () => {
+    const sessionId = 'e20383a7-8361-4ea9-bfee-305ea79263bc';
+    await writeFile(join(projectDir, `${sessionId}.jsonl`), jsonline({ type: 'user' }));
+
+    const subagentsDir = join(projectDir, sessionId, 'subagents');
+    await mkdir(subagentsDir, { recursive: true });
+    await writeFile(join(subagentsDir, 'agent-1111111111111111.jsonl'), jsonline({ type: 'user' }));
+
+    const workflowDir = join(subagentsDir, 'workflows', 'wf_2ca7ddd8-324');
+    await mkdir(workflowDir, { recursive: true });
+    await writeFile(join(workflowDir, 'agent-a4f3fba033446cc4f.jsonl'), jsonline({ type: 'user' }));
+    await writeFile(join(workflowDir, 'agent-a4f3fba033446cc4f.meta.json'), '{"agentType":"workflow-subagent"}');
+    await writeFile(join(workflowDir, 'journal.jsonl'), jsonline({ type: 'started' }));
+
+    const { watcher, result } = makeWatcher();
+    await watcher.scan();
+
+    expect(result.newSessions).toContain(sessionId);
+    expect(result.newSessions).toContain('agent-1111111111111111');
+    expect(result.newSessions).toContain('agent-a4f3fba033446cc4f');
+    // Orchestration journal and meta files must not become agents
+    expect(result.newSessions).not.toContain('journal');
+    expect(result.newSessions).not.toContain('agent-a4f3fba033446cc4f.meta');
+  });
+
+  test('emits updates when a workflow agent JSONL grows', async () => {
+    const sessionId = 'f207718a-066f-4609-82cb-eccf36a9e5a2';
+    const workflowDir = join(projectDir, sessionId, 'subagents', 'workflows', 'wf_9ca5aadf-8ab');
+    await mkdir(workflowDir, { recursive: true });
+    const agentPath = join(workflowDir, 'agent-afa8678eb14a03831.jsonl');
+    await writeFile(agentPath, jsonline({ type: 'user' }));
+
+    const { watcher, result } = makeWatcher();
+    await watcher.scan();
+    expect(result.newSessions).toContain('agent-afa8678eb14a03831');
+
+    await appendFile(agentPath, jsonline({ type: 'assistant' }));
+    await watcher.scan();
+    expect(result.updates).toContain('agent-afa8678eb14a03831');
+  });
+});

server/src/watchers/file-watcher.ts

@@ -128,13 +128,41 @@ export class FileWatcher {
         if (subFiles === null) continue;
 
         for (const subFile of subFiles) {
-          if (!subFile.endsWith('.jsonl')) continue;
-          await this.processJsonlFile(join(subagentsDir, subFile), subFile.replace('.jsonl', ''), claudeDir);
+          if (subFile.endsWith('.jsonl')) {
+            await this.processJsonlFile(join(subagentsDir, subFile), subFile.replace('.jsonl', ''), claudeDir);
+            continue;
+          }
+
+          // Ultra mode (Workflow tool) nests agent JSONLs one level deeper:
+          // <sessionId>/subagents/workflows/wf_<runId>/agent-*.jsonl
+          // (alongside agent-*.meta.json and an orchestration journal.jsonl)
+          if (subFile !== 'workflows') continue;
+          await this.scanWorkflowsDir(join(subagentsDir, subFile), claudeDir);
         }
       }
     }
   }
 
+  private async scanWorkflowsDir(workflowsDir: string, claudeDir: string): Promise<void> {
+    const runDirs = await readdir(workflowsDir).catch(() => null);
+    if (runDirs === null) return;
+
+    for (const runDir of runDirs) {
+      const runPath = join(workflowsDir, runDir);
+      const runStat = await stat(runPath).catch(() => null);
+      if (runStat === null || !runStat.isDirectory()) continue;
+
+      const runFiles = await readdir(runPath).catch(() => null);
+      if (runFiles === null) continue;
+
+      for (const runFile of runFiles) {
+        // Only agent transcripts — skips journal.jsonl and agent-*.meta.json
+        if (!runFile.startsWith('agent-') || !runFile.endsWith('.jsonl')) continue;
+        await this.processJsonlFile(join(runPath, runFile), runFile.replace('.jsonl', ''), claudeDir);
+      }
+    }
+  }
+
   private async processJsonlFile(filePath: string, sessionId: string, claudeDir: string): Promise<void> {
     const fileStat = await stat(filePath).catch(() => null);
     if (fileStat === null) return;