@nexrall/code-core 1.4.71 → 1.4.73

package/dist/agent/loop.js

@@ -5,6 +5,7 @@ exports.lastToolResults = exports.summariseSubTaskProgress = exports.capSubTaskT
 exports.dispatchSubAgent = dispatchSubAgent;
 exports.dispatchBackgroundSubAgent = dispatchBackgroundSubAgent;
 exports.dispatchForkedSubAgent = dispatchForkedSubAgent;
+exports.runForkedSkill = runForkedSkill;
 exports.runAgentLoop = runAgentLoop;
 exports.trimToResumableBoundary = trimToResumableBoundary;
 const readDedupe_1 = require("./readDedupe");
@@ -16,6 +17,7 @@ const executor_1 = require("../tools/executor");
 const sharedTasks_1 = require("./sharedTasks");
 const agentTypes_1 = require("./agentTypes");
 const skills_1 = require("./skills");
+const nestedInstructions_1 = require("./nestedInstructions");
 const rules_1 = require("../permissions/rules");
 const modePolicy_1 = require("../permissions/modePolicy");
 const destructive_1 = require("../permissions/destructive");
@@ -25,6 +27,7 @@ const destructive_1 = require("../permissions/destructive");
 const bashClassify_1 = require("../permissions/bashClassify");
 Object.defineProperty(exports, "bashNeedsRepoLock", { enumerable: true, get: function () { return bashClassify_1.bashNeedsRepoLock; } });
 const planMode_1 = require("./planMode");
+const instructions_1 = require("../mcp/instructions");
 const worktreeEnforcement_1 = require("./worktreeEnforcement");
 const sandbox_1 = require("../tools/sandbox");
 const testIntegrity_1 = require("./testIntegrity");
@@ -235,8 +238,11 @@ function dispatchBackgroundSubAgent(input, options, agentTypes, hub) {
     if (overBudget)
         return { error: overBudget };
     const agentType = (typeof input.subagent_type === 'string' && input.subagent_type) || 'general-purpose';
-    const description = (typeof input.description === 'string' && input.description.trim())
-        || String(input.prompt ?? '').trim().slice(0, 60) || agentType;
+    const description = (typeof input.description === 'string' && input.description.trim()) ||
+        String(input.prompt ?? '')
+            .trim()
+            .slice(0, 60) ||
+        agentType;
     const mode = (0, modePolicy_1.parseMode)(options.mode);
     const backgroundPermission = backgroundPermissionPolicy(options, mode);
     const started = hub.start({ description, agentType }, async ({ abort, onToolUse }) => {
@@ -344,6 +350,59 @@ function dispatchForkedSubAgent(conversation, prompt, options, agentTypes, hub)
     }
     return { id: started.id, description, agentType, messages: conversation.length };
 }
+/**
+ * Resolve the skill a `use_skill` call names, returning it ONLY if it runs as a
+ * fork (`context: 'fork'`) — the signal `runAgentLoop` uses to divert the call
+ * away from the inline-injection path and into the sub-agent machinery.
+ *
+ * The snapshot is the list the catalogue was built from (loaded once per run);
+ * a MISS reloads from disk so a skill created mid-turn is found — the same
+ * trade-off `runSubTask` documents for `agentTypes`.
+ */
+function resolveForkSkill(skills, input, options) {
+    const name = typeof input.name === 'string' ? input.name.trim() : '';
+    if (!name)
+        return undefined;
+    const skill = (0, skills_1.findSkill)(skills, name) ??
+        (0, skills_1.resolveNestedSkill)(options.workDir, name) ?? // `<dir>:<name>` - see skills.ts
+        (0, skills_1.findSkill)((0, skills_1.loadSkillsWithWarnings)(options.workDir, options._extraSkills ?? []).skills, name);
+    return skill?.context === 'fork' ? skill : undefined;
+}
+/**
+ * Run a `context: fork` skill as an ISOLATED sub-agent (Claude Code parity):
+ * the expanded body is the child's prompt and the parent conversation is NOT
+ * copied in — a forked skill must stand on its own, which is the point of the
+ * fork (the invoking context stays clean and the child cannot lean on it).
+ *
+ * Background by default (CC 2.1.x), exactly like `task(run_in_background)`: the
+ * call returns as soon as the child starts and the report arrives later as a
+ * <task-notification>; `background: false` awaits the child and returns its
+ * report as the tool result. Hosts with no hub (headless `-p`/SDK callers)
+ * always await — the same place CC waits regardless of the frontmatter.
+ *
+ * The `subagent_type` rides the ordinary `task` dispatch, so `deny:
+ * ["task(<name>)"]` rules, the depth limit and the session sub-agent budget all
+ * apply unchanged (see runSubTask / dispatchSubAgent).
+ */
+async function runForkedSkill(skill, args, options, agentTypes) {
+    const workDir = options.workDir ?? process.cwd();
+    const input = {
+        prompt: (0, skills_1.expandSkill)(skill, args, workDir),
+        description: `/${skill.name}`,
+        subagent_type: skill.agent?.trim() || 'general-purpose',
+    };
+    // `model:` on the skill applies to the fork exactly as it does when the skill is
+    // typed as a turn (`/name` in chat.ts): the child starts on that model. A model
+    // the agent TYPE declares still wins — the child resolves it over ours, same as
+    // any `task` call (see subTask.ts).
+    const childOptions = skill.model ? { ...options, model: (0, modelCatalogue_1.resolveSubAgentModel)(skill.model, options.model) } : options;
+    const depth = options._depth ?? 0;
+    const wantsBackground = skill.background !== false && depth === 0;
+    if (wantsBackground && childOptions.backgroundAgents) {
+        return dispatchBackgroundSubAgent(input, childOptions, agentTypes, childOptions.backgroundAgents);
+    }
+    return dispatchSubAgent(input, childOptions, agentTypes);
+}
 // ─── Agent Loop ───────────────────────────────────────────────────────────────
 async function runAgentLoop(initialMessages, options) {
     const messages = [...initialMessages];
@@ -400,7 +459,10 @@ async function runAgentLoop(initialMessages, options) {
         const addContext = (ctx) => {
             const m = messages[lastIdx];
             if (m && Array.isArray(m.content))
-                messages[lastIdx] = { ...m, content: [...m.content, { type: 'text', text: `\n\n<hook-context>\n${ctx}\n</hook-context>` }] };
+                messages[lastIdx] = {
+                    ...m,
+                    content: [...m.content, { type: 'text', text: `\n\n<hook-context>\n${ctx}\n</hook-context>` }],
+                };
         };
         const sid = options.sessionId || subAgentBudget_1.PROCESS_BUDGET_KEY;
         if (isPrompt && !_sessionStarted.has(sid) && (hooks.SessionStart?.length ?? 0) > 0) {
@@ -436,7 +498,9 @@ async function runAgentLoop(initialMessages, options) {
     // the user request that caused it belong to the same run — which is precisely
     // the chain of custody the trail exists to prove.
     const auditCfg = options.audit
-        ? (options.audit.sessionId ? options.audit : { ...options.audit, sessionId: (0, audit_1.newAuditSessionId)() })
+        ? options.audit.sessionId
+            ? options.audit
+            : { ...options.audit, sessionId: (0, audit_1.newAuditSessionId)() }
         : undefined;
     const auditCtx = auditCfg
         ? {
@@ -479,7 +543,24 @@ async function runAgentLoop(initialMessages, options) {
     // just a reusable prompt template (via use_skill), not another spawn point, so
     // sub-agents benefit from the same playbooks without the recursion concerns that
     // gate agentsCatalogue to the top level.
-    const skillsCatalogue = (0, skills_1.summariseSkills)((0, skills_1.loadSkillsWithWarnings)(options.workDir, options._extraSkills ?? []).skills);
+    const skillsList = (0, skills_1.loadSkillsWithWarnings)(options.workDir, options._extraSkills ?? []).skills;
+    // Nested-skill discovery (CC 2.1.x parity): as tool calls touch files, their
+    // directories get checked for their own `.nexrall/skills`, and anything found is
+    // addressed as `<dir>:<name>` (see skills.ts). The catalogue below is rebuilt
+    // PER REQUEST precisely so a discovery mid-turn reaches the model on its next
+    // round-trip without a new user message; resolutions go through findSkill /
+    // resolveNestedSkill, so a scoped name works even before its turn advertises it.
+    const nestedSkillScan = options.workDir ? new skills_1.NestedSkillScanner(options.workDir) : null;
+    // Nested instruction files (S18c): a subdirectory's `nexrall.md` applies once the
+    // agent works there — the same 2.1.x behaviour as the nested skills above, and the
+    // same per-request composition (the prompt reads the ledger's list() every call).
+    // The HOST normally owns the ledger: one scanner per session, passed to every run,
+    // because a loaded file must not silently vanish between turns. A host that passes
+    // nothing gets run-scoped discovery — the right lifetime for a one-shot run. `false`
+    // disables the feature entirely (`--bare`: no discovery).
+    const nestedInstructionScan = options._nestedInstructions === false
+        ? null
+        : (options._nestedInstructions ?? (options.workDir ? new nestedInstructions_1.NestedInstructionScanner(options.workDir) : null));
     // Plan mode instructions ride the project-instructions channel, which is
     // authoritative in the system prompt. Prepended rather than appended: the
     // lock has to be read before the project conventions it overrides.
@@ -491,7 +572,26 @@ async function runAgentLoop(initialMessages, options) {
         options.planMode ? planMode_1.PLAN_MODE_INSTRUCTIONS : null,
         options.worktree ? (0, worktreeEnforcement_1.worktreeInstructions)(options.worktree) : null,
         options.nexrallMd ?? null,
-    ].filter((s) => s !== null).join('\n\n---\n\n') || undefined; // '' (nothing at all was present) must behave exactly like the old `: options.nexrallMd` fallback (undefined), not an empty-but-truthy string.
+    ]
+        .filter((s) => s !== null)
+        .join('\n\n---\n\n') || undefined; // '' (nothing at all was present) must behave exactly like the old `: options.nexrallMd` fallback (undefined), not an empty-but-truthy string.
+    // MCP `initialize.instructions` — a server's own reference notes. Composed PER
+    // REQUEST so a server that connects (or is enabled) mid-session contributes
+    // without the caller rebuilding the session brief; a sub-agent only reads the
+    // servers its allowlist names (another server's notes are not its business).
+    // The size caps live in mcp/instructions.ts.
+    const mcpInstructionsBlock = () => (0, instructions_1.formatMcpInstructions)((options.mcpManager?.serverInstructions() ?? []).filter((e) => !options._mcpServerAllowlist || options._mcpServerAllowlist.has(e.server)));
+    // Per-server `alwaysLoad` (CC parity): names the user pinned in mcp.json. The
+    // backend keeps their `<server>__*` tools out of BOTH deferral paths (tool-search
+    // `defer_loading` and the cap selector's droppable set). Sub-agent runs narrow the
+    // list to servers their own allowlist can actually reach — naming a server the run
+    // cannot use would protect nothing and leak the catalogue's shape. Empty →
+    // undefined so older backends receive the exact same body as before.
+    const alwaysLoadServerNames = (() => {
+        const named = options.mcpManager?.alwaysLoadServers() ?? [];
+        const scoped = named.filter((n) => !options._mcpServerAllowlist || options._mcpServerAllowlist.has(n));
+        return scoped.length ? scoped : undefined;
+    })();
     // The request options every main-loop call sends. Shared with the compaction
     // summariser so its request has the SAME system prompt and tools as the conversation
     // — that is what lets the summary call read the whole history from cache (0.10×)
@@ -502,7 +602,13 @@ async function runAgentLoop(initialMessages, options) {
         effort: options.effort,
         env: options.env,
         editorContext: options.editorContext,
-        nexrallMd: planAndWorktreeAwareNexrallMd,
+        nexrallMd: [
+            planAndWorktreeAwareNexrallMd,
+            (0, nestedInstructions_1.formatNestedInstructions)(nestedInstructionScan?.list() ?? []),
+            mcpInstructionsBlock(),
+        ]
+            .filter((s) => !!s)
+            .join('\n\n---\n\n') || undefined,
         clientType: options.clientType,
         abortSignal: options.abortSignal,
         // MCP tools, plus the per-agent memory tool when (and only when) this run
@@ -511,8 +617,7 @@ async function runAgentLoop(initialMessages, options) {
         // to every other run: a tool the model cannot see is one it cannot try,
         // which is better than advertising it everywhere and refusing it at the gate.
         extraTools: [
-            ...(options.mcpManager?.getAnthropicTools() ?? [])
-                .filter((t) => !options._mcpServerAllowlist || options._mcpServerAllowlist.has(String(t.name).split('__')[0])),
+            ...(options.mcpManager?.getAnthropicTools() ?? []).filter((t) => !options._mcpServerAllowlist || options._mcpServerAllowlist.has(String(t.name).split('__')[0])),
             ...(options._agentMemory ? [iterationPolicy_1.AGENT_MEMORY_TOOL_SCHEMA] : []),
             ...(options.extraToolSchemas ?? []),
         ],
@@ -522,11 +627,7 @@ async function runAgentLoop(initialMessages, options) {
         // memory_write, which no sub-agent allowlist contains.
         // Sub-agents NEVER write the shared store (the main agent decides what to persist) —
         // an unnamed/general-purpose child has no allowlist, which used to read as "may write".
-        canWriteSharedMemory: depth > 0
-            ? false
-            : options._allowedTools
-                ? options._allowedTools.has('memory_write')
-                : true, // no allowlist = main agent = may write
+        canWriteSharedMemory: depth > 0 ? false : options._allowedTools ? options._allowedTools.has('memory_write') : true, // no allowlist = main agent = may write
         hasOwnAgentStore: !!options._agentMemory,
         // Same derivation, same reason, for the network. The base prompt's
         // "Web search" section tells the run to reach the network, but
@@ -543,11 +644,15 @@ async function runAgentLoop(initialMessages, options) {
         // (and gets refused on) write, office and image tools. Sorted so the tools cache
         // prefix is identical for every run of the same agent type.
         toolAllowlist: options._allowedTools ? [...options._allowedTools].sort() : undefined,
+        // Servers the user pinned with `alwaysLoad: true` (computed above). The backend
+        // keeps their `<server>__*` tools out of the tool cap and both deferral paths;
+        // undefined (not []) when nothing is pinned so older backends see the same body.
+        alwaysLoadServers: alwaysLoadServerNames,
         // Withholds the `task` schema and its instructions when this run cannot
         // delegate — see canSpawnSubAgents.
         canSpawnSubAgents: maySpawn,
         agents: agentsCatalogue || undefined,
-        skills: skillsCatalogue || undefined,
+        skills: (0, skills_1.summariseSkills)(skillsList) || undefined,
     });
     // Optional OS-level bash sandbox (opt-in via settings.json "sandbox").
     const sandboxCfg = (0, sandbox_1.parseSandboxConfig)(settings.raw.sandbox) ?? undefined;
@@ -563,7 +668,7 @@ async function runAgentLoop(initialMessages, options) {
     // Per-run: a sub-agent's own runAgentLoop gets its own, so it never sees its parent's reads.
     const readDedupe = new readDedupe_1.ReadDedupe(options.workDir);
     // Only the main agent owns background agents (runSubTask never passes the hub down).
-    const drainBackgroundNotifications = () => depth === 0 ? (options.backgroundAgents?.takeNotifications() ?? []) : [];
+    const drainBackgroundNotifications = () => (depth === 0 ? (options.backgroundAgents?.takeNotifications() ?? []) : []);
     // Live prompt-size estimate, updated from usage events after every stream.
     let lastPromptTokens = 0;
     let compacting = false; // re-entrancy guard — compaction itself calls streamChat
@@ -734,7 +839,11 @@ async function runAgentLoop(initialMessages, options) {
                 compactDisabled = false;
                 compactFailures = 0;
             }
-            if (autoCompact && !compactDisabled && !compacting && (tokenPressure || bytePressure) && messages.length > compaction_1.COMPACT_KEEP_MIN + 2) {
+            if (autoCompact &&
+                !compactDisabled &&
+                !compacting &&
+                (tokenPressure || bytePressure) &&
+                messages.length > compaction_1.COMPACT_KEEP_MIN + 2) {
                 compacting = true;
                 try {
                     // Measured BEFORE, so "did it actually help?" is a fact about bytes rather
@@ -759,9 +868,7 @@ async function runAgentLoop(initialMessages, options) {
                     const reclaimed = bytesBefore - bytesAfter;
                     if (did) {
                         lastPromptTokens = 0; // stale — next usage event refreshes it
-                        const reason = bytePressure
-                            ? `body ~${(bodyBytes / (1024 * 1024)).toFixed(1)}MB`
-                            : 'context window';
+                        const reason = bytePressure ? `body ~${(bodyBytes / (1024 * 1024)).toFixed(1)}MB` : 'context window';
                         // Silent, same as the prune above — routine housekeeping. Only the
                         // actionable "auto-compaction paused" warning below is surfaced.
                         void reason;
@@ -1091,8 +1198,8 @@ async function runAgentLoop(initialMessages, options) {
             //    be an example here too — as of the 2026-08-11+ provider-agnostic port it is a
             //    plain client tool executed by THIS process, so it no longer belongs in this set.)
             const serverSideResultIds = new Set(assistantMessage.content
-                .filter(b => b.type === 'tool_result')
-                .map(b => b.tool_use_id)
+                .filter((b) => b.type === 'tool_result')
+                .map((b) => b.tool_use_id)
                 .filter((id) => !!id));
             const toolUseBlocks = assistantMessage.content.filter((block) => block.type === 'tool_use' && !serverSideResultIds.has(block.id));
             // ─── TRUNCATED-TOOL-CALL GUARD ──────────────────────────────────────────
@@ -1117,9 +1224,7 @@ async function runAgentLoop(initialMessages, options) {
             // model retries with a smaller call, rather than either failing
             // mysteriously or silently mutating a file incompletely.
             const lastBlock = assistantMessage.content[assistantMessage.content.length - 1];
-            const truncatedToolUseId = assistantMessage.stopReason === 'max_tokens' && lastBlock?.type === 'tool_use'
-                ? lastBlock.id
-                : undefined;
+            const truncatedToolUseId = assistantMessage.stopReason === 'max_tokens' && lastBlock?.type === 'tool_use' ? lastBlock.id : undefined;
             // 4. If no tool use → agent produced a final text response.
             //    But if the user queued a follow-up while we were working, fold it in as the
             //    next user turn and keep going instead of ending (Claude-Code style).
@@ -1170,7 +1275,8 @@ async function runAgentLoop(initialMessages, options) {
                     const bullet = fresh.map((t) => `  • ${t.path}: ${t.reason}`).join('\n');
                     messages.push({
                         role: 'user',
-                        content: [{
+                        content: [
+                            {
                                 type: 'text',
                                 text: 'STOP — test-integrity check. Before finishing, I detected that you WEAKENED test(s) this session:\n' +
                                     bullet +
@@ -1178,7 +1284,8 @@ async function runAgentLoop(initialMessages, options) {
                                     '  1. Revert the weakening and fix the actual code so the ORIGINAL test passes, or\n' +
                                     '  2. Justify concretely why the change is a legitimate test refactor (e.g. the behaviour was intentionally removed per the task, a duplicate test, or the assertion was genuinely wrong) — and confirm the remaining tests still meaningfully cover the behaviour.\n' +
                                     'Then re-run the test suite to prove it passes for real.',
-                            }],
+                            },
+                        ],
                     });
                     continue;
                 }
@@ -1191,15 +1298,19 @@ async function runAgentLoop(initialMessages, options) {
                     if (flaky.length) {
                         for (const f of flaky)
                             flakyNudgedCmds.add(f.cmd);
-                        const bullet = flaky.map((f) => `  • ${f.cmd}  (${f.passes} pass / ${f.fails} fail on identical code)`).join('\n');
+                        const bullet = flaky
+                            .map((f) => `  • ${f.cmd}  (${f.passes} pass / ${f.fails} fail on identical code)`)
+                            .join('\n');
                         messages.push({
                             role: 'user',
-                            content: [{
+                            content: [
+                                {
                                     type: 'text',
                                     text: 'STOP — flaky-test check. These command(s) produced BOTH a pass and a fail with NO code change in between, so they are non-deterministic:\n' +
                                         bullet +
                                         '\n\nA green run of a flaky test proves nothing, and re-running until it passes is not a fix. Do NOT declare success on this basis. Instead: identify the source of non-determinism (unseeded RNG, timing/sleep races, test-ordering or shared-state dependence, wall-clock/timezone, network) and make the test deterministic — or, if it is out of scope, say so explicitly and flag it as pre-existing flakiness rather than treating the passing run as proof.',
-                                }],
+                                },
+                            ],
                         });
                         continue;
                     }
@@ -1213,10 +1324,12 @@ async function runAgentLoop(initialMessages, options) {
                     verificationNudgeSent = true;
                     messages.push({
                         role: 'user',
-                        content: [{
+                        content: [
+                            {
                                 type: 'text',
-                                text: 'Before finishing: you edited file(s) in this task but I don\'t see a build/test/lint/typecheck command run to confirm the change works. If this project has one, please run it now and fix any failures. If verification genuinely doesn\'t apply here (e.g. docs-only change, no test suite), just say so and finish.',
-                            }],
+                                text: "Before finishing: you edited file(s) in this task but I don't see a build/test/lint/typecheck command run to confirm the change works. If this project has one, please run it now and fix any failures. If verification genuinely doesn't apply here (e.g. docs-only change, no test suite), just say so and finish.",
+                            },
+                        ],
                     });
                     continue;
                 }
@@ -1358,6 +1471,11 @@ async function runAgentLoop(initialMessages, options) {
                     if (err instanceof subTaskSupport_1.ToolNotAllowedError)
                         deniedReason = err.message;
                 }
+                // `context: fork` skills never reach the executor's inline injection: the
+                // call is diverted into the same sub-agent machinery `task` uses, with the
+                // expanded body as the child's prompt (see runForkedSkill). Resolved here —
+                // only for an allowed `use_skill` — so a denied call pays nothing for it.
+                const forkSkill = permitted && name === 'use_skill' ? resolveForkSkill(skillsList, input, options) : undefined;
                 if (!permitted) {
                     result = { error: deniedReason ?? 'Permission denied by user' };
                 }
@@ -1373,8 +1491,9 @@ async function runAgentLoop(initialMessages, options) {
                     // reimplementing depth/budget/concurrency enforcement a second time.
                     // Background only for the MAIN agent, and only when the host can deliver the
                     // result later; otherwise it quietly runs in the foreground.
-                    const wantsBackground = input.run_in_background === true
-                        || (input.run_in_background !== false && !!(0, agentTypes_1.findAgentType)(agentTypes, String(input.subagent_type ?? ''))?.background);
+                    const wantsBackground = input.run_in_background === true ||
+                        (input.run_in_background !== false &&
+                            !!(0, agentTypes_1.findAgentType)(agentTypes, String(input.subagent_type ?? ''))?.background);
                     const taskOptions = { ...auditOptions, _taskToolUseId: id };
                     // PreToolUse/PostToolUse cover spawns too (Claude Code's matcher "Task"/"Agent"
                     // works the same way): a hook can veto a delegation or audit what came back.
@@ -1383,9 +1502,10 @@ async function runAgentLoop(initialMessages, options) {
                         result = { error: `Blocked by PreToolUse hook: ${preTask.reason}` };
                     }
                     else {
-                        result = wantsBackground && depth === 0 && options.backgroundAgents && !input.resume_agent_id
-                            ? dispatchBackgroundSubAgent(input, taskOptions, agentTypes, options.backgroundAgents)
-                            : await dispatchSubAgent(input, taskOptions, agentTypes);
+                        result =
+                            wantsBackground && depth === 0 && options.backgroundAgents && !input.resume_agent_id
+                                ? dispatchBackgroundSubAgent(input, taskOptions, agentTypes, options.backgroundAgents)
+                                : await dispatchSubAgent(input, taskOptions, agentTypes);
                         const postTask = await (0, hooks_1.runToolHooks)(hooks.PostToolUse, 'PostToolUse', name, input, options.workDir, result, (0, hooks_1.hookRunOptsFor)(options));
                         const injectedTask = [preTask.context, postTask.context].filter(Boolean).join('\n');
                         if (injectedTask) {
@@ -1399,6 +1519,28 @@ async function runAgentLoop(initialMessages, options) {
                         }
                     }
                 }
+                else if (forkSkill) {
+                    // `use_skill` on a `context: fork` skill — the same hook pair as any call,
+                    // so a Pre can veto the fork and a Post sees its start/report.
+                    const preFork = await (0, hooks_1.runToolHooks)(hooks.PreToolUse, 'PreToolUse', name, input, options.workDir, undefined, (0, hooks_1.hookRunOptsFor)(options));
+                    if (preFork.block) {
+                        result = { error: `Blocked by PreToolUse hook: ${preFork.reason}` };
+                    }
+                    else {
+                        result = await runForkedSkill(forkSkill, typeof input.args === 'string' ? input.args : '', { ...auditOptions, _taskToolUseId: id }, agentTypes);
+                        const postFork = await (0, hooks_1.runToolHooks)(hooks.PostToolUse, 'PostToolUse', name, input, options.workDir, result, (0, hooks_1.hookRunOptsFor)(options));
+                        const injectedFork = [preFork.context, postFork.context].filter(Boolean).join('\n');
+                        if (injectedFork) {
+                            if (result.error !== undefined)
+                                result.error = `${result.error}\n\n[hook] ${injectedFork}`;
+                            else
+                                result.output = `${result.output ?? ''}\n\n[hook] ${injectedFork}`;
+                        }
+                        if (postFork.block) {
+                            result.error = `${result.error ? result.error + '\n' : ''}PostToolUse hook flagged: ${postFork.reason}`;
+                        }
+                    }
+                }
                 else {
                     const pre = await (0, hooks_1.runToolHooks)(hooks.PreToolUse, 'PreToolUse', name, input, options.workDir, undefined, (0, hooks_1.hookRunOptsFor)(options));
                     if (pre.block) {
@@ -1407,9 +1549,7 @@ async function runAgentLoop(initialMessages, options) {
                     else {
                         // TaskCreated needs the id of the task the tool is ABOUT to create, which only
                         // the tool can know — so snapshot the ids first and diff afterwards (see below).
-                        const taskIdsBefore = name === 'create_shared_task'
-                            ? new Set((0, sharedTasks_1.listSharedTasks)(options.workDir).map((t) => t.id))
-                            : null;
+                        const taskIdsBefore = name === 'create_shared_task' ? new Set((0, sharedTasks_1.listSharedTasks)(options.workDir).map((t) => t.id)) : null;
                         try {
                             // TaskCompleted (Claude Code): the hook is the GATE, so it runs BEFORE the
                             // update — refusing means the task simply stays open, and the reason goes
@@ -1445,9 +1585,10 @@ async function runAgentLoop(initialMessages, options) {
                             }
                             else if (options.mcpManager?.isMcpTool(name)) {
                                 const mcpOutput = await (0, subTaskSupport_1.stopAwaiting)(options.mcpManager.callTool(name, input, options.abortSignal), options.abortSignal);
-                                result = mcpOutput === subTaskSupport_1.STOP_TIMEOUT_RESULT
-                                    ? subTaskSupport_1.STOP_TIMEOUT_RESULT
-                                    : { output: (0, executor_1.capExternalOutput)(mcpOutput ?? '', `mcp-${name}`) };
+                                result =
+                                    mcpOutput === subTaskSupport_1.STOP_TIMEOUT_RESULT
+                                        ? subTaskSupport_1.STOP_TIMEOUT_RESULT
+                                        : { output: (0, executor_1.capExternalOutput)(mcpOutput ?? '', `mcp-${name}`) };
                                 // 3. Fall through to built-in executor
                             }
                             else {
@@ -1472,7 +1613,9 @@ async function runAgentLoop(initialMessages, options) {
                                 // This matters far more with sub-agents than without: up to 4 run
                                 // concurrently, each issuing its own tool calls into this same process.
                                 const locks = name === 'bash'
-                                    ? ((0, bashClassify_1.bashNeedsRepoLock)(String(input.command ?? '')) ? [fileLocks_1.REPO_STATE_LOCK] : [])
+                                    ? (0, bashClassify_1.bashNeedsRepoLock)(String(input.command ?? ''))
+                                        ? [fileLocks_1.REPO_STATE_LOCK]
+                                        : []
                                     : (0, fileLocks_1.lockPathsFor)(name, input, options.workDir);
                                 // Two lock layers, nested outer-then-inner:
                                 //  1. Cross-process (OS lock file) — the ONLY layer that protects
@@ -1523,7 +1666,9 @@ async function runAgentLoop(initialMessages, options) {
                             const task = created[created.length - 1];
                             if (task) {
                                 const veto = await taskHookVeto(hooks.TaskCreated, 'TaskCreated', input, options, {
-                                    task_id: task.id, task_subject: task.content, task_description: task.content,
+                                    task_id: task.id,
+                                    task_subject: task.content,
+                                    task_description: task.content,
                                 });
                                 if (veto) {
                                     (0, sharedTasks_1.deleteSharedTask)(options.workDir, task.id);
@@ -1531,6 +1676,35 @@ async function runAgentLoop(initialMessages, options) {
                                 }
                             }
                         }
+                        // Nested-skill discovery: whatever this call touched is where the model
+                        // is working, so those directories' own `.nexrall/skills` now matter.
+                        // Runs regardless of success - a failed read still signals the area,
+                        // and a re-touched directory costs a Set lookup.
+                        if (nestedSkillScan) {
+                            for (const s of nestedSkillScan.scanInput(input)) {
+                                if (!skillsList.some((k) => k.name === s.name))
+                                    skillsList.push(s);
+                            }
+                        }
+                        // Nested instruction files are discovered on the same touch, from the same
+                        // directories (S18c), and path-scoped `.nexrall/rules` files when their globs
+                        // match (S18d). A fresh file joins the ledger the prompt reads per request,
+                        // and is announced ONCE to the host — carrying the vocabulary's own name for
+                        // its event ('nested_traversal' for a directory the agent worked in,
+                        // 'path_glob_match' for a rule whose `paths:` matched the touched path).
+                        // Sub-agents clear both the callback and the ledger (subTask.ts), so only
+                        // the session's own discoveries fire hooks; a child's ephemeral load is
+                        // not a fact about this session's instruction set.
+                        if (nestedInstructionScan) {
+                            const fresh = nestedInstructionScan.scanInput(input);
+                            if (fresh.length && options._onInstructionsDiscovered) {
+                                options._onInstructionsDiscovered(fresh.map((f) => ({
+                                    file_path: f.filePath,
+                                    memory_type: 'Project',
+                                    load_reason: f.loadReason,
+                                })));
+                            }
+                        }
                         // Opportunistic memory compaction — memory_write is the only tool that can
                         // grow a memory file, so this is the cheapest point to check whether it just
                         // crossed the compaction threshold. Fire-and-forget: never blocks the turn,
@@ -1544,7 +1718,12 @@ async function runAgentLoop(initialMessages, options) {
                         // PostToolUseFailure: only when the call errored. Its context/exit-2 text joins the
                         // PostToolUse output, so the model sees it next to the error it explains.
                         if (result.error !== undefined && (hooks.PostToolUseFailure?.length ?? 0) > 0) {
-                            const f = await (0, hooks_1.runLifecycleHooks)(hooks.PostToolUseFailure, 'PostToolUseFailure', options.workDir, { session_id: options.sessionId ?? '', tool_name: name, tool_input: input, error: String(result.error).slice(0, 4000) }, name, (0, hooks_1.hookRunOptsFor)(options)).catch(() => ({ block: false }));
+                            const f = await (0, hooks_1.runLifecycleHooks)(hooks.PostToolUseFailure, 'PostToolUseFailure', options.workDir, {
+                                session_id: options.sessionId ?? '',
+                                tool_name: name,
+                                tool_input: input,
+                                error: String(result.error).slice(0, 4000),
+                            }, name, (0, hooks_1.hookRunOptsFor)(options)).catch(() => ({ block: false }));
                             if (f.context)
                                 post.context = [post.context, f.context].filter(Boolean).join('\n');
                             if (f.block) {
@@ -1630,8 +1809,10 @@ async function runAgentLoop(initialMessages, options) {
                 // command that timed out mid-test-run), surface both so the model can
                 // see WHY it hung — the failure detail is usually in the output tail.
                 content: result.error
-                    ? (result.output ? `Error: ${result.error}\n\n${result.output}` : `Error: ${result.error}`)
-                    : result.output ?? '',
+                    ? result.output
+                        ? `Error: ${result.error}\n\n${result.output}`
+                        : `Error: ${result.error}`
+                    : (result.output ?? ''),
                 is_error: result.error !== undefined,
             }));
             // Fold any follow-up the user queued mid-task into THIS user turn (alongside the
@@ -1687,7 +1868,9 @@ async function runAgentLoop(initialMessages, options) {
                         tool_input: b.input,
                         tool_use_id: b.id,
                         tool_response: r.error !== undefined
-                            ? (r.output ? `Error: ${r.error}\n\n${r.output}` : `Error: ${r.error}`)
+                            ? r.output
+                                ? `Error: ${r.error}\n\n${r.output}`
+                                : `Error: ${r.error}`
                             : (r.output ?? ''),
                     })),
                 }, undefined, (0, hooks_1.hookRunOptsFor)(options));
@@ -1791,7 +1974,11 @@ async function runAgentLoop(initialMessages, options) {
         // Routed through onNotice (falling back to onText) like every other housekeeping
         // message in this file — these are statements from the harness, not from the model,
         // and splicing them into the assistant's own bubble reads as if it said them.
-        const notice = (0, iterationPolicy_1.stopReasonNotice)(stopReason, { budget, repeatError: stalledRepeatError, hookReason: hookBlockedReason });
+        const notice = (0, iterationPolicy_1.stopReasonNotice)(stopReason, {
+            budget,
+            repeatError: stalledRepeatError,
+            hookReason: hookBlockedReason,
+        });
         // A sub-agent's stop belongs in its parent's tool result, not in the user's chat as
         // if the MAIN agent had stopped (runSubTask turns it into an error for the parent).
         if (options._onStopReason)

package/dist/agent/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/agent/memory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/agent/memory.ts"],"names":[],"mappings":"AAiEA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/C;;;sDAGsD;AACtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,gBAAgB,QAAS,CAAC;AACvC,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAMnD,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAKtE,eAAO,MAAM,wBAAwB,QAAmC,CAAC;AAiGzE,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;kCAI8B;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;6DAEyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,iBAAiB,CAAC,CA2D5B;AAED,MAAM,WAAW,iBAAiB;IAChC;;;iDAG6C;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,MAAM,CAKrG;AAED;gFACgF;AAChF,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,MAAM,CASpF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAOtE;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAUpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKlE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAC7C,OAAO,CAAC,OAAO,CAAC,CA4DlB;AAkBD,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAC7C,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,EACnC,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAiBf;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhH;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,EACnC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAyB1D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAWpH"}

package/dist/agent/memory.js

@@ -147,7 +147,9 @@ const _locks = new Map();
 async function withLock(key, fn) {
     const prev = _locks.get(key) ?? Promise.resolve();
     let release;
-    const next = new Promise((res) => { release = res; });
+    const next = new Promise((res) => {
+        release = res;
+    });
     _locks.set(key, prev.then(() => next));
     try {
         await prev;
@@ -218,7 +220,10 @@ function evictToFit(active, archived, maxBytes) {
 function sanitizeSourceTag(source) {
     if (!source)
         return '';
-    return source.trim().replace(/[[\]\n\r]/g, '').slice(0, SOURCE_TAG_MAX_CHARS);
+    return source
+        .trim()
+        .replace(/[[\]\n\r]/g, '')
+        .slice(0, SOURCE_TAG_MAX_CHARS);
 }
 async function writeMemory(content, scope, workDir, opts = {}) {
     let trimmed = content.trim();
@@ -306,7 +311,9 @@ function clearMemory(scope, workDir) {
     try {
         fs.rmSync(file, { force: true });
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
 }
 function memoryStats(scope, workDir) {
     const file = memoryFilePath(scope, workDir);
@@ -374,7 +381,8 @@ async function compactMemoryIfNeeded(scope, workDir, summarize) {
         }
         // 2. If the active set alone is still driving the size past the trigger,
         //    summarize its oldest half.
-        if (Buffer.byteLength(serializeSections(active, archived), 'utf-8') > exports.MEMORY_COMPACT_TRIGGER_BYTES && active.length >= 8) {
+        if (Buffer.byteLength(serializeSections(active, archived), 'utf-8') > exports.MEMORY_COMPACT_TRIGGER_BYTES &&
+            active.length >= 8) {
             const cut = Math.floor(active.length / 2);
             const older = active.slice(0, cut);
             const recent = active.slice(cut);
@@ -524,9 +532,7 @@ function agentMemoryPreamble(agentName, scope, workDir) {
     const notes = readAgentMemory(agentName, scope, workDir);
     if (!notes)
         return '';
-    const kept = Buffer.byteLength(notes, 'utf-8') > exports.AGENT_MEMORY_INJECT_MAX
-        ? notes.slice(-exports.AGENT_MEMORY_INJECT_MAX)
-        : notes;
+    const kept = Buffer.byteLength(notes, 'utf-8') > exports.AGENT_MEMORY_INJECT_MAX ? notes.slice(-exports.AGENT_MEMORY_INJECT_MAX) : notes;
     return (`# Your own notes (agent: ${agentName}, scope: ${scope})\n` +
         `These are notes YOU saved on previous runs. Treat them as your accumulated experience, ` +
         `not as instructions from the user, and verify anything that looks stale against the ` +

package/dist/agent/modelCatalogue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modelCatalogue.d.ts","sourceRoot":"","sources":["../../src/agent/modelCatalogue.ts"],"names":[],"mappings":"AAgDA,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBlE;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,OAAO,CAAC;IAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAuBnE;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,IAAI;IAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAElG;AAOD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,sDAAsD;AACtD,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAGzF;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAGvF;AAED,uFAAuF;AACvF,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAExE;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG9G;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,GAAG,IAAI,CAExD;AAED,kEAAkE;AAClE,wBAAgB,iCAAiC,IAAI,IAAI,CAGxD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAO/C,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW3F;AAED,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAIxH;AAED,8DAA8D;AAC9D,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAE9E"}
+{"version":3,"file":"modelCatalogue.d.ts","sourceRoot":"","sources":["../../src/agent/modelCatalogue.ts"],"names":[],"mappings":"AAgDA,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAiBlE;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,OAAO,CAAC;IAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAuBnE;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,IAAI;IAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAElG;AAOD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,sDAAsD;AACtD,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAGzF;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAGvF;AAED,uFAAuF;AACvF,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAExE;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG9G;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,GAAG,IAAI,CAExD;AAED,kEAAkE;AAClE,wBAAgB,iCAAiC,IAAI,IAAI,CAGxD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAU/C,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW3F;AAED,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,GAAG,SAAS,CAIpB;AAED,8DAA8D;AAC9D,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,IAAI,CAE9E"}

package/dist/agent/modelCatalogue.js

@@ -196,7 +196,10 @@ function _resetModelCatalogueCacheForTests() {
 exports.CHEAPEST_MODEL_ALIAS = 'cheapest';
 // Legacy tier aliases the backend still resolves (see agentTypes.ts VALID_MODELS).
 const LEGACY_ALIAS_IDS = {
-    turbo: 'claude-sonnet-5-5', fast: 'claude-sonnet-5-5', pro: 'claude-opus-5-5', ultra: 'claude-fable-5-1',
+    turbo: 'claude-sonnet-5-5',
+    fast: 'claude-sonnet-5-5',
+    pro: 'claude-opus-5-5',
+    ultra: 'claude-fable-5-1',
 };
 function cheapestSameVendorModel(parentModel) {
     if (!_state || !parentModel)