@cspeach/cli 0.8.0 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # CSPeach
 
-AI-assisted ABAP development CLI. 34 skills, direct SAP access, safety
+AI-assisted ABAP development CLI. 35 skills, direct SAP access, safety
 gates the model cannot bypass.
 
 ## Install

package/dist/agent/intent-system-prompt.js

@@ -19,7 +19,7 @@ You help senior SAP consultants and ABAP developers plan, build, modernize, migr
 - Live access to the user's SAP system via the sap_* tool family (~30 tools — get_source, set_source, atc_run, transport_create, sql_query, snapshot_take, etc.).
 - Filesystem + shell + web access to the project the user is working in (file_read, file_edit, file_write, glob, grep, shell_exec, web_fetch, web_search).
 - Subagent dispatch (agent_run) for focused sub-tasks; background_run + monitor_emit for non-blocking processes; schedule_draft_create for persisting schedule envelopes (no runner yet — see tool description).
-- A library of 34 SAP-development playbooks you can read on demand via playbook_get. These cover RAP scaffolding, S/4HANA upgrade remediation, CCA estate analysis, modernization, code review, performance triage, and more. When you need expertise on a specific workflow, fetch the relevant playbook BEFORE acting.
+- A library of 35 SAP-development playbooks you can read on demand via playbook_get. These cover RAP scaffolding, S/4HANA upgrade remediation, CCA estate analysis, modernization, code review, performance triage, and more. When you need expertise on a specific workflow, fetch the relevant playbook BEFORE acting.
 - The project context for this session (CDS views, tables, packages, conventions) — appended below if available.
 
 When the user states an intent, your job is:

package/dist/agent/loop.js

@@ -1,29 +1,35 @@
 import chalk from 'chalk';
 import { basename } from 'node:path';
 import { dispatchTool } from './tool-dispatch.js';
-import { listTools, toAnthropicTools } from '../tools/index.js';
+import { listTools, getTool, toAnthropicTools } from '../tools/index.js';
 import { saveSession } from '../session/store.js';
+import { recordCompletedToolCall } from '../session/pending.js';
 import { loadConfig } from '../config/loader.js';
 import { retryWithBackoff } from './retry.js';
 import { renderChunk, initialBufferState, render } from '../renderer/pipeline.js';
 import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner } from '../renderer/tool-widget.js';
 import { formatToolErrorSummary } from '../sap-errors/parse-adt-exception.js';
 import { startThinkingHeartbeat } from '../renderer/thinking-heartbeat.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.
+import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
 // (progress-chatter import removed 2026-05-01 — superseded by CC-style
 //  two-line dispatch renderer; re-add if a future in-place spinner returns)
 import { buildRetryCapPausePayload, buildSkippedSiblingResults } from './retry-cap.js';
 import { appendCostLine, buildEntry as buildCostEntry } from '../cost/cost-log.js';
 import { lastAssistantIsAwaitingAnswer } from '../session/awaiting-answer.js';
 import { enrichUserMessage } from '../router/intent-extractor.js';
-import { resetRule8State } from '../repl/rule8-detector.js';
-import { runSaveCommand, runPromoteCommand } from '../projects/index.js';
-import { parseFromFlag } from '../skills/promotion-dispatch.js';
+import { resetRule8State, shouldGateRule8 } from '../repl/rule8-detector.js';
+import { runSaveCommand, runPromoteCommand, detectArtifactSkill, offerAnswerBlockers } from '../projects/index.js';
+import { parseFromFlag, coerceDocFromFlagToAttachment } from '../skills/promotion-dispatch.js';
 import { input } from '@inquirer/prompts';
 import { withInquirer } from '../repl/inquirer-guard.js';
 import { expandTextFileAttachments } from '../projects/workspace.js';
 import { getSapSystemInfo, renderSapSystemBlock } from '../sap/system-info.js';
 import { objectKeyFromInput } from './retry-key.js';
 import { repairPartialBlocks, healSessionMessagesInPlace, isPartialJsonApiError } from './repair-partial.js';
+import { drainSteering } from './steering-queue.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
 import { loadWatchdogConfig, evaluateWatchdog } from './turn-watchdog.js';
@@ -56,7 +62,7 @@ const SAVE_HOOK_SKILLS = new Set([
     // 2026-05-08: upgrade pipeline manifest envelopes. Each emits a
     // <!-- csforge:upgrade-manifest --> block that the matching
     // extract-upgrade.* parser turns into the manifest envelope. The
-    // heavy detail (per-finding data) stays in `.abapforge/upgrades/`,
+    // heavy detail (per-finding data) stays in `.cspeach/upgrades/`,
     // referenced by detail_path inside the envelope.
     'abap-upgrade-scan',
     'abap-upgrade-fix',
@@ -64,7 +70,7 @@ const SAVE_HOOK_SKILLS = new Set([
     'abap-upgrade-merge',
     // 2026-05-09: CCA pipeline manifest envelopes. /abap-cca emits a
     // <!-- csforge:cca-manifest --> block wrapping the heavy project.json
-    // detail at .abapforge/cca/projects/<slug>/. /abap-cca-merge produces
+    // detail at .cspeach/cca/projects/<slug>/. /abap-cca-merge produces
     // a consolidated cca-assessment from N parallel consultant slices.
     'abap-cca',
     'abap-cca-merge',
@@ -73,6 +79,10 @@ const SAVE_HOOK_SKILLS = new Set([
     // and can fan out into further chains after their own envelope saves.
     'abap-modernize',
     'abap-test',
+    // 2026-06-06 B3: /abap-plan create mode emits a csforge:plan-manifest
+    // JSON block → plan envelope. Resume turns set suppressSaveHook so the
+    // revision path in commands/plan-resume.ts persists instead.
+    'abap-plan',
 ]);
 /**
  * True when any user message in the session already carries the rendered
@@ -110,9 +120,21 @@ export function hasProjectContextBlock(messages) {
  *
  * Single shape `(q) => Promise<string>` so it slots straight into the
  * existing `prompt:` callback in runSaveCommand + runPromoteCommand.
+ * Exported for A1 (2026-06-10): repl.tsx reuses it as the consent prompt
+ * for harness-owned plan auto-run (offerNextPhaseAutoRun).
  */
-async function inkAwarePrompt(q) {
-    const { shouldUseInk } = await import('../renderer/tty.js');
+export async function inkAwarePrompt(q) {
+    const { shouldUseInk, isHeadless } = await import('../renderer/tty.js');
+    // B5 (2026-06-11) — headless runs must NEVER block on stdin (defect D1
+    // family). Any prompt that reaches the generic helper in headless mode
+    // takes the conservative default: empty answer (callers treat '' as
+    // decline / skip). Prompts that need a different headless default (e.g.
+    // the artifact-save hook, which defaults YES) install their own
+    // headless-aware prompt BEFORE reaching this helper — see maybeOfferSave.
+    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 result = await askQuestionEmitter.request({
@@ -125,25 +147,117 @@ async function inkAwarePrompt(q) {
     }
     return withInquirer(() => input({ message: q }));
 }
+/**
+ * Choices picker for an answer-blocker that carries `options`. Renders the
+ * native Ink AskQuestionModal (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)
+ * - classic (non-Ink) → 'write' so the caller falls back to the free-text box
+ * - Ink → choice/multi modal; Esc or empty selection → skip
+ *
+ * The two sentinels are filtered out of any real picked answer; for multi-select
+ * the modal returns comma-joined values, so Write/Skip win over any co-selected
+ * options.
+ */
+const CHOOSE_WRITE = '__cspeach_write__';
+const CHOOSE_SKIP = '__cspeach_skip__';
+export async function inkAwareChoose(a) {
+    const { shouldUseInk, isHeadless } = await import('../renderer/tty.js');
+    if (isHeadless())
+        return { kind: 'skip' };
+    if (!shouldUseInk())
+        return { kind: 'write' }; // classic REPL → free-text fallback
+    const choices = [
+        ...a.options.map((o) => ({ value: o, label: o })),
+        { value: CHOOSE_WRITE, label: '✏️  Write my own…' },
+        { value: CHOOSE_SKIP, label: '↷  Skip (leave for the viewer)' },
+    ];
+    const { askQuestionEmitter } = await import('../ui/ask-question-emitter.js');
+    const res = await askQuestionEmitter.request({
+        id: 'answer-blocker',
+        question: `Blocker ${a.index + 1}/${a.total}: ${a.question}`,
+        context: a.multiSelect ? 'Space to toggle one or more · Enter to submit' : undefined,
+        kind: a.multiSelect ? 'multi' : 'choice',
+        choices,
+    });
+    if (res.cancelled || res.answer == null)
+        return { kind: 'skip' };
+    const values = res.answer.split(',');
+    if (values.includes(CHOOSE_WRITE))
+        return { kind: 'write' };
+    if (values.includes(CHOOSE_SKIP))
+        return { kind: 'skip' };
+    const real = values.filter((v) => v !== CHOOSE_WRITE && v !== CHOOSE_SKIP);
+    if (real.length === 0)
+        return { kind: 'skip' };
+    return { kind: 'picked', answer: real.join(', ') };
+}
 export async function maybeOfferSave(p) {
-    if (!SAVE_HOOK_SKILLS.has(p.skill))
-        return;
     if (p.assistantText.trim().length === 0)
         return;
+    // C1 (2026-06-11, defect D22) — the hook fires on artifact EVIDENCE, not
+    // only on the routed-skill label. The seed-session plan save was lost
+    // because the turn was misrouted (label 'abap-rap', not in the set) while
+    // the output carried a complete csforge:plan-manifest block. The label
+    // stays the primary trigger — it is authoritative for prose-extracted
+    // artefacts with no inline marker (spec-gap / design / estimate) and keeps
+    // merge-skill provenance exact (abap-cca-merge saves as abap-cca-merge).
+    // When the label would NOT fire, a recognizable manifest block in the
+    // output resolves the registry skill instead (detectArtifactSkill), so a
+    // misroute can no longer silently lose the artifact.
+    let saveSkill = p.skill;
+    if (!SAVE_HOOK_SKILLS.has(p.skill)) {
+        const detected = detectArtifactSkill(p.assistantText);
+        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.`));
+    }
+    // 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
+    // instead of blocking on stdin that will never answer. The auto-answer is
+    // logged so the transcript stays honest about who said yes.
+    //
+    // CONTRACT: this headless prompt blanket-answers 'y' to ANY question it
+    // is asked, so runSaveCommand must ask at most ONE question (the save
+    // confirm). See the matching note at the prompt site in
+    // src/projects/save-command.ts before adding further prompts there.
+    const { isHeadless } = await import('../renderer/tty.js');
+    const prompt = isHeadless()
+        ? async (q) => {
+            p.emit(chalk.dim(`headless: auto-answered '${q.trim()}' → 'y' (artifact save defaults YES)`));
+            return 'y';
+        }
+        : inkAwarePrompt;
     try {
-        await runSaveCommand({
+        const savedPath = await runSaveCommand({
             skillOutput: p.assistantText,
-            skillName: p.skill,
+            skillName: saveSkill,
             skillVersion: '1.0',
             skillInput: p.userMessage,
             tokensUsed: p.tokensUsed,
             model: p.model,
             author: getAuthorIdentity(),
             cwd: process.cwd(),
-            prompt: inkAwarePrompt,
+            prompt,
             log: (...lines) => lines.forEach((l) => p.emit(l)),
             promotedFrom: p.promotedFrom ?? null,
         });
+        // After a spec-gap file is saved, let a developer answer the open BLOCKER
+        // questions inline (recorded as `answered` items in the SAME file) — the
+        // business questions stay open for a consultant to answer in the viewer.
+        // Uses inkAwarePrompt directly (NOT the save hook's blanket-'y' headless
+        // prompt): in headless it returns '' → declined, so nothing is written.
+        if (savedPath && saveSkill === 'abap-spec-gap') {
+            await offerAnswerBlockers({
+                path: savedPath,
+                identity: getAuthorIdentity(),
+                prompt: inkAwarePrompt,
+                choose: inkAwareChoose,
+                log: (...lines) => lines.forEach((l) => p.emit(l)),
+            });
+        }
     }
     catch (err) {
         p.emit(chalk.yellow(`\n[save] skipped: ${err?.message ?? err}`));
@@ -173,7 +287,17 @@ export async function runTurn(params) {
     let userMessageForLLM = params.userMessage;
     let userMessageForSave = params.userMessage;
     {
-        const { fromPath, rest } = parseFromFlag(params.userMessage);
+        // Forgiveness: `--from @<document>` (a .docx/.pdf/.txt/.md, not a saved
+        // .cspeach.json) means "attach this file", not "chain a result". Rewrite it
+        // to a plain @<file> attachment and let Phase D ingest it — never error out
+        // and cancel the turn on this very natural slip.
+        const docAttach = coerceDocFromFlagToAttachment(params.userMessage);
+        if (docAttach) {
+            emit(chalk.dim(`[--from] ${docAttach.filename} is a document, not a saved result — attaching it as input instead.`));
+            userMessageForLLM = docAttach.rewritten;
+            userMessageForSave = docAttach.rewritten;
+        }
+        const { fromPath, rest } = parseFromFlag(docAttach ? '' : params.userMessage);
         if (fromPath) {
             const result = await runPromoteCommand({
                 sourcePath: fromPath,
@@ -318,9 +442,31 @@ export async function runTurn(params) {
     const watchdogConfig = loadWatchdogConfig();
     const turnStartedAt = Date.now();
     let watchdogWarned = false;
+    // 2026-06-08 — manifest-on-interrupt: track the last plan-manifest block we
+    // already handed to onPlanManifest, so we fire once per DISTINCT manifest
+    // (a continue-in-session run emits one per phase) and not once per round.
+    let lastFiredManifest = null;
+    // Bounded auto-continue across max_tokens truncations within one turn, so a
+    // long phase (e.g. /abap-plan c2.behavior) that overruns the output cap
+    // mid-response finishes instead of dying with "unexpected stop reason".
+    let maxTokenContinuations = 0;
     // (emit was hoisted to the top of the function in v0.5 so the Phase J
     //  promote dispatch could share it. Original location was here.)
     while (true) {
+        // Mid-turn steering (2026-06-08): inject any user corrections typed since the
+        // last round so the next createStream sees them. Drains at the top of EVERY
+        // round — round 1 normally drains an empty queue (no-op); a steer typed
+        // during round N lands at the start of round N+1 (between rounds). The
+        // Anthropic API concatenates consecutive user messages, so injecting after a
+        // tool_result user message is valid.
+        {
+            const steers = drainSteering();
+            if (steers.length > 0) {
+                const text = steers.join('\n');
+                session.messages.push({ role: 'user', content: text });
+                emit(chalk.cyan(`↳ steering: ${steers.join(' / ')}`));
+            }
+        }
         let buffer = initialBufferState();
         let stream;
         // 2026-05-06: paint a "thinking" spinner during the LLM round-trip
@@ -339,6 +485,7 @@ export async function runTurn(params) {
         // routed) covers liveness feedback. Classic mode (no chunkEmitter)
         // keeps the stdout spinner unchanged.
         // Guard: test/unit/ink-cursor-invariant.test.ts.
+        turnStatusEmitter.activity('thinking');
         const thinkingSpinner = startThinkingSpinner({ chunkEmitter: params.chunkEmitter });
         // v0.6 — guaranteed-visible heartbeat alongside the in-place spinner.
         // The spinner self-disables on non-TTY (Windows PowerShell sometimes
@@ -358,8 +505,23 @@ export async function runTurn(params) {
                 const allTools = listTools();
                 const filteredTools = params.toolFilter ? allTools.filter(params.toolFilter) : allTools;
                 const tools = toAnthropicTools(filteredTools);
+                // Bug 11a (proactive heal, 2026-06-07) — strip any residual
+                // `partial_json` from tool_use blocks on EVERY outgoing request.
+                // `content_block_stop` normally deletes it (see below), but any miss —
+                // a multi-tool grounding round, an SDK edge case, poison rehydrated
+                // from disk — leaves a block carrying both `input` AND `partial_json`,
+                // and the NEXT createStream 400s with:
+                //   messages.N.content.M.tool_use.partial_json: Extra inputs are not permitted
+                // which interrupts the turn and (in a /abap-plan resume) discards the
+                // expensive grounding work before any manifest is written. The reactive
+                // heal in the catch below only fires AFTER that damage. Sanitising here —
+                // the single chokepoint every request passes through, retries included —
+                // makes the 400 categorically impossible. Idempotent and O(messages).
+                healSessionMessagesInPlace(session.messages);
                 const streamParams = {
-                    model: cfg.default_model,
+                    // A4 — per-turn override (plan model tiering) wins over the
+                    // configured default; absent on every non-plan turn.
+                    model: params.modelOverride ?? cfg.default_model,
                     // v0.3.1 — was 8192. Bumped because code-gen skills (abap-generate
                     // etc.) kept running out of budget mid-turn: adaptive thinking +
                     // multiple tool-result prompts + TL;DR mandate + summary prose
@@ -419,6 +581,7 @@ export async function runTurn(params) {
         let currentAssistantContent = [];
         let sawEndTurn = false;
         let sawToolUse = false;
+        let sawMaxTokens = false;
         // M10 — ensure session.usage is present (shipped session schema may omit it
         // for older saved sessions; we default to zero on first turn).
         if (!session.usage) {
@@ -457,6 +620,11 @@ export async function runTurn(params) {
                     // call stop on an already-stopped handle, which is a no-op.
                     thinkingSpinner.stop();
                     thinkingHeartbeat.stop();
+                    // 2026-06-07 — status-row narration: the model is now emitting
+                    // content. Long emissions (a 4k-token plan manifest) can look
+                    // silent if the renderer buffers the block — the row keeps
+                    // ticking "writing response · 90s" regardless.
+                    turnStatusEmitter.activity('writing response');
                     const block = event.content_block;
                     currentAssistantContent.push(block);
                     if (block.type === 'text') {
@@ -537,6 +705,8 @@ export async function runTurn(params) {
                         sawEndTurn = true;
                     if (stop_reason === 'tool_use')
                         sawToolUse = true;
+                    if (stop_reason === 'max_tokens' || stop_reason === 'length')
+                        sawMaxTokens = true;
                     // H2 — `deltaUsage.output_tokens` is the cumulative running total for
                     // THIS message, NOT a per-event delta. Compute the increment vs the
                     // last-seen cumulative and add only that. Guard against `null` /
@@ -571,18 +741,36 @@ export async function runTurn(params) {
                 process.stdout.write(flushed);
             buffer = initialBufferState();
         }
-        // Repair partial blocks before persistence — drop incomplete tool_use
-        // fragments so the next API call doesn't reject the assistant message.
-        // See ./repair-partial.ts for the full rationale.
-        if (interruptedError !== null) {
-            currentAssistantContent = repairPartialBlocks(currentAssistantContent);
-        }
+        // Repair partial blocks before persistence. ALWAYS run, not just on
+        // interruption: on a clean tool-use round the model's tool_use blocks can
+        // still carry a leftover `partial_json` field, and persisting that poisons
+        // the on-disk session (the next createStream 400s — see the proactive heal
+        // above). `repairPartialBlocks` strips `partial_json` unconditionally and
+        // 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);
         // 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.
         if (currentAssistantContent.length > 0) {
             session.messages.push({ role: 'assistant', content: currentAssistantContent });
         }
+        // 2026-06-08 — manifest-on-interrupt. The assistant message just pushed may
+        // carry a finalised csforge:plan-manifest block (the /abap-plan resume emits
+        // it BEFORE the continuation ask_question, in this same message). Persist it
+        // NOW — before the round's tool loop dispatches that modal — so a Ctrl+C /
+        // exit during the modal can't lose the phase. Fire once per distinct block;
+        // never let a save error crash the turn.
+        if (params.onPlanManifest) {
+            const turnText = collectTurnAssistantText(session.messages, turnStartMessageCount);
+            const blocks = turnText.match(/<!--\s*csforge:plan-manifest\s*\n[\s\S]*?\n\s*-->/g);
+            const latest = blocks ? blocks[blocks.length - 1] : null;
+            if (latest && latest !== lastFiredManifest) {
+                lastFiredManifest = latest;
+                void Promise.resolve(params.onPlanManifest(turnText)).catch(() => { });
+            }
+        }
         session.last_turn_at = new Date().toISOString();
         if (interruptedError !== null) {
             session.turnInterrupted = true;
@@ -611,7 +799,10 @@ export async function runTurn(params) {
             const turnDurationMs = Date.now() - turnStartedAt;
             const entry = buildCostEntry({
                 turn: turnNumber,
-                model: session.model,
+                // A4 — when a per-turn override ran the stream on a different model
+                // (plan model tiering), the cost line must record the ACTUAL model
+                // or the Sonnet-priced turn would be billed at session-model rates.
+                model: params.modelOverride ?? session.model,
                 tokens: turnTokens,
                 duration_ms: turnDurationMs,
             });
@@ -670,16 +861,22 @@ export async function runTurn(params) {
             // their manifest in an early message before a closing ask_question
             // widget; the final wrap-up message ends the turn but doesn't
             // carry the manifest. See ./turn-assistant-text.ts for details.
+            turnStatusEmitter.activity('finishing up');
             const assistantText = collectTurnAssistantText(session.messages, turnStartMessageCount);
-            await maybeOfferSave({
-                skill: params.skill,
-                assistantText,
-                userMessage: userMessageForSave,
-                tokensUsed: Math.max(0, (session.usage?.output_tokens ?? 0) - turnStartOutputTokens),
-                model: cfg.default_model ?? session.model ?? 'unknown',
-                emit,
-                promotedFrom: promotedFromForSave,
-            });
+            if (!params.suppressSaveHook) {
+                await maybeOfferSave({
+                    skill: params.skill,
+                    assistantText,
+                    userMessage: userMessageForSave,
+                    tokensUsed: Math.max(0, (session.usage?.output_tokens ?? 0) - turnStartOutputTokens),
+                    // A4 — record the actual turn model if an override ran the stream
+                    // (unreachable today: plan-resume turns suppress this hook, and
+                    // they are the only modelOverride caller — kept honest anyway).
+                    model: params.modelOverride ?? cfg.default_model ?? session.model ?? 'unknown',
+                    emit,
+                    promotedFrom: promotedFromForSave,
+                });
+            }
             // Phase 2 #9 (2026-05-16) — auto-compact end-of-turn hook.
             // Runs only on the success path (after maybeOfferSave) so an interrupted
             // turn never triggers a summariser call on partial state. The maybeAutoCompact
@@ -707,7 +904,29 @@ export async function runTurn(params) {
             return;
         }
         if (!sawToolUse) {
-            // Unexpected stop reason — bail to avoid infinite loop.
+            // The response was cut off at the output-token cap (stop_reason
+            // 'max_tokens'/'length') mid-generation — NOT a real end of turn. The
+            // truncated assistant message is already persisted (line ~733), so
+            // continue the turn and let the model finish (and, for /abap-plan, still
+            // emit its manifest). Bounded so a pathologically long response can't
+            // loop forever.
+            const MAX_TOKEN_CONTINUATIONS = 4;
+            if (sawMaxTokens && maxTokenContinuations < MAX_TOKEN_CONTINUATIONS) {
+                maxTokenContinuations += 1;
+                emit(chalk.yellow(`\n[output limit reached — auto-continuing (${maxTokenContinuations}/${MAX_TOKEN_CONTINUATIONS})]`));
+                session.messages.push({
+                    role: 'user',
+                    content: 'Your previous response was cut off at the output-token limit. Continue exactly where you left off — do NOT repeat what you already wrote. '
+                        + 'If you were mid-way through a tool call, or (for /abap-plan) had not yet emitted the closing csforge:plan-manifest block, complete it now. '
+                        + 'Keep narration brief to stay within the limit.',
+                });
+                continue;
+            }
+            if (sawMaxTokens) {
+                emit(chalk.yellow(`\n[output limit hit ${maxTokenContinuations}× this turn — stopping. Type "continue" to resume.]`));
+                return;
+            }
+            // Truly unexpected stop reason — bail to avoid an infinite loop.
             emit(chalk.yellow('\n[unexpected stop reason — ending turn]'));
             return;
         }
@@ -734,13 +953,79 @@ export async function runTurn(params) {
                 // animation. Spinner is purely a "still working" cue, not
                 // load-bearing for output.
                 const spinner = startToolSpinner({ chunkEmitter: params.chunkEmitter });
+                // 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 ⏺
+                // dispatch line and the ⎿ result line. Labelled heartbeat prints
+                // fresh "<tool> running… (10s)" lines at thresholds — visible on
+                // every terminal, Ink included.
+                // Interactive tools wait on the USER, not the system — ticking
+                // "ask_question running… (30s)" while they think is noise.
+                // CRITICAL race fix (2026-06-13) — a mutating tool that will trip the
+                // Rule 8 batch gate (2nd+ write of the turn) ALSO blocks on the user:
+                // presentSafetyConfirmation opens an Ink modal from inside dispatchTool
+                // BEFORE the op runs. file_write / shell_exec are otherwise classified
+                // non-interactive, so without this the loop would start the per-second
+                // heartbeat + keep the turn-status row ticking UNDER the modal — the
+                // observed live bug (doubled card, lost Enter, history-replay leak,
+                // ~10-min wedge with the tool spinner ticking under the modal). Detect
+                // the gate the SAME way tool-dispatch does (tool.isMutating &&
+                // shouldGateRule8) and treat it as user-blocking: pause the status row,
+                // skip the heartbeat. The gate's own clearActiveSpinner +
+                // turnStatusEmitter.pause (safety-confirm.ts) is the inner belt; this
+                // is the outer one — together no live render source contends with the
+                // modal for the Ink frame or raw-mode stdin.
+                const willTripBatchGate = (() => {
+                    const t = getTool(block.name);
+                    return !!t?.isMutating && shouldGateRule8();
+                })();
+                const isInteractiveTool = block.name === 'ask_question' ||
+                    block.name === 'request_approval' ||
+                    willTripBatchGate;
+                // Interactive tools block on the USER. PAUSE the turn-status row (don't
+                // just relabel it): a live 250ms tick repaints the dynamic frame and
+                // overdraws the inquirer approval picker / churns the Ink ask_question
+                // modal — the hidden-question + stacked-border + lost-Enter bug
+                // (2026-06-07). resume() in the finally brings it back the moment the
+                // user answers. Non-interactive tools keep the ticking label + heartbeat.
+                if (isInteractiveTool)
+                    turnStatusEmitter.pause();
+                else
+                    turnStatusEmitter.activity(block.name);
+                const toolHeartbeat = isInteractiveTool
+                    ? { stop: () => undefined }
+                    : startThinkingHeartbeat({
+                        chunkEmitter: params.chunkEmitter,
+                        label: `${block.name} running…`,
+                    });
                 // Phase 2b: dispatch (may take 100ms–several seconds for write tools).
                 const dispatchStart = Date.now();
+                // D19 (2026-06-11) — expose the LLM tool_use id to the handler so the
+                // write-tool WAL (appendPending/finalizeToolCall) is keyed by the SAME
+                // id the loop records below. Dispatch is sequential, so a single slot
+                // on the shared ctx is safe.
+                params.ctx.toolUseId = block.id;
                 // Bug 8 — short-circuit for 2nd+ write-class tool in the same round.
                 const guardDecision = checkAndMark(block.name, writeGuard);
-                const result = guardDecision.allow
-                    ? await dispatchTool(block.name, block.input, params.ctx)
-                    : { content: guardDecision.errorContent, is_error: true };
+                let result;
+                try {
+                    result = guardDecision.allow
+                        ? await dispatchTool(block.name, block.input, params.ctx)
+                        : { content: guardDecision.errorContent, is_error: true };
+                }
+                finally {
+                    // D19: clear the slot so a future non-loop invocation on this ctx
+                    // can't inherit a stale block id.
+                    params.ctx.toolUseId = undefined;
+                    // Stop on the error path too — the interval is unref'd but would
+                    // otherwise keep printing "<tool> running…" into the NEXT prompt
+                    // after a dispatch throw.
+                    toolHeartbeat.stop();
+                    // Resume the turn-status row now that the user has answered (or the
+                    // interactive dispatch threw). No-op for non-interactive tools.
+                    if (isInteractiveTool)
+                        turnStatusEmitter.resume();
+                }
                 const durationMs = Date.now() - dispatchStart;
                 // Phase 2c: stop the spinner, which erases its line so the result
                 // row paints in place of it (no scrollback artifacts).
@@ -759,16 +1044,25 @@ export async function runTurn(params) {
                     isError: result.is_error ?? false,
                     resultSummary,
                     chunkEmitter: params.chunkEmitter,
+                    // 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 ?? {}),
                 });
                 // v0.3 (Step 28.0): populate session.toolCalls so the SessionTimeline
                 // overlay can render per-write history. Cap per-entry payload size at
                 // 4kB to bound session.json growth.
+                // D19 (2026-06-11): upsert, not push — write handlers journal the same
+                // call through the WAL under this block.id; pushing unconditionally
+                // produced two ledger entries per approval-gated write.
                 const completedAt = new Date().toISOString();
                 {
                     const resultText = typeof result.content === 'string'
                         ? result.content
                         : JSON.stringify(result.content);
-                    session.toolCalls.push({
+                    recordCompletedToolCall(session, {
                         tool_use_id: block.id,
                         tool: block.name,
                         args: block.input ?? {},

package/dist/agent/providers/license-gate.js

@@ -0,0 +1,44 @@
+/**
+ * Thrown when a non-managed LLM mode is used without a valid CSPeach login.
+ * Carries a user-facing message; callers print it and exit rather than dumping
+ * a stack trace.
+ */
+export class CspeachLicenseError extends Error {
+    mode;
+    constructor(mode) {
+        super(`CSPeach requires a license to run in '${mode}' mode.\n` +
+            `In this mode your prompts go straight to your own LLM — but the CSPeach skills\n` +
+            `and CLI are licensed software. Run \`cspeach login\` to activate your license.\n` +
+            `Need an access key? Email laeeq.siddique@cremencing.com.`);
+        this.name = 'CspeachLicenseError';
+        this.mode = mode;
+    }
+}
+/**
+ * Gate every NON-managed mode (byok / local / ai-hub) on a valid CSPeach login.
+ *
+ * Why: managed mode authenticates against the proxy on every call, so it is
+ * already gated. The other modes bypass our proxy for inference — and the
+ * skills (our IP) are bundled into the package — so without this check a fresh
+ * `npm install` is fully usable by anyone who never logged in, untracked. A
+ * CSPeach key is admin-issued (no open self-signup), so requiring one means we
+ * know who is using the product and can revoke access.
+ *
+ * Scope (Part A): require a CSPeach key to be PRESENT. Server-side validation +
+ * revocation (so a forged key fails) is the Part-B follow-up — see
+ * docs/byok-portal-handover.md §0.
+ */
+export async function assertModeLicensed(mode, getBearer) {
+    if (mode === 'managed')
+        return;
+    let key = '';
+    try {
+        key = (await getBearer()) ?? '';
+    }
+    catch {
+        key = '';
+    }
+    if (key.trim().length === 0) {
+        throw new CspeachLicenseError(mode);
+    }
+}

package/dist/agent/skill-checkpoint.js

@@ -7,7 +7,7 @@
  * with full conversation context.
  *
  * What Layer 1 does NOT cover: skill-internal state files. /abap-cca, for
- * example, maintains `.abapforge/cca/projects/<id>/project.json` with an
+ * example, maintains `.cspeach/cca/projects/<id>/project.json` with an
  * inventory of objects, classifications, and per-package state. The skill
  * writes this file at PHASE BOUNDARIES (end of DISCOVER, end of INVENTORY,
  * etc.). A crash mid-DISCOVER means the partial inventory in project.json