@cspeach/cli 1.1.17 → 1.1.19

package/dist/renderer/syntax.js

@@ -26,6 +26,7 @@ import { createRequire } from 'node:module';
 import abapGrammar from './highlighters/abap.js';
 import cdsGrammar from './highlighters/cds.js';
 import bdefGrammar from './highlighters/bdef.js';
+import { colorOff } from './color-mode.js';
 // A5 fix (2026-06-06) — registration must hit the EXACT module instance
 // cli-highlight loads, and on this pnpm/Windows layout that is NOT what a
 // plain `import hljs from 'highlight.js'` (or even a local require)
@@ -41,18 +42,31 @@ import bdefGrammar from './highlighters/bdef.js';
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const hljs = createRequire(require.resolve('cli-highlight'))('highlight.js');
-// Module-load-time registration. The grammar modules export plain objects
-// (shape matches highlight.js `Language` definition). Cast is safe — the
-// grammars match the runtime contract even when strict typings drift.
-hljs.registerLanguage('abap', () => abapGrammar);
-hljs.registerLanguage('cds', () => cdsGrammar);
-hljs.registerLanguage('bdef', () => bdefGrammar);
-// `ddl` is an alias of the CDS grammar: ```ddl fences carry CDS DDL source
-// (the abap-rap templates emit them). Registering it on the same hljs
-// instance also silences marked-terminal's "Could not find the language
-// 'ddl'" warning, since marked-terminal calls cli-highlight directly with
-// the raw fence lang and never goes through highlightCodeBlock().
-hljs.registerLanguage('ddl', () => cdsGrammar);
+// Registration is idempotent and triggered explicitly (2026-09-26, look
+// piece 1): pipeline.ts calls ensureGrammars() at ITS module load — the same
+// moment this module used to self-register, since pipeline.ts is the only
+// production caller of renderMarkdown — and highlightCodeBlock() calls it
+// lazily. This lets markdown.ts import the fenced-body highlighter without
+// changing the legacy marked-terminal output of a markdown-only module graph
+// (pinned by test/unit/legacy-look-pin.test.ts).
+// The grammar modules export plain objects (shape matches highlight.js
+// `Language` definition). Cast is safe — the grammars match the runtime
+// contract even when strict typings drift.
+let grammarsRegistered = false;
+export function ensureGrammars() {
+    if (grammarsRegistered)
+        return;
+    grammarsRegistered = true;
+    hljs.registerLanguage('abap', () => abapGrammar);
+    hljs.registerLanguage('cds', () => cdsGrammar);
+    hljs.registerLanguage('bdef', () => bdefGrammar);
+    // `ddl` is an alias of the CDS grammar: ```ddl fences carry CDS DDL source
+    // (the abap-rap templates emit them). Registering it on the same hljs
+    // instance also silences marked-terminal's "Could not find the language
+    // 'ddl'" warning, since marked-terminal calls cli-highlight directly with
+    // the raw fence lang and never goes through highlightCodeBlock().
+    hljs.registerLanguage('ddl', () => cdsGrammar);
+}
 const SUPPORTED = new Set(['abap', 'cds', 'bdef', 'ddl']);
 /**
  * Highlight a code block body (without fence markers).
@@ -66,6 +80,11 @@ export function highlightCodeBlock(code, lang) {
     const normalised = lang.trim().toLowerCase();
     if (!SUPPORTED.has(normalised))
         return code;
+    // NO_COLOR (piece 2 §1.2): cli-highlight's own chalk 4 ignores NO_COLOR and an
+    // empty theme falls back to DEFAULT_THEME, so skip highlighting entirely.
+    if (colorOff())
+        return code;
+    ensureGrammars();
     try {
         return highlight(code, {
             language: normalised,

package/dist/renderer/tables.js

@@ -2,6 +2,7 @@
 import Table from 'cli-table3';
 import chalk from 'chalk';
 import { applySeverity } from './severity.js';
+import { colorOff } from './color-mode.js';
 /** Regex that matches a markdown pipe-table row (at least two | delimiters). */
 const PIPE_ROW_RE = /^\|(.+\|)+$/;
 /** Separator row: | --- | or | :---: | etc. */
@@ -46,7 +47,10 @@ function buildTable(lines) {
         return lines.join('\n');
     const [headerRow, ...dataRows] = rows;
     const headers = parseRow(headerRow).map((h) => chalk.cyan.bold(h));
-    const table = new Table({ head: headers });
+    // NO_COLOR (piece 2 §1.2): cli-table3's @colors/colors ignores NO_COLOR, so
+    // empty its default red head / grey border when colour is off. Coloured
+    // output keeps the default style object (byte-identical).
+    const table = new Table(colorOff() ? { head: headers, style: { head: [], border: [] } } : { head: headers });
     for (const row of dataRows) {
         const cells = parseRow(row).map((c) => applySeverity(c));
         table.push(cells);

package/dist/renderer/theme.js

@@ -0,0 +1,44 @@
+// src/renderer/theme.ts
+//
+// Panels look colours (2026-09-26). Every panels string builder asks for a ROLE,
+// never a raw colour, so dark/light terminals and colour depth are handled here
+// once. The legacy look does not use this module.
+import chalk from 'chalk';
+import { getBackground } from './look.js';
+export const PALETTE = {
+    dark: {
+        sap: '#5AA9FF', ok: '#6CCF7F', warn: '#F5B04D', bad: '#FF8A8A',
+        frame: '#33506F', dim: '#8A9BB0', brand: '#FFB38A',
+    },
+    light: {
+        sap: '#0064D9', ok: '#256F3A', warn: '#B44F00', bad: '#AA0808',
+        frame: '#A9B4BE', dim: '#556B82', brand: '#C65A24',
+    },
+};
+export const BRAND_HEX = PALETTE.dark.brand;
+/** Filled tag chip colours (SAP blue, white text) — readable on dark and light terminals. */
+export const CHIP_BG = '#0070F2';
+export const CHIP_FG = '#FFFFFF';
+const BASIC = {
+    sap: (s) => chalk.blue(s),
+    ok: (s) => chalk.green(s),
+    warn: (s) => chalk.yellow(s),
+    bad: (s) => chalk.red(s),
+    frame: (s) => chalk.gray(s),
+    dim: (s) => chalk.gray(s),
+    brand: (s) => chalk.yellow(s),
+};
+export function paint(role, text) {
+    if (chalk.level === 0)
+        return text;
+    if (chalk.level === 1)
+        return BASIC[role](text);
+    return chalk.hex(PALETTE[getBackground()][role])(text);
+}
+export function chip(text) {
+    if (chalk.level === 0)
+        return `[${text}]`;
+    if (chalk.level === 1)
+        return chalk.bgBlue.white.bold(` ${text} `);
+    return chalk.bgHex(CHIP_BG).hex(CHIP_FG).bold(` ${text} `);
+}

package/dist/renderer/thinking-heartbeat.js

@@ -29,6 +29,9 @@
  * fallback.
  */
 import chalk from 'chalk';
+import { getLook } from './look.js';
+import { writeStdout, canAnimateInPlace } from './transcript-flow.js';
+import { isDeclaredOneShot } from './tty.js';
 const LLM_THRESHOLDS = [
     { at: 3_000, label: 'thinking…' },
     { at: 10_000, label: 'thinking… (10s)' },
@@ -71,7 +74,29 @@ export const AUDIT_HEARTBEAT_THRESHOLDS = [
     { at: 240_000, label: '[audit] …running (4m — a prior attempt timed out; retrying · Ctrl+C aborts the turn)' },
     { at: 300_000, label: '[audit] …running (5m — nearly at the retry ceiling; will stop and re-audit on resume if it can\'t finish)' },
 ];
+/**
+ * Fix round 3 (item 8) — one-shot's routing wait (the classifier round-trip,
+ * up to ~16 s with its retry) showed nothing. These lines go to stderr in
+ * one-shot (the default sink there), so stdout stays the answer only.
+ */
+export const ROUTING_HEARTBEAT_THRESHOLDS = [
+    { at: 1_000, label: 'routing…' },
+    { at: 5_000, label: 'routing… (5s)' },
+    { at: 10_000, label: 'routing… (10s)' },
+];
 export function startThinkingHeartbeat(opts) {
+    // Polish P2 (panels look): liveness lines are transient. Where a live
+    // indicator exists — Ink's TurnStatus row (chunkEmitter present) or the
+    // classic in-place spinner (real terminal) — the heartbeat prints nothing,
+    // so no "thinking…" / "Searching …" line is left in the transcript. Pipes
+    // and dumb terminals keep the permanent lines (nothing can be erased
+    // there). Custom sinks/schedules (the plan-chain audit) are unchanged.
+    if (getLook() === 'panels' &&
+        !opts?.emit &&
+        !opts?.thresholds &&
+        (opts?.chunkEmitter !== undefined || canAnimateInPlace())) {
+        return { stop: () => undefined };
+    }
     const startedAt = Date.now();
     let nextIdx = 0;
     let stopped = false;
@@ -106,9 +131,15 @@ export function startThinkingHeartbeat(opts) {
             // render tree and survives subsequent renders.
             opts.chunkEmitter.emit('chunk', line + '\n');
         }
+        else if (isDeclaredOneShot()) {
+            // Fix round 3 (item 7) — one-shot stdout is the answer only; liveness
+            // chatter goes to stderr (piped `cspeach "…" | cat` showed `thinking…`).
+            process.stderr.write(line + '\n');
+        }
         else {
-            // Classic mode — direct stdout, plain newline-terminated line.
-            process.stdout.write(line + '\n');
+            // Classic mode — direct stdout, plain newline-terminated line
+            // (panels: through the transcript flow; legacy: verbatim).
+            writeStdout(line + '\n');
         }
     };
     const tick = () => {

package/dist/renderer/todo-block.js

@@ -1,51 +1,12 @@
-/**
- * todo_set transcript block — UX Wave 2 follow-up (CC-style checklist).
- *
- * Owner feedback (2026-07): "it's not like we have in Claude Code — only
- * shows the phase it's working on with an arrow." The turn-status strip
- * (single ▶ row) and the Ctrl+T panel are both by-design; what was missing
- * was Claude Code's behaviour of dropping the FULL checklist into the
- * scrollback transcript on every todo_set, so the user sees the whole plan
- * advance in place rather than a raw `⏺ todo_set({...})` JSON line.
- *
- * This module is the pure formatter for that block. todo.ts emits the
- * returned string as a `chunk` on ctx.chunkEmitter after a successful set
- * (routes to Ink Static scrollback AND the classic 'chunk'→stdout path);
- * the raw ⏺/⎿ todo_set rows are widget-suppressed (tool-widget.ts) so the
- * block is the sole visible representation — exactly mirroring ask_question.
- *
- * House style follows todo-panel.tsx glyphs precisely so the transcript
- * block and the Ctrl+T panel read as the same list:
- *   ▣ completed   (dim)
- *   ▶ in_progress (peach, bold)
- *   □ pending     (default)
- * Every row is truncate-end (Wave-1 rule — no soft-wrap), preceded by a
- * slim `Tasks (done/total done)` header.
- */
-import chalk from 'chalk';
-import { PEACH } from './banners.js';
-/** Max visible width of a row's TEXT (after the 2-char glyph+space prefix).
- *  72-col total matches the Ctrl+T panel width; 70 leaves room for `▶ `. */
-export const TODO_BLOCK_TEXT_MAX = 70;
-function truncateEnd(s, max) {
-    return s.length > max ? s.substring(0, max - 1) + '…' : s;
-}
-/**
- * Render the checklist as a scrollback block (leading + trailing newline for
- * separation from surrounding transcript content). Returns ANSI-coloured
- * text ready to emit as a `chunk`.
- */
-export function formatTodoChecklistBlock(todos) {
-    const done = todos.filter((t) => t.status === 'completed').length;
-    const total = todos.length;
-    const header = chalk.dim(`Tasks (${done}/${total} done)`);
-    const rows = todos.map((t) => {
-        const text = truncateEnd(t.text, TODO_BLOCK_TEXT_MAX);
-        if (t.status === 'completed')
-            return chalk.dim(`▣ ${text}`);
-        if (t.status === 'in_progress')
-            return chalk.hex(PEACH).bold(`▶ ${text}`);
-        return `□ ${text}`;
+import { formatChecklist } from './checklist-format.js';
+import { uiWidth } from './ui-width.js';
+/** Leading + trailing newline separate the block from surrounding scrollback. */
+export function formatTodoChecklistBlock(todos, width = uiWidth()) {
+    const lines = formatChecklist(todos, {
+        width,
+        maxRows: Math.max(1, todos.length),
+        expanded: true,
+        foldedToOne: false,
     });
-    return '\n' + [header, ...rows].join('\n') + '\n';
+    return '\n' + lines.join('\n') + '\n';
 }

package/dist/renderer/tool-labels.js

@@ -0,0 +1,238 @@
+const OBJECT_MAX = 60;
+/**
+ * Every value shown in a label goes through here: ANSI escape sequences and
+ * other C0 control characters (incl. ESC) and DEL are stripped, whitespace
+ * (incl. newlines) collapses to one space, ends trimmed — one step, one line.
+ */
+// eslint-disable-next-line no-control-regex
+export const ANSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+// eslint-disable-next-line no-control-regex
+const CTRL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+export const clean = (s) => s.replace(ANSI_RE, '').replace(CTRL_RE, '').replace(/\s+/g, ' ').trim();
+/** Raw string arg (for line counting only — never displayed). */
+const raw = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+/** Display-safe string arg. */
+const str = (v) => {
+    const r = raw(v);
+    if (r === undefined)
+        return undefined;
+    const c = clean(r);
+    return c.length > 0 ? c : undefined;
+};
+const lineCount = (s) => (s === '' ? 0 : s.split(/\r?\n/).length);
+/** Shorten from the LEFT for paths (the file name is what matters). */
+const shortLeft = (s, max = OBJECT_MAX) => (s.length > max ? '…' + s.slice(s.length - (max - 1)) : s);
+const shortRight = (s, max = OBJECT_MAX) => (s.length > max ? s.slice(0, max - 1) + '…' : s);
+const humanise = (name) => clean(name.replace(/_/g, ' '));
+const VERB_MAX = 40;
+const sapObject = (verb) => (a) => ({ verb, object: shortRight(str(a['name']) ?? '') });
+/** User-side names for class local includes; unknown values pass through. */
+const INCLUDE_NAMES = {
+    locals_imp: 'local types',
+    locals_def: 'local definitions',
+    testclasses: 'test classes',
+    macros: 'macros',
+};
+/**
+ * sap_activate's real schema is a batch: `objects: [{ name, type }]`.
+ * Up to 3 names are shown; with 4 or more, the first two then "+N more". A bare `name` is still honoured.
+ */
+const activateObject = (a) => {
+    const list = Array.isArray(a['objects'])
+        ? a['objects']
+            .map((o) => (o && typeof o === 'object' ? str(o['name']) : undefined))
+            .filter((n) => n !== undefined)
+        : [];
+    if (list.length === 0)
+        return str(a['name']) ?? '';
+    const shown = list.slice(0, list.length > 3 ? 2 : 3).join(', ');
+    return list.length > 3 ? `${shown} +${list.length - 2} more` : shown;
+};
+/** Length of a JSON array result (e.g. sap_search_object); undefined when it is not one — never a guess. */
+const arrayCount = (r) => {
+    try {
+        const v = JSON.parse(r);
+        return Array.isArray(v) ? v.length : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** sap_search_object's default maxResults (src/tools/sap-read.ts: `args.maxResults ?? 100`). */
+const SEARCH_DEFAULT_MAX = 100;
+const fileCount = (v) => (Array.isArray(v) ? `${v.length} ${v.length === 1 ? 'file' : 'files'}` : '');
+const commandLine = (a) => [str(a['command']) ?? '', ...(Array.isArray(a['args']) ? a['args'].map(str).filter((x) => x !== undefined) : [])].join(' ').trim();
+const RULES = {
+    file_read: (a, r) => ({ verb: 'Read', object: shortLeft(str(a['path']) ?? ''), ...(r !== undefined ? { detail: `${lineCount(r)} lines` } : {}) }),
+    file_write: (a) => ({ verb: 'Wrote', object: shortLeft(str(a['path']) ?? ''), detail: `${lineCount(raw(a['content']) ?? '')} lines` }),
+    file_edit: (a) => ({
+        verb: 'Edited',
+        object: shortLeft(str(a['path']) ?? ''),
+        detail: `+${lineCount(raw(a['new_string']) ?? '')} −${lineCount(raw(a['old_string']) ?? '')}`,
+    }),
+    grep: (a) => ({ verb: 'Searched', object: shortRight(`"${str(a['pattern']) ?? ''}"`) }),
+    glob: (a) => ({ verb: 'Listed', object: shortRight(str(a['pattern']) ?? '') }),
+    shell_exec: (a, r) => {
+        const exit = r ? /exit code:\s*(-?\d+|null)/.exec(r)?.[1] : undefined;
+        return { verb: 'Ran', object: shortRight(commandLine(a)), ...(exit !== undefined ? { detail: `exit ${exit}` } : {}) };
+    },
+    background_run: (a) => ({ verb: 'Started', object: shortRight(commandLine(a)) }),
+    sap_get_source: sapObject('Read'),
+    sap_set_source: sapObject('Wrote'),
+    sap_activate: (a) => ({ verb: 'Activated', object: shortRight(activateObject(a)) }),
+    sap_syntax_check: sapObject('Checked syntax'),
+    sap_atc_run: sapObject('Ran ATC on'),
+    sap_delete_object: sapObject('Deleted'),
+    sap_snapshot_take: sapObject('Snapshot'),
+    sap_usage_references: sapObject('Where-used for'),
+    sap_create_object: (a) => ({ verb: 'Created', object: shortRight([str(a['type']), str(a['name'])].filter(Boolean).join(' ')) }),
+    sap_update_method: (a) => ({ verb: 'Updated', object: shortRight(`${str(a['class_name']) ?? ''} → ${str(a['method_name']) ?? ''}`) }),
+    sap_set_class_include: (a) => {
+        const inc = str(a['includeType']);
+        const incName = inc !== undefined ? (Object.hasOwn(INCLUDE_NAMES, inc) ? INCLUDE_NAMES[inc] : inc) : '';
+        return { verb: 'Wrote', object: shortRight(`${str(a['className']) ?? ''} ${incName}`.trim()) };
+    },
+    sap_search_object: (a, r) => {
+        // "*AGING*" · PROG — the type filter tells otherwise identical searches apart.
+        const type = str(a['type']);
+        const count = r !== undefined ? arrayCount(r) : undefined;
+        // At the cap (maxResults, default 100 as in the tool) there may be more: "100+ hits".
+        const max = typeof a['maxResults'] === 'number' && a['maxResults'] > 0 ? a['maxResults'] : SEARCH_DEFAULT_MAX;
+        const hits = count === undefined ? undefined : count >= max ? `${max}+ hits` : `${count} ${count === 1 ? 'hit' : 'hits'}`;
+        return {
+            verb: 'Searched',
+            object: shortRight(`"${str(a['query']) ?? ''}"${type ? ` · ${type}` : ''}`),
+            ...(hits !== undefined ? { detail: hits } : {}),
+        };
+    },
+    sap_sql_query: (a) => ({ verb: 'Queried', object: shortRight(str(a['query']) ?? '') }),
+    sap_inactive_objects: () => ({ verb: 'Checked inactive objects', object: '' }),
+    fiori_scaffold_fe: (a) => ({ verb: 'Scaffolded app', object: shortLeft(str(a['basePath']) ?? '') }),
+    fiori_render_smoke: (a) => ({ verb: 'Render check', object: shortRight(str(a['previewId']) ?? str(a['appUrl']) ?? '') }),
+    fiori_draft_smoke: (a) => ({ verb: 'Draft check', object: shortRight(str(a['servicePath']) ?? '') }),
+    request_approval: (a) => ({ verb: 'Approval', object: shortRight(str(a['summary']) ?? '') }),
+    // Polish wave (P4): every other registered tool, so none falls back to
+    // "tool name key=value". Coverage test: tool-labels-coverage.test.ts.
+    sap_object_structure: sapObject('Structure'),
+    sap_change_log: sapObject('Change log'),
+    sap_short_dump: (a) => ({ verb: 'Read dumps', object: shortRight(str(a['dumpId']) ?? [str(a['user']), str(a['fromDate'])].filter(Boolean).join(' ')) }),
+    sap_api_state: (a) => ({ verb: 'API state', object: shortRight(activateObject(a)) }),
+    sap_abap_docu: (a) => ({ verb: 'ABAP docs', object: shortRight(str(a['keyword']) ?? '') }),
+    sap_class_includes: (a) => ({ verb: 'Read includes', object: shortRight([str(a['className']), str(a['includeType'])].filter(Boolean).join(' ')) }),
+    sap_diff: sapObject('Compared'),
+    sap_preview_change: sapObject('Previewed change'),
+    sap_run_unit_test: sapObject('Ran unit tests'),
+    sap_odata_test: (a) => ({ verb: 'OData test', object: shortRight([str(a['servicePath']), str(a['entity'])].filter(Boolean).join(' ')) }),
+    sap_badi_list: (a) => ({ verb: 'Searched BAdIs', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
+    sap_snapshot_list: (a) => ({ verb: 'Listed snapshots', object: shortRight(str(a['name']) ?? '') }),
+    sap_snapshot_read: sapObject('Read snapshot'),
+    sap_snapshot_cleanup: () => ({ verb: 'Cleaned snapshots', object: '' }),
+    sap_transport_create: (a) => ({ verb: 'Created transport', object: shortRight(str(a['description']) ?? '') }),
+    sap_transport_for_object: (a) => ({ verb: 'Transport for', object: shortRight(str(a['object_name']) ?? '') }),
+    sap_transport_list: (a) => ({ verb: 'Listed transports', object: shortRight(str(a['owner']) ?? '') }),
+    sap_transport_release: (a) => ({ verb: 'Released', object: shortRight(str(a['transport']) ?? '') }),
+    sap_create_domain: sapObject('Created domain'),
+    sap_create_data_element: sapObject('Created data element'),
+    sap_lock: sapObject('Locked'),
+    sap_unlock: sapObject('Unlocked'),
+    sap_service_binding_publish: sapObject('Published'),
+    sap_service_binding_unpublish: sapObject('Unpublished'),
+    sap_message_maintain: (a) => ({ verb: 'Message', object: shortRight([str(a['messageClass']), str(a['messageNumber'])].filter(Boolean).join(' ')) }),
+    sap_number_range_intervals: (a) => ({ verb: 'Number range', object: shortRight(str(a['nrObject']) ?? '') }),
+    ask_question: (a) => ({ verb: 'Question', object: shortRight(str(a['question']) ?? '') }),
+    todo_set: () => ({ verb: 'Updated todos', object: '' }),
+    dispatch_skill: (a) => ({ verb: 'Ran skill', object: shortRight(str(a['command']) ?? '') }),
+    read_document: (a, r) => ({ verb: 'Read document', object: shortLeft(str(a['path']) ?? ''), ...(r !== undefined ? { detail: `${lineCount(r)} lines` } : {}) }),
+    web_fetch: (a) => ({ verb: 'Fetched', object: shortRight(str(a['url']) ?? '') }),
+    web_search: (a) => ({ verb: 'Searched web', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
+    project_context_get: () => ({ verb: 'Read project context', object: '' }),
+    playbook_get: (a) => ({ verb: 'Read playbook', object: shortRight(str(a['name']) ?? '') }),
+    convention_get: (a) => ({ verb: 'Read convention', object: shortRight(str(a['field']) ?? '') }),
+    cca_merge: (a) => ({ verb: 'Merged CCA', object: fileCount(a['inputs']) }),
+    upgrade_merge_progress: (a) => ({ verb: 'Merged progress', object: fileCount(a['inputs']) }),
+    monitor_emit: (a) => ({ verb: 'Checked background', object: shortRight(str(a['bg_id']) ?? '') }),
+    agent_run: (a) => ({ verb: 'Subagent', object: shortRight(str(a['skill']) ?? '') }),
+    schedule_draft_create: (a) => ({ verb: 'Drafted schedule', object: shortRight(str(a['when']) ?? '') }),
+    fiori_scaffold: (a) => ({ verb: 'Scaffolded app', object: shortLeft(str(a['basePath']) ?? '') }),
+    fiori_apply: (a) => ({ verb: 'Applied', object: shortRight([str(a['entry']), str(a['appDir'])].filter(Boolean).join(' · ')) }),
+    fiori_list: () => ({ verb: 'Listed patterns', object: '' }),
+    fiori_deploy_config: (a) => ({ verb: 'Deploy config', object: shortRight(str(a['name']) ?? str(a['appDir']) ?? '') }),
+    fiori_fe_extend: (a) => ({ verb: 'Extended app', object: shortRight([str(a['op']), str(a['basePath'])].filter(Boolean).join(' · ')) }),
+    fiori_preview: (a) => ({ verb: 'Preview', object: shortRight([str(a['action']) ?? 'start', str(a['appDir'])].filter(Boolean).join(' ')) }),
+    fiori_sample_search: (a) => ({ verb: 'Searched samples', object: shortRight(`"${str(a['text']) ?? ''}"`) }),
+    fiori_sample_get: (a) => ({ verb: 'Read sample', object: shortRight(str(a['name']) ?? '') }),
+    fiori_metadata_audit: (a) => ({ verb: 'Audited metadata', object: shortRight(str(a['servicePath']) ?? '') }),
+    extend_model_insert: (a) => ({ verb: 'Extended model', object: shortRight([str(a['kind']), str(a['field'])].filter(Boolean).join(' · ')) }),
+    system_capability: (a) => ({ verb: 'Checked capability', object: shortRight(str(a['capability']) ?? '') }),
+};
+/** True when the tool has its own label (not the generic fallback). */
+export function hasToolLabel(name) {
+    return Object.hasOwn(RULES, name);
+}
+function fallback(name, a) {
+    // Only simple values: strings (display-cleaned; JSON-looking strings skipped),
+    // numbers and booleans. null, arrays and objects are never shown.
+    const simple = [];
+    for (const [k, v] of Object.entries(a)) {
+        if (simple.length >= 2)
+            break;
+        let shown;
+        if (typeof v === 'string') {
+            const c = str(v);
+            shown = c !== undefined && !/^[{[]/.test(c) ? c : undefined;
+        }
+        else if (typeof v === 'number' || typeof v === 'boolean') {
+            shown = String(v);
+        }
+        const key = clean(k);
+        if (shown !== undefined && key.length > 0)
+            simple.push(`${key}=${shown}`);
+    }
+    return { verb: shortRight(humanise(name), VERB_MAX), object: shortRight(simple.join(' · ')) };
+}
+export function toolLabel(name, args, resultContent) {
+    const rule = RULES[name];
+    try {
+        return rule ? rule(args ?? {}, resultContent) : fallback(name, args ?? {});
+    }
+    catch {
+        return fallback(name, {});
+    }
+}
+const PRESENT = {
+    Read: 'Reading', Wrote: 'Writing', Edited: 'Editing', Searched: 'Searching', Listed: 'Listing',
+    Ran: 'Running', Started: 'Starting', Activated: 'Activating', 'Checked syntax': 'Checking syntax',
+    'Ran ATC on': 'Running ATC on', Deleted: 'Deleting', Snapshot: 'Taking snapshot of',
+    'Where-used for': 'Finding where-used for', Created: 'Creating', Updated: 'Updating',
+    Queried: 'Querying', 'Checked inactive objects': 'Checking inactive objects',
+    'Scaffolded app': 'Scaffolding app', 'Render check': 'Running render check',
+    'Draft check': 'Running draft check', Approval: 'Waiting for approval',
+    Structure: 'Reading structure of', 'Change log': 'Reading change log of', 'Read dumps': 'Reading dumps',
+    'API state': 'Checking API state of', 'ABAP docs': 'Reading ABAP docs for', 'Read includes': 'Reading includes of',
+    Compared: 'Comparing', 'Previewed change': 'Previewing change to', 'Ran unit tests': 'Running unit tests on',
+    'OData test': 'Testing OData', 'Searched BAdIs': 'Searching BAdIs', 'Listed snapshots': 'Listing snapshots',
+    'Read snapshot': 'Reading snapshot of', 'Cleaned snapshots': 'Cleaning snapshots',
+    'Created transport': 'Creating transport', 'Transport for': 'Finding transport for',
+    'Listed transports': 'Listing transports', Released: 'Releasing', 'Created domain': 'Creating domain',
+    'Created data element': 'Creating data element', Locked: 'Locking', Unlocked: 'Unlocking',
+    Published: 'Publishing', Unpublished: 'Unpublishing', Message: 'Maintaining message',
+    'Number range': 'Maintaining number range', Question: 'Asking', 'Updated todos': 'Updating todos',
+    'Ran skill': 'Running skill', 'Read document': 'Reading document', Fetched: 'Fetching',
+    'Searched web': 'Searching web', 'Read project context': 'Reading project context',
+    'Read playbook': 'Reading playbook', 'Read convention': 'Reading convention', 'Merged CCA': 'Merging CCA',
+    'Merged progress': 'Merging progress', 'Checked background': 'Checking background',
+    Subagent: 'Running subagent', 'Drafted schedule': 'Drafting schedule', Applied: 'Applying',
+    'Listed patterns': 'Listing patterns', 'Deploy config': 'Writing deploy config', 'Extended app': 'Extending app',
+    Preview: 'Preview', 'Searched samples': 'Searching samples', 'Read sample': 'Reading sample',
+    'Audited metadata': 'Auditing metadata', 'Extended model': 'Extending model',
+    'Checked capability': 'Checking capability',
+};
+export function toolActivityLabel(name, args) {
+    const l = toolLabel(name, args);
+    const verb = PRESENT[l.verb] ?? `Running ${l.verb}`;
+    return l.object ? `${verb} ${l.object}` : verb;
+}
+export function foldOutput(text, keep) {
+    const all = text.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.trim().length > 0);
+    return { lines: all.slice(0, keep), hidden: Math.max(0, all.length - keep) };
+}