@north-light/crouter 0.3.158 → 0.3.160

package/dist/commands/cron.js

@@ -138,7 +138,7 @@ const addLeaf = defineLeaf({
             { kind: 'flag', name: 'tz', type: 'string', required: false, constraint: 'IANA zone (e.g. "America/New_York") for a bare-ISO --at or a calendar --every. Defaults to the host zone.' },
             { kind: 'flag', name: 'on-output', type: 'enum', choices: ['silent', 'on-failure', 'always', 'on-change'], required: false, default: 'on-failure', constraint: 'What each run does with its output. silent: record in the run log, tell nobody — never escalate. on-failure (default): no success delivery; a failing run pauses the cron and spawns a node to deal with it. always: deliver stdout every run to --sink at --tier. on-change: deliver stdout only when it differs from the previous run\'s — the shape polling wants.' },
             { kind: 'flag', name: 'sink', type: 'string', required: false, constraint: 'Where always/on-change stdout deliveries go: "node:<id>" (an existing node\'s inbox — must exist now; gone/finalized at fire time is a failure), "spawn:<kind>" (each delivered output creates a self-finishing node with stdout as kickoff — a managed child while its creator exists, otherwise a terminal parentless root), or "human" (the humanloop inbox). Required by always/on-change, rejected otherwise.' },
-            { kind: 'flag', name: 'tier', type: 'enum', choices: ['normal', 'urgent', 'critical'], required: false, default: 'normal', constraint: 'Inbox priority of a node-sink delivery.' },
+            { kind: 'flag', name: 'tier', type: 'enum', choices: ['normal', 'urgent', 'critical'], required: false, default: 'urgent', constraint: 'Inbox priority of a node-sink delivery. urgent (default): steers the target mid-turn, or wakes it when dormant — a fire is news the node asked for on a schedule, so it should land now. normal: waits for the running turn to settle. critical: aborts the running turn outright.' },
             { kind: 'flag', name: 'expires', type: 'string', required: false, constraint: 'Clock bound (same grammar as --at): the row is deleted once this instant passes. The self-limiting half of a poll-until pattern.' },
             { kind: 'flag', name: 'anchor', type: 'string', required: false, constraint: 'Couple the cron\'s lifetime to a node: the row is deleted when that node is deleted. Without an anchor it outlives every node; it ends through its one-shot run, --expires, explicit cancellation, or self-cancellation from its bash.' },
             { kind: 'flag', name: 'anchor-self', type: 'bool', required: false, constraint: 'Anchor to the calling node ($CRTR_NODE_ID). Errors outside a node.' },
@@ -259,7 +259,7 @@ const addLeaf = defineLeaf({
             scope,
             on_output: input['onOutput'] ?? 'on-failure',
             sink: typeof input['sink'] === 'string' && input['sink'] !== '' ? input['sink'] : null,
-            tier: input['tier'] ?? 'normal',
+            tier: input['tier'] ?? 'urgent',
             expires_at: expiresAt,
             anchor_node: anchorNode,
             cancel_on_wake: cancelOnWake,

package/dist/commands/node.js

@@ -27,7 +27,8 @@ import { profilesStateBlock } from '../core/profiles/state-block.js';
 import { stateBlock } from '../core/help.js';
 import { fuzzyMatch } from '../core/canvas/browse/model.js';
 import { loadPins, savePins } from '../core/canvas/browse/pins.js';
-import { backgroundRunningBashJobs, formatBashElapsed, jobStartedAtMs } from '../core/bash-jobs.js';
+import { existsSync, writeFileSync } from 'node:fs';
+import { activeBackgroundBashJobs, backgroundRunningBashJobs, bashJobPaths, formatBashElapsed, jobStartedAtMs, readJobPgid, tailJobLog } from '../core/bash-jobs.js';
 // The API seam — every canvas mutation/read routes through the daemon (B-1).
 import { cliClient, cliCanvasSource, ApiCanvasSource, rethrowAsCliError, getNodeOrNull } from './api-client.js';
 // Past this much context, an ORCHESTRATOR that spawns a managed child is better
@@ -842,16 +843,153 @@ const nodeBashBackground = defineLeaf({
         return `Handed ${result['backgrounded']} bash command(s) to the background job system for ${result['node_id']} · ran ${formatBashElapsed(oldestElapsedMs)} in the foreground.`;
     },
 });
+const nodeBashList = defineLeaf({
+    name: 'list',
+    description: 'list a node’s live background bash jobs',
+    whenToUse: 'the Inspector’s jobs section reads this to show what a node handed off to the background',
+    tier: 'hidden',
+    help: {
+        name: 'node bash list',
+        summary: 'read every still-running background bash job owned by one node',
+        params: [
+            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node whose background jobs to list. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
+            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE.' },
+            { kind: 'flag', name: 'tail', type: 'int', required: false, default: 0, constraint: 'Include this many trailing log lines per job (0 = none).' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The target node.' },
+            { name: 'jobs', type: 'object[]', required: true, constraint: 'Oldest-first {job_id, command, started_at, elapsed_ms, log_path, pgid, log_tail} for every live background job.' },
+        ],
+        outputKind: 'object',
+        effects: ['Reads the node context jobs directory. Changes nothing.'],
+    },
+    run: async (input) => {
+        const pane = input['pane'] ?? process.env['TMUX_PANE'];
+        let id = input['node'];
+        if (id === undefined || id === '')
+            id = nodeInPane(pane);
+        if (id === undefined || id === '')
+            id = process.env['CRTR_NODE_ID'];
+        if (id === undefined || id === '') {
+            throw new InputError({ error: 'no_node', message: 'no node found for the bash job list', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
+        }
+        const node = await getNodeOrNull(id);
+        if (node === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const now = Date.now();
+        const tail = Math.max(0, Math.trunc(Number(input['tail'] ?? 0)));
+        const dir = contextDir(node.node_id);
+        const jobs = activeBackgroundBashJobs(dir).map((job) => ({
+            job_id: job.jobId,
+            command: job.command,
+            started_at: new Date(job.startedAtMs).toISOString(),
+            elapsed_ms: now - job.startedAtMs,
+            log_path: job.logPath,
+            pgid: readJobPgid(dir, job.jobId) ?? null,
+            log_tail: tailJobLog(job.logPath, tail),
+        }));
+        return { node_id: node.node_id, jobs };
+    },
+    render: (result) => {
+        const jobs = result['jobs'];
+        if (jobs.length === 0)
+            return `No background bash jobs for ${result['node_id']}.`;
+        return jobs.map((job) => `${job.job_id} · ${formatBashElapsed(job.elapsed_ms)} · ${job.command.split('\n')[0]}\n  log: ${job.log_path}`).join('\n');
+    },
+});
+/** SIGTERM the job's process group, give it a moment, then SIGKILL. Returns
+ *  false only when the group was already gone at the first signal. */
+function stopJobGroup(pgid) {
+    try {
+        process.kill(-pgid, 'SIGTERM');
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+const nodeBashKill = defineLeaf({
+    name: 'kill',
+    description: 'stop one of a node’s background bash jobs',
+    whenToUse: 'a human watching the Inspector or the attach cockpit’s bash row wants a long-running background job to stop now, or an agent is abandoning work it backgrounded',
+    tier: 'hidden',
+    help: {
+        name: 'node bash kill',
+        summary: 'terminate a background bash job’s process group and tell the owning node it was canceled',
+        params: [
+            { kind: 'positional', name: 'job', required: true, constraint: 'Job id, as reported by node bash list.' },
+            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node owning the job. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
+            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE.' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The owning node.' },
+            { name: 'job_id', type: 'string', required: true, constraint: 'The job that was stopped.' },
+            { name: 'signaled', type: 'boolean', required: true, constraint: 'True when the process group was still alive and received SIGTERM.' },
+        ],
+        outputKind: 'object',
+        effects: [
+            'Sends SIGTERM (then SIGKILL) to the job’s whole process group, stopping the command and anything it forked.',
+            'Records the job’s exit so it stops showing as live, and sends the owning node an urgent inbox message saying the job was stopped — which steers that node mid-turn.',
+        ],
+    },
+    run: async (input) => {
+        const pane = input['pane'] ?? process.env['TMUX_PANE'];
+        let id = input['node'];
+        if (id === undefined || id === '')
+            id = nodeInPane(pane);
+        if (id === undefined || id === '')
+            id = process.env['CRTR_NODE_ID'];
+        if (id === undefined || id === '') {
+            throw new InputError({ error: 'no_node', message: 'no node found for the bash job', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
+        }
+        const node = await getNodeOrNull(id);
+        if (node === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const jobId = input['job'];
+        const dir = contextDir(node.node_id);
+        const paths = bashJobPaths(dir, jobId);
+        if (!existsSync(paths.dir)) {
+            throw new InputError({ error: 'not_found', message: `no background job ${jobId} for ${node.node_id}`, next: 'List live jobs with `crtr node bash list`.' });
+        }
+        const pgid = readJobPgid(dir, jobId);
+        if (pgid === undefined) {
+            throw new InputError({
+                error: 'not_stoppable',
+                message: `job ${jobId} recorded no process group`,
+                next: `It started before crtr persisted one. Stop it by hand, then it will disappear from the list. Log: ${paths.jobLog}`,
+            });
+        }
+        const signaled = stopJobGroup(pgid);
+        // The supervisor shares the group it leads, so it usually dies with the
+        // command and never writes job.exit. Record the cancellation ourselves —
+        // that sentinel is what retires the job from every live-jobs read.
+        await new Promise((r) => setTimeout(r, 400));
+        try {
+            process.kill(-pgid, 'SIGKILL');
+        }
+        catch { /* already gone */ }
+        if (!existsSync(paths.jobExit))
+            writeFileSync(paths.jobExit, '143\n');
+        await cliClient().sendMessage(node.node_id, {
+            body: `Background bash job ${jobId} was stopped by the human before it finished. Log: ${paths.jobLog}  Command: ${paths.cmdSh}`,
+            tier: 'urgent',
+        });
+        return { node_id: node.node_id, job_id: jobId, signaled };
+    },
+    render: (result) => `Canceled background bash job ${result['job_id']} for ${result['node_id']}${result['signaled'] === true ? '' : ' (its process group was already gone)'}.`,
+});
 const nodeBash = defineBranch({
     name: 'bash',
     description: 'control file-backed bash jobs owned by a node',
-    whenToUse: 'the tmux prefix menu needs to hand a running bash command off without waiting for the automatic timeout',
+    whenToUse: 'a running bash command must be handed off, listed, or stopped — the tmux prefix menu backgrounds, the Inspector’s jobs section lists and cancels',
     tier: 'hidden',
     help: {
         name: 'node bash',
         summary: 'control file-backed bash jobs owned by a node',
     },
-    children: [nodeBashBackground],
+    children: [nodeBashBackground, nodeBashList, nodeBashKill],
 });
 export const surfaceNodeIdLeaf = defineLeaf({
     name: 'id',

package/dist/commands/search.js

@@ -12,7 +12,7 @@ export function registerSearch() {
         rootEntry: {
             concept: 'web search for agents — find pages, get grounded answers, extract page content (Exa)',
             desc: 'search the web, answer a question with citations, or extract content from known URLs',
-            useWhen: 'you need information from the live web — current events, documentation, sources, facts beyond your training. Use web for relevant pages with excerpts, answer for one synthesized cited answer, and contents for clean text from URLs you already hold. Needs an Exa API key (EXA_API_KEY or ~/.crouter/exa.key).',
+            useWhen: 'you need information from the live web — current events, documentation, sources, facts beyond your training. Use web for relevant pages with excerpts, answer for one synthesized cited answer, and contents for clean text from URLs you already hold. This reaches PUBLIC pages read-only: for anything behind the user’s login, or any action inside a web app, drive their own browser with `crtr device`, and to call a service’s API server-side use `crtr connector`. Needs an Exa API key (EXA_API_KEY or ~/.crouter/exa.key).',
         },
         help: {
             name: 'search',

package/dist/commands/surface-inspect.js

@@ -8,17 +8,18 @@ import { runCoreView } from '../core/tui/host.js';
 export const surfaceInspectLeaf = defineLeaf({
     name: 'inspect',
     description: 'host the native Inspector for one node',
-    whenToUse: 'you want a live native screen for a node’s overview, raw record, and owner-scoped crons. Use node inspect show for the underlying one-shot data read instead.',
+    whenToUse: 'you want a live native screen for a node’s overview, raw record, owner-scoped crons, and live background bash jobs. Use node inspect show for the underlying one-shot data read instead.',
     help: {
         name: 'surface inspect',
         summary: 'host the native Inspector in this pane (the attach viewer opens it as a tmux popup)',
+        // sections: overview · schedule (armed crons) · jobs (live background bash) · raw
         params: [
             { kind: 'positional', name: 'node', required: true, constraint: 'Node id or resolvable reference to inspect.' },
-            { kind: 'flag', name: 'section', type: 'enum', choices: ['overview', 'schedule', 'raw'], required: false, default: 'overview', constraint: 'Section focused when the Inspector opens.' },
+            { kind: 'flag', name: 'section', type: 'enum', choices: ['overview', 'schedule', 'jobs', 'raw'], required: false, default: 'overview', constraint: 'Section focused when the Inspector opens.' },
         ],
         output: [],
         outputKind: 'object',
-        effects: ['Reads node and cron data through crtr subprocesses and crtrd. Takes over the hosting pane (or popup) until it quits.'],
+        effects: ['Reads node, cron, and background bash job data through crtr subprocesses and crtrd. Takes over the hosting pane (or popup) until it quits.'],
     },
     run: async (input) => {
         const node = input['node'];

package/dist/commands/sys/config.js

@@ -16,6 +16,7 @@ const TOP_LEVEL_KEYS = new Set([
     'completion_bell',
     'live_cycles',
     'condensed_history',
+    'fold_finished_tools',
     'modelLadders',
 ]);
 const MODEL_PROVIDERS = new Set(['anthropic', 'openai']);
@@ -153,6 +154,13 @@ function setNestedValue(cfg, key, rawValue, value) {
         cfg.condensed_history = rawValue;
         return;
     }
+    if (key === 'fold_finished_tools') {
+        if (typeof value !== 'boolean') {
+            throw usage(`fold_finished_tools must be true or false`);
+        }
+        cfg.fold_finished_tools = value;
+        return;
+    }
     if (parts.length === 1) {
         cfg[topKey] = value;
         return;
@@ -175,7 +183,7 @@ const configGet = defineLeaf({
         name: 'sys config get',
         summary: 'read a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, brokerThresholds (user only; warning and automaticReviveCap), completion_bell, live_cycles, condensed_history, modelLadders, or the whole keybindings object. Keybindings are edited only through sys setup.' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, brokerThresholds (user only; warning and automaticReviveCap), completion_bell, live_cycles, condensed_history, fold_finished_tools, modelLadders, or the whole keybindings object. Keybindings are edited only through sys setup.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to read from. Default: user.' },
         ],
         output: [
@@ -209,7 +217,7 @@ const configSet = defineLeaf({
         name: 'sys config set',
         summary: 'write a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, brokerThresholds.warning, brokerThresholds.automaticReviveCap (user scope; positive integers), completion_bell, live_cycles (integer >= 1 — trailing cycles the attach viewer renders at full fidelity; older cycles condense to prose), condensed_history (none|user|agent|both — which messages of a condensed cycle still render; none keeps only the cycle dividers), modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, brokerThresholds.warning, brokerThresholds.automaticReviveCap (user scope; positive integers), completion_bell, live_cycles (integer >= 1 — trailing cycles the attach viewer renders at full fidelity; older cycles condense to prose), condensed_history (none|user|agent|both — which messages of a condensed cycle still render; none keeps only the cycle dividers), fold_finished_tools (true|false — fold every settled tool call in the attach viewer to its single call line), modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.' },
             { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. Stored as-is if quoted; coerced to number or boolean when unambiguous.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user.' },
         ],

package/dist/commands/sys/doctor.js

@@ -10,6 +10,8 @@ import { lsRemote } from '../../core/git.js';
 import { isPidAlive } from '../../core/canvas/pid.js';
 import { cliClient } from '../api-client.js';
 import { readFault } from '../../core/runtime/fault.js';
+import { detectNerdFont, nerdFontInstallCommand, NERD_FONT_SELECT_HINT } from '../../core/runtime/nerd-font.js';
+import { detectPackageManager } from './setup-core.js';
 import { validateEffectiveCommandPlugins } from '../../core/command-plugins/discovery.js';
 import { buildExternalCommandSnapshot } from '../../core/configured-clis/discovery.js';
 import { effectiveConfiguredClis } from '../../core/configured-clis/registration.js';
@@ -277,6 +279,23 @@ async function verifySealed(root) {
     }
     await walk(root);
 }
+/** The viewer draws every tool and command icon with Nerd Font codepoints, so a
+ *  machine with no Nerd Font installed renders tofu boxes. Nothing else in
+ *  crtr notices — this is the one place a fresh install learns why. Never
+ *  auto-fixed: installing a font, and pointing the terminal profile at it, is a
+ *  human action. */
+function runNerdFontCheck() {
+    const detection = detectNerdFont();
+    if (detection.installed) {
+        return pass('user', 'terminal:nerd-font', `installed (${detection.evidence}) — if icons still render as boxes, ${NERD_FONT_SELECT_HINT}`);
+    }
+    const plan = nerdFontInstallCommand(detectPackageManager());
+    return failCheck('user', 'terminal:nerd-font', 'no Nerd Font installed — viewer tool/command icons will render as tofu boxes', {
+        kind: 'human_action',
+        description: `Install a Nerd Font (${plan.hint}), ${NERD_FONT_SELECT_HINT}`,
+        ...(plan.command ? { command: plan.command } : {}),
+    });
+}
 async function generationChecks(label, lookup, allowAbsent) {
     if (lookup.generation === null) {
         const message = lookup.error ?? 'no runtime generation';
@@ -486,7 +505,7 @@ export const sysDoctorLeaf = defineLeaf({
             { kind: 'flag', name: 'remote', type: 'bool', required: false, constraint: 'Check git remotes with ls-remote (slow — makes network calls).' },
         ],
         output: [
-            { name: 'checks', type: 'object[]', required: true, constraint: 'Each: {scope, name, status, message, fixed?, remediation?}. status: pass | fail. scope may be user | project | canvas. Runtime checks validate selected and process generation manifests, sealing/containment, and full SHA-256 inventories. Command-plugin manifest checks appear as plugin:<name>:commands (validated statically, never executed); their remediation is always a human_action (disable/update/remove the plugin). remediation (when present) is {kind, description, ...payload} where kind is remove_config_key | rm_path | human_action; fault human_action remediations include the canonical logs command. Sorted by scope then name.' },
+            { name: 'checks', type: 'object[]', required: true, constraint: 'Each: {scope, name, status, message, fixed?, remediation?}. status: pass | fail. scope may be user | project | canvas. Runtime checks validate selected and process generation manifests, sealing/containment, and full SHA-256 inventories. terminal:nerd-font (user scope) reports whether a Nerd Font is installed for the viewer\'s icon glyphs; its remediation is always a human_action carrying the platform install command, never auto-fixed. Command-plugin manifest checks appear as plugin:<name>:commands (validated statically, never executed); their remediation is always a human_action (disable/update/remove the plugin). remediation (when present) is {kind, description, ...payload} where kind is remove_config_key | rm_path | human_action; fault human_action remediations include the canonical logs command. Sorted by scope then name.' },
             { name: 'ok', type: 'boolean', required: true, constraint: 'True when no unresolved fail checks remain.' },
         ],
         outputKind: 'object',
@@ -506,6 +525,8 @@ export const sysDoctorLeaf = defineLeaf({
             const results = runChecksForScope(scope, { fix, remote });
             allResults.push(...results);
         }
+        if (scopes.includes('user'))
+            allResults.push(runNerdFontCheck());
         allResults.push(...runCommandPluginChecks(scopes));
         allResults.push(...runConfiguredCliChecks(scopes));
         allResults.push(...await runFaultChecks());

package/dist/commands/sys/setup-core.d.ts

@@ -1,6 +1,10 @@
 import { type BindingId, type BindingResolution, type KeybindingDiagnostic, type SparseKeybindingOverrides } from '../../core/keybindings/index.js';
 export type SetupPackageId = 'crtr-extensions' | 'mode-switch' | 'oauth-adapter' | 'capture-plugin';
-export type SetupTool = 'tmux' | 'nvim';
+/** `nerd-font` is not a command on PATH like the other two — it is an installed
+ *  font face, detected by fontconfig/font-directory scan. The viewer renders
+ *  every tool and command icon with Nerd Font codepoints, so without it a fresh
+ *  machine shows tofu boxes. */
+export type SetupTool = 'tmux' | 'nvim' | 'nerd-font';
 /** `marketplace-plugin` installs a crtr plugin from a registered marketplace
  *  (`installSource` is a `<marketplace>/<plugin>` ref) instead of running the
  *  bundled pi CLI. Offered in setup and NOT installed by first-run bootstrap:

package/dist/commands/sys/setup-core.js

@@ -9,6 +9,7 @@ import { builtinPiPackageDir } from '../../core/scope.js';
 import { readJsonIfExists } from '../../core/fs-utils.js';
 import { resolveBundledPiCliPath } from '../../core/runtime/pi-cli.js';
 import { installTmuxBindings } from '../../core/runtime/tmux-chrome.js';
+import { detectNerdFont, nerdFontInstallCommand, NERD_FONT_SELECT_HINT } from '../../core/runtime/nerd-font.js';
 import { globalHumanloopHealth, globalHumanloopInstallCommand } from '../../core/runtime/package-health.js';
 import { registerCrouterRoot } from '../human/shared.js';
 import { installFromMarketplace } from '../pkg/plugin-manage.js';
@@ -301,6 +302,19 @@ export function buildSystemInstallPlan(tool, packageManager, installed) {
             autoInstall: false,
         };
     }
+    if (tool === 'nerd-font') {
+        const plan = nerdFontInstallCommand(packageManager);
+        return {
+            tool,
+            label,
+            installed: false,
+            checked: plan.autoInstall,
+            packageManager,
+            command: plan.command,
+            hint: `${plan.hint} — ${NERD_FONT_SELECT_HINT}`,
+            autoInstall: plan.autoInstall,
+        };
+    }
     const packageName = tool === 'nvim' ? 'neovim' : 'tmux';
     switch (packageManager) {
         case 'brew':
@@ -361,7 +375,7 @@ export function buildSystemInstallPlan(tool, packageManager, installed) {
     }
 }
 export function buildSystemToolState(tool, packageManager, commandExists = detectCommandOnPath) {
-    const installed = commandExists(tool);
+    const installed = tool === 'nerd-font' ? detectNerdFont().installed : commandExists(tool);
     return {
         tool,
         installed,
@@ -397,7 +411,7 @@ export function buildSetupInitialState(opts = {}) {
         installedPackageIds.add(id);
     const commandExists = opts.commandExists ?? detectCommandOnPath;
     const packageManager = opts.packageManager ?? detectPackageManager(process.platform, commandExists);
-    const systemTools = ['tmux', 'nvim'].map((tool) => buildSystemToolState(tool, packageManager, commandExists));
+    const systemTools = ['tmux', 'nvim', 'nerd-font'].map((tool) => buildSystemToolState(tool, packageManager, commandExists));
     return { manifest, installedPackageIds, systemTools, exaKeyPath: resolveExaKeyPath(homeDir) };
 }
 export function buildSetupStaticInstructions(opts) {

package/dist/commands/sys/setup-wizard.d.ts

@@ -62,6 +62,8 @@ export declare class SetupWizard implements Component, Focusable {
     private keyNotice;
     private brokerLimitIndex;
     private brokerLimitNotice;
+    private displayIndex;
+    private displayNotice;
     private cachedWidth;
     private cachedHeight;
     private cachedLines;
@@ -74,6 +76,14 @@ export declare class SetupWizard implements Component, Focusable {
     invalidate(): void;
     private setTab;
     private moveTab;
+    private moveDisplayRow;
+    /** Advance the selected display setting to its next value and persist it to user
+     *  config immediately — these are one-keystroke view preferences, so there is no
+     *  separate save gesture to forget. A viewer picks the new value up on its next
+     *  attach (`live_cycles` / `condensed_history` / `fold_finished_tools` are all read
+     *  per ChatView), and `completion_bell` on the next turn end. */
+    private cycleDisplaySetting;
+    private handleDisplayInput;
     private cancel;
     dispose(): void;
     private matches;
@@ -124,6 +134,7 @@ export declare class SetupWizard implements Component, Focusable {
     private renderKeybindings;
     private renderModels;
     private renderBrokerLimits;
+    private renderDisplay;
     render(width: number): string[];
 }
 export declare function runSetup(): Promise<void>;

package/dist/commands/sys/setup-wizard.js

@@ -13,6 +13,7 @@ import { removeProviderRow } from '../../core/provider-management.js';
 import { readConfig, readRawConfigAtRoot, readRawScopeConfig, updateRawConfigAtomically, persistDefaultKindModel, persistModelLadders, readMergedLaunchConfig } from '../../core/config.js';
 import { findProjectScopeRoots, userScopeRoot } from '../../core/scope.js';
 import { loadProfileManifest, profileRoot } from '../../core/profiles/manifest.js';
+import { CONDENSED_HISTORY_MODES } from '../../types.js';
 import { BINDING_CATALOG, formatBinding, formatGesture, matchesPiTuiInput, persistUserKeybindings, resolveKeybindings, KeybindingConcurrentEditError, KeybindingValidationError, } from '../../core/keybindings/index.js';
 import { configuredLadderProviders, inferPortableModelSelection } from '../../core/runtime/model-selection.js';
 import { cliClient } from '../api-client.js';
@@ -79,7 +80,11 @@ function currentWidth() {
     return Math.max(1, process.stdout.columns ?? 80);
 }
 function toolLabel(tool) {
-    return tool === 'nvim' ? 'nvim' : 'tmux';
+    if (tool === 'nvim')
+        return 'nvim';
+    if (tool === 'nerd-font')
+        return 'Nerd Font';
+    return 'tmux';
 }
 function positiveInteger(value) {
     if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1)
@@ -652,6 +657,45 @@ class ProviderPanel {
         return useFrame ? framed(body, width) : body.map((line) => truncateToWidth(line, width));
     }
 }
+const TAB_LABELS = ['Providers', 'Plugins', 'System', 'Exa', 'Keybindings', 'Models', 'Broker limits', 'Display'];
+const DISPLAY_TAB = 7;
+/** The viewer display settings the Display tab edits, in row order. Each row owns
+ *  its own value cycling and its own formatting, so adding a setting here is the
+ *  whole change — the tab's input and render loops stay generic. Every one is a
+ *  user-scope `ScopeConfig` key persisted the moment it changes. */
+const DISPLAY_ROWS = [
+    {
+        key: 'fold_finished_tools',
+        label: 'Fold finished tools',
+        description: 'Fold every settled tool call to its call line (path included). Toggle live with /fold-tools.',
+        format: (cfg) => (cfg.fold_finished_tools ? 'on' : 'off'),
+        next: (cfg) => ({ fold_finished_tools: !cfg.fold_finished_tools }),
+    },
+    {
+        key: 'completion_bell',
+        label: 'Completion bell',
+        description: 'Ring a short sound in the viewer when the node you are watching finishes a turn.',
+        format: (cfg) => (cfg.completion_bell ? 'on' : 'off'),
+        next: (cfg) => ({ completion_bell: !cfg.completion_bell }),
+    },
+    {
+        key: 'live_cycles',
+        label: 'Live cycles',
+        description: 'Trailing refresh cycles rendered at full fidelity; older cycles condense to text. Default 2.',
+        format: (cfg) => String(cfg.live_cycles),
+        next: (cfg, delta) => ({ live_cycles: ((cfg.live_cycles - 1 + delta + 6) % 6) + 1 }),
+    },
+    {
+        key: 'condensed_history',
+        label: 'Condensed history',
+        description: 'Which messages of a condensed cycle still render. Tool calls are never kept.',
+        format: (cfg) => cfg.condensed_history,
+        next: (cfg, delta) => ({
+            condensed_history: CONDENSED_HISTORY_MODES[(CONDENSED_HISTORY_MODES.indexOf(cfg.condensed_history) + delta + CONDENSED_HISTORY_MODES.length)
+                % CONDENSED_HISTORY_MODES.length],
+        }),
+    },
+];
 const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
 const LADDER_PROVIDER_KEYS = ['anthropic', 'openai'];
 const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
@@ -1265,6 +1309,8 @@ export class SetupWizard {
     keyNotice;
     brokerLimitIndex = 0;
     brokerLimitNotice;
+    displayIndex = 0;
+    displayNotice;
     cachedWidth;
     cachedHeight;
     cachedLines;
@@ -1336,9 +1382,39 @@ export class SetupWizard {
         this.invalidate();
     }
     moveTab(delta) {
-        const next = ((this.activeTab + delta + 7) % 7);
+        const next = ((this.activeTab + delta + TAB_LABELS.length) % TAB_LABELS.length);
         this.setTab(next);
     }
+    moveDisplayRow(delta) {
+        this.displayIndex = (this.displayIndex + delta + DISPLAY_ROWS.length) % DISPLAY_ROWS.length;
+        this.displayNotice = undefined;
+        this.invalidate();
+    }
+    /** Advance the selected display setting to its next value and persist it to user
+     *  config immediately — these are one-keystroke view preferences, so there is no
+     *  separate save gesture to forget. A viewer picks the new value up on its next
+     *  attach (`live_cycles` / `condensed_history` / `fold_finished_tools` are all read
+     *  per ChatView), and `completion_bell` on the next turn end. */
+    cycleDisplaySetting(delta) {
+        const row = DISPLAY_ROWS[this.displayIndex];
+        const current = readConfig('user');
+        const next = row.next(current, delta);
+        updateRawConfigAtomically('user', (latest) => ({ ...latest, ...next }));
+        this.displayNotice = `Saved ${row.key} = ${row.format({ ...current, ...next })}. Applies on the next attach.`;
+        this.invalidate();
+    }
+    handleDisplayInput(data) {
+        if (this.matches('crtr.setup.list-down', data))
+            this.moveDisplayRow(1);
+        else if (this.matches('crtr.setup.list-up', data))
+            this.moveDisplayRow(-1);
+        else if (this.matches('crtr.setup.toggle', data) || this.matches('crtr.setup.cell-next', data))
+            this.cycleDisplaySetting(1);
+        else if (this.matches('crtr.setup.cell-previous', data))
+            this.cycleDisplaySetting(-1);
+        else if (this.matches('crtr.setup.advance', data))
+            this.moveTab(1);
+    }
     cancel() {
         if (this.confirming) {
             this.confirming = false;
@@ -1899,11 +1975,15 @@ export class SetupWizard {
                 this.invalidate();
             return;
         }
+        if (this.activeTab === DISPLAY_TAB) {
+            this.handleDisplayInput(data);
+            return;
+        }
         this.handleBrokerLimitsInput(data);
     }
     renderHeader(width) {
-        const tabs = ['Providers', 'Plugins', 'System', 'Exa', 'Keybindings', 'Models', 'Broker limits'];
-        const fullTabLine = tabs
+        const tabs = TAB_LABELS;
+        const fullTabLine = tabs.slice()
             .map((label, index) => tabPill(label, index === this.activeTab))
             .join(theme.fg('dim', '  ·  '));
         const tabLine = visibleWidth(fullTabLine) <= width
@@ -1923,6 +2003,9 @@ export class SetupWizard {
                 : `${this.label('crtr.setup.list-down')}/${this.label('crtr.setup.list-up')} row · ${this.label('crtr.setup.cell-previous')}/${this.label('crtr.setup.cell-next')} column · ${this.label('crtr.setup.models.scope-next')} scope · ${this.label('crtr.setup.models.open')} edit · ${this.label('crtr.setup.tab-next')} next · ${this.label('crtr.setup.cancel')} cancel`;
             return [truncateToWidth(theme.fg('dim', hint), width)];
         }
+        if (this.activeTab === DISPLAY_TAB) {
+            return [truncateToWidth(theme.fg('dim', `${this.label('crtr.setup.list-down')}/${this.label('crtr.setup.list-up')} row · ${this.label('crtr.setup.toggle')} or ${this.label('crtr.setup.cell-next')}/${this.label('crtr.setup.cell-previous')} change value · ${tabs} · ${this.label('crtr.setup.cancel')} cancel`), width)];
+        }
         if (this.activeTab === 6) {
             return [truncateToWidth(theme.fg('dim', `${this.label('crtr.setup.list-down')}/${this.label('crtr.setup.list-up')} field · type value · Enter save · ${this.fieldSafeLabel('crtr.setup.tab-next')}/${this.fieldSafeLabel('crtr.setup.tab-previous')} switch tabs · ${this.label('crtr.setup.cancel')} cancel`), width)];
         }
@@ -1973,7 +2056,7 @@ export class SetupWizard {
     }
     renderSystems(width) {
         const out = [];
-        out.push(truncateToWidth(`${theme.fg('accent', theme.bold('System deps'))}${theme.fg('dim', '  tmux + nvim check')}`, width));
+        out.push(truncateToWidth(`${theme.fg('accent', theme.bold('System deps'))}${theme.fg('dim', '  tmux + nvim + Nerd Font check')}`, width));
         for (const [index, tool] of this.systemTools.entries()) {
             const selected = index === this.systemIndex;
             const marker = selected ? theme.fg('accent', '▶') : theme.fg('dim', ' ');
@@ -2172,6 +2255,26 @@ export class SetupWizard {
         }
         return out;
     }
+    renderDisplay(width) {
+        const out = [];
+        const cfg = readConfig('user');
+        out.push(truncateToWidth(`${theme.fg('accent', theme.bold('Display'))}${theme.fg('dim', '  user scope · attach viewer')}`, width));
+        out.push(truncateToWidth(theme.fg('dim', 'Each change saves immediately and applies to viewers attached from now on.'), width));
+        out.push('');
+        for (const [index, row] of DISPLAY_ROWS.entries()) {
+            const selected = index === this.displayIndex;
+            const marker = selected ? theme.fg('accent', '▶') : ' ';
+            const name = selected ? theme.fg('accent', row.label) : row.label;
+            out.push(truncateToWidth(`${marker} ${padAnsi(name, 24)} ${theme.fg('success', row.format(cfg))}`, width));
+            out.push(truncateToWidth(theme.fg('dim', `    ${row.description}`), width));
+        }
+        if (this.displayNotice) {
+            out.push('');
+            for (const line of wrapText(this.displayNotice, width))
+                out.push(theme.fg('success', line));
+        }
+        return out;
+    }
     render(width) {
         const bypass = this.activeTab === 5 && this.models.isPickerOpen();
         const height = this.terminalRows();
@@ -2194,7 +2297,9 @@ export class SetupWizard {
                                     ? this.renderKeybindings(width)
                                     : this.activeTab === 5
                                         ? this.renderModels(width)
-                                        : this.renderBrokerLimits(width)),
+                                        : this.activeTab === 6
+                                            ? this.renderBrokerLimits(width)
+                                            : this.renderDisplay(width)),
             '',
             ...this.renderFooter(width),
         ];

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -75,7 +75,7 @@ async function waitFor(predicate, timeoutMs = 3000, stepMs = 10) {
         await wait(stepMs);
     }
 }
-test('coalesce inlines short reports with their absolute path and only hints for remaining canonical refs', () => {
+test('coalesce inlines short report bodies with a trailing artifact pointer and only hints for remaining canonical refs', () => {
     freshNode('child');
     const child = createNode({
         node_id: 'child',
@@ -93,8 +93,10 @@ test('coalesce inlines short reports with their absolute path and only hints for
     const digest = coalesce([
         finalizeInboxEntry({ from: 'child', tier: 'normal', kind: 'update', label: 'short report', ref: 'child:reports/short-update.md' }),
     ]);
-    assert.match(digest, new RegExp(`\\[update\\] short report at ${reportPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:`));
-    assert.match(digest, /short report body/);
+    // The label is NOT reprinted above the body it duplicates; the path trails it.
+    assert.doesNotMatch(digest, /\[update\] short report/);
+    assert.match(digest, /\[update\]\n {4}short report body\n/);
+    assert.match(digest, new RegExp(`\\(report: ${reportPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\)`));
     assert.doesNotMatch(digest, /Dereference a ref with/);
     const guidance = 'Dereference a ref with `crtr canvas history read <ref>`.';
     const canonical = coalesce([