codehere 1.0.1 → 1.0.3

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

@@ -1,906 +0,0 @@
-/**
- * ProgressAggregator — PM UX Layer 2 (principles #1 "web is not a terminal", #2 "info density").
- *
- * Ingests the raw TaskEvent stream and produces semantic ProgressStep[] that a
- * product manager would actually read ("Read src/session.ts", "Run npm test",
- * "Writing reply…") rather than the underlying token-level chatter.
- *
- * Agent-aware by design: Claude's stream-json tool_use blocks and Codex's
- * item.completed entries label differently, so we dispatch on the agent id.
- * Keeps the per-adapter files free of PM-layer concerns.
- */
-const MAX_LABEL = 60;
-function shortPath(p) {
-    const parts = String(p).split('/');
-    return parts.length <= 2 ? p : '…/' + parts.slice(-2).join('/');
-}
-function truncate(s, max = MAX_LABEL) {
-    return s.length > max ? s.slice(0, max - 1) + '…' : s;
-}
-/** A successful tool_result sometimes extracts to no text (structured payloads),
- *  leaving the step row bare. For tools whose SUCCESS carries a computable claim
- *  (Edit succeeded = the replacement applied), derive the outcome from the input
- *  we captured at tool_use time. Only states what the success guarantees. */
-function synthesizeOutcome(tool, input) {
-    if (!tool || !input)
-        return '';
-    if (tool === 'Edit' || tool === 'MultiEdit') {
-        // MultiEdit carries {edits:[{old_string,new_string,replace_all?}]}; Edit is flat.
-        const edits = Array.isArray(input.edits) ? input.edits : [input];
-        let d = 0;
-        for (const e of edits) {
-            // replace_all applies per-occurrence — a computed delta would understate
-            // the real change, so claim only what success guarantees.
-            if (e.replace_all)
-                return 'change applied';
-            const o = String(e.old_string ?? '');
-            const n = String(e.new_string ?? '');
-            if (!o && !n)
-                continue;
-            d += n.split('\n').length - o.split('\n').length;
-        }
-        return d === 0 ? 'change applied' : `${d > 0 ? '+' + d : d} lines · change applied`;
-    }
-    if (tool === 'Write') {
-        const c = String(input.content ?? '');
-        return c ? `${c.split('\n').length} lines written` : 'file written';
-    }
-    return '';
-}
-function labelForClaudeToolUse(name, input) {
-    const i = (input && typeof input === 'object' ? input : {});
-    switch (name) {
-        case 'Read':
-            return 'Read ' + shortPath(String(i.file_path ?? 'file'));
-        case 'Write':
-            return 'Write ' + shortPath(String(i.file_path ?? 'file'));
-        case 'Edit':
-            return 'Edit ' + shortPath(String(i.file_path ?? 'file'));
-        case 'MultiEdit': {
-            const edits = Array.isArray(i.edits) ? i.edits : [];
-            const first = edits[0];
-            return `Edit ${shortPath(String(first?.file_path ?? 'file'))} (${edits.length})`;
-        }
-        case 'NotebookEdit':
-            return 'Edit notebook ' + shortPath(String(i.notebook_path ?? 'notebook'));
-        case 'Bash': {
-            const cmd = String(i.command ?? '')
-                .replace(/\n/g, ' ')
-                .trim();
-            return truncate('Run ' + cmd);
-        }
-        case 'Grep':
-            // 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 files matching ' + truncate(String(i.pattern ?? ''), 40);
-        case 'WebFetch':
-            return 'Fetch ' + truncate(String(i.url ?? ''), 50);
-        case 'WebSearch':
-            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':
-            // 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));
-}
-/** Parse a Claude AskUserQuestion tool_use input into the step.question shape.
- *  Defensive — SDK shape is { questions: [{ question, header?, multiSelect?,
- *  options: [{ label, description? }] }] }; missing pieces degrade gracefully. */
-function parseAskUserQuestion(toolUseId, input) {
-    const raw = Array.isArray(input?.questions) ? input.questions : [];
-    const questions = raw.map((qq) => {
-        const q = (qq && typeof qq === 'object' ? qq : {});
-        const opts = Array.isArray(q.options) ? q.options : [];
-        return {
-            question: String(q.question ?? ''),
-            ...(q.header ? { header: String(q.header) } : {}),
-            ...(q.multiSelect ? { multiSelect: true } : {}),
-            options: opts.map((oo) => {
-                const o = (oo && typeof oo === 'object' ? oo : {});
-                return { label: String(o.label ?? ''), ...(o.description ? { description: String(o.description) } : {}) };
-            }),
-        };
-    });
-    return { toolUseId, questions };
-}
-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.
-    const m = command.match(/^(?:\/bin\/(?:zsh|bash|sh)|sh|bash|zsh)\s+-l?c\s+["'](.+)["']\s*$/);
-    return m ? m[1].trim() : command.trim();
-}
-function labelForCodexCommand(command) {
-    const raw = unwrapShellWrapper(String(command).replace(/\n/g, ' ').trim());
-    // Heuristic friendly prefix for common operations
-    if (/^cat\s+/.test(raw))
-        return truncate('Read ' + raw.replace(/^cat\s+/, '').split(/\s+/)[0]);
-    if (/^sed\s+-n\s+/.test(raw)) {
-        // e.g. `sed -n '1,260p' README.md` → "Read README.md"
-        const tail = raw.split(/\s+/).slice(-1)[0];
-        return truncate('Read ' + tail);
-    }
-    if (/^(?:ls|find)\b/.test(raw))
-        return truncate('List ' + raw.replace(/^(?:ls|find)\s*/, ''));
-    // 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))
-        return truncate('Run tests');
-    return truncate('Run ' + raw);
-}
-export class ProgressAggregator {
-    agentId;
-    _steps = [];
-    toolUseIndex = new Map(); // tool_use_id → step idx (Claude)
-    constructor(agentId) {
-        this.agentId = agentId;
-    }
-    get steps() {
-        return this._steps;
-    }
-    /** @returns true if the step list changed (caller emits synthetic event). */
-    ingest(event) {
-        const type = String(event.type || '');
-        const data = (event.data ?? {});
-        if (this.agentId === 'claude-code')
-            return this.ingestClaude(type, data);
-        if (this.agentId === 'codex')
-            return this.ingestCodex(type, data);
-        if (this.agentId === 'gemini')
-            return this.ingestGemini(type, data);
-        if (this.agentId === 'aider')
-            return this.ingestAider(type, data);
-        if (this.agentId === 'opencode')
-            return this.ingestOpencode(type, data);
-        // Generic-config agents (cursor, etc.): the generic-cli-adapter normalizes
-        // their stream-json to flat tool_use + stdout events. Build steps from those
-        // so "watch it work" isn't empty (real dogfood 2026-06-23: cursor runs edited
-        // files + verified green but rendered 0 steps).
-        return this.ingestGeneric(type, data);
-    }
-    ingestGeneric(type, data) {
-        if (type === 'tool_use') {
-            const name = String(data.name ?? data.tool_name ?? 'tool');
-            const input = (data.input ?? data.parameters ?? {});
-            const arg = (typeof input.path === 'string' && input.path) ||
-                (typeof input.file_path === 'string' && input.file_path) ||
-                (typeof input.command === 'string' && input.command) ||
-                (typeof input.query === 'string' && input.query) ||
-                '';
-            const short = arg ? arg.split('/').pop() || arg : '';
-            const verb = name ? name.charAt(0).toUpperCase() + name.slice(1) : 'Tool';
-            this._steps.push({
-                label: truncate(short ? `${verb} ${short}` : verb),
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            return true;
-        }
-        if (type === 'stdout') {
-            const line = String(data.line ?? '').trim();
-            if (!line)
-                return false;
-            this._steps.push({
-                kind: 'say',
-                label: truncate(line),
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            return true;
-        }
-        return false;
-    }
-    // OpenCode · `run --format json` emits tool_use with shape
-    // { type:'tool_use', part:{ tool, state:{ input, output, status } } }. Was
-    // never wired into the aggregator (opencode showed ZERO timeline steps — a
-    // real gap surfaced by the mock harness). Build a step on the terminal
-    // (status==='completed') event so opencode is a first-class agent.
-    ingestOpencode(type, data) {
-        // OpenCode's narrative text rides `text` events with part.text (the same
-        // shape the adapter's summary extraction reads) — cross-vendor say capture
-        // per the v1 spec, so opencode's Final Report stops degrading to the
-        // deterministic fallback.
-        if (type === 'text') {
-            const part = (data.part ?? {});
-            return this.pushSay(String(part.text ?? ''));
-        }
-        if (type !== 'tool_use')
-            return false;
-        const part = (data.part ?? {});
-        if (part.state?.status && part.state.status !== 'completed')
-            return false; // skip in-flight
-        const map = {
-            bash: 'Bash',
-            read: 'Read',
-            write: 'Write',
-            edit: 'Edit',
-            grep: 'Grep',
-            glob: 'Glob',
-            webfetch: 'WebFetch',
-            websearch: 'WebSearch',
-        };
-        const tool = map[String(part.tool ?? '').toLowerCase()] || 'Bash';
-        const label = labelForClaudeToolUse(tool, part.state?.input);
-        const output = typeof part.state?.output === 'string' ? part.state.output : '';
-        this._steps.push({
-            label,
-            state: 'done',
-            startedAt: Date.now(),
-            completedAt: Date.now(),
-            ...(output ? { output: truncateOutput(output) } : {}),
-        });
-        return true;
-    }
-    /** Flush: mark every still-active step as failed (called on abnormal exit). */
-    finalize(status) {
-        // Surface any trailing reasoning that had no following action.
-        let changed = this.flushAiderSay();
-        if (this.flushGeminiSay())
-            changed = true;
-        for (const s of this._steps) {
-            if (s.state === 'active' || s.state === 'pending') {
-                s.state = status === 'completed' ? 'done' : 'failed';
-                s.completedAt = Date.now();
-                changed = true;
-            }
-        }
-        return changed;
-    }
-    addStep(label, state = 'active') {
-        const idx = this._steps.push({ label, state, startedAt: Date.now() }) - 1;
-        return idx;
-    }
-    /**
-     * Git-diff fallback (Phase 1 — aider parity). Aider has no structured event
-     * stream; its file-edit steps are parsed from stdout lines ("Applied edit to
-     * X" / "Creating empty file X") matched against aider's `base_coder.py`
-     * wording. A version bump that re-words those lines would silently yield ZERO
-     * file-action steps — a run that really changed files would then render an
-     * empty timeline and a "no files changed" report (the exact "did nothing"
-     * lie user-#1 hit on a real aider run).
-     *
-     * This is the format-independent safety net. Given the git-diff file list the
-     * artifacts-extractor already computed (which the adapter passes on exit), if
-     * NO file-action step exists, synthesize one per changed file from the diff —
-     * git is more authoritative than stdout parsing, not less, so these aren't
-     * guesses. No-op when the stdout parse already produced file-action steps (so
-     * we never double-count). Returns true iff a synthetic step was added.
-     */
-    applyFileFallback(files) {
-        if (!files || files.length === 0)
-            return false;
-        const hasFileAction = this._steps.some((s) => /^(Edit|Write|Delete) /.test(s.label));
-        if (hasFileAction)
-            return false;
-        let added = false;
-        for (const f of files) {
-            const path = String(f?.path ?? '').trim();
-            if (!path)
-                continue;
-            this._steps.push({
-                label: 'Edit ' + shortPath(path),
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            added = true;
-        }
-        return added;
-    }
-    /** The agent's own narration as a kind:'say' step — the "watch it work"
-     *  signal AND what the Final Report engine reuses as the summary. Cross-
-     *  vendor by decision of the v1 spec (the room thread is "tool steps woven
-     *  with the agent's plain-English narration" — for every agent, not just
-     *  claude/aider). Same 500-char cap as the original claude capture. */
-    pushSay(text) {
-        const said = String(text ?? '').trim();
-        if (!said)
-            return false;
-        this._steps.push({
-            kind: 'say',
-            label: said.length > 20000 ? said.slice(0, 20000) + '…' : said,
-            state: 'done',
-            startedAt: Date.now(),
-            completedAt: Date.now(),
-        });
-        return true;
-    }
-    ingestClaude(type, data) {
-        if (type === 'assistant') {
-            const msg = (data.message ?? {});
-            const content = Array.isArray(msg.content) ? msg.content : [];
-            let changed = false;
-            for (const blk of content) {
-                const b = (blk && typeof blk === 'object' ? blk : {});
-                if (b.type === 'text' && typeof b.text === 'string' && b.text.trim()) {
-                    // The agent's own words/reasoning. In claude's stream the text block
-                    // precedes the tool_use in the same message — capture it first so the
-                    // timeline reads "explains → acts". This is the "watch it work" signal
-                    // the agent already produces; we were dropping it.
-                    const said = b.text.trim();
-                    this._steps.push({
-                        kind: 'say',
-                        label: said.length > 20000 ? said.slice(0, 20000) + '…' : said,
-                        state: 'done',
-                        startedAt: Date.now(),
-                        completedAt: Date.now(),
-                    });
-                    changed = true;
-                }
-                else if (b.type === 'thinking') {
-                    // Claude's interleaved reasoning block — was 100% dropped. Surface it
-                    // as a muted 'think' step so the user can watch the agent reason.
-                    const think = typeof b.thinking === 'string' ? b.thinking.trim() : '';
-                    if (think) {
-                        this._steps.push({
-                            kind: 'think',
-                            label: think.length > 20000 ? think.slice(0, 20000) + '…' : think,
-                            state: 'done',
-                            startedAt: Date.now(),
-                            completedAt: Date.now(),
-                        });
-                        changed = true;
-                    }
-                }
-                else if (b.type === 'tool_use') {
-                    const id = String(b.id ?? '');
-                    const name = String(b.name ?? '');
-                    const input = b.input && typeof b.input === 'object' ? b.input : undefined;
-                    if (name === 'AskUserQuestion') {
-                        // The agent is asking the user. Capture the questions+options (was
-                        // discarded) and mark it 'ask' so the UI renders a question card —
-                        // not a generic failed tool step.
-                        const q = parseAskUserQuestion(id, input);
-                        const n = q.questions.length;
-                        const idx = this.addStep(`Asking you ${n} question${n === 1 ? '' : 's'}`, 'active');
-                        const step = this._steps[idx];
-                        step.kind = 'ask';
-                        step.toolName = name;
-                        step.question = q;
-                        if (id)
-                            this.toolUseIndex.set(id, idx);
-                    }
-                    else {
-                        const label = labelForClaudeToolUse(name, input);
-                        const idx = this.addStep(label, 'active');
-                        const step = this._steps[idx];
-                        step.toolName = name;
-                        if (input)
-                            step.toolInput = input;
-                        if (id)
-                            this.toolUseIndex.set(id, idx);
-                    }
-                    changed = true;
-                }
-            }
-            return changed;
-        }
-        if (type === 'user') {
-            // Match tool_result blocks back to their tool_use step.
-            const msg = (data.message ?? {});
-            const content = Array.isArray(msg.content) ? msg.content : [];
-            let changed = false;
-            for (const blk of content) {
-                const b = (blk && typeof blk === 'object' ? blk : {});
-                if (b.type === 'tool_result') {
-                    const id = String(b.tool_use_id ?? '');
-                    const idx = id ? this.toolUseIndex.get(id) : undefined;
-                    if (idx !== undefined) {
-                        const step = this._steps[idx];
-                        // An un-answered AskUserQuestion returns is_error headless, but it's
-                        // a PENDING question, not a failure — don't flip it to 'failed'.
-                        if (step.kind !== 'ask')
-                            step.state = b.is_error ? 'failed' : 'done';
-                        step.completedAt = Date.now();
-                        // Capture BOTH: fullOutput (untruncated, ANSI preserved — for the
-                        // expandable view) and output (bounded, ANSI-stripped preview so the
-                        // per-step SSE snapshot stays small). On failure, keep the error body.
-                        const out = extractClaudeToolResultText(b);
-                        if (out) {
-                            step.fullOutput = out;
-                            step.output = truncateOutput(out);
-                            if (b.is_error)
-                                step.errorText = out;
-                        }
-                        else if (!b.is_error && step.kind !== 'ask') {
-                            // Structured results extract to '' and the row would read as a bare
-                            // "Edit x · 0.5s". For tools whose success has a computable meaning,
-                            // synthesize a truthful outcome from the input we already hold.
-                            const synth = synthesizeOutcome(step.toolName, step.toolInput);
-                            if (synth)
-                                step.output = synth;
-                        }
-                        changed = true;
-                    }
-                }
-            }
-            return changed;
-        }
-        return false;
-    }
-    /**
-     * Gemini's stream-json schema (verified against @google/gemini-cli source):
-     *   tool_use:    { tool_name, tool_id, parameters }       — adds an active step
-     *   tool_result: { tool_id, ...output }                   — closes by tool_id
-     *
-     * We reuse the Claude-shaped tool labelling as a best-effort default — Gemini's
-     * tool surface (Read, Edit, Write, Shell, Grep, Glob, etc.) overlaps heavily
-     * with the Claude SDK tool naming since both emerged from the same agent
-     * lineage. If a specific Gemini tool name doesn't match, the default branch in
-     * `labelForClaudeToolUse` falls back to the raw tool name.
-     */
-    ingestGemini(type, data) {
-        if (type === 'tool_use') {
-            // Narration precedes the action in gemini's stream — flush any buffered
-            // assistant text first so the timeline reads "explains → acts".
-            this.flushGeminiSay();
-            const id = String(data.tool_id ?? '');
-            const name = String(data.tool_name ?? 'tool');
-            const label = labelForClaudeToolUse(name, data.parameters);
-            const idx = this.addStep(label, 'active');
-            if (id)
-                this.toolUseIndex.set(id, idx);
-            return true;
-        }
-        if (type === 'tool_result') {
-            const id = String(data.tool_id ?? '');
-            const idx = id ? this.toolUseIndex.get(id) : undefined;
-            if (idx !== undefined) {
-                const step = this._steps[idx];
-                // Gemini's tool_result may carry an `error` field on failure; treat any
-                // non-undefined `error` as failed. Otherwise mark done.
-                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;
-            }
-        }
-        // Gemini's narrative text — THE REAL STREAM SHAPE (verified against
-        // @google/gemini-cli StreamJsonFormatter, mirrored in gemini-adapter.ts):
-        // `message` events `{ role:'assistant', content, delta?: bool }`, where
-        // content arrives as delta CHUNKS. The old `content`-type branch below
-        // never matched a real run — so real gemini sessions produced ZERO say
-        // steps and every Final Report degraded to the deterministic "didn't
-        // leave a written summary" fallback (R10 dogfood gap c). Buffer deltas;
-        // flush as ONE say step at a message boundary (non-delta), before the
-        // next action (tool_use above), or at stream end (result/error/finalize).
-        if (type === 'message') {
-            if (data.role === 'assistant' && typeof data.content === 'string' && data.content) {
-                this.geminiSayBuffer.push(data.content);
-                if (data.delta !== true)
-                    return this.flushGeminiSay();
-                return false; // chunk buffered; the flush is the visible step
-            }
-            return false;
-        }
-        if (type === 'result' || type === 'error') {
-            return this.flushGeminiSay();
-        }
-        // Legacy shape kept for old cassettes: `content` events with a text field.
-        if (type === 'content' && typeof data.text === 'string') {
-            return this.pushSay(data.text);
-        }
-        return false;
-    }
-    /** Buffered gemini assistant delta chunks awaiting a boundary flush. */
-    geminiSayBuffer = [];
-    /** Flush buffered gemini narration as one kind:'say' step. */
-    flushGeminiSay() {
-        if (this.geminiSayBuffer.length === 0)
-            return false;
-        const text = this.geminiSayBuffer.join('');
-        this.geminiSayBuffer = [];
-        return this.pushSay(text);
-    }
-    /**
-     * Aider observability parity (v0.5 Path B per docs/design/f3_memory_spec.md
-     * + ~/.claude/.../memory/learning_aider.md).
-     *
-     * Aider doesn't expose a structured event stream — we parse stdout lines
-     * matching the EXACT patterns aider's `base_coder.py` writes when it
-     * applies an edit, creates a new file, or runs a shell command (verified
-     * against installed aider 0.86.2 source — line refs below).
-     *
-     * Patterns we match:
-     *   "Running <command>"               — base_coder.py:2472 — fires AFTER
-     *     aider's confirm_ask returns yes (which `--yes-always` answers
-     *     automatically). Aider has already started executing by the time we see
-     *     this — OBSERVABILITY, not blocking.
-     *   "Applied edit to <path>"          — base_coder.py:2334 — fires after
-     *     a SEARCH/REPLACE block lands. Used for both edits AND net-new files
-     *     created via the same flow (aider doesn't distinguish in this message).
-     *   "Creating empty file <path>"      — base_coder.py:461 — fires when
-     *     aider creates a brand-new empty file as scaffolding before edits.
-     *
-     * Patterns we DELIBERATELY do NOT match:
-     *   "Did not apply edit to ..."       — explicit non-event; we drop these
-     *     (would be a false-positive Edit step otherwise).
-     *   "Create new file?"                — that's a CONFIRM_ASK prompt, not a
-     *     tool_output. With `--yes-always` it never fires interactively, and
-     *     it's not the action-taken signal anyway.
-     *
-     * Each matched pattern → one ProgressStep marked done immediately (aider
-     * doesn't emit separate completion events; the line itself IS the completion).
-     *
-     * Label vocabulary is aligned with Claude / Gemini / Codex labels for
-     * cross-agent UI consistency: `Run X` for shell, `Edit <path>` for file
-     * edits, `Write <path>` for net-new file creation.
-     *
-     * ANSI handling: HEADLESS_FLAGS in aider-adapter.ts include `--no-pretty`
-     * which strips colors. As defense-in-depth (in case extraArgs override that
-     * or aider regresses), we strip ANSI escape sequences before matching.
-     *
-     * Limitation: codehere CANNOT block aider's actions via this path. The
-     * upstream-PR Path A (adding `--pre-action-hook` to aider) is what enables
-     * blocking parity. v0.5 ships observability; v0.5.x or v0.6 ships blocking
-     * once Path A merges.
-     */
-    static ANSI_RE = /\x1b\[[0-9;]*m/g;
-    /**
-     * Per-instance set of file paths aider just created via "Creating empty file ...".
-     * Aider emits BOTH `Creating empty file <p>` AND `Applied edit to <p>` for one
-     * logical net-new-file creation (file gets touched, then initial content
-     * gets applied). Without this set we'd record two steps (`Write <p>` then
-     * `Edit <p>`) for one action — codex Round 2 caught this. We suppress the
-     * subsequent `Applied edit to` for the same path so the user sees `Write`
-     * 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 = [];
-    /**
-     * A1 (PRODUCT_STATE §0 NEXT #1) — Aider's natural-language reasoning.
-     * Aider streams its plain-English explanation to stdout BEFORE the
-     * SEARCH/REPLACE blocks and "Applied edit" lines. We were dropping every
-     * such line. Mirror ingestClaude's text-block handling: collect consecutive
-     * prose lines (skipping diff fences + SEARCH/REPLACE markers + aider's own
-     * status noise) and flush them as ONE kind:'say' step before the next
-     * action — the "watch it work" signal across aider, not just claude.
-     */
-    aiderSayBuffer = [];
-    aiderInFence = false;
-    aiderInDiff = false;
-    /** Aider stdout lines that are status/noise, never reasoning prose. The
-     *  "must contain a space + length >= 4" guard in collectAiderSay already
-     *  drops bare filenames, fence langs and spinner rules; this catches the
-     *  noisy lines that DO contain spaces. */
-    static AIDER_NONPROSE_RE = /^(=======\s*$|Tokens:|Cost:|Commit [0-9a-f]|Applied edit to |Running |Creating empty file |Did not |Added \S+ to the chat|Removed \S+ from the chat|No changes made|Warning: |Scanning repo|Initial repo scan|Repo-map:|Repo-map can|Main model:|Weak model:|Model:|Git repo:|Cur working dir|Git working dir|Use \/|aider |Aider v|Committing )/;
-    /** Aider CLI startup/warning boilerplate that arrives as prose-shaped lines
-     *  (often prefixed "Note: ..."), so it slips past the line-start regex above.
-     *  Matched ANYWHERE in the line by its distinctive phrases — this is the noise
-     *  that leaked into "the agent's words" and made the room read like stderr. */
-    static AIDER_BOILERPLATE_RE = /in-chat filenames|working dir|repo-map can'?t|deleted from the file system|but not from git\?/i;
-    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 = [];
-    }
-    /** Flush buffered aider prose as one kind:'say' step. Returns true if a step
-     *  was pushed (so finalize can fold it into its changed flag). */
-    flushAiderSay() {
-        if (this.aiderSayBuffer.length === 0)
-            return false;
-        const said = this.aiderSayBuffer.join(' ').replace(/\s+/g, ' ').trim();
-        this.aiderSayBuffer = [];
-        if (!said)
-            return false;
-        this._steps.push({
-            kind: 'say',
-            label: said.length > 20000 ? said.slice(0, 20000) + '…' : said,
-            state: 'done',
-            startedAt: Date.now(),
-            completedAt: Date.now(),
-        });
-        return true;
-    }
-    /** Collect one aider stdout line as reasoning prose unless it's a fence, a
-     *  SEARCH/REPLACE marker/body, status noise, or a bare token. */
-    collectAiderSay(line) {
-        if (line.startsWith('```')) {
-            this.aiderInFence = !this.aiderInFence;
-            return;
-        }
-        if (this.aiderInFence)
-            return;
-        if (/^<<<<<<< SEARCH/.test(line)) {
-            this.aiderInDiff = true;
-            return;
-        }
-        if (/^>>>>>>> REPLACE/.test(line)) {
-            this.aiderInDiff = false;
-            return;
-        }
-        if (this.aiderInDiff)
-            return;
-        if (ProgressAggregator.AIDER_NONPROSE_RE.test(line))
-            return;
-        if (ProgressAggregator.AIDER_BOILERPLATE_RE.test(line))
-            return; // CLI startup noise, anywhere in the line
-        // Require a space + minimum length so filenames/code tokens don't leak in.
-        if (line.length < 4 || !line.includes(' '))
-            return;
-        this.aiderSayBuffer.push(line);
-    }
-    ingestAider(type, data) {
-        if (type !== 'stdout')
-            return false;
-        const raw = typeof data.line === 'string' ? data.line : '';
-        // Strip ANSI escape codes BEFORE matching so the parser survives a
-        // `--no-pretty` regression or override.
-        const line = raw.replace(ProgressAggregator.ANSI_RE, '').trim();
-        if (!line)
-            return false;
-        // EXPLICIT NON-EVENT: defense-in-depth guard. The `^Applied edit to` regex
-        // below wouldn't match "Did not apply edit to ..." because of the anchor,
-        // but if either pattern ever loosens, this short-circuit prevents a false
-        // Edit step from creeping in.
-        if (/^Did not apply edit to\s+/.test(line))
-            return false;
-        // "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();
-            this.flushAiderSay(); // emit any reasoning prose that preceded this run
-            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();
-            this.flushAiderSay(); // emit reasoning prose that preceded this edit
-            // 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
-            // path (in this same session) DO show as Edit.
-            if (this.aiderJustCreated.has(path)) {
-                this.aiderJustCreated.delete(path);
-                return false;
-            }
-            this._steps.push({
-                label: 'Edit ' + shortPath(path),
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            return true;
-        }
-        // "Creating empty file <path>" — base_coder.py:461 — net-new file scaffold
-        m = line.match(/^Creating empty file\s+(.+)$/);
-        if (m) {
-            const path = m[1];
-            this.aiderFlushOutput();
-            this.flushAiderSay(); // emit reasoning prose that preceded this write
-            this.aiderJustCreated.add(path);
-            // Use "Write" to align with Claude/Gemini's net-new-file label vocabulary.
-            this._steps.push({
-                label: 'Write ' + shortPath(path),
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            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
-        }
-        // Outside a Running window: aider's natural-language reasoning. Buffer it
-        // (skipping diff fences + markers + status noise); flushed as one kind:'say'
-        // step before the next action or at finalize. (PRODUCT_STATE §0 NEXT #1)
-        if (this.aiderRunningStepIdx === null)
-            this.collectAiderSay(line);
-        return false;
-    }
-    ingestCodex(type, data) {
-        if (type !== 'item.completed')
-            return false;
-        const item = (data.item ?? {});
-        const itemType = String(item.type ?? '');
-        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;
-        }
-        // file_change — codex emits one item per Edit/Write/Delete batch. The audit
-        // mirror (codex-adapter.ts) already handles these; the timeline-step path was
-        // dropping them, so real codex file edits were invisible in "watch it work"
-        // (mock-currency audit 2026-06-02 caught this — the mock emits the real shape).
-        if (itemType === 'file_change') {
-            const changes = Array.isArray(item.changes)
-                ? item.changes
-                : [];
-            let changed = false;
-            for (const ch of changes) {
-                const path = String(ch.path ?? '');
-                const kind = String(ch.kind ?? 'update');
-                const toolName = kind === 'add' ? 'Write' : kind === 'delete' ? 'Delete' : 'Edit';
-                // Label directly so the path always shows (labelForClaudeToolUse only
-                // knows Edit/Write/Read — it drops the path for Delete).
-                this._steps.push({
-                    label: path ? toolName + ' ' + path : toolName,
-                    state: 'done',
-                    startedAt: Date.now(),
-                    completedAt: Date.now(),
-                });
-                changed = true;
-            }
-            return changed;
-        }
-        // mcp_tool_call + web_search — real visible actions the codex-adapter mirrors
-        // to audit; surface them as timeline steps too (2026-06-02 follow-up, Ega-approved
-        // class: "watch it work"). Labels mirror codex-adapter conventions.
-        if (itemType === 'mcp_tool_call') {
-            const server = String(item.server ?? '');
-            const tool = String(item.tool ?? 'mcp');
-            this._steps.push({
-                label: 'MCP · ' + (server ? server + '.' : '') + tool,
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            return true;
-        }
-        if (itemType === 'web_search') {
-            const q = String(item.query ?? '')
-                .trim()
-                .slice(0, 80);
-            this._steps.push({
-                label: q ? 'Web search · ' + q : 'Web search',
-                state: 'done',
-                startedAt: Date.now(),
-                completedAt: Date.now(),
-            });
-            return true;
-        }
-        // agent_message = codex's own narration. Captured as kind:'say' since the
-        // v1 spec settled the taste call that used to be flagged here (pm-layers
-        // "just chatter" decision): the room thread is "tool steps woven with the
-        // agent's plain-English narration" for EVERY vendor, and the Final Report
-        // engine reuses 'say' steps as the summary — without this, codex always
-        // degraded to the deterministic fallback.
-        if (itemType === 'agent_message') {
-            return this.pushSay(String(item.text ?? ''));
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=progress-aggregator.js.map