@north-light/crouter 0.3.158 → 0.3.160

package/dist/core/runtime/naming.js

@@ -6,6 +6,12 @@
 // the first prompt by asking pi headlessly (`pi -p`), persisted on the node's
 // meta so it survives revives and updates the live session name.
 //
+// The namer returns a STRUCTURED result — {name, icon} — produced by constrained
+// sampling against the `name_session` tool in `pi-extensions/naming-tool.ts`,
+// not by parsing prose. The icon is a Nerd Font glyph the model picks freely
+// (guided by example blocks, not a closed enum) and is stored as its own meta
+// field, so each surface decides whether to render it.
+//
 // One entry point: generateAndPersistName — async (execFile, non-blocking).
 // Naming happens INSIDE the named node's own pi process, off the first real
 // message (the kickoff task or a human's first line), never on the spawn path:
@@ -16,23 +22,59 @@
 // Best-effort: a failed/slow/garbled pi call falls back to a local slug of the
 // prompt, so a node always gets a sane name.
 import { execFile } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { bundledPiSubprocessEnv, resolveBundledPiCliPath } from './pi-cli.js';
+import { NAMING_TOOL_PATH } from './canvas-extensions.js';
+import { defaultProvider, modelLadders, stripThinkingSuffix } from './model-selection.js';
 /** Cap on prompt text fed to the namer — a name needs only the gist. */
 const PROMPT_CAP = 2000;
-/** Wall-clock budget for the headless pi call before we fall back to a slug. */
-const NAME_TIMEOUT_MS = 20_000;
-const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. This name is a label used to identify the ' +
+/** Wall-clock budget for the headless pi call before we fall back to a slug.
+ *  Generous because the structured path costs a tool round-trip on top of the
+ *  provider's own cold start; naming is async and off the spawn path, so a slow
+ *  call delays only the label, never the node. */
+const NAME_TIMEOUT_MS = 45_000;
+/** Nerd Font glyphs offered to the namer as EXAMPLES, never as a closed set —
+ *  the model may pick any Nerd Font character it thinks fits better. Grouped by
+ *  the kind of work they read as, so the model generalizes from the grouping
+ *  instead of pattern-matching a lookup table. */
+const ICON_EXAMPLES = [
+    'fixing/diagnosis: U+F188 bug, U+F0F1 stethoscope, U+F06D fire, U+F071 warning',
+    'building/changing code: U+F0AD wrench, U+F067 plus, U+F121 code, U+F085 cogs, U+F021 refresh',
+    'testing/verifying: U+F0C3 flask, U+F00C check, U+F24E balance',
+    'writing/docs/research: U+F02D book, U+F15C document, U+F002 magnifier, U+F0EB lightbulb',
+    'data/infra: U+F1C0 database, U+F0C2 cloud, U+F120 terminal, U+F013 gear, U+F1B3 packages',
+    'ship/perf/scale: U+F135 rocket, U+F0E7 bolt, U+F080 chart, U+F201 trend line',
+    'security/access: U+F132 shield, U+F023 lock, U+F084 key',
+    'interface/design: U+F1FC paintbrush, U+F03E image, U+F108 display',
+    'communication/coordination: U+F1D8 paper plane, U+F0E6 comments, U+F0E8 sitemap, U+F0C1 link',
+].join('\n');
+const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. The name is a label used to identify the ' +
     'session at a glance among many other concurrent programming sessions, so it must ' +
-    'describe what the task is about. Reply with ONLY a concise 3-8 word name in ' +
-    'kebab-case: lowercase words joined by single hyphens (e.g. `refactor-auth-token-flow`, ' +
-    '`add-csv-export-endpoint`). No punctuation, quotes, prose, or trailing text. ' +
-    'Output JUST the name, nothing else.';
+    'describe what the task is about.\n\n' +
+    'Call the `name_session` tool exactly once with:\n' +
+    '- `name`: a concise 3-8 word kebab-case name — lowercase words joined by single ' +
+    'hyphens (e.g. `refactor-auth-token-flow`, `add-csv-export-endpoint`). No punctuation, ' +
+    'quotes, or prose.\n' +
+    '- `icon`: ONE Nerd Font glyph, written as its codepoint in `U+XXXX` form (e.g. ' +
+    '`U+F188`). ANY Nerd Font codepoint is allowed — the whole Font Awesome, Material, ' +
+    'Devicons, Octicons and Codicons ranges are available, so reach for the glyph that ' +
+    'actually depicts this work rather than settling for one of the examples below. ' +
+    'Emit a codepoint, not a name like `nf-fa-bug`, and not an emoji.\n\n' +
+    'Pick the glyph whose depicted object a person would associate with this work at a ' +
+    'glance. Prefer the concrete subject (a database, a lock, a browser, a specific ' +
+    "technology's logo) over a generic verb glyph when the task has one; fall back to the " +
+    'activity (fixing, building, testing) otherwise. Never reuse a generic gear for ' +
+    'everything.\n\n' +
+    'Examples of what reads well, by kind of work:\n' +
+    ICON_EXAMPLES;
 /** Put the raw task text FIRST in a delimited block, then the instruction, so the
  *  model reads the content before being told what to do and never mistakes the
  *  prompt's own text for the instruction. The prompt is capped first, so the
  *  closing tag is always present. */
 function nameUserPrompt(prompt) {
-    return `<prompt>\n${prompt.slice(0, PROMPT_CAP)}\n</prompt>\n\nName this session based on the task above. The name should describe what the task is about, so it can be identified among many other programming sessions. Output JUST the name, nothing else.`;
+    return `<prompt>\n${prompt.slice(0, PROMPT_CAP)}\n</prompt>\n\nName this session based on the task above, and pick an icon depicting it. Call \`name_session\` once, then stop.`;
 }
 /** A short stop-word set so the local-slug fallback skips filler words. */
 const STOPWORDS = new Set([
@@ -64,18 +106,24 @@ export function slugFromPrompt(prompt) {
         .slice(0, 3);
     return sanitizeSessionName(picked.join('-')) || 'session';
 }
-/** Default namer model — Anthropic's small/fast model. Naming is a one-line
- *  classification, so we pin Haiku (cheap, quick) instead of inheriting the
- *  node's heavyweight default. Override with CRTR_NAME_MODEL. */
-const DEFAULT_NAME_MODEL = 'anthropic/claude-haiku-4-5';
-/** The pi argv for a headless name request. Stripped down (no tools, session,
- *  context files, extensions, skills, templates, themes) so it's fast and
- *  side-effect free. Pinned to Haiku with thinking off — naming is a trivial
- *  classification that never needs a reasoning budget. Override the model with
- *  CRTR_NAME_MODEL. */
-function piTextArgs(systemPrompt, userPrompt) {
+/** The namer's model: the `light` rung of the DEFAULT provider's ladder, with
+ *  any thinking suffix stripped (we pass `--thinking off` explicitly — naming is
+ *  a trivial classification that never needs a reasoning budget). Reading the
+ *  ladder rather than pinning a concrete model id keeps naming working for a
+ *  user who never configured Anthropic: an OpenAI default provider resolves to
+ *  its own light rung. `CRTR_NAME_MODEL` still overrides. */
+function nameModel() {
     const override = process.env['CRTR_NAME_MODEL'];
-    const model = override !== undefined && override.trim() !== '' ? override.trim() : DEFAULT_NAME_MODEL;
+    if (override !== undefined && override.trim() !== '')
+        return override.trim();
+    const ladders = modelLadders();
+    return stripThinkingSuffix(ladders[defaultProvider(ladders)].light);
+}
+/** The pi argv for a headless TEXT request (issue titles). Stripped down (no
+ *  tools, session, context files, extensions, skills, templates, themes) so
+ *  it's fast and side-effect free. */
+function piTextArgs(systemPrompt, userPrompt) {
+    const model = nameModel();
     return [
         '-p',
         '--no-session',
@@ -93,32 +141,120 @@ function piTextArgs(systemPrompt, userPrompt) {
         userPrompt,
     ];
 }
+/** The pi argv for a headless STRUCTURED name request: same stripped-down run,
+ *  but with the naming tool loaded explicitly (`-e` still works under
+ *  `--no-extensions`) and the tool allowlist narrowed to it, so the model's only
+ *  possible action is one constrained-schema emission. */
 function nameArgs(prompt) {
-    return piTextArgs(NAME_SYSTEM_PROMPT, nameUserPrompt(prompt));
+    return [
+        '-p',
+        '--no-session',
+        '--no-context-files',
+        '--no-extensions',
+        '--no-skills',
+        '--no-prompt-templates',
+        '--no-themes',
+        '-e', NAMING_TOOL_PATH,
+        '--tools', 'name_session',
+        '--mode', 'text',
+        // A trivial one-shot classification — no thinking budget, ever.
+        '--thinking', 'off',
+        '--model', nameModel(),
+        '--system-prompt', NAME_SYSTEM_PROMPT,
+        nameUserPrompt(prompt),
+    ];
 }
-/** Ask pi headlessly for a kebab-case name for `body`, async. Resolves to the
- *  sanitized name, or '' on any failure (non-zero exit, timeout, empty/garbled
- *  output) so the caller can fall back to a local slug. Owns the subprocess
- *  mechanics — crucially it hands pi an immediate stdin EOF: `pi -p` reads
- *  stdin, and execFile's default stdin is an OPEN pipe that never closes, so
- *  without this pi blocks waiting for EOF and the call exits non-zero (the
- *  regression that silently lost every LLM name to the slug fallback).
+/** Normalize a model-supplied icon to a single renderable glyph, or '' when
+ *  nothing usable came back.
+ *
+ *  The model is asked for a `U+XXXX` codepoint rather than the literal
+ *  character: Nerd Font glyphs sit in the private-use areas, which models
+ *  reproduce unreliably as literal text (they tend to substitute an emoji), but
+ *  name accurately as codepoints. A literal glyph is still accepted — including
+ *  an emoji, which renders fine even if it is not the house style — so a model
+ *  that ignores the format still contributes. Rejects a spelled-out
+ *  `nf-fa-bug`, a bare ASCII letter, and anything multi-glyph, all of which
+ *  would render as noise or tofu in a label. */
+export function sanitizeIcon(raw) {
+    const trimmed = (raw ?? '').trim();
+    if (trimmed === '')
+        return '';
+    const codepoint = /^(?:u\+|0x|\\u\{?|&#x)?([0-9a-f]{4,6})\}?;?$/i.exec(trimmed);
+    if (codepoint !== null) {
+        const value = Number.parseInt(codepoint[1], 16);
+        // Anything below the symbol blocks is a letter/digit/control — not an icon.
+        if (value >= 0x2000 && value <= 0x10ffff) {
+            try {
+                return String.fromCodePoint(value);
+            }
+            catch {
+                return '';
+            }
+        }
+        return '';
+    }
+    const points = [...trimmed];
+    // A glyph, plus at most a variation selector.
+    if (points.length > 2)
+        return '';
+    return points[0].codePointAt(0) >= 0x2000 ? trimmed : '';
+}
+/** Ask pi headlessly for a structured {name, icon} for `body`, async. Resolves
+ *  to a sanitized SessionName, or `{name:'',icon:''}` on any failure (non-zero
+ *  exit, timeout, no tool call, garbled emission) so the caller can fall back to
+ *  a local slug. Owns the subprocess mechanics — crucially it hands pi an
+ *  immediate stdin EOF: `pi -p` reads stdin, and execFile's default stdin is an
+ *  OPEN pipe that never closes, so without this pi blocks waiting for EOF and
+ *  the call exits non-zero (the regression that silently lost every LLM name to
+ *  the slug fallback).
  *
  *  Exported (not just for tests): the canvas-coupled persistence wrapper
  *  generateAndPersistName lives in naming-persist.ts to keep this module
  *  canvas-free, and imports this pure helper. */
 export function headlessName(body) {
+    const empty = { name: '', icon: '' };
     return new Promise((resolve) => {
+        let dir = null;
         try {
-            const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...nameArgs(body)], { encoding: 'utf8', timeout: NAME_TIMEOUT_MS, env: bundledPiSubprocessEnv() }, (err, stdout) => {
-                if (err || typeof stdout !== 'string')
-                    return resolve('');
-                resolve(sanitizeSessionName(stdout));
+            dir = mkdtempSync(join(tmpdir(), 'crtr-name-'));
+            const resultFile = join(dir, 'name.json');
+            const done = (value) => {
+                if (dir !== null) {
+                    try {
+                        rmSync(dir, { recursive: true, force: true });
+                    }
+                    catch { /* temp */ }
+                }
+                resolve(value);
+            };
+            const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...nameArgs(body)], {
+                encoding: 'utf8',
+                timeout: NAME_TIMEOUT_MS,
+                env: { ...bundledPiSubprocessEnv(), CRTR_NAME_RESULT_FILE: resultFile },
+            }, () => {
+                // The tool call is the ONLY channel: a non-zero exit still counts when
+                // the emission already landed (pi print-mode can exit oddly after a
+                // terminating tool), and a clean exit without the file is a failure.
+                try {
+                    const parsed = JSON.parse(readFileSync(resultFile, 'utf8'));
+                    const name = sanitizeSessionName(typeof parsed['name'] === 'string' ? parsed['name'] : '');
+                    const icon = sanitizeIcon(typeof parsed['icon'] === 'string' ? parsed['icon'] : '');
+                    done(name !== '' ? { name, icon } : empty);
+                }
+                catch {
+                    done(empty);
+                }
             });
             child.stdin?.end(); // immediate EOF — see the doc above
         }
         catch {
-            resolve('');
+            if (dir !== null) {
+                try {
+                    rmSync(dir, { recursive: true, force: true });
+                }
+                catch { /* temp */ }
+            }
+            resolve(empty);
         }
     });
 }

package/dist/core/runtime/nerd-font.d.ts

@@ -0,0 +1,28 @@
+export interface NerdFontDetection {
+    /** A Nerd Font face is installed somewhere on this system. */
+    installed: boolean;
+    /** The family or filename that matched, for the doctor message. */
+    evidence: string | null;
+    /** How the match was found — fontconfig query, or a font-directory scan. */
+    source: 'fc-list' | 'font-dir' | null;
+}
+export declare function detectNerdFont(platform?: NodeJS.Platform, home?: string): NerdFontDetection;
+/** Download the upstream symbols-only patch into the user's font dir. Works on
+ *  every Linux regardless of package manager — Debian/Ubuntu and Fedora ship no
+ *  Nerd Font package, so there is nothing native to install there. Needs no
+ *  sudo: it writes to `~/.local/share/fonts`. */
+export declare const NERD_FONT_MANUAL_LINUX_COMMAND: string;
+export interface NerdFontInstallCommand {
+    command: string | null;
+    hint: string;
+    autoInstall: boolean;
+}
+/** The install command for this platform/package manager. `packageManager`
+ *  matches setup's detection: only brew and pacman have a real Nerd Font
+ *  package, everything else on Linux gets the upstream download. A non-brew
+ *  package manager only ever exists on Linux, so it settles the platform on its
+ *  own and `platform` decides only the `manual` case. */
+export declare function nerdFontInstallCommand(packageManager: 'brew' | 'apt-get' | 'dnf' | 'pacman' | 'manual', platform?: NodeJS.Platform): NerdFontInstallCommand;
+/** Every install path ends the same way: the font is on disk but the terminal
+ *  emulator still has to be pointed at it, and crtr cannot do that. */
+export declare const NERD_FONT_SELECT_HINT = "then set your terminal profile's font to a Nerd Font (e.g. add \"Symbols Nerd Font Mono\" as the non-ASCII/fallback font) \u2014 installing it does not select it";

package/dist/core/runtime/nerd-font.js

@@ -0,0 +1,127 @@
+import { spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** crtr's viewer renders tool calls, command icons, node badges and the
+ *  inspector with Nerd Font private-use-area codepoints (see
+ *  `core/preview-registry.ts` and `clients/attach/render/tool-calls.ts`), so a
+ *  terminal without a Nerd Font shows tofu boxes for every icon. Nothing about
+ *  the font is auto-detectable from inside the process — the terminal emulator
+ *  picks the face — so the best we can do is detect an INSTALLED Nerd Font on
+ *  the system and tell the user to point their terminal profile at it. */
+/** Font-family and filename fragments that only appear in Nerd Font builds.
+ *  `symbols` alone would false-positive on system symbol faces, so the
+ *  symbols-only patch is matched with its full distributed name. */
+const NERD_FONT_PATTERN = /nerd[ _-]?font|symbolsnerdfont|symbols-only/i;
+/** Font directories searched when fontconfig is unavailable (always the case
+ *  on macOS). User-level dirs first: an install crtr suggested lands there. */
+function fontDirs(platform, home) {
+    if (platform === 'darwin') {
+        return [join(home, 'Library', 'Fonts'), '/Library/Fonts', '/System/Library/Fonts'];
+    }
+    return [
+        join(home, '.local', 'share', 'fonts'),
+        join(home, '.fonts'),
+        '/usr/local/share/fonts',
+        '/usr/share/fonts',
+    ];
+}
+/** Shallow recursive filename scan. Font trees nest a couple of levels
+ *  (`/usr/share/fonts/truetype/<family>/`), so depth 3 reaches every real
+ *  install without walking an unbounded tree. */
+function scanForNerdFont(dir, depth) {
+    if (depth < 0)
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null; // absent or unreadable directory is simply not a match
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const nested = scanForNerdFont(join(dir, entry.name), depth - 1);
+            if (nested !== null)
+                return nested;
+            continue;
+        }
+        if (!/\.(ttf|otf|ttc)$/i.test(entry.name))
+            continue;
+        if (NERD_FONT_PATTERN.test(entry.name))
+            return entry.name;
+    }
+    return null;
+}
+/** Ask fontconfig for installed families. Present on Linux, absent on macOS. */
+function queryFontconfig() {
+    const probe = spawnSync('sh', ['-lc', 'command -v fc-list >/dev/null 2>&1'], { stdio: 'ignore' });
+    if (probe.status !== 0)
+        return null;
+    const res = spawnSync('fc-list', [':', 'family'], { encoding: 'utf8', timeout: 5000 });
+    if (res.status !== 0 || typeof res.stdout !== 'string')
+        return null;
+    for (const line of res.stdout.split('\n')) {
+        if (NERD_FONT_PATTERN.test(line))
+            return line.split(',')[0].trim();
+    }
+    return ''; // fontconfig answered and knows of no Nerd Font — authoritative miss
+}
+export function detectNerdFont(platform = process.platform, home = homedir()) {
+    if (platform !== 'darwin') {
+        const family = queryFontconfig();
+        if (family !== null && family !== '')
+            return { installed: true, evidence: family, source: 'fc-list' };
+    }
+    for (const dir of fontDirs(platform, home)) {
+        const file = scanForNerdFont(dir, 3);
+        if (file !== null)
+            return { installed: true, evidence: file, source: 'font-dir' };
+    }
+    return { installed: false, evidence: null, source: null };
+}
+/** Download the upstream symbols-only patch into the user's font dir. Works on
+ *  every Linux regardless of package manager — Debian/Ubuntu and Fedora ship no
+ *  Nerd Font package, so there is nothing native to install there. Needs no
+ *  sudo: it writes to `~/.local/share/fonts`. */
+export const NERD_FONT_MANUAL_LINUX_COMMAND = 'mkdir -p ~/.local/share/fonts && '
+    + 'curl -fsSL -o /tmp/NerdFontsSymbolsOnly.zip '
+    + 'https://github.com/ryanoasis/nerd-fonts/releases/latest/download/NerdFontsSymbolsOnly.zip && '
+    + 'unzip -oq /tmp/NerdFontsSymbolsOnly.zip -d ~/.local/share/fonts && fc-cache -f';
+/** The install command for this platform/package manager. `packageManager`
+ *  matches setup's detection: only brew and pacman have a real Nerd Font
+ *  package, everything else on Linux gets the upstream download. A non-brew
+ *  package manager only ever exists on Linux, so it settles the platform on its
+ *  own and `platform` decides only the `manual` case. */
+export function nerdFontInstallCommand(packageManager, platform = process.platform) {
+    const onLinux = platform !== 'darwin' || packageManager === 'apt-get' || packageManager === 'dnf' || packageManager === 'pacman';
+    if (packageManager === 'brew') {
+        return {
+            command: 'brew install --cask font-symbols-only-nerd-font',
+            hint: 'Homebrew cask',
+            autoInstall: true,
+        };
+    }
+    if (packageManager === 'pacman') {
+        return {
+            command: 'sudo pacman -S --noconfirm ttf-nerd-fonts-symbols',
+            hint: 'pacman install',
+            autoInstall: true,
+        };
+    }
+    if (onLinux) {
+        return {
+            command: NERD_FONT_MANUAL_LINUX_COMMAND,
+            hint: 'download symbols-only patch to ~/.local/share/fonts (needs curl + unzip)',
+            autoInstall: true,
+        };
+    }
+    return {
+        command: null,
+        hint: 'install Homebrew, or download a Nerd Font from https://nerdfonts.com and add it in Font Book',
+        autoInstall: false,
+    };
+}
+/** Every install path ends the same way: the font is on disk but the terminal
+ *  emulator still has to be pointed at it, and crtr cannot do that. */
+export const NERD_FONT_SELECT_HINT = 'then set your terminal profile\'s font to a Nerd Font (e.g. add "Symbols Nerd Font Mono" as the non-ASCII/fallback font) — installing it does not select it';

package/dist/core/runtime/tmux.js

@@ -483,6 +483,8 @@ const MENU_ACTIONS = {
     // M-S-r carries shift+alt and lands as the same chord the keyboard produces.
     'crtr.tmux.menu.file-review': { description: 'review a file', action: { kind: 'raw-keys', keys: 'M-S-r' } },
     'crtr.tmux.menu.metadata': { description: 'metadata', action: { kind: 'keys', keys: '/node-metadata' } },
+    'crtr.tmux.menu.fold-tools': { description: 'fold finished tool calls', action: { kind: 'keys', keys: '/fold-tools' } },
+    'crtr.tmux.menu.view-settings': undefined,
     'crtr.tmux.menu.context': { description: 'context + reports', action: { kind: 'keys', keys: '/context' } },
     'crtr.tmux.menu.providers': { description: 'settings', action: { kind: 'popup', run: 'sys setup' } },
     'crtr.tmux.menu.graph': { description: 'graph view', action: { kind: 'keys', keys: '/graph' } },
@@ -627,6 +629,11 @@ function menuItems(bindings) {
         'crtr.tmux.menu.metadata',
         'crtr.tmux.menu.context',
     ]);
+    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
+    // is a toggle the viewer applies to its own render state (a `/`-command sent to
+    // the pane); a tmux menu is built once and cannot show live state, so the item
+    // reads as the action and the viewer answers with a notice.
+    const viewSettingsItems = boundItems(['crtr.tmux.menu.fold-tools']);
     const exploreItems = boundItems([
         'crtr.tmux.menu.resume',
         'crtr.tmux.menu.graph',
@@ -641,6 +648,15 @@ function menuItems(bindings) {
             });
         }
     }
+    if (viewSettingsItems.length > 0) {
+        for (const gesture of bindings.gestures('crtr.tmux.menu.view-settings')) {
+            exploreItems.push({
+                description: 'view settings ›',
+                selector: menuSelector(gesture),
+                action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
+            });
+        }
+    }
     // Explore changes what is in view or opens a canvas-level browser. Current
     // node acts on the agent in this pane without changing its lifecycle.
     addGroup('Explore', exploreItems);

package/dist/core/tui/host.js

@@ -501,9 +501,12 @@ export async function runCoreView(core, tui, text, opts = {}) {
         setMode(mode) { chrome.mode = mode; },
         quit() { finish(); },
     };
-    // The single-flight busy lane lives in the external FIFO. Key input still
-    // drops while busy; refresh timers still skip while busy; ctx.dispatch from
-    // inside an intent runs inline so chained intents do not deadlock.
+    // The single-flight busy lane lives in the external FIFO. Refresh timers skip
+    // while busy; ctx.dispatch from inside an intent runs inline so chained intents
+    // do not deadlock. Keystrokes QUEUE behind an in-flight intent (up to a small
+    // depth) rather than vanishing: a view whose auto-refresh shells out is busy a
+    // real fraction of the time, and silently swallowing a `y` confirmation or a
+    // cursor move is the difference between a live surface and a deaf one.
     const streams = new Set();
     let busy = false;
     let dispatching = false;
@@ -627,6 +630,9 @@ export async function runCoreView(core, tui, text, opts = {}) {
     render();
     if (core.intents['refresh'])
         await enqueueDispatch('refresh');
+    // Keystroke-dispatch backlog depth (see onData).
+    const MAX_QUEUED_KEYS = 2;
+    let queuedKeys = 0;
     // Capture-mode buffer: the host's line-editor draft while a `capture` binding's
     // when(state) is true; reset to '' whenever no capture binding is active.
     let captureBuf = '';
@@ -650,8 +656,10 @@ export async function runCoreView(core, tui, text, opts = {}) {
             finish();
             return;
         }
-        // Drop keystrokes while an async intent is in flight (paces fetch/send).
-        if (busy)
+        // Queue behind an in-flight intent, but shallowly: past a couple of pending
+        // keys the user is hammering a stuck view, and replaying the backlog later
+        // would act on a screen they never saw.
+        if (busy && queuedKeys >= MAX_QUEUED_KEYS)
             return;
         // Text-capture: while a capture binding is active, printable/backspace edit
         // the host buffer and dispatch capture(nextDraft); other keys (return/escape)
@@ -673,8 +681,15 @@ export async function runCoreView(core, tui, text, opts = {}) {
             captureBuf = '';
         }
         const m = matchViewBinding(tui.keymap, bindings, input, key, state, raw);
-        if (m)
+        if (!m)
+            return;
+        queuedKeys += 1;
+        try {
             await enqueueDispatch(m.intent, m.payload);
+        }
+        finally {
+            queuedKeys -= 1;
+        }
     };
     process.stdin.on('data', (d) => { void onData(d); });
     // Resize → repaint from current state (never re-enter an in-flight intent).

package/dist/daemon/api/map.js

@@ -105,6 +105,8 @@ export function toNodeDetailDTO(meta, edges) {
     };
     if (meta.description !== undefined)
         dto.description = meta.description;
+    if (meta.icon !== undefined)
+        dto.icon = meta.icon;
     if (meta.cycles !== undefined)
         dto.cycles = meta.cycles;
     dto.context_tokens = readContextTokens(meta.node_id);

package/dist/pi-extensions/canvas-bash-valve.js

@@ -244,6 +244,11 @@ export function createValveOperations(nodeId, contextDir) {
                     finish(() => reject(err));
                 });
                 pgid = child.pid;
+                // The detached supervisor IS the group leader, so its pid is the pgid.
+                // Persisting it is what lets a human stop the job from the Inspector
+                // later; the agent's own handoff notice quotes the same number.
+                if (pgid !== undefined)
+                    writeFileSync(paths.jobPgid, String(pgid));
                 child.unref();
                 interval = setInterval(() => {
                     offset = tailOnce(paths.jobLog, offset, onData);

package/dist/pi-extensions/naming-tool.d.ts

@@ -0,0 +1,24 @@
+interface PiLike {
+    registerTool: (definition: Record<string, unknown>) => void;
+}
+/** The naming schema — the ONE definition of what a generated session name is.
+ *  Both fields are required: a name without an icon renders a bare label, and
+ *  an icon without a name is useless, so the model is made to decide both in a
+ *  single constrained emission. */
+export declare const NAME_SESSION_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.";
+        };
+        readonly icon: {
+            readonly type: "string";
+            readonly description: "The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).";
+        };
+    };
+    readonly required: readonly ["name", "icon"];
+    readonly additionalProperties: false;
+};
+export declare function registerNamingTool(pi: PiLike): void;
+export default registerNamingTool;

package/dist/pi-extensions/naming-tool.js

@@ -0,0 +1,67 @@
+// naming-tool.ts — the structured-output seam for session naming.
+//
+// Loaded ONLY by the headless namer subprocess (`runtime/naming.ts` passes it
+// with `-e` alongside `--no-extensions`), never by a canvas node. It registers a
+// single `name_session` tool whose parameters ARE the naming schema, with
+// pi's constrained sampling turned on, so the light model emits a real typed
+// object instead of prose we have to parse out of a text reply.
+//
+// The result travels back to the parent over a file: the parent creates a temp
+// path, passes it as CRTR_NAME_RESULT_FILE, and reads it after the subprocess
+// exits. stdout is unusable for this — pi print-mode writes its own chatter
+// there.
+//
+// Inert (registers nothing) when CRTR_NAME_RESULT_FILE is absent, so an
+// accidental load in any other context is a no-op.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** The naming schema — the ONE definition of what a generated session name is.
+ *  Both fields are required: a name without an icon renders a bare label, and
+ *  an icon without a name is useless, so the model is made to decide both in a
+ *  single constrained emission. */
+export const NAME_SESSION_SCHEMA = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.',
+        },
+        icon: {
+            type: 'string',
+            description: 'The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).',
+        },
+    },
+    required: ['name', 'icon'],
+    additionalProperties: false,
+};
+export function registerNamingTool(pi) {
+    const out = process.env['CRTR_NAME_RESULT_FILE'];
+    if (out === undefined || out.trim() === '')
+        return;
+    pi.registerTool({
+        name: 'name_session',
+        label: 'Name session',
+        description: 'Record the name and icon for this coding session. Call exactly once, then stop.',
+        parameters: NAME_SESSION_SCHEMA,
+        // Ask the provider to constrain sampling to the schema. `prefer` degrades
+        // silently on a model without strict tool support (`require` would fail the
+        // whole request); the parent validates and falls back to a local slug
+        // either way, so this only makes a malformed emission rarer.
+        constrainedSampling: { type: 'json_schema', strict: 'prefer' },
+        execute(_id, params) {
+            try {
+                mkdirSync(dirname(out), { recursive: true });
+                writeFileSync(out, JSON.stringify(params ?? {}), 'utf8');
+            }
+            catch {
+                // The parent falls back to a local slug when the file never lands.
+            }
+            return {
+                content: [{ type: 'text', text: 'Recorded.' }],
+                details: { recorded: true },
+                terminate: true,
+            };
+        },
+    });
+}
+export default registerNamingTool;

package/dist/types.d.ts

@@ -152,6 +152,11 @@ export interface ScopeConfig {
      *  `both` keeps both. Tool calls and results are never kept. Full detail for
      *  every cycle stays in the session file. */
     condensed_history: CondensedHistoryMode;
+    /** Fold every SETTLED tool call in the attach viewer down to its single call
+     *  line (`/fold-tools`, Alt+C → w → f). A tool still running is never folded —
+     *  it folds itself once it settles. Toggling it in a viewer writes back here,
+     *  so the choice carries into later chats and later viewers. Default false. */
+    fold_finished_tools: boolean;
     keybindings: KeybindingOverrides;
     modelLadders: ModelLaddersConfig;
     /** The kind registry (spec §1.5): kind existence + launch knobs, keyed by

package/dist/types.js

@@ -38,6 +38,7 @@ export function defaultScopeConfig() {
         completion_bell: true,
         live_cycles: DEFAULT_LIVE_CYCLES,
         condensed_history: DEFAULT_CONDENSED_HISTORY,
+        fold_finished_tools: false,
         keybindings: {},
         modelLadders: defaultModelLaddersConfig(),
         kinds: defaultKindsConfig(),