@cspeach/cli 1.1.16 → 1.1.17

package/dist/agent/loop.js

@@ -37,7 +37,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, isPartialJsonApiError } from './repair-partial.js';
+import { repairPartialBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError } from './repair-partial.js';
 import { drainSteering } from './steering-queue.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
@@ -565,6 +565,14 @@ ${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-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
+                // so the model sees the call did not complete and redoes it.
+                const healedOrphans = healOrphanToolUses(session.messages);
+                if (healedOrphans > 0) {
+                    emit(chalk.dim(`(repaired ${healedOrphans} tool call(s) cut off by an interruption — the model will redo them)`));
+                }
                 const streamParams = {
                     // A4 — per-turn override (plan model tiering) wins over the
                     // configured default; absent on every non-plan turn. model-governance

package/dist/agent/repair-partial.js

@@ -116,3 +116,54 @@ export function isPartialJsonApiError(err) {
         && s.includes('partial_json')
         && /not permitted|Extra inputs/i.test(s));
 }
+/** Result text for a tool call whose real result was lost to an interruption. */
+export const INTERRUPTED_TOOL_RESULT = 'This tool call did not complete — the turn was interrupted before its result was recorded. ' +
+    'Its effect is unknown: check before relying on it, and re-run it if needed.';
+/**
+ * 2026-09-24 — heal tool_use blocks that have no tool_result after them.
+ *
+ * A turn cut after the model streamed a tool_use but before the result was
+ * recorded leaves a history the API rejects on EVERY later request
+ * ("messages.N: `tool_use` ids were found without `tool_result` blocks
+ * immediately after") — a customer's `continue` could never succeed. Each
+ * orphan gets a synthetic error result, placed where the API requires it: at
+ * the front of the next user message (created if the next message is not a
+ * user message). Mutates `messages`; returns the number of results added.
+ * Idempotent; a no-op on a healthy conversation.
+ */
+export function healOrphanToolUses(messages) {
+    if (!messages)
+        return 0;
+    let added = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg?.role !== 'assistant' || !Array.isArray(msg.content))
+            continue;
+        const ids = msg.content
+            .filter((b) => b?.type === 'tool_use' && typeof b.id === 'string')
+            .map((b) => b.id);
+        if (ids.length === 0)
+            continue;
+        let next = messages[i + 1];
+        if (next?.role !== 'user') {
+            next = { role: 'user', content: [] };
+            messages.splice(i + 1, 0, next);
+        }
+        else if (!Array.isArray(next.content)) {
+            next.content = [{ type: 'text', text: String(next.content ?? '') }];
+        }
+        const have = new Set(next.content.filter((b) => b?.type === 'tool_result').map((b) => b.tool_use_id));
+        const missing = ids
+            .filter((id) => !have.has(id))
+            .map((id) => ({ type: 'tool_result', tool_use_id: id, is_error: true, content: INTERRUPTED_TOOL_RESULT }));
+        if (missing.length === 0)
+            continue;
+        // tool_result blocks must lead the message: existing results, then the
+        // synthetic ones, then everything else (e.g. the user's "continue").
+        const results = next.content.filter((b) => b?.type === 'tool_result');
+        const rest = next.content.filter((b) => b?.type !== 'tool_result');
+        next.content = [...results, ...missing, ...rest];
+        added += missing.length;
+    }
+    return added;
+}

package/dist/agent/turn-error-ux.js

@@ -39,6 +39,11 @@ export function describeError(err) {
     }
     if (msg.includes('ECONNRESET'))
         return 'network connection reset';
+    // 2026-09-24 — the other shapes a dropped connection takes (our service
+    // restarting, a network blip): say it plainly instead of the raw text.
+    if (/fetch failed|socket hang up|other side closed|UND_ERR_SOCKET|ECONNREFUSED/i.test(msg)) {
+        return 'connection to CSPeach dropped';
+    }
     if (msg.includes('ETIMEDOUT'))
         return 'network timeout';
     if (msg.toLowerCase().includes('aborterror'))
@@ -111,6 +116,9 @@ export async function renderTurnError(input) {
     const reason = describeError(input.err);
     const logPath = await writeErrorLog(input.session.id, input.err);
     print(chalk.red(`⚠  Turn interrupted: ${reason}`));
+    if (input.inSession) {
+        print(chalk.yellow(`   Your work so far is saved. Type continue to pick up where it stopped.`));
+    }
     print(chalk.gray(`   Session: ${input.session.id}`));
     if (input.streamFilePath) {
         print(chalk.gray(`   Stream:  ${input.streamFilePath}`));

package/dist/repl.js

@@ -1380,11 +1380,18 @@ export async function runRepl(opts) {
                 });
             }
             catch (err) {
-                const { emitError } = await import('./ui/error-emitter.js');
-                emitError({
-                    code: 'RUN_TURN_ERROR',
-                    title: 'Turn failed',
-                    body: err.message,
+                // 2026-09-24 — print the turn-error block INTO the conversation (it
+                // stays on screen) instead of the overlay box that vanished after 5 s
+                // — a customer's dropped turn left no trace of what happened or what
+                // to do. Same block classic mode prints; in-session it leads with
+                // "type continue" (the partial turn is already saved).
+                const { renderTurnError } = await import('./agent/turn-error-ux.js');
+                await renderTurnError({
+                    err,
+                    session,
+                    userInterrupted: currentTurnAbort?.signal.aborted ?? false,
+                    inSession: true,
+                    print: (line) => chunkEmitter.emit('chunk', line + '\n'),
                 });
             }
             finally {
@@ -2942,6 +2949,7 @@ export async function runRepl(opts) {
                 err,
                 session,
                 userInterrupted: interruptedByUser,
+                inSession: true,
                 print: (line) => console.error(line),
             });
         }

package/dist/skills/bundled-skills.js

@@ -1,6 +1,6 @@
 // GENERATED FILE — bundled skills for local mode.
 // Source: https://manifest.cspeach.dev/v1.json
-// Generated: 2026-09-24T14:23:23.324Z
+// Generated: 2026-09-24T16:31:52.103Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.16",
+  "version": "1.1.17",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",