@cspeach/cli 1.1.51 → 1.1.53

package/dist/agent/maybe-build-project-context.js

@@ -30,7 +30,7 @@
  *    Phase 3. Today the cache is process-lifetime; users get a fresh
  *    context next CLI invocation.
  */
-import { getProjectContext, renderProjectContext } from '../project-context/index.js';
+import { getProjectContext, renderProjectContextCapped } from '../project-context/index.js';
 /**
  * The env-var name that gates this enrichment. Treated case-insensitively
  * but value comparison is exact ("on" only — anything else is OFF).
@@ -70,6 +70,8 @@ export function resetProjectContextCache() {
 export function __resetProjectContextCacheForTests() {
     resetProjectContextCache();
 }
+/** The one plain line shown when the folder picture was shortened. */
+export const PROJECT_CONTEXT_CUT_LINE = 'This folder is very large, so we work from a shortened picture of it.';
 /**
  * Returns the rendered <project_context> block for splicing into the
  * user message, or '' when the flag is off / no context was detectable.
@@ -94,7 +96,14 @@ export async function maybeBuildProjectContext(options) {
         const ctx = await getProjectContext(options.cwd, {
             sapConnection: options.sapConnection ?? null,
         });
-        cachedBlock = ctx ? renderProjectContext(ctx) : '';
+        const rendered = ctx ? renderProjectContextCapped(ctx) : { block: '', cut: false };
+        cachedBlock = rendered.block;
+        if (rendered.cut) {
+            try {
+                options.emit?.(PROJECT_CONTEXT_CUT_LINE);
+            }
+            catch { /* a display failure never drops the block */ }
+        }
     }
     catch (err) {
         // getProjectContext is documented as never-throws; reaching this

package/dist/agent/provider-shape.js

@@ -1,5 +1,5 @@
 import { TOOL_CHANGES_BETA, isToolSearchEntry } from '../tools/tool-loading.js';
-import { DELEGATE_SKILL_HEADER } from './system-prompt.js';
+import { DELEGATE_SKILL_HEADER, SKILL_INLINE_HEADER } from './system-prompt.js';
 import { STYLE_HEADER } from './style.js';
 import { LEVEL_HEADER } from './level.js';
 /** Betas the proxy sends on every managed turn (messages.ts `betas: [...]`). */
@@ -270,14 +270,14 @@ export function withoutInternalHeaders(headers) {
 /**
  * Task 9 — the role header is new proxy plumbing; AI-hub keeps today's header
  * set, so X-CSPeach-Model-Role (and, 2026-10-04, the delegate header; and,
- * 2026-10-17, the talking-style and level headers — applied locally) are
- * removed.
+ * 2026-10-17, the talking-style and level headers — applied locally; and,
+ * Stage 1A, the inline header — applied locally) are removed.
  */
 export function withoutRoleHeader(headers) {
     const out = {};
     for (const [k, v] of Object.entries(headers ?? {})) {
         const lk = k.toLowerCase();
-        if (lk === 'x-cspeach-model-role' || lk === DELEGATE_SKILL_HEADER.toLowerCase() || lk === STYLE_HEADER.toLowerCase() || lk === LEVEL_HEADER.toLowerCase())
+        if (lk === 'x-cspeach-model-role' || lk === DELEGATE_SKILL_HEADER.toLowerCase() || lk === STYLE_HEADER.toLowerCase() || lk === LEVEL_HEADER.toLowerCase() || lk === SKILL_INLINE_HEADER.toLowerCase())
             continue;
         out[k] = v;
     }
@@ -291,6 +291,10 @@ export function headersForProfile(profile, headers) {
         case 'none': return { ...(headers ?? {}) };
     }
 }
+/** Stage 1A — true when the loop sent X-CSPeach-Skill-Inline: '1' (a direct provider then builds the one block locally). */
+export function skillInlineFromHeaders(options) {
+    return options.headers?.[SKILL_INLINE_HEADER] === '1';
+}
 /** 2026-10-04 — the plan phase's delegate skill, when the loop sent one. */
 export function delegateSkillName(options) {
     const v = options.headers?.[DELEGATE_SKILL_HEADER];

package/dist/agent/providers/ai-hub-provider.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import keychain from '../../auth/keychain.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, requireSkillName, toLegacyShape, withoutRoleHeader } from '../provider-shape.js';
+import { delegateSkillName, requireSkillName, skillInlineFromHeaders, toLegacyShape, withoutRoleHeader } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -28,7 +28,7 @@ export function createAiHubProvider(cfg, getBearer = defaultBearer) {
             const skillName = requireSkillName(options, 'AI Hub');
             const token = await getToken();
             // Task 18 — the `_reader` header uses the pinned reader prompt, no lookup.
-            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: AI_HUB_PROFILE.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: AI_HUB_PROFILE.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
             const request = {
                 ...toLegacyShape(params),
                 system,

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

@@ -15,7 +15,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import { sendsEffortFor } from '../connection-profile.js';
 import { AZURE_PROFILE } from '../azure-profile.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, headersForProfile, requireSkillName, withoutToolChanges, withSkillPrompt } from '../provider-shape.js';
+import { delegateSkillName, headersForProfile, requireSkillName, skillInlineFromHeaders, withoutToolChanges, withSkillPrompt } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -66,7 +66,7 @@ export function createAzureProvider(cfg, getBearer = defaultBearer, deps = {}) {
             throw new AzureConnectionRefusedError(v.message);
         const conn = cached.connection;
         const skillName = requireSkillName(options, 'Azure');
-        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: profile.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: profile.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
         const base = profile.toolChanges ? params : withoutToolChanges(params);
         const family = familyFromTable(params.model, conn.deployments);
         const body = withAzureEffort(shapeForAzure(withSkillPrompt(base, system, { cacheMarkers: profile.cacheMarkers }), profile), profile, roleOf(options.headers), family);

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

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import keychain from '../../auth/keychain.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, modelAcceptsFallbacks, requiredBetas, requireSkillName, withoutInternalHeaders, withSkillPrompt } from '../provider-shape.js';
+import { delegateSkillName, skillInlineFromHeaders, modelAcceptsFallbacks, requiredBetas, requireSkillName, withoutInternalHeaders, withSkillPrompt } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -21,7 +21,7 @@ export function createByokProvider(cfg, getBearer = defaultBearer) {
         const skillName = requireSkillName(options, 'BYOK');
         const key = await getKey();
         // Task 18 — the `_reader` header uses the pinned reader prompt, no lookup.
-        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: BYOK_PROFILE.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: BYOK_PROFILE.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
         // Task 6 — opt into server-side fallback, only for the families probe
         // P3 proved (allow-list); requiredBetas adds its beta.
         const prompted = withSkillPrompt(params, system, { cacheMarkers: BYOK_PROFILE.cacheMarkers });

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

@@ -2,7 +2,7 @@
 const loadOpenAI = async () => (await import('openai')).default;
 import crypto from 'node:crypto';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, requireSkillName } from '../provider-shape.js';
+import { delegateSkillName, requireSkillName, skillInlineFromHeaders } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -29,7 +29,7 @@ export function createLocalProvider(cfg, getBearer = defaultBearer) {
             // message (no cache markers). anthropicParamsToOpenAI copies only
             // max_tokens / messages / system, so newer fields never reach the endpoint.
             const skillName = requireSkillName(options, 'Local');
-            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: false }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: false, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
             const OpenAI = await loadOpenAI();
             const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
             const openAiParams = anthropicParamsToOpenAI({ ...params, system }, model);

package/dist/agent/repair-partial.js

@@ -204,6 +204,27 @@ export function isPartialJsonApiError(err) {
 /** 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.';
+/**
+ * LT-15 D6 — result text for a tool call stopped (Esc / Ctrl+C) at a point
+ * where the tool KNOWS nothing ran yet: before its card, its WAL entry and any
+ * SAP change. Same shape and flags as INTERRUPTED_TOOL_RESULT (is_error: true).
+ */
+export const STOPPED_BEFORE_START_RESULT = 'This tool call was stopped before anything ran — no change was made in SAP. Ask again if it is still needed.';
+/**
+ * 1.1.53 item 10 — the dim line shown when healOrphanToolUses closed off steps
+ * cut by an earlier stop. Plain words for the person; no internals.
+ */
+export function closedOffStepsLine(n) {
+    return n === 1
+        ? '(we closed off a step that was stopped earlier)'
+        : `(we closed off ${n} steps that were stopped earlier)`;
+}
+/**
+ * LT-15 D6 (review M5) — the same, for the write pipeline's second guard: by
+ * then the approval was spent and SAP was read (a local snapshot may exist),
+ * but the change itself was not made. Same shape and flags.
+ */
+export const STOPPED_BEFORE_WRITE_RESULT = 'This tool call was stopped before the change was made — nothing was written to SAP. Ask again if it is still needed.';
 /**
  * 2026-09-24 — heal tool_use blocks that have no tool_result after them.
  *

package/dist/agent/skill-block-key.js

@@ -0,0 +1,134 @@
+/**
+ * Stage 1A, Task 1A.2 fix round 1 — the per-install key that proves a
+ * `<skill>` block in the history was written by this CLI.
+ *
+ * A content hash proves only that a block agrees with itself: anyone can
+ * compute sha256(body). So each block the loop writes also carries an
+ * HMAC-SHA256 tag keyed by a random 32-byte secret kept under the CSPeach
+ * home (`<home>/skill-block.key`, 0600 on POSIX, CSPEACH_HOME respected).
+ * Only a block whose tag verifies counts as loaded.
+ *
+ * - The key is created on the first WRITE of a block (`skillBlockKeyForWrite`),
+ *   never by a read: a process that never runs inline creates no file.
+ * - A missing or unreadable key means nothing verifies: the body is simply
+ *   sent again (cost only, never a failed turn).
+ * - A resumed session on the same install still verifies. On another machine
+ *   (another key) every block reads as not loaded, is neutralised in place,
+ *   and each body is sent once more.
+ */
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+const KEY_FILE = 'skill-block.key';
+const KEY_HEX = /^[0-9a-f]{64}$/;
+/** Keys found or made in this process, by the file they live in. */
+const cache = new Map();
+/** Test seam: a fixed key (Buffer), no key (null), or the real file (undefined). */
+let override;
+function keyPath() {
+    return path.join(cspeachRoot(), KEY_FILE);
+}
+function readKeyFile(p) {
+    try {
+        const hex = fs.readFileSync(p, 'utf-8').trim();
+        return KEY_HEX.test(hex) ? Buffer.from(hex, 'hex') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The key, if this install has one. Never creates it. */
+export function skillBlockKeyForRead() {
+    if (override !== undefined)
+        return override;
+    const p = keyPath();
+    const hit = cache.get(p);
+    if (hit)
+        return hit;
+    const k = readKeyFile(p);
+    if (k)
+        cache.set(p, k);
+    return k;
+}
+function chmod600(p) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        fs.chmodSync(p, 0o600);
+    }
+    catch { /* best effort */ }
+}
+/**
+ * The key, made on first use. A key file that exists but is not a 32-byte hex
+ * key (corrupt, truncated) is REPLACED here, atomically (temp file + rename),
+ * with one debug line, so inline turns do not re-send bodies forever. Only
+ * this write path creates or replaces the file; reads never do. null when it
+ * cannot be written (the block then never verifies: cost only).
+ */
+export function skillBlockKeyForWrite() {
+    if (override !== undefined)
+        return override;
+    const existing = skillBlockKeyForRead();
+    if (existing)
+        return existing;
+    const p = keyPath();
+    const fresh = `${randomBytes(32).toString('hex')}\n`;
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        if (!fs.existsSync(p)) {
+            // First use. 'wx': another process making it at the same time wins.
+            fs.writeFileSync(p, fresh, { encoding: 'utf-8', mode: 0o600, flag: 'wx' });
+            chmod600(p);
+        }
+        else {
+            const tmp = `${p}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+            try {
+                fs.writeFileSync(tmp, fresh, { encoding: 'utf-8', mode: 0o600 });
+                chmod600(tmp);
+                fs.renameSync(tmp, p);
+            }
+            finally {
+                try {
+                    fs.unlinkSync(tmp);
+                }
+                catch { /* renamed */ }
+            }
+            if (process.env['CSPEACH_DEBUG'] === '1') {
+                process.stderr.write(`[inline] the skill block key at ${p} was not readable; a new key replaced it (earlier blocks are sent again once)\n`);
+            }
+        }
+    }
+    catch {
+        // Another process made it first (EEXIST), or the home is not writable:
+        // read whatever is there now.
+    }
+    return skillBlockKeyForRead();
+}
+/** HMAC-SHA256 (hex) of the parts, joined with NUL. '' when there is no key. */
+export function skillBlockTag(key, parts) {
+    if (!key)
+        return '';
+    return createHmac('sha256', key).update(parts.join('\0'), 'utf8').digest('hex');
+}
+/** Constant-time comparison of two hex tags; a length difference (or a missing tag) is simply false. */
+export function skillBlockTagsEqual(a, b) {
+    const x = Buffer.from(a, 'hex');
+    const y = Buffer.from(b, 'hex');
+    if (x.length === 0 || x.length !== y.length)
+        return false;
+    return timingSafeEqual(x, y);
+}
+/** A short id of the key in use ('none' without one), so a saved scan is redone when the key changes. */
+export function skillBlockKeyId(key) {
+    return key ? createHmac('sha256', key).update('id').digest('hex').slice(0, 16) : 'none';
+}
+/** Test seam. */
+export function __setSkillBlockKeyForTests(k) {
+    override = k;
+    cache.clear();
+}
+/** Test seam: forget keys read in this process (the file stays). */
+export function __clearSkillBlockKeyCache() {
+    cache.clear();
+}

package/dist/agent/steering-queue.js

@@ -1,27 +1,63 @@
-/**
- * Mid-turn steering queue (2026-06-08).
- *
- * While a turn is in flight the user can type a correction and press Enter;
- * the Footer enqueues it here instead of bouncing it. The agent loop drains
- * this at each round boundary and injects the text as a user message before
- * the next createStream, so the model reads the correction and adapts —
- * CC-style "type any time". Module-level singleton, mirroring the
- * pendingDispatch accessor pattern; there is exactly one interactive REPL
- * turn loop at a time.
- */
 const queue = [];
+const listeners = new Set();
+/** Tell every listener the queue changed. A listener that throws is ignored. */
+function notify() {
+    if (listeners.size === 0)
+        return;
+    const snap = steeringSnapshot();
+    for (const fn of [...listeners]) {
+        try {
+            fn(snap);
+        }
+        catch { /* a UI listener must never break the queue */ }
+    }
+}
 /** Add a steer. Trims; ignores empty / whitespace-only input. */
-export function enqueueSteering(text) {
+export function enqueueSteering(text, opts) {
     const t = text.trim();
     if (t.length === 0)
         return;
-    queue.push(t);
+    queue.push({ text: t, alreadyRead: opts?.alreadyRead === true });
+    notify();
 }
 /** Return all queued steers (FIFO) and clear the queue. */
 export function drainSteering() {
-    return queue.splice(0, queue.length);
+    return drainSteeringEntries().map((e) => e.text);
+}
+/** LT-15 Task 4 — drain with each message's already-read mark (the loop's round top). */
+export function drainSteeringEntries() {
+    const out = queue.splice(0, queue.length);
+    if (out.length > 0)
+        notify();
+    return out;
+}
+/** LT-15 Task 4 — drain every waiting message as one text (joined with newlines), or null. */
+export function drainSteeringText() {
+    const all = drainSteering();
+    return all.length > 0 ? all.join('\n') : null;
 }
 /** True when at least one steer is queued. */
 export function hasSteering() {
     return queue.length > 0;
 }
+/** A copy of the waiting messages (FIFO). Changing it never changes the queue. */
+export function steeringSnapshot() {
+    return queue.map((e) => e.text);
+}
+/** Take back the LAST waiting message, or null when nothing waits. */
+export function withdrawLastSteering() {
+    if (queue.length === 0)
+        return null;
+    const t = queue.pop();
+    notify();
+    return t.text;
+}
+/**
+ * Call `fn` with a fresh snapshot after every change (enqueue, drain,
+ * withdraw). Not called for a change that changed nothing. Returns the
+ * unsubscribe function.
+ */
+export function subscribeSteering(fn) {
+    listeners.add(fn);
+    return () => { listeners.delete(fn); };
+}

package/dist/agent/system-prompt.js

@@ -12,8 +12,15 @@ import { READER_SKILL, READER_SYSTEM_PROMPT } from '../tools/subagent/reader-pro
 import { CHAT_SKILL, CHAT_SYSTEM_PROMPT } from './chat-prompt.js';
 import { appendStyleText, DEFAULT_STYLE } from './style.js';
 import { appendLevelText, DEFAULT_LEVEL } from './level.js';
+import { CONVERSATION_SYSTEM_PROMPT } from './conversation-prompt.js';
 /** 2026-10-04 (continuous run) — the phase's delegate skill travels as this header. */
 export const DELEGATE_SKILL_HEADER = 'X-CSPeach-Delegate-Skill';
+/**
+ * Stage 1A, Task 1A.2 — '1' on a main call of an inline session: the system
+ * block is the one conversation prompt and the playbook rides in the
+ * conversation as a <skill> block (agent/inline-skill-block.ts).
+ */
+export const SKILL_INLINE_HEADER = 'X-CSPeach-Skill-Inline';
 /** The line that tells the model how the two bodies relate. Same text in cspeach-proxy. */
 export function delegatePreface(name) {
     return `This plan step is delegated to the ${name} playbook below. Follow it for HOW to build. `
@@ -54,6 +61,14 @@ export function buildChatSystemPrompt(opts, style = DEFAULT_STYLE, level = DEFAU
     // D-K order: style, then level, one block.
     return appendLevelText(appendStyleText([{ type: 'text', text: CHAT_SYSTEM_PROMPT, ...marker }], style), level);
 }
+/**
+ * Stage 1A — the inline session's one system block: the conversation prompt,
+ * then style, then level, in one block (the same order as the chat prompt).
+ */
+export function buildConversationSystemPrompt(opts, style = DEFAULT_STYLE, level = DEFAULT_LEVEL) {
+    const marker = opts.cacheMarkers ? { cache_control: { type: 'ephemeral' } } : {};
+    return appendLevelText(appendStyleText([{ type: 'text', text: CONVERSATION_SYSTEM_PROMPT, ...marker }], style), level);
+}
 /**
  * The system prompt for the skill named in the X-CSForge-Skill header, plus —
  * on a plan phase turn — the delegate playbook named in X-CSPeach-Delegate-Skill.
@@ -65,10 +80,17 @@ export function buildChatSystemPrompt(opts, style = DEFAULT_STYLE, level = DEFAU
  * reader (which reports facts) never gets style. A non-default `level`
  * (§10 D14) follows the style text; developer changes nothing; a reader never
  * gets it.
+ *
+ * Stage 1A — `opts.inline` (the call carried X-CSPeach-Skill-Inline): one
+ * block, the conversation prompt, plus style and level, for every skill name
+ * but `_reader`. No body is fetched (the loop put it in the conversation) and
+ * the delegate is not composed. Absent or false: today's three cases.
  */
 export async function systemPromptForSkill(skillName, skillSource, opts, delegateName, style = DEFAULT_STYLE, level = DEFAULT_LEVEL) {
     if (skillName === READER_SKILL)
         return buildReaderSystemPrompt(opts);
+    if (opts.inline === true)
+        return buildConversationSystemPrompt(opts, style, level);
     if (skillName === CHAT_SKILL)
         return buildChatSystemPrompt(opts, style, level);
     const skill = await skillSource.getSkillBody(skillName);

package/dist/agent/tool-dispatch.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { getTool, isStandalone } from '../tools/index.js';
 import { NOT_CONNECTED_MESSAGE } from '../sap/offline-adt-client.js';
 import { unreachableCode } from '../sap/unreachable.js';
-import { noteSapUnreachable, unreachableCodeInText, SAP_UNREACHABLE_DIRECTIVE } from '../sap/reachability-state.js';
+import { noteSapUnreachable, unreachableCodeInText, SAP_UNREACHABLE_DIRECTIVE, SAP_UNREACHABLE_NOTE } from '../sap/reachability-state.js';
 import { isPlanPhaseActive } from '../commands/plan-gate.js';
 import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
 import { shouldGateRule8, recordWriteOp, renderPlanSummary, getWriteOpsThisTurn, } from '../repl/rule8-detector.js';
@@ -10,7 +10,7 @@ import { isCredentialHandoverApproved, markCredentialHandoverApproved, } from '.
 import { READER_TOOLS } from '../tools/subagent/reader-prompt.js';
 import { riskOf } from './risk-gate.js';
 import { NOT_ON_THIS_RELEASE, gateWithVerify } from '../sap/profile-gate.js';
-import { INTERRUPTED_TOOL_RESULT } from './repair-partial.js';
+import { INTERRUPTED_TOOL_RESULT, STOPPED_BEFORE_START_RESULT } from './repair-partial.js';
 import { WRITE_TOOLS } from '../tools/write-mode.js';
 const READER_TOOL_SET = new Set(READER_TOOLS);
 /** Chat lane (spec 2026-10-17 D4) — the model-facing reason; names hand_off. */
@@ -113,8 +113,12 @@ export async function dispatchTool(name, args, ctx) {
     }
     // Final review I-3 — the D11 re-check can take seconds of SAP reads; an Esc
     // in that window must stop the call here, not let the handler run "as unknown".
-    if (ctx.signal?.aborted)
-        return { content: INTERRUPTED_TOOL_RESULT, is_error: true };
+    // 1.1.53 item 10 — the handler has not run (the gate only reads). A tool
+    // that cannot change SAP (hand_off, reads, local files) says so plainly; a
+    // tool that can change SAP keeps the "effect unknown, check" safety text.
+    if (ctx.signal?.aborted) {
+        return { content: isChatRefusedTool(tool) ? INTERRUPTED_TOOL_RESULT : STOPPED_BEFORE_START_RESULT, is_error: true };
+    }
     // L1-6 R1-6 (owner decision 2026-09-21) — a call that hands the stored SAP
     // login to a local child process ALWAYS asks a human, once per session per
     // alias, even as the first mutating call of a turn (where Rule 8 below stays
@@ -133,6 +137,11 @@ export async function dispatchTool(name, args, ctx) {
             is_error: true,
         };
     }
+    // LT-15 D6 (review M1) — the handover check above can await file reads; a
+    // stop there opens no handover, risky-command or Rule 8 card, and the
+    // handler never runs.
+    if (ctx.signal?.aborted)
+        return { content: STOPPED_BEFORE_START_RESULT, is_error: true };
     const sessionId = ctx.session?.id;
     if (handover && !isCredentialHandoverApproved(sessionId, handover.alias, handover.scope)) {
         const r = await presentSafetyConfirmation({
@@ -210,22 +219,29 @@ export async function dispatchTool(name, args, ctx) {
         // 2026-10-04 (continuous run, spec §3.5) — a SAP tool that failed because
         // SAP is not reachable from this machine: note it (the REPL pauses the
         // plan after the turn) and tell the model to stop without a manifest.
-        // Only inside a plan step: elsewhere the error text stays as it is.
-        if (tool.requiresSap && (result.is_error ?? false) && isPlanPhaseActive()) {
+        // Only inside a plan step. LT-14 (1A fix wave): elsewhere a short note
+        // rides on the error (no pause, no flag), so the model never invents
+        // network advice for the person.
+        if (tool.requiresSap && (result.is_error ?? false)) {
             const code = unreachableCodeInText(result.content);
-            if (code) {
+            if (code && isPlanPhaseActive()) {
                 noteSapUnreachable(code);
                 return { content: `${result.content}\n\n${SAP_UNREACHABLE_DIRECTIVE}`, is_error: true };
             }
+            if (code)
+                return { content: `${result.content}\n\n${SAP_UNREACHABLE_NOTE}`, is_error: true };
         }
         return { content: result.content, is_error: result.is_error ?? false };
     }
     catch (err) {
-        const code = tool.requiresSap && isPlanPhaseActive() ? (unreachableCode(err) ?? unreachableCodeInText(String(err))) : null;
-        if (code) {
+        const code = tool.requiresSap ? (unreachableCode(err) ?? unreachableCodeInText(String(err))) : null;
+        if (code && isPlanPhaseActive()) {
             noteSapUnreachable(code);
             return { content: JSON.stringify({ error: String(err), sap_unreachable: true, directive: SAP_UNREACHABLE_DIRECTIVE }), is_error: true };
         }
+        // LT-14 — outside a plan step: the short note only.
+        if (code)
+            return { content: JSON.stringify({ error: String(err), note: SAP_UNREACHABLE_NOTE }), is_error: true };
         return { content: JSON.stringify({ error: String(err) }), is_error: true };
     }
 }

package/dist/agent/turn-watchdog.js

@@ -42,7 +42,7 @@ export function evaluateWatchdog(input, now = Date.now()) {
     if (!input.config.enabled || input.alreadyWarned) {
         return { shouldWarn: false, reason: '', message: '' };
     }
-    const elapsedMs = Math.max(0, now - input.startedAt);
+    const elapsedMs = Math.max(0, now - input.startedAt - Math.max(0, input.pausedMs ?? 0));
     const wallExceeded = elapsedMs >= input.config.wallBudgetMs;
     const tokensExceeded = input.outputTokensThisTurn >= input.config.tokenBudget;
     if (!wallExceeded && !tokensExceeded) {

package/dist/approvals/advisory-render.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { paint } from '../renderer/theme.js';
 import { uiWidth } from '../renderer/ui-width.js';
 import { sanitizeControlChars as clean } from '../renderer/sanitize.js';
+import { getBoxChars, DOUBLE_BOX } from '../ui/ascii-chars.js';
 const ADVISORY_TITLE = ' ADVISORY MODE — proposed change (no SAP write will occur) ';
 export const ADVISORY_KEY_HINT = 'Press c to copy to clipboard, y when applied, s to skip, n to abort.';
 export function renderAdvisoryProposal(args, opts = {}) {
@@ -12,9 +13,11 @@ export function renderAdvisoryProposal(args, opts = {}) {
     // Borders line up: top and bottom share one width (§1.4 rule, widened
     // only if the title itself would not fit).
     const w = Math.max(uiWidth(), ADVISORY_TITLE.length + 6);
-    const top = '╔══' + ADVISORY_TITLE + '═'.repeat(w - 4 - ADVISORY_TITLE.length) + '╗';
-    const bottom = '╚' + '═'.repeat(w - 2) + '╝';
-    const rule = paint('dim', '─'.repeat(w));
+    // Old Windows console: the classic ASCII frame (getBoxChars), same width.
+    const b = getBoxChars(DOUBLE_BOX);
+    const top = b.tl + b.h + b.h + ADVISORY_TITLE + b.h.repeat(w - 4 - ADVISORY_TITLE.length) + b.tr;
+    const bottom = b.bl + b.h.repeat(w - 2) + b.br;
+    const rule = paint('dim', getBoxChars().h.repeat(w));
     displayParts.push(chalk.bold(paint('warn', top)));
     displayParts.push(chalk.bold(`Summary: ${clean(args.summary)}`));
     displayParts.push(`Risk: ${args.risk}`);

package/dist/approvals/approval-prompt.js

@@ -6,14 +6,19 @@ import { uiWidth } from '../renderer/ui-width.js';
 import { paint } from '../renderer/theme.js';
 import { emitTrace } from '../renderer/trace.js';
 import { askConfirm } from '../ui/confirm-request.js';
+import { getBoxChars, SQUARE_BOX } from '../ui/ascii-chars.js';
 // Classic box: width from the §1.4 rule (was a fixed 62); padding counts
 // VISIBLE cells (string-width ignores ANSI) so coloured rows line up with
 // plain ones. (strip-ansi is a devDependency only — not usable here.)
+// Old Windows console: the classic ASCII frame (getBoxChars), same width.
 const boxWidth = () => uiWidth() - 2;
-const top = () => '┌' + '─'.repeat(boxWidth()) + '┐';
-const bottom = () => '└' + '─'.repeat(boxWidth()) + '┘';
-const pad = (s) => '│  ' + s + ' '.repeat(Math.max(0, boxWidth() - 2 - stringWidth(s))) + '│';
-const blank = () => '│' + ' '.repeat(boxWidth()) + '│';
+const top = () => { const b = getBoxChars(SQUARE_BOX); return b.tl + b.h.repeat(boxWidth()) + b.tr; };
+const bottom = () => { const b = getBoxChars(SQUARE_BOX); return b.bl + b.h.repeat(boxWidth()) + b.br; };
+const pad = (s) => {
+    const b = getBoxChars(SQUARE_BOX);
+    return b.v + '  ' + s + ' '.repeat(Math.max(0, boxWidth() - 2 - stringWidth(s))) + b.v;
+};
+const blank = () => { const b = getBoxChars(SQUARE_BOX); return b.v + ' '.repeat(boxWidth()) + b.v; };
 /**
  * Capture a single keypress for the y/n/d answer. Raw-mode readline so the
  * hand-drawn box stays the only visible affordance.

package/dist/approvals/op-labels.js

@@ -3,6 +3,7 @@ import { sanitizeControlChars } from '../renderer/sanitize.js';
 import { wrapRows } from '../renderer/wrap-rows.js';
 import { shownUpTo } from '../register/atc-file.js';
 import { transportForWrite } from '../register/project-transport.js';
+import { decodeDisplayEntities, decodeDisplayBlock } from '../renderer/html-entities.js';
 /**
  * Human-readable operation + object labels for the approval surfaces.
  *
@@ -71,6 +72,20 @@ export function humanType(type) {
         return type;
     return type.toLowerCase();
 }
+/** LT-10 (1A fix wave) — the word for a known type code ('CLAS/OC' -> 'class'); undefined otherwise. */
+export function knownTypeWord(type) {
+    return Object.prototype.hasOwnProperty.call(TYPE_WORDS, typeCode(type)) ? TYPE_WORDS[typeCode(type)] : undefined;
+}
+/**
+ * LT-11 (1A fix wave) — the types that share their view's name on SAP's
+ * generator path. A write to one names its kind ("access control ZR_X"), so
+ * it never reads as a write to the view. Every other type: the name alone.
+ */
+const SHARES_VIEW_NAME = new Set(['DDLX', 'DCLS', 'BDEF']);
+export function writtenObjectName(type, name) {
+    const code = typeCode(type);
+    return SHARES_VIEW_NAME.has(code) ? `${TYPE_WORDS[code]} ${name}` : name;
+}
 /** e.g. "Create table ZMNT_NOTE", "Change class ZCL_X", "Delete table ZOLD". */
 export function verbLine(change) {
     return [humanVerb(change.op), humanType(change.type), change.object]
@@ -89,7 +104,7 @@ export function affectsLine(change) {
     // line comes from the change's op and type, never from a model-supplied field.
     if (change.op === 'delete' && typeCode(change.type) === 'FUGR')
         return FUGR_DELETE_LINE;
-    const t = sanitizeControlChars(String(change.affects ?? '')).trim();
+    const t = decodeDisplayEntities(sanitizeControlChars(String(change.affects ?? ''))).trim();
     return t ? `Affects: ${t}` : null;
 }
 /** Task 7 — the longest behaviour text a card shows, and the most rows it takes. */
@@ -107,7 +122,8 @@ export function behaviourText(change) {
     // shownUpTo drops whole escape sequences first (a lone sanitizeControlChars
     // pass would leave their '[31m' tails), then every control character.
     // The cut counts code points, so it never leaves half a surrogate pair.
-    const flat = Array.from(shownUpTo(String(change.behaviour ?? ''), Number.POSITIVE_INFINITY));
+    // 1.1.53 item 5: entities decode before the cut, so the cut counts what shows.
+    const flat = Array.from(decodeDisplayEntities(shownUpTo(String(change.behaviour ?? ''), Number.POSITIVE_INFINITY)));
     const t = flat.length > BEHAVIOUR_MAX ? `${flat.slice(0, BEHAVIOUR_MAX).join('')}…` : flat.join('');
     if (!t || NOTHING_CHANGES.test(t))
         return null;
@@ -195,7 +211,8 @@ export function displayTransport(op, explicit, session, owning, project) {
  * modal's [v] view and the classic prompt's View source branch.
  */
 export function toSourceLines(content) {
-    return content
+    // 1.1.53 item 5: display decode of the whole block (kept as written when it has a raw field symbol or markup).
+    return decodeDisplayBlock(content)
         .split('\n')
         .filter((l) => !l.startsWith('@@') && !l.startsWith('+++') && !l.startsWith('---'))
         .map((l) => l.replace(/^[+-] ?/, ''));