@cspeach/cli 1.1.18 → 1.1.20

package/dist/agent/tool-dispatch.js

@@ -3,11 +3,20 @@ 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';
+import { READER_TOOLS } from '../tools/subagent/reader-prompt.js';
+const READER_TOOL_SET = new Set(READER_TOOLS);
 export async function dispatchTool(name, args, ctx) {
     const tool = getTool(name);
     if (!tool) {
         return { content: JSON.stringify({ error: `unknown_tool: ${name}` }), is_error: true };
     }
+    // Task 18 (ruling F22) — a reader subagent is read-only and depth 1: only
+    // its fixed tool list runs, whatever the model calls (no writes, no
+    // questions or approvals, no nested read_agent / agent_run, no shell).
+    if (ctx.readerMode && !READER_TOOL_SET.has(name)) {
+        return { content: `error: read-only reader — ${name} is not allowed here`, is_error: true };
+    }
     // Standalone safety net (2026-09-16). SAP-dependent tools are already
     // filtered out of the list the model sees (agent/loop.ts), but a model can
     // still call a tool it remembers from an earlier turn or from training. Fail
@@ -23,6 +32,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).
@@ -49,28 +89,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);
@@ -88,6 +110,29 @@ 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

package/dist/agent/tool-loading-pin.js

@@ -0,0 +1,100 @@
+/**
+ * Final review I2 (controller ruling, 2026-09-28) — the tool-loading mode is
+ * pinned on the SESSION, not resolved per process.
+ *
+ * The first request pins `session.tool_loading` to the mode that request
+ * uses (the process-resolved mode, gated by the model allow-list). A resumed
+ * session keeps its pinned mode: a 'static' session never turns deferred
+ * (its `tools[]` stays byte-stable), and a 'deferred' session stays deferred
+ * while the call allows it.
+ *
+ * A 'deferred' session must become 'static' when a call cannot take the
+ * deferred shapes: the admin kill switch, a failed startup config fetch
+ * (static until restart), `CSPEACH_TOOL_LOADING=static`, or a call on a model
+ * outside the allow-list (a plan-tier sonnet turn, an adopted opus-4-8). Its
+ * history then still holds deferred artefacts — `server_tool_use` /
+ * `tool_search_tool_result` blocks and `role: 'system'` tool_addition
+ * messages — which a request with no search tool and no deferred entries
+ * cannot carry. They are stripped ONCE, before that request, and the session
+ * is re-pinned 'static' so the strip never repeats. This is a deliberate
+ * one-time prefix rewrite, like /compact: every assistant message from the
+ * first edit on loses its thinking blocks (the API binds thinking to the exact
+ * prefix that produced it), the same stripThinking /compact and the cold
+ * prune apply.
+ */
+import { stripThinking } from '../commands/compact.js';
+import { modelAcceptsDeferredTools } from '../tools/tool-loading.js';
+const SERVER_TOOL_BLOCK_TYPES = new Set(['server_tool_use', 'tool_search_tool_result']);
+/** True when the history holds a shape only a deferred-mode request may carry. */
+export function hasDeferredArtefacts(messages) {
+    for (const m of messages ?? []) {
+        if (m?.role === 'system')
+            return true;
+        if (Array.isArray(m?.content) && m.content.some((b) => SERVER_TOOL_BLOCK_TYPES.has(b?.type)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Remove every deferred artefact from `messages` in place: `role: 'system'`
+ * messages, and `server_tool_use` / `tool_search_tool_result` blocks (a
+ * message left with no content is dropped). Every assistant message from the
+ * first edit on loses its thinking blocks (a thinking-only message keeps a
+ * placeholder text). Returns the number of messages and blocks removed; 0 ⇒
+ * untouched. Idempotent.
+ */
+export function stripDeferredArtefacts(messages) {
+    let removed = 0;
+    let firstEdit = -1;
+    const out = [];
+    for (const m of messages) {
+        if (m?.role === 'system') {
+            removed++;
+            if (firstEdit < 0)
+                firstEdit = out.length;
+            continue;
+        }
+        if (Array.isArray(m?.content)) {
+            const kept = m.content.filter((b) => !SERVER_TOOL_BLOCK_TYPES.has(b?.type));
+            if (kept.length !== m.content.length) {
+                removed += m.content.length - kept.length;
+                if (firstEdit < 0)
+                    firstEdit = out.length;
+                if (kept.length > 0)
+                    out.push({ ...m, content: kept });
+                continue;
+            }
+        }
+        out.push(m);
+    }
+    if (removed === 0)
+        return 0;
+    for (let i = firstEdit; i < out.length; i++)
+        out[i] = stripThinking(out[i]);
+    messages.splice(0, messages.length, ...out);
+    return removed;
+}
+/**
+ * Decide the tool-loading mode for one call and keep the session consistent
+ * with it. `resolved` is the process-resolved mode (resolveToolLoading);
+ * `model` is the model this call sends. Mutates `session.tool_loading` and,
+ * on a deferred → static change, `session.messages` (see the file comment).
+ */
+export function settleSessionToolLoading(session, i) {
+    const allowed = i.resolved === 'deferred' && modelAcceptsDeferredTools(i.model) ? 'deferred' : 'static';
+    // A session saved before the pin existed: its history tells how it ran.
+    const pinned = session.tool_loading
+        ?? (hasDeferredArtefacts(session.messages) ? 'deferred' : undefined);
+    if (pinned === undefined) {
+        session.tool_loading = allowed;
+        return { mode: allowed, stripped: 0 };
+    }
+    if (pinned === 'deferred' && allowed === 'deferred') {
+        session.tool_loading = 'deferred';
+        return { mode: 'deferred', stripped: 0 };
+    }
+    // Static for this call (and from now on): strip once, pin 'static'.
+    session.tool_loading = 'static';
+    const stripped = pinned === 'deferred' ? stripDeferredArtefacts(session.messages) : 0;
+    return { mode: 'static', stripped };
+}

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 {