codehere 0.7.1 → 1.0.1

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

@@ -17,6 +17,36 @@ function shortPath(p) {
 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) {
@@ -99,6 +129,26 @@ function truncateOutput(s) {
         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.
@@ -161,6 +211,44 @@ export class ProgressAggregator {
             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
@@ -169,6 +257,14 @@ export class ProgressAggregator {
     // 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 ?? {});
@@ -198,8 +294,10 @@ export class ProgressAggregator {
     }
     /** Flush: mark every still-active step as failed (called on abnormal exit). */
     finalize(status) {
-        // Surface any trailing aider reasoning that had no following action.
+        // 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';
@@ -213,6 +311,61 @@ export class ProgressAggregator {
         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 ?? {});
@@ -228,19 +381,56 @@ export class ProgressAggregator {
                     const said = b.text.trim();
                     this._steps.push({
                         kind: 'say',
-                        label: said.length > 500 ? said.slice(0, 500) + '\\u2026' : said,
+                        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 label = labelForClaudeToolUse(String(b.name ?? ''), b.input);
-                    const idx = this.addStep(label, 'active');
-                    if (id)
-                        this.toolUseIndex.set(id, idx);
+                    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;
                 }
             }
@@ -258,17 +448,29 @@ export class ProgressAggregator {
                     const idx = id ? this.toolUseIndex.get(id) : undefined;
                     if (idx !== undefined) {
                         const step = this._steps[idx];
-                        step.state = b.is_error ? 'failed' : 'done';
+                        // 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();
-                        // 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.
+                        // 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)
+                        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;
                     }
                 }
@@ -290,6 +492,9 @@ export class ProgressAggregator {
      */
     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);
@@ -322,8 +527,43 @@ export class ProgressAggregator {
                 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).
@@ -407,7 +647,12 @@ export class ProgressAggregator {
      *  "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:|Main model:|Weak model:|Model:|Git repo:|Use \/|aider |Committing )/;
+    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;
@@ -434,7 +679,7 @@ export class ProgressAggregator {
             return false;
         this._steps.push({
             kind: 'say',
-            label: said.length > 500 ? said.slice(0, 500) + '…' : said,
+            label: said.length > 20000 ? said.slice(0, 20000) + '…' : said,
             state: 'done',
             startedAt: Date.now(),
             completedAt: Date.now(),
@@ -462,6 +707,8 @@ export class ProgressAggregator {
             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;
@@ -633,7 +880,9 @@ export class ProgressAggregator {
             return true;
         }
         if (itemType === 'web_search') {
-            const q = String(item.query ?? '').trim().slice(0, 80);
+            const q = String(item.query ?? '')
+                .trim()
+                .slice(0, 80);
             this._steps.push({
                 label: q ? 'Web search · ' + q : 'Web search',
                 state: 'done',
@@ -642,12 +891,15 @@ export class ProgressAggregator {
             });
             return true;
         }
-        // NOTE (mock-currency 2026-06-02): codex `agent_message` is intentionally NOT
-        // captured here — a prior decision (pm-layers.test.ts "just chatter, not a
-        // step") drops it. This is INCONSISTENT with ingestClaude/ingestAider, which
-        // DO capture agent narration as kind:'say' (per #45 + A1 "watch it work").
-        // Resolving that inconsistency is a product taste call → flagged for Ega in
-        // mock-currency-2026-06-02.md, not changed unilaterally by the autonomous loop.
+        // 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;
     }
 }