lsd-pi 1.1.2 → 1.1.3

package/dist/resources/extensions/memory/extension-manifest.json

@@ -5,7 +5,7 @@
   "description": "Persistent file-based memory across sessions",
   "tier": "bundled",
   "provides": {
-    "hooks": ["session_start", "before_agent_start", "session_shutdown"],
-    "commands": ["memories", "remember", "forget"]
+    "hooks": ["session_start", "before_agent_start", "turn_end", "tool_call", "session_shutdown"],
+    "commands": ["memories", "remember", "forget", "dream", "auto-dream"]
   }
 }

package/dist/resources/extensions/memory/index.js

@@ -7,15 +7,15 @@
  * Memory files live under ~/.lsd/memory/<sanitized-project-path>/ and are
  * indexed by a MEMORY.md entrypoint that is always loaded into context.
  */
+import { isToolCallEventType, } from '@gsd/pi-coding-agent';
 import { readFileSync, existsSync, writeFileSync } from 'node:fs';
 import { getMemoryDir, getMemoryEntrypoint, ensureMemoryDir } from './memory-paths.js';
 import { MEMORY_FRONTMATTER_EXAMPLE, TYPES_SECTION, WHAT_NOT_TO_SAVE_SECTION, WHEN_TO_ACCESS_SECTION, TRUSTING_RECALL_SECTION, } from './memory-types.js';
 import { scanMemoryFiles } from './memory-scan.js';
 import { memoryAge } from './memory-age.js';
 import { extractMemories } from './auto-extract.js';
+import { formatDreamStatus, isMaintenanceModeToolAllowed, maybeStartAutoDream, readAutoDreamSettings, setProjectAutoDreamEnabled, startDream, } from './dream.js';
 // ── Constants ────────────────────────────────────────────────────────
-/** Name of the entrypoint file that indexes all memories. */
-const ENTRYPOINT_NAME = 'MEMORY.md';
 /** Maximum number of lines loaded from MEMORY.md into context. */
 const MAX_ENTRYPOINT_LINES = 200;
 /** Maximum byte size loaded from MEMORY.md into context. */
@@ -109,14 +109,17 @@ ${MEMORY_FRONTMATTER_EXAMPLE.join('\n')}
  * Memory extension for LSD.
  *
  * Lifecycle:
- *   session_start     → bootstrap memory directory & MEMORY.md
+ *   session_start      → bootstrap memory directory & MEMORY.md
  *   before_agent_start → inject memory system prompt
+ *   turn_end           → check auto-dream gates and start background consolidation
  *   session_shutdown   → fire-and-forget auto-extract of new memories
  *
  * Commands:
- *   /memories  — list all saved memories
- *   /remember  — save a memory immediately
- *   /forget    — remove a memory by topic
+ *   /memories    — list all saved memories
+ *   /remember    — save a memory immediately
+ *   /forget      — remove a memory by topic
+ *   /dream       — run memory consolidation now or show dream status
+ *   /auto-dream  — enable/disable/show auto-dream status
  */
 export default function memoryExtension(pi) {
     let memoryCwd = '';
@@ -153,12 +156,49 @@ export default function memoryExtension(pi) {
             systemPrompt: event.systemPrompt + '\n\n' + prompt,
         };
     });
+    // ── turn_end: check auto-dream gates ───────────────────────────────
+    pi.on('turn_end', async (_event, ctx) => {
+        if (!memoryCwd)
+            return;
+        const result = maybeStartAutoDream(ctx);
+        if (result.started) {
+            pi.sendMessage({
+                customType: 'memory:auto-dream',
+                content: result.message,
+                display: true,
+            });
+        }
+    });
+    // ── tool_call: restrict background maintenance workers ─────────────
+    pi.on('tool_call', async (event, ctx) => {
+        if (!(process.env.LSD_MEMORY_EXTRACT === '1' || process.env.LSD_MEMORY_DREAM === '1'))
+            return;
+        if (isMaintenanceModeToolAllowed(event.toolName, event.input, ctx.cwd)) {
+            return;
+        }
+        if (isToolCallEventType('write', event) || isToolCallEventType('edit', event)) {
+            return {
+                block: true,
+                reason: `Memory maintenance workers may only write inside the memory directory. Blocked path: ${event.input.path}`,
+            };
+        }
+        if (isToolCallEventType('bash', event)) {
+            return {
+                block: true,
+                reason: 'Memory maintenance workers may only run read-only bash commands.',
+            };
+        }
+        return {
+            block: true,
+            reason: `Tool ${event.toolName} is blocked for memory maintenance workers.`,
+        };
+    });
     // ── session_shutdown: trigger auto-extract ────────────────────────
     pi.on('session_shutdown', async (_event, ctx) => {
         if (!memoryCwd)
             return;
-        // Don't extract if this IS the extraction agent
-        if (process.env.LSD_MEMORY_EXTRACT === '1')
+        // Don't extract if this IS the extraction or dream worker
+        if (process.env.LSD_MEMORY_EXTRACT === '1' || process.env.LSD_MEMORY_DREAM === '1')
             return;
         try {
             extractMemories(ctx, memoryCwd);
@@ -220,4 +260,71 @@ export default function memoryExtension(pi) {
             pi.sendUserMessage(`Please find and remove any memories about: ${topic}`);
         },
     });
+    /**
+     * /dream — run a consolidation pass now, or show dream status.
+     */
+    pi.registerCommand('dream', {
+        description: 'Run memory consolidation now or show dream status',
+        handler: async (args, ctx) => {
+            if (!memoryCwd)
+                return;
+            const subcommand = args.trim().toLowerCase();
+            if (subcommand === 'status') {
+                pi.sendMessage({
+                    customType: 'memory:dream-status',
+                    content: formatDreamStatus(ctx),
+                    display: true,
+                });
+                return;
+            }
+            const result = startDream(ctx, { trigger: 'manual' });
+            pi.sendMessage({
+                customType: 'memory:dream',
+                content: result.message,
+                display: true,
+            });
+        },
+    });
+    /**
+     * /auto-dream — enable, disable, or inspect project auto-dream.
+     */
+    pi.registerCommand('auto-dream', {
+        description: 'Enable, disable, or show project auto-dream status',
+        handler: async (args, ctx) => {
+            if (!memoryCwd)
+                return;
+            const subcommand = args.trim().toLowerCase();
+            if (subcommand === 'on') {
+                const settings = setProjectAutoDreamEnabled(memoryCwd, true);
+                pi.sendMessage({
+                    customType: 'memory:auto-dream-settings',
+                    content: `Auto-dream enabled for this project. Thresholds: ${settings.minHours}h / ${settings.minSessions} sessions.`,
+                    display: true,
+                });
+                return;
+            }
+            if (subcommand === 'off') {
+                const settings = setProjectAutoDreamEnabled(memoryCwd, false);
+                pi.sendMessage({
+                    customType: 'memory:auto-dream-settings',
+                    content: `Auto-dream disabled for this project. Thresholds remain ${settings.minHours}h / ${settings.minSessions} sessions.`,
+                    display: true,
+                });
+                return;
+            }
+            const settings = readAutoDreamSettings(memoryCwd);
+            pi.sendMessage({
+                customType: 'memory:auto-dream-status',
+                content: [
+                    'Auto-Dream Settings',
+                    '',
+                    `- Enabled: ${settings.enabled ? 'yes' : 'no'}`,
+                    `- Thresholds: ${settings.minHours}h / ${settings.minSessions} sessions`,
+                    '',
+                    formatDreamStatus(ctx),
+                ].join('\n'),
+                display: true,
+            });
+        },
+    });
 }

package/dist/resources/extensions/slash-commands/extension-manifest.json

@@ -1,12 +1,12 @@
 {
-  "id": "slash-commands",
-  "name": "Slash Commands",
-  "version": "1.0.0",
-  "description": "Boilerplate generators for slash commands, extensions, and audit tools",
-  "tier": "bundled",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "commands": ["create-slash-command", "create-extension", "audit", "clear", "plan", "execute", "cancel-plan"],
-    "flags": ["plan"]
-  }
+	"id": "slash-commands",
+	"name": "Slash Commands",
+	"version": "1.0.0",
+	"description": "Bundled slash commands for audit, clearing state, and plan workflows",
+	"tier": "bundled",
+	"requires": { "platform": ">=2.29.0" },
+	"provides": {
+		"commands": ["audit", "clear", "plan", "execute", "cancel-plan"],
+		"flags": ["plan"]
+	}
 }

package/dist/resources/extensions/slash-commands/index.js

@@ -1,11 +1,7 @@
-import createSlashCommand from "./create-slash-command.js";
-import createExtension from "./create-extension.js";
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import planCommand from "./plan.js";
 export default function slashCommands(pi) {
-    createSlashCommand(pi);
-    createExtension(pi);
     auditCommand(pi);
     clearCommand(pi);
     planCommand(pi);

package/dist/resources/extensions/slash-commands/plan.js

@@ -1,6 +1,6 @@
-import { mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { getAgentDir, getPermissionMode, isToolCallEventType, setPermissionMode } from "@gsd/pi-coding-agent";
 import { join } from "node:path";
-import { getPermissionMode, isToolCallEventType, setPermissionMode } from "@gsd/pi-coding-agent";
 const PLAN_ENTRY_TYPE = "plan-mode-state";
 const PLAN_APPROVAL_QUESTION_ID = "plan_mode_approval";
 const PLAN_DIR_RE = /(^|[/\\])\.(?:lsd|gsd)[/\\]plan([/\\]|$)/;
@@ -56,15 +56,64 @@ const BLOCKED_TOOLS = new Set([
     "write",
     "edit",
 ]);
-let state = {
+const DEFAULT_APPROVAL_PERMISSION_MODE = "auto";
+const APPROVE_AUTO_LABEL = "Approve & switch to Auto mode";
+const APPROVE_BYPASS_LABEL = "Approve & switch to Bypass mode";
+const REVISE_LABEL = "Revise plan";
+const CANCEL_LABEL = "Cancel";
+const INITIAL_STATE = {
     active: false,
     task: "",
+    latestPlanPath: undefined,
     approvalStatus: "cancelled",
+    previousMode: undefined,
+    preplanModel: undefined,
+    targetPermissionMode: undefined,
 };
+let state = { ...INITIAL_STATE };
 let startedFromFlag = false;
 function isPlanModeActive() {
     return getPermissionMode() === "plan";
 }
+function parseQualifiedModelRef(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const parts = trimmed.split("/");
+    if (parts.length !== 2)
+        return undefined;
+    const [provider, id] = parts.map((part) => part.trim());
+    if (!provider || !id)
+        return undefined;
+    return { provider, id };
+}
+export function readPlanModeReasoningModel() {
+    try {
+        const settingsPath = join(getAgentDir(), "settings.json");
+        if (!existsSync(settingsPath))
+            return undefined;
+        const raw = readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const model = parseQualifiedModelRef(parsed.planModeReasoningModel);
+        return model ? `${model.provider}/${model.id}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameModel(left, right) {
+    return !!left && !!right && left.provider === right.provider && left.id === right.id;
+}
+function resolveModelFromContext(ctx, modelRef) {
+    const allModels = typeof ctx?.modelRegistry?.getAll === "function" ? ctx.modelRegistry.getAll() : [];
+    return allModels.find((model) => model.provider === modelRef.provider && model.id === modelRef.id);
+}
+function setPermissionModeAndEnv(mode) {
+    setPermissionMode(mode);
+    process.env.LUCENT_CODE_PERMISSION_MODE = mode;
+}
 function saveState(pi) {
     pi.appendEntry(PLAN_ENTRY_TYPE, { ...state });
 }
@@ -72,15 +121,11 @@ function setState(pi, next) {
     state = next;
     saveState(pi);
 }
-function clearState(pi) {
-    state = {
-        active: false,
-        task: "",
-        latestPlanPath: undefined,
-        approvalStatus: "cancelled",
-        previousMode: undefined,
-    };
-    saveState(pi);
+function resetState(pi, overrides = {}) {
+    setState(pi, {
+        ...INITIAL_STATE,
+        ...overrides,
+    });
 }
 function ensurePlanDir() {
     const dir = join(process.cwd(), ".lsd", "plan");
@@ -102,32 +147,63 @@ function restoreStateFromSession(ctx) {
         // Best-effort restore only.
     }
 }
-function enablePlanMode(pi, next = {}) {
+function enablePlanMode(pi, currentModel, next = {}) {
     const currentMode = getPermissionMode();
-    const previousMode = currentMode === "plan"
-        ? (state.previousMode ?? "accept-on-edit")
-        : currentMode;
-    setPermissionMode("plan");
-    process.env.LUCENT_CODE_PERMISSION_MODE = "plan";
+    const enteringPlanMode = currentMode !== "plan";
+    const previousMode = enteringPlanMode
+        ? currentMode
+        : (state.previousMode ?? "accept-on-edit");
+    setPermissionModeAndEnv("plan");
     setState(pi, {
         active: true,
         task: next.task ?? state.task,
         latestPlanPath: next.latestPlanPath ?? state.latestPlanPath,
         approvalStatus: next.approvalStatus ?? state.approvalStatus ?? "pending",
         previousMode: next.previousMode ?? previousMode,
+        preplanModel: next.preplanModel ?? (enteringPlanMode ? (currentModel ?? state.preplanModel) : state.preplanModel),
+        targetPermissionMode: next.targetPermissionMode ?? state.targetPermissionMode,
     });
 }
-function disablePlanMode(pi, approvalStatus, clearTask = false) {
-    const restoreMode = state.previousMode ?? "accept-on-edit";
-    setPermissionMode(restoreMode);
-    process.env.LUCENT_CODE_PERMISSION_MODE = restoreMode;
+function leavePlanMode(pi, approvalStatus, nextPermissionMode, clearTask = false) {
+    setPermissionModeAndEnv(nextPermissionMode);
     setState(pi, {
         active: false,
         task: clearTask ? "" : state.task,
         latestPlanPath: state.latestPlanPath,
         approvalStatus,
-        previousMode: restoreMode,
+        previousMode: state.previousMode,
+        preplanModel: state.preplanModel,
+        targetPermissionMode: state.targetPermissionMode ?? nextPermissionMode,
     });
+    return nextPermissionMode;
+}
+async function setModelIfNeeded(pi, ctx, modelRef) {
+    if (!modelRef)
+        return;
+    const currentModel = parseQualifiedModelRef(ctx?.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
+    if (sameModel(currentModel, modelRef))
+        return;
+    const model = resolveModelFromContext(ctx, modelRef);
+    if (!model)
+        return;
+    await pi.setModel(model, { persist: false });
+}
+async function approvePlan(pi, ctx, permissionMode) {
+    const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
+    if (reasoningModel) {
+        await setModelIfNeeded(pi, ctx, reasoningModel);
+    }
+    state = {
+        ...state,
+        targetPermissionMode: permissionMode,
+    };
+    leavePlanMode(pi, "approved", permissionMode);
+}
+async function cancelPlan(pi, ctx, clearTask = true) {
+    const restoreMode = state.previousMode ?? "accept-on-edit";
+    await setModelIfNeeded(pi, ctx, state.preplanModel);
+    leavePlanMode(pi, "cancelled", restoreMode, clearTask);
+    resetState(pi, { approvalStatus: "cancelled" });
     return restoreMode;
 }
 function buildPlanModeSystemPrompt() {
@@ -143,6 +219,49 @@ function buildPlanModeSystemPrompt() {
         details.push(`Latest plan artifact: ${state.latestPlanPath}`);
     return details.join(" ");
 }
+function buildApprovalSteeringMessage(planPath) {
+    return [
+        `Plan artifact saved at ${planPath}.`,
+        "Present approval options now using ask_user_questions with exactly one single-select question.",
+        `Use question id \"${PLAN_APPROVAL_QUESTION_ID}\" and ask the user what to do next.`,
+        "Important: ask_user_questions single-select supports only 2-3 explicit options.",
+        "Use exactly these 3 options:",
+        `1. ${APPROVE_AUTO_LABEL} (Recommended)`,
+        `2. ${APPROVE_BYPASS_LABEL}`,
+        `3. ${REVISE_LABEL}`,
+        `Do not include \"${CANCEL_LABEL}\" as an explicit option. If the user wants to cancel, they should choose \"None of the above\" and type \"${CANCEL_LABEL}\" in the free-text note.`,
+        "If the dialog is dismissed or the user gives no answer, continue planning.",
+    ].join(" ");
+}
+function approvalSelectionToPermissionMode(selected) {
+    if (selected.includes(APPROVE_AUTO_LABEL))
+        return "auto";
+    if (selected.includes(APPROVE_BYPASS_LABEL))
+        return "danger-full-access";
+    return undefined;
+}
+function selectionRequestsCancel(selected) {
+    const values = Array.isArray(selected) ? selected : [selected];
+    return values.some((value) => {
+        if (typeof value !== "string")
+            return false;
+        if (value.includes(CANCEL_LABEL))
+            return true;
+        const normalized = value.replace(/^user_note:\s*/i, "").trim().toLowerCase();
+        return normalized === "cancel" || normalized.includes("cancel plan");
+    });
+}
+export const __testing = {
+    getState() {
+        return { ...state };
+    },
+    resetState() {
+        state = { ...INITIAL_STATE };
+        startedFromFlag = false;
+    },
+    parseQualifiedModelRef,
+    approvalSelectionToPermissionMode,
+};
 export default function planCommand(pi) {
     pi.registerFlag("plan", {
         description: "Start the session in plan mode and require a persisted .lsd/plan markdown plan before execution",
@@ -152,8 +271,7 @@ export default function planCommand(pi) {
         restoreStateFromSession(ctx);
         startedFromFlag = false;
         if (state.active) {
-            setPermissionMode("plan");
-            process.env.LUCENT_CODE_PERMISSION_MODE = "plan";
+            setPermissionModeAndEnv("plan");
         }
     });
     pi.on("before_agent_start", async () => {
@@ -163,16 +281,18 @@ export default function planCommand(pi) {
             systemPrompt: buildPlanModeSystemPrompt(),
         };
     });
-    pi.on("input", async (event) => {
+    pi.on("input", async (event, ctx) => {
         const planFlag = pi.getFlag("plan");
         if (startedFromFlag || planFlag !== true || event.source !== "interactive") {
             return { action: "continue" };
         }
         startedFromFlag = true;
         ensurePlanDir();
-        enablePlanMode(pi, {
+        enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
             task: event.text.trim(),
             approvalStatus: "pending",
+            latestPlanPath: undefined,
+            targetPermissionMode: undefined,
         });
         return { action: "continue" };
     });
@@ -204,16 +324,22 @@ export default function planCommand(pi) {
             };
         }
     });
-    pi.on("tool_result", async (event) => {
+    pi.on("tool_result", async (event, ctx) => {
         if (event.toolName === "write" || event.toolName === "edit") {
             const input = event.input;
             const path = input?.path;
-            if (path && PLAN_DIR_RE.test(path)) {
+            if (path && PLAN_DIR_RE.test(path) && isPlanModeActive()) {
                 setState(pi, {
                     ...state,
                     latestPlanPath: path,
-                    approvalStatus: state.approvalStatus === "revising" ? "pending" : state.approvalStatus,
+                    approvalStatus: "pending",
+                    targetPermissionMode: undefined,
                 });
+                if (!ctx.hasUI) {
+                    await approvePlan(pi, ctx, DEFAULT_APPROVAL_PERMISSION_MODE);
+                    return;
+                }
+                pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
             }
             return;
         }
@@ -225,35 +351,43 @@ export default function planCommand(pi) {
         const answer = details.response.answers[PLAN_APPROVAL_QUESTION_ID];
         if (!answer)
             return;
-        const selected = Array.isArray(answer.selected) ? answer.selected[0] : answer.selected;
-        if (typeof selected !== "string")
+        const selected = Array.isArray(answer.selected) ? answer.selected : [answer.selected];
+        if (!selected.every((value) => typeof value === "string"))
             return;
-        if (selected.includes("Approve plan")) {
-            disablePlanMode(pi, "approved");
+        const targetPermissionMode = approvalSelectionToPermissionMode(selected[0]);
+        if (targetPermissionMode) {
+            state = {
+                ...state,
+                targetPermissionMode,
+            };
+            await approvePlan(pi, ctx, targetPermissionMode);
             return;
         }
-        if (selected.includes("Revise plan")) {
-            enablePlanMode(pi, { approvalStatus: "revising" });
+        if (selected.some((value) => value.includes(REVISE_LABEL))) {
+            enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
+                approvalStatus: "revising",
+            });
             return;
         }
-        if (selected.includes("Cancel")) {
-            disablePlanMode(pi, "cancelled", true);
-            clearState(pi);
+        if (selectionRequestsCancel(selected)) {
+            await cancelPlan(pi, ctx, true);
         }
     });
     pi.registerCommand("plan", {
         description: "Toggle plan mode. While active, only investigative tools and writes under .lsd/plan/ are allowed",
         async handler(args, ctx) {
             if (isPlanModeActive()) {
-                disablePlanMode(pi, "cancelled");
+                await cancelPlan(pi, ctx, true);
                 ctx.ui.notify("Plan mode disabled.", "info");
                 return;
             }
             ensurePlanDir();
             const task = args.trim();
-            enablePlanMode(pi, {
+            enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
                 task,
+                latestPlanPath: undefined,
                 approvalStatus: "pending",
+                targetPermissionMode: undefined,
             });
             ctx.ui.notify(task
                 ? `Plan mode enabled. Current task: ${task}`
@@ -267,17 +401,19 @@ export default function planCommand(pi) {
                 ctx.ui.notify("Plan mode is not active.", "info");
                 return;
             }
-            const restoreMode = disablePlanMode(pi, "approved");
-            ctx.ui.notify(`Plan mode disabled. Permission mode restored to ${restoreMode}.`, "info");
+            await approvePlan(pi, ctx, DEFAULT_APPROVAL_PERMISSION_MODE);
+            ctx.ui.notify(`Plan approved. Permission mode switched to ${DEFAULT_APPROVAL_PERMISSION_MODE}.`, "info");
         },
     });
     pi.registerCommand("cancel-plan", {
         description: "Cancel the current plan-mode session without executing",
         async handler(_args, ctx) {
             if (isPlanModeActive()) {
-                disablePlanMode(pi, "cancelled", true);
+                await cancelPlan(pi, ctx, true);
+            }
+            else {
+                resetState(pi, { approvalStatus: "cancelled" });
             }
-            clearState(pi);
             ctx.ui.notify("Plan mode cancelled.", "info");
         },
     });

package/dist/resources/extensions/subagent/agents.js

@@ -5,6 +5,19 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 const PROJECT_AGENT_DIR_CANDIDATES = [".lsd", ".gsd", ".pi"];
+function normalizeAgentModel(model) {
+    const trimmed = model?.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed === "$budget_model")
+        return trimmed;
+    if (trimmed.includes(" "))
+        return undefined;
+    if (!trimmed.includes("/"))
+        return trimmed;
+    const parts = trimmed.split("/");
+    return parts.length === 2 && parts.every(Boolean) ? trimmed : undefined;
+}
 function loadAgentsFromDir(dir, source) {
     const agents = [];
     if (!fs.existsSync(dir)) {
@@ -42,7 +55,7 @@ function loadAgentsFromDir(dir, source) {
             name: frontmatter.name,
             description: frontmatter.description,
             tools: tools && tools.length > 0 ? tools : undefined,
-            model: frontmatter.model,
+            model: normalizeAgentModel(frontmatter.model),
             systemPrompt: body,
             source,
             filePath,

package/dist/resources/extensions/subagent/configured-model.js

@@ -1,9 +1,10 @@
+import { normalizeSubagentModel } from "./model-resolution.js";
 export function resolveConfiguredSubagentModel(agent, preferences, settingsBudgetModel) {
     const configuredModel = agent.model?.trim();
     if (!configuredModel)
         return undefined;
     if (configuredModel === "$budget_model") {
-        return settingsBudgetModel?.trim() || preferences?.subagent?.budget_model?.trim() || undefined;
+        return normalizeSubagentModel(settingsBudgetModel) ?? normalizeSubagentModel(preferences?.subagent?.budget_model);
     }
-    return configuredModel;
+    return normalizeSubagentModel(configuredModel);
 }