@cspeach/cli 1.1.17 → 1.1.19

package/dist/agent/tool-dispatch.js

@@ -3,6 +3,7 @@ import { getTool, isStandalone } from '../tools/index.js';
 import { NOT_CONNECTED_MESSAGE } from '../sap/offline-adt-client.js';
 import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
 import { shouldGateRule8, recordWriteOp, renderPlanSummary, getWriteOpsThisTurn, } from '../repl/rule8-detector.js';
+import { isCredentialHandoverApproved, markCredentialHandoverApproved, } from '../repl/credential-handover-gate.js';
 export async function dispatchTool(name, args, ctx) {
     const tool = getTool(name);
     if (!tool) {
@@ -23,6 +24,37 @@ export async function dispatchTool(name, args, ctx) {
             is_error: true,
         };
     }
+    // L1-6 R1-6 (owner decision 2026-09-21) — a call that hands the stored SAP
+    // login to a local child process ALWAYS asks a human, once per session per
+    // alias, even as the first mutating call of a turn (where Rule 8 below stays
+    // silent). Headless runs are declined, never auto-approved.
+    // The hook may be async (it reads the app's files). A hook that throws is
+    // doubt — never let the call through unprompted: fail the call instead.
+    let handover = null;
+    try {
+        handover = (await tool.credentialHandover?.(args, ctx)) ?? null;
+    }
+    catch (err) {
+        return {
+            content: JSON.stringify({ error: 'credential_handover_check_failed', reason: String(err) }),
+            is_error: true,
+        };
+    }
+    const sessionId = ctx.session?.id;
+    if (handover && !isCredentialHandoverApproved(sessionId, handover.alias)) {
+        const r = await presentSafetyConfirmation({
+            rule: 'CREDENTIAL_HANDOVER',
+            op: tool.name,
+            object: { type: 'SAP login', name: handover.alias },
+            what_will_happen: handover.summary,
+            rollback_available: false, // a handed-over secret cannot be taken back
+            transport: '',
+            args,
+        });
+        if (!r.confirmed)
+            return declined(r);
+        markCredentialHandoverApproved(sessionId, handover.alias);
+    }
     // Rule 8 — no batch without plan. 2nd+ mutating call this turn requires
     // explicit confirmation. Fires regardless of /safety-mode toggle (batch
     // detection is unconditional per Plan 3 §6.6).
@@ -31,7 +63,12 @@ export async function dispatchTool(name, args, ctx) {
     // GUIDE.md) — local scratch, not SAP objects. Rule 8 protects SAP batches;
     // applying it here made the 2nd+ file (GUIDE.md) hit the batch card and,
     // headless, get refused. Exempt from the gate AND from the batch count.
-    const scratchWrite = isScratchOutputWrite(tool, args, ctx.cwd);
+    // Local project work (owner decision 2026-09-25, CAP spike F2): the same
+    // reasoning for ALL local work — file edits (the filesystem tools refuse any
+    // path outside the project) and the safelisted local build commands. One-shot
+    // refused the 2nd edit of a CAP schema and left it half-changed. SAP writes
+    // are gated exactly as before.
+    const scratchWrite = isLocalProjectWork(tool, args) || isScratchOutputWrite(tool, args, ctx.cwd);
     if (tool.isMutating && !scratchWrite && shouldGateRule8()) {
         const r = await presentSafetyConfirmation({
             rule: 'RULE_8_BATCH_PLAN',
@@ -44,28 +81,10 @@ export async function dispatchTool(name, args, ctx) {
             rollback_available: true, // snapshots taken per-write
             transport: typeof args?.transport === 'string' ? args.transport : '',
             batch_count: getWriteOpsThisTurn().length + 1,
+            args,
         });
-        if (!r.confirmed) {
-            // B5 — discriminate WHO declined. A headless fail-fast (nobody ever
-            // saw the card) must not masquerade as a user decision: the model
-            // (and any transcript reader) reacts differently to "the user said
-            // no" vs "no user was available to say yes". Uniform `headless: true`
-            // marker matches the other headless result payloads.
-            if (r.headless) {
-                return {
-                    content: JSON.stringify({
-                        error: 'headless_safety_decline',
-                        headless: true,
-                        reason: r.reason,
-                    }),
-                    is_error: true,
-                };
-            }
-            return {
-                content: JSON.stringify({ error: 'cancelled_by_user', reason: r.reason }),
-                is_error: true,
-            };
-        }
+        if (!r.confirmed)
+            return declined(r);
     }
     try {
         const result = await tool.handler(args, ctx);
@@ -83,6 +102,45 @@ export async function dispatchTool(name, args, ctx) {
         return { content: JSON.stringify({ error: String(err) }), is_error: true };
     }
 }
+/**
+ * B5 — discriminate WHO declined a safety card. A headless fail-fast (nobody
+ * ever saw the card) must not masquerade as a user decision: the model (and
+ * any transcript reader) reacts differently to "the user said no" vs "no user
+ * was available to say yes". Uniform `headless: true` marker matches the
+ * other headless result payloads.
+ */
+function declined(r) {
+    if (r.headless) {
+        return {
+            content: JSON.stringify({
+                error: 'headless_safety_decline',
+                headless: true,
+                reason: r.reason,
+            }),
+            is_error: true,
+        };
+    }
+    return {
+        content: JSON.stringify({ error: 'cancelled_by_user', reason: r.reason }),
+        is_error: true,
+    };
+}
+/**
+ * True for local project work: the filesystem tools (confined to the project
+ * folder by resolveSafePath) and shell_exec (a hardcoded safelist of local build
+ * and VCS commands run in the project). Neither touches an SAP object, which is
+ * what Rule 8 protects — EXCEPT a deploy or publish: `npm run deploy` /
+ * `ui5 deploy` / `fiori deploy` upload to the ABAP repository, so any shell
+ * command with a deploy/publish argument still counts (deliberately broad).
+ */
+export function isLocalProjectWork(tool, args) {
+    if (tool.category === 'filesystem')
+        return true;
+    if (tool.category !== 'shell')
+        return false;
+    const argv = [args?.command, ...(Array.isArray(args?.args) ? args.args : [])].map((a) => String(a ?? ''));
+    return !argv.some((a) => /deploy|publish/i.test(a));
+}
 /**
  * True for a mutating filesystem tool whose target sits under the project's
  * own ./cspeach-out/ (cwd). Accepts `cspeach-out/…`, `./cspeach-out/…`, the

package/dist/agent/turn-error-ux.js

@@ -5,8 +5,8 @@
  * everything. The new behaviour:
  *
  *   - Writes the full error (message + stack) to ~/.cspeach/logs/<sessionId>-<ts>.log
- *   - Prints a clean 4-6 line block to stderr with: cause, session id,
- *     stream path, log path, resume hint.
+ *   - Prints the piece 2 failure shape to stderr: cause, session id,
+ *     stream path, log path and resume facts as dim detail, then one Next: line.
  *   - Never throws — best-effort. The CLI returns to the prompt cleanly so
  *     the user can either resume or type a new prompt.
  *
@@ -14,7 +14,9 @@
  * pushed any partial assistant content onto session.messages and saved
  * the session before the throw bubbled here. Resume picks up that state.
  */
-import chalk from 'chalk';
+import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
+import { paint } from '../renderer/theme.js';
+import { getLook } from '../renderer/look.js';
 import { promises as fs } from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
@@ -48,7 +50,37 @@ export function describeError(err) {
         return 'network timeout';
     if (msg.toLowerCase().includes('aborterror'))
         return 'request aborted';
-    return msg.slice(0, 200);
+    const api = describeApiError(err, msg);
+    if (api)
+        return api;
+    return msg.replace(/\s+/g, ' ').trim().slice(0, 200);
+}
+/**
+ * 2026-09-27 — an upstream API error arrives as `Error: 400 {"type":"error",
+ * "error":{…,"message":"…"},"request_id":"…"}`. Show ONE readable line
+ * (`service error 400: <message>`), never the raw JSON body.
+ */
+function describeApiError(err, msg) {
+    const brace = msg.indexOf('{');
+    if (brace < 0)
+        return null;
+    const end = msg.lastIndexOf('}');
+    let body;
+    try {
+        body = JSON.parse(msg.slice(brace, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (!body || typeof body !== 'object')
+        return null;
+    const head = msg.slice(0, brace).match(/(\d{3})\s*$/);
+    const statusRaw = head?.[1] ?? err?.status;
+    const status = statusRaw != null && /^\d{3}$/.test(String(statusRaw)) ? String(statusRaw) : null;
+    const inner = body?.error?.message ?? body?.message;
+    const text = typeof inner === 'string' ? inner.replace(/\s+/g, ' ').trim() : '';
+    const label = status ? `service error ${status}` : 'service error';
+    return (text ? `${label}: ${text}` : label).slice(0, 200);
 }
 /**
  * Write a full diagnostic log to ~/.cspeach/logs/<sessionId>-<ts>.log.
@@ -96,38 +128,57 @@ async function writeErrorLog(sessionId, err) {
         return null;
     }
 }
+/** Print a multi-line block through the line-based `print` sink. */
+function printBlock(print, block) {
+    for (const l of block.replace(/\n$/, '').split('\n'))
+        print(l);
+}
 /**
- * Render the user-facing turn-error block. Writes a log file (best-effort)
- * and prints a 4-6 line diagnostic that names the cause + the recovery path.
+ * Render the user-facing turn-error block (piece 2 §9 failure shape). Writes a
+ * log file (best-effort) and prints the cause plus the Session, Stream, Log and
+ * Resume facts as dim detail, ending with ONE Next: line — "type continue"
+ * inside a live session, `cspeach --resume <id>` otherwise.
  */
 export async function renderTurnError(input) {
     const print = input.print ?? ((line) => process.stderr.write(line + '\n'));
+    const id = input.session.id;
+    const resumeRows = [
+        `Resume:  cspeach --resume ${id}`,
+        `         cspeach --resume  (no arg → pick from a list)`,
+    ];
     print('');
     if (input.userInterrupted) {
-        // User pressed Ctrl+C / Esc — frame as a deliberate cancellation,
-        // not a crash. Skip the log file (no diagnostic value).
-        print(chalk.yellow(`✋  Turn cancelled.`));
-        print(chalk.gray(`   Session: ${input.session.id}`));
-        print(chalk.gray(`   Resume:  cspeach --resume ${input.session.id}`));
-        print(chalk.gray(`            cspeach --resume  (no arg → pick from a list)`));
+        // User pressed Ctrl+C / Esc — a deliberate cancellation, not a crash.
+        // Skip the log file (no diagnostic value). Round 6 item 4d — the panels
+        // shape: ONE notice line. Review M4 — the legacy look keeps its rows.
+        if (getLook() === 'panels') {
+            printBlock(print, formatInfo(input.inSession
+                ? 'Turn cancelled · your work so far is kept · type continue to pick up'
+                : `Turn cancelled · resume: cspeach --resume ${id}`));
+        }
+        else {
+            printBlock(print, formatInfo('Turn cancelled'));
+            for (const r of [`Session: ${id}`, ...resumeRows])
+                print(`  ${paint('dim', r)}`);
+        }
         print('');
         return;
     }
     const reason = describeError(input.err);
-    const logPath = await writeErrorLog(input.session.id, input.err);
-    print(chalk.red(`⚠  Turn interrupted: ${reason}`));
-    if (input.inSession) {
-        print(chalk.yellow(`   Your work so far is saved. Type continue to pick up where it stopped.`));
-    }
-    print(chalk.gray(`   Session: ${input.session.id}`));
-    if (input.streamFilePath) {
-        print(chalk.gray(`   Stream:  ${input.streamFilePath}`));
-    }
-    if (logPath) {
-        print(chalk.gray(`   Log:     ${logPath}`));
-    }
-    print(chalk.gray(`   Resume:  cspeach --resume ${input.session.id}`));
-    print(chalk.gray(`            cspeach --resume  (no arg → pick from a list)`));
+    const logPath = await writeErrorLog(id, input.err);
+    const detail = [reason, `Session: ${id}`];
+    if (input.streamFilePath)
+        detail.push(`Stream:  ${input.streamFilePath}`);
+    if (logPath)
+        detail.push(`Log:     ${logPath}`);
+    detail.push(...resumeRows);
+    printBlock(print, formatFailure({
+        what: 'Turn interrupted',
+        detail,
+        next: input.inSession
+            ? 'type continue to pick up where it stopped (your work so far is saved)'
+            : `cspeach --resume ${id}`,
+    }));
     print('');
 }
 /** Re-export for callers that want to compute a stream path independently. */

package/dist/agent/turn-stream.js

@@ -29,6 +29,17 @@ export function streamsRoot() {
 export class TurnStreamWriter {
     filePath;
     headerWritten = false;
+    /**
+     * Fix round 3 (item 11a) — every write runs after the previous one. The
+     * loop calls append() per text delta WITHOUT awaiting, so unserialised
+     * appendFile calls interleaved on disk (a scrambled log) and two racing
+     * first appends could each write the header.
+     */
+    chain = Promise.resolve();
+    enqueue(work) {
+        this.chain = this.chain.then(work, work);
+        return this.chain;
+    }
     constructor(sessionId, startedAt = new Date()) {
         // ISO timestamp with filename-safe punctuation.
         const stamp = startedAt.toISOString().replace(/[:.]/g, '-');
@@ -43,9 +54,12 @@ export class TurnStreamWriter {
      * file-IO errors so a write hiccup never kills a working turn. Lazily writes
      * a small header on the first append so an unused turn produces no file.
      */
-    async append(text) {
+    append(text) {
         if (!text || text.length === 0)
-            return;
+            return Promise.resolve();
+        return this.enqueue(() => this.write(text));
+    }
+    async write(text) {
         try {
             if (!this.headerWritten) {
                 await fs.mkdir(path.dirname(this.filePath), { recursive: true });
@@ -63,7 +77,15 @@ export class TurnStreamWriter {
      * Close the stream with an optional footer (token totals, duration, end
      * status). Idempotent — safe to call multiple times.
      */
-    async close(footer) {
+    close(footer) {
+        return this.enqueue(() => this.writeFooter(footer));
+    }
+    async writeFooter(footer) {
+        // Round 6 item 4e — a turn cut before it streamed any text (a cancel
+        // while thinking, /exit mid-turn) still gets a log with its footer, so
+        // the goodbye can point at it. A clean turn with no text writes nothing.
+        if (!this.headerWritten && footer)
+            await this.write('');
         if (!this.headerWritten)
             return;
         try {

package/dist/approvals/adt-type.js

@@ -0,0 +1,27 @@
+/**
+ * Re-review item 3 — one normaliser for object types, shared by the syntax
+ * state (tools/syntax-state.ts) and the 8e risk-floor backstop. Approvals
+ * carry whatever type word the model chose ("CLASS", "Program", "PROG/P");
+ * the syntax state records the tool's ADT code. Unknown words return
+ * undefined so the caller can fall back to a name-only match.
+ */
+const ALIASES = {
+    CLASS: 'CLAS', PROGRAM: 'PROG', REPORT: 'PROG', INTERFACE: 'INTF',
+    'FUNCTION GROUP': 'FUGR', FUNCTIONGROUP: 'FUGR', 'FUNCTION MODULE': 'FUNC', FUNCTION: 'FUNC',
+    TABLE: 'TABL', STRUCTURE: 'TABL', 'DATA ELEMENT': 'DTEL', DOMAIN: 'DOMA', INCLUDE: 'PROG',
+    'CDS VIEW': 'DDLS', CDS: 'DDLS', 'CDS VIEW ENTITY': 'DDLS', 'BEHAVIOR DEFINITION': 'BDEF', 'BEHAVIOUR DEFINITION': 'BDEF',
+    'SERVICE DEFINITION': 'SRVD', 'SERVICE BINDING': 'SRVB', 'METADATA EXTENSION': 'DDLX', 'ACCESS CONTROL': 'DCLS',
+    'MESSAGE CLASS': 'MSAG', PACKAGE: 'DEVC',
+};
+const CODES = new Set([
+    'CLAS', 'PROG', 'INTF', 'FUGR', 'FUNC', 'TABL', 'DTEL', 'DOMA', 'DDLS', 'BDEF', 'SRVD', 'SRVB',
+    'DDLX', 'DCLS', 'MSAG', 'DEVC', 'ENHO', 'XSLT', 'TTYP', 'VIEW', 'SHLP', 'NROB',
+]);
+/** ADT code (CLAS, PROG, …) for a type word, or undefined when unknown. */
+export function normaliseAdtType(type) {
+    const t = (type ?? '').trim().toUpperCase().replace(/\s+/g, ' ');
+    const head = t.split('/')[0].trim();
+    if (CODES.has(head))
+        return head;
+    return ALIASES[t] ?? ALIASES[head];
+}

package/dist/approvals/advisory-prompt.js

@@ -1,7 +1,55 @@
 import clipboardy from 'clipboardy';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
+import { shouldUseInk } from '../renderer/tty.js';
+import { emitTrace, formatDecisionTrace } from '../renderer/trace.js';
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { askConfirm } from '../ui/confirm-request.js';
+const ADVISORY_LABEL = { applied: 'I applied it', skipped: 'Skip', aborted: 'Stop' };
+/**
+ * Piece 2 §6.2 — Ink: the proposal goes to scrollback once; a confirm card
+ * holds the choices. `c` copies, shows "· Copied" and asks again (not a
+ * decision, as today). y/c/s/n and the words yes/skip/abort still work.
+ * Esc / no listener → 'aborted': stop, nothing is written. The cursor starts
+ * on Copy, so a bare Enter decides nothing (as a bare Enter does today).
+ */
+async function promptAdvisoryInk(args) {
+    emitTrace(args.displayText);
+    for (;;) {
+        const res = await askConfirm({
+            id: 'advisory-proposal',
+            tag: 'ADVISORY',
+            title: 'Did you apply this change in ADT or SE80?',
+            facts: ['The proposal is shown above.', 'Nothing is written to SAP from here.'],
+            choices: [
+                { value: 'applied', label: ADVISORY_LABEL.applied },
+                { value: 'copy', label: 'Copy to clipboard' },
+                { value: 'skipped', label: ADVISORY_LABEL.skipped },
+                { value: 'aborted', label: ADVISORY_LABEL.aborted },
+            ],
+            initial: 1,
+            aliases: {
+                y: 'applied', yes: 'applied', applied: 'applied',
+                c: 'copy', copy: 'copy',
+                s: 'skipped', skip: 'skipped', skipped: 'skipped',
+                n: 'aborted', no: 'aborted', abort: 'aborted', aborted: 'aborted',
+            },
+            footnote: 'Advisory mode',
+        }, { trace: false });
+        if (res.value === 'copy') {
+            await clipboardy.write(args.clipboardText);
+            emitTrace(paint('dim', `${getGlyphs().info} Copied`));
+            continue;
+        }
+        const outcome = res.value === 'applied' ? 'applied' : res.value === 'skipped' ? 'skipped' : 'aborted';
+        emitTrace(formatDecisionTrace('Advisory proposal', ADVISORY_LABEL[outcome]));
+        return outcome;
+    }
+}
 export async function promptAdvisory(args) {
+    if (shouldUseInk())
+        return promptAdvisoryInk(args);
     output.write(args.displayText + '\n');
     const rl = readline.createInterface({ input, output });
     try {

package/dist/approvals/advisory-render.js

@@ -1,12 +1,25 @@
 import chalk from 'chalk';
-export function renderAdvisoryProposal(args) {
+import { paint } from '../renderer/theme.js';
+import { uiWidth } from '../renderer/ui-width.js';
+import { sanitizeControlChars as clean } from '../renderer/sanitize.js';
+const ADVISORY_TITLE = ' ADVISORY MODE — proposed change (no SAP write will occur) ';
+export const ADVISORY_KEY_HINT = 'Press c to copy to clipboard, y when applied, s to skip, n to abort.';
+export function renderAdvisoryProposal(args, opts = {}) {
+    // Model text is shown with control characters made harmless (it must not
+    // drive the terminal); the clipboard copy keeps it verbatim.
     const displayParts = [];
     const clipboardParts = [];
-    displayParts.push(chalk.yellow.bold('╔══ ADVISORY MODE — proposed change (no SAP write will occur) ══╗'));
-    displayParts.push(chalk.bold(`Summary: ${args.summary}`));
+    // Borders line up: top and bottom share one width (§1.4 rule, widened
+    // only if the title itself would not fit).
+    const w = Math.max(uiWidth(), ADVISORY_TITLE.length + 6);
+    const top = '╔══' + ADVISORY_TITLE + '═'.repeat(w - 4 - ADVISORY_TITLE.length) + '╗';
+    const bottom = '╚' + '═'.repeat(w - 2) + '╝';
+    const rule = paint('dim', '─'.repeat(w));
+    displayParts.push(chalk.bold(paint('warn', top)));
+    displayParts.push(chalk.bold(`Summary: ${clean(args.summary)}`));
     displayParts.push(`Risk: ${args.risk}`);
     if (args.transport)
-        displayParts.push(`Target transport: ${args.transport}`);
+        displayParts.push(`Target transport: ${clean(args.transport)}`);
     displayParts.push('');
     clipboardParts.push(`# ${args.summary}`);
     if (args.transport)
@@ -14,21 +27,22 @@ export function renderAdvisoryProposal(args) {
     clipboardParts.push('');
     args.changes.forEach((change, idx) => {
         const header = `Change ${idx + 1}: ${change.op.toUpperCase()} ${change.type} ${change.object}`;
-        displayParts.push(chalk.cyan(header));
+        displayParts.push(paint('sap', clean(header)));
         clipboardParts.push(`## ${header}`);
         if (change.diff) {
-            displayParts.push(chalk.gray('─'.repeat(64)));
-            displayParts.push(change.diff);
-            displayParts.push(chalk.gray('─'.repeat(64)));
+            displayParts.push(rule);
+            displayParts.push(clean(change.diff));
+            displayParts.push(rule);
             clipboardParts.push('');
             clipboardParts.push(change.diff);
             clipboardParts.push('');
         }
     });
     displayParts.push('');
-    displayParts.push(chalk.yellow('Next step: open this object in ADT or SE80, apply the change, save and activate.'));
-    displayParts.push(chalk.gray('Press c to copy to clipboard, y when applied, s to skip, n to abort.'));
-    displayParts.push(chalk.yellow.bold('╚══════════════════════════════════════════════════════════════════╝'));
+    displayParts.push(paint('warn', 'Next step: open this object in ADT or SE80, apply the change, save and activate.'));
+    if (opts.interactiveHint !== false)
+        displayParts.push(paint('dim', ADVISORY_KEY_HINT));
+    displayParts.push(chalk.bold(paint('warn', bottom)));
     clipboardParts.push('');
     clipboardParts.push('# This is an advisory proposal. Apply manually in ADT/SE80.');
     return {

package/dist/approvals/approval-prompt.js

@@ -1,10 +1,19 @@
 import chalk from 'chalk';
+import stringWidth from 'string-width';
 import { loadConfig, saveConfig } from '../config/loader.js';
-const BOX_WIDTH = 62;
-const TOP = '┌' + '─'.repeat(BOX_WIDTH) + '┐';
-const BOTTOM = '└' + '─'.repeat(BOX_WIDTH) + '┘';
-const pad = (s) => '│  ' + s.padEnd(BOX_WIDTH - 2) + '│';
-const blank = '│' + ' '.repeat(BOX_WIDTH) + '│';
+import { shouldUseInk } from '../renderer/tty.js';
+import { uiWidth } from '../renderer/ui-width.js';
+import { paint } from '../renderer/theme.js';
+import { emitTrace } from '../renderer/trace.js';
+import { askConfirm } from '../ui/confirm-request.js';
+// Classic box: width from the §1.4 rule (was a fixed 62); padding counts
+// VISIBLE cells (string-width ignores ANSI) so coloured rows line up with
+// plain ones. (strip-ansi is a devDependency only — not usable here.)
+const boxWidth = () => uiWidth() - 2;
+const top = () => '┌' + '─'.repeat(boxWidth()) + '┐';
+const bottom = () => '└' + '─'.repeat(boxWidth()) + '┘';
+const pad = (s) => '│  ' + s + ' '.repeat(Math.max(0, boxWidth() - 2 - stringWidth(s))) + '│';
+const blank = () => '│' + ' '.repeat(boxWidth()) + '│';
 /**
  * Capture a single keypress for the y/n/d answer. Raw-mode readline so the
  * hand-drawn box stays the only visible affordance.
@@ -43,6 +52,31 @@ async function promptNagChoice() {
         process.stdin.on('data', onData);
     });
 }
+/**
+ * Piece 2 §6.1 — under Ink the nag is a confirm card in the card slot.
+ * Raw stdin reads while Ink is mounted steal or double keystrokes.
+ * y / n / d stay as keys; Esc (or no listener) is 'n', like Ctrl+C today.
+ * Cursor starts on "No": the one choice that writes nothing.
+ */
+async function promptNagChoiceInk(sapAlias) {
+    const res = await askConfirm({
+        id: 'auto-approve-nag',
+        tag: 'QUESTION',
+        title: `Auto-approve low-risk changes on ${sapAlias}?`,
+        facts: [
+            'This change was classified as low risk.',
+            `Today every change on ${sapAlias} asks you first.`,
+        ],
+        choices: [
+            { value: 'y', label: 'Yes, auto-approve low-risk changes', hint: 'DEV systems only' },
+            { value: 'n', label: 'No, keep asking every time' },
+            { value: 'd', label: `Don't ask me this again on ${sapAlias}` },
+        ],
+        initial: 1,
+        aliases: { y: 'y', n: 'n', d: 'd' },
+    });
+    return res.value === 'y' || res.value === 'd' ? res.value : 'n';
+}
 /**
  * Called just before `renderPerChangeApproval` when the current change
  * is low-risk on a `never` system and the nag has not been dismissed.
@@ -61,29 +95,42 @@ export async function maybeShowAutoApproveNag(ctx) {
         return;
     if (sapCfg.nag_dismissed ?? false)
         return;
-    // Draw the box. This is the ONLY visible UI — keypress answers it directly.
-    console.log('');
-    console.log(TOP);
-    console.log(blank);
-    console.log(pad(chalk.yellow('This change was classified as LOW risk.')));
-    console.log(blank);
-    console.log(pad(`Your current policy on ${ctx.sapAlias} prompts on everything.`));
-    console.log(pad('Want to auto-approve low-risk changes on this system?'));
-    console.log(blank);
-    console.log(pad(chalk.green('[y] yes') + '  (safer for DEV systems only)'));
-    console.log(pad(chalk.dim('[n] no ') + '  (keep prompting every time)'));
-    console.log(pad(chalk.dim('[d] don\'t ask me this again (on ' + ctx.sapAlias + ')')));
-    console.log(blank);
-    console.log(BOTTOM);
-    process.stdout.write(chalk.dim('Press y / n / d: '));
-    const choice = await promptNagChoice();
+    const ink = shouldUseInk();
+    let choice;
+    if (ink) {
+        choice = await promptNagChoiceInk(ctx.sapAlias);
+    }
+    else {
+        // Classic: the box is the UI — keypress answers it directly.
+        console.log('');
+        console.log(top());
+        console.log(blank());
+        console.log(pad(chalk.yellow('This change was classified as LOW risk.')));
+        console.log(blank());
+        console.log(pad(`Your current policy on ${ctx.sapAlias} prompts on everything.`));
+        console.log(pad('Want to auto-approve low-risk changes on this system?'));
+        console.log(blank());
+        console.log(pad(chalk.green('[y] yes') + '  (safer for DEV systems only)'));
+        console.log(pad(chalk.dim('[n] no ') + '  (keep prompting every time)'));
+        console.log(pad(chalk.dim('[d] don\'t ask me this again (on ' + ctx.sapAlias + ')')));
+        console.log(blank());
+        console.log(bottom());
+        process.stdout.write(chalk.dim('Press y / n / d: '));
+        choice = await promptNagChoice();
+    }
     if (choice === 'y') {
         const fresh = await loadConfig(); // re-read to avoid stale write
         if (fresh.sap[ctx.sapAlias]) {
             fresh.sap[ctx.sapAlias].auto_approve = 'low';
             await saveConfig(fresh);
-            console.log(chalk.green(`Auto-approve set to "low" for ${ctx.sapAlias}.`));
-            console.log(chalk.gray('Change with: cspeach config set sap.' + ctx.sapAlias + '.auto_approve never\n'));
+            if (ink) {
+                emitTrace(paint('ok', `Auto-approve set to "low" for ${ctx.sapAlias}.`));
+                emitTrace(paint('dim', `Change with: cspeach config set sap.${ctx.sapAlias}.auto_approve never`));
+            }
+            else {
+                console.log(chalk.green(`Auto-approve set to "low" for ${ctx.sapAlias}.`));
+                console.log(chalk.gray('Change with: cspeach config set sap.' + ctx.sapAlias + '.auto_approve never\n'));
+            }
         }
     }
     else if (choice === 'd') {
@@ -93,7 +140,10 @@ export async function maybeShowAutoApproveNag(ctx) {
         if (fresh.sap[ctx.sapAlias]) {
             fresh.sap[ctx.sapAlias].nag_dismissed = true;
             await saveConfig(fresh);
-            console.log(chalk.gray(`Noted. This prompt will not appear again on ${ctx.sapAlias}.\n`));
+            if (ink)
+                emitTrace(paint('dim', `Noted. This prompt will not appear again on ${ctx.sapAlias}.`));
+            else
+                console.log(chalk.gray(`Noted. This prompt will not appear again on ${ctx.sapAlias}.\n`));
         }
     }
     // 'n' → no config change, fall through to per-change approval normally.

package/dist/approvals/jwt.js

@@ -55,12 +55,13 @@ export async function mintApprovalId(payload) {
  * through this function instead of calling mintApprovalId with a free-text
  * object string.
  */
-export async function mintChangeApproval(change, sessionId) {
+export async function mintChangeApproval(change, sessionId, opts = {}) {
     return mintApprovalId({
         object: canonicalApprovalObject(change.object),
         type: change.type,
         op: change.op,
         session_id: sessionId,
+        ...(opts.auto ? { auto: true } : {}),
     });
 }
 export async function verifyAndSpendApprovalId(jwt, expectedObject, expectedOp) {