@cspeach/cli 1.1.51 → 1.1.52

package/dist/renderer/steering-echo.js

@@ -1,8 +1,8 @@
 // src/renderer/steering-echo.ts
 //
-// The receipt a mid-turn message leaves in scrollback (spec §7). ONE themed
-// helper for both echo paths: App.beginSubmit (ui/app.tsx) and the fallback
-// in repl.tsx handleSubmit for callers that bypass beginSubmit.
+// How a mid-turn message is shown (spec §7). LT-15 Feature 1 (D5): typing it
+// leaves no scrollback receipt any more; the App's live queue row shows it
+// while it waits, and the loop prints "↳ read · …" when the model reads it.
 import { paint } from './theme.js';
 import { sanitizeControlChars } from './sanitize.js';
 /** Wave1 fast-follow — only the first line, clipped, with a line count. */
@@ -20,12 +20,57 @@ export function formatSteeringEcho(text) {
     return out;
 }
 /**
- * `↳ queued · <first line…>` in the dim role, newline-terminated. The text may
- * come from a paste, so control characters are neutralised before it reaches
- * scrollback.
+ * One waiting or read message as shown: first line, clipped, no control
+ * characters, and each tab as one space (a tab is 0 wide to string-width, so
+ * Ink's truncate-end would cut too late and the line could wrap).
  */
-export function steeringEchoLine(text) {
-    return paint('dim', `↳ queued · ${sanitizeControlChars(formatSteeringEcho(text))}`) + '\n';
+function shownSteer(text) {
+    return sanitizeControlChars(formatSteeringEcho(text)).replace(/\t/g, ' ');
+}
+/**
+ * LT-15 Feature 1 (D5, F7) — the receipt the loop prints when the model reads
+ * a waiting message: `↳ read · <first line…>` in the dim role, one line per
+ * message (the caller adds the newline). The text may come from a paste, so
+ * it is clipped and control characters are neutralised.
+ */
+export function steeringReadLine(text) {
+    return paint('dim', `↳ read · ${shownSteer(text)}`);
+}
+/** The queue row shows at most this many messages; the rest are counted. */
+export const QUEUE_ROW_MAX_ITEMS = 3;
+/**
+ * LT-15 Feature 1 — the live row's lines (plain text, one terminal row each;
+ * App paints them dim and truncates to the width). Empty queue → no lines.
+ *
+ *   4 waiting · use ZPKG
+ *             · also check the tests… (+1 line)
+ *             · and the docs
+ *             + 1 more
+ *
+ * `maxLines` is the room left in the live area. When the full row does not
+ * fit it folds to ONE line, never fewer: `4 waiting · use ZPKG + 3 more`.
+ *
+ * LT-15 Feature 2 (review I6) — `canEdit` adds `· ↑ to edit` right after the
+ * count, only while ↑ would really take the last message back (the App
+ * decides). It sits before the messages so a long message never cuts it off.
+ * Without it the bytes are exactly the Task 2 ones.
+ */
+export function formatQueueRow(items, maxLines = Infinity, opts = {}) {
+    if (items.length === 0)
+        return [];
+    const count = `${items.length} waiting${opts.canEdit ? ' · ↑ to edit' : ''}`;
+    const full = Math.min(items.length, QUEUE_ROW_MAX_ITEMS) + (items.length > QUEUE_ROW_MAX_ITEMS ? 1 : 0);
+    if (full > Math.max(1, maxLines)) {
+        return [`${count} · ${shownSteer(items[0])} + ${items.length - 1} more`];
+    }
+    const head = `${count} `;
+    const pad = ' '.repeat(head.length);
+    const shown = items.slice(0, QUEUE_ROW_MAX_ITEMS);
+    const lines = shown.map((t, i) => `${i === 0 ? head : pad}· ${shownSteer(t)}`);
+    const rest = items.length - shown.length;
+    if (rest > 0)
+        lines.push(`${pad}+ ${rest} more`);
+    return lines;
 }
 export function classifyMidTurnLine(text) {
     const first = text.trim().split(/\s+/)[0] ?? '';

package/dist/renderer/tool-labels.js

@@ -1,4 +1,5 @@
 import { spillLabelFor } from '../lib/spill-labels.js';
+import { writtenObjectName } from '../approvals/op-labels.js';
 const OBJECT_MAX = 60;
 /**
  * Every value shown in a label goes through here: ANSI escape sequences and
@@ -108,7 +109,8 @@ const RULES = {
     },
     background_run: (a) => ({ verb: 'Started', object: shortRight(commandLine(a)) }),
     sap_get_source: sapObject('Read'),
-    sap_set_source: sapObject('Wrote'),
+    // LT-11 — an access control, metadata extension or behavior definition names its kind.
+    sap_set_source: (a) => ({ verb: 'Wrote', object: shortRight(writtenObjectName(str(a['type']), str(a['name']) ?? '')) }),
     sap_activate: (a) => ({ verb: 'Activated', object: shortRight(activateObject(a)) }),
     sap_syntax_check: sapObject('Checked syntax'),
     sap_atc_run: sapObject('Ran ATC on'),

package/dist/repl/chat-lane.js

@@ -113,8 +113,11 @@ export function turnStatusLabel(skill) {
 }
 /** D11 — the one dim line shown in place of the echo when the message re-runs through today's router. */
 export const CHAT_UNAVAILABLE_LINE = "Chat isn't available on this server yet — using skill routing.";
-export function chatFallbackOrigin() {
-    return { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE };
+export function chatFallbackOrigin(prose = false) {
+    // LT-15 Task 4 fix round 1 — a withdrawn prose replay re-runs as prose.
+    return prose
+        ? { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE, prose: true }
+        : { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE };
 }
 /**
  * The one place a process lane's tool side effect is applied (D5, §6.1).

package/dist/repl/inline-mode.js

@@ -0,0 +1,51 @@
+// cspeach-cli/src/repl/inline-mode.ts
+//
+// Stage 1A, Task 1A.1 — when `assistant.skills = inline` is active.
+//
+// Decided at EVERY submit from the inputs as they are then (rev 4 M4), never
+// cached, never stored in the session file: a resumed session re-decides from
+// today's config and today's proxy. The history is NOT an input (rev 5 S-B):
+// `assistant.skills = system`, `/chat off`, a non-TTY and a non-serving proxy
+// always win. The REPL passes the result to the loop as `ctx.inlineSkills`.
+// Piped stdin and one-shot never get it; reader and agent_run children never
+// carry it (their ctx is built field by field).
+import { servedInlineSkills } from '../models/server-config.js';
+/** True only for `skills = inline` in the chat lane, on a TTY, where the provider can serve it. */
+export function inlineActive({ skills, lane, interactive, served }) {
+    return interactive && served && skills === 'inline' && lane === 'chat';
+}
+/**
+ * Can this provider serve the inline system block? Managed: only when the
+ * proxy's served config says `inline_skills: true` (an old proxy, the kill
+ * switch or a stale cache ⇒ false). byok / ai-hub / azure / local build the
+ * system block on the laptop ⇒ true. Read at submit time: the served config
+ * loads after the config is read at startup.
+ */
+export function inlineServed(mode) {
+    if (mode === undefined)
+        return false;
+    return mode === 'managed' ? servedInlineSkills() : true;
+}
+/**
+ * The `config show` comment for a stored `inline` that would not be active in
+ * an interactive session; null when there is nothing to say.
+ */
+export function inlineInactiveReason(i) {
+    if (i.skills !== 'inline')
+        return null;
+    if (i.lane !== 'chat')
+        return 'not active: skill routing is on';
+    if (!i.served)
+        return 'not active: this server does not serve it';
+    return null;
+}
+/**
+ * Stage 1A, Task 1A.2 (S5) — an interactive chat-lane process: lane `chat` and
+ * a TTY, the condition applyLaneTools uses, whatever `assistant.skills` and the
+ * proxy say. In such a process the loop neutralises `<skill`, `<playbook` and
+ * `<session_context` in what the person sends (ctx.chatLaneProcess). Decided
+ * at every turn site like inlineActive.
+ */
+export function isChatLaneProcess(lane, interactive) {
+    return lane === 'chat' && interactive;
+}

package/dist/repl/leftover.js

@@ -0,0 +1,90 @@
+/**
+ * LT-15 Feature 4 — messages typed while CSPeach worked that are still
+ * waiting when a dispatch ends (Ink REPL only; classic, headless and one-shot
+ * never queue anything).
+ *
+ * The runner holds the per-dispatch flags (plan review I4): a Ctrl+C press,
+ * a turn error, a scheduled hop. They are set during the dispatch, read ONCE
+ * by `settle` at that dispatch's end (handleSubmit's finally, after release,
+ * or a restore's end), and reset right there, so a stale flag can never touch
+ * the next hop or turn.
+ *
+ * `settle` acts on leftoverDecision:
+ *  - run:      on the next tick, drain the queue THERE (a message typed
+ *              between the end and the tick rides along) and submit it once
+ *              as the person's prose. Nothing when a dispatch is already busy
+ *              (that turn reads the queue at its round 0, or its own end
+ *              decides) or the session is ending (I4.1, I4.3).
+ *  - to-input: ask the App to put the text back into the input box (D1, I5).
+ *  - wait / report-unsent / none: touch nothing. A queued hop reads the
+ *              message at its round 0 (D3); the exit reports what is left.
+ * Every message ends in exactly one place (I1.1).
+ */
+import { drainSteering, drainSteeringText, steeringSnapshot } from '../agent/steering-queue.js';
+import { leftoverDecision, unsentLine } from '../ui/interrupt.js';
+import { formatInfo } from '../renderer/notice-shape.js';
+import { parseShortcut } from '../router/classifier.js';
+export function createLeftoverRunner(deps) {
+    let ctrlCStop = false;
+    let errorEnd = false;
+    let dispatchScheduled = false;
+    const reset = () => {
+        ctrlCStop = false;
+        errorEnd = false;
+        dispatchScheduled = false;
+    };
+    return {
+        noteCtrlC() { ctrlCStop = true; },
+        noteError() { errorEnd = true; },
+        noteDispatchScheduled() { dispatchScheduled = true; },
+        reset,
+        settle(s) {
+            const decision = leftoverDecision({
+                done: deps.isDone(),
+                exitRequested: s.exitRequested,
+                forceExit: s.forceExit === true,
+                ctrlCStop,
+                braked: s.braked === true,
+                errorEnd,
+                dispatchScheduled,
+                restoreActive: s.restoreActive === true,
+                waiting: steeringSnapshot().length,
+            });
+            reset();
+            if (decision === 'run') {
+                deps.schedule(() => {
+                    if (deps.isDone() || deps.isBusy())
+                        return;
+                    const text = drainSteeringText();
+                    if (text !== null)
+                        deps.submit(text);
+                });
+            }
+            else if (decision === 'to-input') {
+                deps.toBox();
+            }
+            return decision;
+        },
+        toBoxOrReport() {
+            if (steeringSnapshot().length === 0)
+                return;
+            deps.toBox();
+            const left = drainSteering();
+            if (left.length > 0)
+                deps.print(formatInfo(unsentLine(left.length)));
+        },
+    };
+}
+/** At exit: drain what still waits and return the one line to print, or null. */
+export function takeUnsentReport() {
+    const left = drainSteering();
+    return left.length > 0 ? formatInfo(unsentLine(left.length)) : null;
+}
+/**
+ * LT-15 F4 — how a submitted line is read. A replayed waiting message is
+ * prose: never a slash command or an @-shortcut, so "/sap/bc/adt/x is slow"
+ * reaches the model as text. Anything typed at the prompt is read as today.
+ */
+export function parseSubmitted(input, prose) {
+    return prose ? { prompt: input } : parseShortcut(input);
+}

package/dist/repl/reroute-turn.js

@@ -13,7 +13,13 @@ export async function runRerouteTurn(p) {
         await p.run();
     }
     catch (err) {
-        await renderTurnError({ err, session: p.session, userInterrupted: p.signal?.aborted ?? false, inSession: true, print: p.print });
+        const stopped = p.signal?.aborted ?? false;
+        const line = stopped ? p.stopLine?.() ?? null : null;
+        if (line !== null)
+            p.print(line);
+        else
+            await renderTurnError({ err, session: p.session, userInterrupted: stopped, inSession: true, print: p.print });
+        p.onError?.();
     }
     finally {
         p.onFinally();

package/dist/repl/turn-stop.js

@@ -0,0 +1,64 @@
+/**
+ * LT-15 Task 5b — how the current dispatch was stopped (Ink REPL only;
+ * classic, headless and one-shot have no Esc brake).
+ *
+ * Per dispatch (plan review I4): set by the presses, read by autoDispatch
+ * (a queued hop / lane plan / switch is not started after ANY stop) and by
+ * the leftover runner's settle, then reset in handleSubmit's finally right
+ * after that settle, and at a restore's end. Never reset at controller
+ * creation, so a stale stop can never touch the next hop or turn.
+ *
+ * `press` is the Esc brake. It reuses what Ctrl+C already does — the SAME
+ * `currentTurnAbort.abort()` (deps.abortTurn) or, in the post-turn window,
+ * the SAME pending cancel (deps.cancelPending) — and never touches Ctrl+C's
+ * press count (review C1): after an Esc, one Ctrl+C is still Ctrl+C's FIRST
+ * press, never the force-exit.
+ */
+import { steeringSnapshot } from '../agent/steering-queue.js';
+import { decideEscape, brakeLine, brakeEndLine } from '../ui/interrupt.js';
+export function createTurnStop(deps) {
+    let braked = false;
+    let ctrlC = false;
+    const waiting = deps.waiting ?? (() => steeringSnapshot().length);
+    const decide = (ui) => decideEscape({
+        ...ui,
+        turnActive: deps.turnActive(),
+        busy: deps.busy(),
+        restoreActive: deps.restoreActive(),
+        phase: deps.phase(),
+        canChain: deps.canChain(),
+        alreadyStopped: braked || ctrlC || deps.exitRequested(),
+    });
+    const brake = () => {
+        braked = true;
+        deps.print(brakeLine(waiting() > 0));
+        deps.abortTurn();
+    };
+    return {
+        stopFromCard() {
+            // The card itself is the overlay that owned the key: decide as if
+            // nothing else were open. Only a running turn is stopped.
+            if (decide({ overlayOpen: false, bufferCount: 0, fuzzyOpen: false }) !== 'brake')
+                return 'none';
+            brake();
+            return 'brake';
+        },
+        press(ui) {
+            const action = decide(ui);
+            if (action === 'brake') {
+                brake();
+            }
+            else if (action === 'cancel-pending') {
+                braked = true;
+                deps.cancelPending();
+            }
+            return action;
+        },
+        noteCtrlCStop() { ctrlC = true; },
+        get braked() { return braked; },
+        get stopped() { return braked || ctrlC; },
+        get brakedOnly() { return braked && !ctrlC; },
+        endLine() { return brakeEndLine(waiting() > 0); },
+        reset() { braked = false; ctrlC = false; },
+    };
+}