@north-light/crouter 0.3.158 → 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/storage-tiers.md

@@ -3,6 +3,8 @@ name: internal/storage-tiers
 kind: knowledge
 description: Where crouter state belongs
 when-and-why-to-read: When locating crtr state or deciding where a new file belongs, this reference should be read so files are found or placed in the storage tier with the right ownership and durability.
+system-prompt-visibility: name
+file-read-visibility: none
 short-form: The two crtr storage tiers — scope root for durable user/repo content and canvas home for node-graph runtime state, node artifacts, and human tickets.
 ---
 

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,9 +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;
-/** Readable drill-in document for the tmux detail surface. Watch-only — no
- *  cancel line: the owning agent already received the exact `kill -- -<pgid>`
- *  in its handoff notice, and persisting pgid to add a human stop affordance is
- *  a separable future addition (measuring-stick restraint). */
-export declare function renderBashJobsDetails(jobs: readonly BashJobStatus[], nowMs?: number): string;
+/** 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

@@ -1,43 +1,31 @@
-// chrome/bash-jobs.ts — the attach-side formatter pair for live backgrounded bash
-// jobs (R3 of the Alt+C -> b bash handoff refinements design), mirroring
-// chrome/cron-wait.ts: a compact one-row cockpit summary and a read-only markdown
-// detail document. Pure — takes the already-scanned job list, never touches
-// disk itself (that's activeBackgroundBashJobs' job, in core/bash-jobs.ts).
+// chrome/bash-jobs.ts — the attach-side formatter for live backgrounded bash jobs,
+// mirroring chrome/cron-wait.ts: the compact one-row cockpit summary. Pure — takes
+// the already-scanned job list, never touches disk itself (that's
+// 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)}`;
 }
-/** Readable drill-in document for the tmux detail surface. Watch-only — no
- *  cancel line: the owning agent already received the exact `kill -- -<pgid>`
- *  in its handoff notice, and persisting pgid to add a human stop affordance is
- *  a separable future addition (measuring-stick restraint). */
-export function renderBashJobsDetails(jobs, nowMs = Date.now()) {
-    const lines = [
-        '# Background bash jobs',
-        '',
-        `${jobs.length} bash job${jobs.length === 1 ? '' : 's'} running in the background.`,
-    ];
-    for (const job of jobs) {
-        lines.push('', `## ⚙ ${cmdCell(job.command)}`, '');
-        lines.push(`- **Elapsed:** ${formatBashElapsed(nowMs - job.startedAtMs)} · started ${new Date(job.startedAtMs).toISOString()}`);
-        lines.push(`- **Log:** \`${job.logPath}\``);
-        lines.push(`- **Watch:** \`tail -f ${job.logPath}\``);
-        lines.push('', '### Command', '', '```bash', job.command, '```');
-    }
-    return `${lines.join('\n')}\n`;
-}

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,14 +5,20 @@ 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;
     /** Open the viewer-owned Inspector popup (`surface inspect`) on a section —
-     *  the cron wait row routes to `schedule`; the native Inspector owns details. */
-    openInspector: (section: 'overview' | 'schedule') => void;
+     *  the cron wait row routes to `schedule` and the bash row to `jobs`; the
+     *  native Inspector owns details for both. */
+    openInspector: (section: 'overview' | 'schedule' | 'jobs') => void;
 }
 export interface AttachRoster {
     /** Rebuild the rows from the canvas source, reconcile the selection, repaint. */

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

@@ -4,9 +4,11 @@
 // editor's visual bottom drops the cursor into the list; within it ↑/↓ move the
 // highlight, ↑ off the TOP row returns to the editor, ↓ CLAMPS at the bottom,
 // Enter opens the row (SWAPS this pane in place onto a node, or opens the wait
-// detail surface for a human/cron/bash row), Esc / any typed key returns to the
-// editor. Disabled entirely for a REMOTE attach: a remote graph id has no local
-// pane to swap into and no local jobs/crons to inspect.
+// detail surface for a human/cron/bash row: a human row opens the inbox, a cron
+// row the Inspector's schedule section, a bash row the Inspector's jobs section),
+// Esc / any typed key returns to the editor. Disabled entirely for a REMOTE
+// attach: a remote graph id has no local pane to swap into and no local
+// jobs/crons to inspect.
 //
 // TWO EDITOR COUPLINGS ARE OWNED HERE, deliberately and exclusively:
 //   • `editor.onCursorDownAtBottom` — the boundary handoff. The editor owns
@@ -23,18 +25,12 @@
 // 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 { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-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 { inTmux, shellQuote } from '../../../core/runtime/placement-tmux.js';
-import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
+import { fillBar, fillWidth, stripSgr, REVERSE } from '../../../core/canvas/nav-render.js';
 import { buildCanvasPanelLines } from './canvas-panels.js';
-import { renderBashJobsDetails } from './bash-jobs.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
  *  spawned into a non-active pane (a `split -d` beside another node — the
@@ -54,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;
@@ -65,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;
     };
@@ -73,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();
     };
@@ -100,44 +107,78 @@ 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();
         }
     };
-    editor.onCursorDownAtBottom = remote ? undefined : () => {
-        if (selKey !== undefined || items.length === 0)
-            return;
-        selKey = items[0].key;
-        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;
     };
-    /** Open a read-only markdown detail popup in nvim, deleting the temp file when
-     *  the popup closes and re-running the chrome refresh (background-bash wait row). */
-    const openDetailsPopup = (prefix, file, title, missingNvim, body) => {
-        const dir = mkdtempSync(join(tmpdir(), prefix));
-        const path = join(dir, file);
-        writeFileSync(path, body, 'utf8');
-        const cmd = `if command -v nvim >/dev/null 2>&1; then exec nvim -R -c 'setlocal filetype=markdown' -- ${shellQuote(path)}; else printf '${missingNvim}\\n'; printf 'Press Enter to close.'; read _; fi`;
-        execFile('tmux', ['display-popup', '-E', '-T', title, '-w', '90%', '-h', '85%', ...surfaceTmuxStyleArgs(), cmd], () => {
-            rmSync(dir, { recursive: true, force: true });
-            hooks.requestChromeRefresh();
-        });
-    };
-    const openBashJobsDetails = () => {
-        const current = activeBackgroundBashJobs(contextDir(nodeId));
-        if (current.length === 0) {
+    /** `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 (!inTmux()) {
-            hooks.setNotice('Background job details require tmux');
+        if (jobs.length > 1) {
+            hooks.setNotice(`${jobs.length} background jobs — press ↵ to pick one in the Inspector`);
             return;
         }
-        openDetailsPopup('crtr-bash-jobs-', 'background-bash-jobs.md', ' background bash jobs ', 'nvim is required to inspect background bash jobs. Install Neovim and retry.', renderBashJobsDetails(current));
+        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;
+        selKey = items[0].key;
+        paint();
     };
     const openSelected = () => {
         const item = items.find((candidate) => candidate.key === selKey);
@@ -158,8 +199,13 @@ export function createRoster(s, hooks) {
             return;
         }
         if (item.kind === 'bash') {
+            if (activeBackgroundBashJobs(contextDir(nodeId)).length === 0) {
+                hooks.setNotice('Background job already finished');
+                hooks.requestChromeRefresh();
+                return;
+            }
             exit();
-            openBashJobsDetails();
+            hooks.openInspector('jobs');
             return;
         }
         const id = item.nodeId;
@@ -196,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 {};