@cspeach/cli 1.1.31 → 1.1.32

package/dist/router/router-core.js

@@ -36,7 +36,8 @@ export const ROUTER_SCHEMA_VERSION = 1;
  * its own bundled copy — so a stale published manifest never rolls a newer
  * CLI back to older routing. router-revision-pin.test.ts fails until bumped.
  */
-export const ROUTER_REVISION = 2;
+// 3 (2026-10-09): runs_system (shadow-only text) added; live text unchanged.
+export const ROUTER_REVISION = 3;
 // 2026-06-12: keep in lockstep with .claude/skills (35 abap skills).
 // abap-dump replaced abap-dump-analyze + abap-dump-triage (portfolio merge);
 // added previously-missing abap-plan, abap-fiori-build, abap-cca-merge, abap-upgrade-merge.
@@ -90,15 +91,35 @@ export const SKILL_DESCRIPTIONS = {
     'abap-upgrade-verify': 'Verify upgrade remediation — re-run ATC, compare against baseline, flag regressions.',
 };
 export const SKILL_LIST = Object.keys(SKILL_DESCRIPTIONS);
+// Guided runs (2026-10-09, spec 2026-10-08 §3.3; review C-1/I-1): a run is a
+// declared, routable entry (.claude/runs/<name>/RUN.md) the CLI runs with code.
+// In SHADOW (CLI 1.1.32) the live text below stays byte-identical for every
+// installed CLI — a label the proxy cannot gate by CLI version would make old
+// CLIs dispatch it as a skill. The run label, the abap-clean-core line and the
+// run note live ONLY in ROUTER_SYSTEM_RUNS, which the shadow call alone asks
+// for (`shadow: 'runs'`). They go live with the flip. run-app is declared but
+// not routed until it has fixtures (§3.5).
+export const CLEAN_CORE_SKILL_LINE = 'Decide and defend the clean-core-correct approach for ONE requirement, proposed approach or object/API — the recommended path, its level (A/B/C/D) and citable evidence. Read-only; a question or a decision, never a multi-step run.';
+export const RUN_DESCRIPTIONS = {
+    'run-clean-core': 'Start, or carry on with, the guided clean-core run on named packages (ZFI_AR, ZFI_GL): inventory, start the team project, decide per object, fix, prove with the check, report. Not a question about clean core.',
+};
+export const RUN_LIST = Object.keys(RUN_DESCRIPTIONS);
+export const RUN_NOTE = '- Starting or continuing a multi-step clean-core run on named packages → run-clean-core; a question about clean core → abap-clean-core; inventorying the estate → abap-cca.';
+/** The skill lines; with `runs`, abap-clean-core joins in alphabetical place. */
+function skillLines(runs) {
+    const names = runs ? [...SKILL_LIST, 'abap-clean-core'].sort() : SKILL_LIST;
+    return names.map((n) => `- ${n} — ${n === 'abap-clean-core' ? CLEAN_CORE_SKILL_LINE : SKILL_DESCRIPTIONS[n]}`).join('\n');
+}
 // Screenshot-aware routing (2026-09-23) — appended ONLY when images are sent,
 // so text-only routing keeps the exact pre-feature instructions.
 export const SCREENSHOT_NOTE = `
 
 A screenshot is attached. Read it (error text, transaction code such as ST22/ATC/SE80, object names) and classify on the prompt AND the screenshot together — a vague prompt ("can you see this?") with an ST22 dump is abap-dump. Also add "screenshot": a one-line reading of it (e.g. "ST22 dump: CX_SY_ZERODIVIDE in ZCL_X, method CALC").`;
-export const ROUTER_SYSTEM = `You classify user prompts into ABAP-development skills. Given a prompt and context, return JSON: {"skill": "<name>", "confidence": 0-1, "alternates": ["<name>"], "reasoning": "..."}.
+function systemText(runs) {
+    return `You classify user prompts into ABAP-development skills. Given a prompt and context, return JSON: {"skill": "<name>", "confidence": 0-1, "alternates": ["<name>"], "reasoning": "..."}.
 
 Skills (name — what it is for):
-${SKILL_LIST.map((n) => `- ${n} — ${SKILL_DESCRIPTIONS[n]}`).join('\n')}
+${skillLines(runs)}${runs ? `\n\nGuided runs (name — what it is for; answer with the run name as "skill"):\n${RUN_LIST.map((n) => `- ${n} — ${RUN_DESCRIPTIONS[n]}`).join('\n')}` : ''}
 
 Routing notes:
 - Editing, changing, or adding a feature to an EXISTING custom (Z*/Y*) object → abap-refactor (in-place change) or abap-generate (new objects). abap-enhance is ONLY for SAP-delivered STANDARD objects — never for custom code.
@@ -107,14 +128,19 @@ Routing notes:
 - Building an app FROM a spec or requirements document (Word / PDF / Excel, 'build the app in this spec') → abap-app. A direct request without a spec document keeps its own skill.
 - Quick cold-read / orientation of an object → abap-explain (technical audience).
 - Performance issues / N+1 / SELECT * → abap-review (performance lens). Clean-core / ABAP Cloud readiness of one object → abap-review (cloud lens); estate-wide clean-core → abap-cca.
-- Developer documentation of an object → abap-handover (object scope).
+- Developer documentation of an object → abap-handover (object scope).${runs ? `\n${RUN_NOTE}` : ''}
 
 Pick the single best skill. Confidence is 0.75+ if the intent clearly matches one skill, 0.6-0.75 if two skills are plausible, <0.6 if none are clearly right.`;
+}
+export const ROUTER_SYSTEM = systemText(false);
+/** The shadow-only text: live + abap-clean-core + the run label + the run note. */
+export const ROUTER_SYSTEM_RUNS = systemText(true);
 export const ROUTER_PROMPT = {
     schema_version: ROUTER_SCHEMA_VERSION,
     revision: ROUTER_REVISION,
     system: ROUTER_SYSTEM,
     screenshot_note: SCREENSHOT_NOTE,
+    runs_system: ROUTER_SYSTEM_RUNS,
 };
 /**
  * A router entry read from outside (the signed manifest), or null when it is
@@ -134,7 +160,13 @@ export function asRouterPrompt(raw) {
         return null;
     if (typeof r.screenshot_note !== 'string')
         return null;
-    return { schema_version: ROUTER_SCHEMA_VERSION, revision: r.revision, system: r.system, screenshot_note: r.screenshot_note };
+    return {
+        schema_version: ROUTER_SCHEMA_VERSION,
+        revision: r.revision,
+        system: r.system,
+        screenshot_note: r.screenshot_note,
+        ...(typeof r.runs_system === 'string' && r.runs_system.trim() !== '' ? { runs_system: r.runs_system } : {}),
+    };
 }
 const tok = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 // Live fix 2026-10-02: some prompts made the router answer in prose instead of
@@ -210,8 +242,12 @@ export function routerUserMessage(prompt, context) {
     return `Prompt: ${prompt}\n\nContext: sap_system=${context.sap_system ?? 'unknown'}, last_skill=${context.last_skill ?? 'none'}`;
 }
 /** The router request body (Messages API), exactly as the proxy has sent it since 2026-10-02. */
-export function buildRouterRequest(model, prompt, context, images = [], routerPrompt = ROUTER_PROMPT) {
+export function buildRouterRequest(model, prompt, context, images = [], routerPrompt = ROUTER_PROMPT, 
+// Guided runs (2026-10-09): `runs` sends the shadow-only text; without it
+// the request is byte-identical to the live one.
+opts = {}) {
     const userMsg = routerUserMessage(prompt, context);
+    const base = opts.runs ? (routerPrompt.runs_system ?? ROUTER_SYSTEM_RUNS) : routerPrompt.system;
     return {
         model,
         // Root cause found live 2026-10-02 (v54): the router model (claude-sonnet-5)
@@ -220,7 +256,7 @@ export function buildRouterRequest(model, prompt, context, images = [], routerPr
         // a quick pick: thinking off, and headroom for the JSON answer.
         max_tokens: 600,
         thinking: { type: 'disabled' },
-        system: images.length === 0 ? routerPrompt.system : routerPrompt.system + routerPrompt.screenshot_note,
+        system: images.length === 0 ? base : base + routerPrompt.screenshot_note,
         // 2026-10-02: JSON via structured outputs (see the note above).
         output_config: { format: { type: 'json_schema', schema: resultSchema(images.length > 0) } },
         // Screenshot-aware routing (2026-09-23): images ride ahead of the text in

package/dist/router/routing-decision.js

@@ -6,7 +6,7 @@
 // (Layer B spec), extend the silent-arm with a margin check: if
 // top-2.confidence is within 0.15 of top-1, demote to 'coach'. One extra
 // `if` — no API change to this file's exports.
-const HIGH_THRESHOLD = 0.85;
+export const HIGH_THRESHOLD = 0.85;
 const COACH_THRESHOLD = 0.60;
 export function decideRouting(result) {
     if (result.confidence >= HIGH_THRESHOLD) {

package/dist/runs/bundled-runs.js

@@ -0,0 +1,100 @@
+export const BUNDLED_RUNS = [
+    {
+        "name": "run-app",
+        "kind": "guided-run",
+        "title": "Guided app build from a spec",
+        "version": "1.0",
+        "min_cli_version": "1.1.32",
+        "description": "Build an app from a spec file (Word, PDF, Excel or text): find the gaps, pick the app lane (backend and UI) on a card, then plan and build.",
+        "entry": "/run app <@spec>",
+        "alias": "/abap-app <@spec>",
+        "resume_words": [],
+        "steps": [
+            {
+                "id": "GAPS",
+                "kind": "skill",
+                "skill": "abap-spec-gap",
+                "min": "1.0"
+            },
+            {
+                "id": "LANE",
+                "kind": "skill",
+                "skill": "abap-app",
+                "mode": "Stage 2 — what to do",
+                "min": "1.0"
+            },
+            {
+                "id": "PLAN",
+                "kind": "skill",
+                "skill": "abap-plan",
+                "min": "1.2"
+            }
+        ],
+        "cards": [
+            "Build this now?"
+        ],
+        "engine": "lane/app-chain.ts",
+        "paragraph": "Builds an app from a spec file. CSPeach finds the gaps in the spec, picks the app lane (the backend and the UI) and shows it on a card, then plans the build and runs it. The lane is picked by CSPeach, never by the model. State lives in the saved spec-gap and plan files in this folder.",
+        "source_sha256": "db993138068ee8e2dd675ed2af500576c4ecf9d7e898575eddcdd6e08761a1bb"
+    },
+    {
+        "name": "run-clean-core",
+        "kind": "guided-run",
+        "title": "Guided clean-core run",
+        "version": "1.0",
+        "min_cli_version": "1.1.32",
+        "description": "Start, or carry on with, the guided clean-core run on named packages (ZFI_AR, ZFI_GL): inventory, start the team project, decide per object, fix, prove with the check, report. Not a question about clean core.",
+        "entry": "/run clean-core <PKG…>",
+        "alias": "/abap-clean-core start <PKG…>",
+        "resume_words": [
+            "carry on",
+            "continue",
+            "continue clean core",
+            "carry on with clean core"
+        ],
+        "steps": [
+            {
+                "id": "INVENTORY",
+                "kind": "code",
+                "does": "team discover"
+            },
+            {
+                "id": "START",
+                "kind": "code",
+                "does": "team init or join, then the first check per package"
+            },
+            {
+                "id": "DECIDE",
+                "kind": "skill",
+                "skill": "abap-clean-core",
+                "mode": "Triage mode",
+                "min": "1.0"
+            },
+            {
+                "id": "FIX",
+                "kind": "skill",
+                "skill": "abap-refactor",
+                "min": "1.1"
+            },
+            {
+                "id": "PROVE",
+                "kind": "code",
+                "does": "team refresh with the project's check variant"
+            },
+            {
+                "id": "REPORT",
+                "kind": "code",
+                "does": "team report"
+            }
+        ],
+        "cards": [
+            "Look at the system?",
+            "Start the project here?",
+            "Run the first check per package now?",
+            "Fix X now?"
+        ],
+        "engine": "journey/chain.ts",
+        "paragraph": "Starts a clean-core run on the packages you name. CSPeach looks at the system, starts a team project in this folder, proposes a level and a target per object, fixes what you approve, proves each fix with the check, and writes the report. It never writes to SAP without a card. Its state lives in the project files in this folder and in this session; say carry on to pick up after a pause.",
+        "source_sha256": "9fd8ec6b3eac4fa24e664c36641e779ae08d1194a1eb8aeb1b55bf5eda4dcbde"
+    }
+];

package/dist/runs/front-door.js

@@ -0,0 +1,19 @@
+import { resolveRunCommand } from './run-command.js';
+export async function detectRunStart(input, ctx) {
+    const cmd = resolveRunCommand(input);
+    if (cmd.kind === 'line')
+        return cmd;
+    const text = cmd.kind === 'rewrite' ? cmd.command : input;
+    const { detectJourney, parseJourneyStart } = await import('../journey/trigger.js');
+    const trigger = ctx.resume ? detectJourney(text, { cwd: ctx.cwd, session: ctx.session }) : parseJourneyStart(text);
+    if (!trigger) {
+        // I-5: a /run with nothing after the name, whose alias is not a trigger,
+        // would be an empty skill turn — say what the run needs instead.
+        if (cmd.kind === 'rewrite' && cmd.tail === '')
+            return { kind: 'line', line: `Add what the run needs: ${cmd.entry}` };
+        return { kind: 'input', input: text };
+    }
+    if ((trigger.kind === 'start' || trigger.kind === 'refuse') && !text.trimStart().startsWith('/'))
+        ctx.onFreeTextStart?.(text);
+    return { kind: 'run', trigger, input: text };
+}

package/dist/runs/manifest-runs.js

@@ -0,0 +1,50 @@
+const VERSION = /^\d+(\.\d+){0,2}$/;
+const NAME = /^run-[a-z0-9-]+$/;
+const str = (v) => (typeof v === 'string' ? v : '');
+export function asRunEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const e of raw) {
+        if (!e || typeof e !== 'object' || Array.isArray(e))
+            continue;
+        const r = e;
+        const name = str(r.name);
+        const min = str(r.min_cli_version);
+        if (!NAME.test(name) || !VERSION.test(min))
+            continue;
+        const steps = Array.isArray(r.steps)
+            ? r.steps.flatMap((s) => {
+                if (!s || typeof s !== 'object')
+                    return [];
+                const o = s;
+                if (o.kind !== 'code' && o.kind !== 'skill')
+                    return [];
+                return [{ id: str(o.id), kind: o.kind, ...(typeof o.skill === 'string' ? { skill: o.skill } : {}), ...(typeof o.min === 'string' ? { min: o.min } : {}) }];
+            })
+            : [];
+        out.push({ name, version: str(r.version), min_cli_version: min, title: str(r.title), entry: str(r.entry), alias: str(r.alias), steps, sha256: str(r.sha256) });
+    }
+    return out;
+}
+function compare(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/** The run whose min_cli_version is above `current` — the highest one; null when every run is satisfied. */
+export function runsFloor(entries, current) {
+    let best = null;
+    for (const r of entries) {
+        if (compare(current, r.min_cli_version) >= 0)
+            continue;
+        if (!best || compare(r.min_cli_version, best.min) > 0)
+            best = { name: r.name, min: r.min_cli_version };
+    }
+    return best;
+}

package/dist/runs/run-command.js

@@ -0,0 +1,24 @@
+// The /run verb (spec 2026-10-08 §6.1): `/run <name> <tail>` is rewritten to
+// the run's declared alias (RUN.md `alias`, its <…> placeholder = the tail)
+// and goes down today's path unchanged — /run clean-core ZFI_AR becomes
+// /abap-clean-core start ZFI_AR. No new engine entry, no new routing.
+import { BUNDLED_RUNS, runByShortName } from './runs.js';
+const RUN_LINE = /^\/run(?:\s+([\s\S]*))?$/i;
+const SHORT = /^[a-z0-9-]{1,30}$/i;
+export const RUNS_USAGE_LINE = () => `Guided runs: ${BUNDLED_RUNS.map((r) => r.entry).join(' · ')}. Type /help for what each one does.`;
+export function resolveRunCommand(input) {
+    const m = RUN_LINE.exec(input.trim());
+    if (!m)
+        return { kind: 'none' };
+    const rest = (m[1] ?? '').trim();
+    if (!rest)
+        return { kind: 'line', line: RUNS_USAGE_LINE() };
+    const short = rest.split(/\s+/, 1)[0] ?? '';
+    const run = SHORT.test(short) ? runByShortName(short) : undefined;
+    if (!run)
+        return { kind: 'line', line: `No guided run called ${SHORT.test(short) ? short : 'that'}. ${RUNS_USAGE_LINE()}` };
+    const prefix = run.alias.slice(0, run.alias.indexOf('<')).trimEnd();
+    // The tail as typed (line breaks kept): for /run app it is the skill turn's body.
+    const tail = rest.slice(short.length).trim();
+    return { kind: 'rewrite', command: `${prefix} ${tail}`.trim(), run: run.name, entry: run.entry, tail };
+}

package/dist/runs/runs.js

@@ -0,0 +1,27 @@
+// Guided runs — typed access to the bundled declarations (spec 2026-10-08 §3).
+// A declaration names, describes and versions; the engine (code) runs.
+import { BUNDLED_RUNS } from './bundled-runs.js';
+export { BUNDLED_RUNS };
+/** The router labels of the declared runs ("run-" prefix). */
+export const RUN_LABELS = new Set(BUNDLED_RUNS.map((r) => r.name));
+export const isRunLabel = (s) => RUN_LABELS.has(s);
+export function runByName(name) {
+    return BUNDLED_RUNS.find((r) => r.name === name);
+}
+/** The word typed after /run ('clean-core'), any case. */
+export function runByShortName(short) {
+    return runByName(`run-${short.toLowerCase()}`);
+}
+/** 'run-clean-core (step DECIDE)' for a skill a run uses; undefined otherwise. */
+export function partOfRun(skill) {
+    for (const r of BUNDLED_RUNS) {
+        const step = r.steps.find((s) => s.kind === 'skill' && s.skill === skill);
+        if (step)
+            return `${r.name} (step ${step.id})`;
+    }
+    return undefined;
+}
+/** The first skill step's skill — what a run label falls back to while routing is in shadow. */
+export function firstSkillOf(run) {
+    return run.steps.find((s) => s.kind === 'skill')?.skill;
+}

package/dist/runs/shadow.js

@@ -0,0 +1,100 @@
+// Guided runs, shadow routing (spec 2026-10-08 §4 step 2). The proxy has a
+// shadow-only router text that knows the run label (Task 8); trigger.ts still
+// decides. This module counts whether the two agree, so the flip (§4 step 3)
+// can be gated on evidence:
+//   both          the trigger started a run AND the router said the run label at ≥ 0.85 (would route silently)
+//   trigger-only  the trigger started a run; the router gave a real answer that was anything else   ← the gate: must stay 0
+//   unknown       no real answer (offline, unparseable, error, or not managed mode)
+//   unexpected    a LIVE answer carried a run label (cannot happen with the live text; guarded anyway)
+// The shadow sends the start sentence to our router for classification, the
+// same as any typed message today (managed mode only). Counts only are kept:
+// never the prompt, a package, a session. File: ~/.cspeach/shadow-runs.json.
+import fs from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+import { isKnownSkill } from '../router/classifier.js';
+import { HIGH_THRESHOLD } from '../router/routing-decision.js';
+import { firstSkillOf, isRunLabel, runByName } from './runs.js';
+const FIELD = {
+    both: 'both', 'trigger-only': 'triggerOnly', unknown: 'unknown', unexpected: 'unexpected',
+};
+export function shadowFile() {
+    return path.join(cspeachRoot(), 'shadow-runs.json');
+}
+export function readShadowCounts(file = shadowFile()) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            return {};
+        const out = {};
+        for (const [run, v] of Object.entries(raw)) {
+            if (!isRunLabel(run) || !v || typeof v !== 'object')
+                continue;
+            const c = v;
+            const n = (k) => (typeof c[k] === 'number' && Number.isFinite(c[k]) ? c[k] : 0);
+            out[run] = { since: typeof c.since === 'string' ? c.since : new Date().toISOString(), both: n('both'), triggerOnly: n('triggerOnly'), unknown: n('unknown'), unexpected: n('unexpected') };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** Add one to a count. Best effort and silent: a broken file is started over; an unwritable one is ignored. */
+export function recordShadow(run, kind, file = shadowFile()) {
+    try {
+        const all = readShadowCounts(file);
+        const c = all[run] ?? { since: new Date().toISOString(), both: 0, triggerOnly: 0, unknown: 0, unexpected: 0 };
+        c[FIELD[kind]] += 1;
+        all[run] = c;
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(file, JSON.stringify(all, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    }
+    catch {
+        // Counting never gets in the way of the run, and never writes to the screen.
+    }
+}
+/** The kind for a start the trigger accepted, given what the router said (null = no answer). Review I-2. */
+export function shadowKindFor(result, run) {
+    if (!result || result.offline || result.reasoning === 'router_unparseable')
+        return 'unknown';
+    return result.skill === run && result.confidence >= HIGH_THRESHOLD ? 'both' : 'trigger-only';
+}
+/** Shadow-classify a free-text start the trigger accepted. Resolves always; the REPL does not await it. */
+export async function shadowStart(text, run, deps) {
+    const record = deps.record ?? recordShadow;
+    if (deps.llmMode !== 'managed') {
+        record(run, 'unknown');
+        return;
+    }
+    let result = null;
+    try {
+        result = await deps.classify(text, deps.context);
+    }
+    catch {
+        result = null;
+    }
+    record(run, shadowKindFor(result, run));
+}
+/**
+ * Defensive guard on a LIVE answer: the live router text has no run label
+ * (Task 8), so this never fires in this release. If it ever does: count it,
+ * hand the dispatcher a real skill (first known alternate, else the run's
+ * first skill step), drop run labels from alternates, and keep the confidence
+ * under the silent threshold so the person sees the picker, never a silent
+ * dispatch of a skill the router did not score (review I-1).
+ */
+export function guardRunLabel(result, record = recordShadow) {
+    const alternates = result.alternates.filter((a) => !isRunLabel(a));
+    if (!isRunLabel(result.skill))
+        return alternates.length === result.alternates.length ? result : { ...result, alternates };
+    record(result.skill, 'unexpected');
+    const run = runByName(result.skill);
+    const fallback = alternates.find(isKnownSkill) ?? (run ? firstSkillOf(run) : undefined) ?? 'abap-explain';
+    return {
+        ...result,
+        skill: fallback,
+        confidence: Math.min(result.confidence, HIGH_THRESHOLD - 0.01),
+        alternates: alternates.filter((a) => a !== fallback && isKnownSkill(a)),
+    };
+}

package/dist/runs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/session/queued-step.js

@@ -0,0 +1,45 @@
+// src/session/queued-step.ts
+//
+// Audit M-2 (2026-10-08) — who queued the command in the pending-dispatch slot.
+//
+// The slot holds the next command the REPL runs with no keypress. CSPeach
+// itself fills it (the clean-core journey's DECIDE/FIX step, the rebuild
+// hand-off, the app chain, the plan chain), and so does dispatch_skill after
+// the person picked "Switch to /abap-X". A command CSPeach built is never shown
+// as if the person typed it ("You › …"): its source tags it with an origin when
+// it queues it, and both REPLs (Ink and classic) render it through
+// queuedStepView — one rendering for every origin. A dispatch_skill switch is
+// tagged `switch` (must-fix follow-up b): the person agreed to the switch, but
+// the exact command was written by the model, so it shows as "Auto-routed: …",
+// never as typed. An untagged command keeps the old echo.
+import { shownUpTo } from '../register/atc-file.js';
+export function createDispatchSlot() {
+    let cmd = null;
+    let origin = null;
+    return {
+        get: () => cmd,
+        set(command, o) {
+            cmd = command;
+            origin = command === null ? null : o ?? null;
+        },
+        take() {
+            if (cmd === null)
+                return null;
+            const q = { cmd, origin };
+            cmd = null;
+            origin = null;
+            return q;
+        },
+    };
+}
+/**
+ * How a dispatched command shows on screen. A CSPeach step: its own line (or
+ * nothing when the source already said it), never the "You ›" echo. No origin:
+ * the echo, as for anything the person chose.
+ */
+export function queuedStepView(origin) {
+    if (!origin)
+        return { echo: true };
+    const line = origin.line ? shownUpTo(origin.line, 160).trim() : '';
+    return { echo: false, line: line || null };
+}