pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/commands/command-controller.js

@@ -1,3 +1,4 @@
+import { GitCommandActions } from "./command-git-actions.js";
 import { ModelCommandActions } from "./command-model-actions.js";
 import { NavigationCommandActions } from "./command-navigation-actions.js";
 import { createSlashCommands } from "./command-registry.js";
@@ -6,11 +7,13 @@ export class AppCommandController {
     host;
     slashCommands;
     modelActions;
+    gitActions;
     sessionActions;
     navigationActions;
     constructor(host) {
         this.host = host;
         this.modelActions = new ModelCommandActions(host);
+        this.gitActions = new GitCommandActions(host);
         this.sessionActions = new SessionCommandActions(host);
         this.navigationActions = new NavigationCommandActions(host);
         this.slashCommands = createSlashCommands(this.registryActions(), host);
@@ -18,9 +21,15 @@ export class AppCommandController {
     async runResumeCommand(queryOrOptions = "") {
         await this.navigationActions.runResumeCommand(queryOrOptions);
     }
+    async runDraftSessionSelector() {
+        await this.navigationActions.runResumeCommand({ preserveStatus: true, placement: "draft-surface", draft: true });
+    }
     async runModelCommand(model) {
         await this.modelActions.runModelCommand(model);
     }
+    async runModelThinkingCommand(model, level) {
+        await this.modelActions.runModelThinkingCommand(model, level);
+    }
     async runThinkingCommand(level) {
         await this.modelActions.runThinkingCommand(level);
     }
@@ -35,6 +44,8 @@ export class AppCommandController {
             runThinkingSlashCommand: (argumentsText) => this.modelActions.runThinkingSlashCommand(argumentsText),
             runDefaultThinkingSlashCommand: (argumentsText) => this.modelActions.runDefaultThinkingSlashCommand(argumentsText),
             runEnhanceCommand: () => this.host.enhancePrompt(),
+            runCodeReviewCommand: () => this.gitActions.runCodeReviewCommand(),
+            runCommitMessageCommand: () => this.gitActions.runCommitMessageCommand(),
             runExportCommand: (argumentsText) => this.sessionActions.runExportCommand(argumentsText),
             runImportCommand: (argumentsText) => this.sessionActions.runImportCommand(argumentsText),
             runShareCommand: () => this.sessionActions.runShareCommand(),

package/dist/app/commands/command-git-actions.d.ts

@@ -0,0 +1,25 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { type AsyncProcessResult, type RunProcessOptions } from "../process.js";
+import { type CommandControllerHost } from "./command-host.js";
+export type GitAssistantKind = "review" | "commit-message";
+type GitProcessRunner = (command: string, args?: readonly string[], options?: RunProcessOptions) => Promise<AsyncProcessResult>;
+type GitAssistantRunner = (runtime: AgentSessionRuntime, kind: GitAssistantKind, diff: string) => Promise<string>;
+export type GitCommandActionsDeps = {
+    runProcess?: GitProcessRunner;
+    generateGitAssistantText?: GitAssistantRunner;
+};
+export declare class GitCommandActions {
+    private readonly host;
+    private readonly runProcess;
+    private readonly generateGitAssistantText;
+    constructor(host: CommandControllerHost, deps?: GitCommandActionsDeps);
+    runCodeReviewCommand(): Promise<void>;
+    runCommitMessageCommand(): Promise<void>;
+    private gitRoot;
+    private trackedDiff;
+    private reviewInput;
+    private untrackedFiles;
+}
+export declare function generateGitAssistantText(runtime: AgentSessionRuntime, kind: GitAssistantKind, diff: string): Promise<string>;
+export declare function loadGitAssistantModelRefs(cwd: string, kind: GitAssistantKind, homeDir?: string): string[];
+export {};

package/dist/app/commands/command-git-actions.js

@@ -0,0 +1,381 @@
+import { existsSync, lstatSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { getPixConfigPath, getProjectPixConfigPath } from "../../config.js";
+import { createId } from "../id.js";
+import { parseModelRef } from "../model/model-ref.js";
+import { runProcess } from "../process.js";
+import { captureCommandScope, isCommandScopeActive, } from "./command-host.js";
+import { getIdleRuntime } from "./command-runtime.js";
+const GIT_REVIEW_TIMEOUT_MS = 120_000;
+const GIT_COMMIT_MESSAGE_TIMEOUT_MS = 45_000;
+const GIT_REVIEW_MAX_TOKENS = 4_096;
+const GIT_COMMIT_MESSAGE_MAX_TOKENS = 768;
+const GIT_DIFF_MAX_CHARS = 200_000;
+const UNTRACKED_FILE_MAX_BYTES = 128 * 1024;
+const DEFAULT_GIT_REVIEW_MODEL = "openai-codex/gpt-5.6-luna:medium";
+const DEFAULT_GIT_COMMIT_MESSAGE_MODEL = "openai-codex/gpt-5.6-luna:minimal";
+const REVIEW_SYSTEM_PROMPT = `You review Git diffs as a senior software engineer.
+
+Focus on correctness, regressions, edge cases, security, data loss, concurrency, and missing tests.
+Report concrete findings in descending severity and include file/line context when the diff provides it.
+Do not invent problems or request unrelated refactors.
+Do not flag a deletion merely because code or functionality was removed. Report a deletion only when the diff gives concrete evidence of a surviving broken reference, violated contract, unintended data loss/security impact, or another specific regression.
+If there are no significant findings, say that clearly and briefly.
+Return concise Markdown suitable for a code-review panel.`;
+const COMMIT_MESSAGE_SYSTEM_PROMPT = `You write Git commit messages from staged diffs.
+
+Write an imperative subject line no longer than 72 characters.
+Add a short body only when it materially improves understanding.
+Describe what changed and why, not implementation trivia.
+Output only the final commit message. Do not use Markdown fences or commentary.`;
+export class GitCommandActions {
+    host;
+    runProcess;
+    generateGitAssistantText;
+    constructor(host, deps = {}) {
+        this.host = host;
+        this.runProcess = deps.runProcess ?? runProcess;
+        this.generateGitAssistantText = deps.generateGitAssistantText ?? generateGitAssistantText;
+    }
+    async runCodeReviewCommand() {
+        const runtime = getIdleRuntime(this.host, "code-review");
+        if (!runtime)
+            return;
+        const scope = captureCommandScope(this.host);
+        this.host.setStatus("collecting Git changes");
+        this.host.render();
+        const root = await this.gitRoot(runtime.cwd);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        const diff = await this.reviewInput(root);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        if (!diff.trim()) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "No Git changes to review." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.setStatus("reviewing Git changes");
+        this.host.render();
+        const review = await this.generateGitAssistantText(runtime, "review", diff);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Code review\n\n${review}` });
+        this.host.setSessionStatus(runtime.session);
+        this.host.toast.success("Code review complete");
+    }
+    async runCommitMessageCommand() {
+        const runtime = getIdleRuntime(this.host, "commit-message");
+        if (!runtime)
+            return;
+        const scope = captureCommandScope(this.host);
+        this.host.setStatus("reading staged changes");
+        this.host.render();
+        const root = await this.gitRoot(runtime.cwd);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        const stagedDiff = await this.trackedDiff(root, true);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        if (!stagedDiff.trim()) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "There are no staged changes to commit." });
+            this.host.setSessionStatus(runtime.session);
+            this.host.toast.info("No staged changes");
+            return;
+        }
+        this.host.setStatus("generating commit message");
+        this.host.render();
+        const message = await this.generateGitAssistantText(runtime, "commit-message", capGitInput(stagedDiff));
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: `Generated commit message\n\n${message}`,
+        });
+        this.host.setSessionStatus(runtime.session);
+        const action = await this.host.showMenu([
+            {
+                value: "commit",
+                label: "Commit staged changes",
+                description: firstLine(message),
+                variant: "accent",
+            },
+            { value: "cancel", label: "Cancel" },
+        ], { title: "Create Git commit?", searchable: false, preserveStatus: true });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        if (action !== "commit") {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Commit cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        const currentStagedDiff = await this.trackedDiff(root, true);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        if (currentStagedDiff !== stagedDiff) {
+            this.host.addEntry({
+                id: createId("error"),
+                kind: "error",
+                text: "Staged changes changed after the commit message was generated. Run /commit-message again before committing.",
+            });
+            this.host.setSessionStatus(runtime.session);
+            this.host.toast.warning("Staged changes changed");
+            return;
+        }
+        this.host.setStatus("creating Git commit");
+        this.host.render();
+        const result = await this.runProcess("git", ["commit", "-F", "-"], {
+            cwd: root,
+            input: `${message.trim()}\n`,
+            timeoutMs: 120_000,
+            maxBufferBytes: 256 * 1024,
+        });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        if (result.status !== 0) {
+            throw new Error(gitFailureMessage("git commit", result));
+        }
+        const detail = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: detail ? `Git commit created\n\n${detail}` : "Git commit created.",
+        });
+        this.host.setSessionStatus(runtime.session);
+        this.host.toast.success("Git commit created");
+    }
+    async gitRoot(cwd) {
+        const result = await this.runProcess("git", ["rev-parse", "--show-toplevel"], {
+            cwd,
+            timeoutMs: 10_000,
+            maxBufferBytes: 16 * 1024,
+        });
+        if (result.status !== 0)
+            throw new Error(gitFailureMessage("git rev-parse", result));
+        const root = result.stdout.trim();
+        if (!root)
+            throw new Error("Git repository root is unavailable");
+        return root;
+    }
+    async trackedDiff(root, staged) {
+        const args = ["diff", ...(staged ? ["--cached"] : []), "--no-ext-diff", "--no-color", "--minimal"];
+        const result = await this.runProcess("git", args, {
+            cwd: root,
+            timeoutMs: 20_000,
+            maxBufferBytes: GIT_DIFF_MAX_CHARS + 16 * 1024,
+        });
+        if (result.status !== 0)
+            throw new Error(gitFailureMessage(staged ? "git diff --cached" : "git diff", result));
+        return result.stdout;
+    }
+    async reviewInput(root) {
+        const staged = await this.trackedDiff(root, true);
+        const unstaged = await this.trackedDiff(root, false);
+        const untracked = await this.untrackedFiles(root);
+        const sections = [];
+        if (staged.trim())
+            sections.push(`# Staged changes\n\n${staged.trimEnd()}`);
+        if (unstaged.trim())
+            sections.push(`# Working tree changes\n\n${unstaged.trimEnd()}`);
+        if (untracked.trim())
+            sections.push(`# Untracked files\n\n${untracked.trimEnd()}`);
+        return capGitInput(sections.join("\n\n"));
+    }
+    async untrackedFiles(root) {
+        const result = await this.runProcess("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+            cwd: root,
+            timeoutMs: 10_000,
+            maxBufferBytes: GIT_DIFF_MAX_CHARS,
+        });
+        if (result.status !== 0)
+            throw new Error(gitFailureMessage("git ls-files", result));
+        const files = result.stdout.split("\0").filter(Boolean);
+        const sections = [];
+        let used = 0;
+        for (const file of files) {
+            const absolutePath = resolve(root, file);
+            const relativePath = relative(root, absolutePath);
+            if (isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(`..${sep}`))
+                continue;
+            const label = displayGitPath(file);
+            let body;
+            try {
+                const info = lstatSync(absolutePath);
+                if (info.isSymbolicLink()) {
+                    body = `new symbolic link -> ${readlinkSync(absolutePath)}`;
+                }
+                else if (!info.isFile()) {
+                    body = "non-regular file omitted";
+                }
+                else if (statSync(absolutePath).size > UNTRACKED_FILE_MAX_BYTES) {
+                    body = `file omitted: larger than ${UNTRACKED_FILE_MAX_BYTES} bytes`;
+                }
+                else {
+                    const bytes = readFileSync(absolutePath);
+                    body = bytes.includes(0)
+                        ? "binary file omitted"
+                        : bytes.toString("utf8").split(/\r?\n/u).map((line) => `+${line}`).join("\n");
+                }
+            }
+            catch {
+                body = "file became unavailable while collecting review input";
+            }
+            const section = `## ${label}\n\n--- /dev/null\n+++ b/${label}\n${body}`;
+            if (used + section.length > GIT_DIFF_MAX_CHARS) {
+                sections.push("[additional untracked files omitted: review input limit reached]");
+                break;
+            }
+            sections.push(section);
+            used += section.length;
+        }
+        return sections.join("\n\n");
+    }
+}
+export async function generateGitAssistantText(runtime, kind, diff) {
+    const normalizedDiff = diff.trim();
+    if (!normalizedDiff)
+        throw new Error("Git diff is empty");
+    const timeoutMs = kind === "review" ? GIT_REVIEW_TIMEOUT_MS : GIT_COMMIT_MESSAGE_TIMEOUT_MS;
+    const signal = AbortSignal.timeout(timeoutMs);
+    const modelRuntime = runtime.services.modelRuntime;
+    await modelRuntime.refresh({ signal });
+    let lastError;
+    for (const modelRef of loadGitAssistantModelRefs(runtime.cwd, kind)) {
+        if (signal.aborted)
+            throw signal.reason ?? new Error("Git assistant request aborted");
+        let parsed;
+        try {
+            parsed = parseModelRef(modelRef);
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+        const model = modelRuntime.getModel(parsed.provider, parsed.modelId);
+        if (!model) {
+            lastError = new Error(`Git assistant model not found: ${parsed.provider}/${parsed.modelId}`);
+            continue;
+        }
+        try {
+            const tokenLimit = kind === "review" ? GIT_REVIEW_MAX_TOKENS : GIT_COMMIT_MESSAGE_MAX_TOKENS;
+            const maxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, tokenLimit) : tokenLimit;
+            let output = "";
+            let streamError;
+            const stream = modelRuntime.streamSimple({ ...model, maxTokens }, {
+                systemPrompt: kind === "review" ? REVIEW_SYSTEM_PROMPT : COMMIT_MESSAGE_SYSTEM_PROMPT,
+                messages: [{
+                        role: "user",
+                        content: [
+                            kind === "review" ? "Review this diff." : "Write a commit message for this staged diff.",
+                            "<git-diff>",
+                            normalizedDiff,
+                            "</git-diff>",
+                        ].join("\n"),
+                        timestamp: Date.now(),
+                    }],
+            }, {
+                signal,
+                reasoning: parsed.thinkingLevel && parsed.thinkingLevel !== "off" ? parsed.thinkingLevel : "minimal",
+                cacheRetention: "none",
+                maxRetryDelayMs: 0,
+                maxRetries: 0,
+                maxTokens,
+                timeoutMs,
+            });
+            for await (const event of stream) {
+                if (event.type === "text_delta")
+                    output += event.delta;
+                else if (event.type === "done" && !output)
+                    output = assistantText(event.message);
+                else if (event.type === "error")
+                    streamError = event.error.errorMessage ?? event.reason;
+            }
+            if (streamError)
+                throw new Error(streamError);
+            const cleaned = cleanupOutput(output);
+            if (!cleaned)
+                throw new Error("Git assistant returned an empty response");
+            return cleaned;
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason ?? error;
+            lastError = error;
+        }
+    }
+    throw lastError ?? new Error("No Git assistant models are configured");
+}
+export function loadGitAssistantModelRefs(cwd, kind, homeDir = homedir()) {
+    const defaults = kind === "review"
+        ? { modelRef: DEFAULT_GIT_REVIEW_MODEL, fallbackModels: [] }
+        : { modelRef: DEFAULT_GIT_COMMIT_MESSAGE_MODEL, fallbackModels: [] };
+    const globalConfig = { ...defaults, ...readGitAssistantModelConfig(getPixConfigPath(homeDir), kind) };
+    const projectConfig = readGitAssistantModelConfig(getProjectPixConfigPath(cwd), kind);
+    const resolved = { ...globalConfig, ...projectConfig };
+    return [...new Set([resolved.modelRef, ...resolved.fallbackModels].map((ref) => ref.trim()).filter(Boolean))];
+}
+function readGitAssistantModelConfig(path, kind) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = parseJsonc(readFileSync(path, "utf8"));
+        if (!isRecord(parsed) || !isRecord(parsed.desktop) || !isRecord(parsed.desktop.git))
+            return {};
+        const git = parsed.desktop.git;
+        const modelValue = kind === "review" ? git.reviewModelRef : git.commitMessageModelRef;
+        const fallbackKey = kind === "review" ? "reviewFallbackModels" : "commitMessageFallbackModels";
+        const modelRef = typeof modelValue === "string" && modelValue.trim() ? modelValue.trim() : undefined;
+        const hasFallbackModels = Object.prototype.hasOwnProperty.call(git, fallbackKey);
+        return {
+            ...(modelRef ? { modelRef } : {}),
+            ...(hasFallbackModels ? { fallbackModels: modelFallbackList(git[fallbackKey]) } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function modelFallbackList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean))];
+}
+function capGitInput(value) {
+    if (value.length <= GIT_DIFF_MAX_CHARS)
+        return value;
+    const marker = "\n\n[Git diff truncated to fit the review input limit]";
+    return `${value.slice(0, GIT_DIFF_MAX_CHARS - marker.length)}${marker}`;
+}
+function cleanupOutput(value) {
+    let text = value.replace(/\r\n/gu, "\n").trim();
+    const fenced = /^```[^\n`]*\n([\s\S]*?)\n```$/u.exec(text);
+    if (fenced)
+        text = fenced[1].trim();
+    return text;
+}
+function assistantText(message) {
+    if (!isRecord(message))
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("");
+}
+function firstLine(value) {
+    return value.trim().split(/\r?\n/u, 1)[0] ?? "Use the generated commit message";
+}
+function displayGitPath(value) {
+    return value.replaceAll("\n", "\\n").replaceAll("\r", "\\r");
+}
+function gitFailureMessage(command, result) {
+    const detail = result.stderr.trim() || result.stdout.trim() || result.error?.message;
+    return detail ? `${command} failed: ${detail}` : `${command} failed`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/app/commands/command-host.d.ts

@@ -7,6 +7,8 @@ export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type CommandControllerHost = {
     readonly options: AppOptions;
     runtime(): AgentSessionRuntime | undefined;
+    inputScopeKey?(): string | undefined;
+    subagentTypes?(runtime: AgentSessionRuntime): readonly string[] | undefined;
     awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     requestHistory(): AppRequestHistory;
     getInput(): string;
@@ -41,6 +43,7 @@ export type CommandControllerHost = {
     setDirectPopupMenuPreserveStatus(preserveStatus: boolean): void;
     getDirectPopupMenuQuery(): string;
     setDirectPopupMenuQuery(query: string): void;
+    setResumeMenuMode?(mode: "resume" | "draft"): void;
     refreshUserMessageJumpMenuItems(): Promise<void>;
     getResumeLoading(): boolean;
     getResumeSessions(): readonly SessionInfo[];
@@ -54,6 +57,7 @@ export type CommandControllerHost = {
 export type CommandScope = {
     readonly runtime: AgentSessionRuntime | undefined;
     readonly session: AgentSession | undefined;
+    readonly inputScopeKey: string | undefined;
 };
 export declare function captureCommandScope(host: CommandControllerHost): CommandScope;
 export declare function isCommandRuntimeActive(host: CommandControllerHost, runtime: AgentSessionRuntime): boolean;

package/dist/app/commands/command-host.js

@@ -1,10 +1,13 @@
 export function captureCommandScope(host) {
     const runtime = host.runtime();
-    return { runtime, session: runtime?.session };
+    return { runtime, session: runtime?.session, inputScopeKey: host.inputScopeKey?.() };
 }
 export function isCommandRuntimeActive(host, runtime) {
     return host.isRunning() && host.runtime() === runtime;
 }
 export function isCommandScopeActive(host, scope) {
-    return host.isRunning() && host.runtime() === scope.runtime && scope.runtime?.session === scope.session;
+    return host.isRunning()
+        && host.runtime() === scope.runtime
+        && scope.runtime?.session === scope.session
+        && (host.inputScopeKey === undefined || host.inputScopeKey() === scope.inputScopeKey);
 }

package/dist/app/commands/command-model-actions.d.ts

@@ -12,6 +12,7 @@ export declare class ModelCommandActions {
     runThinkingSlashCommand(argumentsText: string): Promise<void>;
     runDefaultThinkingSlashCommand(argumentsText: string): Promise<void>;
     runModelCommand(model: SessionModel): Promise<void>;
+    runModelThinkingCommand(model: SessionModel, level: ThinkingLevel): Promise<void>;
     runThinkingCommand(level: ThinkingLevel): Promise<void>;
     private addPersistentSystemEntry;
     private reloadAfterModelChange;

package/dist/app/commands/command-model-actions.js

@@ -4,6 +4,7 @@ import { getProjectPixConfigPath, savePixAutocompleteModel, savePixDefaultModel,
 import { createId } from "../id.js";
 import { isThinkingLevel, parseScopedModelRef } from "../model/model-ref.js";
 import { appendPixSystemDisplayEntry } from "../session/pix-system-message.js";
+import { createReloadContextInventory, formatReloadContextInventory } from "./reload-context-inventory.js";
 export class ModelCommandActions {
     host;
     constructor(host) {
@@ -45,19 +46,7 @@ export class ModelCommandActions {
         const scope = captureCommandScope(this.host);
         const modelRef = argumentsText.trim();
         if (!modelRef) {
-            const selected = await this.host.showMenu(this.host.getModelMenuItems(""), {
-                title: "Select model",
-                placeholder: "Search models",
-                emptyText: "No matching models",
-            });
-            if (!isCommandScopeActive(this.host, scope))
-                return;
-            if (!selected) {
-                this.host.setSessionStatus(this.host.runtime()?.session);
-                this.host.render();
-                return;
-            }
-            await this.runModelCommand(selected.model);
+            this.host.openDirectPopupMenu("model");
             this.host.render();
             return;
         }
@@ -73,14 +62,10 @@ export class ModelCommandActions {
         const model = runtime.services.modelRuntime.getModel(parsed.provider, parsed.modelId);
         if (!model)
             throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
-        await this.runModelCommand(model);
-        if (!isCommandScopeActive(this.host, scope))
-            return;
-        if (parsed.thinkingLevel !== undefined) {
-            runtime.session.setThinkingLevel(parsed.thinkingLevel);
-            this.addPersistentSystemEntry(runtime.session, `Selected thinking level ${runtime.session.thinkingLevel}`);
-            this.host.setSessionStatus(runtime.session);
-        }
+        if (parsed.thinkingLevel !== undefined)
+            await this.runModelThinkingCommand(model, parsed.thinkingLevel);
+        else
+            await this.runModelCommand(model);
     }
     async runDefaultModelSlashCommand(argumentsText) {
         const scope = captureCommandScope(this.host);
@@ -241,19 +226,7 @@ export class ModelCommandActions {
         const scope = captureCommandScope(this.host);
         const level = argumentsText.trim();
         if (!level) {
-            const selected = await this.host.showMenu(this.host.getThinkingMenuItems(""), {
-                title: "Select thinking level",
-                placeholder: "Search thinking levels",
-                emptyText: "No matching thinking levels",
-            });
-            if (!isCommandScopeActive(this.host, scope))
-                return;
-            if (!selected) {
-                this.host.setSessionStatus(this.host.runtime()?.session);
-                this.host.render();
-                return;
-            }
-            await this.runThinkingCommand(selected.level);
+            this.host.openDirectPopupMenu("thinking");
             this.host.render();
             return;
         }
@@ -312,6 +285,51 @@ export class ModelCommandActions {
             return;
         this.host.setSessionStatus(runtime.session);
     }
+    async runModelThinkingCommand(model, level) {
+        const runtime = getRuntime(this.host, "model");
+        if (!runtime)
+            return;
+        const scope = captureCommandScope(this.host);
+        const session = runtime.session;
+        const ref = this.host.modelRef(model);
+        const currentModel = session.model;
+        const modelChanged = currentModel?.provider !== model.provider || currentModel.id !== model.id;
+        const initialThinking = session.thinkingLevel;
+        if (!modelChanged && initialThinking === level) {
+            this.host.setSessionStatus(session);
+            return;
+        }
+        this.host.setStatus(`selecting ${ref} · thinking ${level}`);
+        this.host.render();
+        if (modelChanged) {
+            await session.setModel(model);
+            if (!isCommandScopeActive(this.host, scope))
+                return;
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected model ${ref}` });
+        }
+        session.setThinkingLevel(level);
+        if (modelChanged || session.thinkingLevel !== initialThinking) {
+            this.addPersistentSystemEntry(session, `Selected thinking level ${session.thinkingLevel}`);
+        }
+        if (!modelChanged) {
+            this.host.setSessionStatus(session);
+            return;
+        }
+        if (session.isStreaming) {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: "Skipped reload because the agent is still running. Run /reload when idle to refresh model-specific tools.",
+            });
+            this.host.toast.warning("Model changed; reload skipped while the agent is running");
+            this.host.setSessionStatus(session);
+            return;
+        }
+        await this.reloadAfterModelChange(session, ref, scope);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
+        this.host.setSessionStatus(session);
+    }
     async runThinkingCommand(level) {
         const runtime = getRuntime(this.host, "thinking");
         if (!runtime)
@@ -333,10 +351,14 @@ export class ModelCommandActions {
             await session.reload();
             if (!isCommandScopeActive(this.host, scope))
                 return;
+            const runtime = scope.runtime;
+            const text = runtime
+                ? formatReloadContextInventory(createReloadContextInventory(runtime, this.host.subagentTypes?.(runtime)), `Reloaded resources after model change to ${ref}`)
+                : `Reloaded resources after model change to ${ref}`;
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
-                text: `Reloaded resources after model change to ${ref}`,
+                text,
             });
             this.host.toast.success("Model changed and resources reloaded");
         }

package/dist/app/commands/command-navigation-actions.d.ts

@@ -26,6 +26,7 @@ export declare class NavigationCommandActions {
     runResumeCommand(queryOrOptions?: string | {
         preserveStatus?: boolean;
         placement?: PopupMenuPlacement;
+        draft?: boolean;
     }): Promise<void>;
     private loadResumeSessionsInBackground;
     private formatSessionTree;