@cspeach/cli 1.1.18 → 1.1.19

package/dist/projects/plan-run.js

@@ -6,6 +6,12 @@
 // picker, the tracker renderer, and the revision builder unit-testable
 // without touching disk.
 import chalk from 'chalk';
+import stringWidth from 'string-width';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { paint } from '../renderer/theme.js';
+import { countLabel } from '../renderer/checklist-format.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
+import { truncateToWidth, uiWidth } from '../renderer/ui-width.js';
 /** Statuses a dead session may have left behind — resumable, picked before fresh `todo`s. */
 const IN_PROGRESS = ['designing', 'building', 'verifying'];
 /**
@@ -29,8 +35,8 @@ export function isAuditResolved(audit) {
     // against the work — and the phase already passed its own exit gate
     // (activation + ATC) — so walling verified work on an infra outage is wrong.
     // It resolves like a warn: dependants unlock, the chain continues, and the
-    // "not verified" fact is surfaced (loud chain note + the ⚠ audit-not-run
-    // glyph) and recorded (state stays infra_failed; NOT laundered to waived).
+    // "not verified" fact is surfaced (loud chain note + the `! audit not run`
+    // tag) and recorded (state stays infra_failed; NOT laundered to waived).
     return audit.state === 'passed' || audit.state === 'waived'
         || audit.state === 'warn' || audit.state === 'infra_failed';
 }
@@ -85,13 +91,14 @@ export function computeNextPhase(phases, statuses) {
 }
 /**
  * Plan-progress board printed before and after every resume turn (and by
- * `--status` for plan envelopes). Plain text — flows through chunkEmitter
- * in Ink mode and console.log in classic mode alike.
+ * `--status` for plan envelopes). Flows through chunkEmitter in Ink mode and
+ * console.log in classic mode alike.
  *
- *   ─ Plan: HR Dayforce Extract (v3) ── 2/7 validated ─
- *     ✔ c1.types          abap-data-model  → ZDOM_DAYF_STATUS (S4HK903412)
- *     ▶ c1.orchestration  abap-generate    ← THIS SESSION
- *     ○ c1.integration    abap-generate    (needs c1.orchestration)
+ *   HR Dayforce Extract (v3) · 2 of 7 done
+ *
+ *     ✓ Types — ZDOM_DAYF_STATUS ✓ audited
+ *     ◼ Tables — Reason checktable + text table active
+ *     ☐ Service — Service binding published
  */
 // Human phase labels — a phase is named for the KIND of work it does, so a
 // non-ABAP reader can follow the plan. The exit-gate / produced objects carry
@@ -140,89 +147,120 @@ function phaseDetail(p, s) {
     return shortGate(p.exitGate);
 }
 /**
- * Auditor-verdict glyph rendered after the phase status (2026-07-03,
- * agentic-flow). Empty string when the phase carries no audit — legacy
- * envelopes must render byte-identical to the pre-audit tracker.
+ * Audit tag after the phase status (spec §4 words): `✓ audited`, `! N notes`,
+ * `✗ audit failed`, `· hand-edited`, `· waived`, `! audit not run`. Empty
+ * string when the phase carries no audit — legacy envelopes render no tag.
  */
-function auditGlyph(audit) {
+function auditTag(audit) {
     if (!audit)
         return '';
+    const g = getGlyphs();
     switch (audit.state) {
-        case 'passed': return ` ${chalk.green('✔ audited')}`;
+        case 'passed': return ` ${paint('ok', `${g.done} audited`)}`;
         case 'warn': {
             // Non-blocking tier: validated-WITH-NOTES. Distinct from a clean pass and
             // from the "not run" states — it ran, passed, and carries N notes.
             const n = audit.findings?.length ?? 0;
-            return ` ${chalk.yellow(`⚠ ${n} note${n === 1 ? '' : 's'}`)}`;
+            return ` ${paint('warn', `${g.attention} ${n} note${n === 1 ? '' : 's'}`)}`;
+        }
+        case 'waived': {
+            const cat = audit.waiveCategory ? ` (${sanitizeControlChars(audit.waiveCategory)})` : '';
+            return ` ${paint('dim', `${g.info} waived${cat}`)}`;
         }
-        case 'waived': return ` ${chalk.yellow(`✎ waived${audit.waiveCategory ? ` (${audit.waiveCategory})` : ''}`)}`;
-        case 'failed': return ` ${chalk.red('✖ audit failed')}`;
-        case 'not_audited_hand_edited': return ` ${chalk.yellow('✋ hand-edited')}`;
+        case 'failed': return ` ${paint('bad', `${g.failed} audit failed`)}`;
+        case 'not_audited_hand_edited': return ` ${paint('dim', `${g.info} hand-edited`)}`;
         case 'pending':
         case 'infra_failed':
         default:
-            // `default` is deliberate forward-compat, not a missed case: an unknown
-            // future PlanAuditState renders "⚠ audit not run" instead of crashing.
-            return ` ${chalk.yellow('⚠ audit not run')}`;
+            // Deliberate forward-compat: an unknown future state reads "audit not run".
+            return ` ${paint('warn', `${g.attention} audit not run`)}`;
     }
 }
 /**
- * Plan-progress board — a Claude-Code-style checkbox task list. Each phase is
- * named for the work it does (not its mechanical id), so the reader can follow
- * along; ☒ = done (dim), ☐ = to do, the active phase is bold with a `◀ now`
- * marker, blocked is red. Flows through chunkEmitter (Ink) and console.log
- * (classic) alike — chalk degrades to plain text on a non-colour stream.
+ * Pre-cut a row's title and detail (plain text, before painting) so both fit
+ * in `room` cells. The title has priority; the detail, with its separator,
+ * gets what is left and is dropped when too little room remains.
+ */
+function fitRow(title, detail, sep, room) {
+    const t = truncateToWidth(title, room);
+    const rest = room - stringWidth(t);
+    const full = detail ? `${sep}${detail}` : '';
+    const tail = full && rest > stringWidth(sep) + 1 ? truncateToWidth(full, rest) : '';
+    return { title: t, tail };
+}
+/**
+ * Plan-progress board (spec §4) — printed once per phase event to scrollback,
+ * never a live element. Same glyphs and "N of M" count as the live checklist:
+ * ✓ done (dim) · ◼ current (SAP blue, bold) · ☐ to do · ✗ blocked (bad).
+ * Titles and details come from plan files / the model: control characters are
+ * neutralised and every row is pre-cut to the UI width before painting.
+ * Flows through chunkEmitter (Ink) and console.log (classic) alike.
  */
 export function renderPlanTracker(a) {
-    const PEACH = '#F5A623';
+    const g = getGlyphs();
+    const width = uiWidth();
     const lines = [];
     const total = a.content.phases.length;
     // Waived phases count as done in the header tally — the DAG treats them as
-    // satisfied; the per-line "✓* (waived)" marker carries the distinction.
-    // Audit-aware (2026-07-03): a validated-but-audit-failed phase must NOT
-    // count as done, or the header would say "N/N done" while the completion
-    // check refuses to complete — the tally uses the same predicate as the DAG.
+    // satisfied. Audit-aware: a validated-but-audit-failed phase must NOT count,
+    // or the header would say "N of N done" while the completion check refuses
+    // to complete — the tally uses the same predicate as the DAG (pinned by
+    // plan-tracker-pin).
     const validated = a.content.phases.filter((p) => isPhaseSatisfied(a.statuses[p.id], p.audit)).length;
     if (a.includeHeader !== false) {
-        lines.push(chalk.dim(`─ ${a.title} (v${a.version}) · ${validated}/${total} done ─`));
+        const tail = ` (v${a.version}) · ${countLabel(validated, total)} done`;
+        const head = truncateToWidth(sanitizeControlChars(a.title), Math.max(1, width - stringWidth(tail)));
+        lines.push(chalk.bold(head) + paint('dim', tail));
         lines.push('');
     }
     for (const p of a.content.phases) {
         const s = a.statuses[p.id] ?? 'todo';
         const isCurrent = a.currentId != null && p.id === a.currentId;
-        const title = phaseTitle(p);
-        const detail = phaseDetail(p, s);
-        const dash = detail ? ` — ${detail}` : '';
-        // Auditor verdict after the status — '' on legacy phases (no audit field),
-        // so pre-audit envelopes render byte-identical.
-        const audit = auditGlyph(p.audit);
+        const title = sanitizeControlChars(phaseTitle(p));
+        const detail = sanitizeControlChars(phaseDetail(p, s));
+        // Auditor verdict after the status — '' on legacy phases (no audit field).
+        const audit = auditTag(p.audit);
+        const auditW = stringWidth(audit);
         if (s === 'validated') {
-            lines.push(chalk.dim(`  ☒ ${title}${dash}`) + audit);
+            const lead = `  ${g.done} `;
+            const r = fitRow(title, detail, ' — ', width - stringWidth(lead) - auditW);
+            lines.push(paint('dim', `${lead}${r.title}${r.tail}`) + audit);
         }
         else if (s === 'validated-with-waiver') {
-            // C1 (D30 waiver) — done-but-waived: the exit gate was never met; the
-            // user accepted it anyway. Distinct marker so a tracker reader can tell
-            // a verified phase from a waived one at a glance.
-            lines.push(chalk.dim(`  ☒ ${title}${dash}`) + ` ${chalk.yellow('✓* (waived)')}` + audit);
+            // Done-but-waived: the exit gate was never met; the user accepted it.
+            const lead = `  ${g.done} `;
+            const mark = `${g.done}* (waived)`;
+            const r = fitRow(title, detail, ' — ', width - stringWidth(lead) - 1 - stringWidth(mark) - auditW);
+            lines.push(paint('dim', `${lead}${r.title}${r.tail}`) + ` ${paint('warn', mark)}` + audit);
         }
         else if (s === 'blocked') {
-            lines.push(`  ${chalk.red('☐')} ${chalk.red(title)} ${chalk.red('— blocked')}${detail ? chalk.dim(` · ${detail}`) : ''}${audit}`);
+            const lead = `  ${g.failed} `;
+            const mark = ' — blocked';
+            const r = fitRow(title, detail, ' · ', width - stringWidth(lead) - stringWidth(mark) - auditW);
+            lines.push(`  ${paint('bad', `${g.failed} ${r.title}${mark}`)}${r.tail ? paint('dim', r.tail) : ''}${audit}`);
         }
         else if (isCurrent) {
-            lines.push(`  ${chalk.hex(PEACH)('☐')} ${chalk.bold(title)}${dash}${audit}  ${chalk.hex(PEACH).bold('◀ now')}`);
+            const lead = `  ${g.current} `;
+            const r = fitRow(title, detail, ' — ', width - stringWidth(lead) - auditW);
+            lines.push(`  ${chalk.bold(paint('sap', `${g.current} ${r.title}`))}${paint('dim', r.tail)}${audit}`);
         }
         else if (IN_PROGRESS.includes(s)) {
-            lines.push(`  ${chalk.hex(PEACH)('☐')} ${chalk.bold(title)}${dash}${audit}  ${chalk.dim(`(${s})`)}`);
+            const lead = `  ${g.pending} `;
+            const note = `  (${s})`;
+            const r = fitRow(title, detail, ' — ', width - stringWidth(lead) - stringWidth(note) - auditW);
+            lines.push(`  ${g.pending} ${chalk.bold(r.title)}${paint('dim', r.tail)}${audit}${paint('dim', note)}`);
         }
         else {
-            lines.push(`  ☐ ${title}${chalk.dim(dash)}${audit}`);
+            const lead = `  ${g.pending} `;
+            const r = fitRow(title, detail, ' — ', width - stringWidth(lead) - auditW);
+            lines.push(`  ${paint('dim', g.pending)} ${r.title}${paint('dim', r.tail)}${audit}`);
         }
     }
     // Off-switch footer — honesty: state plainly that this run's phases are not
     // being audited. Rendered only when the caller threads auditsOff (in-memory).
     if (a.auditsOff) {
         lines.push('');
-        lines.push(chalk.dim('  audits: off'));
+        lines.push(paint('dim', '  audits: off'));
     }
     return lines.join('\n');
 }
@@ -272,7 +310,10 @@ export function findServiceBinding(phases) {
  * /abap-fiori-build — with the EXACT binding name when resolvable. A plan
  * that already built its UI, or never built a service, gets no chain line.
  */
-export function planCompletionLines(phases) {
+export function planCompletionLines(phases, 
+// Terminal callers follow the terminal's glyph set; file writers (the
+// handover markdown) pass UNICODE_GLYPHS so file content never varies.
+g = getGlyphs()) {
     const lines = ['Plan complete — every phase validated.'];
     // Confidence-tiered redesign (2026-07-08): a completed plan that carried
     // non-blocking warn verdicts surfaces them in the FINAL summary — a warned
@@ -283,9 +324,10 @@ export function planCompletionLines(phases) {
         if (p.audit?.state !== 'warn')
             continue;
         const notes = p.audit.findings ?? [];
+        // Findings are model-written text: sanitise before they reach a terminal.
         lines.push(notes.length > 0
-            ? `⚠ ${p.id} passed with ${notes.length} note${notes.length === 1 ? '' : 's'}: ${notes.join('; ')}.`
-            : `⚠ ${p.id} passed with notes.`);
+            ? `${g.attention} ${p.id} passed with ${notes.length} note${notes.length === 1 ? '' : 's'}: ${sanitizeControlChars(notes.join('; '))}.`
+            : `${g.attention} ${p.id} passed with notes.`);
     }
     // §10 Q2 (audit-confidence redesign): a waived phase surfaces its light
     // category + reason in the FINAL summary — an "all validated" plan never
@@ -295,9 +337,10 @@ export function planCompletionLines(phases) {
     for (const p of phases) {
         if (p.audit?.state !== 'waived')
             continue;
-        const cat = p.audit.waiveCategory ? ` (${p.audit.waiveCategory})` : '';
-        const reason = p.audit.waivedReason ? `: ${p.audit.waivedReason}` : '';
-        lines.push(`✎ ${p.id} waived${cat}${reason}.`);
+        // Same "· waived" tag as the board (auditTag); the reason is user-typed text.
+        const cat = p.audit.waiveCategory ? ` (${sanitizeControlChars(p.audit.waiveCategory)})` : '';
+        const reason = p.audit.waivedReason ? `: ${sanitizeControlChars(p.audit.waivedReason)}` : '';
+        lines.push(`${g.info} ${p.id} waived${cat}${reason}.`);
     }
     // audit-infra-continue (2026-07-09): a phase whose audit could NOT RUN
     // surfaces in the FINAL summary as a DISTINCT "unverified" line — an "all
@@ -308,7 +351,7 @@ export function planCompletionLines(phases) {
     for (const p of phases) {
         if (p.audit?.state !== 'infra_failed')
             continue;
-        lines.push(`⚠ ${p.id} was NOT audit-verified (audit infrastructure failed — its own exit gate, activation + ATC, passed).`);
+        lines.push(`${g.attention} ${p.id} was NOT audit-verified (audit infrastructure failed — its own exit gate, activation + ATC, passed).`);
     }
     const hasUi = phases.some((p) => p.layer === 'ui' || p.delegateTo === 'abap-fiori-build');
     const hasService = phases.some((p) => p.layer === 'service');

package/dist/projects/promote-command.js

@@ -1,6 +1,7 @@
 import { readProjectFile } from './status.js';
 import { buildPromotedFromSnapshot, buildReviewDecisionsBlock, buildDetailPathHint, validatePromotionSource } from './promote.js';
 import { resolveAtTokenAsync, formatProjectFileList } from './workspace.js';
+import { askYesNo } from './yes-no.js';
 /**
  * Per-skill predecessor map. v0.7 admits multi-source via array values —
  * e.g. /abap-upgrade-fix accepts BOTH upgrade-scan (the existing chain
@@ -79,14 +80,22 @@ export async function runPromoteCommand(args) {
     }
     for (const w of validation.warnings) {
         if (w.kind === 'ZERO_ANSWERED') {
-            const reply = await args.prompt(`Source has no answered items (${w.count} still open). Continue anyway? [y/N]: `);
+            const reply = await askYesNo({
+                question: `Source has no answered items (${w.count} still open). Continue anyway?`,
+                confirm: args.confirm,
+                prompt: args.prompt,
+            });
             if (!affirmative(reply))
                 return null;
         }
         else if (w.kind === 'PARTIAL_OPEN') {
             const sample = w.openIds.slice(0, 5).join(', ');
             const more = w.openIds.length > 5 ? `, ... ${w.openIds.length - 5} more` : '';
-            const reply = await args.prompt(`${w.openIds.length} item(s) still open (${sample}${more}). Promote anyway? [y/N]: `);
+            const reply = await askYesNo({
+                question: `${w.openIds.length} item(s) still open (${sample}${more}). Promote anyway?`,
+                confirm: args.confirm,
+                prompt: args.prompt,
+            });
             if (!affirmative(reply))
                 return null;
         }

package/dist/projects/save-command.js

@@ -17,6 +17,7 @@ import { saveProject } from './save.js';
 import { renderEmailTemplate } from './email-template.js';
 import { writePlanHandover } from './handover-md.js';
 import { ensureWorkspace, resolveWorkspacePath } from './workspace.js';
+import { askYesNo, isYes } from './yes-no.js';
 const SKILL_REGISTRY = {
     'abap-spec-gap': {
         artefactType: 'spec-gap',
@@ -317,8 +318,8 @@ export async function runSaveCommand(args) {
     // question added here would silently receive 'y' too. If you need another
     // prompt, give maybeOfferSave's headless prompt a question-aware answer
     // first.
-    const answer = (await args.prompt('Save as project file? [y/N]: ')).trim().toLowerCase();
-    if (answer !== 'y' && answer !== 'yes')
+    const answer = await askYesNo({ question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt });
+    if (!isYes(answer))
         return null;
     let env;
     if (planExtract && prior) {

package/dist/projects/status.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { validateEnvelope } from './validate.js';
 import { canonicalSha256 } from './canonicalize.js';
 import { statusesFromItems, computeNextPhase, renderPlanTracker } from './plan-run.js';
+import { getGlyphs } from '../renderer/glyphs.js';
 export function readProjectFile(path) {
     const raw = readFileSync(path, 'utf8');
     let parsed;
@@ -167,7 +168,7 @@ export async function renderMultiFileStatus(envs) {
         const distinct = new Set(shas);
         if (distinct.size > 1) {
             const lines = [];
-            lines.push(`⚠ Two v${firstVer} files received from same source, with conflicting changes.`);
+            lines.push(`${getGlyphs().attention} Two v${firstVer} files received from same source, with conflicting changes.`);
             for (let i = 0; i < envs.length; i++) {
                 const e = envs[i];
                 const items = e.interaction.items;

package/dist/projects/yes-no.js

@@ -0,0 +1,12 @@
+export async function askYesNo(a) {
+    if (a.confirm)
+        return a.confirm(a.question, { default: 'n' });
+    if (!a.prompt)
+        return '';
+    return (await a.prompt(`${a.question} [y/N]: `)).trim().toLowerCase();
+}
+/** Today's decision rule at all six sites. */
+export function isYes(reply) {
+    const v = reply.trim().toLowerCase();
+    return v === 'y' || v === 'yes';
+}

package/dist/renderer/abap-inline.js

@@ -36,6 +36,22 @@ const ABAP_KEYWORDS = new Set([
 // Now accepts any alphanumeric/_/- lang slug and makes it available as m[1].
 const OPEN_FENCE_RE = /^```([a-z0-9_-]*)\s*$/i;
 const CLOSE_FENCE_RE = /^```\s*$/;
+/** Highlight one fenced block body for the languages CSPeach owns
+ *  (abap, cds, bdef, ddl). undefined = not ours (caller keeps its default). */
+export function highlightFencedBody(body, lang) {
+    // Only the first word of the info string names the language
+    // (```abap linenums → abap).
+    const l = (lang.trim().split(/\s+/)[0] ?? '').toLowerCase();
+    // Preserve v0.1.1 regex-based highlighter for ABAP — it is stable,
+    // has been tested in production, and avoids a second runtime
+    // dependency for the hottest fenced-block type.
+    if (l === 'abap')
+        return highlightAbapBlock(body);
+    // cli-highlight grammars via the Task 5 dispatcher.
+    if (l === 'cds' || l === 'bdef' || l === 'ddl')
+        return highlightCodeBlock(body, l);
+    return undefined;
+}
 /** Whole-text pass. Splits by fenced blocks; routes each block by lang. */
 export function applyCodeHighlight(text) {
     const lines = text.split('\n');
@@ -59,20 +75,8 @@ export function applyCodeHighlight(text) {
         // inFence === true
         if (CLOSE_FENCE_RE.test(line)) {
             const body = blockLines.join('\n');
-            if (lang === 'abap') {
-                // Preserve v0.1.1 regex-based highlighter for ABAP — it is stable,
-                // has been tested in production, and avoids a second runtime
-                // dependency for the hottest fenced-block type.
-                out.push(highlightAbapBlock(body));
-            }
-            else if (lang === 'cds' || lang === 'bdef' || lang === 'ddl') {
-                // cli-highlight grammars via the Task 5 dispatcher.
-                out.push(highlightCodeBlock(body, lang));
-            }
-            else {
-                // Unknown / empty lang → pass through unchanged.
-                out.push(body);
-            }
+            // Unknown / empty lang → pass through unchanged.
+            out.push(highlightFencedBody(body, lang) ?? body);
             out.push(line);
             inFence = false;
             lang = '';

package/dist/renderer/answer-trim.js

@@ -0,0 +1,69 @@
+// src/renderer/answer-trim.ts
+//
+// Round 6 item 4f — one-shot stdout is the answer only: no blank lines before
+// it, exactly one newline after it. Newlines (and colour codes next to them)
+// are held until visible text proves they are inside the answer; leading ones
+// are dropped, trailing ones are dropped at end().
+// eslint-disable-next-line no-control-regex
+const ESC_SEQ = /^\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07]*\x07)/;
+export class AnswerTrim {
+    started = false;
+    /** Held newlines + escapes, in order. */
+    held = '';
+    /**
+     * Round 6 review M3 — a newline the caller already wrote on its own
+     * (writeAboveSpinner ends a line before repainting the spinner). The next
+     * held newline, or the final one, is covered by it.
+     */
+    forced = false;
+    /** The caller wrote a newline itself after the last output. */
+    noteForcedNewline() {
+        if (this.started)
+            this.forced = true;
+    }
+    flushHeld() {
+        let h = this.held;
+        if (this.forced) {
+            h = h.replace(/\r?\n/, '');
+            this.forced = false;
+        }
+        return h;
+    }
+    feed(s) {
+        let out = '';
+        let i = 0;
+        while (i < s.length) {
+            const ch = s[i];
+            if (ch === '\x1b') {
+                const m = ESC_SEQ.exec(s.slice(i));
+                if (m) {
+                    this.held += m[0];
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            if (ch === '\n' || ch === '\r') {
+                this.held += ch;
+            }
+            else {
+                // Before the answer starts, held newlines are dropped (escapes kept).
+                out += this.started ? this.flushHeld() : this.held.replace(/[\r\n]/g, '');
+                this.held = '';
+                this.started = true;
+                out += ch;
+            }
+            i++;
+        }
+        return out;
+    }
+    /** What to write when the answer is done: held escapes + one newline (nothing if no answer). */
+    end() {
+        const escapes = this.held.replace(/[\r\n]/g, '');
+        this.held = '';
+        if (this.forced) {
+            this.forced = false;
+            return escapes;
+        }
+        return this.started ? `${escapes}\n` : escapes;
+    }
+}

package/dist/renderer/banners.js

@@ -1,10 +1,8 @@
 import chalk from 'chalk';
 import { CLI_VERSION } from '../lib/version.js';
-/** CSPeach brand colour — used for the brand-name text in the startup line,
- *  the tool-dispatch bullet (⏺), and the result continuation glyph (⎿).
- *  Single source of truth so a future rebrand is one find-replace.
- *  The startup banner uses the 🍑 emoji directly (no tint) for identity. */
-export const PEACH = '#FFCBA4';
+// Legacy brand colour — frozen in legacy-palette.ts (piece 2 §1.1).
+import { LEGACY_PEACH as PEACH } from './legacy-palette.js';
+import { formatAttention } from './notice-shape.js';
 /**
  * Minimal startup line — terse, single bullet, three lines max. Modeled on
  * Claude Code's `✻ Welcome to Claude Code v1.0.x` pattern but with the
@@ -33,8 +31,10 @@ export function printStartupBanner() {
     console.log(`   ${chalk.gray('ABAP + AI + safety gates')} ${chalk.dim('·')} ${chalk.gray('by Cremencing Solutions')}`);
     console.log('');
 }
+/** Piece 2 §10: the keychain fallback is ONE "!" line (was three). */
+export function keychainFallbackNotice() {
+    return formatAttention({ text: 'OS keychain unavailable', fact: 'the API key and SAP passwords are asked each session' });
+}
 export function printKeytarFallbackBanner() {
-    console.log(chalk.yellow('⚠  OS keychain unavailable on this system.'));
-    console.log(chalk.yellow('   API key + SAP passwords will be prompted per session.'));
-    console.log(chalk.yellow('   Run `cspeach doctor` for remediation hints.\n'));
+    process.stdout.write(keychainFallbackNotice());
 }

package/dist/renderer/brand-settled.js

@@ -0,0 +1,19 @@
+// src/renderer/brand-settled.ts
+//
+// The early panels brand line (startup-lines.ts startEarlyBrand) is written
+// without its newline while the sign-in check runs. Anything that prints on
+// its own schedule during startup (the fire-and-forget upgrade check) awaits
+// brandSettled() first, so it can never land in the middle of that line.
+// Resolved by default: with no early brand line open there is nothing to wait for.
+// Kept dependency-free: cli.ts reaches it statically through upgrade-check.ts.
+let settled = Promise.resolve();
+let release;
+export function brandSettled() {
+    return settled;
+}
+/** Marks the brand line open; returns the function that settles it (idempotent). */
+export function holdBrand() {
+    settled = new Promise((r) => { release = r; });
+    const mine = release;
+    return () => { mine(); };
+}