@cspeach/cli 1.1.16 → 1.1.18

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/tool-dispatch.js

@@ -31,7 +31,12 @@ export async function dispatchTool(name, args, ctx) {
     // GUIDE.md) — local scratch, not SAP objects. Rule 8 protects SAP batches;
     // applying it here made the 2nd+ file (GUIDE.md) hit the batch card and,
     // headless, get refused. Exempt from the gate AND from the batch count.
-    const scratchWrite = isScratchOutputWrite(tool, args, ctx.cwd);
+    // Local project work (owner decision 2026-09-25, CAP spike F2): the same
+    // reasoning for ALL local work — file edits (the filesystem tools refuse any
+    // path outside the project) and the safelisted local build commands. One-shot
+    // refused the 2nd edit of a CAP schema and left it half-changed. SAP writes
+    // are gated exactly as before.
+    const scratchWrite = isLocalProjectWork(tool, args) || isScratchOutputWrite(tool, args, ctx.cwd);
     if (tool.isMutating && !scratchWrite && shouldGateRule8()) {
         const r = await presentSafetyConfirmation({
             rule: 'RULE_8_BATCH_PLAN',
@@ -83,6 +88,22 @@ export async function dispatchTool(name, args, ctx) {
         return { content: JSON.stringify({ error: String(err) }), is_error: true };
     }
 }
+/**
+ * True for local project work: the filesystem tools (confined to the project
+ * folder by resolveSafePath) and shell_exec (a hardcoded safelist of local build
+ * and VCS commands run in the project). Neither touches an SAP object, which is
+ * what Rule 8 protects — EXCEPT a deploy or publish: `npm run deploy` /
+ * `ui5 deploy` / `fiori deploy` upload to the ABAP repository, so any shell
+ * command with a deploy/publish argument still counts (deliberately broad).
+ */
+export function isLocalProjectWork(tool, args) {
+    if (tool.category === 'filesystem')
+        return true;
+    if (tool.category !== 'shell')
+        return false;
+    const argv = [args?.command, ...(Array.isArray(args?.args) ? args.args : [])].map((a) => String(a ?? ''));
+    return !argv.some((a) => /deploy|publish/i.test(a));
+}
 /**
  * True for a mutating filesystem tool whose target sits under the project's
  * own ./cspeach-out/ (cwd). Accepts `cspeach-out/…`, `./cspeach-out/…`, the

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-25T16:38:47.082Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {

package/dist/skills/signing-public-key.js

@@ -1,4 +1,4 @@
 // GENERATED FILE — do not edit by hand.
 // Build artifact: ed25519 public key for SKILL.md body verification.
 // Regenerated by `pnpm prebuild` on each release.
-export const MANIFEST_PUBLIC_KEYS = ['a7Qj8ibfLTj49kQRTn1DOE/UAExuoBgjhaXxf33+JPY='];
+export const MANIFEST_PUBLIC_KEYS = ['Nexqg3TSUYzVPirLv6h1tbCmpQF7MbAtVDmqoLAie+8=', 'a7Qj8ibfLTj49kQRTn1DOE/UAExuoBgjhaXxf33+JPY='];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
@@ -52,7 +52,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.90.0",
     "@cspeach/register-core": "0.1.0",
-    "@cspeach/sap-client": "0.1.12",
+    "@cspeach/sap-client": "0.1.13",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",