@link-assistant/hive-mind 2.11.2 → 2.11.4

package/src/formal-ai-pricing.lib.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Pricing and provider identity for the Formal AI model (issue #2119).
+ *
+ * `--model formal-ai` routes every request through a local Formal AI model
+ * server (`formal-ai with <tool> ...`). The requests never reach OpenCode Zen,
+ * OpenAI, Anthropic or Google, so:
+ *
+ *   - the provider is Link.Assistant, not the provider of whichever agentic CLI
+ *     happens to be driving the session;
+ *   - the cost is $0.00, so an inherited `total_cost_usd` (claude reported
+ *     $0.252315 for a Formal AI session) or a models.dev price lookup for an
+ *     unrelated base model is a false positive.
+ *
+ * Every pricing producer funnels through here so the same numbers appear in
+ * logs, GitHub comments and budget statistics.
+ */
+
+import { FORMAL_AI_MODEL_ALIAS, isFormalAiModel } from './models/index.mjs';
+
+export const FORMAL_AI_PROVIDER_NAME = 'Link.Assistant';
+
+const ZERO_PRICING = Object.freeze({
+  inputPerMillion: 0,
+  outputPerMillion: 0,
+  cacheReadPerMillion: 0,
+  cacheWritePerMillion: 0,
+  reasoningPerMillion: 0,
+});
+
+const ZERO_BREAKDOWN = Object.freeze({
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  reasoning: 0,
+});
+
+/**
+ * Build the pricing record for a Formal AI session.
+ *
+ * @param {string|null} modelId model id as passed to the tool (alias or `formalai/formal-ai`)
+ * @param {Object|null} tokenUsage aggregated token usage, kept so token counts stay reportable
+ * @returns {Object} pricing info with a Link.Assistant provider and a $0.00 cost
+ */
+export const buildFormalAiPricingInfo = (modelId = FORMAL_AI_MODEL_ALIAS, tokenUsage = null) => ({
+  modelId: modelId || FORMAL_AI_MODEL_ALIAS,
+  modelName: FORMAL_AI_MODEL_ALIAS,
+  provider: FORMAL_AI_PROVIDER_NAME,
+  // No third-party price applies, so there is no base model to reference.
+  originalProvider: null,
+  baseModelName: null,
+  tokenUsage: tokenUsage || null,
+  pricing: { ...ZERO_PRICING },
+  breakdown: { ...ZERO_BREAKDOWN },
+  totalCostUSD: 0,
+  isFreeModel: true,
+  isFormalAi: true,
+});
+
+/**
+ * Wrap a `(modelId, tokenUsage) => pricingInfo` calculator so Formal AI model
+ * ids short-circuit to the free Link.Assistant record instead of being priced
+ * against models.dev.
+ *
+ * @param {Function} calculatePricing the tool's own pricing calculator
+ * @returns {Function} wrapped calculator with the same signature
+ */
+export const withFormalAiPricing =
+  calculatePricing =>
+  async (modelId, tokenUsage, ...rest) => {
+    if (isFormalAiModel(modelId)) return buildFormalAiPricingInfo(modelId, tokenUsage);
+    return calculatePricing(modelId, tokenUsage, ...rest);
+  };
+
+/**
+ * Normalize a tool result's pricing fields for Formal AI sessions.
+ *
+ * Tools that report a provider cost of their own (claude's `total_cost_usd`)
+ * or that build a static provider record (gemini's "Google", qwen's "Alibaba")
+ * would otherwise attribute a Formal AI session to the wrong provider at a
+ * non-zero price.
+ *
+ * @param {Object} params
+ * @param {string|null} params.model model requested on the command line
+ * @param {Object|null} [params.pricingInfo]
+ * @param {number|null} [params.publicPricingEstimate]
+ * @param {number|null} [params.anthropicTotalCostUSD]
+ * @param {Object|null} [params.tokenUsage] fallback token usage when pricingInfo carries none
+ * @returns {{pricingInfo: Object|null, publicPricingEstimate: number|null, anthropicTotalCostUSD: number|null}}
+ */
+export const applyFormalAiPricingOverride = ({ model, pricingInfo = null, publicPricingEstimate = null, anthropicTotalCostUSD = null, tokenUsage = null }) => {
+  if (!isFormalAiModel(model)) return { pricingInfo, publicPricingEstimate, anthropicTotalCostUSD };
+
+  const usage = pricingInfo?.tokenUsage || tokenUsage || null;
+  // Drop provider-specific cost fields carried by the tool's own record: a
+  // Formal AI session was never billed by OpenCode Zen, so a
+  // "Calculated by OpenCode Zen" line would be a false positive.
+  const { opencodeCost: _opencodeCost, isOpencodeFreeModel: _isOpencodeFreeModel, ...carried } = pricingInfo || {};
+  return {
+    pricingInfo: { ...carried, ...buildFormalAiPricingInfo(pricingInfo?.modelId || model, usage) },
+    publicPricingEstimate: 0,
+    // The session never billed Anthropic, so any captured Anthropic cost is a
+    // false positive and must not be rendered as a second cost line.
+    anthropicTotalCostUSD: null,
+  };
+};
+
+export { isFormalAiModel };

package/src/gemini.lib.mjs

@@ -17,12 +17,15 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 const __geminiBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'gemini', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { defaultModels, geminiModels } from './models/index.mjs';
+import { defaultModels, geminiModels, isFormalAiModel } from './models/index.mjs';
 import { logPreparedToolCommand, resolveFormalAiToolInvocation } from './formal-ai.lib.mjs';
+import { buildFormalAiPricingInfo } from './formal-ai-pricing.lib.mjs'; // Issue #2119
 import { checkPlaywrightMcpPackageAvailability } from './playwright-mcp.lib.mjs';
 import { classifyRetryableError, prepareRetryAfterError, waitWithCountdown } from './tool-retry.lib.mjs';
 import { getCumulativeContextInputTokens, toTokenCount } from './context-fill.lib.mjs';
+import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 import { getTerminalEventCompletionHealth } from './tool-run-health.lib.mjs'; // Issue #1990
+import { takeJsonRecords } from './json-stream.lib.mjs'; // Issue #2119
 
 const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 
@@ -130,6 +133,15 @@ const pickTokenValue = (...values) => {
   return 0;
 };
 
+/**
+ * Issue #2119: `--model formal-ai` is served by the local Link.Assistant model
+ * server, so the session must not be attributed to Google.
+ */
+export const buildGeminiPricingInfo = mappedModel => {
+  if (isFormalAiModel(mappedModel)) return buildFormalAiPricingInfo(mappedModel);
+  return { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null };
+};
+
 export const buildGeminiResultModelUsage = (modelId, stats = null) => {
   const modelStats = stats?.models && typeof stats.models === 'object' ? stats.models : null;
   if (modelStats) {
@@ -221,41 +233,17 @@ export const parseGeminiJsonOutput = (output, state = {}, modelId = null) => {
     partialLine: state.partialLine || '',
   };
 
-  const trimmedOutput = output.trim();
-  if (trimmedOutput && !nextState.partialLine) {
-    try {
-      const parsed = JSON.parse(trimmedOutput);
-      for (const event of Array.isArray(parsed) ? parsed : [parsed]) {
-        applyGeminiJsonEvent(event, nextState, modelId);
-      }
-      return nextState;
-    } catch {
-      // stream-json emits one JSON object per line; fall through to JSONL parsing.
-    }
-  }
-
-  const bufferedOutput = `${nextState.partialLine}${output}`;
-  nextState.partialLine = '';
-  const lines = bufferedOutput.split(/\r?\n/);
-  const hasTrailingLineBreak = /\r?\n$/.test(bufferedOutput);
-  const completeLines = hasTrailingLineBreak ? lines : lines.slice(0, -1);
-  const possiblePartialLine = hasTrailingLineBreak ? '' : lines.at(-1) || '';
-
-  for (const line of completeLines) {
-    if (!line.trim()) continue;
-
-    try {
-      applyGeminiJsonEvent(JSON.parse(line), nextState, modelId);
-    } catch {
-      continue;
-    }
-  }
-
-  if (possiblePartialLine.trim()) {
-    try {
-      applyGeminiJsonEvent(JSON.parse(possiblePartialLine), nextState, modelId);
-    } catch {
-      nextState.partialLine = possiblePartialLine;
+  // Issue #2119: frame the stream by balanced JSON values instead of by lines.
+  // `formal-ai with gemini` emits pretty-printed, multi-line records, so every
+  // line failed to parse and every event - including the token usage - was
+  // dropped. Scanning for balanced values also covers records concatenated
+  // without a separator and records split across two process chunks.
+  const { records, rest } = takeJsonRecords(`${nextState.partialLine}${String(output ?? '')}`);
+  nextState.partialLine = rest;
+
+  for (const record of records) {
+    for (const event of Array.isArray(record) ? record : [record]) {
+      applyGeminiJsonEvent(event, nextState, modelId);
     }
   }
 
@@ -587,8 +575,8 @@ export const executeGeminiCommand = async params => {
           messageCount: geminiJsonState.messageCount || 0,
           toolUseCount: geminiJsonState.toolUseCount || 0,
           resultModelUsage: geminiJsonState.resultModelUsage || buildGeminiResultModelUsage(mappedModel),
-          pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
-          publicPricingEstimate: null,
+          pricingInfo: buildGeminiPricingInfo(mappedModel),
+          publicPricingEstimate: buildGeminiPricingInfo(mappedModel).totalCostUSD,
           resultSummary: geminiJsonState.resultSummary || null,
           // Issue #1845/#1941: surface the actual error, rejecting meaningless fragments (e.g. a lone "}")
           errorInfo: { message: buildToolErrorMessage({ lastMessage: errorText, exitCode, fallback: `Gemini command failed with exit code ${exitCode}`, toolLabel: 'Gemini' }), exitCode },
@@ -631,8 +619,8 @@ export const executeGeminiCommand = async params => {
           messageCount: geminiJsonState.messageCount || 0,
           toolUseCount: geminiJsonState.toolUseCount || 0,
           resultModelUsage: geminiJsonState.resultModelUsage || buildGeminiResultModelUsage(mappedModel),
-          pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
-          publicPricingEstimate: null,
+          pricingInfo: buildGeminiPricingInfo(mappedModel),
+          publicPricingEstimate: buildGeminiPricingInfo(mappedModel).totalCostUSD,
           resultSummary: geminiJsonState.resultSummary || null,
           completionHealth,
           incompleteSession: completionHealth.incompleteSession,
@@ -655,8 +643,8 @@ export const executeGeminiCommand = async params => {
         messageCount: geminiJsonState.messageCount || 0,
         toolUseCount: geminiJsonState.toolUseCount || 0,
         resultModelUsage: geminiJsonState.resultModelUsage || buildGeminiResultModelUsage(mappedModel),
-        pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
-        publicPricingEstimate: null,
+        pricingInfo: buildGeminiPricingInfo(mappedModel),
+        publicPricingEstimate: buildGeminiPricingInfo(mappedModel).totalCostUSD,
         resultSummary: geminiJsonState.resultSummary || null,
       };
     } catch (error) {
@@ -690,11 +678,14 @@ export const executeGeminiCommand = async params => {
 
 export const checkForUncommittedChanges = async (tempDir, owner, repo, branchName, $, log, autoCommit = false, autoRestartEnabled = true) => {
   await log('\n🔍 Checking for uncommitted changes...');
+  // Issue #2119: AI tools leave scratch state (.formal-ai/, .playwright-mcp/) in
+  // the workspace. Ignoring it here keeps it out of both this check and 'git add -A'.
+  await ensureAiToolScratchIgnored(tempDir, log);
   try {
     const gitStatusResult = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
 
     if (gitStatusResult.code === 0) {
-      const statusOutput = gitStatusResult.stdout.toString().trim();
+      const statusOutput = filterAiToolScratchFromStatus(gitStatusResult.stdout.toString().trim());
 
       if (statusOutput) {
         await log('📝 Found uncommitted changes');

package/src/github-cost-info.lib.mjs

@@ -51,6 +51,11 @@ export const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricing
       }
       costInfo += `\n- Public pricing estimate: $${publicDec.toFixed(6)}${pricingRef}`;
     }
+  } else if (pricingInfo?.isFreeModel && !pricingInfo?.baseModelName) {
+    // Issue #2119: a free model has a known price - $0.00 - even when no
+    // usage-derived estimate was produced. Reporting "unknown" for it was a
+    // false negative (`--model formal-ai` is served free by Link.Assistant).
+    costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
   } else if (hasPricing) {
     costInfo += '\n- Public pricing estimate: unknown';
   }

package/src/json-stream.lib.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * Incremental JSON record scanner for agentic CLI output streams.
+ *
+ * Issue #2119: the agent stream readers split the raw output on newlines and
+ * called `JSON.parse` on each line. That works only when the tool emits strict
+ * NDJSON on line boundaries that happen to align with process chunk
+ * boundaries. Three real-world stream shapes break it:
+ *
+ *   1. Pretty-printed records — `formal-ai with agent --verbose` emits
+ *      multi-line, indented JSON, so *every* line fails to parse. Every
+ *      structured event (session id, token usage, errors, result text) is then
+ *      dropped, which is how a run with 21677 input / 22834 output tokens was
+ *      published as "Token usage: 0 input, 0 output".
+ *   2. Concatenated records — `{...}{...}` arriving without a separator
+ *      (issue #1250).
+ *   3. Split records — one record spanning two process chunks.
+ *
+ * Scanning for balanced JSON values instead of relying on line framing handles
+ * all three with a single mechanism, and non-JSON output is still surfaced
+ * verbatim as text events so plain tool logs keep flowing.
+ */
+
+// A pending fragment that never balances (for example prose that happens to
+// start with `{`) must not grow without bound. Once the buffer exceeds this
+// size it is released as text.
+export const DEFAULT_MAX_PENDING_BYTES = 4 * 1024 * 1024;
+
+const isStructuralOpener = character => character === '{' || character === '[';
+
+/**
+ * Find the index just past the JSON value starting at `start`.
+ * @returns {number} end index (exclusive), or -1 when the value is incomplete.
+ */
+const findValueEnd = (buffer, start) => {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = start; index < buffer.length; index++) {
+    const character = buffer[index];
+
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === '\\') escaped = true;
+      else if (character === '"') inString = false;
+      continue;
+    }
+
+    if (character === '"') {
+      inString = true;
+      continue;
+    }
+    if (character === '{' || character === '[') {
+      depth++;
+      continue;
+    }
+    if (character === '}' || character === ']') {
+      depth--;
+      if (depth === 0) return index + 1;
+      if (depth < 0) return -1;
+    }
+  }
+
+  return -1;
+};
+
+/**
+ * Create a stateful scanner that turns a byte stream into JSON and text events.
+ *
+ * @param {Object} [options]
+ * @param {number} [options.maxPendingBytes] release an unbalanced buffer once it grows past this size
+ * @returns {{write: (chunk: string) => Array<Object>, flush: () => Array<Object>}}
+ */
+export const createJsonStreamScanner = (options = {}) => {
+  const maxPendingBytes = options.maxPendingBytes ?? DEFAULT_MAX_PENDING_BYTES;
+  let pending = '';
+
+  const emitTextLines = (text, events) => {
+    for (const line of text.split('\n')) {
+      if (line.trim()) events.push({ type: 'text', value: line });
+    }
+  };
+
+  const scan = (final, events) => {
+    let index = 0;
+
+    while (index < pending.length) {
+      const character = pending[index];
+
+      if (character === '\n' || character === '\r' || character === ' ' || character === '\t') {
+        index++;
+        continue;
+      }
+
+      if (isStructuralOpener(character)) {
+        const end = findValueEnd(pending, index);
+        if (end < 0) break; // incomplete record: wait for more input
+        const raw = pending.slice(index, end);
+        try {
+          events.push({ type: 'json', value: JSON.parse(raw), raw });
+        } catch {
+          // Balanced but not valid JSON: surface it verbatim rather than
+          // silently dropping tool output.
+          emitTextLines(raw, events);
+        }
+        index = end;
+        continue;
+      }
+
+      const newline = pending.indexOf('\n', index);
+      if (newline < 0) break; // incomplete text line: wait for more input
+      const line = pending.slice(index, newline).replace(/\r$/, '');
+      if (line.trim()) events.push({ type: 'text', value: line });
+      index = newline + 1;
+    }
+
+    pending = pending.slice(index);
+
+    if (final) {
+      if (pending.trim()) {
+        const trimmed = pending.trim();
+        let parsed = null;
+        if (isStructuralOpener(trimmed[0])) {
+          try {
+            parsed = { type: 'json', value: JSON.parse(trimmed), raw: trimmed };
+          } catch {
+            parsed = null;
+          }
+        }
+        if (parsed) events.push(parsed);
+        else emitTextLines(pending, events);
+      }
+      pending = '';
+    } else if (pending.length > maxPendingBytes) {
+      emitTextLines(pending, events);
+      pending = '';
+    }
+
+    return events;
+  };
+
+  return {
+    write(chunk) {
+      pending += String(chunk ?? '');
+      return scan(false, []);
+    },
+    flush() {
+      return scan(true, []);
+    },
+    /** The unconsumed tail: an incomplete record or text line. */
+    pending() {
+      return pending;
+    },
+  };
+};
+
+/**
+ * Split a buffered stream into complete JSON records plus the unconsumed tail.
+ *
+ * Stateless counterpart of `createJsonStreamScanner`, for the parsers that keep
+ * their buffer inside a plain state object they hand back to their caller
+ * (`parseGeminiJsonOutput`, `parseQwenStreamJsonOutput`) instead of holding a
+ * closure across chunks.
+ *
+ * @param {string} buffered carried-over tail followed by the new chunk
+ * @returns {{records: Array<Object>, rest: string}}
+ */
+export const takeJsonRecords = buffered => {
+  const scanner = createJsonStreamScanner();
+  const events = scanner.write(String(buffered ?? ''));
+  return {
+    records: events.filter(event => event.type === 'json').map(event => event.value),
+    rest: scanner.pending(),
+  };
+};
+
+/**
+ * Buffer a byte stream into whole lines.
+ *
+ * Line-oriented parsers (Codex NDJSON plus its interleaved OTEL diagnostics)
+ * stay correct as long as they never see half a line. A process chunk boundary
+ * can fall anywhere, so the trailing partial line is carried over to the next
+ * chunk and released by `flush()`.
+ *
+ * @returns {{write: (chunk: string) => string, flush: () => string}}
+ */
+export const createLineBuffer = () => {
+  let pending = '';
+
+  return {
+    write(chunk) {
+      pending += String(chunk ?? '');
+      const boundary = pending.lastIndexOf('\n');
+      if (boundary < 0) return '';
+      const complete = pending.slice(0, boundary + 1);
+      pending = pending.slice(boundary + 1);
+      return complete;
+    },
+    flush() {
+      const rest = pending;
+      pending = '';
+      return rest;
+    },
+  };
+};
+
+/**
+ * Extract every complete JSON record from a finished output buffer.
+ *
+ * @param {string} output raw tool output
+ * @returns {Array<Object>} parsed JSON values in stream order
+ */
+export const parseJsonRecords = output => {
+  const scanner = createJsonStreamScanner();
+  const events = [...scanner.write(String(output ?? '')), ...scanner.flush()];
+  return events.filter(event => event.type === 'json').map(event => event.value);
+};

package/src/opencode.lib.mjs

@@ -23,8 +23,10 @@ import { opencodeModels, defaultModels } from './models/index.mjs';
 import { logPreparedToolCommand, resolveFormalAiToolInvocation } from './formal-ai.lib.mjs';
 import { checkPlaywrightMcpPackageAvailability, getOpenCodePlaywrightMcpDisableEnv } from './playwright-mcp.lib.mjs';
 import { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage as parseOpenCodeTokenUsage } from './agent-token-usage.lib.mjs';
+import { createJsonStreamScanner } from './json-stream.lib.mjs';
 import { calculateAgentPricing } from './agent.lib.mjs';
 import { classifyRetryableError, prepareRetryAfterError, waitWithCountdown } from './tool-retry.lib.mjs';
+import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 
 export { parseOpenCodeTokenUsage };
 
@@ -336,6 +338,48 @@ export const executeOpenCodeCommand = async params => {
       let lastTextContent = ''; // Issue #1263: Track last text content for result summary
       let allOutput = ''; // Collect all output for error detection
 
+      // Issue #2119: frame records by balanced JSON instead of by newlines, so
+      // pretty-printed, concatenated and chunk-split records are all counted.
+      // The previous per-chunk try/catch also aborted parsing of the whole
+      // chunk as soon as one line was not JSON.
+      const stdoutScanner = createJsonStreamScanner();
+      const stderrScanner = createJsonStreamScanner();
+
+      const handleOpenCodeRecords = events => {
+        for (const event of events) {
+          if (event.type !== 'json') continue;
+          const data = sanitizeObjectStrings(event.value);
+          // Issue #1968: a bare `null`/primitive record must not abort the
+          // rest of the chunk (data.type access would throw on null).
+          if (data === null || typeof data !== 'object') continue;
+          accumulateAgentStepFinishUsage(streamingTokenUsage, data);
+          // Track text content for result summary
+          // OpenCode outputs text via 'text', 'assistant', 'message', or 'result' type events
+          if (data.type === 'text' && data.text) {
+            lastTextContent = data.text;
+          } else if (data.type === 'assistant' && data.message?.content) {
+            const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
+            for (const item of content) {
+              if (item.type === 'text' && item.text) {
+                lastTextContent = item.text;
+              }
+            }
+          } else if (data.type === 'message' && data.content) {
+            if (typeof data.content === 'string') {
+              lastTextContent = data.content;
+            } else if (Array.isArray(data.content)) {
+              for (const item of data.content) {
+                if (item.type === 'text' && item.text) {
+                  lastTextContent = item.text;
+                }
+              }
+            }
+          } else if (data.type === 'result' && data.result) {
+            lastTextContent = data.result;
+          }
+        }
+      };
+
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
@@ -343,44 +387,8 @@ export const executeOpenCodeCommand = async params => {
           lastMessage = output;
           allOutput += output;
 
-          // Issue #1263: Try to parse JSON output to extract text content for result summary
-          try {
-            const lines = output.split('\n');
-            for (const line of lines) {
-              if (!line.trim()) continue;
-              const data = sanitizeObjectStrings(JSON.parse(line));
-              // Issue #1968: a bare `null`/primitive NDJSON line must not abort the
-              // rest of the chunk (data.type access would throw on null).
-              if (data === null || typeof data !== 'object') continue;
-              accumulateAgentStepFinishUsage(streamingTokenUsage, data);
-              // Track text content for result summary
-              // OpenCode outputs text via 'text', 'assistant', 'message', or 'result' type events
-              if (data.type === 'text' && data.text) {
-                lastTextContent = data.text;
-              } else if (data.type === 'assistant' && data.message?.content) {
-                const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
-                for (const item of content) {
-                  if (item.type === 'text' && item.text) {
-                    lastTextContent = item.text;
-                  }
-                }
-              } else if (data.type === 'message' && data.content) {
-                if (typeof data.content === 'string') {
-                  lastTextContent = data.content;
-                } else if (Array.isArray(data.content)) {
-                  for (const item of data.content) {
-                    if (item.type === 'text' && item.text) {
-                      lastTextContent = item.text;
-                    }
-                  }
-                }
-              } else if (data.type === 'result' && data.result) {
-                lastTextContent = data.result;
-              }
-            }
-          } catch {
-            // Not JSON, continue
-          }
+          // Issue #1263: Parse JSON output to extract text content for result summary
+          handleOpenCodeRecords(stdoutScanner.write(output));
         }
 
         if (chunk.type === 'stderr') {
@@ -389,47 +397,18 @@ export const executeOpenCodeCommand = async params => {
             await log(errorOutput, { stream: 'stderr' });
             allOutput += errorOutput;
 
-            // Issue #1263: Also try to parse stderr for text content
-            try {
-              const lines = errorOutput.split('\n');
-              for (const line of lines) {
-                if (!line.trim()) continue;
-                const data = sanitizeObjectStrings(JSON.parse(line));
-                // Issue #1968: skip bare `null`/primitive lines (see stdout handler above).
-                if (data === null || typeof data !== 'object') continue;
-                accumulateAgentStepFinishUsage(streamingTokenUsage, data);
-                if (data.type === 'text' && data.text) {
-                  lastTextContent = data.text;
-                } else if (data.type === 'assistant' && data.message?.content) {
-                  const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
-                  for (const item of content) {
-                    if (item.type === 'text' && item.text) {
-                      lastTextContent = item.text;
-                    }
-                  }
-                } else if (data.type === 'message' && data.content) {
-                  if (typeof data.content === 'string') {
-                    lastTextContent = data.content;
-                  } else if (Array.isArray(data.content)) {
-                    for (const item of data.content) {
-                      if (item.type === 'text' && item.text) {
-                        lastTextContent = item.text;
-                      }
-                    }
-                  }
-                } else if (data.type === 'result' && data.result) {
-                  lastTextContent = data.result;
-                }
-              }
-            } catch {
-              // Not JSON, continue
-            }
+            // Issue #1263: Also parse stderr for text content
+            handleOpenCodeRecords(stderrScanner.write(errorOutput));
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
         }
       }
 
+      // Release any record that was still being assembled when the stream ended.
+      handleOpenCodeRecords(stdoutScanner.flush());
+      handleOpenCodeRecords(stderrScanner.flush());
+
       // Clean up the opencode.json config file to avoid polluting the repository
       try {
         await fs.unlink(opencodeConfigPath);
@@ -631,11 +610,14 @@ export const executeOpenCodeCommand = async params => {
 export const checkForUncommittedChanges = async (tempDir, owner, repo, branchName, $, log, autoCommit = false, autoRestartEnabled = true) => {
   // Similar to Claude version, check for uncommitted changes
   await log('\n🔍 Checking for uncommitted changes...');
+  // Issue #2119: AI tools leave scratch state (.formal-ai/, .playwright-mcp/) in
+  // the workspace. Ignoring it here keeps it out of both this check and 'git add -A'.
+  await ensureAiToolScratchIgnored(tempDir, log);
   try {
     const gitStatusResult = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
 
     if (gitStatusResult.code === 0) {
-      const statusOutput = gitStatusResult.stdout.toString().trim();
+      const statusOutput = filterAiToolScratchFromStatus(gitStatusResult.stdout.toString().trim());
 
       if (statusOutput) {
         await log('📝 Found uncommitted changes');