@north-light/crouter 0.3.159 → 0.3.160

package/dist/api/dto/nodes.d.ts

@@ -86,6 +86,9 @@ export interface NodeWorktreeDTO {
  *  `GET /v1/nodes/{id}` and by the create/lifecycle actions that yield a node. */
 export interface NodeDetailDTO extends NodeSummaryDTO {
     description?: string;
+    /** The Nerd Font glyph the namer chose for this node's work, when it has one
+     *  (`NodeMeta.icon`). Rendered ahead of the label by surfaces that want it. */
+    icon?: string;
     cycles?: number;
     /** Approximate context-window token load of the node's live/last session,
      *  used by the orchestrator yield-nudge (`childFollowUp`). Null when unknown

package/dist/builtin-memory/internal/INDEX.md

@@ -15,6 +15,7 @@ Open this dir whenever a task turns on understanding the runtime itself or chang
 - **nodes-and-canvas** — the agent-runtime model: nodes on the canvas graph, spawn/delegate, the push/feed spine, lifecycle (mode + lifecycle axes), and revive (manual + daemon auto-revive).
 - **storage-tiers** — where every kind of state lives: the two tiers (scope root and canvas home) and their durability/ownership contracts.
 - **agent-shaping** — the when-to-use-which layer over the four dials that shape a node: kinds (the builtin roster, sub-kinds, and custom personas), modes (base vs orchestrator), profiles, and the memory tiers (node/profile/project/user/builtin).
+- **workflow-codification** — the codification loop for repeatable tasks: do the work hands-on under a capture session, mine the HAR, then codify it as scripts (scope-root `scripts/`) + a slash-invokable memory doc, with the self-heal rule that a failed script is re-derived and rewritten.
 - **plugins** — authoring a crtr plugin: the plugin.json manifest, directory layout, scopes, install mechanics, versioning, command plugins (contributing top-level CLI commands via commands.json + one executable), and configured CLIs (contributing commands as definition + HTTP from a remote manifest, no executable).
 - **marketplaces** — authoring a crtr marketplace: the marketplace.json index, plugin entries, symlink-based install, auto-bump CI, dual-publishing.
 - **examples/** — worked compositions of the primitives into complete systems (the analogue of pi's `examples/` dir), e.g. the iMessage assistant node.

package/dist/builtin-memory/internal/workflow-codification.md

@@ -0,0 +1,82 @@
+---
+kind: knowledge
+when-and-why-to-read: When the user names a task as repeatable — "make this repeatable", "save this workflow", "we do this every month" — or when you are about to redo a multi-step task an agent has done before, this playbook should be read because codifying the task into scripts plus a slash-invokable doc makes every future run faster and more reliable than re-deriving it, and an uncodified repeat wastes the entire prior derivation.
+short-form: "The codification loop: do a repeatable task hands-on under a capture session, mine the HAR for direct API calls, then codify it as a slash-invokable memory doc (judgment + facts) plus scripts (the fast path). Scripts live in scope-root scripts/; a failed script means re-derive hands-on and rewrite."
+system-prompt-visibility: preview
+file-read-visibility: none
+---
+
+# Codifying repeatable work — workflows as a slash doc + scripts
+
+A **codified workflow** is a convention assembled from two existing surfaces, each carrying what it is best at:
+
+- **A workflow memory doc** with `slash: true` in its frontmatter, invocable as `/<name>`. It is the entry point and the single home for everything prose: the *judgment* (ordered steps, verification criteria, stop conditions — "if amounts mismatch, do NOT upload — flag it"), the *environment facts* that outlive any one run (which account bills when, which browser profile is logged in where, which API returns an app shell instead of a PDF), and pointers to the scripts.
+- **Scripts** (`scripts/`, below) are the fast path. Each one deterministically performs a mechanical step the agent would otherwise re-derive: a direct API call mined from traffic, a DOM injection, a PDF fetch.
+
+Judgment and facts stay in prose where the agent applies them fresh each run; mechanics compile into scripts that run in milliseconds. A workflow codified as *only* prose is permanently slow; codified as *only* scripts it breaks silently the first time the world drifts. Together they self-heal: **when a script fails, fall back to doing that step hands-on with `crtr capture`, then rewrite the script (and any stale facts in the doc) before finishing.** The workflow gets faster over time and never permanently breaks.
+
+Codify only what the user has named repeatable, or what you are repeating yourself. A one-off task gets no scripts.
+
+## The loop
+
+1. **Run the task hands-on under a capture session.** `crtr capture session start --url <entry>` — the session auto-records HAR, so your clicks and navigations leave a complete traffic trace as a side effect of just doing the work. Sessions attach to the user's real logged-in browser (auto-detection prefers it; `--port` pins an endpoint; `--hold` with a later `--target` adopts an already-open tab).
+2. **Finish the task.** Correctness first — codification captures a *successful* run.
+3. **Mine the trace.** `crtr capture session har <id> --filter-url <domain> --full` inlines request headers, post data, and response bodies. You are looking for the direct path the UI was hiding: the JSON endpoint behind the dashboard, the presigned-URL hop behind the download button, the exact payload a form submit produced. What took ten clicks is usually one or two requests.
+4. **Codify.** Write the workflow doc (`slash: true`) and the scripts (shapes below). The doc references scripts by absolute path; scripts open with a header naming their owning doc.
+5. **Replay and repair.** Next time, `/<name>` runs the scripts in order. On any script failure: re-derive that step hands-on under a fresh session, rewrite the script in place, and update the doc if the *shape* of the task changed. Rewrite as if fresh — never append a changelog.
+
+## The scripts tier
+
+Scripts live in the scope root, beside `memory/`:
+
+- `~/.crouter/scripts/` — user-scope: personal workflows (receipts, bookings, account chores).
+- `<project>/.crouter/scripts/` — project-scope: workflows owned by a repo.
+
+Layout: one directory per workflow (`scripts/mercury-receipts/`), plus `scripts/lib/` for shared helpers. Every script opens with a header comment:
+
+```js
+// @workflow mercury-receipts — fetch one Anthropic invoice PDF via the invoicedata.stripe.com hop
+// @owner memory/mercury-receipts.md
+```
+
+The header is the discovery contract: it makes scripts greppable and lets tooling list them later without any new runtime machinery. A script with no owning workflow doc is an orphan — every script must be reachable from the doc that explains when to run it.
+
+**Default runtime is Node ESM (`.mjs`), executable, no dependencies.** JS keeps scripts importable by each other and by the rest of the ecosystem, and Node's builtins cover the usual needs (`util.parseArgs` for flags, `fetch` for HTTP, `child_process` for CLIs). Reach for another runtime only when JS genuinely cannot do the job (e.g. a Python CDP-websocket edge case) — note why in the header.
+
+## Calling crtr and capture from a script
+
+The CLI is the SDK. Every capture command mirrors its result as JSON under `--json`; spawn it and parse:
+
+```js
+import { execFileSync } from 'node:child_process';
+const run = (...args) => JSON.parse(execFileSync('crtr', [...args, '--json'], { encoding: 'utf8' }));
+const tabs = run('capture', 'tab', 'list');
+```
+
+Do not import crouter's internals into a script. crtrd owns canvas state and the CLI is the sanctioned client seam; the exec boundary also keeps scripts version-proof across runtime generations, since they always talk to the installed CLI.
+
+Grow `scripts/lib/kit.mjs` as helpers recur — `run()` above, a `pageExec(js, {port, target})` wrapper, a pinned-target guard. The kit is agent-owned and evolves with use; there is no shipped package to wait on.
+
+## Script shape: linear script vs mini-CLI
+
+A workflow step with one job is one linear script. But when a workflow has several verbs sharing state and safety rules, build the script *as a small CLI* — subcommands over `util.parseArgs`, noun-verb naming, invariants enforced inside:
+
+```
+recgov pin [target]   # persist the exact browser target; refuse ambiguity
+recgov inspect        # read login/cart/availability state, never mutate
+recgov add <date>     # refuses non-empty cart, wrong site class, unverified login
+recgov fill           # fills forms, stops before any payment action
+```
+
+This shape earns its keep exactly when the task has **irreversible edges** (payments, submissions, deletions): the CLI encodes the guard once — verify login before every mutation, refuse a stale port, never touch the purchase button — instead of trusting each future run to remember. The agent building its own harness for a workflow family is the intended endgame of codification, not scope creep.
+
+## Mining guidance
+
+- **Auth rides the browser.** If a mined endpoint needs cookies or CSRF tokens, call it *in-page* via `crtr capture page exec` (XHR/fetch runs with the session's credentials). Curl directly only when the request proved public — presigned URLs, tokenized links.
+- **Capture the payload shape, not just the URL.** The HAR's post data is the schema documentation the vendor never published.
+- **Pin targets for anything stateful.** Multiple Chromium apps expose CDP (Electron shells, Spotify, secondary browser profiles). Before mutating anything, verify you are in the right browser *and* the right identity — read a logged-in marker off the page, not just the tab title. `CDP_PORT`/`CDP_TARGET` pin the pair for every subsequent command.
+- **Verify effects like the UI would.** After an upload or submission, re-read the page state that a human would check (the badge count dropped, the row disappeared). A 200 response is not confirmation.
+
+## What good codification looks like
+
+The test: a fresh agent, given only `/<name>`, completes the task in a fraction of the original time, refuses the same dangerous states the first derivation learned to refuse, and — when the vendor shipped a redesign overnight — degrades to hands-on capture work instead of failing, then leaves the codification better than it found it.

package/dist/clients/attach/__tests__/bash-call-width.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/bash-call-width.test.js

@@ -0,0 +1,38 @@
+// REGRESSION: ctrl+o (expanded tool output) on a bash call whose command is
+// wider than a narrow pane emitted the command line unclipped, so pi-tui's line
+// accounting desynced from the terminal's own wrapping and the viewer crashed
+// with "Rendered line N exceeds terminal width". Expanded bash now wraps into
+// the pane instead of overhanging it.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { visibleWidth } from '@earendil-works/pi-tui';
+import { createCrtrPlainBashToolDefinition } from '../render/tool-calls.js';
+const theme = {
+    fg(_name, text) { return text; },
+    bg(_name, text) { return text; },
+    bold(text) { return text; },
+};
+function renderExpanded(command, width, timeout) {
+    const def = createCrtrPlainBashToolDefinition('/tmp');
+    const component = def.renderCall({ command, timeout }, theme, { expanded: true, state: {} });
+    return component.render(width);
+}
+const COMMANDS = [
+    'ls -la /Users/silasrhyneer/Code/cli/crouter',
+    'grep -rn "averyveryverylongtokenwithnospacesatallxxxxxxxxxxxxxxxxxxxxxx" src/',
+    `first\nsecond ${'x'.repeat(120)}`,
+];
+test('expanded bash call never renders a line wider than the pane', () => {
+    for (const width of [80, 42, 20, 3, 2, 1]) {
+        for (const command of COMMANDS) {
+            for (const line of renderExpanded(command, width, 120)) {
+                assert.ok(visibleWidth(line) <= width, `width ${width}: line of ${visibleWidth(line)} cols for ${JSON.stringify(command)}`);
+            }
+        }
+    }
+});
+test('expanded bash wraps rather than clipping — the whole command survives', () => {
+    const command = 'ls -la /Users/silasrhyneer/Code/cli/crouter';
+    const joined = renderExpanded(command, 42).map((line) => line.trim()).join(' ');
+    assert.ok(joined.includes('/Users/silasrhyneer/Code/cli/crouter'), joined);
+});

package/dist/clients/attach/__tests__/chat-view-snapshot-ordering.test.js

@@ -62,6 +62,26 @@ function assistantSnapshot(count, tag) {
 }
 const countOf = (children, ctor) => children.filter((c) => c instanceof ctor).length;
 initTheme(undefined, false);
+test('folded tools are separated from preceding assistant prose and thinking', async () => {
+    const tui = new TUI(fakeTerminal());
+    const container = new Container();
+    const view = new ChatView(tui, container, { hideThinking: false });
+    const internals = view;
+    internals.foldSettledTools = true;
+    await view.applySnapshot({
+        messages: [
+            { role: 'assistant', content: [{ type: 'text', text: 'Prose.' }, { type: 'toolCall', id: 'text-tool', name: 'bash', arguments: { command: 'true' } }] },
+            { role: 'toolResult', toolCallId: 'text-tool', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
+            { role: 'assistant', content: [{ type: 'thinking', thinking: 'Think.' }, { type: 'toolCall', id: 'thinking-tool', name: 'bash', arguments: { command: 'true' } }] },
+            { role: 'toolResult', toolCallId: 'thinking-tool', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
+        ],
+        stats: {},
+        state: { isStreaming: false },
+    });
+    internals.applyToolDisplay();
+    const separators = internals.historyContainer.children.filter((child) => child.render(80).length === 1 && child.render(80)[0] === '');
+    assert.equal(separators.length, 2, 'both visible assistant blocks receive a folded-tool gap');
+});
 test('live bash animation survives history caching and stops on a welcome snapshot', async () => {
     let renderRequests = 0;
     const tui = {

package/dist/clients/attach/__tests__/crtr-output-coverage.test.js

@@ -51,5 +51,7 @@ test('the attach viewer covers crtr bash tool calls and crtr-output messages nat
     assert.match(chatView, /CRTR_OUTPUT_CUSTOM_TYPE/);
     assert.match(chatView, /new CrtrOutputMessageComponent\(/);
     assert.match(chatView, /createCrtrBashToolDefinition\(args\)/);
-    assert.match(chatView, /new ToolExecutionComponent\([\s\S]*toolDefinition as never/);
+    // MinimizableToolComponent is the viewer's ToolExecutionComponent subclass (it
+    // adds the Ctrl+O minimized state); the crtr tool definition still threads through it.
+    assert.match(chatView, /new MinimizableToolComponent\([\s\S]*toolDefinition as never/);
 });

package/dist/clients/attach/chrome/bash-jobs.d.ts

@@ -1,4 +1,6 @@
 import { type BashJobStatus } from '../../../core/bash-jobs.js';
-/** Compact cockpit row: the running command (or job count) plus elapsed time.
- *  `undefined` for an empty list — the caller omits the row entirely. */
-export declare function bashJobsWaitSummary(jobs: readonly BashJobStatus[], nowMs?: number): string | undefined;
+/** Compact cockpit row: state first (matching the cron row), then the running
+ *  command. `cmdCap` is the columns the caller has left for that command, so the
+ *  cell shrinks with the pane instead of being clipped after the row's own key
+ *  hints. `undefined` for an empty list — the caller omits the row entirely. */
+export declare function bashJobsWaitSummary(jobs: readonly BashJobStatus[], nowMs?: number, cmdCap?: number): string | undefined;

package/dist/clients/attach/chrome/bash-jobs.js

@@ -4,20 +4,27 @@
 // activeBackgroundBashJobs' job, in core/bash-jobs.ts). Enter on that row opens
 // the Inspector's `jobs` section, which owns the drill-in rendering.
 import { formatBashElapsed } from '../../../core/bash-jobs.js';
-const CMD_CELL_CAP = 26;
-/** First line of `command`, whitespace-collapsed and capped to ~26 chars. */
-function cmdCell(command) {
+/** First line of `command`, whitespace-collapsed and capped to `cap` columns. A
+ *  shell one-liner is cut on a word boundary when there is one near the cap, so
+ *  the cell ends on a readable token instead of mid-`$((`. */
+function cmdCell(command, cap) {
     const oneLine = command.split('\n')[0].replace(/\s+/g, ' ').trim();
-    return oneLine.length > CMD_CELL_CAP ? `${oneLine.slice(0, CMD_CELL_CAP - 1)}…` : oneLine;
+    if (oneLine.length <= cap)
+        return oneLine;
+    const cut = oneLine.slice(0, Math.max(1, cap - 1));
+    const space = cut.lastIndexOf(' ');
+    return `${(space >= cap - 12 ? cut.slice(0, space) : cut).trimEnd()}…`;
 }
-/** Compact cockpit row: the running command (or job count) plus elapsed time.
- *  `undefined` for an empty list — the caller omits the row entirely. */
-export function bashJobsWaitSummary(jobs, nowMs = Date.now()) {
+/** Compact cockpit row: state first (matching the cron row), then the running
+ *  command. `cmdCap` is the columns the caller has left for that command, so the
+ *  cell shrinks with the pane instead of being clipped after the row's own key
+ *  hints. `undefined` for an empty list — the caller omits the row entirely. */
+export function bashJobsWaitSummary(jobs, nowMs = Date.now(), cmdCap = 26) {
     if (jobs.length === 0)
         return undefined;
     if (jobs.length === 1) {
         const job = jobs[0];
-        return `${cmdCell(job.command)} · ${formatBashElapsed(nowMs - job.startedAtMs)}`;
+        return `bash job · ${formatBashElapsed(nowMs - job.startedAtMs)} · ${cmdCell(job.command, Math.max(12, cmdCap))}`;
     }
     const oldest = jobs[0]; // activeBackgroundBashJobs returns oldest-first
     return `${jobs.length} bash jobs · oldest ${formatBashElapsed(nowMs - oldest.startedAtMs)}`;

package/dist/clients/attach/chrome/canvas-panels.js

@@ -12,7 +12,10 @@
 // caller owns the Containers and the refresh trigger. beginFrameTelem() clears the
 // nav-model telemetry cache for this one build pass so token/activity cells are
 // read fresh for every chrome frame.
-import { beginFrameTelem, navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, askBadge, activityCell, YELLOW, RESET, DIM, GREEN, } from '../../../core/canvas/nav-render.js';
+import { beginFrameTelem, navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, askBadge, activityCell, fillWidth, YELLOW, RESET, DIM, GREEN, } from '../../../core/canvas/nav-render.js';
+/** Columns the bash row spends on everything except the command itself:
+ *  ` ⚙ ` + `bash job · ` + elapsed + ` · ` + ` · ↵ details`. */
+const BASH_ROW_CHROME = 34;
 import { RemoteCanvasSource } from '../../../core/canvas/remote-canvas-source.js';
 import { cronWaitSummary } from './cron-wait.js';
 import { bashJobsWaitSummary } from './bash-jobs.js';
@@ -158,10 +161,14 @@ export async function buildCanvasPanelLines(nodeId, asks, palette, source, crons
         items.push({ key: 'human', kind: 'human', line: ` ${YELLOW}⚑ waiting on human · ${selfAsks} pending${RESET}` });
     // Bash wait row: attention (human) -> active-now (running background work) ->
     // scheduled-future (armed crons). The leading glyph distinguishes the row type.
-    const bashSummary = bashJobsWaitSummary(jobs);
+    // `x stop` is advertised on the row because it is the roster's only
+    // destructive verb and nothing else would teach it. The command cell gets
+    // whatever the row's fixed decoration leaves, so the hints always survive.
+    const stopHint = jobs.length === 1 ? ' · x stop' : '';
+    const bashSummary = bashJobsWaitSummary(jobs, Date.now(), fillWidth() - (BASH_ROW_CHROME + stopHint.length));
     if (bashSummary !== undefined) {
         const gear = palette ? palette.info('⚙') : '⚙';
-        items.push({ key: 'bash', kind: 'bash', line: ` ${gear} ${muted(`${bashSummary} · ↵ details`)}${RESET}` });
+        items.push({ key: 'bash', kind: 'bash', line: ` ${gear} ${muted(`${bashSummary} · ↵ details${stopHint}`)}${RESET}` });
     }
     const cronSummary = cronWaitSummary(crons);
     if (cronSummary !== undefined) {

package/dist/clients/attach/chrome/roster.d.ts

@@ -5,8 +5,13 @@ export interface RosterHooks {
     /** Live per-node human-ticket counts — read fresh on every rebuild, since the
      *  viewer's attention poll reassigns the map behind us. */
     asks: () => Record<string, number>;
-    /** Transient footer notice (errors, "already fired", swap failures). */
-    setNotice: (msg: string) => void;
+    /** Transient footer notice (errors, "already fired", swap failures). A
+     *  `sticky` notice holds until it is replaced or cleared — what the `x` stop
+     *  confirmation needs, since the ordinary notice fades in three seconds and a
+     *  question that vanished must not still be armed. */
+    setNotice: (msg: string, opts?: {
+        sticky?: boolean;
+    }) => void;
     /** Ask the viewer to re-run the full chrome refresh. Detail popups call this
      *  on close so a wait row that resolved while the popup was open disappears. */
     requestChromeRefresh: () => void;

package/dist/clients/attach/chrome/roster.js

@@ -25,11 +25,11 @@
 // graph, so `refresh()` rebuilds the cached rows asynchronously while arrow
 // movement only reverses the selected cached row and renders immediately.
 import { execFile, execFileSync } from 'node:child_process';
-import { Text, matchesKey } from '@earendil-works/pi-tui';
+import { Text, decodeKittyPrintable, matchesKey } from '@earendil-works/pi-tui';
 import { cliClient } from '../../../commands/api-client.js';
 import { activeBackgroundBashJobs } from '../../../core/bash-jobs.js';
 import { contextDir } from '../../../core/canvas/paths.js';
-import { fillBar, fillWidth, REVERSE } from '../../../core/canvas/nav-render.js';
+import { fillBar, fillWidth, stripSgr, REVERSE } from '../../../core/canvas/nav-render.js';
 import { buildCanvasPanelLines } from './canvas-panels.js';
 /** Seed pane focus from the pane's REAL active state, not an unconditional
  *  `true`. tmux only emits DECSET 1004 focus events on a TRANSITION, so a viewer
@@ -50,6 +50,8 @@ function initialPaneActive() {
         return true;
     }
 }
+/** How long an armed `x` waits for its `y`. */
+const ARM_TIMEOUT_MS = 15_000;
 export function createRoster(s, hooks) {
     const { editor, tui, pal, nodeId, remote, role, canvasSource } = s;
     const reports = s.containers.reports;
@@ -61,6 +63,12 @@ export function createRoster(s, hooks) {
     if (autoSelect !== undefined)
         delete process.env['CRTR_ATTACH_ROSTER'];
     let paneFocused = initialPaneActive();
+    // Armed job cancellation: `x` on the bash row names the job, `y` confirms.
+    // Held here (not in the item list) so any other key, a selection move, or a
+    // rebuild that retires the job drops it — a stale confirmation must never
+    // kill a job the user is no longer looking at.
+    let pendingKill;
+    let killTimer;
     const syncCursorDim = () => {
         editor.paneFocused = paneFocused && selKey === undefined;
     };
@@ -69,7 +77,10 @@ export function createRoster(s, hooks) {
         reports.clear();
         for (const item of items) {
             const selected = item.key === selKey;
-            reports.addChild(new Text(selected ? fillBar(item.line, fillWidth(), REVERSE) : item.line, 1, 0));
+            // Selected rows highlight as ONE uniform bar: strip the row's own colours
+            // first, because reverse-video turns every tinted span into a coloured
+            // block and the bar reads as a patchwork otherwise.
+            reports.addChild(new Text(selected ? fillBar(stripSgr(item.line), fillWidth(), REVERSE) : item.line, 1, 0));
         }
         tui.requestRender();
     };
@@ -96,14 +107,73 @@ export function createRoster(s, hooks) {
         if (selKey !== undefined && !items.some((item) => item.key === selKey)) {
             selKey = undefined;
         }
+        if (pendingKill !== undefined && !bashJobs.some((job) => job.jobId === pendingKill?.jobId))
+            disarmKill(true);
         paint();
     };
+    /** Drop an armed stop, and the question with it. */
+    const disarmKill = (clearNotice) => {
+        if (killTimer !== undefined) {
+            clearTimeout(killTimer);
+            killTimer = undefined;
+        }
+        if (pendingKill === undefined)
+            return;
+        pendingKill = undefined;
+        if (clearNotice)
+            hooks.setNotice('');
+    };
     const exit = () => {
+        disarmKill(true);
         if (selKey !== undefined) {
             selKey = undefined;
             paint();
         }
     };
+    /** The printable character a keystroke carries, under both plain and Kitty
+     *  encodings — the roster's own `x`/`y` verbs are letters, not chords. */
+    const typed = (data) => decodeKittyPrintable(data) ?? (data.length === 1 ? data : undefined);
+    /** First line of a command, for the confirmation prompt. */
+    const commandHead = (command, cap = 40) => {
+        const line = (command.split('\n')[0] ?? '').replace(/\s+/g, ' ').trim();
+        return line.length > cap ? `${line.slice(0, cap - 1)}…` : line;
+    };
+    /** `x` on the bash row: arm cancellation for the one live job. With several
+     *  jobs there is no single target on a summary row, so send the user into the
+     *  Inspector, where each job is separately selectable. */
+    const armKill = () => {
+        if (role !== 'controller') {
+            hooks.setNotice('Read-only observer attach — cannot stop background jobs');
+            return;
+        }
+        const jobs = activeBackgroundBashJobs(contextDir(nodeId));
+        if (jobs.length === 0) {
+            hooks.setNotice('Background job already finished');
+            hooks.requestChromeRefresh();
+            return;
+        }
+        if (jobs.length > 1) {
+            hooks.setNotice(`${jobs.length} background jobs — press ↵ to pick one in the Inspector`);
+            return;
+        }
+        const job = jobs[0];
+        pendingKill = { jobId: job.jobId, label: commandHead(job.command) };
+        hooks.setNotice(`Stop “${pendingKill.label}”? Press y to confirm.`, { sticky: true });
+        // An unanswered question expires rather than sitting armed forever — a `y`
+        // typed minutes later belongs to whatever the user is doing then.
+        killTimer = setTimeout(() => disarmKill(true), ARM_TIMEOUT_MS);
+    };
+    const confirmKill = () => {
+        const target = pendingKill;
+        if (target === undefined)
+            return;
+        disarmKill(false);
+        hooks.setNotice(`Stopping “${target.label}”…`);
+        execFile('crtr', ['node', 'bash', 'kill', target.jobId, '--node', nodeId], (err) => {
+            hooks.setNotice(err === null ? `Stopped “${target.label}”.` : `Could not stop the job: ${err.message.split('\n')[0]}`);
+            hooks.requestChromeRefresh();
+        });
+    };
     editor.onCursorDownAtBottom = remote ? undefined : () => {
         if (selKey !== undefined || items.length === 0)
             return;
@@ -172,6 +242,20 @@ export function createRoster(s, hooks) {
         // Roster active. Explicit boundaries on the single list: ↑ off the TOP row
         // returns to the editor; ↓ CLAMPS at the bottom row.
         const i = items.findIndex((item) => item.key === selKey);
+        const selected = items[i];
+        // Confirmation first: while a kill is armed, `y` fires it and every other
+        // key disarms it before taking its normal meaning.
+        if (pendingKill !== undefined) {
+            if (typed(data) === 'y') {
+                confirmKill();
+                return true;
+            }
+            disarmKill(true);
+        }
+        if (selected?.kind === 'bash' && typed(data) === 'x') {
+            armKill();
+            return true;
+        }
         if (up) {
             if (i <= 0)
                 exit();

package/dist/clients/attach/input/controller.d.ts

@@ -48,6 +48,9 @@ export interface InputControllerHooks {
     /** OPTIONAL: Ctrl+O / app.tools.expand — flip global tool-output expansion in
      *  the render layer (ChatView owns the components). Absent → the key no-ops. */
     onToggleToolsExpand?: () => void;
+    /** OPTIONAL: `/fold-tools` — flip the "fold finished tool calls" view setting.
+     *  Absent → the command notifies it is unwired. */
+    onFoldTools?: () => void;
     /** OPTIONAL: Ctrl+T / app.thinking.toggle — flip thinking-block visibility in
      *  the render layer. Absent → the key no-ops. */
     onToggleThinking?: () => void;

package/dist/clients/attach/input/controller.js

@@ -244,6 +244,7 @@ export class InputController {
             onCopy: this.hooks.onCopy,
             onColor: this.hooks.onColor,
             onNodeMetadata: this.hooks.onNodeMetadata,
+            onFoldTools: this.hooks.onFoldTools,
             openModelPicker: () => void this.openModelPicker(),
             openSessionPicker: () => void this.openSessionPicker(),
             openForkPicker: () => void this.openForkPicker(),

package/dist/clients/attach/render/assistant-message.d.ts

@@ -0,0 +1,13 @@
+import { AssistantMessageComponent } from '@earendil-works/pi-coding-agent';
+type AssistantMessageLike = Parameters<AssistantMessageComponent['updateContent']>[0];
+export declare class ViewerAssistantMessageComponent extends AssistantMessageComponent {
+    /** The message as it arrived, thinking parts intact. */
+    private original;
+    /** The stripped copy last handed to the base class, for identity comparison. */
+    private stripped;
+    private hidden;
+    constructor(message: AssistantMessageLike | undefined, hideThinkingBlock?: boolean, markdownTheme?: ConstructorParameters<typeof AssistantMessageComponent>[2], hiddenThinkingLabel?: string);
+    updateContent(message: AssistantMessageLike): void;
+    setHideThinkingBlock(hide: boolean): void;
+}
+export {};

package/dist/clients/attach/render/assistant-message.js

@@ -0,0 +1,55 @@
+// assistant-message.ts — the viewer's assistant message component.
+//
+// pi's AssistantMessageComponent renders a hidden thinking run as a one-line
+// `Thinking...` placeholder. In the viewer, thinking is hidden by DEFAULT
+// (viewer.ts), so that placeholder is the steady state: a transcript of real work
+// ends up striped with italic `Thinking...` lines nobody asked to see. Hidden here
+// means gone — the run renders nothing at all.
+//
+// The content is not lost: the original message is retained, so Ctrl+T
+// (`setHideThinkingBlock(false)`) re-renders the real thinking text in place.
+import { AssistantMessageComponent } from '@earendil-works/pi-coding-agent';
+/** Same message with its `thinking` parts removed, so the base component sees a
+ *  message that simply has no thinking run to label. */
+function withoutThinking(message) {
+    const content = message.content;
+    if (!Array.isArray(content) || !content.some((part) => part?.type === 'thinking'))
+        return message;
+    return { ...message, content: content.filter((part) => part?.type !== 'thinking') };
+}
+export class ViewerAssistantMessageComponent extends AssistantMessageComponent {
+    /** The message as it arrived, thinking parts intact. */
+    original;
+    /** The stripped copy last handed to the base class, for identity comparison. */
+    stripped;
+    hidden;
+    constructor(message, hideThinkingBlock = false, markdownTheme, hiddenThinkingLabel) {
+        // Defer content to our own updateContent so stripping applies to it too.
+        super(undefined, hideThinkingBlock, markdownTheme, hiddenThinkingLabel);
+        this.hidden = hideThinkingBlock;
+        if (message)
+            this.updateContent(message);
+    }
+    updateContent(message) {
+        // The base class re-renders by calling this with ITS last message (invalidate,
+        // setHideThinkingBlock) — that copy is the stripped one, so only a genuinely
+        // new message replaces the original we keep for un-hiding.
+        if (message !== this.stripped)
+            this.original = message;
+        const source = this.original ?? message;
+        if (this.hidden) {
+            this.stripped = withoutThinking(source);
+            super.updateContent(this.stripped);
+        }
+        else {
+            this.stripped = undefined;
+            super.updateContent(source);
+        }
+    }
+    setHideThinkingBlock(hide) {
+        this.hidden = hide;
+        // Base implementation flips its own flag and re-renders through
+        // `this.updateContent`, which lands on the override above.
+        super.setHideThinkingBlock(hide);
+    }
+}

package/dist/clients/attach/render/chat-view.d.ts

@@ -59,7 +59,12 @@ export declare class ChatView {
     private readonly imageWidthCells;
     private hideThinking;
     private readonly hiddenThinkingLabel;
+    /** Ctrl+O: pi's two-state tool-output expansion. */
     private toolOutputExpanded;
+    /** The view setting (Alt+C → w → f): fold every SETTLED tool call to its single
+     *  call line. Independent of `toolOutputExpanded` — it survives an expand/collapse
+     *  and only ever applies to tool calls that are done. */
+    private foldSettledTools;
     private readonly onFooterEvent;
     /** Theme-derived colorizers for the activity/status area. */
     private readonly spinnerStyle;
@@ -70,6 +75,12 @@ export declare class ChatView {
     /** The assistant message component currently being streamed (between
      *  message_start and message_end for an assistant turn). */
     private streamingComponent;
+    /** The separator immediately after the live assistant component. It becomes
+     *  visible when that response has visible prose or thinking and folded tools. */
+    private streamingToolSeparator;
+    /** Content classes for each separator, so Ctrl+T can add/remove thinking gaps
+     * without rebuilding the transcript. */
+    private readonly foldedToolSeparatorContents;
     /** Tool-call id → its execution component, for the duration of the call. */
     private readonly pendingTools;
     /** The `!` bash component currently streaming (between bash_start and bash_end). */
@@ -133,6 +144,13 @@ export declare class ChatView {
      *  the caller can surface a notice. Condensed cycles hold no tool components and
      *  are frozen as text, so they are unaffected by design. */
     toggleToolsExpanded(): boolean;
+    /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → f).
+     *  Returns the new state so the caller can surface a notice. */
+    toggleFoldSettledTools(): boolean;
+    /** Push both display settings onto every rendered component. A tool call still in
+     *  `pendingTools` is in flight, so it is never folded — you keep watching live
+     *  output, and it folds on its own once `tool_execution_end` settles it. */
+    private applyToolDisplay;
     /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
      *  every assistant message (the in-flight streaming bubble is itself a child of
      *  the container, so the loop covers it too). Returns the new HIDDEN state. */
@@ -147,6 +165,17 @@ export declare class ChatView {
         fullOutputPath?: string;
     }): void;
     private addMessageToChat;
+    /** Render an assistant reply plus its initially-hidden boundary separator. */
+    private appendAssistantMessage;
+    /** Add a separator in transcript order now; it renders only after a following
+     * tool settles in the folded view. */
+    private appendFoldedToolSeparator;
+    /** Make each separator visible only if its immediately-following tool call is
+     * actually folded; in-flight calls remain flush with their live output. */
+    private updateFoldedToolSeparators;
+    /** Track whether an assistant response contains prose or thinking, then make
+     * its separator eligible only for content the current Ctrl+T setting shows. */
+    private setAssistantSeparatorContent;
     /** Tool component with native viewer renderers for crouter-owned tool output. */
     private makeToolComponent;
     /** Append conversation content above the independent live status area — or into