@north-light/crouter 0.3.161 → 0.3.163

package/dist/core/runtime/canvas-extensions.d.ts

@@ -4,6 +4,7 @@ export declare const CANVAS_RECAP_PATH: string;
 export declare const CANVAS_GOAL_CAPTURE_PATH: string;
 export declare const CANVAS_PASSIVE_CONTEXT_PATH: string;
 export declare const CANVAS_CONTEXT_INTRO_PATH: string;
+export declare const CANVAS_TOOL_GUIDE_PATH: string;
 export declare const CANVAS_DOC_SUBSTRATE_PATH: string;
 export declare const CANVAS_STRUCTURED_OUTPUT_PATH: string;
 export declare const CANVAS_BASH_VALVE_PATH: string;

package/dist/core/runtime/canvas-extensions.js

@@ -16,6 +16,7 @@ export const CANVAS_RECAP_PATH = resolveExtension('canvas-recap');
 export const CANVAS_GOAL_CAPTURE_PATH = resolveExtension('canvas-goal-capture');
 export const CANVAS_PASSIVE_CONTEXT_PATH = resolveExtension('canvas-passive-context');
 export const CANVAS_CONTEXT_INTRO_PATH = resolveExtension('canvas-context-intro');
+export const CANVAS_TOOL_GUIDE_PATH = resolveExtension('canvas-tool-guide');
 export const CANVAS_DOC_SUBSTRATE_PATH = resolveExtension('canvas-doc-substrate');
 export const CANVAS_STRUCTURED_OUTPUT_PATH = resolveExtension('canvas-structured-output');
 export const CANVAS_BASH_VALVE_PATH = resolveExtension('canvas-bash-valve');
@@ -32,6 +33,7 @@ export const CANVAS_EXTENSIONS = [
     CANVAS_GOAL_CAPTURE_PATH,
     CANVAS_PASSIVE_CONTEXT_PATH,
     CANVAS_CONTEXT_INTRO_PATH,
+    CANVAS_TOOL_GUIDE_PATH,
     CANVAS_DOC_SUBSTRATE_PATH,
     CANVAS_STRUCTURED_OUTPUT_PATH,
     CANVAS_BASH_VALVE_PATH,

package/dist/core/runtime/launch.d.ts

@@ -1,19 +1,8 @@
-export { CANVAS_EXTENSIONS, CANVAS_STOPHOOK_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_RECAP_PATH, CANVAS_GOAL_CAPTURE_PATH, CANVAS_PASSIVE_CONTEXT_PATH, CANVAS_CONTEXT_INTRO_PATH, CANVAS_DOC_SUBSTRATE_PATH, CANVAS_STRUCTURED_OUTPUT_PATH, CANVAS_BASH_VALVE_PATH, } from './canvas-extensions.js';
+export { CANVAS_EXTENSIONS, CANVAS_STOPHOOK_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_RECAP_PATH, CANVAS_GOAL_CAPTURE_PATH, CANVAS_PASSIVE_CONTEXT_PATH, CANVAS_CONTEXT_INTRO_PATH, CANVAS_TOOL_GUIDE_PATH, CANVAS_DOC_SUBSTRATE_PATH, CANVAS_STRUCTURED_OUTPUT_PATH, CANVAS_BASH_VALVE_PATH, } from './canvas-extensions.js';
 import type { NodeMeta, LaunchSpec, Mode, Lifecycle } from '../canvas/index.js';
 import type { ModelProvider, ModelStrength, ScopeConfig } from '../../types.js';
 export { OPENAI_PROVIDER_ENV, configuredLadderProviders, inferPortableModelSelection } from './model-selection.js';
 export type { PortableModelSelection } from './model-selection.js';
-export interface EquivalentProviderModel {
-    fromProvider: ModelProvider;
-    toProvider: ModelProvider;
-    strength: ModelStrength;
-    model: string;
-}
-/** Map a concrete ladder model back to its provider×strength cell, then return
- *  the other configured provider's model at the same strength. `failedProviders`
- *  is per-turn state: once a provider has produced a retryable outage error, do
- *  not bounce back to it or keep reattempting the same failed provider. */
-export declare function equivalentOtherProviderModel(currentModel: string, failedProviders?: ReadonlySet<ModelProvider>): EquivalentProviderModel | null;
 /** True when an explicit model token is QUALIFIED — a `<provider>/<model-id>`
  *  or `<provider>/<tier>` raw token — the structural marker of a concrete exact
  *  pick. Deliberately provider-agnostic: a real registry provider namespace
@@ -31,6 +20,10 @@ export declare function isProviderPinnedModelToken(model: string): boolean;
  *  ladder the running build ships, so they never freeze a stale concrete
  *  model id to disk. Mirrors `normalizeModel`'s branch structure exactly. */
 export declare function isPortableModelToken(model: string): boolean;
+export declare function logicalModelIntent(model: string, ladders?: ScopeConfig['modelLadders']): {
+    family: string;
+    strength: ModelStrength;
+} | undefined;
 export declare function normalizeModel(model: string, ladders?: ScopeConfig['modelLadders']): string;
 /** The interleaved model-ladder cycle Alt+M / Alt+Shift+M walks: for each strength tier
  *  from strongest to weakest, each offered provider before descending — anthropic/ultra,
@@ -95,6 +88,11 @@ export declare function buildLaunchSpec(kind: string, mode: Mode, opts: {
      *  promote/config, where `opts.model`'s shape IS the raw token and
      *  legitimately re-decides the pin. */
     modelProviderPinned?: boolean;
+    /** Preserved intent from an existing launch recipe when rebuilding it. */
+    modelIntent?: {
+        family: string;
+        strength: ModelStrength;
+    };
     /** Exact-consult launch: pass the captured `provider/id:thinking` spec
      *  verbatim as `launch.model`, skipping `floorReviewModel`/`normalizeModel`
      *  entirely (avoids any tier-collision reinterpretation). `opts.model` MUST

package/dist/core/runtime/launch.js

@@ -14,7 +14,7 @@ import { readMergedLaunchConfig } from '../config.js';
 import { LAUNCH_SYSTEM_PROMPT } from './launch-prompt.js';
 import { nodeEnv } from './nodes.js';
 import { editorLabel } from '../canvas/index.js';
-export { CANVAS_EXTENSIONS, CANVAS_STOPHOOK_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_RECAP_PATH, CANVAS_GOAL_CAPTURE_PATH, CANVAS_PASSIVE_CONTEXT_PATH, CANVAS_CONTEXT_INTRO_PATH, CANVAS_DOC_SUBSTRATE_PATH, CANVAS_STRUCTURED_OUTPUT_PATH, CANVAS_BASH_VALVE_PATH, } from './canvas-extensions.js';
+export { CANVAS_EXTENSIONS, CANVAS_STOPHOOK_PATH, CANVAS_INBOX_WATCHER_PATH, CANVAS_RECAP_PATH, CANVAS_GOAL_CAPTURE_PATH, CANVAS_PASSIVE_CONTEXT_PATH, CANVAS_CONTEXT_INTRO_PATH, CANVAS_TOOL_GUIDE_PATH, CANVAS_DOC_SUBSTRATE_PATH, CANVAS_STRUCTURED_OUTPUT_PATH, CANVAS_BASH_VALVE_PATH, } from './canvas-extensions.js';
 import { nodeDir } from '../canvas/paths.js';
 import { CANVAS_EXTENSIONS, mergeCanvasExtensions, assertMandatoryCanvasExtensions } from './canvas-extensions.js';
 import { modelLadders, defaultProvider, STRENGTH_ALIASES, MODEL_PROVIDER_KEYS, MODEL_STRENGTHS, THINKING_SUFFIXES, stripThinkingSuffix, } from './model-selection.js';
@@ -43,26 +43,7 @@ export { OPENAI_PROVIDER_ENV, configuredLadderProviders, inferPortableModelSelec
 function ladderFor(provider, ladders = modelLadders()) {
     return ladders[provider];
 }
-// Automatic turn-time fallback ordering + strength ranking stay local to the
-// launch recipe (not needed by the pure selection primitives).
-const FALLBACK_PROVIDER_KEYS = ['anthropic', 'openai'];
 const MODEL_STRENGTH_RANK = { light: 0, medium: 1, strong: 2, ultra: 3 };
-/** Map a concrete ladder model back to its provider×strength cell, then return
- *  the other configured provider's model at the same strength. `failedProviders`
- *  is per-turn state: once a provider has produced a retryable outage error, do
- *  not bounce back to it or keep reattempting the same failed provider. */
-export function equivalentOtherProviderModel(currentModel, failedProviders = new Set()) {
-    const ladders = modelLadders();
-    const cell = findLadderCell(normalizeModel(currentModel), ladders, FALLBACK_PROVIDER_KEYS);
-    if (cell === null)
-        return null;
-    if (failedProviders.has(cell.provider))
-        return null;
-    const toProvider = cell.provider === 'anthropic' ? 'openai' : 'anthropic';
-    if (failedProviders.has(toProvider))
-        return null;
-    return { fromProvider: cell.provider, toProvider, strength: cell.strength, model: ladders[toProvider][cell.strength] };
-}
 /** Back-map a concrete model spec to the provider×strength ladder cell it came
  *  from. Two cells may legitimately name the SAME model id at different thinking
  *  levels (the openai ladder's `ultra` and `strong` are both gpt-5.6-sol, at
@@ -147,7 +128,8 @@ function floorReviewModel(kind, requestedModel, kindModel, ladders = modelLadder
  *  (`ultra`) or bare family alias (`opus`/`sonnet`/`haiku`) has no `/` and
  *  stays unpinned. */
 export function isProviderPinnedModelToken(model) {
-    return model.includes('/');
+    // Logical family/strength refs express a preference, not provider exclusivity.
+    return model.includes('/') && !isPortableModelToken(model);
 }
 /** True when `model` is a PORTABLE ladder token — a bare strength/alias
  *  (`ultra`, `normal`, `opus`, …) or a `anthropic|openai / strength` pair —
@@ -165,6 +147,16 @@ export function isPortableModelToken(model) {
     }
     return STRENGTH_ALIASES[model] !== undefined || model === 'opus' || model === 'sonnet' || model === 'haiku';
 }
+export function logicalModelIntent(model, ladders = modelLadders()) {
+    const strength = modelTokenStrength(model);
+    if (strength === null)
+        return undefined;
+    if (model.includes('/'))
+        return { family: model.slice(0, model.indexOf('/')), strength };
+    if (model === 'opus' || model === 'sonnet' || model === 'haiku')
+        return { family: 'anthropic', strength };
+    return { family: defaultProvider(ladders), strength };
+}
 export function normalizeModel(model, ladders = modelLadders()) {
     // 1. Qualified provider/rest.
     if (model.includes('/')) {
@@ -265,10 +257,12 @@ export function buildLaunchSpec(kind, mode, opts) {
     const ladders = merged.modelLadders;
     const kindModel = mode === 'orchestrator' ? kindConfig?.orchestratorModel ?? kindConfig?.model : kindConfig?.model;
     const chosenModel = opts.modelExact === true ? opts.model : floorReviewModel(kind, opts.model, kindModel, ladders);
+    const intent = opts.modelExact === true ? undefined : (opts.modelIntent ?? (chosenModel !== undefined ? logicalModelIntent(chosenModel, ladders) : undefined));
     const launch = {
         model: opts.modelExact === true
             ? chosenModel
             : (chosenModel !== undefined ? normalizeModel(chosenModel, ladders) : undefined),
+        modelIntent: intent,
         modelProviderPinned: opts.modelProviderPinned !== undefined
             ? opts.modelProviderPinned
             : opts.model !== undefined && isProviderPinnedModelToken(opts.model),
@@ -276,7 +270,7 @@ export function buildLaunchSpec(kind, mode, opts) {
         tools: kindConfig?.tools ?? [],
         extensions: mergeCanvasExtensions([...CANVAS_EXTENSIONS, ...(kindConfig?.extensions ?? [])]),
         systemPrompt: LAUNCH_SYSTEM_PROMPT,
-        env: { ...(opts.extraEnv ?? {}) },
+        env: { ...(opts.extraEnv ?? {}), ...(intent ? { CRTR_MODEL_INTENT: `${intent.family}/${intent.strength}` } : {}) },
     };
     return { launch, lifecycle: opts.lifecycle };
 }

package/dist/core/runtime/managed-provider-cooling.d.ts

@@ -4,20 +4,6 @@ import type { AssistantMessageDiagnostic } from "@earendil-works/pi-ai";
 export declare const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
 /** Stable error code so a caller can recognize the typed error without message parsing. */
 export declare const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/**
- * Broker-owned, live policy exposed to the jiti-loaded provider-rotation
- * extension through its UI context. A callback (rather than a boot-time value)
- * is required because an attached viewer can pin or unpin the running broker
- * with `set_model`; the very next provider attempt must observe that decision.
- */
-export declare const MANAGED_PROVIDER_ROTATION_POLICY_UI: unique symbol;
-export type ManagedProviderRotationPolicy = {
-    allowCrossProviderFallback: boolean;
-    reason?: "provider-pinned" | "model-exact";
-};
-export type ManagedProviderRotationPolicyControl = () => ManagedProviderRotationPolicy;
-/** Non-broker/test hosts retain the historical permissive fallback policy. */
-export declare function readManagedProviderRotationPolicy(ui: unknown): ManagedProviderRotationPolicy;
 /** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
  *  the earliest future deadline (epoch ms) across those pools. */
 export declare class ManagedProviderCoolingError extends Error {

package/dist/core/runtime/managed-provider-cooling.js

@@ -16,25 +16,6 @@
 export const MANAGED_PROVIDER_COOLING_DIAGNOSTIC = "crtr:managed-provider-cooling";
 /** Stable error code so a caller can recognize the typed error without message parsing. */
 export const MANAGED_PROVIDER_COOLING_CODE = "managed_provider_cooling";
-/**
- * Broker-owned, live policy exposed to the jiti-loaded provider-rotation
- * extension through its UI context. A callback (rather than a boot-time value)
- * is required because an attached viewer can pin or unpin the running broker
- * with `set_model`; the very next provider attempt must observe that decision.
- */
-export const MANAGED_PROVIDER_ROTATION_POLICY_UI = Symbol.for("@crouton-kit/crtr:managed-provider-rotation-policy");
-/** Non-broker/test hosts retain the historical permissive fallback policy. */
-export function readManagedProviderRotationPolicy(ui) {
-    const control = ui?.[MANAGED_PROVIDER_ROTATION_POLICY_UI];
-    if (typeof control !== "function")
-        return { allowCrossProviderFallback: true };
-    try {
-        return control();
-    }
-    catch {
-        return { allowCrossProviderFallback: true };
-    }
-}
 /** Every managed provider pool tried this turn is cooling; `rateLimitedUntil` is
  *  the earliest future deadline (epoch ms) across those pools. */
 export class ManagedProviderCoolingError extends Error {

package/dist/core/runtime/model-swap.js

@@ -65,6 +65,12 @@ export function persistDormantModel(nodeId, spec, pinned) {
     const meta = getNode(nodeId);
     if (meta === null)
         return;
-    const launch = meta.launch !== undefined ? { ...meta.launch, model: spec, modelProviderPinned: pinned } : undefined;
+    const launch = meta.launch === undefined
+        ? undefined
+        : (() => {
+            const { modelIntent: _modelIntent, env, ...rest } = meta.launch;
+            const { CRTR_MODEL_INTENT: _intentEnv, ...remainingEnv } = env;
+            return { ...rest, model: spec, modelProviderPinned: pinned, env: remainingEnv };
+        })();
     updateNode(nodeId, { model_override: spec, ...(launch !== undefined ? { launch } : {}) });
 }

package/dist/core/runtime/promote.js

@@ -59,6 +59,7 @@ function reshapeNode(nodeId, opts = {}, beforePersist) {
         // just re-supplies the current value for resolution, not a new user
         // choice — so carry the node's existing pin verbatim instead.
         modelProviderPinned: opts.model === undefined ? node.launch?.modelProviderPinned : undefined,
+        modelIntent: opts.model === undefined ? node.launch?.modelIntent : undefined,
         // Resolve kind/ladder config against the NODE's own cwd + profile, not
         // this process's ambient scope.
         cwd: node.cwd,

package/dist/core/runtime/tmux.js

@@ -11,7 +11,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
+import { BINDING_CATALOG, formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
 import { bundledPiCommandForShell } from './pi-cli.js';
 import { surfaceTmuxStyleArgs } from './surface-bg.js';
 import { inboxToggleTmuxCommand } from '@crouton-kit/humanloop';
@@ -470,7 +470,7 @@ export function sendKeysEnter(pane, text) {
 // ---------------------------------------------------------------------------
 const TMUX_BINDING_MANIFEST = '@crtr_keybindings_manifest';
 const ROOT_TABLE = 'root';
-const MENU_ACTIONS = {
+const LEAF_MENU_ACTIONS = {
     'crtr.tmux.menu.promote': { description: 'promote to orchestrator', action: { kind: 'keys', keys: '/promote' } },
     'crtr.tmux.menu.resume': { description: 'resume node', action: { kind: 'keys', keys: '/resume-node' } },
     'crtr.tmux.menu.fork': { description: 'fork into idle root', action: { kind: 'direct', run: 'node fork --pane {pane}' } },
@@ -484,7 +484,6 @@ const MENU_ACTIONS = {
     'crtr.tmux.menu.file-review': { description: 'review a file', action: { kind: 'raw-keys', keys: 'M-S-r' } },
     'crtr.tmux.menu.metadata': { description: 'metadata', action: { kind: 'keys', keys: '/node-metadata' } },
     'crtr.tmux.menu.fold-tools': { description: 'fold finished tool calls', action: { kind: 'keys', keys: '/fold-tools' } },
-    'crtr.tmux.menu.view-settings': undefined,
     'crtr.tmux.menu.context': { description: 'context + reports', action: { kind: 'keys', keys: '/context' } },
     'crtr.tmux.menu.providers': { description: 'settings', action: { kind: 'popup', run: 'sys setup' } },
     'crtr.tmux.menu.graph': { description: 'graph view', action: { kind: 'keys', keys: '/graph' } },
@@ -492,16 +491,8 @@ const MENU_ACTIONS = {
     'crtr.tmux.menu.copy-id': { description: 'copy node id', action: { kind: 'command', run: 'surface node id --pane {pane}' } },
     'crtr.tmux.menu.reload-viewer': { description: 'reload viewer', action: { kind: 'direct', run: 'surface reload --pane {pane}' } },
     'crtr.tmux.menu.pin': { description: 'pin conversation', action: { kind: 'direct', run: 'surface node pin --pane {pane}' } },
-    'crtr.tmux.menu.open': undefined,
-    'crtr.tmux.menu.show': undefined,
-    'crtr.tmux.menu.issues': undefined,
-    'crtr.tmux.menu.issue.idea': undefined,
-    'crtr.tmux.menu.issue.bug': undefined,
-    'crtr.tmux.node.next': undefined,
-    'crtr.tmux.node.previous': undefined,
-    'crtr.tmux.inbox.toggle': undefined,
-    'crtr.tmux.view.next': undefined,
-    'crtr.tmux.view.previous': undefined,
+    'crtr.tmux.menu.issue.idea': { description: 'idea', action: { kind: 'popup', run: 'canvas issue new --type idea' } },
+    'crtr.tmux.menu.issue.bug': { description: 'bug', action: { kind: 'popup', run: 'canvas issue new --type bug' } },
 };
 function escapeTmuxFormats(value) {
     return value.replace(/#/g, '##');
@@ -512,34 +503,69 @@ function tmuxCommand(args) {
 function chordCommand(run, interactive = false) {
     const command = `crtr canvas chord --pane '#{pane_id}' --run ${shellQuote(escapeTmuxFormats(run))}${interactive ? ' --interactive' : ''}`;
     return interactive
-        ? `display-popup -E -w 60% -h 50% -d "#{pane_current_path}" ${shellQuote(command)}`
-        : `run-shell ${shellQuote(`${command} >/dev/null 2>&1`)}`;
+        ? {
+            argv: ['display-popup', '-E', '-w', '60%', '-h', '50%', '-d', '#{pane_current_path}', command],
+            menu: `display-popup -E -w 60% -h 50% -d "#{pane_current_path}" ${shellQuote(command)}`,
+        }
+        : {
+            argv: ['run-shell', `${command} >/dev/null 2>&1`],
+            menu: `run-shell ${shellQuote(`${command} >/dev/null 2>&1`)}`,
+        };
 }
-/** Dispatch a menu action straight to a `crtr` invocation, skipping the
+/** Dispatch an action straight to a `crtr` invocation, skipping the
  *  `canvas chord` hop entirely. Only sound for an action whose sole
  *  interpolation need is `{pane}` — tmux expands it natively as `#{pane_id}` at
- *  selection time (a real tmux format, substituted AFTER escaping the static
+ *  keypress time (a real tmux format, substituted AFTER escaping the static
  *  run text so the `#` here is never doubled), so chord's node-resolution
- *  round trip buys nothing. `-b` keeps the menu selection non-blocking. */
+ *  round trip buys nothing. `-b` keeps dispatch non-blocking. */
 function directCommand(run) {
     const argv = escapeTmuxFormats(run).replace('{pane}', '#{pane_id}');
-    return `run-shell -b ${shellQuote(`crtr ${argv} >/dev/null 2>&1`)}`;
+    const command = `crtr ${argv} >/dev/null 2>&1`;
+    return {
+        argv: ['run-shell', '-b', command],
+        menu: `run-shell -b ${shellQuote(command)}`,
+    };
 }
-function renderMenuAction(action) {
+/** One command constructor serves both display-menu selections and direct root
+ *  shortcuts. Each result carries the argv bind-key needs plus the stable menu
+ *  serialization existing Alt+C installs already use. */
+function menuActionCommand(action) {
     switch (action.kind) {
-        case 'disabled': return '';
-        case 'separator': return '';
+        case 'disabled': return null;
+        case 'separator': return null;
         // Choosing any menu item closes it; refresh-client is the deliberately
         // inert command that lets the prefix shortcut choose this close row.
-        case 'dismiss': return 'refresh-client';
-        case 'keys': return `send-keys -t '#{pane_id}' ${shellQuote(escapeTmuxFormats(action.keys))} Enter`;
-        case 'raw-keys': return `send-keys -t '#{pane_id}' ${shellQuote(escapeTmuxFormats(action.keys))}`;
+        case 'dismiss': return { argv: ['refresh-client'], menu: 'refresh-client' };
+        case 'keys': {
+            const keys = escapeTmuxFormats(action.keys);
+            return {
+                // A root binding already runs in the pressed key's pane context. Its
+                // target must stay implicit: bind-key does not expand `#{pane_id}` in
+                // send-keys' target argument. A menu command is serialized later and
+                // does need the pane captured when the menu opened.
+                argv: ['send-keys', keys, 'Enter'],
+                menu: `send-keys -t '#{pane_id}' ${shellQuote(keys)} Enter`,
+            };
+        }
+        case 'raw-keys': {
+            const keys = escapeTmuxFormats(action.keys);
+            return {
+                argv: ['send-keys', keys],
+                menu: `send-keys -t '#{pane_id}' ${shellQuote(keys)}`,
+            };
+        }
         case 'command': return chordCommand(action.run);
         case 'direct': return directCommand(action.run);
         case 'popup': return chordCommand(action.run, true);
-        case 'submenu': return tmuxCommand(buildMenuArgs(action.title, action.items));
+        case 'submenu': {
+            const argv = buildMenuArgs(action.title, action.items);
+            return { argv, menu: tmuxCommand(argv) };
+        }
     }
 }
+function renderMenuAction(action) {
+    return menuActionCommand(action)?.menu ?? '';
+}
 /** Visible width of a menu item name: style markup (`#[...]`) takes no cells. */
 function menuItemWidth(description) {
     return description.replace(/#\[[^\]]*\]/g, '').length;
@@ -573,8 +599,12 @@ function tmuxKey(stroke) {
     let key = parts.pop();
     const modifiers = new Set(parts);
     if (modifiers.has('shift') && key.length === 1 && /[a-z]/.test(key)) {
+        // tmux names a shifted printable with its uppercase character even when an
+        // extended-key terminal also preserves Shift as a modifier: Alt+Shift+F is
+        // `M-S-F`. Shift by itself needs only the uppercase character (`F`).
         key = key.toUpperCase();
-        modifiers.delete('shift');
+        if (!modifiers.has('ctrl') && !modifiers.has('alt'))
+            modifiers.delete('shift');
     }
     key = TMUX_NAMED_KEYS[key] ?? key;
     const prefix = [
@@ -589,34 +619,56 @@ function menuSelector(stroke) {
     const key = parts.at(-1);
     return parts.includes('shift') && /[a-z]/.test(key) ? key.toUpperCase() : key === 'space' ? ' ' : key;
 }
-function menuItems(bindings) {
-    const boundItems = (ids) => {
-        const items = [];
-        for (const id of ids) {
-            const entry = MENU_ACTIONS[id];
-            if (entry === undefined)
-                continue;
-            for (const gesture of bindings.gestures(id)) {
-                items.push({ description: entry.description, selector: menuSelector(gesture), action: entry.action });
-            }
-        }
-        return items;
-    };
-    const issueItems = [];
-    for (const [id, description, type] of [
-        ['crtr.tmux.menu.issue.idea', 'idea', 'idea'],
-        ['crtr.tmux.menu.issue.bug', 'bug', 'bug'],
-    ]) {
+function boundMenuItems(ids, entries, bindings) {
+    const items = [];
+    for (const id of ids) {
+        const entry = entries.get(id);
+        if (entry === undefined)
+            continue;
         for (const gesture of bindings.gestures(id)) {
-            issueItems.push({ description, selector: menuSelector(gesture), action: { kind: 'popup', run: `canvas issue new --type ${type}` } });
+            items.push({ description: entry.description, selector: menuSelector(gesture), action: entry.action });
         }
     }
-    const lifecycleItems = boundItems([
-        'crtr.tmux.menu.promote',
-        'crtr.tmux.menu.demote',
-        'crtr.tmux.menu.detach',
-        'crtr.tmux.menu.close-subtree',
-    ]);
+    return items;
+}
+/** Resolve the complete action descriptor set once. Submenu openers point at
+ *  the same child MenuItems the prefix menu renders, so their direct global
+ *  shortcuts cannot drift from the menu path. */
+function resolvedMenuActions(bindings) {
+    const entries = new Map();
+    for (const [id, entry] of Object.entries(LEAF_MENU_ACTIONS)) {
+        if (entry !== undefined)
+            entries.set(id, entry);
+    }
+    const showItems = boundMenuItems([
+        'crtr.tmux.menu.metadata',
+        'crtr.tmux.menu.context',
+    ], entries, bindings);
+    entries.set('crtr.tmux.menu.show', {
+        description: 'show ›',
+        action: { kind: 'submenu', title: ' show node ', items: showItems },
+    });
+    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
+    // is a toggle the viewer applies to its own render state (a `/`-command sent to
+    // the pane); a tmux menu is built once and cannot show live state, so the item
+    // reads as the action and the viewer answers with a notice.
+    const viewSettingsItems = boundMenuItems(['crtr.tmux.menu.fold-tools'], entries, bindings);
+    entries.set('crtr.tmux.menu.view-settings', {
+        description: 'view settings ›',
+        action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
+    });
+    const issueItems = boundMenuItems([
+        'crtr.tmux.menu.issue.idea',
+        'crtr.tmux.menu.issue.bug',
+    ], entries, bindings);
+    entries.set('crtr.tmux.menu.issues', {
+        description: 'create ›',
+        action: { kind: 'submenu', title: ' create ', items: issueItems },
+    });
+    return entries;
+}
+function menuItems(bindings, entries) {
+    const boundItems = (ids) => boundMenuItems(ids, entries, bindings);
     const items = [];
     const addGroup = (heading, groupItems) => {
         if (groupItems.length === 0)
@@ -625,41 +677,15 @@ function menuItems(bindings) {
             items.push({ description: '', selector: '', action: { kind: 'separator' } });
         items.push({ description: `-#[bold]${heading}`, selector: '', action: { kind: 'disabled' } }, ...groupItems);
     };
-    const showItems = boundItems([
-        'crtr.tmux.menu.metadata',
-        'crtr.tmux.menu.context',
-    ]);
-    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
-    // is a toggle the viewer applies to its own render state (a `/`-command sent to
-    // the pane); a tmux menu is built once and cannot show live state, so the item
-    // reads as the action and the viewer answers with a notice.
-    const viewSettingsItems = boundItems(['crtr.tmux.menu.fold-tools']);
-    const exploreItems = boundItems([
+    // Explore changes what is in view or opens a canvas-level browser. Current
+    // node acts on the agent in this pane without changing its lifecycle.
+    addGroup('Explore', boundItems([
         'crtr.tmux.menu.resume',
         'crtr.tmux.menu.graph',
         'crtr.tmux.menu.focus-manager',
-    ]);
-    if (showItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.show')) {
-            exploreItems.push({
-                description: 'show ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' show node ', items: showItems },
-            });
-        }
-    }
-    if (viewSettingsItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.view-settings')) {
-            exploreItems.push({
-                description: 'view settings ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
-            });
-        }
-    }
-    // Explore changes what is in view or opens a canvas-level browser. Current
-    // node acts on the agent in this pane without changing its lifecycle.
-    addGroup('Explore', exploreItems);
+        'crtr.tmux.menu.show',
+        'crtr.tmux.menu.view-settings',
+    ]));
     addGroup('Current node', boundItems([
         'crtr.tmux.menu.background-bash',
         'crtr.tmux.menu.file-review',
@@ -667,21 +693,17 @@ function menuItems(bindings) {
         'crtr.tmux.menu.copy-id',
         'crtr.tmux.menu.reload-viewer',
     ]));
-    addGroup('Lifecycle', [
-        ...boundItems(['crtr.tmux.menu.fork']),
-        ...lifecycleItems,
-    ]);
-    const systemItems = boundItems(['crtr.tmux.menu.providers']);
-    if (issueItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.issues')) {
-            systemItems.push({
-                description: 'create ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' create ', items: issueItems },
-            });
-        }
-    }
-    addGroup('System', systemItems);
+    addGroup('Lifecycle', boundItems([
+        'crtr.tmux.menu.fork',
+        'crtr.tmux.menu.promote',
+        'crtr.tmux.menu.demote',
+        'crtr.tmux.menu.detach',
+        'crtr.tmux.menu.close-subtree',
+    ]));
+    addGroup('System', boundItems([
+        'crtr.tmux.menu.providers',
+        'crtr.tmux.menu.issues',
+    ]));
     const prefixGestures = bindings.gestures('crtr.tmux.menu.open');
     if (prefixGestures.length > 0 && items.length > 0) {
         items.push({ description: '', selector: '', action: { kind: 'separator' } });
@@ -835,10 +857,24 @@ export function installTmuxBindings(bindings = resolveUserKeybindings()) {
         installed.push({ table, key });
         return true;
     };
-    const menuCommand = buildMenuArgs(' crtr ', menuItems(bindings));
+    const menuActions = resolvedMenuActions(bindings);
+    const menuCommand = buildMenuArgs(' crtr ', menuItems(bindings, menuActions));
     for (const gesture of bindings.gestures('crtr.tmux.menu.open')) {
         install(ROOT_TABLE, tmuxKey(gesture), menuCommand, 'crtr.tmux.menu.open', gesture);
     }
+    for (const definition of BINDING_CATALOG) {
+        if (definition.pair?.field !== 'menu')
+            continue;
+        const menuId = definition.id;
+        const globalId = definition.pair.pairedId;
+        const entry = menuActions.get(menuId);
+        const command = entry === undefined ? null : menuActionCommand(entry.action);
+        if (command === null)
+            throw new Error(`no direct tmux action for paired menu binding ${menuId}`);
+        for (const gesture of bindings.gestures(globalId)) {
+            install(ROOT_TABLE, tmuxKey(gesture), command.argv, globalId, gesture);
+        }
+    }
     for (const id of ['crtr.tmux.node.next', 'crtr.tmux.node.previous', 'crtr.tmux.inbox.toggle']) {
         for (const gesture of bindings.gestures(id))
             install(ROOT_TABLE, tmuxKey(gesture), actionCommand(id), id, gesture);

package/dist/core/scope.js

@@ -87,11 +87,10 @@ export function findProjectScopeRoot(startDir = process.cwd()) {
  *  nested under a directory tree that itself contains a `.crouter/` (e.g. a
  *  mock-VM home under the real host home) would sweep the host's `~/.crouter`
  *  (and any other above-HOME `.crouter`) in as a bogus project ancestor,
- *  leaking one machine's user-global memory into a nested-HOME node. Mirrors
- *  the on-read positional-walk fence (src/core/substrate/on-read.ts). A read
- *  whose start dir is outside HOME (e.g. a production VM with HOME=/root and no
- *  ancestor `.crouter`) never reaches home and walks to the filesystem root, as
- *  before. */
+ *  leaking one machine's user-global memory into a nested-HOME node. The
+ *  explicit file-context store discovery in substrate/on-read.ts applies the
+ *  same fence. A read whose start dir is outside HOME (e.g. a production VM
+ *  with HOME=/root and no ancestor `.crouter`) walks to the filesystem root. */
 function collectAncestorScopeRoots(startDir, userRoot) {
     const roots = [];
     const home = realpathOrSelf(homedir());