@cspeach/cli 1.1.18 → 1.1.19

package/README.md

@@ -79,12 +79,11 @@ On `/exit` you get a session summary + the `cspeach --resume <id>` command in pl
 
 ## UI modes
 
-Two REPL modes, both supported. **Default is `classic`.** Switch with `/ui ink` or `/ui classic`; saves to `~/.cspeach/config.toml` under `[ui]`.
+An interactive terminal gets the standard display (the Ink frame). `/ui auto` (the default) picks it for you; `/ui ink` asks for it explicitly. Both save to `~/.cspeach/config.toml` under `[ui]` and apply after a relaunch.
 
-- **`classic`** — chalk + readline. The supported, demo-tested mode. Use this unless you have a reason not to. Native terminal scroll, mouse wheel, search — everything your terminal does naturally just works.
-- **`ink`** — React-based TUI. **PREVIEW.** Some rendering quirks remain (occasional phantom cursor, picker fossil in scrollback). Functional for daily use but not yet polished enough to recommend as default. Promoted to default in a later release.
+One-shot runs (`cspeach "<prompt>"`), piped input or output, and CI get plain line output automatically.
 
-If `ink` is misbehaving for you, run `/ui classic` once — change applies after relaunch.
+The classic display is retiring. A saved `ui.rendering = "classic"` is no longer used: the next interactive start switches it to `auto` and says so once. If you need classic for one launch, set the environment variable `CSPEACH_UI=classic` before starting `cspeach`.
 
 ## Configuration
 

package/dist/agent/loop.js

@@ -8,9 +8,14 @@ import { loadConfig } from '../config/loader.js';
 import { resolveModelRole } from '../models/resolve.js';
 import { retryWithBackoff } from './retry.js';
 import { renderChunk, initialBufferState, render } from '../renderer/pipeline.js';
-import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner, isWidgetSuppressedTool } from '../renderer/tool-widget.js';
+import { nextWritingActivity } from '../renderer/fence-state.js';
+import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner, isWidgetSuppressedTool, toolActivityText, toolHeartbeatLabel } from '../renderer/tool-widget.js';
 import { formatToolErrorSummary } from '../sap-errors/parse-adt-exception.js';
 import { startThinkingHeartbeat } from '../renderer/thinking-heartbeat.js';
+import { isDeclaredOneShot } from '../renderer/tty.js';
+import { USER_STOP_REASON } from '../session/interrupt-reason.js';
+import { writeStdout, stdoutFlow } from '../renderer/transcript-flow.js';
+import { formatFailure, formatAttention, formatInfo } from '../renderer/notice-shape.js';
 // 2026-06-07 — status-row narration. Safe to import in every mode: the
 // emitter has zero listeners outside Ink (classic / one-shot / subagent),
 // so activity() calls are no-ops there.
@@ -25,6 +30,7 @@ import { globalStore } from '../ui/sap-state-store.js';
 import { lastAssistantIsAwaitingAnswer } from '../session/awaiting-answer.js';
 import { enrichUserMessage } from '../router/intent-extractor.js';
 import { resetRule8State, shouldGateRule8 } from '../repl/rule8-detector.js';
+import { consumeTodoSetThisTurn } from '../ui/todo-emitter.js';
 import { runSaveCommand, runPromoteCommand, detectArtifactSkill, offerAnswerBlockers } from '../projects/index.js';
 import { parseFromFlag, coerceDocFromFlagToAttachment } from '../skills/promotion-dispatch.js';
 import { input } from '@inquirer/prompts';
@@ -37,7 +43,7 @@ import { renderStandaloneContextBlock } from '../sap/standalone-profile.js';
 import { renderStandardsBlock } from '../standards/standards-file.js';
 import { composeSessionContextBlock } from './session-context.js';
 import { objectKeyFromInput } from './retry-key.js';
-import { repairPartialBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError } from './repair-partial.js';
+import { repairPartialBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError, stripUnsignedThinking, isThinkingOnly, dropTrailingThinkingOnly } from './repair-partial.js';
 import { drainSteering } from './steering-queue.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
@@ -155,9 +161,52 @@ export async function inkAwarePrompt(q) {
     }
     return withInquirer(() => input({ message: q }));
 }
+/**
+ * Piece 2 / Q3 (spec §3 "[y/N] prompts") — the Yes/No question for the six
+ * [y/N] sites (via projects/yes-no.ts askYesNo). Returns 'y' | 'n' | ''.
+ *
+ * - headless → '' (never blocks), same log line as inkAwarePrompt. The save
+ *   hook keeps its blanket 'y' by NOT passing this in headless (maybeOfferSave).
+ * - Ink → an AskCard Yes/No (v1 choice 'y'/'n') under the card-slot focus
+ *   claim: cursor on the default, marked "(default)"; y/n keys answer at
+ *   once; Esc / no listener / anything else → '' (today's
+ *   `result.answer ?? ''`). Leaves one decision trace in scrollback.
+ * - classic → inquirer input with today's exact "<q> [y/N]: " text.
+ */
+export async function inkAwareConfirm(q, opts) {
+    const { shouldUseInk, isHeadless } = await import('../renderer/tty.js');
+    if (isHeadless()) {
+        console.error(chalk.dim(`headless: skipped prompt '${q.trim()}' → '' (default)`));
+        return '';
+    }
+    if (shouldUseInk()) {
+        const { askQuestionEmitter } = await import('../ui/ask-question-emitter.js');
+        const { withFocusClaim } = await import('../ui/card-slot.js');
+        const { emitTrace, formatDecisionTrace } = await import('../renderer/trace.js');
+        const { uiWidth } = await import('../renderer/ui-width.js');
+        const res = await withFocusClaim(() => askQuestionEmitter.request({
+            id: 'agent-confirm',
+            question: q,
+            kind: 'choice',
+            choices: [{ value: 'y', label: 'Yes' }, { value: 'n', label: 'No' }],
+            defaultValue: opts.default,
+            keys: { y: 'y', n: 'n' },
+        }));
+        const answer = res.answer === 'y' || res.answer === 'n' ? res.answer : '';
+        emitTrace(formatDecisionTrace(q, answer === 'y' ? 'Yes' : answer === 'n' ? 'No' : 'cancelled', uiWidth()));
+        return answer;
+    }
+    const hint = opts.default === 'y' ? '[Y/n]' : '[y/N]';
+    const raw = (await withInquirer(() => input({ message: `${q} ${hint}: ` }))).trim().toLowerCase();
+    if (raw === 'y' || raw === 'yes')
+        return 'y';
+    if (raw === '')
+        return opts.default;
+    return 'n';
+}
 /**
  * Choices picker for an answer-blocker that carries `options`. Renders the
- * native Ink AskQuestionModal (the same CC-style picker the ask_question tool
+ * native Ink AskCard (the same CC-style picker the ask_question tool
  * uses) with the candidate answers plus "Write my own" and "Skip" escapes.
  *
  * - headless  → skip (never blocks on stdin)
@@ -220,7 +269,7 @@ export async function maybeOfferSave(p) {
         if (!detected)
             return;
         saveSkill = detected;
-        p.emit(chalk.dim(`[save] ${detected} artifact manifest detected in this turn's output (turn was labelled '${p.skill}') — offering save.`));
+        p.emit(formatInfo(`${detected} output found in this turn (routed as ${p.skill}) · offering to save it`).trimEnd());
     }
     // B5 (2026-06-11) — defect D2: in headless runs the artifact IS the point
     // of the run, so the "Save as project file? [y/N]" prompt defaults YES
@@ -249,6 +298,9 @@ export async function maybeOfferSave(p) {
             author: getAuthorIdentity(),
             cwd: process.cwd(),
             prompt,
+            // Piece 2 / Q3 — interactive saves ask a Yes/No card; headless passes
+            // no confirm so the blanket-'y' prompt above still answers (B5 contract).
+            confirm: isHeadless() ? undefined : inkAwareConfirm,
             log: (...lines) => lines.forEach((l) => p.emit(l)),
             promotedFrom: p.promotedFrom ?? null,
         });
@@ -262,17 +314,36 @@ export async function maybeOfferSave(p) {
                 path: savedPath,
                 identity: getAuthorIdentity(),
                 prompt: inkAwarePrompt,
+                confirm: inkAwareConfirm,
                 choose: inkAwareChoose,
                 log: (...lines) => lines.forEach((l) => p.emit(l)),
             });
         }
     }
     catch (err) {
-        p.emit(chalk.yellow(`\n[save] skipped: ${err?.message ?? err}`));
+        p.emit('\n' + formatAttention({ text: 'Not saved as a project file', fact: String(err?.message ?? err) }).trimEnd());
     }
 }
 export async function runTurn(params) {
     resetRule8State(); // Rule 8 — fresh batch counter per LLM turn (= per user prompt)
+    // Piece 2 / P2 — fresh "plan changed this turn" flag per TOP-LEVEL turn.
+    // Not every path ends in pushPostTurnStatus (the Ink /reroute turn does
+    // not), so a mark left by such a turn must not earn the NEXT turn a close
+    // line. Subagent ctxs omit todoEmitter: a child turn keeps the parent's mark.
+    if (params.ctx.todoEmitter)
+        consumeTodoSetThisTurn();
+    // Panels spacing (polish P1): the REPL printed the prompt etc. outside the
+    // stdout transcript flow, so a stdout turn starts from "fresh line".
+    if (!params.chunkEmitter)
+        stdoutFlow.reset();
+    // Fix round 7 item 2 — one-shot passes its answer emitter (stdout, trimmed)
+    // as chunkEmitter. Liveness (spinners, heartbeats) must never enter the
+    // answer: in one-shot it keeps its own sinks (stderr heartbeat, in-place
+    // spinner only on a real terminal) exactly as before.
+    const livenessEmitter = isDeclaredOneShot() ? undefined : params.chunkEmitter;
+    // Owner ruling (r3 M11) — in one-shot the tool rows go with the tool
+    // notices (ctx.chunkEmitter → stderr), never into the answer on stdout.
+    const toolRowEmitter = isDeclaredOneShot() ? (params.ctx.chunkEmitter ?? params.chunkEmitter) : params.chunkEmitter;
     const cfg = await loadConfig();
     const session = params.ctx.session;
     // Define `emit` early so the Phase J promote dispatch (below) can stream
@@ -311,6 +382,7 @@ export async function runTurn(params) {
                 sourcePath: fromPath,
                 targetSkill: params.skill,
                 prompt: inkAwarePrompt,
+                confirm: inkAwareConfirm,
                 log: (...lines) => lines.forEach((l) => emit(l)),
             });
             if (!result) {
@@ -385,7 +457,12 @@ ${imageExpansion.error}`));
     // user has no standards file, so the composed block (and therefore the whole
     // prompt) stays byte-identical to pre-feature output for existing users.
     const standardsBlock = await renderStandardsBlock(params.ctx.cwd);
-    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, standardsBlock]);
+    // Round 6 review I4 — a resume moved this session to another system: tell
+    // the model once, on this turn, then drop the note.
+    const switchNote = session.systemSwitchNote
+        ? `<system_switch>${session.systemSwitchNote}</system_switch>`
+        : '';
+    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, standardsBlock, switchNote]);
     // Deterministically extract structured facts from the user's prompt
     // (package, transport, object names, environment hint, create intent)
     // and prepend them as an XML `<session_context>` block. The model reads
@@ -398,9 +475,12 @@ ${imageExpansion.error}`));
     // here, which would defeat a "first turn only" check. Skip only when the
     // message already begins with <session_context> (caller enriched it) or
     // when extraction yields nothing (enrichUserMessage returns original).
+    // Final batch 1 — a caller-enriched message still gets the switch note,
+    // inside its own <session_context> block.
     const enriched = userMessageForLLM.startsWith('<session_context>')
-        ? userMessageForLLM
+        ? (switchNote ? userMessageForLLM.replace('<session_context>', `<session_context>\n  ${switchNote}`) : userMessageForLLM)
         : enrichUserMessage(userMessageForLLM, sessionContextBlock);
+    const switchNoteUsed = switchNote !== '' && enriched.includes(switchNote);
     // Phase 2 of Track B — opt-in project-context enrichment, gated by
     // CSPEACH_PROJECT_CONTEXT=on. Default OFF: production behavior is
     // identical to today. When on, the rendered <project_context> block
@@ -434,6 +514,10 @@ ${imageExpansion.error}`));
     // Images (if any) ride as blocks ahead of the text; with none this is the
     // same plain string as before.
     session.messages.push({ role: 'user', content: buildUserContent(finalUserContent, imageExpansion.images) });
+    // Round 6 review I4 / final batch 1 — the switch note is dropped only once
+    // it is in a pushed user message.
+    if (switchNoteUsed)
+        delete session.systemSwitchNote;
     if (imageExpansion.images.length > 0 && params.provider.name === 'local-openai-compat') {
         // The local (OpenAI-compatible) provider keeps text blocks only.
         emit(chalk.dim('(local model: the image is not sent — the model gets the text only)'));
@@ -513,6 +597,7 @@ ${imageExpansion.error}`));
             }
         }
         let buffer = initialBufferState();
+        let writingCode = false; // piece 2 §11.2 — "writing code…" while a fence is held back
         let stream;
         // 2026-05-06: paint a "thinking" spinner during the LLM round-trip
         // wait so the user sees activity instead of staring at a silent
@@ -531,7 +616,7 @@ ${imageExpansion.error}`));
         // keeps the stdout spinner unchanged.
         // Guard: test/unit/ink-cursor-invariant.test.ts.
         turnStatusEmitter.activity('thinking');
-        const thinkingSpinner = startThinkingSpinner({ chunkEmitter: params.chunkEmitter });
+        const thinkingSpinner = startThinkingSpinner({ chunkEmitter: livenessEmitter });
         // v0.6 — guaranteed-visible heartbeat alongside the in-place spinner.
         // The spinner self-disables on non-TTY (Windows PowerShell sometimes
         // reports isTTY=false; resume mode also lost spinner visibility) so a
@@ -541,7 +626,7 @@ ${imageExpansion.error}`));
         // heartbeat lines land in the Body region (via React) instead of
         // being raw-written to stdout (which Ink overdraws on its next
         // render, briefly flashing the line then making it disappear).
-        const thinkingHeartbeat = startThinkingHeartbeat({ chunkEmitter: params.chunkEmitter });
+        const thinkingHeartbeat = startThinkingHeartbeat({ chunkEmitter: livenessEmitter });
         try {
             stream = await retryWithBackoff(() => (async () => {
                 // W2.5 — apply optional tool filter (used by agent_run with
@@ -565,6 +650,12 @@ ${imageExpansion.error}`));
                 // the single chokepoint every request passes through, retries included —
                 // makes the 400 categorically impossible. Idempotent and O(messages).
                 healSessionMessagesInPlace(session.messages);
+                // 2026-09-27 — same chokepoint: a thinking block without its
+                // signature (a turn cancelled mid-thinking, saved by an older CLI)
+                // 400s every later request with "Invalid `signature` in `thinking`
+                // block". Drop it; the model simply thinks again.
+                stripUnsignedThinking(session.messages);
+                dropTrailingThinkingOnly(session.messages);
                 // 2026-09-24 — same chokepoint: a tool call cut off before its
                 // result was recorded 400s every later request (a customer's
                 // `continue` could never succeed). Give each orphan an error result
@@ -621,7 +712,11 @@ ${imageExpansion.error}`));
             if (isPartialJsonApiError(err)) {
                 const scrubbed = healSessionMessagesInPlace(session.messages);
                 await saveSession(session);
-                emit(chalk.yellow(`\n⚠  Session was poisoned by a partial-json tool_use block; healed in-memory${scrubbed > 0 ? ` (${scrubbed} block${scrubbed === 1 ? '' : 's'} cleaned)` : ''}. Please retry your last message.`));
+                emit('\n' + formatAttention({
+                    text: 'Session repaired',
+                    fact: `a broken tool call was cleaned up${scrubbed > 0 ? ` (${scrubbed} block${scrubbed === 1 ? '' : 's'})` : ''}`,
+                    next: 'send your last message again',
+                }).trimEnd());
                 return;
             }
             // Proxy returns 409 upgrade_required when CLI is older than skill's min_cli_version.
@@ -629,13 +724,19 @@ ${imageExpansion.error}`));
             const bodyRaw = err?.error ?? err?.response?.data ?? err?.body;
             const body = typeof bodyRaw === 'string' ? JSON.parse(bodyRaw) : bodyRaw;
             if (status === 409 && body?.error === 'upgrade_required') {
-                emit(chalk.yellow.bold(`\n⚠  This skill requires cspeach >= ${body.min_cli_version} (you have ${body.current ?? 'unknown'}).`));
-                emit(chalk.yellow(`   Run: cspeach --upgrade`));
+                emit('\n' + formatFailure({
+                    what: 'This skill needs a newer CSPeach',
+                    detail: [`needs ${body.min_cli_version} or later · you have ${body.current ?? 'unknown'}`],
+                    next: 'cspeach --upgrade',
+                }).trimEnd());
                 return;
             }
             throw err;
         }
         let currentAssistantContent = [];
+        // 2026-09-27 — blocks whose content_block_stop arrived. A thinking block
+        // not in here was cut mid-stream and must never be persisted.
+        const completedBlocks = new WeakSet();
         let sawEndTurn = false;
         let sawToolUse = false;
         let sawMaxTokens = false;
@@ -682,6 +783,7 @@ ${imageExpansion.error}`));
                     // silent if the renderer buffers the block — the row keeps
                     // ticking "writing response · 90s" regardless.
                     turnStatusEmitter.activity('writing response');
+                    writingCode = false;
                     const block = event.content_block;
                     currentAssistantContent.push(block);
                     if (block.type === 'text') {
@@ -689,7 +791,7 @@ ${imageExpansion.error}`));
                         if (params.chunkEmitter)
                             params.chunkEmitter.emit('chunk', sep);
                         else
-                            process.stdout.write(sep);
+                            writeStdout(sep);
                     }
                 }
                 else if (type === 'content_block_delta') {
@@ -698,11 +800,15 @@ ${imageExpansion.error}`));
                     if (delta.type === 'text_delta') {
                         const { output, state } = renderChunk(delta.text, buffer);
                         buffer = state;
+                        const wa = nextWritingActivity(writingCode, buffer.pending);
+                        writingCode = wa.writingCode;
+                        if (wa.label)
+                            turnStatusEmitter.activity(wa.label);
                         if (output) {
                             if (params.chunkEmitter)
                                 params.chunkEmitter.emit('chunk', output);
                             else
-                                process.stdout.write(output);
+                                writeStdout(output);
                         }
                         if (last?.type === 'text')
                             last.text = (last.text ?? '') + delta.text;
@@ -730,6 +836,8 @@ ${imageExpansion.error}`));
                 }
                 else if (type === 'content_block_stop') {
                     const last = currentAssistantContent[currentAssistantContent.length - 1];
+                    if (last && typeof last === 'object')
+                        completedBlocks.add(last);
                     if (last?.type === 'tool_use' && last.partial_json) {
                         try {
                             last.input = JSON.parse(last.partial_json);
@@ -804,8 +912,9 @@ ${imageExpansion.error}`));
             if (params.chunkEmitter)
                 params.chunkEmitter.emit('chunk', flushed);
             else
-                process.stdout.write(flushed);
+                writeStdout(flushed);
             buffer = initialBufferState();
+            writingCode = false;
         }
         // Repair partial blocks before persistence. ALWAYS run, not just on
         // interruption: on a clean tool-use round the model's tool_use blocks can
@@ -815,7 +924,11 @@ ${imageExpansion.error}`));
         // only DROPS a block when its `input` is undefined — which never happens on
         // a clean round (content_block_stop always sets `input`), so this is a
         // no-op-except-strip on the happy path. See ./repair-partial.ts.
-        currentAssistantContent = repairPartialBlocks(currentAssistantContent);
+        currentAssistantContent = repairPartialBlocks(currentAssistantContent, { completed: completedBlocks });
+        // Review M2 — a cut right after the thinking block leaves a thinking-only
+        // turn: nothing the user can read, and nothing the next request needs.
+        if (isThinkingOnly(currentAssistantContent))
+            currentAssistantContent = [];
         // Persist the assistant message — even if it's partial. Empty content
         // arrays are skipped so we don't push a meaningless empty assistant
         // message that would confuse the next round.
@@ -842,7 +955,9 @@ ${imageExpansion.error}`));
         if (interruptedError !== null) {
             session.turnInterrupted = true;
             const msg = interruptedError instanceof Error ? interruptedError.message : String(interruptedError);
-            session.turnInterruptedReason = msg.slice(0, 200);
+            // Round 7 item 8d — a stop the user asked for (Ctrl+C, /exit mid-turn)
+            // is saved as such, never as the raw "Request was aborted.".
+            session.turnInterruptedReason = params.signal?.aborted ? USER_STOP_REASON : msg.slice(0, 200);
         }
         else {
             // Clean completion — clear any stale interrupted flag from a prior turn.
@@ -884,8 +999,9 @@ ${imageExpansion.error}`));
             void appendCostLine(session.id, entry);
         }
         // Close the stream-to-disk mirror with a footer (lightweight diagnostics).
-        // Best-effort — failure here is invisible to the turn flow.
-        void turnStreamWriter.close(interruptedError !== null
+        // Best-effort — failure here is invisible to the turn flow. Awaited
+        // (round 6 item 4e) so an exit right after the turn finds the log.
+        await turnStreamWriter.close(interruptedError !== null
             ? `_interrupted: ${session.turnInterruptedReason ?? 'unknown'}_`
             : undefined);
         // Re-throw AFTER persistence so the outer REPL catch can render the
@@ -1038,7 +1154,7 @@ ${imageExpansion.error}`));
                 renderToolCallTop({
                     name: block.name,
                     args: (block.input ?? {}),
-                    chunkEmitter: params.chunkEmitter,
+                    chunkEmitter: toolRowEmitter,
                 });
                 // Phase 2a: start the peach-themed spinner. No-op outside TTY / Ink
                 // / CI — the result line still prints, just without the in-place
@@ -1048,7 +1164,7 @@ ${imageExpansion.error}`));
                 // orphan on its own row above the form.
                 const spinner = isWidgetSuppressedTool(block.name)
                     ? { stop: () => undefined }
-                    : startToolSpinner({ chunkEmitter: params.chunkEmitter });
+                    : startToolSpinner({ chunkEmitter: livenessEmitter, label: toolActivityText(block.name, (block.input ?? {})) });
                 // 2026-06-06 (turn-liveness, B5 smoke feedback) — the in-place tool
                 // spinner self-disables under Ink (phantom cursor #25), which left
                 // slow tool calls (SAP over VPN: 10-60s) as DEAD AIR between the ⏺
@@ -1087,12 +1203,12 @@ ${imageExpansion.error}`));
                 if (isInteractiveTool)
                     turnStatusEmitter.pause();
                 else
-                    turnStatusEmitter.activity(block.name);
+                    turnStatusEmitter.activity(toolActivityText(block.name, (block.input ?? {})));
                 const toolHeartbeat = isInteractiveTool
                     ? { stop: () => undefined }
                     : startThinkingHeartbeat({
-                        chunkEmitter: params.chunkEmitter,
-                        label: `${block.name} running…`,
+                        chunkEmitter: livenessEmitter,
+                        label: toolHeartbeatLabel(block.name, (block.input ?? {})),
                     });
                 // Phase 2b: dispatch (may take 100ms–several seconds for write tools).
                 const dispatchStart = Date.now();
@@ -1139,13 +1255,15 @@ ${imageExpansion.error}`));
                     durationMs,
                     isError: result.is_error ?? false,
                     resultSummary,
-                    chunkEmitter: params.chunkEmitter,
+                    chunkEmitter: toolRowEmitter,
                     // D29 (2026-06-12): self-identifying result row. Heartbeat lines,
                     // sap-client warns, and notice lines legitimately print between
                     // the ⏺ top line and this row — without the name here those rows
                     // read as anonymous `⎿ ✓ 364ms` orphans in the transcript.
                     name: block.name,
                     args: (block.input ?? {}),
+                    // Panels look: counts ("17 lines") and folded command output.
+                    resultContent: typeof result.content === 'string' ? result.content : undefined,
                 });
                 // v0.3 (Step 28.0): populate session.toolCalls so the SessionTimeline
                 // overlay can render per-write history. Cap per-entry payload size at

package/dist/agent/providers/local-provider.js

@@ -1,4 +1,5 @@
-import OpenAI from 'openai';
+// Loaded on use (fix round 3, item 11e): only local mode needs the OpenAI SDK.
+const loadOpenAI = async () => (await import('openai')).default;
 import crypto from 'node:crypto';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
@@ -19,6 +20,7 @@ export function createLocalProvider(cfg) {
             if (params.tools && params.tools.length > 0) {
                 throw new Error('Tool calling not supported in local mode (Plan A). Switch to managed/byok/ai-hub, or wait for the local-mode tool-calling follow-up PR.');
             }
+            const OpenAI = await loadOpenAI();
             const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
             const openAiParams = anthropicParamsToOpenAI(params, model);
             // stream: true widens via object spread; the literal-true overload cannot be
@@ -29,6 +31,7 @@ export function createLocalProvider(cfg) {
         },
         async healthCheck() {
             try {
+                const OpenAI = await loadOpenAI();
                 const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
                 await sdk.chat.completions.create({
                     model,

package/dist/agent/repair-partial.js

@@ -1,23 +1,19 @@
 /**
- * Repair partial assistant content blocks before persisting them to a session.
- *
- * When a provider stream is interrupted mid-flight (HTTP socket dropped,
- * AbortController fired, network blip), the agent loop's accumulated
- * `currentAssistantContent` may include `tool_use` blocks whose `input` JSON
- * never finished streaming — typically the SDK has buffered the bytes into
- * `partial_json` but `JSON.parse` was never called, so `input` is undefined.
- *
- * Persisting an assistant message that contains an incomplete tool_use block
- * causes the next API call to reject the message with:
- *   400 each `tool_use` block must contain `input` (or similar)
- *
- * Drop incomplete tool_use blocks. The model will re-emit them on the next
- * round (the prior tool round's results are already on session.messages,
- * giving the model the same context). Text and thinking blocks are kept
- * even if truncated — partial prose is still useful for the user to read,
- * and a short paragraph fragment is a valid assistant message.
+ * 2026-09-27 — a thinking block is only valid to send back to the API with its
+ * complete signature. The signature arrives last (`signature_delta`, right
+ * before `content_block_stop`), so a turn cancelled mid-thinking leaves a block
+ * with `signature: ''` — and every later request 400s with
+ *   messages.N.content.M: Invalid `signature` in `thinking` block
+ * A redacted_thinking block is likewise only valid with its `data`.
  */
-export function repairPartialBlocks(blocks) {
+export function isUnsignedThinking(b) {
+    if (b?.type === 'thinking')
+        return typeof b.signature !== 'string' || b.signature.length === 0;
+    if (b?.type === 'redacted_thinking')
+        return typeof b.data !== 'string' || b.data.length === 0;
+    return false;
+}
+export function repairPartialBlocks(blocks, opts = {}) {
     return blocks.filter((b) => {
         if (b == null || typeof b !== 'object')
             return false;
@@ -35,10 +31,46 @@ export function repairPartialBlocks(blocks) {
                 delete b.partial_json;
             return true;
         }
-        // text, thinking, redacted_thinking, etc. — keep as-is.
+        if (b.type === 'thinking' || b.type === 'redacted_thinking') {
+            // Never persist a partial thinking block: no signature, or cut before
+            // its content_block_stop. The model re-thinks on the next round.
+            if (isUnsignedThinking(b))
+                return false;
+            if (opts.completed && !opts.completed.has(b))
+                return false;
+            return true;
+        }
+        // text etc. — keep as-is (partial prose is still useful and valid).
         return true;
     });
 }
+/**
+ * Heal a session already poisoned by an unsigned thinking block (saved by a
+ * CLI before 2026-09-27): drop every thinking / redacted_thinking block that
+ * lacks its signature, and drop a message left with no content (the API
+ * rejects empty content; consecutive user turns are merged by the API).
+ * Mutates `messages`; returns the number of blocks removed. Idempotent.
+ */
+export function stripUnsignedThinking(messages) {
+    if (!messages)
+        return 0;
+    let removed = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!Array.isArray(msg?.content))
+            continue;
+        const kept = msg.content.filter((b) => !isUnsignedThinking(b));
+        const dropped = msg.content.length - kept.length;
+        if (dropped === 0)
+            continue;
+        removed += dropped;
+        if (kept.length === 0)
+            messages.splice(i, 1);
+        else
+            msg.content = kept;
+    }
+    return removed;
+}
 /**
  * In-memory heal for a poisoned session.messages array.
  *
@@ -167,3 +199,28 @@ export function healOrphanToolUses(messages) {
     }
     return added;
 }
+/** Review M2 — true when every block is thinking / redacted_thinking (and there is one). */
+export function isThinkingOnly(blocks) {
+    return Array.isArray(blocks) && blocks.length > 0
+        && blocks.every((b) => b?.type === 'thinking' || b?.type === 'redacted_thinking');
+}
+/**
+ * Review M2 — a turn cut right after a signed thinking block (before any
+ * text or tool call) left an assistant message holding only thinking. Drop
+ * it when it is the LAST assistant message; earlier turns are never touched
+ * (removing a block mid-transcript would invalidate later signed blocks).
+ * Mutates `messages`; returns the number of messages removed. Idempotent.
+ */
+export function dropTrailingThinkingOnly(messages) {
+    if (!messages)
+        return 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i]?.role !== 'assistant')
+            continue;
+        if (!isThinkingOnly(messages[i].content))
+            return 0;
+        messages.splice(i, 1);
+        return 1;
+    }
+    return 0;
+}