codehere 0.5.0-alpha.6 → 0.6.0-alpha.1

package/dist/infrastructure/orchestration/gemini-adapter.js

@@ -28,7 +28,9 @@
  * fingerprints. Finalizes on `close` (not `exit`) so trailing stdout flushes.
  * Kills the process group (negative pid) so subagents under gemini exit too.
  */
-import { spawn, execFileSync } from 'child_process';
+import { spawn, execFile, execFileSync } from 'child_process';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
 import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
 import { existsSync } from 'fs';
@@ -36,6 +38,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 // `--approval-mode=yolo` auto-accepts every tool action without prompting (the
 // older `--yolo` flag is deprecated). codehere's safety hook is the external
@@ -87,6 +90,41 @@ function scanForKnownError(text) {
     }
     return null;
 }
+/**
+ * Parse the plain-text output of `gemini --list-sessions` and return the
+ * 1-based index for a given session UUID, or null if not found.
+ *
+ * Format (verified against gemini-cli source — packages/cli/src/utils/sessions.ts):
+ *   Available sessions for this project (3):
+ *
+ *     1. Some Title (5 minutes ago) [a1b2c3d4-...]
+ *     2. Other Title (1 hour ago, current) [e5f6g7h8-...]
+ *     3. Third One (yesterday) [9i0j1k2l-...]
+ *
+ * Indices are 1-based and stable within one run (sort-by-startTime); the UUID
+ * is the durable handle. We exported as a pure function so tests don't need
+ * the real gemini binary or a real session store.
+ */
+export function parseGeminiSessionIndexForUuid(listOutput, uuid) {
+    if (!uuid)
+        return null;
+    // Match `  N. <title> ... [<uuid>]` — UUID is always the last bracketed
+    // segment on the line. Title can contain anything (including bracketed
+    // text), so we match `[uuid]` at end-of-line, not the first `[...]`.
+    const lineRegex = /^\s*(\d+)\.\s.*\[([0-9a-fA-F-]{8,})\]\s*$/;
+    for (const raw of listOutput.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        const m = line.match(lineRegex);
+        if (!m)
+            continue;
+        const idx = Number.parseInt(m[1], 10);
+        if (!Number.isFinite(idx) || idx <= 0)
+            continue;
+        if (m[2] === uuid)
+            return idx;
+    }
+    return null;
+}
 export function spawnGemini(prompt, options = {}) {
     const sessionId = randomUUID();
     const startedAt = Date.now();
@@ -137,6 +175,27 @@ export function spawnGemini(prompt, options = {}) {
             if (typeof t === 'string')
                 textAccum += t + '\n';
         }
+        // #110 slice 4 — mirror gemini tool calls to the audit log. Same
+        // shape Codex uses (post-hoc, no block). gemini emits tool_use
+        // BEFORE the call lands; mirror at that point so the audit row
+        // appears around when the action happens.
+        if (event.type === 'tool_use') {
+            const data = event.data;
+            const toolName = String(data?.tool_name ?? 'tool');
+            const params = data?.parameters ?? {};
+            const input = (typeof params.command === 'string' && params.command) ||
+                (typeof params.file_path === 'string' && params.file_path) ||
+                (typeof params.path === 'string' && params.path) ||
+                (typeof params.query === 'string' && params.query) ||
+                JSON.stringify(params).slice(0, 500);
+            mirrorToolCallToAudit({
+                sessionId,
+                agent: 'gemini',
+                toolName,
+                toolInput: String(input),
+                cwd,
+            });
+        }
         // Token usage comes ONLY in the final `result` event with status:'success',
         // shape { stats: { input_tokens, output_tokens, total_tokens, cached } }.
         if (event.type === 'result') {
@@ -234,6 +293,11 @@ export function spawnGemini(prompt, options = {}) {
         };
     }
     let stdoutBuf = '';
+    // Captured from the gemini-cli `init` event so appendMessage can resolve
+    // it to a session-list index (gemini's --resume only takes index or
+    // 'latest', NOT the UUID itself). See parseGeminiSessionIndexForUuid +
+    // the appendMessage block below.
+    let geminiSessionUuid = null;
     child.stdout?.on('data', (chunk) => {
         stdoutBuf += chunk.toString('utf-8');
         let idx;
@@ -244,6 +308,9 @@ export function spawnGemini(prompt, options = {}) {
                 continue;
             try {
                 const data = JSON.parse(line);
+                if (data.type === 'init' && typeof data.session_id === 'string') {
+                    geminiSessionUuid = data.session_id;
+                }
                 emit({ type: data.type ?? 'gemini_event', timestamp: Date.now(), data });
             }
             catch {
@@ -356,24 +423,58 @@ export function spawnGemini(prompt, options = {}) {
         },
         canAppendMessage: true,
         /**
-         * v0.6.0 — Slice 2b of REPL persistence. Gemini's --resume flag accepts
-         * either a numeric INDEX (per-cwd ordinal of past sessions) or the literal
-         * string "latest" — NOT the session_id UUID that the init JSONL event
-         * emits. UUID→index mapping requires --list-sessions which has its own
-         * race condition (indices shift as sessions are added/deleted).
+         * v0.6.x — UUID→index resolution (replaces the prior --resume latest
+         * shortcut). Gemini's --resume flag accepts a numeric INDEX (per-cwd
+         * ordinal of past sessions) or the literal 'latest' — NOT the session_id
+         * UUID that the init JSONL event emits.
          *
-         * For the v0.6 cut we use --resume latest. Limitation: if the user spawns
-         * another gemini session in this cwd between the original spawn and this
-         * follow-up, the follow-up routes to the wrong session. Same caveat as
-         * opencode's --continue. Acceptable for the typical reply-within-minutes
-         * flow; the rigorous UUID→index helper is queued for v0.6.x.
+         * Strategy: capture session_id on spawn (see geminiSessionUuid above) →
+         * here, run `gemini --list-sessions` (plain text, no --json flag), parse
+         * each line for `[uuid]` at end of line, find the index that matches our
+         * captured UUID, and use it in --resume <N>. If anything fails (binary
+         * missing, list times out, UUID not found), fall back to --resume latest
+         * — same posture as before for safety, but with a chance to nail the
+         * exact session in the common case.
+         *
+         * Concurrency win: if a sibling session is spawned in the same cwd between
+         * spawn and reply, we no longer route the reply to the wrong one.
          */
-        appendMessage(text) {
+        async appendMessage(text) {
             const startedAt = Date.now();
+            // Resolve UUID→index ASYNCHRONOUSLY before spawning the followup. Must
+            // be async (not execFileSync) because this runs in the daemon's HTTP
+            // request path; a sync call would block the event loop and freeze every
+            // other in-flight session for up to the timeout.
+            let resumeArg = 'latest';
+            if (geminiSessionUuid) {
+                try {
+                    // gemini-cli's --list-sessions runs an internal generateSummary()
+                    // first, which itself has a 5000ms LLM-call abort timeout (see
+                    // sessionSummaryService.ts DEFAULT_TIMEOUT_MS in upstream). Our
+                    // wrapper timeout MUST be comfortably greater than that or we kill
+                    // the child mid-summary, get empty stdout, and silently fall back
+                    // to --resume latest — which would defeat the whole UUID→index fix.
+                    // 15s = 5s upstream LLM cap + parse/flush/spawn overhead + slack.
+                    // Override via CODEHERE_GEMINI_LIST_TIMEOUT_MS for slow boxes.
+                    const timeoutMs = Number(process.env.CODEHERE_GEMINI_LIST_TIMEOUT_MS) || 15000;
+                    const { stdout: listOut } = await execFileAsync('gemini', ['--list-sessions'], {
+                        cwd,
+                        env: spawnEnv,
+                        encoding: 'utf-8',
+                        timeout: timeoutMs,
+                    });
+                    const idx = parseGeminiSessionIndexForUuid(listOut, geminiSessionUuid);
+                    if (idx !== null)
+                        resumeArg = String(idx);
+                }
+                catch {
+                    // Binary missing, slow auth, no sessions yet — fall through to latest.
+                }
+            }
             return new Promise((resolve, reject) => {
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('gemini', ['-p', text, '--resume', 'latest', ...HEADLESS_FLAGS], {
+                const followup = spawn('gemini', ['-p', text, '--resume', resumeArg, ...HEADLESS_FLAGS], {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],
@@ -387,7 +488,7 @@ export function spawnGemini(prompt, options = {}) {
                 });
                 followup.on('exit', (code) => {
                     if (code !== 0) {
-                        reject(new Error(`gemini --resume latest exited ${code}: ${stderr.slice(0, 300)}`));
+                        reject(new Error(`gemini --resume ${resumeArg} exited ${code}: ${stderr.slice(0, 300)}`));
                         return;
                     }
                     // Parse stream-json — extract assistant message text from 'message'
@@ -417,6 +518,7 @@ export function spawnGemini(prompt, options = {}) {
 export const GeminiAdapter = {
     id: 'gemini',
     label: 'Gemini',
+    description: 'Google\'s coding agent. Has a free tier and can read very large amounts of code or docs at once. Useful when the paid agents are out of credits.',
     // Match `gemini`, `node /path/.../gemini`, and `./gemini` invocations.
     processPattern: /(?:^|\/)gemini(?:\s|$)|node\s+\S*gemini/,
     isInstalled() {

package/dist/infrastructure/orchestration/opencode-adapter.js

@@ -10,16 +10,64 @@
  *
  * Same spawn-pattern pattern as Codex.
  */
-import { spawn, execFileSync } from 'child_process';
+import { spawn, execFile, execFileSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
 import { existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { promisify } from 'util';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { applyMemoryPrefix } from './memory-injector.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
+const execFileAsync = promisify(execFile);
 const HEADLESS_FLAGS = ['run', '--format', 'json'];
+/**
+ * Tag prefix written into opencode's `--title` so we can find a session by
+ * codehere's own UUID later (opencode's `ses_*` ID isn't observable until
+ * the LLM call completes — see appendMessage docblock for the full story).
+ */
+const CODEHERE_TITLE_PREFIX = 'codehere-';
+/**
+ * Parse `opencode session list --format json` output and return the opencode
+ * session ID (`ses_*`) for the row whose title starts with our codehere
+ * tag. Pure function so tests don't need a real opencode binary.
+ *
+ * Schema verified live (2026-05-04):
+ *   [{ "id": "ses_212f...", "title": "...", "updated": <ms>, "created": <ms>,
+ *      "projectId": "...", "directory": "..." }, ...]
+ *
+ * Returns the session whose title is exactly `<prefix><codehereSessionId>`.
+ * Falls back to null if not found, the input is malformed, or the array is
+ * empty. Caller falls back to --continue in that case.
+ */
+export function parseOpenCodeSessionIdByTitle(listJson, codehereSessionId) {
+    if (!codehereSessionId)
+        return null;
+    const wantedTitle = `${CODEHERE_TITLE_PREFIX}${codehereSessionId}`;
+    let parsed;
+    try {
+        parsed = JSON.parse(listJson);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed))
+        return null;
+    for (const row of parsed) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const r = row;
+        if (typeof r.id === 'string' && typeof r.title === 'string' && r.title === wantedTitle) {
+            // Defense in depth: opencode's IDs are always `ses_<base32-ish>`. If
+            // an attacker (or upstream bug) injects a row with a poisoned id like
+            // ` --rm-rf` we don't want to feed it back as a CLI arg.
+            if (/^ses_[A-Za-z0-9]+$/.test(r.id))
+                return r.id;
+        }
+    }
+    return null;
+}
 const ERROR_PATTERNS = [
     {
         code: 'auth_invalid',
@@ -122,7 +170,12 @@ export function spawnOpenCode(prompt, options = {}) {
     let child;
     try {
         // OpenCode's `run` expects the message as positional args, not stdin.
-        child = spawn('opencode', [...HEADLESS_FLAGS, finalPrompt, ...(options.extraArgs ?? [])], {
+        // --title 'codehere-<sessionId>' tags the session with codehere's own
+        // UUID; appendMessage later looks it up by this title (see
+        // parseOpenCodeSessionIdByTitle for the why — opencode buffers the
+        // ses_* id until LLM completion, so we can't capture it mid-stream).
+        const titleTag = `${CODEHERE_TITLE_PREFIX}${sessionId}`;
+        child = spawn('opencode', [...HEADLESS_FLAGS, '--title', titleTag, finalPrompt, ...(options.extraArgs ?? [])], {
             cwd,
             env: spawnEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
@@ -247,28 +300,56 @@ export function spawnOpenCode(prompt, options = {}) {
         },
         canAppendMessage: true,
         /**
-         * v0.6.0 — Slice 2c of REPL persistence. OpenCode's `run --format json`
-         * output is fully buffered until the LLM call completes; the session ID
-         * (ses_*) is not observable mid-stream like claude-code's session_id or
-         * codex's thread_id. The cleanest available alternative is `-c/--continue`
-         * which targets the last session.
+         * v0.6.x — UUID→ses_* resolution (replaces the prior --continue shortcut).
+         * OpenCode's `run --format json` buffers stdout until the LLM call
+         * completes, so the ses_* session ID isn't observable mid-stream like
+         * claude-code's session_id or codex's thread_id.
+         *
+         * Strategy: spawn() above tags the session with `--title codehere-<our
+         * UUID>`. Here, run `opencode session list --format json` (clean array,
+         * no parsing of column-aligned text), find the row whose title matches
+         * our tag, capture its ses_* id, and use `-s <ses_*>`. Falls back to
+         * --continue if anything fails (binary missing, no match, parse error)
+         * — same posture as before for safety, never worse.
          *
-         * Limitation: same as gemini's --resume latest — if the user spawns
-         * another opencode session in this cwd between the original spawn and the
-         * follow-up, the follow-up routes to the wrong session. Acceptable for
-         * the typical reply-within-minutes flow; the rigorous version (capture
-         * session ID via post-spawn `opencode session list` filtered by --title
-         * tag) is queued for v0.6.x.
+         * Concurrency win: spawning a sibling opencode session in the same cwd
+         * between original spawn and reply no longer hijacks the reply target.
          *
-         * Output parsing: `--format json` here uses the same JSONL event shape as
-         * the spawn path; we extract assistant message text from `text` events.
+         * Output parsing: same shape as spawn — text events carry assistant text.
          */
-        appendMessage(text) {
+        async appendMessage(text) {
             const startedAt = Date.now();
+            // Resolve our codehere session UUID → opencode ses_* id asynchronously.
+            // Async (not execFileSync) because this runs in the daemon's HTTP
+            // request path; sync exec would block the event loop for up to the
+            // timeout, freezing every other in-flight session.
+            let resumeArgs = ['--continue'];
+            try {
+                // Override timeout via env for slow boxes; default 15s mirrors the
+                // gemini adapter's choice (and is well above any LLM-tied internal
+                // timer opencode might have).
+                const timeoutMs = Number(process.env.CODEHERE_OPENCODE_LIST_TIMEOUT_MS) || 15000;
+                const { stdout: listOut } = await execFileAsync('opencode', ['session', 'list', '--format', 'json'], {
+                    cwd,
+                    env: spawnEnv,
+                    encoding: 'utf-8',
+                    timeout: timeoutMs,
+                    // opencode's session-list output can grow as the user accumulates
+                    // sessions. Default exec maxBuffer is 1MB; bump to 8MB so a long
+                    // history doesn't ENOBUFS the lookup.
+                    maxBuffer: 8 * 1024 * 1024,
+                });
+                const sesId = parseOpenCodeSessionIdByTitle(listOut, sessionId);
+                if (sesId)
+                    resumeArgs = ['-s', sesId];
+            }
+            catch {
+                // Binary missing, slow auth, or no list — fall through to --continue.
+            }
             return new Promise((resolve, reject) => {
                 let stdout = '';
                 let stderr = '';
-                const followup = spawn('opencode', [...HEADLESS_FLAGS, '--continue', text], {
+                const followup = spawn('opencode', [...HEADLESS_FLAGS, ...resumeArgs, text], {
                     cwd,
                     env: spawnEnv,
                     stdio: ['ignore', 'pipe', 'pipe'],
@@ -282,7 +363,7 @@ export function spawnOpenCode(prompt, options = {}) {
                 });
                 followup.on('exit', (code) => {
                     if (code !== 0) {
-                        reject(new Error(`opencode --continue exited ${code}: ${stderr.slice(0, 300)}`));
+                        reject(new Error(`opencode ${resumeArgs.join(' ')} exited ${code}: ${stderr.slice(0, 300)}`));
                         return;
                     }
                     // Parse JSONL — extract assistant text from `text` events
@@ -312,6 +393,7 @@ export function spawnOpenCode(prompt, options = {}) {
 export const OpenCodeAdapter = {
     id: 'opencode',
     label: 'OpenCode',
+    description: 'Runs several agents at once for genuinely independent jobs. You won\'t see live progress while it works — the trade-off for the speed of doing things in parallel.',
     processPattern: /(?:^|\/)opencode(?:\s|$)/,
     isInstalled() {
         try {

package/dist/infrastructure/orchestration/progress-aggregator.js

@@ -40,21 +40,65 @@ function labelForClaudeToolUse(name, input) {
             return truncate('Run ' + cmd);
         }
         case 'Grep':
-            return 'Grep ' + truncate(String(i.pattern ?? ''), 40);
+            // M2 plain-English pass: "Grep" is a unix command name, jargon
+            // for non-technical users. "Search code for" tells the user what
+            // it actually does.
+            return 'Search code for ' + truncate(String(i.pattern ?? ''), 40);
         case 'Glob':
-            return 'List ' + truncate(String(i.pattern ?? ''), 40);
+            return 'List files matching ' + truncate(String(i.pattern ?? ''), 40);
         case 'WebFetch':
             return 'Fetch ' + truncate(String(i.url ?? ''), 50);
         case 'WebSearch':
-            return 'Search ' + truncate(String(i.query ?? ''), 50);
+            return 'Search the web for ' + truncate(String(i.query ?? ''), 50);
         case 'TodoWrite':
             return 'Plan ' + (Array.isArray(i.todos) ? `${i.todos.length} items` : 'tasks');
         case 'Task':
-            return 'Delegate to subagent';
+            // M2 plain-English pass: "subagent" is internal vocab. "Specialist"
+            // matches the team-roster framing the user already sees in the
+            // dashboard ("codehere · Conductor", "Claude Code specialist", etc.)
+            return 'Hand off to a specialist';
         default:
             return truncate(String(name || 'tool'));
     }
 }
+/**
+ * Extract human-readable text from a Claude tool_result content block.
+ * Handles the two shapes the SDK emits:
+ *   { content: 'plain text' }                                            (most)
+ *   { content: [{type:'text', text:'...'}, {type:'image', ...}, ...] }  (multi-block)
+ */
+function extractClaudeToolResultText(b) {
+    const c = b.content;
+    if (typeof c === 'string')
+        return c;
+    if (Array.isArray(c)) {
+        const parts = [];
+        for (const part of c) {
+            if (part && typeof part === 'object') {
+                const p = part;
+                if (p.type === 'text' && typeof p.text === 'string')
+                    parts.push(p.text);
+            }
+            else if (typeof part === 'string') {
+                parts.push(part);
+            }
+        }
+        return parts.join('\n');
+    }
+    return '';
+}
+/**
+ * Truncate output for step preview. Keeps the LAST ~400 chars (tail is
+ * usually more useful than head for command output — errors land
+ * there). Adds a leading ellipsis when truncation occurs.
+ */
+function truncateOutput(s) {
+    const max = 400;
+    const stripped = s.replace(/\[[0-9;]*m/g, ''); // strip ANSI
+    if (stripped.length <= max)
+        return stripped;
+    return '…' + stripped.slice(-(max - 1));
+}
 function unwrapShellWrapper(command) {
     // Codex wraps its shell calls in `/bin/zsh -lc "…"` or `sh -c "…"`. Strip that
     // so the step label reads as the actual command instead of the wrapper.
@@ -73,8 +117,20 @@ function labelForCodexCommand(command) {
     }
     if (/^(?:ls|find)\b/.test(raw))
         return truncate('List ' + raw.replace(/^(?:ls|find)\s*/, ''));
-    if (/^(?:mkdir|cp|mv|rm|touch)\b/.test(raw) || /\becho\s+.+>/.test(raw))
-        return truncate('File op: ' + raw);
+    // M2 plain-English pass: "File op:" is awkward; describe what's
+    // happening per command kind.
+    if (/^mkdir\b/.test(raw))
+        return truncate('Create folder: ' + raw.replace(/^mkdir\s+(?:-\S+\s+)*/, ''));
+    if (/^cp\b/.test(raw))
+        return truncate('Copy: ' + raw.replace(/^cp\s+(?:-\S+\s+)*/, ''));
+    if (/^mv\b/.test(raw))
+        return truncate('Move/rename: ' + raw.replace(/^mv\s+(?:-\S+\s+)*/, ''));
+    if (/^rm\b/.test(raw))
+        return truncate('Remove: ' + raw.replace(/^rm\s+(?:-\S+\s+)*/, ''));
+    if (/^touch\b/.test(raw))
+        return truncate('Create file: ' + raw.replace(/^touch\s+/, ''));
+    if (/\becho\s+.+>/.test(raw))
+        return truncate('Write to file: ' + raw);
     if (/^git\s+/.test(raw))
         return truncate(raw);
     if (/^npm\s+test\b/.test(raw) || /^pytest\b/.test(raw) || /^vitest\b/.test(raw))
@@ -153,6 +209,15 @@ export class ProgressAggregator {
                         const step = this._steps[idx];
                         step.state = b.is_error ? 'failed' : 'done';
                         step.completedAt = Date.now();
+                        // P22 / Track B #8 — capture tool-result text for the
+                        // dashboard's bash-output preview. Claude SDK shape:
+                        //   content: string  (most cases)
+                        //   content: Array<{type:'text', text:string}>  (multi-block)
+                        // Truncate to last ~400 chars so the SSE payload + render
+                        // cost stay bounded.
+                        const out = extractClaudeToolResultText(b);
+                        if (out)
+                            step.output = truncateOutput(out);
                         changed = true;
                     }
                 }
@@ -192,6 +257,17 @@ export class ProgressAggregator {
                 const isError = data.error !== undefined && data.error !== null;
                 step.state = isError ? 'failed' : 'done';
                 step.completedAt = Date.now();
+                // P22 slice 3 — Gemini tool_result output. Schema is sparse;
+                // accept the common output/result/content fields, with error
+                // text as fallback when isError is true.
+                const out = (typeof data.output === 'string' && data.output) ||
+                    (typeof data.result === 'string' && data.result) ||
+                    (typeof data.content === 'string' && data.content) ||
+                    (isError && data.error && typeof data.error === 'object'
+                        ? `${data.error.type ?? ''} ${data.error.message ?? ''}`
+                        : '');
+                if (out)
+                    step.output = truncateOutput(String(out));
                 return true;
             }
         }
@@ -252,6 +328,34 @@ export class ProgressAggregator {
      * once, not `Write` followed by `Edit`.
      */
     aiderJustCreated = new Set();
+    /**
+     * P22 slice 4 (Aider) — output buffering. Aider's command output
+     * streams as raw stdout lines AFTER a "Running X" announcement and
+     * BEFORE the next aider-pattern (or end of session). This index is
+     * the most-recent "Run" step that's still collecting its tail. When
+     * a new aider-pattern fires we flush the buffer onto step.output and
+     * reset.
+     *
+     * Only "Running" steps collect output — file-edit/write actions
+     * don't have a captured stdout; their target IS the visible state.
+     */
+    aiderRunningStepIdx = null;
+    aiderOutputBuffer = [];
+    aiderFlushOutput() {
+        if (this.aiderRunningStepIdx === null)
+            return;
+        const step = this._steps[this.aiderRunningStepIdx];
+        if (!step) {
+            this.aiderRunningStepIdx = null;
+            this.aiderOutputBuffer = [];
+            return;
+        }
+        if (this.aiderOutputBuffer.length > 0) {
+            step.output = truncateOutput(this.aiderOutputBuffer.join('\n'));
+        }
+        this.aiderRunningStepIdx = null;
+        this.aiderOutputBuffer = [];
+    }
     ingestAider(type, data) {
         if (type !== 'stdout')
             return false;
@@ -270,18 +374,26 @@ export class ProgressAggregator {
         // "Running <command>" — base_coder.py:2472
         let m = line.match(/^Running\s+(.+)$/);
         if (m) {
+            // P22 slice 4 — flush the previous Running step's buffer before
+            // starting the new one. New step is the active output target.
+            this.aiderFlushOutput();
+            const idx = this._steps.length;
             this._steps.push({
                 label: truncate('Run ' + m[1]),
                 state: 'done',
                 startedAt: Date.now(),
                 completedAt: Date.now(),
             });
+            this.aiderRunningStepIdx = idx;
             return true;
         }
         // "Applied edit to <path>" — base_coder.py:2334
         m = line.match(/^Applied edit to\s+(.+)$/);
         if (m) {
             const path = m[1];
+            // P22 slice 4 — flush any in-flight running-step output before
+            // recording the edit (which is a new aider-pattern signal).
+            this.aiderFlushOutput();
             // If aider JUST created this file, the Write step already represents the
             // action; skip the Edit step that aider emits for the initial content.
             // Clear from the set after consuming so subsequent edits to the same
@@ -302,6 +414,7 @@ export class ProgressAggregator {
         m = line.match(/^Creating empty file\s+(.+)$/);
         if (m) {
             const path = m[1];
+            this.aiderFlushOutput();
             this.aiderJustCreated.add(path);
             // Use "Write" to align with Claude/Gemini's net-new-file label vocabulary.
             this._steps.push({
@@ -312,6 +425,20 @@ export class ProgressAggregator {
             });
             return true;
         }
+        // P22 slice 4 — non-pattern stdout line WITHIN a Running window
+        // gets buffered as that step's output. Cap at 50 lines so a long-
+        // running command (e.g., `npm test` printing thousands) doesn't
+        // bloat memory; truncateOutput at flush time keeps the on-step
+        // value bounded too.
+        if (this.aiderRunningStepIdx !== null && this.aiderOutputBuffer.length < 50) {
+            this.aiderOutputBuffer.push(line);
+            // Update the active step's output incrementally so the dashboard
+            // sees the tail before the next aider-pattern flushes.
+            const step = this._steps[this.aiderRunningStepIdx];
+            if (step)
+                step.output = truncateOutput(this.aiderOutputBuffer.join('\n'));
+            return true; // mark as "step changed" so the SSE re-emits codehere:steps
+        }
         return false;
     }
     ingestCodex(type, data) {
@@ -322,21 +449,29 @@ export class ProgressAggregator {
         if (itemType === 'command_execution') {
             const label = labelForCodexCommand(String(item.command ?? ''));
             const ok = item.exit_code === 0 || item.status === 'completed';
+            // P22 slice 2 — capture aggregated_output for the bash preview.
+            // Codex emits the full stdout+stderr in this field on completion.
+            const aggregated = typeof item.aggregated_output === 'string' ? item.aggregated_output : '';
             this._steps.push({
                 label,
                 state: ok ? 'done' : 'failed',
                 startedAt: Date.now(),
                 completedAt: Date.now(),
+                ...(aggregated ? { output: truncateOutput(aggregated) } : {}),
             });
             return true;
         }
         if (itemType === 'tool_call' || itemType === 'local_shell_call') {
             const name = String(item.tool_name ?? item.name ?? 'tool');
+            // Tool-call items may carry a `result` or `output` field too.
+            const result = (typeof item.result === 'string' ? item.result : '') ||
+                (typeof item.output === 'string' ? item.output : '');
             this._steps.push({
                 label: truncate(name),
                 state: 'done',
                 startedAt: Date.now(),
                 completedAt: Date.now(),
+                ...(result ? { output: truncateOutput(result) } : {}),
             });
             return true;
         }