@north-light/crouter 0.3.161 → 0.3.163

package/dist/core/__tests__/review-model-floor.test.js

@@ -68,7 +68,7 @@ test('review still permits equal-or-stronger explicit models', () => {
     assert.equal(spec('review', 'strong'), expected('strong'));
     assert.equal(spec('review', 'ultra'), expected('ultra'));
 });
-test('explicit provider-qualified overrides preserve their provider pin through launch construction', () => {
+test('concrete overrides stay pinned while logical provider/strength overrides remain unpinned', () => {
     const qualified = buildLaunchSpec('developer', 'base', {
         lifecycle: 'terminal', hasManager: true, cwd: home, profileId: null, model: 'anthropic/ultra',
     }).launch;
@@ -78,7 +78,7 @@ test('explicit provider-qualified overrides preserve their provider pin through
     const bare = buildLaunchSpec('developer', 'base', {
         lifecycle: 'terminal', hasManager: true, cwd: home, profileId: null, model: 'ultra',
     }).launch;
-    assert.equal(qualified.modelProviderPinned, true);
+    assert.equal(qualified.modelProviderPinned, false);
     assert.equal(exact.modelProviderPinned, true);
     assert.equal(bare.modelProviderPinned, false);
 });

package/dist/core/__tests__/revive.test.js

@@ -193,9 +193,9 @@ test('buildPiArgv restores mandatory canvas extensions when persisted launch met
     }
     assert.deepEqual(extensions.slice(0, required.size), mandatory, 'mandatory extensions are loaded first and once');
 });
-test('buildPiArgv replaces the historical stophook-first prefix without loading old-generation hooks twice', () => {
+test('buildPiArgv replaces the previous mandatory prefix with the current canvas hooks', () => {
     const historicalNames = [
-        'canvas-stophook', 'canvas-inbox-watcher', 'canvas-recap',
+        'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap',
         'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
         'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
     ];

package/dist/core/__tests__/tmux-surface.test.js

@@ -224,6 +224,7 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         const remapped = installTmuxBindings(resolveKeybindings({
             'crtr.tmux.menu.open': ['alt+shift+z'],
             'crtr.tmux.menu.graph': ['shift+z'],
+            'crtr.tmux.menu-global.fold-tools': ['alt+shift+f'],
             'crtr.tmux.node.next': [],
             'crtr.tmux.view.next': ['alt+z > n'],
             'crtr.tmux.view.previous': ['alt+z > p'],
@@ -231,10 +232,15 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         assert.equal(remapped.ok, true, JSON.stringify(remapped.diagnostics));
         assert.equal(tmuxBinding(socket, 'root', 'M-c'), null);
         assert.equal(tmuxBinding(socket, 'root', 'M-]'), null);
-        const menu = tmuxBinding(socket, 'root', 'M-Z') ?? '';
+        assert.equal(tmuxBinding(socket, 'root', 'M-F'), null);
+        assert.equal(tmuxBinding(socket, 'root', 'M-S-f'), null);
+        const foldTools = tmuxBinding(socket, 'root', 'M-S-F') ?? '';
+        assert.match(foldTools, /fold-tools/);
+        assert.doesNotMatch(foldTools, /#\{pane_id\}/);
+        const menu = tmuxBinding(socket, 'root', 'M-S-Z') ?? '';
         assert.match(menu, /graph view/);
         assert.match(menu, /Z/);
-        assert.match(menu, /"Alt\+Shift\+Z to close" M-Z refresh-client/);
+        assert.match(menu, /"Alt\+Shift\+Z to close" M-S-Z refresh-client/);
         const prefix = tmuxBinding(socket, 'root', 'M-z') ?? '';
         assert.match(prefix, /switch-client/);
         const again = installTmuxBindings(resolveKeybindings({
@@ -244,11 +250,11 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
             'crtr.tmux.view.previous': ['alt+z > p'],
         }));
         assert.equal(again.ok, true, JSON.stringify(again.diagnostics));
-        isolatedTmux(socket, ['bind-key', '-T', 'root', 'M-Z', 'display-message', 'user-owned']);
+        isolatedTmux(socket, ['bind-key', '-T', 'root', 'M-S-Z', 'display-message', 'user-owned']);
         const occupied = installTmuxBindings(resolveKeybindings({ 'crtr.tmux.menu.open': ['alt+shift+z'] }));
         assert.equal(occupied.ok, true);
         assert.ok(occupied.diagnostics.some((diagnostic) => diagnostic.code === 'occupied' && diagnostic.bindingId === 'crtr.tmux.menu.open'));
-        assert.match(tmuxBinding(socket, 'root', 'M-Z') ?? '', /user-owned/);
+        assert.match(tmuxBinding(socket, 'root', 'M-S-Z') ?? '', /user-owned/);
     }
     finally {
         if (priorTmux === undefined)

package/dist/core/__tests__/worktree.test.js

@@ -386,15 +386,15 @@ test('close still blocks on real .crouter/memory/ work — a tracked-file edit a
     run(['config', 'user.email', 'test@example.com'], memoryRepo);
     run(['config', 'user.name', 'Test'], memoryRepo);
     mkdirSync(join(memoryRepo, '.crouter', 'memory'), { recursive: true });
-    writeFileSync(join(memoryRepo, '.crouter', 'memory', 'AGENTS.md'), 'tracked memory doc\n');
+    writeFileSync(join(memoryRepo, '.crouter', 'memory', 'tracked.md'), 'tracked memory doc\n');
     run(['add', '.'], memoryRepo);
     run(['commit', '-m', 'init with tracked memory'], memoryRepo);
     const editNodeId = 'wt-real-crouter-memory-edit';
     const editWt = createManagedWorktree(memoryRepo, editNodeId);
     createNode(node(editNodeId, { cwd: editWt.path, managed_worktree: editWt }));
-    writeFileSync(join(editWt.path, '.crouter', 'memory', 'AGENTS.md'), 'edited tracked memory doc\n');
+    writeFileSync(join(editWt.path, '.crouter', 'memory', 'tracked.md'), 'edited tracked memory doc\n');
     const editStatus = gitSync(['status', '--porcelain'], editWt.path).stdout;
-    assert.ok(editStatus.includes('M .crouter/memory/AGENTS.md'), 'a tracked .crouter/memory/ edit must still show as modified — exclude can never hide a tracked-file change');
+    assert.ok(editStatus.includes('M .crouter/memory/tracked.md'), 'a tracked .crouter/memory/ edit must still show as modified — exclude can never hide a tracked-file change');
     assert.throws(() => closeManagedWorktree(editNodeId), (error) => error instanceof Error && 'code' in error && error.code === 'dirty_worktree');
     const newDocNodeId = 'wt-real-crouter-memory-new-doc';
     const newDocWt = createManagedWorktree(memoryRepo, newDocNodeId);

package/dist/core/auth-file.d.ts

@@ -20,8 +20,9 @@ export declare function readAuthCredentials(authPath?: string): Promise<AuthFile
 export declare function readAuthCredential(providerId: string, authPath?: string): Promise<Credential | undefined>;
 /** Persist one provider's credential under the auth.json lock, leaving every other entry intact. */
 export declare function setAuthCredential(providerId: string, credential: Credential, authPath?: string): Promise<void>;
-/** Remove one provider's credential (logout) under the auth.json lock. */
-export declare function deleteAuthCredential(providerId: string, authPath?: string): Promise<void>;
+/** Remove one provider's credential (logout) under the auth.json lock. Returns
+ * whether a record was removed from the exact snapshot this write replaced. */
+export declare function deleteAuthCredential(providerId: string, authPath?: string): Promise<boolean>;
 /**
  * The `CredentialStore` crouter hands to `ModelRuntime`. Backed directly by auth.json rather
  * than by an in-memory cache, so `modify` is a real cross-process read-modify-write: pi's

package/dist/core/auth-file.js

@@ -126,12 +126,14 @@ export async function setAuthCredential(providerId, credential, authPath = defau
         return { result: undefined, next: serialize(data) };
     });
 }
-/** Remove one provider's credential (logout) under the auth.json lock. */
+/** Remove one provider's credential (logout) under the auth.json lock. Returns
+ * whether a record was removed from the exact snapshot this write replaced. */
 export async function deleteAuthCredential(providerId, authPath = defaultAuthPath()) {
-    await new LockedJsonFile(authPath).withLockAsync(async (current) => {
+    return new LockedJsonFile(authPath).withLockAsync(async (current) => {
         const data = parse(current);
+        const removed = Object.hasOwn(data, providerId);
         delete data[providerId];
-        return { result: undefined, next: serialize(data) };
+        return { result: removed, next: serialize(data) };
     });
 }
 /**

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

@@ -1,4 +1,4 @@
-export declare const CANVAS_EXTENSION_NAMES: readonly ["canvas-inbox-watcher", "canvas-stophook", "canvas-recap", "canvas-goal-capture", "canvas-passive-context", "canvas-context-intro", "canvas-doc-substrate", "canvas-structured-output", "canvas-bash-valve"];
+export declare const CANVAS_EXTENSION_NAMES: readonly ["canvas-inbox-watcher", "canvas-stophook", "canvas-recap", "canvas-goal-capture", "canvas-passive-context", "canvas-context-intro", "canvas-tool-guide", "canvas-doc-substrate", "canvas-structured-output", "canvas-bash-valve"];
 /** Remove a complete persisted canvas prefix while retaining every genuine
  * caller/kind extra, including a custom extension whose basename happens to
  * resemble a canvas hook. */

package/dist/core/canvas/extensions.js

@@ -1,18 +1,28 @@
 // Canvas-extension identity is structural, not basename-based: old runtime roots
-// are recognized only when they carry the complete shipped canvas prefix.
+// are recognized only when they carry a complete shipped canvas prefix.
 // canvas-inbox-watcher must load before canvas-stophook: at agent_settled it
 // commits the cursor the stophook then reads to decide idle release.
 export const CANVAS_EXTENSION_NAMES = [
     'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap',
     'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
-    'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
+    'canvas-tool-guide', 'canvas-doc-substrate', 'canvas-structured-output',
+    'canvas-bash-valve',
 ];
-const LEGACY_CANVAS_EXTENSION_NAMES = [
-    'canvas-stophook', 'canvas-inbox-watcher', 'canvas-recap',
-    'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
-    'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
+const HISTORICAL_CANVAS_EXTENSION_PREFIXES = [
+    [
+        'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap',
+        'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
+        'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
+    ],
+    [
+        'canvas-stophook', 'canvas-inbox-watcher', 'canvas-recap',
+        'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
+        'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
+    ],
 ];
 function matchesExtensionPrefix(extensions, names) {
+    if (extensions.length < names.length)
+        return false;
     const paths = extensions.slice(0, names.length);
     const first = paths[0].replaceAll('\\', '/');
     const marker = '/pi-extensions/';
@@ -24,11 +34,8 @@ function matchesExtensionPrefix(extensions, names) {
     return names.every((name, index) => paths[index].replaceAll('\\', '/') === `${root}${name}${suffix}`);
 }
 function extensionPrefixLength(extensions) {
-    if (extensions.length < CANVAS_EXTENSION_NAMES.length)
-        return 0;
-    return matchesExtensionPrefix(extensions, CANVAS_EXTENSION_NAMES) || matchesExtensionPrefix(extensions, LEGACY_CANVAS_EXTENSION_NAMES)
-        ? CANVAS_EXTENSION_NAMES.length
-        : 0;
+    const prefixes = [CANVAS_EXTENSION_NAMES, ...HISTORICAL_CANVAS_EXTENSION_PREFIXES];
+    return prefixes.find((names) => matchesExtensionPrefix(extensions, names))?.length ?? 0;
 }
 /** Remove a complete persisted canvas prefix while retaining every genuine
  * caller/kind extra, including a custom extension whose basename happens to

package/dist/core/canvas/labels.d.ts

@@ -23,9 +23,8 @@ export declare function fullName(node: NamedNode): string;
  *  badge. */
 export declare function personaLabel(meta: Pick<NodeMeta, 'kind' | 'mode'>): string;
 /** The pi session display name — the editor label in the top-left. It carries
- *  ONE name: the pi-generated description of the node's first task once naming
- *  has run, else the spawn handle. Unlike `fullName` it never prints both, so
- *  the chip doesn't read as two names side by side. Persona lives in the
- *  editor's bottom-right badge. Recomputed from meta on every revive and pushed
- *  live when naming generates the first task description. */
+ *  ONE name: a person's explicit handle when present, otherwise the generated
+ *  description of the node's first task. Unlike `fullName` it never prints
+ *  both, so the chip doesn't read as two names side by side. Persona lives in
+ *  the editor's bottom-right badge. Recomputed from meta on every revive. */
 export declare function editorLabel(meta: NodeMeta): string;

package/dist/core/canvas/labels.js

@@ -2,9 +2,9 @@
 //
 // One source of truth for "what do we call this node on screen". `fullName`
 // combines the node's explicit handle (meta.name) with the pi-generated
-// description of its first task (meta.description) — the same string the editor
-// label, the canvas dashboard tree, the nav spine, and the tmux window tab all
-// render, so a node reads identically everywhere it appears.
+// description of its first task (meta.description) for canvas and tmux surfaces.
+// `editorLabel` keeps the editor chip compact by choosing the explicit handle
+// when a person supplied one, otherwise the generated description.
 /** Nerd Font glyph for a node's mode in its persona badge. A base worker reads
  *  as a single figure (nf-fa-user, U+F007); an orchestrator reads as a fan-out
  *  hierarchy (nf-fa-sitemap, U+F0E8). */
@@ -30,14 +30,14 @@ export function personaLabel(meta) {
     return `${modeIcon(meta.mode)} ${meta.kind}`;
 }
 /** The pi session display name — the editor label in the top-left. It carries
- *  ONE name: the pi-generated description of the node's first task once naming
- *  has run, else the spawn handle. Unlike `fullName` it never prints both, so
- *  the chip doesn't read as two names side by side. Persona lives in the
- *  editor's bottom-right badge. Recomputed from meta on every revive and pushed
- *  live when naming generates the first task description. */
+ *  ONE name: a person's explicit handle when present, otherwise the generated
+ *  description of the node's first task. Unlike `fullName` it never prints
+ *  both, so the chip doesn't read as two names side by side. Persona lives in
+ *  the editor's bottom-right badge. Recomputed from meta on every revive. */
 export function editorLabel(meta) {
     const icon = (meta.icon ?? '').trim();
+    const handle = meta.name && meta.name !== meta.kind ? meta.name.trim() : '';
     const desc = (meta.description ?? '').trim();
-    const name = desc !== '' ? desc : fullName(meta);
+    const name = handle !== '' ? handle : desc !== '' ? desc : meta.name;
     return icon !== '' ? `${icon} ${name}` : name;
 }

package/dist/core/canvas/types.d.ts

@@ -25,7 +25,12 @@ export type EdgeType = 'subscribes_to' | 'spawned_by';
 export interface LaunchSpec {
     /** Model id/pattern passed to pi `--model`. */
     model?: string;
-    /** True only for a caller's explicit `provider/tier` or `provider/id` override. */
+    /** Original logical family/strength preference, retained after normalization. */
+    modelIntent?: {
+        family: string;
+        strength: import('../../types.js').ModelStrength;
+    };
+    /** True only for a caller's explicit concrete `provider/id` override. */
     modelProviderPinned?: boolean;
     /** True for an exact-consult launch: `model` is the verbatim captured
      *  `provider/id:thinking` spec, bypassing the review floor/normalize and

package/dist/core/command-manifests/schema.js

@@ -27,7 +27,7 @@ const CONFIGURED_LEAF_KEYS = new Set([...LEAF_KEYS_COMMON, 'rest']);
 const ROOT_ENTRY_KEYS = new Set(['concept', 'description', 'whenToUse']);
 const FILE_ENCODINGS = new Set(['text', 'base64']);
 const PARAM_KEYS_BY_KIND = {
-    positional: new Set(['kind', 'name', 'type', 'required', 'constraint', 'encoding', 'defaultFromEnv']),
+    positional: new Set(['kind', 'name', 'type', 'required', 'constraint', 'repeatable', 'encoding', 'defaultFromEnv']),
     flag: new Set([
         'kind',
         'name',
@@ -137,18 +137,31 @@ function validateParams(raw, path, issue) {
                 issue('command_node_invalid', `positional type must be string|path`, String(p['type']), 'string | path | omitted', 'Fix the positional type.', `${pp}.type`);
                 return null;
             }
+            let repeatable = false;
+            if (p['repeatable'] !== undefined) {
+                if (typeof p['repeatable'] !== 'boolean') {
+                    issue('command_node_invalid', `repeatable must be a boolean`, typeName(p['repeatable']), 'true | false | omitted', 'Fix repeatable.', `${pp}.repeatable`);
+                    return null;
+                }
+                repeatable = p['repeatable'];
+            }
             const encoding = validateFileEncoding(p, pp, issue);
             if (encoding === null)
                 return null;
             const envDefault = validateDefaultFromEnv(p, pp, issue);
             if (envDefault === null)
                 return null;
+            if (repeatable && envDefault !== undefined) {
+                issue('command_node_invalid', `repeatable positional must not declare defaultFromEnv`, name, 'no defaultFromEnv on a repeatable positional (values accumulate into an array)', 'Remove defaultFromEnv, or drop repeatable.', `${pp}.defaultFromEnv`);
+                return null;
+            }
             out.push({
                 kind: 'positional',
                 name,
                 ...(p['type'] !== undefined ? { type: p['type'] } : {}),
                 required: p['required'],
                 constraint: p['constraint'],
+                ...(repeatable ? { repeatable: true } : {}),
                 ...(encoding !== undefined ? { encoding } : {}),
                 ...(envDefault !== undefined ? { defaultFromEnv: envDefault } : {}),
             });
@@ -251,7 +264,7 @@ function validateFileEncoding(p, pp, issue) {
  *  so it is meaningful only on a string|path param, and it cannot coexist with a
  *  static `default` (two competing sources for one slot is an authoring error,
  *  not a precedence puzzle for the reader). The caller checks `repeatable`
- *  separately, where that flag is in scope: a repeatable flag accumulates an
+ *  separately, where that param is in scope: a repeatable param accumulates an
  *  ARRAY, and one env string cannot honestly fill it. Returns the env var name,
  *  undefined when absent, or null when invalid. */
 function validateDefaultFromEnv(p, pp, issue) {
@@ -716,11 +729,11 @@ function validateRestMapping(raw, basePath, params, issue) {
                 return null;
             }
         }
-        // A repeatable flag's parsed value is an array; only JSON body placement
+        // A repeatable param's parsed value is an array; only JSON body placement
         // can carry it faithfully (query/header/path would String() it into "a,b").
         const mappedParam = paramsByName.get(paramName);
-        if (mappedParam.kind === 'flag' && mappedParam.repeatable === true && inValue !== 'body') {
-            issue('command_rest_invalid', `repeatable flag must use body placement`, `${paramName}: in "${inValue}"`, 'in: "body" (array values ship as a JSON array)', `Map "${paramName}" to body placement.`, `${path}.params.${paramName}.in`);
+        if ((mappedParam.kind === 'flag' || mappedParam.kind === 'positional') && mappedParam.repeatable === true && inValue !== 'body') {
+            issue('command_rest_invalid', `repeatable param must use body placement`, `${paramName}: in "${inValue}"`, 'in: "body" (array values ship as a JSON array)', `Map "${paramName}" to body placement.`, `${path}.params.${paramName}.in`);
             return null;
         }
         // Collect body params for coalesced source validation

package/dist/core/command.js

@@ -283,7 +283,8 @@ export async function parseArgv(params, tokens, options) {
             result[flagNameToKey(f.name)] = f.default;
         }
     }
-    let positionalValue;
+    const positionalValues = [];
+    const repeatablePositional = positionalParam?.repeatable === true;
     let positionalWasSupplied = false; // Track if positional came from argv (not stdin)
     let forcedPositional = false; // true after bare --
     let i = 0;
@@ -385,7 +386,13 @@ export async function parseArgv(params, tokens, options) {
             continue;
         }
         // Positional (or token after --)
-        if (positionalValue !== undefined) {
+        if (repeatablePositional && positionalParam !== undefined) {
+            positionalValues.push(token);
+            positionalWasSupplied = true;
+            i++;
+            continue;
+        }
+        if (positionalValues.length > 0) {
             // A leaf that also declares a `stdin` param treats its stdin value as
             // write-only/sensitive by convention (`profile env set`'s value, etc.).
             // An unexpected extra positional here is the single most likely misuse
@@ -404,13 +411,15 @@ export async function parseArgv(params, tokens, options) {
         if (positionalParam === undefined && stdinParam === undefined) {
             throw parseArgvError('bad_invocation', `this leaf takes no positional arguments: ${token}`, token, undefined, 'Use --flag for parameters. Run -h for the schema.');
         }
-        positionalValue = token;
+        positionalValues.push(token);
         positionalWasSupplied = true;
         i++;
     }
     // Assign positional (already tracked in provided set above)
-    if (positionalValue !== undefined && positionalParam !== undefined) {
-        result[flagNameToKey(positionalParam.name)] = positionalValue;
+    if (positionalValues.length > 0 && positionalParam !== undefined) {
+        result[flagNameToKey(positionalParam.name)] = repeatablePositional
+            ? positionalValues
+            : positionalValues[0];
     }
     // Resolve stdin if declared. A positional token (when there's no dedicated
     // positional param to claim it) satisfies the stdin param directly, so
@@ -421,7 +430,8 @@ export async function parseArgv(params, tokens, options) {
     // and name both sources.
     let stdinWasSupplied = false;
     if (stdinParam !== undefined) {
-        if (positionalValue !== undefined && positionalParam === undefined) {
+        if (positionalValues.length > 0 && positionalParam === undefined) {
+            const positionalValue = positionalValues[0];
             if (positionalValue === '-') {
                 const raw = await readStdinRaw();
                 // Empty required stdin is NOT thrown here: it is left unset so the
@@ -492,7 +502,7 @@ export async function parseArgv(params, tokens, options) {
         const envValue = process.env[p.defaultFromEnv];
         if (envValue === undefined || envValue === '')
             continue;
-        result[key] = envValue;
+        result[key] = p.kind === 'positional' && p.repeatable === true ? [envValue] : envValue;
         provided.add(key);
     }
     // Validate required params — COMPLETE, never first-failure. Drip-feeding one

package/dist/core/config.d.ts

@@ -1,4 +1,4 @@
-import type { Scope, ScopeConfig, ScopeState, KindConfig, ModelLaddersConfig, ModelProvider, ModelStrength } from '../types.js';
+import type { Scope, ScopeConfig, ScopeState, KindConfig, ModelLaddersConfig, ModelProvider, ModelStrength, ModelRouteConfig, ModelRoutingConfig } from '../types.js';
 export declare function configPath(scope: Scope): string | null;
 export declare function statePath(scope: Scope): string | null;
 export declare function readConfig(scope: Scope): ScopeConfig;
@@ -33,6 +33,8 @@ export declare function readRawScopeConfig(scope: Scope): Partial<ScopeConfig> |
 export interface MergedLaunchConfig {
     kinds: Record<string, KindConfig>;
     modelLadders: ModelLaddersConfig;
+    modelRoutes?: Record<string, ModelRouteConfig>;
+    modelRouting?: ModelRoutingConfig;
     /** The merged `spawnEnv.allow` set (project stack > profile > user >
      *  builtin, additive) — read by `buildOperationalEnvBase`
      *  (`core/runtime/spawn-env.ts`) as source C of the broker spawn-env

package/dist/core/config.js

@@ -2,6 +2,7 @@ import { mkdirSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { CONFIG_FILE, STATE_FILE, CONDENSED_HISTORY_MODES, defaultScopeConfig, defaultScopeState, defaultModelLaddersConfig, defaultKindsConfig, defaultRemoteCanvasConfig } from '../types.js';
+import { emitEvent } from './events/emit.js';
 import { atomicWriteJson, readJsonIfExists, writeJson, ensureDir } from './fs-utils.js';
 import { scopeRoot, requireScopeRoot, findProjectScopeRoots } from './scope.js';
 import { profileRoot } from './profiles/manifest.js';
@@ -172,6 +173,83 @@ function mergeModelLadders(raw, base = defaultModelLaddersConfig()) {
     }
     return out;
 }
+function validStrength(value) {
+    return value === 'ultra' || value === 'strong' || value === 'medium' || value === 'light';
+}
+/** Validate and overlay route entries. Invalid declarations are loud but local:
+ * a typo must not prevent unrelated launch configuration from resolving. */
+function mergeModelRoutes(raw, base = {}) {
+    const out = { ...base };
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return out;
+    for (const [routeId, value] of Object.entries(raw)) {
+        const patch = value;
+        const invalid = (rule) => { emitEvent({ level: 'warn', event: 'config.model_routes.invalid', fields: { route_id: routeId, rule } }); };
+        if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+            invalid('route must be an object');
+            continue;
+        }
+        const route = { ...out[routeId], ...patch, models: { ...out[routeId]?.models, ...patch.models } };
+        if (typeof route.family !== 'string' || route.family.trim() === '') {
+            invalid('family must be a non-empty string');
+            continue;
+        }
+        if (typeof route.credentialSource !== 'string' || route.credentialSource.trim() === '') {
+            invalid('credentialSource must be a non-empty string');
+            continue;
+        }
+        if (typeof route.providerId !== 'string' || route.providerId.trim() === '') {
+            invalid('providerId must be a non-empty string');
+            continue;
+        }
+        if (!route.models || typeof route.models !== 'object' || Array.isArray(route.models)) {
+            invalid('models must be an object');
+            continue;
+        }
+        const models = {};
+        let rule;
+        for (const [strength, spec] of Object.entries(route.models)) {
+            if (!validStrength(strength)) {
+                rule = `models.${strength} is not a model strength`;
+                break;
+            }
+            if (typeof spec !== 'string' || spec.trim() === '') {
+                rule = `models.${strength} must be a non-empty provider/id ref`;
+                break;
+            }
+            const slash = spec.indexOf('/');
+            if (slash <= 0 || slash === spec.length - 1) {
+                rule = `models.${strength} must be provider/id`;
+                break;
+            }
+            if (spec.slice(0, slash) !== route.providerId) {
+                rule = `models.${strength} provider prefix must equal providerId`;
+                break;
+            }
+            models[strength] = spec;
+        }
+        if (rule !== undefined) {
+            invalid(rule);
+            continue;
+        }
+        out[routeId] = { family: route.family, credentialSource: route.credentialSource, providerId: route.providerId, models };
+    }
+    return out;
+}
+function mergeModelRouting(raw, base) {
+    if (raw === undefined)
+        return base;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return base;
+    const value = raw;
+    const strings = (items) => Array.isArray(items) && items.every((item) => typeof item === 'string' && item.trim() !== '') ? [...items] : undefined;
+    const strengths = Array.isArray(value.strengthFallback) && value.strengthFallback.every((item) => validStrength(item)) ? [...value.strengthFallback] : undefined;
+    return {
+        ...(strings(value.credentialSourceOrder) !== undefined ? { credentialSourceOrder: strings(value.credentialSourceOrder) } : {}),
+        ...(strings(value.familyOrder) !== undefined ? { familyOrder: strings(value.familyOrder) } : {}),
+        ...(strengths !== undefined ? { strengthFallback: strengths } : {}),
+    };
+}
 /** True when `pattern` (a `spawnEnv.allow` entry) matches EVERY possible env
  *  var name — a bare `*`, or any run of nothing but `*` characters (`**`,
  *  `***`, …). This is the one glob shape that reopens the inherit-all hole
@@ -362,10 +440,12 @@ function mergeConfig(partial) {
     const fold_finished_tools = typeof partial.fold_finished_tools === 'boolean' ? partial.fold_finished_tools : defaults.fold_finished_tools;
     const keybindings = normalizeKeybindings(partial.keybindings);
     const modelLadders = mergeModelLadders(partial.modelLadders);
+    const modelRoutes = mergeModelRoutes(partial.modelRoutes);
+    const modelRouting = mergeModelRouting(partial.modelRouting, undefined);
     const kinds = mergeKinds(partial.kinds);
     const remoteCanvas = mergeRemoteCanvas(partial.remoteCanvas);
     const spawnEnv = mergeSpawnEnv(partial.spawnEnv, defaults.spawnEnv?.allow);
-    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, fold_finished_tools, keybindings, modelLadders, kinds, remoteCanvas, spawnEnv };
+    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, fold_finished_tools, keybindings, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, spawnEnv };
 }
 /** Raw (un-defaulted) partial config for one scope, or null if the scope has
  *  no root or no config.json. Used by `readMergedLaunchConfig` to layer
@@ -450,18 +530,24 @@ export function readMergedLaunchConfig(targetCwd = process.cwd(), targetProfileI
     const projectRawsFarthestFirst = readRawProjectScopeConfigs(targetCwd, targetProfileId);
     let kinds = mergeKinds(userRaw?.kinds, defaults.kinds);
     let modelLadders = mergeModelLadders(userRaw?.modelLadders, defaults.modelLadders);
+    let modelRoutes = mergeModelRoutes(userRaw?.modelRoutes);
+    let modelRouting = mergeModelRouting(userRaw?.modelRouting, undefined);
     let spawnEnv = mergeSpawnEnv(userRaw?.spawnEnv, defaults.spawnEnv?.allow);
     if (profileRaw !== null) {
         kinds = mergeKinds(profileRaw.kinds, kinds);
         modelLadders = mergeModelLadders(profileRaw.modelLadders, modelLadders);
+        modelRoutes = mergeModelRoutes(profileRaw.modelRoutes, modelRoutes);
+        modelRouting = mergeModelRouting(profileRaw.modelRouting, modelRouting);
         spawnEnv = mergeSpawnEnv(profileRaw.spawnEnv, spawnEnv.allow);
     }
     for (const raw of projectRawsFarthestFirst) {
         kinds = mergeKinds(raw.kinds, kinds);
         modelLadders = mergeModelLadders(raw.modelLadders, modelLadders);
+        modelRoutes = mergeModelRoutes(raw.modelRoutes, modelRoutes);
+        modelRouting = mergeModelRouting(raw.modelRouting, modelRouting);
         spawnEnv = mergeSpawnEnv(raw.spawnEnv, spawnEnv.allow);
     }
-    return { kinds, modelLadders, spawnEnv };
+    return { kinds, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), spawnEnv };
 }
 /** The effective `KindConfig` for one full kind string (top-level, e.g.
  *  `developer`, or sub-kind, e.g. `plan/reviewers/security`), across

package/dist/core/configured-clis/invoker.js

@@ -190,6 +190,8 @@ function materializeBodyValue(spec, param, value) {
     if (param.kind === 'context-file')
         return value;
     if ((param.kind === 'positional' || param.kind === 'flag') && param.type === 'path') {
+        if (Array.isArray(value))
+            return value.map((item) => materializeBodyValue(spec, param, item));
         const filePath = String(value);
         const resolved = resolvePath(process.cwd(), filePath);
         let stat;

package/dist/core/help.d.ts

@@ -6,7 +6,7 @@ export interface Field {
      *  token caps. Lives here, never in a separate Preconditions section. */
     constraint: string;
 }
-/** Positional argument — at most one per leaf. */
+/** Positional argument — at most one parameter per leaf; optionally repeatable. */
 export interface PositionalParam {
     kind: 'positional';
     name: string;
@@ -14,6 +14,8 @@ export interface PositionalParam {
     type?: 'string' | 'path';
     required: boolean;
     constraint: string;
+    /** When true, every positional token is collected into an array in argv order. */
+    repeatable?: boolean;
     /** Local-file materialization contract, valid only on a `path` param. The
      *  CLI-side value is a path to a local file; the invoker reads that file and
      *  sends its CONTENT as the mapped value — 'text' as UTF-8, 'base64' as the

package/dist/core/help.js

@@ -175,7 +175,7 @@ export function renderBranch(h) {
 /** Build the display label for a param entry (left column). */
 function paramLabel(p) {
     if (p.kind === 'positional')
-        return p.name.toUpperCase();
+        return `${p.name.toUpperCase()}${p.repeatable === true ? '...' : ''}`;
     if (p.kind === 'stdin')
         return 'stdin';
     if (p.kind === 'context-file')
@@ -207,7 +207,10 @@ function envDefaultNote(envVar) {
 function paramDesc(p) {
     const req = p.required ? 'required' : 'optional';
     if (p.kind === 'positional') {
-        return `positional, ${req}.${fileEncodingNote(p.encoding)}${envDefaultNote(p.defaultFromEnv)} ${p.constraint}`;
+        const repeatable = p.repeatable === true
+            ? ' Repeatable — pass multiple values to accumulate in argv order.'
+            : '';
+        return `positional, ${req}.${fileEncodingNote(p.encoding)}${envDefaultNote(p.defaultFromEnv)} ${p.constraint}${repeatable}`;
     }
     if (p.kind === 'stdin')
         return `${req}. ${p.constraint}`;

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

@@ -13,9 +13,12 @@ void rejectedBindingId;
 function ids(prefix, actions) {
     return actions.map((action) => `${prefix}.${action}`);
 }
+function pairedMenuIds(actions) {
+    return actions.flatMap((action) => [`crtr.tmux.menu.${action}`, `crtr.tmux.menu-global.${action}`]);
+}
 const REQUIRED_IDS = [
-    ...ids('crtr.tmux.menu', ['open', 'promote', 'resume', 'fork', 'demote', 'detach', 'close-subtree', 'background-bash', 'file-review', 'pin', 'show', 'view-settings', 'fold-tools', 'metadata', 'context', 'providers', 'graph', 'focus-manager', 'copy-id', 'reload-viewer', 'issues']),
-    ...ids('crtr.tmux.menu.issue', ['idea', 'bug']),
+    'crtr.tmux.menu.open',
+    ...pairedMenuIds(['promote', 'resume', 'fork', 'demote', 'detach', 'close-subtree', 'background-bash', 'file-review', 'pin', 'show', 'view-settings', 'fold-tools', 'metadata', 'context', 'providers', 'graph', 'focus-manager', 'copy-id', 'reload-viewer', 'issues', 'issue.idea', 'issue.bug']),
     ...ids('crtr.tmux.node', ['next', 'previous']),
     'crtr.tmux.inbox.toggle',
     ...ids('crtr.tmux.view', ['next', 'previous']),