@cspeach/cli 1.1.50 → 1.1.52

package/dist/session/cli-record.js

@@ -0,0 +1,165 @@
+// cspeach-cli/src/session/cli-record.ts
+//
+// /export docx conversation, fix round 1 (2026-10-23). Two small records kept
+// on the session for the conversation export, NEVER sent to the model:
+//
+// - cli_messages: which user-role messages CSPeach wrote itself (a plan step
+//   prompt, the output-limit continuation, the watchdog note, a /compact or
+//   plan-boundary summary, a queued next step, a mid-turn steer). Each entry is
+//   the sha of the message content, not an index: compaction drops and moves
+//   messages, a content hash still finds the same message. The messages
+//   themselves are untouched, so every model request stays byte-identical.
+// - cli_cards: the CLI's own cards that matter for a change ticket (the plan
+//   gate "Build this now?", the plan startup "Continue", the lane card, the
+//   journey cards), anchored by turn_seq. Never the save or Word cards.
+//
+// Both are optional session fields. A session file is JSON.parse'd and written
+// whole (store.ts), so an older CLI that resumes the file keeps them as they are.
+import crypto from 'node:crypto';
+export const CLI_RECORD_CAP = 500;
+export const CONTINUE_LINE = 'CSPeach asked the model to continue a long answer.';
+export const WATCHDOG_LINE = 'CSPeach asked the model to wrap up a long turn.';
+export const COMPACT_LINE = 'Earlier turns were summarised to keep the session small.';
+export const PLAN_BOUNDARY_LINE = 'CSPeach summarised the earlier plan steps.';
+function shaOf(content) {
+    return crypto.createHash('sha256').update(typeof content === 'string' ? content : JSON.stringify(content ?? null)).digest('hex').slice(0, 32);
+}
+function capped(list) {
+    return list.length > CLI_RECORD_CAP ? list.slice(list.length - CLI_RECORD_CAP) : list;
+}
+/** Note that CSPeach wrote this user-role message. Never throws. */
+export function markCliMessage(session, content, kind, line) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        s.cli_messages = capped([...(s.cli_messages ?? []), { sha: shaOf(content), kind, line }]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/**
+ * Fixed-shape CLI texts, for sessions written before the record existed (or
+ * a mark the cap dropped). Prefixes only; the bodies are CSPeach's own words.
+ */
+const KNOWN_PREFIXES = [
+    { prefix: 'Resume execution of the project plan', kind: 'plan-step', line: 'CSPeach ran the next plan step.' },
+    { prefix: 'Your previous response was cut off at the output-token limit.', kind: 'continue', line: CONTINUE_LINE },
+    { prefix: '[CSPeach watchdog]', kind: 'watchdog', line: WATCHDOG_LINE },
+    { prefix: '[Context summary auto-generated', kind: 'compact', line: COMPACT_LINE },
+    { prefix: '[Summary of the earlier steps of this plan', kind: 'plan-boundary', line: PLAN_BOUNDARY_LINE },
+];
+function prefixMark(message) {
+    const text = typeof message.content === 'string' ? message.content
+        : Array.isArray(message.content) ? message.content.filter((b) => b?.type === 'text').map((b) => String(b.text ?? '')).join('\n') : '';
+    const t = text.trimStart();
+    const known = KNOWN_PREFIXES.find((k) => t.startsWith(k.prefix));
+    return known ? { sha: '', kind: known.kind, line: known.line } : undefined;
+}
+/**
+ * The mark of each message (undefined for the developer's own words), in
+ * message order. Fix round 2 (m-8): each mark is used once, in order — a
+ * message takes the first unused mark at or after the last one used that has
+ * its sha. So a command the developer retypes after CSPeach queued it, or a
+ * typed "continue" equal to an earlier steer, stays the developer's: that mark
+ * is already used. Marks of messages a compaction dropped are simply passed
+ * over. The prefix fallback is only for sessions with no records at all.
+ */
+export function resolveCliMarks(session, messages) {
+    const marks = session?.cli_messages;
+    if (!marks || marks.length === 0)
+        return messages.map((m) => (m.role === 'user' ? prefixMark(m) : undefined));
+    // Final-review fix (I-1): used once, any order. Look from the last mark used
+    // on; when nothing matches there, look again from the start (a file an older
+    // CLI compacted has the summary's mark last). A used mark is never reused.
+    const used = new Set();
+    let next = 0;
+    return messages.map((m) => {
+        if (m.role !== 'user')
+            return undefined;
+        const sha = shaOf(m.content);
+        const at = (from, to) => {
+            for (let j = from; j < to; j++)
+                if (!used.has(j) && marks[j].sha === sha)
+                    return j;
+            return -1;
+        };
+        let j = at(next, marks.length);
+        if (j < 0)
+            j = at(0, Math.min(next, marks.length));
+        if (j < 0)
+            return undefined;
+        used.add(j);
+        next = j + 1;
+        return marks[j];
+    });
+}
+/**
+ * Final-review fix (I-1): after a compaction keeps `kept` (the tail of the old
+ * messages, from index `keepFrom`) behind a new summary message, rebuild the
+ * record in message order: the summary's mark first, then the marks of the
+ * kept messages (recomputed from their content, so a mark found by the prefix
+ * fallback in an older file becomes a real one). Marks of dropped messages go.
+ */
+export function rebuildCliMarksAfterCompact(session, oldMessages, keepFrom, summaryContent, summary) {
+    try {
+        const resolved = resolveCliMarks(session, oldMessages);
+        const kept = [];
+        for (let i = keepFrom; i < oldMessages.length; i++) {
+            const m = resolved[i];
+            if (m)
+                kept.push({ sha: shaOf(oldMessages[i].content), kind: m.kind, line: m.line });
+        }
+        session.cli_messages = capped([{ sha: shaOf(summaryContent), kind: summary.kind, line: summary.line }, ...kept]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/** A turn of its own (the developer's prompt, a plan step, a queued step) vs. a message inside a turn. */
+export function startsTurn(mark) {
+    return !mark || mark.kind === 'plan-step' || mark.kind === 'queued';
+}
+/* ── cards ────────────────────────────────────────────────────────────── */
+let bound = null;
+/** The REPL (and each top-level turn) binds the session the cards belong to. */
+export function bindCliCardSession(session) { bound = session; }
+/**
+ * The card ids the card slot records for the export: plan startup, lane,
+ * journey. Never save or Word cards. "Build this now?" (app-start-build) is
+ * recorded by afterPlanSave itself, which knows the plan file and whether the
+ * object-list approval was installed (fix round 2, N-1).
+ */
+export function isRecordedCard(id) {
+    return id === 'plan-continue' || id === 'app-lane' || id === 'app-lane-runtime' || id.startsWith('journey-');
+}
+/** Record one card on the bound session (or the one given), with the time. Never throws. */
+export function recordCliCard(card, session = bound) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        const entry = { turn_seq: s.turn_seq ?? 0, at: new Date().toISOString(), ...card };
+        s.cli_cards = capped([...(s.cli_cards ?? []), entry]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/* ── once-per-object document offers ──────────────────────────────────── */
+/**
+ * Per session (in memory): the (skill, object) keys the newer document skills
+ * already offered "Save…?" for. Kept here, beside the records, so /new can
+ * clear it (final-review m-4).
+ */
+const documentOffers = new WeakMap();
+export function documentOffersFor(session) {
+    let s = documentOffers.get(session);
+    if (!s) {
+        s = new Set();
+        documentOffers.set(session, s);
+    }
+    return s;
+}
+/** /new: the once-per-object offers and the records of the cleared conversation go too. */
+export function clearConversationRecords(session) {
+    documentOffers.delete(session);
+    const s = session;
+    delete s.cli_messages;
+    delete s.cli_cards;
+}

package/dist/session/fresh-start.js

@@ -1,3 +1,4 @@
+import { clearConversationRecords } from './cli-record.js';
 export function startFreshConversation(session) {
     session.messages = [];
     session.turnInterrupted = false;
@@ -6,6 +7,9 @@ export function startFreshConversation(session) {
     delete session.lastAutoCompactTurn;
     // An open plan step does not survive: "continue" must not resume it.
     session.plan_in_flight = null;
+    // Word export (final-review m-4): the once-per-object save offers and the
+    // export records describe the cleared conversation; they go with it.
+    clearConversationRecords(session);
 }
 /** The one line /new prints. */
 export function freshStartText(lane) {

package/dist/session/queued-step.js

@@ -45,5 +45,7 @@ export function queuedStepView(origin) {
     if (!line)
         return { echo: false, line: null };
     // D11 — the chat-fallback line is dim; painted after shownUpTo flattened it.
-    return { echo: false, line: origin.by === 'chat_fallback' ? paint('dim', line) : line };
+    // LT-4 (1A fix wave, owner ruling): the hand-off arrow line is dim too, kept in scrollback.
+    const dim = origin.by === 'chat_fallback' || origin.by === 'hand_off';
+    return { echo: false, line: dim ? paint('dim', line) : line };
 }

package/dist/session/user-prompt.js

@@ -26,8 +26,17 @@ export function isUserPrompt(m) {
  * (`<session_context>` from the intent extractor / SAP system info,
  * `<project_context>` from CSPEACH_PROJECT_CONTEXT). The user never typed
  * them, so a prompt preview must never show them (fix round 3, item 2).
+ * Stage 1A (M5) — `<skill>`, the playbook block an inline turn appends. The
+ * order matters: `<session_context>` first, so the bare `<skill>` word in a
+ * `<playbook>` line goes with the block it sits in — `skill` stays last.
+ * Shared with the conversation export (commands/export-conversation.ts).
  */
-const INJECTED_CONTEXT_TAGS = ['session_context', 'project_context'];
+export const INJECTED_CONTEXT_TAGS = [
+    'session_context', 'project_context',
+    // The /export docx conversation list (main, 2026-10-23): one list for both readers.
+    'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection',
+    'skill',
+];
 /**
  * One-line preview of what the user typed: injected context blocks removed,
  * `<attached file="x">…</attached>` expansions shown as the original `@x`

package/dist/skills/manifest-client.js

@@ -4,6 +4,7 @@ import { sha512 } from '@noble/hashes/sha512';
 import { bytesToHex, concatBytes } from '@noble/hashes/utils';
 import { MANIFEST_PUBLIC_KEYS } from './signing-public-key.js';
 import { canonicalise } from './canonical.js';
+import { fetchWithConnectRetry } from '../util/connect-retry.js';
 // @noble/ed25519 v2 requires an ed25519 sha512 hook.
 ed.etc.sha512Sync = (...m) => sha512(concatBytes(...m));
 /**
@@ -39,7 +40,7 @@ export class ManifestClient {
     async fetchManifest() {
         let r;
         try {
-            r = await fetch(this.manifestUrl, { signal: AbortSignal.timeout(10_000) });
+            r = await fetchWithConnectRetry(this.manifestUrl, () => ({ signal: AbortSignal.timeout(10_000) }));
         }
         catch (e) {
             throw new ManifestUnavailableError(`manifest fetch failed (${this.manifestUrl}): ${e.message}`);
@@ -99,7 +100,7 @@ export class ManifestClient {
     async fetchSkillBody(name, bodyUrl, opts) {
         let r;
         try {
-            r = await fetch(bodyUrl, { signal: AbortSignal.timeout(10_000) });
+            r = await fetchWithConnectRetry(bodyUrl, () => ({ signal: AbortSignal.timeout(10_000) }));
         }
         catch (e) {
             throw new Error(`skill body fetch failed (${bodyUrl}): ${e.message}`);

package/dist/skills/preamble.js

@@ -52,8 +52,10 @@ take precedence if a skill's instruction conflicts with them.
   revise and re-submit.
 
 ## Transport discipline
-- All writes go into the active session transport. Do not ask the user
-  for a transport number per change.
+- All writes go into the session transport once one is set. Do not ask
+  the user for a transport number per change. When a create says a
+  transport is needed, ask the user once: a new session transport
+  (recommended) or one of the open requests for the package.
 - Never use \$TMP unless the user explicitly requests local-only work.
 
 ## Escalate, don't fail silently
@@ -70,6 +72,6 @@ take precedence if a skill's instruction conflicts with them.
 
 ## One skill per turn
 - If the user's request is better served by a different skill, call
-  switch_skill with a clear reason. Do not try to do the work of another
-  skill yourself.
+  dispatch_skill after the person has picked the command. Do not try to do
+  the work of another skill yourself.
 `;

package/dist/skills/source-authed.js

@@ -14,6 +14,7 @@ import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
 import { ManifestClient, DEFAULT_MANIFEST_URL, SkillIntegrityError, ManifestUnavailableError, } from './manifest-client.js';
 import { fileSkillsCache } from './skills-cache.js';
+import { fetchWithConnectRetry } from '../util/connect-retry.js';
 // Defined next to the client that throws it (Task 8 (a): typed, never string-matched).
 export { SkillIntegrityError };
 export class SkillNotInPlanError extends Error {
@@ -69,10 +70,10 @@ async function fetchSignedInBody(baseUrl, name, expectedSha, getBearer, doFetch)
         throw new SkillSignInError();
     let r;
     try {
-        r = await doFetch(`${baseUrl}/v1/skills/${encodeURIComponent(name)}`, {
+        r = await fetchWithConnectRetry(`${baseUrl}/v1/skills/${encodeURIComponent(name)}`, () => ({
             headers: { Authorization: `Bearer ${bearer}` },
             signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-        });
+        }), { fetchImpl: doFetch });
     }
     catch {
         throw new SkillsUnavailableError('could not reach CSPeach');

package/dist/tools/approval.js

@@ -6,6 +6,14 @@ import { isHeadless, shouldUseInk } from '../renderer/tty.js';
 import { effectiveRisk, riskResultFields, typeCode } from '../approvals/risk-floor.js';
 import { objectsWithSyntaxErrors } from './syntax-state.js';
 import { noteWriteTransport } from '../repl/current-transport.js';
+import { STOPPED_BEFORE_START_RESULT } from '../agent/repair-partial.js';
+/**
+ * LT-15 D6 (F6) — after a stop (Esc or Ctrl+C set the same turn abort) no new
+ * card opens and no approval id is minted. The shape dispatchTool returns for
+ * a tool that never started (the tool_use stays paired), with a text that says
+ * nothing ran.
+ */
+const stoppedBeforeCard = (ctx) => (ctx.signal?.aborted ? { content: STOPPED_BEFORE_START_RESULT, is_error: true } : null);
 /**
  * Round 8 item 6 — the footer showed "no transport" while the approved card
  * said "transport S4HK903731". An approval granted for an explicit transport
@@ -29,7 +37,7 @@ import { promptAdvisory } from '../approvals/advisory-prompt.js';
 import { markPlanGateApproved } from '../repl/rule8-detector.js';
 import { getEffectiveWriteMode } from '../repl/mode-cycle.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
-import { displayTransport } from '../approvals/op-labels.js';
+import { displayTransport, knownTypeWord } from '../approvals/op-labels.js';
 import { canonicalApprovalObject as bareObjectName } from '../approvals/canonical.js';
 import { projectTransport, SEVERAL_REQUESTS_LABEL, transportForWrite, TRANSPORT_REQUEST } from '../register/project-transport.js';
 import { NOT_ON_THIS_RELEASE, approvalRefusedByProfile } from '../sap/profile-gate.js';
@@ -223,7 +231,8 @@ registerTool({
                     type: 'object',
                     properties: {
                         op: { type: 'string', enum: ['create', 'modify', 'delete', 'activate', 'release', 'run'] },
-                        object: { type: 'string' },
+                        // P-2 (1A fix wave): a group word ('DCLs') is not an object the plan grant can match.
+                        object: { type: 'string', description: "One real object name per row (comma-join several only in an activate row), never a group word such as 'DCLs'." },
                         type: { type: 'string' },
                         diff: { type: 'string', description: 'For a CREATE op this MUST be the exact, complete source that will be written — verbatim, character-for-character, NOT a description, summary, or paraphrase. It is shown to the developer in the approval box as the exact thing they are approving, so a one-line summary here means they approve a write they cannot inspect. For a MODIFY op, the real unified diff of the change (again verbatim, not a description).' },
                         package: { type: 'string', description: 'Target package (development class) for the object, if known — shown on the approval box' },
@@ -298,6 +307,10 @@ registerTool({
         // no role configured and no session override this is exactly
         // cfg.write_mode — byte-identical behavior.
         const role = cfg.sap[ctx.sapAlias]?.role;
+        // LT-15 D6 — stopped during the profile read above: no advisory card, no card.
+        const stopA = stoppedBeforeCard(ctx);
+        if (stopA)
+            return stopA;
         // Advisory-only short-circuit — never mint approval_ids.
         // The developer applies the change manually in ADT; the AI gets an
         // ai_directive telling it not to attempt any SAP write tools.
@@ -313,11 +326,17 @@ registerTool({
             return { content: JSON.stringify(releaseRefusal), is_error: true };
         // Task 8 (B11) — the request that already holds each modified object, before any card.
         await attachOwningTransport(args.changes ?? [], ctx);
+        // LT-15 D6 — stopped during the reads above: no card, no nag, no id minted
+        // (the plan-grant and auto-approve paths below mint without a card).
+        const stopB = stoppedBeforeCard(ctx);
+        if (stopB)
+            return stopB;
         let sapCfg = cfg.sap[ctx.sapAlias];
         const riskCtx = {
             sapAlias: ctx.sapAlias,
             autoApprovePolicy: sapCfg?.auto_approve ?? 'never',
             syntaxErrorObjects: objectsWithSyntaxErrors(),
+            typeWord: knownTypeWord, // LT-10: the syntax-errors reason names the kind of object
         };
         const changes = args.changes;
         const declared = args.risk;
@@ -421,6 +440,10 @@ registerTool({
             sapCfg = cfg.sap[ctx.sapAlias];
             riskCtx.autoApprovePolicy = sapCfg?.auto_approve ?? 'never';
         }
+        // LT-15 D6 (review M3) — stopped while the nag was up: no card after it, no id.
+        const stopC = stoppedBeforeCard(ctx);
+        if (stopC)
+            return stopC;
         // 1.1.31 (owner, 2026-10-07): a package or transport always gets a person's
         // yes. Live, auto_approve="low" let the model's own "low" create package
         // ZCC_FIX_PROOF and request S4HK903757 with no card. The plan-grant path
@@ -478,12 +501,14 @@ registerTool({
         // for one task" complaint. Review-each falls back to the per-change
         // gate. Cancel rejects the whole plan.
         //
-        // Task 9 (C8): only for more than one VISIBLE change — the same count the
-        // plan gate shows (an activate whose write is in the list is not a change
-        // a person sees). A modify + its activate on one class gets the
-        // per-change card only; the activate follows its approved write below.
+        // Task 9 (C8): only for more than one VISIBLE change (an activate whose
+        // write is in the list is not a change a person sees). A modify + its
+        // activate on one class gets the per-change card only; the activate
+        // follows its approved write below. LT-12: the plan gate's LIST also
+        // hides a modify that a create of the same object covers (planRows), so
+        // it may show fewer rows than this count; this count is unchanged.
         let skipPerChangeGates = false;
-        // Raw keys on purpose: the same collapse (and count) the plan gate displays.
+        // Raw keys on purpose: activates collapsed, nothing else.
         const visibleCount = collapseImplicitActivates(changes).length;
         if (visibleCount > 1) {
             const mode = await renderPlanGate(args.summary, changes, planGateTransport, eff, ctx.sapAlias);
@@ -549,6 +574,11 @@ registerTool({
                 outcome = { approved: false, reason: 'sibling_write_skipped' };
             }
             else {
+                // LT-15 D6 (review M3) — stopped during the mint after the card before:
+                // the next card does not open; ids minted so far are dropped unused.
+                const stopD = stoppedBeforeCard(ctx);
+                if (stopD)
+                    return stopD;
                 outcome = await renderPerChangeApprovalV3(c, eff, displayTransport(c.op, args.transport, sessionTransport, c.owningTransport, project));
             }
             if (outcome.approved) {

package/dist/tools/dispatch-skill.js

@@ -44,7 +44,7 @@ registerTool({
         properties: {
             command: {
                 type: 'string',
-                description: 'Full slash command including arguments. Must start with `/`. Example: `/abap-rap --from @order-approval-system-design-2924-v1.cspeach.json`.',
+                description: 'Full slash command including arguments. Must start with `/`. Example: `/abap-rap --from @order-approval-system-design-2924-v1.cspeach.json`. Never put a transport description in it unless the person typed it.',
             },
         },
         required: ['command'],

package/dist/tools/hand-off.js

@@ -5,6 +5,9 @@
  * chat turn then ends and the workflow runs with its own plan + approvals.
  * No extra consent card (D5): the workflow asks before any write.
  * Refused outside the chat lane; dispatch_skill stays the skills' own switch.
+ * Stage 1A (T1A.4): in an inline session (`ctx.inlineSkills`) a playbook turn
+ * may hand off too — still only queues — except while a plan is in charge or
+ * the slot already holds a step (the harness's next-phase hop wins).
  *
  * Flag-gated: only a chat-lane process enables it (Task 11), so a skills-lane
  * session never lists it and its tools array stays byte-identical to today.
@@ -14,7 +17,37 @@ import { isPlanResumeCommand } from '../commands/plan-resume.js';
 import { SKILL_CATALOG, resolveSkillAlias } from '../skill-catalog.js';
 /** Longest request hand_off queues (after whitespace is collapsed). */
 export const HAND_OFF_REQUEST_MAX = 500;
+/**
+ * I3 (owner, 2026-10-22) — one hand-off per person message. Refusal code when
+ * the running turn was itself started by a hand_off: no workflow-to-workflow
+ * chain of reads and credits without a new person message. A new person
+ * message resets it (the REPL passes who started each turn as `ctx.turnBy`).
+ * dispatch_skill after the person's pick is not capped.
+ */
+export const HAND_OFF_CHAIN_CAPPED = 'HAND_OFF_CHAIN_CAPPED';
 export const HAND_OFF_LINE = (skill) => `→ /${skill}`;
+/** The success note when the model wrote nothing before the call in this turn. */
+export const HAND_OFF_NOTE = 'The workflow runs next and asks before it writes. End the turn now. If you wrote a line before the call, add nothing. If you wrote nothing, add one short line saying the workflow takes it from here. Do not print the command.';
+/**
+ * LT-3 (live check 2026-10-26) — the model often skipped the "if you wrote a
+ * line" test and announced the hand-off twice. The loop knows whether text
+ * came first in this turn and then gives this plain note instead.
+ */
+export const HAND_OFF_NOTE_ALREADY_SAID = 'The workflow runs next and asks before it writes. You already told the developer in this turn, so end the turn now and write nothing more. Do not print the command.';
+/** The hand_off success content with the note for a turn that already said its line. Anything else unchanged. */
+export function settleHandOffNote(content, saidBefore) {
+    if (!saidBefore)
+        return content;
+    try {
+        const r = JSON.parse(content);
+        if (r.ok !== true || r.note !== HAND_OFF_NOTE)
+            return content;
+        return JSON.stringify({ ...r, note: HAND_OFF_NOTE_ALREADY_SAID });
+    }
+    catch {
+        return content;
+    }
+}
 export const buildHandOffCommand = (skill, request) => `/${skill} ${request}`;
 const CATALOG_NAMES = new Set(SKILL_CATALOG.map((s) => s.name));
 /**
@@ -45,15 +78,25 @@ registerTool({
         type: 'object',
         properties: {
             skill: { type: 'string', description: 'Workflow name without the slash, e.g. "abap-refactor".' },
-            request: { type: 'string', description: 'What the workflow should do, with object names. One sentence, at most 500 characters, no flags.' },
+            request: { type: 'string', description: 'What the workflow should do, with object names. One sentence, at most 500 characters, no flags. Never put a transport description in it unless the person typed it.' },
         },
         required: ['skill', 'request'],
     },
     handler: async (args, ctx) => {
         const bad = (error, reason) => ({ is_error: true, content: JSON.stringify({ error, reason }) });
-        if (ctx.session?.lane !== 'chat') {
+        // Stage 1A (T1A.4) — in an inline session a playbook turn may hand off too.
+        const playbookTurn = ctx.session?.lane !== 'chat';
+        if (playbookTurn && !ctx.inlineSkills) {
             return bad('HAND_OFF_OUTSIDE_CHAT', 'hand_off is only for the chat; in a workflow, continue with the workflow (dispatch_skill switches workflows after the person agreed).');
         }
+        // The plan harness queues its next phase through the same slot; never race it.
+        if (playbookTurn && (ctx.session?.plan_in_flight || ctx.session?.skill === 'abap-plan')) {
+            return bad('HAND_OFF_PLAN_IN_FLIGHT', 'finish this step; after the plan, the person can ask for that in chat');
+        }
+        // I3 — one hand-off per person message.
+        if (ctx.turnBy === 'hand_off') {
+            return bad(HAND_OFF_CHAIN_CAPPED, "this workflow was already handed off from the person's message; one hand-off per message. Finish this workflow's answer, then let the person decide the next step: offer that workflow as a suggestion in your answer instead of calling hand_off. Do not call dispatch_skill either unless the person picks it.");
+        }
         const skill = normaliseSkill(args.skill);
         if (!skill) {
             return bad('HAND_OFF_UNKNOWN_SKILL', `unknown workflow "${String(args.skill ?? '')}". Use one of: ${SKILL_CATALOG.map((s) => s.name).join(', ')}`);
@@ -74,13 +117,12 @@ registerTool({
         if (!ctx.pendingDispatch) {
             return bad('DISPATCH_UNSUPPORTED', 'no dispatch slot in this context (one-shot or test); tell the developer which /abap-… command to run instead');
         }
+        if (playbookTurn && ctx.pendingDispatch.get() !== null) {
+            return bad('HAND_OFF_SLOT_TAKEN', 'a step is already queued; end the turn');
+        }
         ctx.pendingDispatch.set(command, { by: 'hand_off', line: HAND_OFF_LINE(skill) });
         return {
-            content: JSON.stringify({
-                ok: true,
-                queued: command,
-                note: 'The workflow runs next and asks before it writes. End the turn now with at most one short line; do not print the command.',
-            }),
+            content: JSON.stringify({ ok: true, queued: command, note: HAND_OFF_NOTE }),
         };
     },
 });

package/dist/tools/lane/app-lane-resolve.js

@@ -36,6 +36,9 @@ import { askConfirm } from '../../ui/confirm-request.js';
 import { isHeadless } from '../../renderer/tty.js';
 import { loadConfig } from '../../config/loader.js';
 import { getSapSystemInfo } from '../../sap/system-info.js';
+import { STOPPED_BEFORE_START_RESULT } from '../../agent/repair-partial.js';
+/** LT-15 D6 (review M2) — after a stop (Esc / Ctrl+C) no card opens and nothing is saved. */
+const stopped = (ctx) => (ctx.signal?.aborted ? { content: STOPPED_BEFORE_START_RESULT, is_error: true } : null);
 const fail = (message) => ({ content: `error: ${message}`, is_error: true });
 const NOT_CHOSEN = 'Lane not chosen. Nothing was saved.';
 const STOP = 'STOP — lane needs your choice.';
@@ -200,6 +203,9 @@ export async function appLaneResolveHandler(args, ctx, deps = {}) {
     }
     else {
         // 7. The lane card.
+        const stopLane = stopped(ctx);
+        if (stopLane)
+            return stopLane;
         const confirm = deps.confirm ?? ((req) => askConfirm(req));
         const card = laneCardRequest(decision);
         const res = await confirm({ ...card, facts: [...(card.facts ?? []), ...cardFacts] });
@@ -224,6 +230,9 @@ export async function appLaneResolveHandler(args, ctx, deps = {}) {
         }
         // 8. A CAP lane needs a runtime.
         if (finalLane.backend === 'cap' && !runtime) {
+            const stopRuntime = stopped(ctx);
+            if (stopRuntime)
+                return stopRuntime;
             const rr = await confirm(runtimeCardRequest());
             const answer = rr.value;
             if (!answer || !RUNTIMES.includes(answer))