@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/pi-extensions/canvas-nav.js

@@ -25,9 +25,9 @@
 //                        viewing the node: a `focuses` viewport points at it
 //                        (tmux host) or ≥1 helloed viewer is connected to its
 //                        broker (job/attach.json). Running is a separate axis,
-//                        signaled by the dot glyph alone (● = engine active on
-//                        its host — which may be an unwatched backstage pane
-//                        or a paneless broker).
+//                        signaled by the overlay-aware glyph (●/○/⟳/⚠) alone on
+//                        its host — which may be an unwatched backstage pane or
+//                        a paneless broker).
 //   SELF               = bold name — a quiet "you are here" marker.
 //
 // Folding is auto by default: a branch stays COLLAPSED unless its subtree holds
@@ -45,7 +45,7 @@
 // inside crouter's own tsc build without a dep on the pi packages.
 import { execFile } from 'node:child_process';
 import { fullName } from '../core/canvas/index.js';
-import { beginFrame, cNode, managerOf, liveReports, sortedChildIds, subtreeIds, climbRoot, computeSubtreeActivity, buildGraphModel, renderGraphRow, navLabel, coloredGlyph, truncate, tokensCell, cycleBadge, childBadge, liveBelowBadge, askBadge, activityCell, focusedNodeIds, graphWidgetBudget, fetchAsksMap, shortId, DIM, RESET, BOLD, YELLOW, GRAPH_HINT, } from '../core/canvas/nav-model.js';
+import { beginFrame, cNode, managerOf, liveReports, sortedChildIds, subtreeIds, climbRoot, computeSubtreeActivity, buildGraphModel, renderGraphRow, navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, childBadge, liveBelowBadge, askBadge, activityCell, focusedNodeIds, graphWidgetBudget, fetchAsksMap, shortId, DIM, RESET, BOLD, YELLOW, GRAPH_HINT, } from '../core/canvas/nav-model.js';
 import { readConfig } from '../core/config.js';
 import { onNavRerender } from './widget-order-bus.js';
 // ---------------------------------------------------------------------------
@@ -207,7 +207,7 @@ export function registerCanvasNav(pi) {
         else {
             const mn = cNode(mgr);
             const name = navLabel(mn, mgr);
-            const mgrLine = truncate(`↑ ${name} ${coloredGlyph(mn)} ${DIM}${mn?.kind ?? ''}${RESET} ${DIM}${tokensCell(mgr)}${RESET}${cycleBadge(mn)}${childBadge(mn)}${liveBelowBadge(mn, activity.activeBelow)}${askBadge(mgr, asksMap)}${activityCell(mgr, mn)}`);
+            const mgrLine = truncate(`↑ ${name} ${nodeGlyph(mn)} ${DIM}${mn?.kind ?? ''}${RESET} ${DIM}${tokensCell(mgr)}${RESET}${cycleBadge(mn)}${childBadge(mn)}${liveBelowBadge(mn, activity.activeBelow)}${askBadge(mgr, asksMap)}${activityCell(mgr, mn)}`);
             ui.setWidget('crtr-managers', [mgrLine], { placement: 'aboveEditor' });
         }
         const reports = liveReports(nodeId);
@@ -220,7 +220,7 @@ export function registerCanvasNav(pi) {
                 const name = navLabel(n, id).padEnd(nameW);
                 const kind = `${DIM}${(n?.kind ?? '').padEnd(6)}${RESET}`;
                 const tokens = `${DIM}${tokensCell(id).padStart(5)}${RESET}`;
-                lines.push(truncate(`  ${coloredGlyph(n)} ${name} ${kind} ${tokens}${cycleBadge(n)}${childBadge(n)}${liveBelowBadge(n, activity.activeBelow)}${askBadge(id, asksMap)}${activityCell(id, n)}`));
+                lines.push(truncate(`  ${nodeGlyph(n)} ${name} ${kind} ${tokens}${cycleBadge(n)}${childBadge(n)}${liveBelowBadge(n, activity.activeBelow)}${askBadge(id, asksMap)}${activityCell(id, n)}`));
             }
         }
         // Self's own pending asks (no self row in BASE) → a trailing inline line.
@@ -473,7 +473,14 @@ export function registerCanvasNav(pi) {
             const target = cursorId ?? nodeId;
             const n = cNode(target);
             const nm = n !== null ? fullName(n) : shortId(target);
-            pendingConfirm = { label: `kill ${nm}?`, action: () => shellCrtr(['node', 'close', '--node', target], render) };
+            pendingConfirm = { label: `kill ${nm}?`, action: () => shellCrtr(['node', 'lifecycle', 'close', '--node', target], render) };
+            render();
+            return { consume: true };
+        }
+        if (isPlain(data, 'e')) {
+            // Expand → tmux: spread the cursor node's local subtree into a tiled tmux
+            // window (same action as the alt+c → e menu chord), for parity.
+            shellCrtr(['canvas', 'tmux-spread', cursorId ?? nodeId], render);
             render();
             return { consume: true };
         }
@@ -517,8 +524,8 @@ export function registerCanvasNav(pi) {
         }
     };
     // -------------------------------------------------------------------------
-    // Slash command + shortcut to toggle GRAPH (registered once per load, like
-    // canvas-commands.ts; pi dedupes duplicate names on /reload).
+    // Slash command + shortcut to toggle GRAPH (registered once per load;
+    // pi dedupes duplicate names on /reload).
     // -------------------------------------------------------------------------
     if (typeof pi.registerCommand === 'function') {
         pi.registerCommand('graph', {

package/dist/pi-extensions/canvas-stophook.d.ts

@@ -1,4 +1,4 @@
-type PiEvents = 'agent_start' | 'turn_end' | 'agent_end' | 'session_shutdown' | 'session_start' | 'tool_execution_start';
+type PiEvents = 'agent_start' | 'turn_end' | 'agent_end' | 'session_shutdown' | 'session_start' | 'tool_execution_start' | 'tool_execution_end';
 interface PiLike {
     on: (event: PiEvents, handler: (event: any, ctx: any) => void | Promise<void>) => void;
     sendUserMessage: (content: string, options?: {

package/dist/pi-extensions/canvas-stophook.js

@@ -31,6 +31,8 @@ import { join } from 'node:path';
 import { getNode, jobDir, updateNode, recordPid, setPresence } from '../core/canvas/index.js';
 import { transition } from '../core/runtime/lifecycle.js';
 import { markBusy, clearBusy } from '../core/runtime/busy.js';
+import { recordFault, clearFault } from '../core/runtime/fault.js';
+import { classify } from '../core/fault-classifier.js';
 import { evaluateStop } from '../core/runtime/stop-guard.js';
 import { personaDrift, commitPersonaAck } from '../core/runtime/persona.js';
 import { handleNewSession, relaunchRoot, markCleanExitDone } from '../core/runtime/reset.js';
@@ -277,8 +279,10 @@ export function registerCanvasStophook(pi) {
             if (event?.reason === 'new') {
                 try {
                     const m = getNode(nodeId);
+                    // relaunchRoot is async now; the enclosing sync catch can't catch its
+                    // rejection, so swallow it here to keep `/new` best-effort.
                     if (m?.parent == null)
-                        relaunchRoot(nodeId);
+                        void relaunchRoot(nodeId).catch(() => { });
                     else
                         handleNewSession(nodeId, id, sessionFile);
                 }
@@ -316,6 +320,8 @@ export function registerCanvasStophook(pi) {
     // rather than reaping it. Cleared at the top of agent_end (turn over).
     // ---------------------------------------------------------------------------
     pi.on('agent_start', () => {
+        // A fresh turn started. Keep any active fault marker in place so the daemon's
+        // retry accounting survives a failed retry cycle; just mark the turn busy.
         try {
             markBusy(nodeId);
         }
@@ -334,6 +340,30 @@ export function registerCanvasStophook(pi) {
         catch { /* best-effort */ }
     });
     // ---------------------------------------------------------------------------
+    // tool_execution_end — IMMEDIATE refresh-yield. When a tool this turn set
+    // intent='refresh' (the node ran `crtr node yield`), shut the broker down NOW
+    // instead of letting the model keep burning its bloated context to the turn's
+    // natural end (agent_end branch (b') would only catch it there). The yield
+    // command persists the yield-message + any roadmap checkpoint BEFORE it
+    // returns, so by the time this fires nothing is lost. ctx.shutdown() disposes
+    // the session (aborting the live turn) and exits 0; the daemon then sees the
+    // dead pid + intent='refresh' and revives the node FRESH against its roadmap.
+    // intent only flips to 'refresh' via `node yield`, so this can't false-fire.
+    // (A node that somehow boots already carrying intent='refresh' correctly
+    // refreshes on its first tool — the desired outcome.)
+    pi.on('tool_execution_end', (_event, ctx) => {
+        try {
+            if (getNode(nodeId)?.intent === 'refresh') {
+                clearBusy(nodeId); // agent_end won't run to clear it; harmless if it lingers
+                try {
+                    ctx?.shutdown?.();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* best-effort */ }
+    });
+    // ---------------------------------------------------------------------------
     // session_shutdown — clean exit → done.
     //
     // pi hands us a reason as a session tears down. Only 'quit' is a node-ending
@@ -349,6 +379,7 @@ export function registerCanvasStophook(pi) {
     pi.on('session_shutdown', (event, _ctx) => {
         try {
             clearBusy(nodeId); // turn marker is meaningless once pi is exiting
+            clearFault(nodeId); // ditto the active fault marker
             // Clean /quit (reason='quit') resolves the node to done; if it held the
             // user's viewport, Q1-close it (tearDownNode kills the frozen focus pane +
             // closes the focus row → returns the user to a shell, §1.5/flow (e)). pi is
@@ -453,8 +484,28 @@ export function registerCanvasStophook(pi) {
             const last = lastAssistantMessage(messages);
             const stopReason = last?.stopReason ?? '';
             // (a) Interrupted or errored — stay alive so the user can re-steer.
-            if (stopReason !== 'stop' && stopReason !== 'length')
+            //     When the engine EXHAUSTED its retry budget (stopReason 'error', NOT
+            //     a human Esc 'aborted'), record an active fault BEFORE the return so
+            //     the canvas graph views can surface the parked window.
+            if (stopReason !== 'stop' && stopReason !== 'length') {
+                if (stopReason === 'error') {
+                    try {
+                        const raw = last?.errorMessage ?? 'engine error (no errorMessage recorded)';
+                        const classified = classify('pi→provider', raw);
+                        recordFault(nodeId, {
+                            link: 'pi→provider',
+                            op: 'generation turn',
+                            kind: classified.kind,
+                            retry: classified.disposition === 'auto' ? { disposition: 'auto', by: 'daemon' } : { disposition: classified.disposition },
+                            message: raw,
+                            logPath: join(jobDirPath, 'broker.log'),
+                            anchorEntryId: ctx.sessionManager.getLeafId?.() ?? undefined,
+                        });
+                    }
+                    catch { /* best-effort */ }
+                }
                 return;
+            }
             // (b) Already done: `crtr push --final` was called this turn, which
             //     transitions node.status → 'done' synchronously. Shut down cleanly.
             const node = getNode(nodeId);
@@ -464,6 +515,10 @@ export function registerCanvasStophook(pi) {
                 // this node's VIEWER pane (if any) and shut the broker down. The daemon
                 // won't revive a done node. tearDownNode closes the viewer focus row +
                 // pane; ctx.shutdown() exits the broker process.
+                try {
+                    clearFault(nodeId);
+                }
+                catch { /* best-effort */ }
                 if (focusOf(nodeId) !== null) {
                     try {
                         tearDownNode(nodeId);
@@ -477,12 +532,16 @@ export function registerCanvasStophook(pi) {
                 catch { /* ignore */ }
                 return;
             }
-            // (b') Refresh-yield: the node ran `crtr node yield` this turn, setting
-            //     intent='refresh'. Just shut the broker down — the daemon sees the
-            //     dead pid + intent='refresh' and reviveNode's relaunches the broker
-            //     FRESH (no resume) so the node re-reads its roadmap. (The daemon
-            //     also force-recycles a stuck refresh whose engine never exits, so a
-            //     stale in-process stophook can't strand the yield — see crtrd.)
+            // (b') Refresh-yield BACKSTOP: the node ran `crtr node yield` this turn,
+            //     setting intent='refresh'. The primary exit is the tool_execution_end
+            //     handler above, which shuts down the instant the yield tool returns
+            //     (so the model never burns more context finishing the turn); this
+            //     branch only fires if that shutdown was missed. Either way: shut the
+            //     broker down — the daemon sees the dead pid + intent='refresh' and
+            //     reviveNode relaunches the broker FRESH (no resume) so the node
+            //     re-reads its roadmap. (The daemon also force-recycles a stuck
+            //     refresh whose engine never exits, so a stale in-process stophook
+            //     can't strand the yield — see crtrd.)
             if (node?.intent === 'refresh') {
                 // A yield is SILENT to subscribers: the node keeps its identity and
                 // subscription edges across the revive and reports only through its own
@@ -505,11 +564,19 @@ export function registerCanvasStophook(pi) {
                 // followUp: the turn just ended but pi may still be flushing, so an
                 // unqualified sendUserMessage races with 'already processing'.
                 pi.sendUserMessage(decision.message, { deliverAs: 'followUp' });
+                try {
+                    clearFault(nodeId);
+                }
+                catch { /* best-effort */ }
                 return;
             }
-            // 'allow' — the node legitimately stopped. Nothing is pushed here; any
-            // report it owed its subscribers was sent by an explicit `crtr push`
-            // during the turn.
+            // 'allow' — the node legitimately stopped. The active-fault marker can
+            // clear now; any report it owed its subscribers was sent by an explicit
+            // `crtr push` during the turn.
+            try {
+                clearFault(nodeId);
+            }
+            catch { /* best-effort */ }
             //
             // Idle-release: a node awaiting its workers (reason 'awaiting') is holding
             // a tmux window for nothing. Free it — mark it idle-released and shut pi

package/dist/prompts/view.js

@@ -1,7 +1,7 @@
-// Scaffold stubs for `crtr view new`. Returns the four files of a dual-target
+// Scaffold stubs for surface-view authoring. Returns the four files of a dual-target
 // view directory — a portable `core.mjs` plus the TUI / web / text presenters —
-// that runs as-is via `crtr view run <name>` (TUI), `crtr view serve <name>`
-// (web), and `crtr view run <name> | cat` (static snapshot).
+// that runs as-is via the surface view host (TUI/static snapshot) and the surface
+// web server (browser).
 //
 // Authoring guidance lives INSIDE each stub (the comment block at the top of the
 // generated file), so a view author reads the contract right where they edit.
@@ -21,15 +21,14 @@ function coreStub(v) {
 // imports NOTHING — no \`node:*\`, no crtr. ALL state + behavior live here;
 // presenters (tui.mjs / web.jsx) are pure reads that dispatch named intents.
 //
-//   Run it:   crtr view run ${v.id}          (TUI, inside tmux)
-//             crtr view run ${v.id} | cat    (static snapshot, exits 0)
-//             crtr view serve ${v.id}        (React + Tailwind web page)
+//   Run it through the surface view host for TUI/static snapshots, or through
+//   the surface web server for the React + Tailwind browser page.
 //
 // THE CONTRACT:
 //   manifest          { id, title, description, refreshMs? } — id MUST equal
 //                     this view's directory name.
 //   init(opts)        cheap, SYNCHRONOUS initial state — NO fetch, NO screen.
-//                     CLI flags arrive in \`opts\` (crtr view run --port/--target).
+//                     CLI flags arrive in \`opts\` (for example port/target options).
 //   sources           { request, parse } READ descriptors. The host's transport
 //                     runs request() (exec/file/http) and hands parse() the bytes
 //                     — your parse is pure, runs in Node AND the browser.
@@ -119,7 +118,7 @@ function webStub(v) {
     return `// ${v.title} — web presenter: a React + Tailwind component.
 //
 // A pure function of \`state\`; DOM events call \`dispatch(intent)\`. Consumed ONLY
-// by \`crtr view serve\` (Vite owns JSX + Tailwind) — never Node-imported. The
+// by the surface web host (Vite owns JSX + Tailwind) — never Node-imported. The
 // SAME state + intents the TUI reads; zero shared render code (an intentional fork).
 
 export default function View({ state, dispatch }) {

package/dist/types.d.ts

@@ -8,7 +8,7 @@ export declare const ExitCode: {
     readonly NETWORK: 5;
 };
 export type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
-export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_VERSION = 4;
 export interface OwnerRef {
     name?: string;
     email?: string;
@@ -50,10 +50,27 @@ export interface AutoUpdateConfig {
     content: AutoUpdateMode;
     interval_hours: number;
 }
-/** One canvas-nav action binding: a `crtr` argv string (templated with
- *  {id|self|name|manager|subtree}) plus optional confirm gate + menu label.
- *  `run` of the sentinel `__graph__` toggles the in-pi GRAPH modal instead of
- *  shelling a command. */
+export type CanvasAction = {
+    kind?: 'crtr';
+    run: string;
+    confirm?: boolean;
+} | {
+    kind: 'keys';
+    keys: string;
+} | {
+    kind: 'menu';
+    items: CanvasMenuItem[];
+} | {
+    kind: 'popup';
+    run: string;
+};
+export interface CanvasMenuItem {
+    key: string;
+    desc: string;
+    action: CanvasAction;
+    confirm?: boolean;
+}
+/** Legacy GRAPH bind shape; retained for graphBinds only. */
 export interface CanvasBind {
     run: string;
     confirm?: boolean;
@@ -68,10 +85,21 @@ export interface CanvasNavConfig {
     /** Fallback pi shortcut for GRAPH toggle when NOT in tmux. Default 'alt+g'. */
     prefixKey?: string;
     /** chord key (after alt+c) → action; tmux-menu layer. */
-    prefixBinds: Record<string, CanvasBind>;
+    prefixBinds: Record<string, CanvasAction & {
+        desc?: string;
+    }>;
     /** extra raw key in GRAPH → action; pi-extension layer (additive only). */
     graphBinds: Record<string, CanvasBind>;
 }
+export type ModelStrength = 'ultra' | 'strong' | 'medium' | 'light';
+export type ModelProvider = 'anthropic' | 'openai';
+export interface ModelLaddersConfig {
+    /** Optional default provider for bare strengths. If unset, runtime falls back
+     *  to CRTR_MODEL_PROVIDER, then anthropic. */
+    defaultProvider?: ModelProvider;
+    anthropic: Record<ModelStrength, string>;
+    openai: Record<ModelStrength, string>;
+}
 export interface ScopeConfig {
     schema_version: number;
     marketplaces: Record<string, ConfigMarketplaceEntry>;
@@ -79,6 +107,8 @@ export interface ScopeConfig {
     auto_update: AutoUpdateConfig;
     max_panes_per_window: number;
     canvasNav: CanvasNavConfig;
+    modelLadders: ModelLaddersConfig;
+    personaStrengths: Record<string, ModelStrength>;
 }
 export interface ScopeState {
     marketplaces: Record<string, {
@@ -90,15 +120,6 @@ export interface ScopeState {
     last_self_check?: string;
     bootstrap_done?: boolean;
 }
-export declare const SKILL_TYPES: readonly ["playbook", "primer", "reference", "runbook", "freeform"];
-export type SkillType = (typeof SKILL_TYPES)[number];
-export declare function isSkillType(v: unknown): v is SkillType;
-export interface SkillFrontmatter {
-    name: string;
-    description?: string;
-    keywords?: string[];
-    type?: SkillType;
-}
 export interface SubagentFrontmatter {
     name: string;
     description?: string;
@@ -144,14 +165,12 @@ export declare const MARKETPLACE_MANIFEST_FILE = "marketplace.json";
 export declare const CRTR_DIR_NAME = ".crouter";
 export declare const CONFIG_FILE = "config.json";
 export declare const STATE_FILE = "state.json";
-export declare const SKILL_ENTRY_FILE = "SKILL.md";
-export declare const SKILLS_DIR = "skills";
 export declare const AGENTS_DIR = "agents";
 export declare const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export declare function defaultScopeConfig(): ScopeConfig;
 /** Built-in canvas-nav binds so an absent config still gives the intended UX.
- *  prefixBinds: g→GRAPH toggle (sentinel), m→focus manager.
- *  1..9 (focus report N) are generated by the menu layer, not literal entries.
- *  graphBinds: empty — built-in GRAPH keys are reserved, custom keys add on. */
+ *  prefixBinds restate the current menu defaults; graphBinds stay empty.
+ */
 export declare function defaultCanvasNavConfig(): CanvasNavConfig;
+export declare function defaultModelLaddersConfig(): ModelLaddersConfig;
 export declare function defaultScopeState(): ScopeState;

package/dist/types.js

@@ -6,11 +6,7 @@ export const ExitCode = {
     AMBIGUOUS: 4,
     NETWORK: 5,
 };
-export const SCHEMA_VERSION = 2;
-export const SKILL_TYPES = ['playbook', 'primer', 'reference', 'runbook', 'freeform'];
-export function isSkillType(v) {
-    return typeof v === 'string' && SKILL_TYPES.includes(v);
-}
+export const SCHEMA_VERSION = 4;
 export const PLUGIN_MANIFEST_DIR = '.crouter-plugin';
 export const PLUGIN_MANIFEST_FILE = 'plugin.json';
 export const MARKETPLACE_MANIFEST_DIR = '.crouter-marketplace';
@@ -18,10 +14,8 @@ export const MARKETPLACE_MANIFEST_FILE = 'marketplace.json';
 export const CRTR_DIR_NAME = '.crouter';
 export const CONFIG_FILE = 'config.json';
 export const STATE_FILE = 'state.json';
-export const SKILL_ENTRY_FILE = 'SKILL.md';
-export const SKILLS_DIR = 'skills';
 // Subagent definitions live as flat `<name>.md` files under `<root>/agents/`,
-// for both scope roots and plugins. Mirrors SKILLS_DIR.
+// for both scope roots and plugins.
 export const AGENTS_DIR = 'agents';
 export const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export function defaultScopeConfig() {
@@ -32,22 +26,53 @@ export function defaultScopeConfig() {
         auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
         max_panes_per_window: DEFAULT_MAX_PANES_PER_WINDOW,
         canvasNav: defaultCanvasNavConfig(),
+        modelLadders: defaultModelLaddersConfig(),
+        personaStrengths: {},
     };
 }
 /** Built-in canvas-nav binds so an absent config still gives the intended UX.
- *  prefixBinds: g→GRAPH toggle (sentinel), m→focus manager.
- *  1..9 (focus report N) are generated by the menu layer, not literal entries.
- *  graphBinds: empty — built-in GRAPH keys are reserved, custom keys add on. */
+ *  prefixBinds restate the current menu defaults; graphBinds stay empty.
+ */
 export function defaultCanvasNavConfig() {
     return {
         prefixKey: 'alt+g',
         prefixBinds: {
-            g: { run: '__graph__', desc: 'graph view' },
-            m: { run: 'node focus {manager}', desc: 'focus manager' },
+            o: { kind: 'keys', keys: '/promote', desc: 'promote to orchestrator' },
+            r: { kind: 'keys', keys: '/resume-node', desc: 'resume node' },
+            d: { kind: 'crtr', run: 'node lifecycle demote --pane {pane}', desc: 'demote to terminal' },
+            D: { kind: 'crtr', run: 'node lifecycle demote --pane {pane} --detach', desc: 'detach to background' },
+            x: { kind: 'crtr', run: 'node lifecycle close --pane {pane}', desc: 'close agent + subtree' },
+            c: { kind: 'keys', keys: '/context', desc: 'browse context dirs' },
+            g: { kind: 'keys', keys: '/graph', desc: 'graph view' },
+            m: { kind: 'crtr', run: 'node focus {manager}', desc: 'focus manager' },
+            i: {
+                kind: 'menu',
+                desc: 'new issue / todo',
+                items: [
+                    { key: 'i', desc: 'idea', action: { kind: 'popup', run: 'canvas issue new --type idea' } },
+                    { key: 'b', desc: 'bug', action: { kind: 'popup', run: 'canvas issue new --type bug' } },
+                ],
+            },
         },
         graphBinds: {},
     };
 }
+export function defaultModelLaddersConfig() {
+    return {
+        anthropic: {
+            ultra: 'anthropic/claude-fable-5:high',
+            strong: 'anthropic/claude-opus-4-8:high',
+            medium: 'anthropic/claude-sonnet-5:high',
+            light: 'anthropic/claude-haiku-4-5:high',
+        },
+        openai: {
+            ultra: 'openai-codex/gpt-5.5:xhigh',
+            strong: 'openai-codex/gpt-5.5:high',
+            medium: 'openai-codex/gpt-5.5:medium',
+            light: 'openai-codex/gpt-5.3-codex-spark',
+        },
+    };
+}
 export function defaultScopeState() {
     return { marketplaces: {}, plugins: {} };
 }