@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/{tui → inspector}/host.js

@@ -1,32 +1,15 @@
-// host.ts — the alt-screen loop that hosts a dual-target ViewCore + TuiPresenter
-// (src/core/view/contract.ts).
+// host.ts — the native Inspector's alt-screen runtime.
 //
-// Models browse/app.ts's loop, generalized: the host owns the screen, input,
-// chrome, and the single-flight async lane. State is immutable (the core's
-// intents update it via `ctx.set`); presenters are pure reads. A keystroke maps
-// through the TuiPresenter's keymap to a named intent the host dispatches.
-//
-//   • TTY gate: non-interactive stdin OR stdout → text.dump(state) (or a synthesized
-//     one-line dump) to stdout, exit 0.
-//   • setup/restore terminal (alt-screen, raw); restore exactly once, however we
-//     leave (quit / Ctrl-C / crash / process exit).
-//   • single-flight async lane: at most ONE async intent in flight; a busy
-//     indicator shows in the chrome; keystrokes that arrive mid-flight are
-//     DROPPED (this paces fetches/sends).
-//   • chrome: title row + separator on top; an error banner + a footer (status
-//     left, keymap hints right) on the bottom; the presenter gets the content Rect.
-//   • loop: parseKeypress → keymap → dispatch(intent) → render; refreshMs polling;
-//     resize → render (NOT refresh) so a resize mid-fetch repaints from current
-//     state without re-entering the in-flight intent.
-import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from './terminal.js';
-import { createDraw, detectColorCaps } from './draw.js';
-import { initialChrome, deriveState } from '../view/chrome.js';
-import { createLocalTransport } from '../view/transport-local.js';
+// The host owns the terminal, chrome, subprocess transport, and single-flight
+// intent lane. Inspector state is immutable; keybindings dispatch named intents.
+import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from '../tui/terminal.js';
+import { createDraw, detectColorCaps } from '../tui/draw.js';
+import { initialChrome, deriveState } from './chrome.js';
+import { createInspectorTransport } from './transport.js';
 import { formatBinding, matchesTerminalInput, resolveUserKeybindings, } from '../keybindings/index.js';
 // Numeric SGR codes only (a color NAME emits a broken CSI — see draw.ts guard).
 const FG = { cyan: '36', green: '32', yellow: '33', red: '31', grey: '90' };
-/** The persistent state signal: word + glyph + hue, derived from host signals so
- *  every view gets it for free. Each pairs hue with a glyph/word — mono-safe. */
+/** The persistent state signal. Each hue is paired with a glyph and word. */
 const CHIP = {
     working: { word: 'working', glyph: '⟳', fg: FG.cyan },
     blocked: { word: 'blocked', glyph: '⚠', fg: FG.red },
@@ -117,7 +100,7 @@ function keymapSpans(hints, avail) {
  *  Three zones: title row (state rail + title/subtitle + state chip + liveness),
  *  a hairline, and a footer (status left, keymap right) with a severity banner
  *  on the row above it when set. */
-function drawChrome(draw, size, manifest, c, now = Date.now()) {
+function drawInspectorChrome(draw, size, manifest, c, now = Date.now()) {
     const { cols, rows } = size;
     const st = deriveState(c);
     // Chip selection. An explicit interaction mode (compose/react) WINS the chip
@@ -179,7 +162,7 @@ function drawChrome(draw, size, manifest, c, now = Date.now()) {
     const height = Math.max(1, rows - top - bottomRows);
     return { row: top, col: 0, width: cols, height };
 }
-export { drawChrome };
+export { drawInspectorChrome };
 /** True when some effective binding claims the `ctrl+h` gesture — used to decide
  * whether the ambiguous 0x08 byte is a Ctrl-H remap or a plain Backspace. */
 function bindingSetClaimsCtrlH(bindings) {
@@ -196,11 +179,8 @@ function summarizeKeybindingDiagnostics(diags) {
     const extra = diags.length > 1 ? ` (+${diags.length - 1} more)` : '';
     return `keybindings: ${diags[0].message}${extra}`;
 }
-/** Extend the shared legacy parser with the terminal gestures the catalog can
- * express. The raw shape goes only to the catalog matcher; custom literals keep
- * their established Key-based matching. When `bindings` is supplied the ambiguous
- * 0x08 byte resolves to Ctrl-H only if an effective binding claims it. */
-export function parseViewKeypress(data, bindings) {
+/** Decode terminal bytes into the shared keybinding catalog's input shape. */
+export function parseInspectorInput(data, bindings) {
     const parsed = parseKeypress(data);
     const raw = { ...parsed.key, input: parsed.input };
     const sequence = data.toString('utf8');
@@ -233,24 +213,14 @@ export function parseViewKeypress(data, bindings) {
         raw[modifiedHomeEnd[2] === 'H' ? 'home' : 'end'] = true;
         setModifiers(modifiedHomeEnd[1]);
     }
-    // Alt+<char> gestures (ESC-prefixed printables/control letters) that the
-    // legacy parser leaves as a raw two-byte `input`. Only the raw catalog shape
-    // gains the alt modifier; `parsed` keeps its Key-based shape so custom literals
-    // still match exactly as before (Alt+<letter> must NOT match a bare literal).
-    // Special keys the legacy parser already decoded (Alt+Backspace, arrows, …)
-    // return `input: ''`, so `parsed.input === sequence` skips them here.
+    // Alt+<char> gestures arrive as an escape-prefixed byte pair.
     if (sequence.length === 2 && sequence.startsWith('\x1b') && parsed.input === sequence) {
         const code = sequence.charCodeAt(1);
         raw.input = code < 32 ? String.fromCharCode(code + 64).toLowerCase() : sequence[1];
         raw.meta = true;
         raw.ctrl = code < 32;
     }
-    // Backspace family. \x7f, \b, and their Alt-prefixed forms all mean "delete one
-    // char" and canonicalize to plain backspace (there is no alt+backspace catalog
-    // action, so Alt+Backspace deletes exactly like Backspace, as before). The 0x08
-    // byte is ALSO Ctrl-H: honor a Ctrl-H remap only when an effective binding
-    // actually claims `ctrl+h`, otherwise it stays backspace so default deletion
-    // keeps working on ^H-erase terminals.
+    // The 0x08 byte is either Backspace or an explicit Ctrl-H remap.
     if (raw.backspace) {
         const ctrlHByte = sequence === '\b' || sequence === '\x1b\b';
         if (ctrlHByte && bindings && bindingSetClaimsCtrlH(bindings)) {
@@ -266,126 +236,46 @@ export function parseViewKeypress(data, bindings) {
             raw.backspace = true;
         }
     }
-    return { ...parsed, raw };
-}
-function keyTokens(input, key) {
-    const t = [];
-    if (key.upArrow)
-        t.push('up');
-    if (key.downArrow)
-        t.push('down');
-    if (key.leftArrow)
-        t.push('left');
-    if (key.rightArrow)
-        t.push('right');
-    if (key.return)
-        t.push('return', 'enter');
-    if (key.escape)
-        t.push('escape', 'esc');
-    if (key.tab)
-        t.push('tab');
-    if (key.shiftTab)
-        t.push('shifttab');
-    if (key.backspace)
-        t.push('backspace');
-    if (key.ctrl && input)
-        t.push(`ctrl+${input}`, `c-${input}`);
-    if (!key.ctrl && !key.escape && input.length === 1)
-        t.push(input);
-    if (input === ' ')
-        t.push('space');
-    return t;
-}
-/** A printable text edit (for the capture line-editor): a non-empty input with
- *  no special-key flag set. */
-function isPrintable(input, key) {
-    if (key.ctrl || key.meta || key.escape || key.return || key.tab || key.backspace
-        || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.shiftTab)
-        return false;
-    return input.length >= 1;
-}
-/** Strip control chars so a paste can't smuggle ANSI into the draft buffer. */
-function sanitizePrintable(s) {
-    return Array.from(s).filter((ch) => ch.charCodeAt(0) >= 32).join('');
+    return raw;
 }
-/** Resolve footer hints for the CURRENT state: only bindings whose `when(state)`
- * passes contribute, so mode-gated affordances (compose/react send/cancel/pick)
- * appear exactly while active. Catalog bindings render the effective key label
- * (omitted entirely when disabled); custom-view literal hints stay verbatim. */
-export function resolveViewKeyHints(keymap, bindings, state) {
+/** Resolve footer hints from the Inspector's current mode and user bindings. */
+export function resolveInspectorKeyHints(keymap, bindings, state) {
     const hints = [];
     for (const binding of keymap) {
-        if (!binding.hint)
+        if (!binding.hint || (binding.when && !binding.when(state)))
             continue;
-        if (binding.when && !binding.when(state))
+        if (bindings.gestures(binding.bindingId).length === 0)
             continue;
-        if ('bindingId' in binding) {
-            if (bindings.gestures(binding.bindingId).length === 0)
-                continue; // disabled: no hint
-            hints.push({ keys: formatBinding(bindings, binding.bindingId), label: binding.hint.label });
-        }
-        else if ('capture' in binding) {
-            hints.push('keys' in binding.hint ? binding.hint : { keys: 'type', label: binding.hint.label });
-        }
-        else {
-            hints.push(binding.hint);
-        }
+        hints.push({ keys: formatBinding(bindings, binding.bindingId), label: binding.hint.label });
     }
     return hints;
 }
-/** The first non-capture binding whose key matches and whose `when` (if any)
- * passes — catalog IDs use the terminal matcher; custom literals retain their
- * presenter-authored matching. */
-export function matchViewBinding(keymap, bindings, input, key, state, raw = { ...key, input }) {
-    const tokens = keyTokens(input, key);
+/** Match the first active Inspector action claimed by the input. */
+export function matchInspectorBinding(keymap, bindings, state, raw) {
     for (const binding of keymap) {
-        if ('capture' in binding)
-            continue;
         if (binding.when && !binding.when(state))
             continue;
-        const matches = 'bindingId' in binding
-            ? matchesTerminalInput(bindings, binding.bindingId, raw)
-            : binding.keys.some((literal) => tokens.includes(literal));
-        if (matches)
+        if (matchesTerminalInput(bindings, binding.bindingId, raw)) {
             return { intent: binding.intent, payload: binding.payload ? binding.payload(state) : undefined };
+        }
     }
     return null;
 }
-/** Match a host-owned generic-view action through the same catalog snapshot. */
-export function matchesViewHostBinding(bindings, id, raw) {
-    return matchesTerminalInput(bindings, id, raw);
-}
-/** The active text-capture binding for this state, if any (compose-mode entry). */
-function activeCapture(keymap, state) {
-    for (const b of keymap) {
-        if ('capture' in b && b.when(state))
-            return b;
-    }
-    return null;
-}
-/** Synthesize a one-line dump for a view that ships no text.mjs: `<title>` plus
- *  ` — <n> items` if state has an obvious top-level list. */
-function synthDump(title, state) {
-    if (state && typeof state === 'object') {
-        for (const v of Object.values(state)) {
-            if (Array.isArray(v))
-                return `${title} — ${v.length} items`;
-        }
-    }
-    return title;
+/** Match the Inspector host's exit action through the catalog snapshot. */
+export function matchesInspectorHostBinding(bindings, raw) {
+    return matchesTerminalInput(bindings, 'crtr.inspector.force-quit', raw);
 }
 /** Run a READ source / WRITE command through a transport → typed Result. */
 async function runRequest(transport, src, args) {
     const raw = await transport.send(src.request(args));
     return src.parse(raw);
 }
-/** Host a dual-target ViewCore + TuiPresenter in the alt screen until it quits
- *  (or Ctrl-C). `text` is the optional text presenter for the piped path. */
-export async function runCoreView(core, tui, text, opts = {}) {
+/** Host the Inspector until it quits, or emit its static text snapshot. */
+export async function runInspector(core, tui, text, opts = {}) {
     const options = Object.freeze({ ...(opts.options ?? {}) });
     const bindings = resolveUserKeybindings();
     const keybindingNotice = summarizeKeybindingDiagnostics(bindings.diagnostics);
-    const transport = createLocalTransport({ cwd: process.cwd() });
+    const transport = createInspectorTransport({ cwd: process.cwd() });
     // ── Non-TTY / piped path: init, best-effort refresh, dump, exit 0. ──
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         if (keybindingNotice)
@@ -402,7 +292,6 @@ export async function runCoreView(core, tui, text, opts = {}) {
             resolve: (s, a) => runRequest(transport, s, a),
             execute: (c, a) => runRequest(transport, c, a),
             signal: dsignal,
-            connect() { throw new Error('stream sources require an interactive view host'); },
             dispatch: async (name, payload) => { const it = core.intents[name]; if (it)
                 await it(dctx, payload); },
         };
@@ -413,7 +302,7 @@ export async function runCoreView(core, tui, text, opts = {}) {
             }
             catch { /* dump current state regardless */ }
         }
-        let out = text ? text.dump(dstate, { banner: dchrome.banner }) : synthDump(core.manifest.title, dstate);
+        let out = text.dump(dstate, { banner: dchrome.banner });
         if (!out.endsWith('\n'))
             out += '\n';
         process.stdout.write(out);
@@ -441,11 +330,9 @@ export async function runCoreView(core, tui, text, opts = {}) {
     const render = () => {
         const size = getTerminalSize();
         const { draw, frame } = createDraw(size, caps);
-        // Footer hints are re-derived per draw so they track the active mode
-        // (compose/react affordances appear only while their `when(state)` holds).
-        const chromeManifest = { ...core.manifest, keymap: resolveViewKeyHints(tui.keymap, bindings, state) };
+        const chromeManifest = { ...core.manifest, keymap: resolveInspectorKeyHints(tui.keymap, bindings, state) };
         const tickChrome = { ...chrome, tick };
-        const content = drawChrome(draw, size, chromeManifest, tickChrome);
+        const content = drawInspectorChrome(draw, size, chromeManifest, tickChrome);
         try {
             tui.render(state, draw, content);
         }
@@ -482,13 +369,6 @@ export async function runCoreView(core, tui, text, opts = {}) {
         while (dispatchQueue.length > 0) {
             dispatchQueue.shift().resolve();
         }
-        for (const channel of streams) {
-            try {
-                channel.close();
-            }
-            catch { /* best-effort */ }
-        }
-        streams.clear();
         stopBusyTick();
         cleanup();
         resolveLoop();
@@ -504,10 +384,8 @@ export async function runCoreView(core, tui, text, opts = {}) {
     // The single-flight busy lane lives in the external FIFO. Refresh timers skip
     // while busy; ctx.dispatch from inside an intent runs inline so chained intents
     // do not deadlock. Keystrokes QUEUE behind an in-flight intent (up to a small
-    // depth) rather than vanishing: a view whose auto-refresh shells out is busy a
-    // real fraction of the time, and silently swallowing a `y` confirmation or a
-    // cursor move is the difference between a live surface and a deaf one.
-    const streams = new Set();
+    // depth) rather than vanishing: Inspector auto-refresh shells out, and silently
+    // swallowing a confirmation or cursor move would make the screen feel deaf.
     let busy = false;
     let dispatching = false;
     const dispatchQueue = [];
@@ -523,26 +401,6 @@ export async function runCoreView(core, tui, text, opts = {}) {
             set(next) { state = typeof next === 'function' ? next(state) : next; render(); },
             resolve: (s, a) => runRequest(transport, s, a),
             execute: (c, a) => runRequest(transport, c, a),
-            connect(source, args) {
-                let channel;
-                channel = transport.open(source.request(args), {
-                    onFrame(frame) {
-                        void enqueueDispatch(source.onFrame, frame);
-                    },
-                    onClose(reason) {
-                        streams.delete(channel);
-                        if (source.onClose)
-                            void enqueueDispatch(source.onClose, { reason, channelId: channel.id });
-                    },
-                    onError(err) {
-                        signal.setBanner(err.display.headline, err.display.level);
-                    },
-                });
-                streams.add(channel);
-                if (source.onOpen)
-                    void enqueueDispatch(source.onOpen, channel);
-                return channel;
-            },
             signal,
             dispatch: (name, payload) => runIntentInline(name, payload),
         };
@@ -625,7 +483,7 @@ export async function runCoreView(core, tui, text, opts = {}) {
             void drainDispatchQueue();
         });
     }
-    // ── Mount: init → loading frame → first refresh (if the view has one). ──
+    // ── Mount: init → loading frame → first refresh. ──
     setupTerminal();
     render();
     if (core.intents['refresh'])
@@ -633,9 +491,6 @@ export async function runCoreView(core, tui, text, opts = {}) {
     // Keystroke-dispatch backlog depth (see onData).
     const MAX_QUEUED_KEYS = 2;
     let queuedKeys = 0;
-    // Capture-mode buffer: the host's line-editor draft while a `capture` binding's
-    // when(state) is true; reset to '' whenever no capture binding is active.
-    let captureBuf = '';
     if (typeof core.manifest.refreshMs === 'number' && core.manifest.refreshMs > 0) {
         loopTimer = setInterval(() => { if (!busy)
             void enqueueDispatch('refresh'); }, core.manifest.refreshMs);
@@ -643,44 +498,23 @@ export async function runCoreView(core, tui, text, opts = {}) {
     const onData = async (data) => {
         if (done)
             return;
-        let parsed;
+        let raw;
         try {
-            parsed = parseViewKeypress(data, bindings);
+            raw = parseInspectorInput(data, bindings);
         }
         catch {
             return;
         }
-        const { input, key, raw } = parsed;
         // The catalog-backed escape hatch works even mid-flight.
-        if (matchesViewHostBinding(bindings, 'crtr.view.host.force-quit', raw)) {
+        if (matchesInspectorHostBinding(bindings, raw)) {
             finish();
             return;
         }
-        // Queue behind an in-flight intent, but shallowly: past a couple of pending
-        // keys the user is hammering a stuck view, and replaying the backlog later
-        // would act on a screen they never saw.
+        // Keep the input backlog shallow so delayed actions never replay against a
+        // substantially newer Inspector frame.
         if (busy && queuedKeys >= MAX_QUEUED_KEYS)
             return;
-        // Text-capture: while a capture binding is active, printable/backspace edit
-        // the host buffer and dispatch capture(nextDraft); other keys (return/escape)
-        // fall through to the keymap so submit/cancel can be bound.
-        const cap = activeCapture(tui.keymap, state);
-        if (cap) {
-            if (matchesViewHostBinding(bindings, 'crtr.view.host.editor.backspace', raw)) {
-                captureBuf = captureBuf.slice(0, -1);
-                await enqueueDispatch(cap.capture, captureBuf);
-                return;
-            }
-            if (isPrintable(input, key)) {
-                captureBuf += sanitizePrintable(input);
-                await enqueueDispatch(cap.capture, captureBuf);
-                return;
-            }
-        }
-        else {
-            captureBuf = '';
-        }
-        const m = matchViewBinding(tui.keymap, bindings, input, key, state, raw);
+        const m = matchInspectorBinding(tui.keymap, bindings, state, raw);
         if (!m)
             return;
         queuedKeys += 1;

package/dist/core/inspector/text.d.ts

@@ -1,5 +1,5 @@
-import type { TextPresenter } from '../view/contract.js';
+import type { InspectorText } from './contract.js';
 import type { InspectorState } from './core.js';
 /** The piped path: same information and grouping as the TUI, minus the glyphs
  *  and hue a pipe cannot carry. */
-export declare const inspectorText: TextPresenter<InspectorState>;
+export declare const inspectorText: InspectorText<InspectorState>;

package/dist/core/inspector/transport.d.ts

@@ -0,0 +1,6 @@
+import type { RawResponse, SourceRequest } from './contract.js';
+export declare function createInspectorTransport(options?: {
+    cwd?: string;
+}): {
+    send(request: SourceRequest): Promise<RawResponse>;
+};

package/dist/core/inspector/transport.js

@@ -0,0 +1,36 @@
+import { execFile } from 'node:child_process';
+const MAX_BUFFER = 10 * 1024 * 1024;
+export function createInspectorTransport(options = {}) {
+    const baseCwd = options.cwd ?? process.cwd();
+    return {
+        send(request) {
+            return new Promise((resolve) => {
+                const child = execFile(request.bin, request.args, { cwd: request.cwd ?? baseCwd, maxBuffer: MAX_BUFFER, encoding: 'utf8' }, (error, stdout, stderr) => {
+                    if (!error) {
+                        resolve({ ok: true, exitCode: 0, stdout, stderr });
+                        return;
+                    }
+                    const code = error.code;
+                    if (typeof code === 'number') {
+                        resolve({ ok: true, exitCode: code, stdout: stdout ?? '', stderr: stderr ?? '' });
+                        return;
+                    }
+                    const signal = error.signal;
+                    if (signal) {
+                        const detail = stderr && stderr.trim() !== ''
+                            ? stderr
+                            : `killed by signal ${signal}${signal === 'SIGKILL' ? ' (often out-of-memory)' : ''}`;
+                        resolve({ ok: true, exitCode: 1, stdout: stdout ?? '', stderr: detail });
+                        return;
+                    }
+                    const message = code === 'ENOENT' ? `${request.bin}: command not found` : error.message;
+                    resolve({ ok: false, stdout: stdout ?? '', stderr: message });
+                });
+                if (request.stdin !== undefined && child.stdin) {
+                    child.stdin.write(request.stdin);
+                    child.stdin.end();
+                }
+            });
+        },
+    };
+}

package/dist/core/inspector/tui.d.ts

@@ -1,3 +1,3 @@
-import type { TuiPresenter } from '../view/contract.js';
+import type { InspectorTui } from './contract.js';
 import type { InspectorState } from './core.js';
-export declare const inspectorTui: TuiPresenter<InspectorState>;
+export declare const inspectorTui: InspectorTui<InspectorState>;

package/dist/core/inspector/tui.js

@@ -269,20 +269,20 @@ export const inspectorTui = {
         draw.list({ ...content, row: content.row + 2, height: Math.max(0, content.height - 2) }, rows, cursor, state.scroll.schedule);
     },
     keymap: [
-        { bindingId: 'crtr.view.inspector.down', intent: 'down', hint: { label: 'move' } },
-        { bindingId: 'crtr.view.inspector.up', intent: 'up' },
-        { bindingId: 'crtr.view.inspector.section-next', intent: 'sectionNext', hint: { label: 'section' } },
-        { bindingId: 'crtr.view.inspector.section-prev', intent: 'sectionPrev' },
-        { bindingId: 'crtr.view.inspector.page-down', intent: 'pageDown' },
-        { bindingId: 'crtr.view.inspector.page-up', intent: 'pageUp' },
-        { bindingId: 'crtr.view.inspector.toggle-detail', intent: 'toggleDetail', when: (state) => (state.section === 'schedule' && state.selectedCronId !== null) || (state.section === 'jobs' && state.selectedJobId !== null), hint: { label: 'details' } },
-        { bindingId: 'crtr.view.inspector.cancel-item', intent: 'cancelItem', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'cancel' } },
-        { bindingId: 'crtr.view.inspector.cancel-item', intent: 'cancelItem', when: (state) => state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'stop job' } },
-        { bindingId: 'crtr.view.inspector.open-log', intent: 'openLog', when: (state) => state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'open log' } },
-        { bindingId: 'crtr.view.inspector.confirm', intent: 'confirm', when: (state) => state.pendingCancel !== null, hint: { label: 'confirm' } },
-        { bindingId: 'crtr.view.inspector.dismiss', intent: 'dismiss', hint: { label: 'dismiss' } },
-        { bindingId: 'crtr.view.inspector.retarget', intent: 'retarget', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'retarget' } },
-        { bindingId: 'crtr.view.inspector.refresh', intent: 'refresh', hint: { label: 'refresh' } },
-        { bindingId: 'crtr.view.inspector.quit', intent: 'quit', hint: { label: 'quit' } },
+        { bindingId: 'crtr.inspector.down', intent: 'down', hint: { label: 'move' } },
+        { bindingId: 'crtr.inspector.up', intent: 'up' },
+        { bindingId: 'crtr.inspector.section-next', intent: 'sectionNext', hint: { label: 'section' } },
+        { bindingId: 'crtr.inspector.section-prev', intent: 'sectionPrev' },
+        { bindingId: 'crtr.inspector.page-down', intent: 'pageDown' },
+        { bindingId: 'crtr.inspector.page-up', intent: 'pageUp' },
+        { bindingId: 'crtr.inspector.toggle-detail', intent: 'toggleDetail', when: (state) => (state.section === 'schedule' && state.selectedCronId !== null) || (state.section === 'jobs' && state.selectedJobId !== null), hint: { label: 'details' } },
+        { bindingId: 'crtr.inspector.cancel-item', intent: 'cancelItem', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'cancel' } },
+        { bindingId: 'crtr.inspector.cancel-item', intent: 'cancelItem', when: (state) => state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'stop job' } },
+        { bindingId: 'crtr.inspector.open-log', intent: 'openLog', when: (state) => state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'open log' } },
+        { bindingId: 'crtr.inspector.confirm', intent: 'confirm', when: (state) => state.pendingCancel !== null, hint: { label: 'confirm' } },
+        { bindingId: 'crtr.inspector.dismiss', intent: 'dismiss', hint: { label: 'dismiss' } },
+        { bindingId: 'crtr.inspector.retarget', intent: 'retarget', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'retarget' } },
+        { bindingId: 'crtr.inspector.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+        { bindingId: 'crtr.inspector.quit', intent: 'quit', hint: { label: 'quit' } },
     ],
 };

package/dist/core/keybindings/__tests__/inbox-affordance.test.js

@@ -8,7 +8,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { resolveKeybindings } from '../index.js';
-import { inboxOpenHint, inboxOpenInstruction, inboxPopupHint, inboxShortcut, } from '../inbox.js';
+import { inboxOpenHint, inboxHint, inboxOpenInstruction, inboxShortcut, } from '../inbox.js';
 const custom = () => resolveKeybindings({ 'crtr.tmux.inbox.toggle': ['alt+j'] });
 const multi = () => resolveKeybindings({ 'crtr.tmux.inbox.toggle': ['alt+i', 'alt+j'] });
 const disabled = () => resolveKeybindings({ 'crtr.tmux.inbox.toggle': [] });
@@ -22,17 +22,17 @@ test('inboxOpenHint mirrors the attach footer contract', () => {
     assert.equal(inboxOpenHint(resolveKeybindings()), 'Alt+I inbox');
     assert.equal(inboxOpenHint(custom()), 'Alt+J inbox');
     assert.equal(inboxOpenHint(multi()), 'Alt+I / Alt+J inbox');
-    assert.equal(inboxOpenHint(disabled()), 'hl inbox open');
+    assert.equal(inboxOpenHint(disabled()), 'crtr human list');
 });
-test('inboxPopupHint is a bare parenthetical token, CLI form when disabled', () => {
-    assert.equal(inboxPopupHint(resolveKeybindings()), 'Alt+I');
-    assert.equal(inboxPopupHint(custom()), 'Alt+J');
-    assert.equal(inboxPopupHint(multi()), 'Alt+I / Alt+J');
-    assert.equal(inboxPopupHint(disabled()), '`hl inbox open`');
+test('inboxHint is a bare parenthetical token, CLI form when disabled', () => {
+    assert.equal(inboxHint(resolveKeybindings()), 'Alt+I');
+    assert.equal(inboxHint(custom()), 'Alt+J');
+    assert.equal(inboxHint(multi()), 'Alt+I / Alt+J');
+    assert.equal(inboxHint(disabled()), '`crtr human list`');
 });
 test('inboxOpenInstruction is an imperative clause, CLI-only when disabled', () => {
-    assert.equal(inboxOpenInstruction(resolveKeybindings()), 'press Alt+I (or run `hl inbox open` at a terminal)');
-    assert.equal(inboxOpenInstruction(custom()), 'press Alt+J (or run `hl inbox open` at a terminal)');
-    assert.equal(inboxOpenInstruction(multi()), 'press Alt+I / Alt+J (or run `hl inbox open` at a terminal)');
-    assert.equal(inboxOpenInstruction(disabled()), 'run `hl inbox open` at a terminal');
+    assert.equal(inboxOpenInstruction(resolveKeybindings()), 'press Alt+I in a node viewer (or run `crtr human list` for the queue)');
+    assert.equal(inboxOpenInstruction(custom()), 'press Alt+J in a node viewer (or run `crtr human list` for the queue)');
+    assert.equal(inboxOpenInstruction(multi()), 'press Alt+I / Alt+J in a node viewer (or run `crtr human list` for the queue)');
+    assert.equal(inboxOpenInstruction(disabled()), 'run `crtr human list` for the queue');
 });

package/dist/core/keybindings/__tests__/resolve.test.js

@@ -25,33 +25,28 @@ function pairedAttachIds(pairs) {
 const REQUIRED_IDS = [
     'crtr.tmux.menu.open',
     'crtr.tmux.menu.attach',
-    ...pairedMenuIds(['promote', 'resume', 'fork', 'demote', 'detach', 'close-subtree', 'background-bash', 'file-review', 'pin', 'show', 'view-settings', 'fold-tools', 'metadata', 'context', 'providers', 'graph', 'focus-manager', 'copy-id', 'reload-viewer', 'issues', 'issue.idea', 'issue.bug']),
+    ...pairedMenuIds(['promote', 'resume', 'fork', 'demote', 'detach', 'close-subtree', 'background-bash', 'file-review', 'pin', 'show', 'view-settings', 'fold-tools', 'metadata', 'context', 'providers', 'graph', 'focus-manager', 'copy-id', 'reload-viewer', 'recap', 'issues', 'issue.idea', 'issue.bug']),
     ...ids('crtr.tmux.node', ['next', 'previous']),
     'crtr.tmux.inbox.toggle',
-    ...ids('crtr.tmux.view', ['next', 'previous']),
     ...pairedAttachIds([
         ['detach', 'crtr.attach.detach'],
         ['clear-or-detach', 'crtr.attach.clear-or-detach'],
-        ['mode-cycle', 'crtr.mode.cycle'],
         ['graph.toggle', 'crtr.attach.graph.toggle'],
+        ['help.toggle', 'crtr.attach.help.toggle'],
+        ['inbox.toggle', 'crtr.attach.inbox.toggle'],
         ['model-ladder.next', 'crtr.attach.model-ladder.next'],
         ['model-ladder.previous', 'crtr.attach.model-ladder.previous'],
         ['command.inspect', 'crtr.attach.command.inspect'],
         ['file-review', 'crtr.attach.file-review'],
         ['profile-files', 'crtr.attach.profile-files'],
+        ['whip', 'crtr.attach.whip'],
     ]),
+    ...ids('crtr.attach.scroll', ['up', 'down', 'page-up', 'page-down', 'live']),
+    'crtr.attach.mouse.toggle',
+    'crtr.attach.copy.message',
     ...ids('crtr.graph', ['down', 'up', 'first', 'last', 'collapse-or-manager', 'expand-or-child', 'focus', 'revive', 'focus-manager', 'close-subtree', 'dismiss']),
     ...ids('crtr.graph.confirm', ['accept', 'cancel']),
-    ...ids('crtr.view.host', ['force-quit', 'editor.backspace']),
-    ...ids('crtr.view.canvas', ['down', 'up', 'refresh', 'quit']),
-    ...ids('crtr.view.chat', ['submit', 'contextual-cancel', 'reconnect', 'quit']),
-    ...ids('crtr.view.git-pr', ['down', 'up', 'refresh', 'quit']),
-    ...ids('crtr.view.inbox', ['down', 'up', 'open', 'reply', 'react', 'filter', 'refresh', 'connect-linkedin', 'connect-gmail', 'quit', 'submit-reply', 'cancel', 'reaction-previous', 'reaction-next', 'submit-reaction']),
-    ...ids('crtr.view.linkedin', ['down', 'up', 'open', 'reply', 'react', 'refresh', 'quit', 'submit-reply', 'cancel', 'reaction-previous', 'reaction-next', 'submit-reaction']),
-    ...ids('crtr.view.prompt-review', ['down', 'up', 'compare-previous', 'compare-next', 'toggle-mode', 'expand', 'export', 'refresh', 'quit']),
-    ...ids('crtr.view.workspace-sidebar', ['down', 'up', 'open', 'refresh', 'quit']),
-    ...ids('crtr.view.inspector', ['down', 'up', 'section-next', 'section-prev', 'page-down', 'page-up', 'toggle-detail', 'cancel-item', 'open-log', 'confirm', 'dismiss', 'retarget', 'refresh', 'quit']),
-    ...ids('crtr.view-picker', ['down', 'up', 'run', 'quit']),
+    ...ids('crtr.inspector', ['force-quit', 'down', 'up', 'section-next', 'section-prev', 'page-down', 'page-up', 'toggle-detail', 'cancel-item', 'open-log', 'confirm', 'dismiss', 'retarget', 'refresh', 'quit']),
     ...ids('crtr.browse', ['quit', 'down', 'up', 'first', 'last', 'expand-or-child', 'collapse-or-parent', 'toggle-fold', 'tab-next', 'tab-previous', 'tab.1', 'tab.2', 'tab.3', 'tab.4', 'tab.5', 'close-subtree', 'confirm-close', 'sort', 'scope', 'profile', 'residents', 'preview', 'search', 'revive-now', 'focus', 'focus-background']),
     ...ids('crtr.browse.search', ['cancel', 'commit', 'delete', 'quit']),
     ...ids('crtr.profile.menu', ['up', 'down', 'select', 'accept-default', 'abort', 'slot.1', 'slot.2', 'slot.3', 'slot.4', 'slot.5', 'slot.6', 'slot.7', 'slot.8', 'slot.9', 'create', 'search-existing', 'use-root', 'set-default', 'add-directory', 'unpin']),
@@ -128,11 +123,9 @@ test('normalizes aliases, modifier order, uppercase printables, sequences, and d
     assert.equal(canonicalTerminalStroke({ input: '+', ctrl: true }), 'ctrl++');
     const resolved = resolveKeybindings({
         'crtr.attach.graph.toggle': ['M-X', 'alt+x'],
-        'crtr.tmux.view.next': ['M-V > ]', 'alt+v > ]'],
         'crtr.tmux.menu.promote': ['space'],
     });
     assert.deepEqual(resolved.gestures('crtr.attach.graph.toggle'), ['alt+shift+x', 'alt+x']);
-    assert.deepEqual(resolved.gestures('crtr.tmux.view.next'), ['alt+shift+v > ]', 'alt+v > ]']);
     assert.deepEqual(resolved.gestures('crtr.tmux.menu.promote'), ['space']);
 });
 test('terminal literal space matches named space bindings', () => {
@@ -145,23 +138,21 @@ test('invalid values and unknown IDs diagnose precisely while valid overrides st
         'crtr.unknown': ['x'],
         'crtr.graph.down': 'down',
         'crtr.attach.graph.toggle': ['alt+x'],
-        'crtr.tmux.view.next': ['alt+v'],
     });
     assert.equal(resolved.gestures('crtr.graph.down')[0], 'j');
     assert.deepEqual(resolved.gestures('crtr.attach.graph.toggle'), ['alt+x']);
-    assert.equal(resolved.gestures('crtr.tmux.view.next')[0], 'alt+v > ]');
     assert.deepEqual(new Set(resolved.diagnostics.map((item) => item.code)), new Set(['unknown-binding', 'invalid-override']));
 });
 test('colliding overrides fall back without affecting unrelated contexts', () => {
     const resolved = resolveKeybindings({
         'crtr.graph.down': ['k'],
-        'crtr.view.canvas.quit': ['x'],
+        'crtr.inspector.quit': ['z'],
         'crtr.attach.graph.toggle': ['alt+c'],
         'crtr.attach.detach': ['j'],
         'crtr.setup.list-down': ['space'],
     });
     assert.equal(resolved.gestures('crtr.graph.down')[0], 'j');
-    assert.deepEqual(resolved.gestures('crtr.view.canvas.quit'), ['x']);
+    assert.deepEqual(resolved.gestures('crtr.inspector.quit'), ['z']);
     assert.deepEqual(resolved.gestures('crtr.attach.graph.toggle'), ['alt+g']);
     assert.deepEqual(resolved.gestures('crtr.attach.detach'), ['ctrl+d']);
     assert.deepEqual(resolved.gestures('crtr.setup.list-down'), ['j', 'down']);