codehere 0.5.0-alpha.6 → 0.6.0

package/dist/infrastructure/orchestration/graphify-context.js

@@ -0,0 +1,256 @@
+/**
+ * graphify-context — shared structural memory layer (P1).
+ *
+ * Wraps `graphify-ts` CLI to compile compact context packs for agent prompts.
+ * Every spawn can optionally get a graphify context pack that replaces
+ * raw file reads + unstructured JSONL scans.
+ *
+ * All functions are synchronous (execFileSync) to slot into the sync
+ * spawn() call chain without breaking the API.
+ *
+ * P1 integration points:
+ *   - Session spawn: inject context pack into prompt prefix
+ *   - Failover handoff (P2): replacement agent inherits the same pack
+ *   - S7 compaction (future): use graph to prune stale session logs
+ *   - PM-brain routing (future): community_overview for agent selection
+ */
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+// ── Constants ──────────────────────────────────────────────────────────────────
+const GRAPHIFY_OUT = 'graphify-out';
+const GRAPH_JSON = 'graph.json';
+const CONTEXT_PACKS_DIR = '.codehere';
+const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function getGraphPath(cwd) {
+    return join(cwd, GRAPHIFY_OUT, GRAPH_JSON);
+}
+function getGraphStats(cwd) {
+    const graphPath = getGraphPath(cwd);
+    try {
+        if (!existsSync(graphPath)) {
+            return { nodeCount: 0, edgeCount: 0 };
+        }
+        const graphJson = JSON.parse(readFileSync(graphPath, 'utf-8'));
+        return {
+            nodeCount: graphJson.nodes?.length ?? 0,
+            edgeCount: graphJson.edges?.length ?? 0,
+        };
+    }
+    catch {
+        return { nodeCount: 0, edgeCount: 0 };
+    }
+}
+// ── Graph management (sync) ────────────────────────────────────────────────────
+/**
+ * Build or update the knowledge graph for a workspace directory.
+ * Writes to <cwd>/graphify-out/graph.json (graphify-ts default).
+ * Synchronous — runs synchronously so it can be called from spawn().
+ */
+export function buildGraphSync(cwd, { incremental = true } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    const args = ['generate', cwd];
+    if (incremental && existsSync(graphPath)) {
+        args.push('--update');
+    }
+    try {
+        execFileSync('npx', ['graphify-ts', ...args], {
+            cwd,
+            stdio: 'ignore',
+            timeout: 120_000,
+        });
+    }
+    catch {
+        // Non-zero exit is fine — graphify-ts returns 1 when no files changed.
+        // Also swallow ENOENT (graphify-ts not installed) — degrade gracefully.
+    }
+    return { elapsedMs: Date.now() - startTime };
+}
+// ── Context pack compilation (sync) ────────────────────────────────────────────
+/**
+ * Compile a compact context pack for a prompt + workspace.
+ * Synchronous — calls graphify-ts pack and returns the payload.
+ */
+export function compileContextPackSync(prompt, cwd, { task = 'explain', budget = 3000, } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    // Build graph if it doesn't exist yet
+    if (!existsSync(graphPath)) {
+        buildGraphSync(cwd, { incremental: false });
+    }
+    // Degrade gracefully if graph still doesn't exist
+    if (!existsSync(graphPath)) {
+        return null;
+    }
+    try {
+        const output = execFileSync('npx', [
+            'graphify-ts', 'pack', prompt,
+            '--graph', graphPath,
+            '--task', task,
+            '--budget', String(budget),
+        ], {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 512 * 1024,
+            timeout: 30_000,
+        });
+        const { nodeCount, edgeCount } = getGraphStats(cwd);
+        return {
+            graphPath,
+            payload: output.trim(),
+            budget,
+            task,
+            nodeCount,
+            edgeCount,
+            elapsedMs: Date.now() - startTime,
+            packId: randomUUID(),
+        };
+    }
+    catch {
+        // graphify-ts may return non-zero or hit timeout — degrade gracefully.
+        return null;
+    }
+}
+/**
+ * Compile a context pack from a session's final state (prompt + artifacts + steps).
+ * Used for P1 session-exit persistence and P2 handoff enrichment.
+ */
+export function compileSessionPackSync(cwd, { prompt, artifacts, steps, agent }) {
+    // Combine prompt + artifacts + steps into a rich prompt for the pack
+    const sessionContext = [
+        prompt,
+        agent ? `Agent: ${agent}` : undefined,
+        artifacts ? `Artifacts:\n${artifacts}` : undefined,
+        steps ? `Steps taken:\n${steps}` : undefined,
+    ].filter(Boolean).join('\n\n');
+    return compileContextPackSync(sessionContext, cwd, { task: 'impact', budget: 2500 });
+}
+// ── Context pack persistence ───────────────────────────────────────────────────
+/**
+ * Persist a context pack to disk for cross-session handoff (P2).
+ * Returns the path to the packs file.
+ */
+export function persistContextPack(pack, cwd) {
+    const packsDir = join(cwd, CONTEXT_PACKS_DIR);
+    if (!existsSync(packsDir)) {
+        mkdirSync(packsDir, { recursive: true });
+    }
+    const packsFile = join(packsDir, CONTEXT_PACKS_FILE);
+    const entry = {
+        packId: pack.packId,
+        timestamp: Date.now(),
+        task: pack.task,
+        nodeCount: pack.nodeCount,
+        edgeCount: pack.edgeCount,
+        graphPath: pack.graphPath,
+        payloadPreview: pack.payload.slice(0, 500), // truncate for log
+        payloadLength: pack.payload.length,
+    };
+    writeFileSync(packsFile, JSON.stringify(entry) + '\n', { flag: 'a' });
+    return packsFile;
+}
+/**
+ * Load the most recent context pack from disk (for P2 handoff).
+ */
+export function loadRecentContextPack(cwd) {
+    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
+    if (!existsSync(packsFile)) {
+        return null;
+    }
+    try {
+        const lines = readFileSync(packsFile, 'utf-8').split('\n').filter(Boolean);
+        if (lines.length === 0)
+            return null;
+        const lastEntry = JSON.parse(lines[lines.length - 1]);
+        return {
+            packId: lastEntry.packId,
+            graphPath: lastEntry.graphPath,
+            payload: '', // payload is truncated in disk storage
+            budget: 3000,
+            task: lastEntry.task,
+            nodeCount: lastEntry.nodeCount,
+            edgeCount: lastEntry.edgeCount,
+            elapsedMs: 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Prompt enrichment (sync) ───────────────────────────────────────────────────
+/**
+ * Prepend a context pack to a prompt if graphify-ts is available.
+ *
+ * Synchronous — can be called directly from spawn().
+ * Returns the original prompt if graphify-ts fails or is unavailable.
+ *
+ * Respects CODEHERE_GRAPHIFY env var:
+ *   - unset or "auto" (default): compile on spawn if graph doesn't exist
+ *   - "force": always compile, even if pack exists
+ *   - "off": skip entirely
+ */
+export function enrichPromptWithPackSync(prompt, cwd, { force = false } = {}) {
+    const mode = process.env.CODEHERE_GRAPHIFY ?? 'auto';
+    if (mode === 'off')
+        return prompt;
+    // Check for existing pack to avoid recompiling on every spawn
+    const existingPack = loadRecentContextPack(cwd);
+    const graphPath = getGraphPath(cwd);
+    const graphExists = existsSync(graphPath);
+    if (!force && existingPack && graphExists) {
+        // Reuse existing pack — just enrich the prompt with a compact reference
+        const reference = `[graphify-ts context pack: ${existingPack.nodeCount} nodes, ${existingPack.edgeCount} edges, pack=${existingPack.packId}]`;
+        return `[graphify context: ${reference} — agent should call retrieve() for full pack]\n\n${prompt}`;
+    }
+    // Compile a fresh pack
+    const pack = compileContextPackSync(prompt, cwd, { task: 'explain', budget: 2500 });
+    if (!pack) {
+        return prompt;
+    }
+    // Persist for P2 handoff
+    persistContextPack(pack, cwd);
+    // Prepend context pack as a system hint so the agent sees it first
+    return [
+        `[graphify-ts context pack — ${pack.nodeCount} nodes, ${pack.edgeCount} edges, ${pack.elapsedMs}ms]`,
+        pack.payload,
+        '---',
+        prompt,
+    ].join('\n\n');
+}
+// ── Graph querying (sync) ──────────────────────────────────────────────────────
+/**
+ * Query the knowledge graph for a question.
+ * Useful for PM-brain routing and structured context handoff (P2).
+ */
+export function queryGraphSync(question, cwd, { maxTokens = 2000 } = {}) {
+    const startTime = Date.now();
+    const graphPath = getGraphPath(cwd);
+    if (!existsSync(graphPath)) {
+        return null;
+    }
+    try {
+        const output = execFileSync('npx', [
+            'graphify-ts', 'query', question,
+            '--graph', graphPath,
+            '--budget', String(maxTokens),
+        ], {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 256 * 1024,
+            timeout: 15_000,
+        });
+        return {
+            question,
+            answer: output.trim(),
+            elapsedMs: Date.now() - startTime,
+            graphPath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=graphify-context.js.map

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;
         }