@north-light/crouter 0.3.170 → 0.3.172

package/dist/commands/sys/__tests__/setup-core.test.js

@@ -20,8 +20,10 @@ test('setup keybinding draft edits, disables, resets, and discards transactional
     const draft = new SetupKeybindingsDraft({ 'crtr.attach.graph.toggle': ['alt+x'] });
     assert.equal(draft.expression('crtr.attach.graph.toggle'), 'alt+x');
     assert.equal(draft.dirty, false);
-    assert.equal(draft.edit('crtr.attach.graph.toggle', 'M-Y, ctrl+g').ok, true);
-    assert.deepEqual(draft.overrides()['crtr.attach.graph.toggle'], ['alt+shift+y', 'ctrl+g']);
+    // M-U (not M-Y): alt+shift+y is now the crtr.attach.copy.message default, so
+    // the uppercase-normalization probe must use a gesture no catalog entry owns.
+    assert.equal(draft.edit('crtr.attach.graph.toggle', 'M-U, ctrl+g').ok, true);
+    assert.deepEqual(draft.overrides()['crtr.attach.graph.toggle'], ['alt+shift+u', 'ctrl+g']);
     assert.equal(draft.dirty, true);
     assert.equal(draft.unbind('crtr.attach.graph.toggle').ok, true);
     assert.deepEqual(draft.overrides()['crtr.attach.graph.toggle'], []);
@@ -34,9 +36,11 @@ test('setup keybinding draft edits, disables, resets, and discards transactional
 });
 test('setup keybinding draft binds the comma key, which doubles as the gesture separator', () => {
     const draft = new SetupKeybindingsDraft(undefined);
-    // A comma with nothing on one side is the comma KEY, not a separator.
-    assert.equal(draft.edit('crtr.tmux.menu.providers', ',').ok, true);
-    assert.deepEqual(draft.overrides()['crtr.tmux.menu.providers'], [',']);
+    // A comma with nothing on one side is the comma KEY, not a separator. Bound
+    // onto a menu selector whose default is NOT the comma (settings already
+    // defaults to it), so the draft records a real override.
+    assert.equal(draft.edit('crtr.tmux.menu.attach.whip', ',').ok, true);
+    assert.deepEqual(draft.overrides()['crtr.tmux.menu.attach.whip'], [',']);
     // A list containing the comma key round-trips through the rendered expression.
     assert.equal(draft.edit('crtr.attach.graph.toggle', ', , ctrl+g').ok, true);
     assert.deepEqual(draft.overrides()['crtr.attach.graph.toggle'], [',', 'ctrl+g']);

package/dist/commands/sys/__tests__/setup-front-door.test.js

@@ -1,28 +1,18 @@
 // Run with: node --import tsx/esm --test src/commands/sys/__tests__/setup-front-door.test.ts
 //
-// M1 — `crtr sys setup` front-door reconciliation. Setup refreshes crouter's
-// tmux bindings (including the inbox toggle) and registers the single canvas
-// nodes root to owner 'crouter' so a resolved humanloop ticket can call back
-// into the asking node (both best-effort). The humanloop registry is
-// isolated with a temp XDG_STATE_HOME (see human-deliver.test.ts); the canvas is
-// isolated with a temp CRTR_HOME + HOME.
-//
-// Stage B-9: `reconcileInboxFrontDoor` no longer opens canvas.db — its node
-// enumeration goes through the crtrd API (`cliClient().listNodes()`). Each test
-// therefore stands up an in-process `createApiServer()` bound to the isolated
-// CRTR_HOME's unix socket; `cliClient()` (autostart on) connects to it, so no
-// real daemon is spawned. `spawnNode` still seeds the canvas rows the server
-// reads back.
+// M1 — `crtr sys setup` front-door reconciliation refreshes crouter's tmux
+// bindings, including the inbox toggle, as a best-effort operation. The fixture
+// isolates its canvas with a temporary CRTR_HOME + HOME and legacy binding state
+// with a temporary XDG_STATE_HOME.
 import { test, before, beforeEach, afterEach, after } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, realpathSync } from 'node:fs';
+import { existsSync, mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { listInboxRoots } from '@crouton-kit/humanloop';
 import { spawnNode } from '../../../core/runtime/nodes.js';
 import { closeDb } from '../../../core/canvas/index.js';
-import { apiSocketPath, nodesRoot } from '../../../core/canvas/paths.js';
+import { apiSocketPath } from '../../../core/canvas/paths.js';
 import { createApiServer } from '../../../daemon/api/server.js';
 import { reconcileInboxFrontDoor } from '../setup-core.js';
 import { sysSetupLeaf } from '../setup.js';
@@ -66,19 +56,6 @@ after(() => {
     delete process.env['CRTR_HOME'];
     delete process.env['XDG_STATE_HOME'];
 });
-test('reconcile registers the one canvas nodes root, regardless of how many node cwds exist', async () => {
-    // Node cwds no longer fan out into per-cwd roots: every bridge ticket lives
-    // under the canvas nodes root, so that single root is the whole contract.
-    const otherCwd = mkdtempSync(join(tmpdir(), 'crtr-setup-cwd-'));
-    spawnNode({ kind: 'general', parent: null, cwd: home, name: 'a' });
-    spawnNode({ kind: 'general', parent: null, cwd: home, name: 'b' });
-    spawnNode({ kind: 'general', parent: null, cwd: otherCwd, name: 'c' });
-    const { interactionRootsRegistered } = await reconcileInboxFrontDoor();
-    assert.equal(interactionRootsRegistered, 1, 'exactly one registration: the canvas nodes root');
-    const crouterRoots = listInboxRoots().filter((r) => r.owner === 'crouter');
-    assert.equal(crouterRoots.length, 1, 'no per-cwd roots linger in the humanloop registry');
-    assert.equal(crouterRoots[0]?.root, realpathSync(nodesRoot()), 'the registered root is the canvas nodes root');
-});
 test('invoking `crtr sys setup` (non-TTY leaf run) reconciles the front door', async () => {
     // Exercise the real control flow — sysSetupLeaf.run() → runSetup() →
     // reconcileInboxFrontDoor — not the helper directly. With no TTY the leaf
@@ -97,11 +74,6 @@ test('invoking `crtr sys setup` (non-TTY leaf run) reconciles the front door', a
         process.stdout.write = originalWrite;
         Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, configurable: true });
     }
-    const homeReal = realpathSync(home);
-    const crouterRoots = listInboxRoots().filter((r) => r.owner === 'crouter');
-    // registerCrouterRoot maps the node cwd to its workspace interactions dir
-    // under that cwd, so the registered root is rooted at the node's home.
-    assert.ok(crouterRoots.some((r) => r.root.startsWith(homeReal)), 'the leaf invocation registered the node cwd as an owner-crouter interaction root');
 });
 test('reconcile refreshes the inbox tmux binding', async (t) => {
     if (spawnSync('tmux', ['-V']).status !== 0) {
@@ -118,7 +90,7 @@ test('reconcile refreshes the inbox tmux binding', async (t) => {
     try {
         await reconcileInboxFrontDoor();
         const binding = spawnSync('tmux', ['-S', socket, 'list-keys', '-T', 'root'], { encoding: 'utf8' }).stdout;
-        assert.match(binding, /bind-key\s+-T root M-i\s+run-shell.*hl inbox toggle/);
+        assert.match(binding, /bind-key\s+-T root M-i\s+run-shell.*crtr human inbox toggle/);
     }
     finally {
         if (priorTmux === undefined)
@@ -128,10 +100,3 @@ test('reconcile refreshes the inbox tmux binding', async (t) => {
         spawnSync('tmux', ['-S', socket, 'kill-server'], { encoding: 'utf8' });
     }
 });
-test('reconcile is idempotent for owner crouter — re-running does not error and keeps the roots', async () => {
-    spawnNode({ kind: 'general', parent: null, cwd: home, name: 'a' });
-    await reconcileInboxFrontDoor();
-    const { interactionRootsRegistered } = await reconcileInboxFrontDoor();
-    assert.equal(interactionRootsRegistered, 1);
-    assert.ok(listInboxRoots().some((r) => r.owner === 'crouter'));
-});

package/dist/commands/sys/config.js

@@ -41,6 +41,16 @@ function assertUserScopeBrokerThresholds(key, scope) {
         throw usage('brokerThresholds are available only in user scope');
     }
 }
+function assertWorkingGerundsScope(key, scope) {
+    if (key === 'working_gerunds' && scope !== 'user') {
+        throw usage('working_gerunds is available only in user scope');
+    }
+}
+function assertWhipMessagesScope(key, scope) {
+    if (key === 'whip_messages' && scope !== 'user') {
+        throw usage('whip_messages are available only in user scope');
+    }
+}
 function assertUserSettingScope(key, scope) {
     if (findUserSetting(key) !== undefined && scope !== 'user') {
         throw usage(`${key} is available only in user scope`);
@@ -80,6 +90,20 @@ function modelLadderPatch(key, rawValue) {
 function setNestedValue(cfg, key, rawValue, value) {
     const parts = key.split('.');
     const topKey = parts[0];
+    if (key === 'working_gerunds' || key === 'whip_messages') {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawValue);
+        }
+        catch {
+            throw usage(`${key} must be a JSON array of non-empty strings`);
+        }
+        if (!Array.isArray(parsed) || parsed.length === 0 || !parsed.every((entry) => typeof entry === 'string' && entry.trim() !== '')) {
+            throw usage(`${key} must be a non-empty JSON array of non-empty strings`);
+        }
+        cfg[key] = parsed.map((entry) => entry.trim());
+        return;
+    }
     if (topKey === 'keybindings') {
         throw usage('keybindings are edited only through `crtr sys setup`');
     }
@@ -152,13 +176,13 @@ const configGet = defineLeaf({
 const configSet = defineLeaf({
     name: 'set',
     description: 'write a config value by key',
-    whenToUse: 'you want to change a supported scalar crtr setting in user or project scope. Use sys setup instead for keybindings, and sys config get to inspect values.',
+    whenToUse: 'you want to change a supported crtr setting in user or project scope. Use sys setup instead for keybindings, and sys config get to inspect values.',
     help: {
         name: 'sys config set',
         summary: 'write a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: `Dotted key path. User-scope scalar settings: ${SCALAR_SETTING_HELP}. Also supported: brokerThresholds.warning and brokerThresholds.automaticReviveCap (user scope; integer >= 1), modelLadders.defaultProvider, and modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.` },
-            { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. Stored as-is if quoted; coerced to number or boolean when unambiguous.' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: `Dotted key path. User-scope scalar settings: ${SCALAR_SETTING_HELP}. Also supported: working_gerunds and whip_messages (non-empty JSON string arrays), brokerThresholds.warning and brokerThresholds.automaticReviveCap (user scope; integer >= 1), modelLadders.defaultProvider, and modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.` },
+            { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. working_gerunds and whip_messages accept JSON arrays; other values are stored as-is if quoted and coerced to number or boolean when unambiguous.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user. Project scope is supported only for modelLadders.' },
         ],
         output: [
@@ -174,6 +198,8 @@ const configSet = defineLeaf({
         const rawValue = input['value'];
         const scope = resolveScope(input['scope']);
         assertUserScopeBrokerThresholds(key, scope);
+        assertWorkingGerundsScope(key, scope);
+        assertWhipMessagesScope(key, scope);
         assertUserSettingScope(key, scope);
         // Flags are stringly-typed; coerce to number or boolean when unambiguous
         const parsed = parseConfigValue(rawValue);

package/dist/commands/sys/feedback.js

@@ -18,7 +18,7 @@ import { projectTier1Event, readLogSnapshot } from '../../core/events/read.js';
 import { readPackageVersion } from './shared.js';
 /** Canonical repo for crtr harness feedback — feedback is always about the
  *  tool, regardless of which project the reporting agent is working in. */
-const FEEDBACK_REPO = 'crouton-labs/crouter';
+const FEEDBACK_REPO = 'vallum-security/crouter';
 async function collectContext() {
     const env = process.env;
     const nodeId = env['CRTR_NODE_ID'] ?? null;

package/dist/commands/sys/setup-core.d.ts

@@ -1,5 +1,5 @@
 import { type BindingId, type BindingResolution, type KeybindingDiagnostic, type SparseKeybindingOverrides } from '../../core/keybindings/index.js';
-export type SetupPackageId = 'crtr-extensions' | 'mode-switch' | 'oauth-adapter' | 'capture-plugin';
+export type SetupPackageId = 'crtr-extensions' | 'oauth-adapter' | 'capture-plugin';
 /** `nerd-font` is not a command on PATH like the other two — it is an installed
  *  font face, detected by fontconfig/font-directory scan. The viewer renders
  *  every tool and command icon with Nerd Font codepoints, so without it a fresh
@@ -55,7 +55,6 @@ export interface SetupExecutionSummary {
     skipped: string[];
     exaKeyWritten: boolean;
     exaKeyPath: string;
-    interactionRootsRegistered: number;
 }
 export interface SetupInitialState {
     manifest: SetupPackageManifestEntry[];
@@ -75,10 +74,17 @@ export declare class SetupKeybindingsDraft {
     private baselineInvalidRoot;
     private invalidRoot;
     private resolutionCache;
-    constructor(rawKeybindings: unknown);
+    private expectedPassthrough;
+    private baselinePassthrough;
+    private currentPassthrough;
+    constructor(rawKeybindings: unknown, rawTmuxPassthrough?: unknown);
     get dirty(): boolean;
     overrides(): Record<string, unknown>;
     expectedKeybindings(): unknown;
+    tmuxPassthrough(): readonly BindingId[];
+    expectedTmuxPassthrough(): unknown;
+    usesTmuxPassthrough(id: BindingId): boolean;
+    toggleTmuxPassthrough(id: BindingId): void;
     resolution(): BindingResolution<BindingId>;
     /** True while the persisted `keybindings` root is a non-object (e.g. a string):
      *  edits cannot be layered onto an invalid root, so the tab must reset-all first. */
@@ -89,7 +95,7 @@ export declare class SetupKeybindingsDraft {
     resetRow(id: BindingId): void;
     resetAll(): void;
     discard(): void;
-    markSaved(overrides: SparseKeybindingOverrides<BindingId>): void;
+    markSaved(overrides: SparseKeybindingOverrides<BindingId>, tmuxPassthrough?: readonly BindingId[]): void;
 }
 export declare function buildSetupManifest(resolveBuiltinPackageDir?: (name: string) => string): SetupPackageManifestEntry[];
 export declare function normalizePackageIdentity(source: string, settingsDir: string, homeDir: string): SetupPackageIdentity;
@@ -123,12 +129,8 @@ export declare function buildSetupStaticInstructions(opts: {
 }): SetupStaticInstructions;
 export declare function renderSetupStaticInstructions(state: Pick<SetupInitialState, 'manifest' | 'installedPackageIds' | 'systemTools' | 'exaKeyPath'>): string;
 export declare function writeExaKey(exaKeyPath: string, exaKey: string): Promise<void>;
-/** Refresh crouter-owned tmux bindings and register the one canvas node root
- * with humanloop so every bridge ticket can call back into `human _deliver`.
- * Both are best-effort: setup must never fail because tmux or humanloop is unavailable. */
-export declare function reconcileInboxFrontDoor(): Promise<{
-    interactionRootsRegistered: number;
-}>;
+/** Refresh crouter-owned tmux bindings. Setup must never fail because tmux is unavailable. */
+export declare function reconcileInboxFrontDoor(): Promise<void>;
 export declare function summarizeSetupExecution(result: {
     installedPackages: string[];
     skippedPackages: string[];
@@ -136,7 +138,6 @@ export declare function summarizeSetupExecution(result: {
     skippedSystemDeps: string[];
     exaKeyWritten: boolean;
     exaKeyPath: string;
-    interactionRootsRegistered: number;
 }): SetupExecutionSummary;
 export declare function formatSetupExecutionSummary(summary: SetupExecutionSummary): string;
 export declare function executeSetupSubmission(submission: SetupSubmission): Promise<SetupExecutionSummary>;

package/dist/commands/sys/setup-core.js

@@ -9,9 +9,9 @@ import { builtinPiPackageDir } from '../../core/scope.js';
 import { readJsonIfExists } from '../../core/fs-utils.js';
 import { resolveBundledPiCliPath } from '../../core/runtime/pi-cli.js';
 import { installTmuxBindings } from '../../core/runtime/tmux-chrome.js';
+import { normalizeTmuxPassthrough } from '../../core/config.js';
 import { detectNerdFont, nerdFontInstallCommand, NERD_FONT_SELECT_HINT } from '../../core/runtime/nerd-font.js';
-import { globalHumanloopHealth, globalHumanloopInstallCommand } from '../../core/runtime/package-health.js';
-import { registerCrouterRoot } from '../human/shared.js';
+import { ensureRenderer, isRendererReady } from '../../core/termrender/termrender.js';
 import { installFromMarketplace } from '../pkg/plugin-manage.js';
 import { findPluginByName } from '../../core/resolver.js';
 function isKeybindingsObject(value) {
@@ -33,16 +33,23 @@ export class SetupKeybindingsDraft {
     baselineInvalidRoot;
     invalidRoot;
     resolutionCache;
-    constructor(rawKeybindings) {
+    expectedPassthrough;
+    baselinePassthrough;
+    currentPassthrough;
+    constructor(rawKeybindings, rawTmuxPassthrough = undefined) {
         this.expected = rawKeybindings;
         this.baseline = cloneKeybindings(rawKeybindings);
         this.current = cloneKeybindings(rawKeybindings);
         this.baselineInvalidRoot = rawKeybindings !== undefined && !isKeybindingsObject(rawKeybindings) ? rawKeybindings : undefined;
         this.invalidRoot = this.baselineInvalidRoot;
+        this.expectedPassthrough = rawTmuxPassthrough;
+        this.baselinePassthrough = normalizeTmuxPassthrough(rawTmuxPassthrough);
+        this.currentPassthrough = [...this.baselinePassthrough];
     }
     get dirty() {
         return !isDeepStrictEqual(this.current, this.baseline)
-            || !isDeepStrictEqual(this.invalidRoot, this.baselineInvalidRoot);
+            || !isDeepStrictEqual(this.invalidRoot, this.baselineInvalidRoot)
+            || !isDeepStrictEqual(this.currentPassthrough, this.baselinePassthrough);
     }
     overrides() {
         return cloneKeybindings(this.current);
@@ -50,6 +57,20 @@ export class SetupKeybindingsDraft {
     expectedKeybindings() {
         return this.expected;
     }
+    tmuxPassthrough() {
+        return [...this.currentPassthrough];
+    }
+    expectedTmuxPassthrough() {
+        return this.expectedPassthrough;
+    }
+    usesTmuxPassthrough(id) {
+        return this.currentPassthrough.includes(id);
+    }
+    toggleTmuxPassthrough(id) {
+        this.currentPassthrough = this.currentPassthrough.includes(id)
+            ? this.currentPassthrough.filter((candidate) => candidate !== id)
+            : [...this.currentPassthrough, id];
+    }
     resolution() {
         if (this.resolutionCache === undefined) {
             this.resolutionCache = resolveKeybindings(this.invalidRoot === undefined ? this.current : this.invalidRoot);
@@ -124,18 +145,23 @@ export class SetupKeybindingsDraft {
     }
     resetAll() {
         this.current = {};
+        this.currentPassthrough = [];
         this.invalidRoot = undefined;
         this.resolutionCache = undefined;
     }
     discard() {
         this.current = cloneKeybindings(this.baseline);
+        this.currentPassthrough = [...this.baselinePassthrough];
         this.invalidRoot = this.baselineInvalidRoot;
         this.resolutionCache = undefined;
     }
-    markSaved(overrides) {
+    markSaved(overrides, tmuxPassthrough = []) {
         this.expected = Object.keys(overrides).length === 0 ? undefined : cloneKeybindings(overrides);
         this.baseline = cloneKeybindings(overrides);
         this.current = cloneKeybindings(overrides);
+        this.expectedPassthrough = tmuxPassthrough.length === 0 ? undefined : [...tmuxPassthrough];
+        this.baselinePassthrough = [...tmuxPassthrough];
+        this.currentPassthrough = [...tmuxPassthrough];
         this.baselineInvalidRoot = undefined;
         this.invalidRoot = undefined;
         this.resolutionCache = undefined;
@@ -147,11 +173,6 @@ const PACKAGE_COPY = {
         shortDescription: 'crtr companion extensions — command palette, help gating, statusline, subscription/OAuth rotation, nested context.',
         longDescription: 'Bundles the extensions built for crtr: a crtr slash-command palette, crtr/crouter help gating, surfacing of Claude Code marketplace plugin commands, nested AGENTS.md/CLAUDE.md loading, a model/subscription/token statusline badge, OAuth login + rotation across multiple Claude subscriptions (provider-rotation), and system-prompt trimming. The OAuth/rotation piece is what lets crtr authenticate your Claude account.',
     },
-    'mode-switch': {
-        name: 'pi-mode-switch',
-        shortDescription: 'Alt+Shift+P cycles spec / plan / normal modes; injects mode-specific guidance on change.',
-        longDescription: 'Press Alt+Shift+P to rotate between three operating modes — spec (requirements gathering), plan (design before code), and normal (execution). Each switch appends mode-tailored guidance to keep the agent in the right gear.',
-    },
     'oauth-adapter': {
         name: 'pi-claude-oauth-adapter',
         shortDescription: 'Anthropic OAuth / Claude Code credential compatibility for pi.',
@@ -165,20 +186,17 @@ const PACKAGE_COPY = {
 };
 const PACKAGE_SOURCES = {
     'crtr-extensions': { kind: 'local-path', source: builtinPiPackageDir('pi-crtr-extensions') },
-    'mode-switch': { kind: 'local-path', source: builtinPiPackageDir('pi-mode-switch') },
     'oauth-adapter': { kind: 'npm', source: 'npm:pi-claude-oauth-adapter@0.1.2' },
     'capture-plugin': { kind: 'marketplace-plugin', source: 'crouter-official-marketplace/capture' },
 };
 const LOCAL_PACKAGE_NAME_ALIASES = {
     'crtr-extensions': ['pi-crtr-extensions'],
-    'mode-switch': ['pi-mode-switch'],
     'oauth-adapter': [],
     'capture-plugin': [],
 };
 export function buildSetupManifest(resolveBuiltinPackageDir = builtinPiPackageDir) {
     return [
         'crtr-extensions',
-        'mode-switch',
         'oauth-adapter',
         'capture-plugin',
     ].map((id) => {
@@ -452,7 +470,7 @@ export function renderSetupStaticInstructions(state) {
         '',
         instructions.exaLine,
         '',
-        `Inbox popup: the inbox-toggle key (${inboxShortcut() ?? 'disabled'}) is a crouter keybinding — view or rebind it in the \`crtr sys setup\` keybindings tab; it is installed on the same tmux server as every other crouter binding. \`crtr sys setup\` also registers known nodes' interaction roots (best-effort).`,
+        `Inbox: the inbox-toggle key (${inboxShortcut() ?? 'disabled'}) is a crouter keybinding — view or rebind it in the \`crtr sys setup\` keybindings tab; it is installed on the same tmux server as every other crouter binding.`,
         instructions.footer,
     ].join('\n') + '\n';
 }
@@ -468,38 +486,27 @@ function installPiPackage(source, piCliPath = resolveBundledPiCliPath()) {
         throw new Error(`pi install failed: ${source}`);
     }
 }
-/** Keep the PATH-global executable used by the tmux inbox binding at least as
- * new as crouter's bundled humanloop library. This is deliberately separate
- * from pi's companion package install: `hl` is a global npm binary, not a pi
- * package entry in settings.json. */
-function ensureGlobalHumanloop() {
-    if (globalHumanloopHealth().current)
-        return false;
-    const command = globalHumanloopInstallCommand();
-    process.stdout.write(`Updating global hl CLI: ${command}\n`);
-    runShellCommand(command);
-    return true;
+/** Provision the pinned termrender venv — crouter's one remaining out-of-tree
+ * dependency. Best-effort: a renderer that will not provision (no `uv`, no
+ * network) reports as skipped and never fails setup. */
+function ensureManagedRenderer() {
+    if (isRendererReady())
+        return 'current';
+    process.stdout.write('Provisioning the pinned termrender renderer…\n');
+    ensureRenderer();
+    return isRendererReady() ? 'provisioned' : 'unavailable';
 }
 export async function writeExaKey(exaKeyPath, exaKey) {
     await mkdir(dirname(exaKeyPath), { recursive: true });
     await writeFile(exaKeyPath, `${exaKey}\n`, 'utf8');
     await chmod(exaKeyPath, 0o600).catch(() => undefined);
 }
-/** Refresh crouter-owned tmux bindings and register the one canvas node root
- * with humanloop so every bridge ticket can call back into `human _deliver`.
- * Both are best-effort: setup must never fail because tmux or humanloop is unavailable. */
+/** Refresh crouter-owned tmux bindings. Setup must never fail because tmux is unavailable. */
 export async function reconcileInboxFrontDoor() {
     try {
         installTmuxBindings();
     }
     catch { /* best-effort: no tmux server */ }
-    try {
-        registerCrouterRoot();
-        return { interactionRootsRegistered: 1 };
-    }
-    catch {
-        return { interactionRootsRegistered: 0 };
-    }
 }
 export function summarizeSetupExecution(result) {
     return {
@@ -507,7 +514,6 @@ export function summarizeSetupExecution(result) {
         skipped: [...result.skippedPackages, ...result.skippedSystemDeps],
         exaKeyWritten: result.exaKeyWritten,
         exaKeyPath: result.exaKeyPath,
-        interactionRootsRegistered: result.interactionRootsRegistered,
     };
 }
 export function formatSetupExecutionSummary(summary) {
@@ -516,7 +522,6 @@ export function formatSetupExecutionSummary(summary) {
         summary.installed.length > 0 ? `installed: ${summary.installed.join(', ')}` : 'installed: none',
         summary.skipped.length > 0 ? `skipped: ${summary.skipped.join(', ')}` : 'skipped: none',
         summary.exaKeyWritten ? `exa key written: ${summary.exaKeyPath}` : 'exa key written: no',
-        `interaction roots registered: ${summary.interactionRootsRegistered}`,
     ].join('\n') + '\n';
 }
 /** Marketplace-plugin manifest entries already installed in any scope — the
@@ -572,18 +577,23 @@ export async function executeSetupSubmission(submission) {
         runShellCommand(plan.command);
         installedSystemDeps.push(plan.tool);
     }
-    if (ensureGlobalHumanloop())
-        installedPackages.push('global hl CLI');
-    else
-        skippedPackages.push('global hl CLI (current)');
+    switch (ensureManagedRenderer()) {
+        case 'provisioned':
+            installedPackages.push('termrender renderer');
+            break;
+        case 'current':
+            skippedPackages.push('termrender renderer (current)');
+            break;
+        case 'unavailable':
+            skippedPackages.push('termrender renderer (unavailable — install uv)');
+            break;
+    }
     const exaKeyWritten = submission.exaKey.trim() !== '';
     if (exaKeyWritten) {
         await writeExaKey(submission.exaKeyPath, submission.exaKey);
     }
-    // Front-door reconciliation: refresh the crouter-owned tmux bindings and
-    // register known nodes' interaction roots for `human _deliver`. Both are
-    // best-effort.
-    const { interactionRootsRegistered } = await reconcileInboxFrontDoor();
+    // Front-door reconciliation refreshes crouter-owned tmux bindings.
+    await reconcileInboxFrontDoor();
     return summarizeSetupExecution({
         installedPackages,
         skippedPackages,
@@ -591,6 +601,5 @@ export async function executeSetupSubmission(submission) {
         skippedSystemDeps,
         exaKeyWritten,
         exaKeyPath: submission.exaKeyPath,
-        interactionRootsRegistered,
     });
 }

package/dist/commands/sys/setup-wizard.d.ts

@@ -61,6 +61,7 @@ export declare class SetupWizard implements Component, Focusable {
     private keyDiagnostics;
     private keyConfirm;
     private keyNotice;
+    private keyTmuxOccupancy;
     private brokerLimitIndex;
     private brokerLimitNotice;
     private settingsIndex;
@@ -71,7 +72,7 @@ export declare class SetupWizard implements Component, Focusable {
     private _focused;
     onSubmit?: (submission: SetupSubmission) => void;
     onCancel?: () => void;
-    constructor(manifest: SetupPackageManifestEntry[], installedPackageIds: Set<SetupPackageId>, systemTools: SetupSystemToolState[], tui: TUI, agentDir: string, runtime: ModelRuntime, registry: ModelRegistry, openingBindings: BindingResolution<BindingId>, rawKeybindings: unknown, terminalRows: () => number);
+    constructor(manifest: SetupPackageManifestEntry[], installedPackageIds: Set<SetupPackageId>, systemTools: SetupSystemToolState[], tui: TUI, agentDir: string, runtime: ModelRuntime, registry: ModelRegistry, openingBindings: BindingResolution<BindingId>, rawKeybindings: unknown, terminalRows: () => number, rawTmuxPassthrough?: unknown);
     set focused(value: boolean);
     get focused(): boolean;
     invalidate(): void;
@@ -107,6 +108,8 @@ export declare class SetupWizard implements Component, Focusable {
     private filteredKeybindings;
     private selectedKeyRow;
     private selectedKeybinding;
+    private tmuxPassthroughOffer;
+    private toggleTmuxPassthrough;
     private moveKey;
     private moveKeyField;
     private keyViewportLines;