@north-light/crouter 0.3.170 → 0.3.172

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

@@ -14,10 +14,10 @@ import { readConfig, readRawConfigAtRoot, readRawScopeConfig, updateConfig, upda
 import { findProjectScopeRoots, userScopeRoot } from '../../core/scope.js';
 import { loadProfileManifest, profileRoot } from '../../core/profiles/manifest.js';
 import { USER_SETTINGS } from '../../core/user-settings.js';
-import { BINDING_CATALOG, formatBinding, formatGesture, matchesPiTuiInput, persistUserKeybindings, resolveKeybindings, KeybindingConcurrentEditError, KeybindingValidationError, } from '../../core/keybindings/index.js';
+import { BINDING_CATALOG, formatBinding, formatGesture, isAttachPaneBinding, matchesPiTuiInput, persistUserKeybindings, resolveKeybindings, KeybindingConcurrentEditError, KeybindingValidationError, } from '../../core/keybindings/index.js';
 import { configuredLadderProviders, inferPortableModelSelection } from '../../core/runtime/model-selection.js';
 import { cliClient } from '../api-client.js';
-import { installTmuxBindings } from '../../core/runtime/tmux-chrome.js';
+import { installTmuxBindings, occupiedTmuxRootGestures } from '../../core/runtime/tmux-chrome.js';
 const ANSI_GREEN = (s) => `\x1b[32m${s}\x1b[39m`;
 const ANSI_YELLOW = (s) => `\x1b[33m${s}\x1b[39m`;
 const theme = {
@@ -1316,6 +1316,7 @@ export class SetupWizard {
     keyDiagnostics = [];
     keyConfirm = null;
     keyNotice;
+    keyTmuxOccupancy;
     brokerLimitIndex = 0;
     brokerLimitNotice;
     settingsIndex = 0;
@@ -1326,7 +1327,7 @@ export class SetupWizard {
     _focused = false;
     onSubmit;
     onCancel;
-    constructor(manifest, installedPackageIds, systemTools, tui, agentDir, runtime, registry, openingBindings, rawKeybindings, terminalRows) {
+    constructor(manifest, installedPackageIds, systemTools, tui, agentDir, runtime, registry, openingBindings, rawKeybindings, terminalRows, rawTmuxPassthrough = undefined) {
         this.manifest = manifest;
         this.providers = new ProviderPanel(tui, agentDir, runtime, registry);
         // The panel drives OAuth async; bust our line cache when it transitions so the panel's
@@ -1338,7 +1339,7 @@ export class SetupWizard {
         this.systemTools = systemTools;
         this.terminalRows = terminalRows;
         this.openingBindings = openingBindings;
-        this.keyDraft = new SetupKeybindingsDraft(rawKeybindings);
+        this.keyDraft = new SetupKeybindingsDraft(rawKeybindings, rawTmuxPassthrough);
         this.keyDiagnostics = this.keyDraft.resolution().diagnostics;
         for (const entry of this.manifest)
             this.selectedPackageIds.add(entry.id);
@@ -1570,6 +1571,32 @@ export class SetupWizard {
     selectedKeybinding() {
         return this.selectedKeyRow()?.fields[this.keyFieldIndex]?.definition;
     }
+    tmuxPassthroughOffer() {
+        const definition = this.selectedKeybinding();
+        if (definition === undefined || !isAttachPaneBinding(definition))
+            return undefined;
+        const gestures = this.keyDraft.resolution().gestures(definition.id);
+        const expression = gestures.join('\u0000');
+        if (this.keyTmuxOccupancy?.id !== definition.id || this.keyTmuxOccupancy.expression !== expression) {
+            this.keyTmuxOccupancy = {
+                id: definition.id,
+                expression,
+                gestures: occupiedTmuxRootGestures(gestures),
+            };
+        }
+        const gesture = this.keyTmuxOccupancy.gestures[0];
+        return gesture === undefined ? undefined : { id: definition.id, gesture };
+    }
+    toggleTmuxPassthrough() {
+        const offer = this.tmuxPassthroughOffer();
+        if (offer === undefined)
+            return false;
+        this.keyDraft.toggleTmuxPassthrough(offer.id);
+        this.keyTmuxOccupancy = undefined;
+        this.keyNotice = undefined;
+        this.invalidate();
+        return true;
+    }
     moveKey(delta) {
         const rows = this.filteredKeybindings();
         if (rows.length === 0)
@@ -1662,8 +1689,10 @@ export class SetupWizard {
         try {
             const saved = persistUserKeybindings(this.keyDraft.overrides(), {
                 expectedKeybindings: this.keyDraft.expectedKeybindings(),
+                tmuxPassthrough: this.keyDraft.tmuxPassthrough(),
+                expectedTmuxPassthrough: this.keyDraft.expectedTmuxPassthrough(),
             });
-            this.keyDraft.markSaved(saved.overrides);
+            this.keyDraft.markSaved(saved.overrides, saved.tmuxPassthrough);
             this.keyNotice = 'Saved. Reload attach and reopen active views to apply changes; refreshing tmux…';
             // The config is already persisted; a tmux-refresh failure (installer throw)
             // must land in the notice, never as an unhandled rejection that tears down
@@ -1863,6 +1892,10 @@ export class SetupWizard {
             this.moveKey(this.keyPageSize());
             return;
         }
+        else if (this.matches('crtr.setup.toggle', data)) {
+            if (this.toggleTmuxPassthrough())
+                return;
+        }
         else if (this.matches('crtr.setup.keybindings.edit', data)) {
             this.beginKeyEdit();
             return;
@@ -2061,7 +2094,7 @@ export class SetupWizard {
                                         ? `type gestures separated by commas · ${this.label('crtr.setup.keybindings.commit-edit')} commit · ${this.label('crtr.setup.keybindings.cancel-edit')} cancel · ${this.label('crtr.setup.keybindings.page-up')}/${this.label('crtr.setup.keybindings.page-down')} scroll`
                                         : this.filteringKeys
                                             ? `filter: ${this.keyFilter || 'type to search'} · ${this.label('crtr.setup.keybindings.edit')} keep · ${this.label('crtr.setup.keybindings.filter-delete')} delete · ${this.label('crtr.setup.keybindings.filter-clear')} clear`
-                                            : `${this.label('crtr.setup.list-down')}/${this.label('crtr.setup.list-up')} move · ${this.label('crtr.setup.cell-previous')}/${this.label('crtr.setup.cell-next')} field · ${this.label('crtr.setup.keybindings.edit')} edit · ${this.label('crtr.setup.keybindings.unbind')} disable · ${this.label('crtr.setup.keybindings.reset-row')} reset · ${this.label('crtr.setup.keybindings.reset-all')} reset all · ${this.label('crtr.setup.keybindings.filter')} filter · ${this.label('crtr.setup.keybindings.save')} save · ${this.label('crtr.setup.keybindings.discard')} ${this.keyFilter !== '' ? 'clear filter' : 'discard'}`;
+                                            : `${this.label('crtr.setup.list-down')}/${this.label('crtr.setup.list-up')} move · ${this.label('crtr.setup.cell-previous')}/${this.label('crtr.setup.cell-next')} field · ${this.label('crtr.setup.keybindings.edit')} edit · ${this.tmuxPassthroughOffer() === undefined ? '' : `${this.label('crtr.setup.toggle')} tmux · `}${this.label('crtr.setup.keybindings.unbind')} disable · ${this.label('crtr.setup.keybindings.reset-row')} reset · ${this.label('crtr.setup.keybindings.reset-all')} reset all · ${this.label('crtr.setup.keybindings.filter')} filter · ${this.label('crtr.setup.keybindings.save')} save · ${this.label('crtr.setup.keybindings.discard')} ${this.keyFilter !== '' ? 'clear filter' : 'discard'}`;
         return [truncateToWidth(theme.fg('dim', line), width)];
     }
     renderProviders(width) {
@@ -2189,7 +2222,8 @@ export class SetupWizard {
             const row = rows[index];
             lines += (row.group !== previousGroup ? 1 : 0)
                 + this.keyRowBodyLineCount(row, index, resolution, width)
-                + (this.keyRowMessage(rows, index) ? 1 : 0);
+                + (this.keyRowMessage(rows, index) ? 1 : 0)
+                + (index === this.keyIndex && this.tmuxPassthroughOffer() !== undefined ? 1 : 0);
             previousGroup = row.group;
         }
         return lines;
@@ -2246,10 +2280,11 @@ export class SetupWizard {
                 ? editingFieldIndex
                 : selected ? Math.min(this.keyFieldIndex, row.fields.length - 1) : 0;
             const message = this.keyRowMessage(rows, index);
+            const tmuxOffer = selected ? this.tmuxPassthroughOffer() : undefined;
             const bodyLines = this.keyRowBodyLineCount(row, index, resolution, width);
             // Budget output lines (heading + responsive row + optional diagnostic) so
             // the list never clips the confirm prompt / notice / footer below it.
-            const cost = (row.group !== previousGroup ? 1 : 0) + bodyLines + (message ? 1 : 0);
+            const cost = (row.group !== previousGroup ? 1 : 0) + bodyLines + (message ? 1 : 0) + (tmuxOffer ? 1 : 0);
             if (emitted > 0 && emitted + cost > viewport)
                 break;
             if (row.group !== previousGroup) {
@@ -2320,6 +2355,12 @@ export class SetupWizard {
                     : '';
                 out.push(truncateToWidth(`${marker}${sourceMark} ${name} ${fieldsText}${description}`, width));
             }
+            if (tmuxOffer) {
+                const checked = this.keyDraft.usesTmuxPassthrough(tmuxOffer.id)
+                    ? theme.fg('success', '[x]')
+                    : theme.fg('dim', '[ ]');
+                out.push(truncateToWidth(`   ${checked} ${theme.fg('accent', `Use tmux's ${formatGesture(tmuxOffer.gesture)} here`)}`, width));
+            }
             if (message) {
                 const fieldPrefix = message.label === undefined ? '' : `${message.label}: `;
                 out.push(truncateToWidth(theme.fg('warning', `   ${fieldPrefix}${message.message}`), width));
@@ -2458,7 +2499,7 @@ export async function runSetup() {
     const openingBindings = resolveKeybindings(rawKeybindings);
     const terminal = new ProcessTerminal();
     const tui = new TUI(terminal, true);
-    const wizard = new SetupWizard(state.manifest, state.installedPackageIds, state.systemTools, tui, agentDir, runtime, registry, openingBindings, rawKeybindings, () => terminal.rows);
+    const wizard = new SetupWizard(state.manifest, state.installedPackageIds, state.systemTools, tui, agentDir, runtime, registry, openingBindings, rawKeybindings, () => terminal.rows, rawUserConfig?.tmux_passthrough);
     tui.addChild(wizard);
     tui.setFocus(wizard);
     await new Promise((resolve, reject) => {

package/dist/commands/sys/sync-deps.js

@@ -4,7 +4,7 @@
 // convention) into the owning project's OWN `.crouter/memory/deps/` as
 // substrate docs. This is the same one-way conversion door as the rest of
 // `sys sync` — SKILL.md never becomes an active runtime surface (see
-// `crtr memory read taste/document-substrate`). The lane's contract:
+// `crtr memory read insights/agent-memory/document-substrate`). The lane's contract:
 //
 //   • `deps/` is WHOLLY DERIVED state — wiped and regenerated from
 //     node_modules on every run (like node_modules itself), guarded by a

package/dist/commands/sys.js

@@ -1,5 +1,4 @@
-// `crtr sys` subtree: config {get,set,path}, doctor, sync, update, version.
-// Replaces old config.ts + doctor.ts + update.ts command files.
+// `crtr sys` subtree: configuration, diagnostics, and self-management.
 import { defineBranch } from '../core/command.js';
 import { configBranch } from './sys/config.js';
 import { daemonBranch } from './sys/daemon.js';
@@ -10,7 +9,6 @@ import { sysSetupLeaf } from './sys/setup.js';
 import { supportBranch } from './sys/support.js';
 import { sysSyspromptLeaf } from './sys/sysprompt.js';
 import { promptReviewLeaf } from './sys/prompt-review.js';
-import { sysPromptStudioLeaf } from './sys/promptstudio.js';
 import { sysSyncBranch } from './sys/sync.js';
 import { sysUpdateLeaf, sysVersionLeaf } from './sys/update.js';
 export function registerSys() {
@@ -18,13 +16,13 @@ export function registerSys() {
         name: 'sys',
         rootEntry: {
             concept: 'crtr configuration, diagnostics, and self-management',
-            desc: 'config, setup, doctor, sysprompt, prompt-review, promptstudio, sync, update, version, feedback, logs, support, daemon',
-            useWhen: 'managing the crtr installation, the crtrd supervisor process, or opening built-in system views',
+            desc: 'config, setup, doctor, sysprompt, prompt-review, sync, update, version, feedback, logs, support, daemon',
+            useWhen: 'managing the crtr installation, inspecting diagnostics, or operating the crtrd supervisor process',
         },
         help: {
             name: 'sys',
             summary: 'crtr system configuration, settings, diagnostics, and self-management',
         },
-        children: [configBranch, sysSetupLeaf, sysDoctorLeaf, sysSyspromptLeaf, promptReviewLeaf, sysPromptStudioLeaf, sysFeedbackLeaf, sysLogsLeaf, supportBranch, sysUpdateLeaf, sysVersionLeaf, sysSyncBranch, daemonBranch],
+        children: [configBranch, sysSetupLeaf, sysDoctorLeaf, sysSyspromptLeaf, promptReviewLeaf, sysFeedbackLeaf, sysLogsLeaf, supportBranch, sysUpdateLeaf, sysVersionLeaf, sysSyncBranch, daemonBranch],
     });
 }

package/dist/core/__tests__/broker-sdk-wiring.test.js

@@ -26,7 +26,7 @@ import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../runtime/broker-sdk.js';
-import { buildBrokerSession, makeBrokerUiContext, isLeadingEngineCommand, chooseGuidanceDeliveryMode, promptWithNextTurnGuidance, isHiddenJsonlBranchEntry, stripHiddenEntriesFromJsonlExport, engineLeadingCommandTokens, } from '../runtime/broker.js';
+import { buildBrokerSession, makeBrokerUiContext, isLeadingEngineCommand, resolveSteerCall, chooseGuidanceDeliveryMode, promptWithNextTurnGuidance, isHiddenJsonlBranchEntry, stripHiddenEntriesFromJsonlExport, engineLeadingCommandTokens, } from '../runtime/broker.js';
 import { CANVAS_EXTENSIONS } from '../runtime/launch.js';
 import { buildRefInventory } from '../memory/inline-ref-inventory.js';
 import { buildGuidance } from '../memory/inline-ref-guidance.js';
@@ -409,6 +409,11 @@ test('C5 — isLeadingEngineCommand truth table against structural stubs (pure,
     };
     assert.equal(isLeadingEngineCommand('/mytemplate', throwingExtButRealTemplate), true, 'a throwing extensionRunner check degrades to false for ITSELF but does not abort the template check');
 });
+test('a streaming extension command uses prompt preflight instead of the rejecting steer queue', () => {
+    const session = { extensionRunner: { getCommand: (name) => (name === 'recap' ? { name: 'recap' } : undefined) } };
+    assert.equal(resolveSteerCall('/recap', session), 'prompt');
+    assert.equal(resolveSteerCall('new information', session), 'steer');
+});
 test('C5 — isLeadingEngineCommand against a REAL session (registered extension command)', async () => {
     // Only the extension-command branch is driven against a REAL session here.
     // Skill/prompt-template discovery requires `session.bindExtensions(...)`

package/dist/core/__tests__/broker-snapshot-history.test.js

@@ -66,7 +66,15 @@ function assistantMsg(text, stopReason = 'stop') {
         timestamp: Date.now(),
     };
 }
-test('broker welcome snapshot serves the persisted history, not pi\u2019s sliced live array (omit-on-revive regression)', async () => {
+// 30s (approved in scripts/test-runner.mjs): this boot loads the REAL mandatory
+// canvas extension set from TypeScript sources, and those extensions pull the
+// crouter module graph through tsx for the first time in the process — ~6s of
+// the ~9s local runtime, and 12.6s total on a hosted runner, which blew the
+// ordinary 10s cap. The extension set is not decoration: booting the same
+// composition production boots is what makes `session.messages.length === 5` at
+// boot a real check that no canvas hook injects a message the persisted tree
+// lacks. Loading `[C3_EXT]` alone runs in ~2.3s but drops that coverage.
+test('broker welcome snapshot serves the persisted history, not pi\u2019s sliced live array (omit-on-revive regression)', { timeout: 30_000 }, async () => {
     const cwd = mkdtempSync(join(tmpdir(), 'crtr-snaphist-'));
     try {
         // 1. Build a real persisted session whose tail mimics an auto-retried turn:

package/dist/core/__tests__/dead-node-policy-table.test.js

@@ -19,7 +19,7 @@ function row(over = {}) {
         intent: null,
         pi_session_id: null,
         cycle_pending: null,
-        private_fork_phase: null,
+        fork_from: null,
         ...over,
     };
 }
@@ -59,12 +59,11 @@ test('row 7: a saved session with no crash markers resumes strictly; a pending c
     assert.equal(classifyDeadNode(row({ pi_session_id: 'sess', cycle_pending: true }), false), 'respawn-cycle');
     assert.equal(classifyDeadNode(row({ pi_session_id: 'sess', cycle_pending: false }), false), 'respawn-resume');
 });
-test('row 8: a private fork dead before binding its child session retries the immutable fork birth', () => {
-    assert.equal(classifyDeadNode(row({ private_fork_phase: 'fork_pending' }), false), 'respawn-fresh');
+test('row 8: an ordinary fork dead before binding its child session retries the immutable fork birth', () => {
+    assert.equal(classifyDeadNode(row({ fork_from: '/reviews/branch-point.jsonl' }), false), 'respawn-fresh');
 });
 test('row 9: sessionless with no fork claim — a fresh launch died before session_start — is a boot failure', () => {
     assert.equal(classifyDeadNode(row(), false), 'boot-failure');
-    assert.equal(classifyDeadNode(row({ private_fork_phase: 'session_started' }), false), 'boot-failure', 'a bound fork whose session identity was cleared for a fresh launch classifies like any fresh launch');
 });
 // ===========================================================================
 // retryResumeMode (pure) — ported verbatim from the deleted grace-clock suite.

package/dist/core/__tests__/fixtures/fake-engine.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';
 /** Test seams for prompt-scoped failures before session_start. The one-shot
  *  variant records its first failure per node so the next cycling retry can
  *  reach boot confirmation. */
@@ -165,8 +165,9 @@ declare class FakeSession {
     get model(): FakeModel | undefined;
     private currentModel;
     private currentThinkingLevel;
-    get thinkingLevel(): string | undefined;
-    setThinkingLevel(level: string): void;
+    get thinkingLevel(): ThinkingLevel | undefined;
+    setThinkingLevel(level: ThinkingLevel): void;
+    cycleThinkingLevel(): ThinkingLevel;
     private recordModel;
     setModel(model: FakeModel): Promise<void>;
     /** The broker's read-op picker data (buildListModelsData → registryOf(session))
@@ -256,7 +257,9 @@ interface FakeModelRuntime {
     getAvailable: () => Promise<FakeModel[]>;
     hasConfiguredAuth: (provider: string) => boolean;
     getError: () => string | undefined;
-    refresh: () => Promise<void>;
+    refresh: (options?: {
+        allowNetwork?: boolean;
+    }) => Promise<void>;
 }
 interface FakeServices {
     resourceLoader: ResourceLoader;
@@ -275,7 +278,7 @@ export declare function createAgentSessionFromServices(options: {
     services: FakeServices;
     sessionManager: SessionManager;
     model?: FakeModel;
-    thinkingLevel?: string;
+    thinkingLevel?: ThinkingLevel;
 }): Promise<{
     session: FakeSession;
 }>;

package/dist/core/__tests__/fixtures/fake-engine.js

@@ -356,7 +356,17 @@ class FakeSession {
         return this.currentThinkingLevel;
     }
     setThinkingLevel(level) {
+        if (this.currentThinkingLevel === level)
+            return;
         this.currentThinkingLevel = level;
+        this.emit({ type: 'thinking_level_changed', level });
+    }
+    cycleThinkingLevel() {
+        const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+        const current = this.currentThinkingLevel === undefined ? -1 : levels.indexOf(this.currentThinkingLevel);
+        const next = levels[(current + 1) % levels.length];
+        this.setThinkingLevel(next);
+        return next;
     }
     recordModel() {
         // Treat the unknown-stub as "no model" on the recorded surface (parity with
@@ -1110,7 +1120,20 @@ export async function createAgentSessionServices(options) {
     // Absent (the common case) → unchanged always-authenticated behavior.
     const home = (process.env['CRTR_HOME'] ?? '').trim();
     const noAuthSentinel = join(home, 'fake-pi.no-auth');
+    const unauthenticatedProviderSentinel = join(home, 'fake-pi.unauthenticated-provider');
     const zeroAuth = () => home !== '' && existsSync(noAuthSentinel);
+    const readUnauthenticatedProvider = () => {
+        try {
+            return readFileSync(unauthenticatedProviderSentinel, 'utf8').trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // Unlike the all-or-nothing no-auth seam, this mirrors ModelRuntime's cached
+    // configuredProviders snapshot: a provider-specific auth change becomes
+    // visible only after refresh() completes.
+    let unauthenticatedProvider = readUnauthenticatedProvider();
     return {
         resourceLoader: loader,
         modelRuntime: {
@@ -1124,9 +1147,12 @@ export async function createAgentSessionServices(options) {
             getAvailableSnapshot: () => (zeroAuth() ? [] : [FAKE_AVAILABLE_MODEL]),
             getAvailable: async () => (zeroAuth() ? [] : [FAKE_AVAILABLE_MODEL]),
             getModels: () => (zeroAuth() ? [] : FAKE_REGISTERED_MODELS),
-            hasConfiguredAuth: () => !zeroAuth(),
+            hasConfiguredAuth: (provider) => !zeroAuth() && provider !== unauthenticatedProvider,
             getError: () => undefined,
-            refresh: async () => { },
+            refresh: async () => {
+                await new Promise((resolve) => setImmediate(resolve));
+                unauthenticatedProvider = readUnauthenticatedProvider();
+            },
         },
     };
 }

package/dist/core/__tests__/full/broker-provider-retry.test.js

@@ -5,13 +5,14 @@
 // exercises runBroker's live retry handler rather than its helpers in isolation.
 import { test, before, after, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHeadlessHarness } from '../helpers/harness.js';
 import { createAttachKit } from '../helpers/broker-clients.js';
 import { defaultModelLaddersConfig } from '../../../types.js';
 import { readFault } from '../../runtime/fault.js';
-import { normalizeModel } from '../../runtime/launch.js';
+import { buildPiArgv, normalizeModel } from '../../runtime/launch.js';
+import { encodeFrame } from '../../runtime/broker-protocol.js';
 const MODEL_LADDERS = defaultModelLaddersConfig();
 function resolvedModel(spec) {
     const normalized = normalizeModel(spec, MODEL_LADDERS);
@@ -269,3 +270,87 @@ test('an explicit picker choice pins and clears prior logical routing; an intern
     assert.equal(after.launch?.modelProviderPinned, true, 'an internal no-raw-token change (cycle_ladder) preserves the existing pin verbatim');
     ctrl.close();
 });
+test("a user's Alt+M and Shift+Tab choices replace stale launch intent for restart replay", { timeout: 30_000 }, async () => {
+    const parent = h.spawnRoot('session choice durability parent');
+    seedPool('anthropic', false);
+    seedPool('openai-codex', false);
+    const child = await h.spawnHeadlessChild(parent, 'session choice durability child', { model: 'openai/strong' });
+    const before = h.node(child);
+    assert.deepEqual(before.launch?.modelIntent, { family: 'openai', strength: 'strong' }, 'fixture starts from a logical launch preference');
+    assert.equal(before.launch?.env.CRTR_MODEL_INTENT, 'openai/strong');
+    const ctrl = await kit.attach(child, 'controller', 'session-choice-durability');
+    ctrl.send({ type: 'cycle_ladder', direction: 'forward' });
+    await ctrl.waitFrame((f) => f.type === 'ack' && f.for === 'cycle_ladder', 'Alt+M cycle acked');
+    let after = h.node(child);
+    assert.equal(after.launch?.modelIntent, undefined, 'Alt+M replaces the old logical route intent');
+    assert.equal(after.launch?.env.CRTR_MODEL_INTENT, undefined, 'a restarted broker cannot resolve the old route over the selected rung');
+    assert.equal(after.launch?.model, after.model_override, 'the selected model and thinking rung is the durable revive recipe');
+    const rung = after.launch?.model;
+    assert.ok(rung, 'Alt+M persisted a concrete model rung');
+    const thinkingFrameOffset = ctrl.frames.length;
+    ctrl.send({ type: 'cycle_thinking' });
+    const thinkingChanged = await h.waitFor(() => ctrl.frames.slice(thinkingFrameOffset).find((f) => f.type === 'thinking_level_changed') ?? null, { label: 'Shift+Tab thinking change relayed' });
+    await ctrl.waitFrame((f) => f.type === 'ack' && f.for === 'cycle_thinking', 'Shift+Tab cycle acked');
+    after = h.node(child);
+    const level = thinkingChanged.type === 'thinking_level_changed' ? thinkingChanged.level : 'off';
+    const bareRung = rung.replace(/:(?:off|minimal|low|medium|high|xhigh|max)$/, '');
+    const expected = `${bareRung}${level === 'off' ? '' : `:${level}`}`;
+    assert.equal(after.launch?.model, expected, 'Shift+Tab persists the new thinking level with the selected model');
+    assert.equal(after.model_override, expected, 'polymorphs preserve the same user-selected model and thinking level');
+    const replay = buildPiArgv(after, { resumeSessionPath: after.pi_session_file ?? undefined });
+    const modelArg = replay.argv.indexOf('--model');
+    assert.notEqual(modelArg, -1, 'a daemon revive replays a model argument');
+    assert.equal(replay.argv[modelArg + 1], expected, 'the replayed model argument carries both choices');
+    assert.equal(replay.env.CRTR_MODEL_INTENT, undefined, 'the stale logical intent is absent from the restarted broker environment');
+    ctrl.close();
+});
+test('reload_auth restores a newly authenticated personal route before the next idle prompt', { timeout: 30_000 }, async () => {
+    const personal = { provider: 'personal-anthropic', id: 'claude-personal' };
+    const funded = { provider: 'northlight-openai', id: 'gpt-funded' };
+    const personalSpec = `${personal.provider}/${personal.id}:xhigh`;
+    const userConfigDir = join(h.agentHome, '.crouter');
+    const userConfigPath = join(userConfigDir, 'config.json');
+    const unauthenticatedProvider = join(h.home, 'fake-pi.unauthenticated-provider');
+    mkdirSync(userConfigDir, { recursive: true });
+    writeFileSync(userConfigPath, JSON.stringify({
+        modelRoutes: {
+            personal: { family: 'anthropic', credentialSource: 'user', providerId: personal.provider, models: { medium: personalSpec } },
+            funded: { family: 'anthropic', credentialSource: 'northlight', providerId: funded.provider, models: { medium: `${funded.provider}/${funded.id}:medium` } },
+        },
+        modelRouting: { credentialSourceOrder: ['user', 'northlight'], familyOrder: ['anthropic'], strengthFallback: ['medium'] },
+    }));
+    writeFileSync(unauthenticatedProvider, personal.provider);
+    try {
+        const parent = h.spawnRoot('auth route reconciliation parent');
+        const child = await h.spawnHeadlessChild(parent, 'auth route reconciliation child', { model: 'anthropic/medium' });
+        assert.deepEqual(model(child), funded, 'the logical request starts on the funded route while personal auth is absent');
+        const controller = await kit.connectRaw(child, { read: true });
+        controller.send({ type: 'hello', role: 'controller', client_id: 'auth-route-reconciliation' });
+        await h.waitFor(() => controller.frames.some((frame) => frame.type === 'welcome') ? true : null, { label: 'route reconciliation controller welcomed' });
+        rmSync(unauthenticatedProvider, { force: true });
+        const frameStart = controller.frames.length;
+        controller.writeRaw(encodeFrame({ type: 'reload_auth' })
+            + encodeFrame({ type: 'prompt', text: 'continue after login' }));
+        await h.waitFor(() => {
+            const frames = controller.frames.slice(frameStart);
+            const changed = frames.some((frame) => frame.type === 'model_changed' && frame.spec === personalSpec);
+            const started = frames.some((frame) => frame.type === 'agent_start');
+            return changed && started ? true : null;
+        }, { label: 'personal route adopted before queued prompt starts' });
+        const frames = controller.frames.slice(frameStart);
+        const modelChangedIndex = frames.findIndex((frame) => frame.type === 'model_changed' && frame.spec === personalSpec);
+        const agentStartIndex = frames.findIndex((frame) => frame.type === 'agent_start');
+        assert.ok(modelChangedIndex >= 0 && modelChangedIndex < agentStartIndex, 'route reconciliation completes before the next idle prompt starts');
+        assert.deepEqual(model(child), personal, 'the live session adopts the newly authenticated personal route');
+        const persisted = await h.waitFor(() => {
+            const node = h.node(child);
+            return node?.launch?.model === personalSpec ? node : null;
+        }, { label: 'personal route persisted without clearing logical intent' });
+        assert.deepEqual(persisted.launch?.modelIntent, { family: 'anthropic', strength: 'medium' });
+        assert.equal(persisted.launch?.env.CRTR_MODEL_INTENT, 'anthropic/medium', 'algorithmic reconciliation preserves the durable logical intent');
+    }
+    finally {
+        rmSync(unauthenticatedProvider, { force: true });
+        rmSync(userConfigPath, { force: true });
+    }
+});

package/dist/core/__tests__/full/broker-whip-interrupt.test.d.ts

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

package/dist/core/__tests__/full/broker-whip-interrupt.test.js

@@ -0,0 +1,39 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/full/broker-whip-interrupt.test.ts
+//
+// A whip is a transport-level abort-then-prompt, not an ordinary steering queue
+// entry. This needs a real broker because the guarantee crosses the socket frame,
+// broker dispatch, and pi session abort boundary.
+import { test, before, after, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { createHeadlessHarness } from '../helpers/harness.js';
+import { createAttachKit } from '../helpers/broker-clients.js';
+let h;
+let heldTurnBefore;
+const kit = createAttachKit(() => h);
+before(async () => {
+    heldTurnBefore = process.env['PI_FAKE_ENGINE_HOLD_TURN'];
+    process.env['PI_FAKE_ENGINE_HOLD_TURN'] = '1';
+    h = await createHeadlessHarness({ sessionPrefix: 'crtr-whip' });
+});
+after(async () => {
+    if (h !== undefined)
+        await h.dispose();
+    if (heldTurnBefore === undefined)
+        delete process.env['PI_FAKE_ENGINE_HOLD_TURN'];
+    else
+        process.env['PI_FAKE_ENGINE_HOLD_TURN'] = heldTurnBefore;
+});
+afterEach(() => {
+    kit.closeAll();
+});
+test('a whip aborts the active turn before starting its prompt', { timeout: 20_000 }, async () => {
+    const root = h.spawnRoot('broker-whip suite root');
+    const id = await h.spawnHeadlessChild(root, 'headless worker — held turn');
+    const controller = await kit.attach(id, 'controller', 'whip-controller');
+    assert.equal(controller.welcome.snapshot.state.isStreaming, true, 'the original turn is held active');
+    const startsBeforeWhip = controller.frames.filter((frame) => frame.type === 'agent_start').length;
+    const message = 'Whip command must start after the active turn is interrupted';
+    controller.send({ type: 'prompt', text: message, interrupt: true });
+    await h.waitFor(() => controller.frames.filter((frame) => frame.type === 'agent_start').length > startsBeforeWhip || null, { label: 'whip prompt started a new turn after the abort' });
+    assert.ok(controller.frames.some((frame) => frame.type === 'message_start' && JSON.stringify(frame).includes(message)), 'the whip message starts a fresh prompt rather than entering the steering queue');
+});

package/dist/core/__tests__/full/detach-focus.test.js

@@ -2,7 +2,7 @@
 //
 // `crtr node demote --detach` on a node with a live viewer (Alt+C → D).
 //
-// BROKER-CUT ADAPTATION (taste/broker-is-the-host, 2026-06-10): every node is a
+// BROKER-CUT ADAPTATION (insights/runtime/broker-is-the-host, 2026-06-10): every node is a
 // detached headless broker. After a09b71f a managed child opens NO viewer on
 // spawn — a viewer is opened on demand via `surface node focus`, registering
 // its `crtr surface attach` VIEWER pane in the focuses table. The engine is NOT in a pane, so the