@crouton-kit/crouter 0.3.70 → 0.3.79

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

@@ -52,7 +52,7 @@ const MAX_FRAME_BYTES = BROKER_READ_CAPS.maxLineBytes - 4 * 1024 * 1024;
  *  see slash-commands.ts's REMOTE_SAFE_BUILTIN_NAMES gate). */
 const DRIVE_FRAME_TYPES = new Set([
     'prompt', 'steer', 'follow_up', 'abort', 'bash',
-    'set_model', 'cycle_model', 'cycle_thinking', 'set_thinking_level', 'dequeue',
+    'set_model', 'cycle_model', 'cycle_ladder', 'cycle_thinking', 'set_thinking_level', 'dequeue',
     'set_auto_retry', 'set_auto_compaction', 'compact', 'new_session',
     'switch_session', 'fork', 'set_session_name', 'navigate_tree', 'reload',
     'export', 'clone', 'share', 'request_control', 'release_control', 'reload_auth',
@@ -64,6 +64,10 @@ export class InputController {
     hooks;
     /** The currently-rendered blocking dialog, if any (for supersede/dismiss). */
     dialog;
+    /** The request id of {@link dialog} — so a broker-driven `extension_ui_dismiss`
+     *  tears down ONLY the matching overlay (correlated dismissal), never an
+     *  unrelated one. */
+    dialogId;
     /** The currently-open native picker overlay, if any (for supersede/dismiss). */
     picker;
     /** Monotonic open counter — a slow read-op reply whose `seq` is no longer the
@@ -92,8 +96,11 @@ export class InputController {
     }
     /** Render extension UI requests from the broker. Blocking dialogs route their
      *  answer back to the broker; non-blocking notify requests become the viewer's
-     *  normal notice line. Supersedes any dialog already on screen (e.g. a re-route
-     *  on control handoff) by dismissing it first. */
+     *  normal notice line and NOTHING else — a notify must never tear down an
+     *  unrelated blocking dialog whose broker request is still pending. A dialog is
+     *  torn down only by (a) a NEW blocking dialog superseding it (control handoff
+     *  re-route), (b) its own answer, or (c) a correlated {@link dismissDialog}
+     *  from the broker (the request was aborted/timed out out-of-band). */
     attachDialog(req) {
         if (req.method === 'notify') {
             const prefix = req.notifyType === 'error' ? 'Error: ' : req.notifyType === 'warning' ? 'Warning: ' : '';
@@ -102,12 +109,26 @@ export class InputController {
             return;
         }
         this.dialog?.dismiss();
+        this.dialogId = req.id;
         this.dialog = renderDialog(this.tui, req, (resp) => {
             this.dialog = undefined;
+            this.dialogId = undefined;
             this.hooks.onDialogResponse(resp);
         }, this.keybindings);
         this.tui.requestRender();
     }
+    /** Broker-driven correlated dismissal: the broker resolved this request itself
+     *  (its request was aborted out-of-band — e.g. a local OAuth loopback callback
+     *  won the race against this manual-paste dialog — or its timeout fired). Tear
+     *  down ONLY the overlay whose id matches; leave any other dialog untouched. */
+    dismissDialog(id) {
+        if (this.dialogId !== id)
+            return;
+        this.dialog?.dismiss();
+        this.dialog = undefined;
+        this.dialogId = undefined;
+        this.tui.requestRender();
+    }
     /** Feed the latest engine state so read-only commands (e.g. `/session`) report
      *  current values. Optional; the controller works without it. */
     setState(state) {
@@ -174,6 +195,7 @@ export class InputController {
             onGraph: this.hooks.onGraph,
             onQuit: this.hooks.onQuit,
             onCopy: this.hooks.onCopy,
+            onColor: this.hooks.onColor,
             openModelPicker: () => void this.openModelPicker(),
             openSessionPicker: () => void this.openSessionPicker(),
             openForkPicker: () => void this.openForkPicker(),
@@ -182,6 +204,7 @@ export class InputController {
             openScopedModelsPicker: () => void this.openScopedModelsPicker(),
             openLoginPicker: this.hooks.openLoginPicker ? () => this.hooks.openLoginPicker() : undefined,
             openLogoutPicker: this.hooks.openLogoutPicker ? () => this.hooks.openLogoutPicker() : undefined,
+            onExplicitModelSet: this.hooks.onExplicitModelSet,
         };
     }
     // -------------------------------------------------------------------------
@@ -299,10 +322,20 @@ export class InputController {
         this.tui.requestRender();
     }
     openModelPicker() {
-        return this.openPicker({ type: 'list_models' }, 'list_models', 'model', (data, close) => buildModelPicker(this.tui, data, this.send, close));
+        return this.openPicker({ type: 'list_models' }, 'list_models', 'model', (data, close) => buildModelPicker(this.tui, data, this.send, close, this.hooks.onExplicitModelSet));
     }
+    /** Unlike the other pickers, the session picker opens IMMEDIATELY — its
+     *  component owns async loaders (with a Loading header), so the multi-second
+     *  session-dir scan runs off the open path instead of blocking it. */
     openSessionPicker() {
-        return this.openPicker({ type: 'list_sessions', scope: 'cwd' }, 'list_sessions', 'session', (data, close) => buildSessionPicker(this.tui, data, this.hooks.onRequest, this.keybindings, this.send, close));
+        const request = this.hooks.onRequest;
+        if (request === undefined) {
+            this.notify("The session picker isn't available in this viewer");
+            return Promise.resolve();
+        }
+        this.openSeq++; // supersede any in-flight fetch-first picker open
+        this.showPicker((controls) => buildSessionPicker(this.tui, this.state?.sessionFile, request, this.keybindings, this.send, controls.close));
+        return Promise.resolve();
     }
     openTreePicker() {
         return this.openPicker({ type: 'get_tree' }, 'get_tree', 'tree', (data, close) => buildTreePicker(this.tui, data, this.send, close));

package/dist/clients/attach/mermaid-render.js

@@ -18,7 +18,7 @@
 //
 // Scope (v1): only ```mermaid fences. The wider termrender directive vocabulary
 // is deliberately out of scope — see the base prompt's Diagrams note.
-import { isRendererReady, renderMarkdown } from '@crouton-kit/humanloop';
+import { ensureRenderer, isRendererReady, renderMarkdown } from '@crouton-kit/humanloop';
 /** A complete mermaid fence: ```mermaid (opening info string) ... closing ```.
  *  Line-anchored (m flag), non-greedy body (captured). An UNCLOSED fence (still
  *  streaming) does not match, so mid-stream text is left raw and only settles to
@@ -71,7 +71,10 @@ function stripBlankEdges(lines) {
  *  diagrams have no width control and overflow rather than truncate), which is
  *  stripped here, so an approximate pane width is fine. */
 export function transformMermaidFences(text, width) {
-    if (!textHasMermaid(text) || !isRendererReady())
+    if (!textHasMermaid(text))
+        return text;
+    ensureRenderer();
+    if (!isRendererReady())
         return text;
     return text.replace(MERMAID_FENCE, (whole, body) => {
         try {

package/dist/clients/attach/pickers.d.ts

@@ -1,5 +1,5 @@
 import { type Component, type KeybindingsManager, type TUI } from '@earendil-works/pi-tui';
-import type { ClientToBroker, GetSettingsData, GetTreeData, ListModelsData, ListScopedModelsData, ListSessionsData } from '../../core/runtime/broker-protocol.js';
+import type { ClientToBroker, GetSettingsData, GetTreeData, ListModelsData, ListScopedModelsData } from '../../core/runtime/broker-protocol.js';
 import type { ReadOpRequest } from './view-socket.js';
 /** A built picker overlay: the `component` to show, and the `focus` target the
  *  caller must `setFocus` (the component itself, or the inner list that owns
@@ -28,12 +28,13 @@ type Notify = (message: string) => void;
 /** `/model` (and ctrl+l) — the real model selector with search + scope toggle.
  *  Select → `set_model` with the resolved `provider/id` (the broker's
  *  `findModelSpec` requires that form). */
-export declare function buildModelPicker(tui: TUI, data: ListModelsData, send: Send, close: Close): Picker;
-/** `/resume` — the real session selector. Reconstructs from async loaders that
- *  fetch each scope on demand (cwd is pre-fetched so the current-session marker
- *  shows immediately; the `all` scope loads only on toggle). Select →
- *  `switch_session`. Rename/delete are out of scope (no command frame). */
-export declare function buildSessionPicker(tui: TUI, prefetchedCwd: ListSessionsData, request: Request, keybindings: KeybindingsManager, send: Send, close: Close): Picker;
+export declare function buildModelPicker(tui: TUI, data: ListModelsData, send: Send, close: Close, onSelect?: (model: string) => void): Picker;
+/** `/resume` — the real session selector. Opens INSTANTLY and reconstructs from
+ *  async loaders that fetch each scope on demand — the component's own Loading
+ *  header covers the scan (listing a large session dir takes seconds, so the
+ *  fetch must stay off the open path). Select → `switch_session`. Rename/delete
+ *  are out of scope (no command frame). */
+export declare function buildSessionPicker(tui: TUI, currentSessionFile: string | undefined, request: Request, keybindings: KeybindingsManager, send: Send, close: Close): Picker;
 /** `/tree` — the real tree navigator (pure data). Select → `navigate_tree`.
  *  Label-edit is out of scope (no command frame) → no `onLabelChange`. */
 export declare function buildTreePicker(tui: TUI, data: GetTreeData, send: Send, close: Close): Picker;

package/dist/clients/attach/pickers.js

@@ -51,7 +51,7 @@ function modelRegistryAdapter(all, available) {
 /** `/model` (and ctrl+l) — the real model selector with search + scope toggle.
  *  Select → `set_model` with the resolved `provider/id` (the broker's
  *  `findModelSpec` requires that form). */
-export function buildModelPicker(tui, data, send, close) {
+export function buildModelPicker(tui, data, send, close, onSelect) {
     const all = data.models;
     const availableSet = new Set(data.availableIds);
     const available = all.filter((m) => availableSet.has(`${m.provider}/${m.id}`));
@@ -60,29 +60,23 @@ export function buildModelPicker(tui, data, send, close) {
         : undefined;
     const component = new ModelSelectorComponent(tui, current, SettingsManager.inMemory(), modelRegistryAdapter(all, available), data.scopedModels, (model) => {
         send({ type: 'set_model', model: `${model.provider}/${model.id}` });
+        onSelect?.(`${model.provider}/${model.id}`);
         close();
     }, () => close());
     return { component, focus: component };
 }
-/** `/resume` — the real session selector. Reconstructs from async loaders that
- *  fetch each scope on demand (cwd is pre-fetched so the current-session marker
- *  shows immediately; the `all` scope loads only on toggle). Select →
- *  `switch_session`. Rename/delete are out of scope (no command frame). */
-export function buildSessionPicker(tui, prefetchedCwd, request, keybindings, send, close) {
+/** `/resume` — the real session selector. Opens INSTANTLY and reconstructs from
+ *  async loaders that fetch each scope on demand — the component's own Loading
+ *  header covers the scan (listing a large session dir takes seconds, so the
+ *  fetch must stay off the open path). Select → `switch_session`. Rename/delete
+ *  are out of scope (no command frame). */
+export function buildSessionPicker(tui, currentSessionFile, request, keybindings, send, close) {
     const revive = (d) => d.sessions.map((s) => ({ ...s, created: new Date(s.created), modified: new Date(s.modified) }));
-    let firstCwd = true;
-    const currentLoader = async () => {
-        if (firstCwd) {
-            firstCwd = false;
-            return revive(prefetchedCwd);
-        }
-        return revive((await request({ type: 'list_sessions', scope: 'cwd' })));
-    };
-    const allLoader = async () => revive((await request({ type: 'list_sessions', scope: 'all' })));
-    const component = new SessionSelectorComponent(currentLoader, allLoader, (path) => {
+    const loader = (scope) => async () => revive((await request({ type: 'list_sessions', scope })));
+    const component = new SessionSelectorComponent(loader('cwd'), loader('all'), (path) => {
         send({ type: 'switch_session', path });
         close();
-    }, () => close(), () => close(), () => tui.requestRender(), { showRenameHint: false, keybindings: keybindings }, prefetchedCwd.currentSessionFile);
+    }, () => close(), () => close(), () => tui.requestRender(), { showRenameHint: false, keybindings: keybindings }, currentSessionFile);
     return { component, focus: component };
 }
 /** `/tree` — the real tree navigator (pure data). Select → `navigate_tree`.

package/dist/clients/attach/slash-commands.d.ts

@@ -46,10 +46,19 @@ export interface SlashContext {
     openTreePicker?: () => void;
     openSettingsPicker?: () => void;
     openScopedModelsPicker?: () => void;
+    /** An EXPLICIT model choice was just issued via `/model <arg>` — mirrors
+     *  `InputControllerHooks.onExplicitModelSet` (the picker path fires it from
+     *  `buildModelPicker`). attach-cmd persists the choice as the node kind's
+     *  default once the broker confirms with `model_changed`. */
+    onExplicitModelSet?: (model: string) => void;
     /** Open the native /login provider selector. */
     openLoginPicker?: () => void;
     /** Open the native /logout provider selector. */
     openLogoutPicker?: () => void;
+    /** `/color` — recolor the editor's name chip (the "bubble" /rename names).
+     *  `null` clears back to the default chip. Wired by attach-cmd (it owns the
+     *  TitledEditor); absent → only the tmux pane outline is painted. */
+    onColor?: (color: string | null) => void;
 }
 /** Canvas slash-commands — implemented NATIVE in the viewer, the ONLY live host:
  *  the broker binds mode:'print', so broker pi-extensions never run their

package/dist/clients/attach/slash-commands.js

@@ -37,6 +37,8 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'resume-node', description: 'Open the canvas navigator (search/scope/sort/tree) and resume the chosen node' },
     { name: 'view', description: 'Open a view in a popup — bare for the picker, or /view <name> to open that view directly' },
     { name: 'context', description: 'Browse this node + its subscriptions’ context dirs in a read-only nvim popup' },
+    { name: 'rename', description: 'Rename this node everywhere — node row, viewer window, session chip, tmux pane: /rename <name>' },
+    { name: 'color', description: 'Color this node — tmux pane outline + name chip: /color <color> (red, blue, #rrggbb, …) or /color none' },
 ];
 const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
 /** Native canvas commands that shell a LOCAL `crtr` mutation or read against
@@ -46,7 +48,15 @@ const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
  *  local node, `/context` opens local `crtr node inspect context`. `/graph`
  *  (the in-process GRAPH overlay, already remote-safe — see graph-overlay.ts)
  *  and `/view` (a self-contained popup unrelated to `nodeId`) stay available. */
-const REMOTE_UNSAFE_CANVAS_NAMES = new Set(['promote', 'resume-node', 'context']);
+const REMOTE_UNSAFE_CANVAS_NAMES = new Set(['promote', 'resume-node', 'context', 'rename']);
+/** tmux named colours accepted by `/color` (plus `colourN`/`#rrggbb`, validated
+ *  by pattern). Mirrors tmux's colour-name table so a typo is rejected with the
+ *  options rather than silently ignored by tmux. */
+const TMUX_NAMED_COLORS = new Set([
+    'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white',
+    'brightred', 'brightgreen', 'brightyellow', 'brightblue', 'brightmagenta', 'brightcyan',
+    'orange', 'grey', 'gray', 'default',
+]);
 /** Builtins with no Phase-4 engine method — scoped out (review m2). */
 const SCOPED_OUT = new Set(['trust']);
 /** Valid `/settings thinking` levels — the `SetThinkingLevelFrame['level']`
@@ -153,6 +163,7 @@ export function dispatchSlashCommand(text, ctx) {
             if (!arg)
                 return openOrHint(ctx.openModelPicker, ctx, 'model', '/model <provider/id>');
             ctx.send({ type: 'set_model', model: arg });
+            ctx.onExplicitModelSet?.(arg);
             return true;
         case 'resume':
             if (!arg)
@@ -232,7 +243,7 @@ export function dispatchSlashCommand(text, ctx) {
 }
 /** Append the native canvas commands to a command list, skipping any already
  *  present (so they survive whatever list Unit Q feeds in — builtins, or the
- *  broker's `get_commands` result). The four canvas commands are viewer-owned,
+ *  broker's `get_commands` result). The canvas commands are viewer-owned,
  *  so they are always surfaced in autocomplete regardless of the source list —
  *  EXCEPT `REMOTE_UNSAFE_CANVAS_NAMES` when `remote`, which are structurally
  *  omitted rather than offered-then-blocked, so a remote attach's autocomplete
@@ -256,7 +267,7 @@ export function commandAutocompleteItems(commands = BUILTIN_SLASH_COMMANDS, remo
 // ---------------------------------------------------------------------------
 // Canvas commands — native reimplementations of the canvas chrome extensions.
 // ---------------------------------------------------------------------------
-/** Dispatch one of the four native canvas commands. Always returns `true` (the
+/** Dispatch one of the native canvas commands. Always returns `true` (the
  *  command is viewer-owned — never forwarded to the engine as a prompt). */
 function dispatchCanvasCommand(name, arg, ctx) {
     // Structural omission (withCanvasCommands) keeps these out of remote-mode
@@ -269,10 +280,8 @@ function dispatchCanvasCommand(name, arg, ctx) {
     }
     switch (name) {
         case 'graph':
-            // `/graph` is inherently the in-process GRAPH overlay (canvas-nav.ts
-            // `toggleGraph`), NOT a tmux popup. The overlay is Unit C/Q's surface; this
-            // unit registers the command + autocomplete entry and triggers the overlay
-            // via the `onGraph` hook the integration unit wires in.
+            // `/graph` opens the attach viewer's in-process GRAPH overlay, not a tmux
+            // popup. Dispatch reaches it through the viewer integration's `onGraph` hook.
             if (ctx.onGraph)
                 ctx.onGraph();
             else
@@ -293,6 +302,11 @@ function dispatchCanvasCommand(name, arg, ctx) {
             // A read-only nvim explorer over this node's + its subscriptions' context
             // dirs, as a self-contained popup.
             return openContext(ctx);
+        case 'rename':
+            renameNode(arg, ctx);
+            return true;
+        case 'color':
+            return colorNode(arg, ctx);
         default:
             ctx.notify(`/${name} is not available in attach`);
             return true;
@@ -351,6 +365,112 @@ function promoteNode(arg, ctx) {
         });
     });
 }
+/** `/rename <name>` — rename this node EVERYWHERE the name shows (à la Claude
+ *  Code's rename): (1) the pi session name, which is what the editor's title
+ *  chip ("bubble") paints — sent as a `set_session_name` frame so the chip
+ *  updates on the session_info_changed round-trip; (2) the tmux pane title
+ *  (visible with pane-border-status / terminal titles); (3) the canvas node row
+ *  via `crtr node config --name`, which also renames the live viewer window. */
+function renameNode(arg, ctx) {
+    const nodeId = (ctx.nodeId ?? process.env['CRTR_NODE_ID'] ?? '').trim();
+    if (nodeId === '') {
+        ctx.notify('/rename: no node to rename (viewer has no node id)');
+        return;
+    }
+    if (arg === '') {
+        ctx.notify('Usage: /rename <name>');
+        return;
+    }
+    // 1. Session name → the editor title chip repaints when the state echoes back.
+    ctx.send({ type: 'set_session_name', name: arg });
+    // 2. tmux pane title (best-effort; no-op outside tmux).
+    const pane = process.env['TMUX_PANE'];
+    if (process.env['TMUX'] !== undefined && pane !== undefined && pane !== '') {
+        execFile('tmux', ['select-pane', '-t', pane, '-T', arg], () => {
+            /* best-effort */
+        });
+    }
+    // 3. Canvas node row + live viewer window.
+    execFile('crtr', ['node', 'config', '--node', nodeId, '--name', arg, '--json'], { timeout: 15_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+        if (err) {
+            // On a non-zero exit crtr still prints the structured error to stdout.
+            let msg = null;
+            try {
+                const payload = JSON.parse(stdout);
+                msg = typeof payload.message === 'string' ? payload.message : null;
+            }
+            catch {
+                msg = null;
+            }
+            ctx.notify(`rename failed: ${msg ?? err.message}`);
+            return;
+        }
+        ctx.notify(`Renamed node → ${arg}`);
+    });
+}
+/** Promisified one-shot tmux call — resolves stdout ('' on error; best-effort). */
+function tmuxCall(args) {
+    return new Promise((resolve) => {
+        execFile('tmux', args, { timeout: 5_000 }, (err, stdout) => resolve(err ? '' : stdout));
+    });
+}
+/** Paint (or clear) THIS pane's border color. `pane-border-style` is a WINDOW
+ *  option — tmux silently hoists a `set-option -p` to window scope, painting
+ *  every pane — so per-pane color rides a per-pane user option instead: the
+ *  color lands in `@crtr_color` on this pane only, and the window's border
+ *  styles are set ONCE to a format tmux expands per pane (`fg=#{@crtr_color}`
+ *  when set, else the style that was in effect before — baked in at install
+ *  time so uncolored panes keep the user's theme). Clearing just unsets
+ *  `@crtr_color`; the format's fallback branch restores the original look. */
+async function paintPaneBorder(pane, value, clear) {
+    if (clear) {
+        await tmuxCall(['set-option', '-p', '-u', '-t', pane, '@crtr_color']);
+        return;
+    }
+    await tmuxCall(['set-option', '-p', '-t', pane, '@crtr_color', value]);
+    for (const opt of ['pane-border-style', 'pane-active-border-style']) {
+        const cur = (await tmuxCall(['show-options', '-wqv', '-t', pane, opt])).trim();
+        if (cur.includes('@crtr_color'))
+            continue; // our format is already installed on this window
+        // Bake the pre-existing effective style into the fallback branch (window
+        // value, else global, else tmux's defaults) — commas escaped so they don't
+        // split the #{?,,} conditional.
+        let base = cur !== '' ? cur : (await tmuxCall(['show-options', '-gqv', opt])).trim();
+        if (base === '')
+            base = opt === 'pane-active-border-style' ? 'fg=green' : 'default';
+        const fmt = `#{?#{!=:#{@crtr_color},},fg=#{@crtr_color},${base.replace(/,/g, '#,')}}`;
+        await tmuxCall(['set-option', '-w', '-t', pane, opt, fmt]);
+    }
+}
+/** `/color <color>` — color this node's two identity surfaces in one stroke:
+ *  the tmux PANE OUTLINE (via `paintPaneBorder` above — per-pane, not the whole
+ *  window) and the editor's NAME CHIP (the bubble `/rename` names), via the
+ *  `onColor` hook attach-cmd wires. Ephemeral by design: the border rides the
+ *  tmux pane and the chip lives in this viewer process. `/color none` clears
+ *  both. Remote-SAFE: both surfaces are local to this viewer. */
+function colorNode(arg, ctx) {
+    const value = arg.trim().toLowerCase();
+    if (value === '') {
+        ctx.notify('Usage: /color <color> — a name (red, blue, orange…), colourN, or #rrggbb; /color none to clear');
+        return true;
+    }
+    const clear = value === 'none' || value === 'clear';
+    const valid = clear || TMUX_NAMED_COLORS.has(value) || /^colour\d{1,3}$/.test(value) || /^#[0-9a-f]{6}$/.test(value);
+    if (!valid) {
+        ctx.notify(`Invalid color "${value}" — use a tmux colour name (${['red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'orange'].join(', ')}, …), colourN, or #rrggbb`);
+        return true;
+    }
+    // Pane outline — per-pane @crtr_color + a per-pane-expanded window format,
+    // so only THIS node's pane recolors (fire-and-forget; best-effort).
+    const pane = process.env['TMUX_PANE'];
+    const inTmux = process.env['TMUX'] !== undefined && pane !== undefined && pane !== '';
+    if (inTmux)
+        void paintPaneBorder(pane, value, clear);
+    // Name chip — the viewer owns the editor, so this rides the onColor hook.
+    ctx.onColor?.(clear ? null : value);
+    ctx.notify(clear ? 'Node color cleared' : `Node colored ${value}${inTmux ? '' : ' (chip only — no tmux pane)'}`);
+    return true;
+}
 /** `/resume-node`. Opens `crtr canvas browse` as a tmux popup,
  *  scoped to this node's cwd; on Enter it focuses the chosen node back into this
  *  pane via `crtr node focus --pane` (which `canvas browse` shells). */

package/dist/clients/attach/titled-editor.d.ts

@@ -1,7 +1,12 @@
 import { CustomEditor } from '@earendil-works/pi-coding-agent';
 import { type EditorOptions, type EditorTheme, type TUI } from '@earendil-works/pi-tui';
 /** Thinking levels pi cycles through (shift+tab), lowest → highest budget. */
-export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/** Build a title-chip styler for a `/color` token (a tmux colour name, `#rrggbb`,
+ *  or `colourN`): the colour as the chip BACKGROUND with contrast-picked bold
+ *  text, matching the thinking-chip treatment. `undefined` for an unrenderable
+ *  token (e.g. `default`) — the caller keeps its fallback style. */
+export declare function colorChipStyle(token: string): ((s: string) => string) | undefined;
 /** The default (thinking `off`) title chip: reverse video + a space of padding
  *  each side, so the name reads as a label sitting on the border rule. Used as
  *  the fallback when no thinking color applies. */
@@ -20,6 +25,7 @@ export declare function thinkingTitleStyle(level: string | undefined, fallback:
  *  and truncates when it only partially fits. Exported pure for the overflow
  *  regression test. */
 export declare function composeTopBorder(width: number, title: string, info: string, titleStyle: (s: string) => string, borderColor: (s: string) => string): string;
+export declare function outlineCursorLine(line: string): string | undefined;
 export declare class TitledEditor extends CustomEditor {
     /** crtr's OWN keybindings manager — the same one CustomEditor matches `app.*`
      *  against. We keep a reference so `handleInput` can resolve the newline chord
@@ -51,5 +57,10 @@ export declare class TitledEditor extends CustomEditor {
     titleStyle: (s: string) => string;
     /** Mode badge colorizer, matched to the current mode type. */
     modeStyle: (s: string) => string;
+    /** Whether the hosting tmux pane / terminal window has FOCUS (terminal focus
+     *  reporting, DECSET 1004 — attach-cmd flips this on `\x1b[I` / `\x1b[O`).
+     *  Distinct from TUI component focus: the editor keeps component focus while
+     *  its pane is blurred. False → the fake cursor renders as an outline. */
+    paneFocused: boolean;
     render(width: number): string[];
 }

package/dist/clients/attach/titled-editor.js

@@ -6,16 +6,16 @@
 //      on each state update), mirroring pi's `getThinkingBorderColor`.
 // Both are pure render-layer chrome; nothing here touches the socket or session.
 import { CustomEditor } from '@earendil-works/pi-coding-agent';
-import { truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
-/** The thinking color scale is a deliberate cool→warm ramp between a blue and
- *  its orange complement, evenly spaced across the five active levels so each
- *  step stays readable without jumping through unrelated hues. `off` falls
- *  back to the caller's default border color. The endpoints are deliberately
- *  deep (not bright) hues: the same colors double as the title-chip BACKGROUND
- *  under bold white text, so every step must clear ~4.5:1 white-on-color
- *  contrast — a lighter blue/orange washes the label out. */
+import { CURSOR_MARKER, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
+/** The standard thinking levels form a deliberate cool→warm ramp between blue
+ *  and its orange complement. `max` is a distinct, intense cyan endpoint so it
+ *  never falls back to the neutral default border. `off` alone falls back to
+ *  the caller's default border color. The colors double as title-chip
+ *  BACKGROUNDS under bold white text, so each must remain dark enough for the
+ *  label to read clearly. */
 const THINKING_START = [46, 92, 190]; // deep blue
 const THINKING_END = [166, 98, 24]; // deep amber
+const THINKING_MAX = [0, 145, 170]; // intense cyan
 function interpolateRgb(start, end, t) {
     return [
         Math.round(start[0] + (end[0] - start[0]) * t),
@@ -30,7 +30,55 @@ const THINKING_RGB = {
     medium: interpolateRgb(THINKING_START, THINKING_END, 2 / 4),
     high: interpolateRgb(THINKING_START, THINKING_END, 3 / 4),
     xhigh: interpolateRgb(THINKING_START, THINKING_END, 4 / 4),
+    max: THINKING_MAX,
 };
+/** Named colours `/color` accepts, as RGB — mirrors the tmux colour-name table
+ *  (so the chip and the pane border read as the same hue). */
+const NAMED_RGB = {
+    black: [0, 0, 0],
+    red: [205, 49, 49],
+    green: [13, 188, 121],
+    yellow: [229, 229, 16],
+    blue: [36, 114, 200],
+    magenta: [188, 63, 188],
+    cyan: [17, 168, 205],
+    white: [229, 229, 229],
+    orange: [228, 152, 68],
+    grey: [128, 128, 128],
+    gray: [128, 128, 128],
+    brightred: [241, 76, 76],
+    brightgreen: [35, 209, 139],
+    brightyellow: [245, 245, 67],
+    brightblue: [59, 142, 234],
+    brightmagenta: [214, 112, 214],
+    brightcyan: [41, 184, 219],
+};
+/** Build a title-chip styler for a `/color` token (a tmux colour name, `#rrggbb`,
+ *  or `colourN`): the colour as the chip BACKGROUND with contrast-picked bold
+ *  text, matching the thinking-chip treatment. `undefined` for an unrenderable
+ *  token (e.g. `default`) — the caller keeps its fallback style. */
+export function colorChipStyle(token) {
+    const t = token.trim().toLowerCase();
+    const c256 = /^colour(\d{1,3})$/.exec(t);
+    if (c256 !== null)
+        return (s) => `\x1b[48;5;${c256[1]}m\x1b[97m\x1b[1m ${s} \x1b[0m`;
+    let rgb;
+    const hex = /^#([0-9a-f]{6})$/.exec(t);
+    if (hex !== null) {
+        const h = hex[1];
+        rgb = [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+    }
+    else {
+        rgb = NAMED_RGB[t];
+    }
+    if (rgb === undefined)
+        return undefined;
+    const [r, g, b] = rgb;
+    // Pick black-on-light / white-on-dark so the name stays readable on any hue.
+    const luma = 0.299 * r + 0.587 * g + 0.114 * b;
+    const fg = luma > 160 ? '\x1b[30m' : '\x1b[97m';
+    return (s) => `\x1b[48;2;${r};${g};${b}m${fg}\x1b[1m ${s} \x1b[0m`;
+}
 /** The default (thinking `off`) title chip: reverse video + a space of padding
  *  each side, so the name reads as a label sitting on the border rule. Used as
  *  the fallback when no thinking color applies. */
@@ -71,6 +119,39 @@ export function composeTopBorder(width, title, info, titleStyle, borderColor) {
     const fill = Math.max(0, width - chipW - visibleWidth(infoChip));
     return chip + borderColor('─'.repeat(fill)) + infoChip;
 }
+/** The stock pi-tui editor paints its fake cursor as a solid reverse-video
+ *  block (`\x1b[7m…\x1b[0m`) unconditionally — in a wall of attach panes every
+ *  pane shows an identical solid white cursor, and nothing tells you which one
+ *  keys actually go to. When the hosting pane/terminal is UNFOCUSED we rewrite
+ *  that cell into a MUTED cursor, mirroring how real terminals de-emphasize
+ *  the hardware cursor on blur. A pixel-true full-cell outline isn't possible
+ *  in text cells, and hollow-box glyphs (▯/⍘/□) render undersized, so the
+ *  muted form is a full-size block in a dim gray background — same footprint
+ *  as the focused cursor, clearly not the bright active one (ruling: tried the
+ *  glyphs, Silas preferred the dim block). The rewrite anchors on pi-tui's
+ *  zero-width CURSOR_MARKER (emitted right before the fake cursor while the
+ *  editor component has TUI focus) so it can never touch reverse video
+ *  elsewhere in the line. Returns undefined when the line carries no cursor.
+ *  Exported pure for tests. */
+const SOLID_CURSOR_PREFIX = '\x1b[7m';
+const SOLID_CURSOR_RESET = '\x1b[0m';
+/** Dim gray bg, default fg — the char under the cursor stays readable. */
+const MUTED_CURSOR_ON = '\x1b[48;5;240m';
+export function outlineCursorLine(line) {
+    const m = line.indexOf(CURSOR_MARKER);
+    if (m === -1)
+        return undefined;
+    const start = m + CURSOR_MARKER.length;
+    if (!line.startsWith(SOLID_CURSOR_PREFIX, start))
+        return undefined;
+    const gStart = start + SOLID_CURSOR_PREFIX.length;
+    const end = line.indexOf(SOLID_CURSOR_RESET, gStart);
+    if (end === -1)
+        return undefined;
+    const grapheme = line.slice(gStart, end);
+    const replacement = `${MUTED_CURSOR_ON}${grapheme}\x1b[0m`;
+    return line.slice(0, start) + replacement + line.slice(end + SOLID_CURSOR_RESET.length);
+}
 export class TitledEditor extends CustomEditor {
     /** crtr's OWN keybindings manager — the same one CustomEditor matches `app.*`
      *  against. We keep a reference so `handleInput` can resolve the newline chord
@@ -114,8 +195,22 @@ export class TitledEditor extends CustomEditor {
     titleStyle = defaultTitleStyle;
     /** Mode badge colorizer, matched to the current mode type. */
     modeStyle = defaultTitleStyle;
+    /** Whether the hosting tmux pane / terminal window has FOCUS (terminal focus
+     *  reporting, DECSET 1004 — attach-cmd flips this on `\x1b[I` / `\x1b[O`).
+     *  Distinct from TUI component focus: the editor keeps component focus while
+     *  its pane is blurred. False → the fake cursor renders as an outline. */
+    paneFocused = true;
     render(width) {
         const lines = super.render(width);
+        if (!this.paneFocused) {
+            for (let i = 0; i < lines.length; i++) {
+                const hollowed = outlineCursorLine(lines[i]);
+                if (hollowed !== undefined) {
+                    lines[i] = hollowed;
+                    break;
+                }
+            }
+        }
         if ((this.title || this.info) && lines.length > 0) {
             // Replace the stock top border; dashes in the current (thinking-aware)
             // border color.

package/dist/commands/canvas-browse.js

@@ -1,6 +1,6 @@
 // `crtr canvas browse` — the interactive full-screen canvas navigator.
 //
-// A raw-mode TUI over the WHOLE canvas: tabs (All/Live/Dormant/Flagged), an
+// A raw-mode TUI over the WHOLE canvas: tabs (All/Live/Dormant/Attention/Pinned), an
 // auto-collapsed tree, and `/` fuzzy search. Enter resumes the chosen node via
 // `crtr node focus` (the ONLY sanctioned open — reviveNode, never `pi --session`).
 // Owns the screen, so it returns void and writes nothing to stdout itself.
@@ -14,7 +14,7 @@ import { readState } from '../core/config.js';
 export const browseLeaf = defineLeaf({
     name: 'browse',
     description: 'open the interactive canvas navigator (tabs/tree/search)',
-    whenToUse: 'you want to VIEW and NAVIGATE the whole canvas interactively — a full-screen TUI with tabs (All/Live/Dormant/Flagged), an expandable tree (children auto-collapsed; → to expand), and `/` fuzzy search that auto-expands ancestors of matches; Enter resumes the chosen node. Use this to find your way around a large canvas. Use `canvas dashboard` instead for a one-shot ASCII tree you can pipe, and `node inspect list` for a flat machine-readable roster',
+    whenToUse: 'you want to VIEW and NAVIGATE the whole canvas interactively — a full-screen TUI with tabs (All/Live/Dormant/Attention/Pinned), an expandable tree (children auto-collapsed; → to expand), `/` fuzzy search, `f` to pin, `m` to message and `R` to rename a node in place, and `?` for the full keymap; Enter resumes the chosen node. Use this to find your way around a large canvas. Use `canvas dashboard` instead for a one-shot ASCII tree you can pipe, and `node inspect list` for a flat machine-readable roster',
     help: {
         name: 'canvas browse',
         summary: 'interactive full-screen canvas navigator — tabs, an auto-collapsed tree, and `/` fuzzy search; Enter resumes the chosen node via `crtr node focus`. Outside a TTY it prints the static forest and exits',

package/dist/commands/human/queue.js

@@ -9,7 +9,7 @@ import { appendInbox } from '../../core/feed/inbox.js';
 import { closeSync, existsSync, linkSync, openSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { inbox, scanInbox, parseDeck, deckPath, responsePath, progressPath, isResolved, atomicWriteJson, ask, launchReview, readJson, display, } from '@crouton-kit/humanloop';
+import { openInbox, scanInbox, parseDeck, deckPath, responsePath, progressPath, isResolved, atomicWriteJson, ask, launchReview, readJson, display, } from '@crouton-kit/humanloop';
 import { killPane } from './shared.js';
 // ---------------------------------------------------------------------------
 // stranded-answer healing
@@ -158,8 +158,8 @@ export const humanInbox = defineLeaf({
         ],
     },
     run: async () => {
-        await inbox([interactionsRoot(process.cwd())]);
-        // humanloop's inbox() writes response.json but never calls pushFinal — so a
+        await openInbox({ roots: [interactionsRoot(process.cwd())] });
+        // humanloop's openInbox() writes response.json but never calls pushFinal — so a
         // deck drained here would strand (no answer-back, leaked bridge node). Heal
         // every resolved-but-live interaction: deliver its answer to the asker + reap.
         const delivered = await healStrandedInteractions(process.cwd());
@@ -766,7 +766,6 @@ export const humanRun = defineLeaf({
                 try {
                     const res = await launchReview(rc.file, {
                         output: rc.output,
-                        noTmux: true,
                     });
                     await pushFinal(rc.job_id, JSON.stringify(res));
                 }