muonroi-cli 1.6.6 → 1.7.1

package/dist/src/providers/__tests__/reasoning-roundtrip.test.js

@@ -19,7 +19,8 @@
  */
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { streamText } from "ai";
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { transformThinkingModeBody } from "../strategies/thinking-mode.js";
 function makeStubProvider(name, capture) {
     return createOpenAICompatible({
         name,
@@ -113,6 +114,11 @@ describe("reasoning_content round-trip — AI SDK 2.0.42 wire shape", () => {
         expect(Array.isArray(assistantMsg.tool_calls)).toBe(true);
         expect(assistantMsg.tool_calls[0]?.id).toBe("c1");
     });
+    // NOTE: the bare provider correctly omits reasoning_content when a turn has
+    // no reasoning part — but that is exactly the shape SiliconFlow's
+    // thinking-mode validator rejects (code 20015) in a mixed history. The
+    // strategy's transformRequestBody backfills it; see the dedicated describe
+    // block below ("transformThinkingModeBody — backfill / disable").
     it("emits no reasoning_content key when there are no reasoning parts (no false positives)", async () => {
         const capture = { current: null };
         const provider = makeStubProvider("siliconflow", capture);
@@ -132,4 +138,67 @@ describe("reasoning_content round-trip — AI SDK 2.0.42 wire shape", () => {
         expect(assistantMsg.reasoning_content).toBeUndefined();
     });
 });
+describe("transformThinkingModeBody — backfill / disable (code 20015 fix)", () => {
+    const ENV = "MUONROI_DEEPSEEK_DISABLE_THINKING";
+    let saved;
+    beforeEach(() => {
+        saved = process.env[ENV];
+        delete process.env[ENV];
+    });
+    afterEach(() => {
+        if (saved === undefined)
+            delete process.env[ENV];
+        else
+            process.env[ENV] = saved;
+    });
+    it("A (default): backfills reasoning_content on a tool-call turn that lacks it", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                // tool-call turn with NO reasoning (the real bug shape)
+                { role: "assistant", content: null, tool_calls: [{ id: "t1", type: "function" }] },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect(asst.reasoning_content).toBe("");
+        expect(Array.isArray(asst.tool_calls)).toBe(true); // tool_calls preserved
+        expect("thinking" in out).toBe(false); // thinking still ON
+    });
+    it("A (default): leaves a real reasoning_content untouched and patches only the gap", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "go" },
+                { role: "assistant", content: null, reasoning_content: "real thought", tool_calls: [{ id: "a" }] },
+                { role: "tool", content: "result" },
+                { role: "assistant", content: null, tool_calls: [{ id: "b" }] }, // gap
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        const asst = out.messages.filter((m) => m.role === "assistant");
+        expect(asst[0].reasoning_content).toBe("real thought"); // untouched
+        expect(asst[1].reasoning_content).toBe(""); // backfilled
+    });
+    it("A (default): does not touch non-assistant messages", () => {
+        const body = {
+            messages: [
+                { role: "user", content: "hi" },
+                { role: "tool", content: "r" },
+            ],
+        };
+        const out = transformThinkingModeBody(body);
+        expect("reasoning_content" in out.messages[0]).toBe(false);
+        expect("reasoning_content" in out.messages[1]).toBe(false);
+    });
+    it("B (env=1): disables thinking and does NOT backfill reasoning_content", () => {
+        process.env[ENV] = "1";
+        const body = {
+            messages: [{ role: "assistant", content: null, tool_calls: [{ id: "t1" }] }],
+        };
+        const out = transformThinkingModeBody(body);
+        expect(out.thinking).toEqual({ type: "disabled" });
+        const asst = out.messages.find((m) => m.role === "assistant");
+        expect("reasoning_content" in asst).toBe(false);
+    });
+});
 //# sourceMappingURL=reasoning-roundtrip.test.js.map

package/dist/src/providers/strategies/deepseek.strategy.js

@@ -7,19 +7,7 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { getProviderCapabilities } from "../capabilities.js";
 import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
 import { BaseProviderStrategy } from "./base.strategy.js";
-/**
- * If MUONROI_DEEPSEEK_DISABLE_THINKING=1 (default for self-qa), inject
- * `extra_body.thinking.type="disabled"` into every DeepSeek request per
- * https://api-docs.deepseek.com/guides/thinking_mode . Cuts response time
- * 30-50% and prevents reasoning prose from leaking into JSON outputs.
- *
- * Set MUONROI_DEEPSEEK_DISABLE_THINKING=0 to keep thinking mode on for
- * chat sessions that actually benefit from reasoning.
- */
-function shouldDisableThinking() {
-    const v = process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"];
-    return v === undefined ? false : v === "1" || v.toLowerCase() === "true";
-}
+import { transformThinkingModeBody } from "./thinking-mode.js";
 export class DeepSeekStrategy extends BaseProviderStrategy {
     id = "deepseek";
     capabilities = getProviderCapabilities("deepseek");
@@ -34,15 +22,10 @@ export class DeepSeekStrategy extends BaseProviderStrategy {
             // json_object form for generateObject calls, matching DeepSeek docs:
             // https://api-docs.deepseek.com/guides/json_mode .
             supportsStructuredOutputs: false,
-            transformRequestBody: (body) => {
-                if (shouldDisableThinking()) {
-                    return {
-                        ...body,
-                        thinking: { type: "disabled" },
-                    };
-                }
-                return body;
-            },
+            // Thinking-mode round-trip fix: backfill reasoning_content (default) or
+            // disable thinking (MUONROI_DEEPSEEK_DISABLE_THINKING=1). See
+            // thinking-mode.ts for the full rationale (code 20015 rejection).
+            transformRequestBody: (body) => transformThinkingModeBody(body),
         });
         return (modelId) => p(modelId);
     }

package/dist/src/providers/strategies/siliconflow.strategy.js

@@ -8,6 +8,7 @@ import { getProviderCapabilities } from "../capabilities.js";
 import { OPENAI_COMPATIBLE_BASE_URLS } from "../endpoints.js";
 import { createSiliconflowRepairFetch } from "../siliconflow-sse-repair.js";
 import { BaseProviderStrategy } from "./base.strategy.js";
+import { transformThinkingModeBody } from "./thinking-mode.js";
 export class SiliconflowStrategy extends BaseProviderStrategy {
     id = "siliconflow";
     capabilities = getProviderCapabilities("siliconflow");
@@ -17,6 +18,10 @@ export class SiliconflowStrategy extends BaseProviderStrategy {
             baseURL: opts.baseURL ?? OPENAI_COMPATIBLE_BASE_URLS.siliconflow,
             apiKey: opts.apiKey,
             fetch: createSiliconflowRepairFetch(),
+            // Thinking-mode round-trip fix (code 20015): backfill reasoning_content
+            // on every assistant turn, or disable thinking when
+            // MUONROI_DEEPSEEK_DISABLE_THINKING=1. See thinking-mode.ts.
+            transformRequestBody: (body) => transformThinkingModeBody(body),
         });
         return (modelId) => p(modelId);
     }

package/dist/src/providers/strategies/thinking-mode.d.ts

@@ -0,0 +1,35 @@
+/**
+ * src/providers/strategies/thinking-mode.ts
+ *
+ * Shared `transformRequestBody` logic for DeepSeek-family providers
+ * (deepseek + siliconflow) that run a `thinking`/reasoning mode.
+ *
+ * THE BUG (verified on a live SiliconFlow wire body): DeepSeek-V4-Flash in
+ * thinking mode rejects the WHOLE request with HTTP 400 / code 20015
+ * ("The reasoning_content in the thinking mode must be passed back to the
+ * API") whenever the history contains an assistant message that lacks a
+ * `reasoning_content` field. During multi-step tool loops some assistant
+ * turns make a tool call WITHOUT emitting a reasoning segment (e.g. a quick
+ * `todo_write`), so `@ai-sdk/openai-compatible` serializes them as
+ * `{content:null, tool_calls:[...]}` with no `reasoning_content` key — and
+ * the next request blows up. The earlier "reasoning round-trips natively"
+ * conclusion only held for histories where EVERY assistant turn had reasoning.
+ *
+ * Two mitigations, selected by `MUONROI_DEEPSEEK_DISABLE_THINKING`:
+ *
+ *   - Default (A): keep thinking ON, but backfill `reasoning_content: ""` onto
+ *     every assistant message in the wire body that is missing it, so the
+ *     thinking-mode validator always sees the field.
+ *   - Fallback (B, env=1): disable thinking entirely via
+ *     `thinking: { type: "disabled" }` (per the DeepSeek thinking_mode guide).
+ *     Sidesteps the whole class of bug, cuts latency 30-50%, and stops
+ *     reasoning prose from leaking into JSON outputs — at the cost of reasoning.
+ *
+ * https://api-docs.deepseek.com/guides/thinking_mode
+ */
+export declare function shouldDisableThinking(): boolean;
+/**
+ * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
+ * fully-serialized wire body right before fetch.
+ */
+export declare function transformThinkingModeBody<T extends Record<string, unknown>>(body: T): T;

package/dist/src/providers/strategies/thinking-mode.js

@@ -0,0 +1,73 @@
+/**
+ * src/providers/strategies/thinking-mode.ts
+ *
+ * Shared `transformRequestBody` logic for DeepSeek-family providers
+ * (deepseek + siliconflow) that run a `thinking`/reasoning mode.
+ *
+ * THE BUG (verified on a live SiliconFlow wire body): DeepSeek-V4-Flash in
+ * thinking mode rejects the WHOLE request with HTTP 400 / code 20015
+ * ("The reasoning_content in the thinking mode must be passed back to the
+ * API") whenever the history contains an assistant message that lacks a
+ * `reasoning_content` field. During multi-step tool loops some assistant
+ * turns make a tool call WITHOUT emitting a reasoning segment (e.g. a quick
+ * `todo_write`), so `@ai-sdk/openai-compatible` serializes them as
+ * `{content:null, tool_calls:[...]}` with no `reasoning_content` key — and
+ * the next request blows up. The earlier "reasoning round-trips natively"
+ * conclusion only held for histories where EVERY assistant turn had reasoning.
+ *
+ * Two mitigations, selected by `MUONROI_DEEPSEEK_DISABLE_THINKING`:
+ *
+ *   - Default (A): keep thinking ON, but backfill `reasoning_content: ""` onto
+ *     every assistant message in the wire body that is missing it, so the
+ *     thinking-mode validator always sees the field.
+ *   - Fallback (B, env=1): disable thinking entirely via
+ *     `thinking: { type: "disabled" }` (per the DeepSeek thinking_mode guide).
+ *     Sidesteps the whole class of bug, cuts latency 30-50%, and stops
+ *     reasoning prose from leaking into JSON outputs — at the cost of reasoning.
+ *
+ * https://api-docs.deepseek.com/guides/thinking_mode
+ */
+export function shouldDisableThinking() {
+    const v = process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"];
+    return v === undefined ? false : v === "1" || v.toLowerCase() === "true";
+}
+/**
+ * Backfill `reasoning_content: ""` onto any assistant message that lacks a
+ * (non-empty/present) one, so SiliconFlow's thinking-mode validator never
+ * sees a reasoning-less assistant turn. Assistant turns that already carry a
+ * real `reasoning_content` are left untouched.
+ */
+function backfillReasoningContent(messages) {
+    let mutated = false;
+    const next = messages.map((m) => {
+        if (m?.role !== "assistant")
+            return m;
+        const rc = m.reasoning_content;
+        if (typeof rc === "string")
+            return m; // already present (incl. "")
+        mutated = true;
+        return { ...m, reasoning_content: "" };
+    });
+    return mutated ? next : messages;
+}
+/**
+ * The shared `transformRequestBody` for deepseek + siliconflow. Runs on the
+ * fully-serialized wire body right before fetch.
+ */
+export function transformThinkingModeBody(body) {
+    if (shouldDisableThinking()) {
+        // Fallback B: turn thinking off. No reasoning is produced, so there is
+        // nothing to backfill.
+        return { ...body, thinking: { type: "disabled" } };
+    }
+    // Default A: keep thinking on, but guarantee every assistant message carries
+    // a reasoning_content field so the validator is satisfied.
+    const messages = body["messages"];
+    if (!Array.isArray(messages))
+        return body;
+    const patched = backfillReasoningContent(messages);
+    if (patched === messages)
+        return body;
+    return { ...body, messages: patched };
+}
+//# sourceMappingURL=thinking-mode.js.map

package/dist/src/tools/registry.js

@@ -593,58 +593,58 @@ export function createBuiltinTools(bash, mode, opts) {
                     .join("\n");
             },
         });
-        // todo_write — Claude-Code-style task list. Each call REPLACES the agent's
-        // current todo snapshot; the orchestrator post-processes this tool's args
-        // into a task_list_update StreamChunk that the UI renders as a sticky
-        // checklist panel. Status flow: pending → in_progress → completed; only
-        // ONE item should be in_progress at a time. Use this when the user asks
-        // for a multi-step task (≥3 distinct steps) so progress is visible.
-        tools.todo_write = dynamicTool({
-            description: "Write the full current todo list. Replaces the previous list entirely on every call (no partial updates). Use when a user request resolves into ≥3 discrete steps so the UI can show progress. Mark exactly one item as in_progress at a time. Always emit the FULL list, not just the changed items.",
-            inputSchema: jsonSchema({
-                type: "object",
-                properties: {
-                    todos: {
-                        type: "array",
-                        description: "The full ordered list of todo items. Replaces any prior list. Keep order stable across updates so the UI doesn't reshuffle on every call.",
-                        items: {
-                            type: "object",
-                            properties: {
-                                id: { type: "string", description: "Stable id across updates (e.g. '1','2', or a slug)." },
-                                subject: { type: "string", description: "Short imperative title shown in the list." },
-                                activeForm: {
-                                    type: "string",
-                                    description: "Present-continuous form shown while in_progress (e.g. 'Reading files'). Falls back to subject when absent.",
-                                },
-                                status: {
-                                    type: "string",
-                                    enum: ["pending", "in_progress", "completed"],
-                                    description: "Item status. Only ONE item should be in_progress at any time.",
-                                },
+    }
+    // todo_write — Claude-Code-style task list. Each call REPLACES the agent's
+    // current todo snapshot; the orchestrator post-processes this tool's args
+    // into a task_list_update StreamChunk that the UI renders as a sticky
+    // checklist panel. Status flow: pending → in_progress → completed; only
+    // ONE item should be in_progress at a time. Use this when the user asks
+    // for a multi-step task (≥3 distinct steps) so progress is visible.
+    tools.todo_write = dynamicTool({
+        description: "Write the full current todo list. Replaces the previous list entirely on every call (no partial updates). Use when a user request resolves into ≥3 discrete steps so the UI can show progress. Mark exactly one item as in_progress at a time. Always emit the FULL list, not just the changed items.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "The full ordered list of todo items. Replaces any prior list. Keep order stable across updates so the UI doesn't reshuffle on every call.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string", description: "Stable id across updates (e.g. '1','2', or a slug)." },
+                            subject: { type: "string", description: "Short imperative title shown in the list." },
+                            activeForm: {
+                                type: "string",
+                                description: "Present-continuous form shown while in_progress (e.g. 'Reading files'). Falls back to subject when absent.",
+                            },
+                            status: {
+                                type: "string",
+                                enum: ["pending", "in_progress", "completed"],
+                                description: "Item status. Only ONE item should be in_progress at any time.",
                             },
-                            required: ["id", "subject", "status"],
                         },
+                        required: ["id", "subject", "status"],
                     },
                 },
-                required: ["todos"],
-            }),
-            execute: async (input) => {
-                const todos = Array.isArray(input?.todos)
-                    ? input.todos
-                    : [];
-                const counts = { completed: 0, inProgress: 0, pending: 0, total: todos.length };
-                for (const t of todos) {
-                    if (t.status === "completed")
-                        counts.completed++;
-                    else if (t.status === "in_progress")
-                        counts.inProgress++;
-                    else
-                        counts.pending++;
-                }
-                return `Tracking ${counts.total} todo${counts.total !== 1 ? "s" : ""}: ${counts.completed} done · ${counts.inProgress} in progress · ${counts.pending} queued.`;
             },
-        });
-    }
+            required: ["todos"],
+        }),
+        execute: async (input) => {
+            const todos = Array.isArray(input?.todos)
+                ? input.todos
+                : [];
+            const counts = { completed: 0, inProgress: 0, pending: 0, total: todos.length };
+            for (const t of todos) {
+                if (t.status === "completed")
+                    counts.completed++;
+                else if (t.status === "in_progress")
+                    counts.inProgress++;
+                else
+                    counts.pending++;
+            }
+            return `Tracking ${counts.total} todo${counts.total !== 1 ? "s" : ""}: ${counts.completed} done · ${counts.inProgress} in progress · ${counts.pending} queued.`;
+        },
+    });
     // Vision-tool gate: drop the 3 vision-proxy tools on turns with no plausible
     // image involvement. Built then deleted (closures are cheap) to avoid
     // re-indenting the tool definitions above. todo_write + core tools untouched.

package/dist/src/utils/install-manager.d.ts

@@ -51,6 +51,35 @@ export declare function saveScriptInstallMetadata(metadata: ScriptInstallMetadat
 export declare function getScriptInstallContext(homeDir?: string): ScriptInstallContext | null;
 export declare function fetchLatestReleaseVersion(): Promise<string | null>;
 export declare function parseChecksumsFile(contents: string): Map<string, string>;
+/**
+ * How this muonroi-cli was installed. Drives which update path the built-in
+ * `/update` flow takes:
+ *   - "script"     → install.sh-managed; runScriptManagedUpdate replaces the binary.
+ *   - "bun-global" → `bun add -g muonroi-cli`; update via bun.
+ *   - "npm-global" → `npm install -g muonroi-cli`; update via npm.
+ *   - "compiled"   → standalone single-file binary; re-download / rebuild.
+ *   - "dev-link"   → linked/source build run from a git checkout (bun link,
+ *                    symlinked global bin, or `bun run src/index.ts`); rebuild dist.
+ *   - "unknown"    → can't tell; fall back to generic guidance.
+ */
+export type InstallMethod = "script" | "bun-global" | "npm-global" | "compiled" | "dev-link" | "unknown";
+/**
+ * Detect how the running muonroi-cli was installed by inspecting the location
+ * of this module on disk plus the runtime. Pure path inspection — no I/O beyond
+ * the install.json check, so it is safe to call on the hot path.
+ */
+export declare function detectInstallMethod(homeDir?: string): InstallMethod;
+/** Package-manager command that updates muonroi-cli for the given method, or null. */
+export declare function getUpdateCommandForMethod(method: InstallMethod): string | null;
+/**
+ * Top-level update entry point. Routes to the script-managed updater for
+ * install.sh installs, and returns the correct package-manager command for
+ * bun/npm global installs (rather than the misleading "reinstall via install.sh"
+ * dead-end). We do NOT auto-spawn the package manager: on Windows overwriting the
+ * files of the live process is unreliable, so we hand the user an exact command
+ * to run from a fresh terminal.
+ */
+export declare function runManagedUpdate(currentVersion: string): Promise<ScriptUpdateRunResult>;
 export declare function runScriptManagedUpdate(currentVersion: string): Promise<ScriptUpdateRunResult>;
 export declare function buildScriptUninstallPlan(options?: ScriptUninstallOptions, homeDir?: string): ScriptUninstallPlan | null;
 export declare function runScriptManagedUninstall(options?: ScriptUninstallOptions): Promise<ScriptUpdateRunResult>;

package/dist/src/utils/install-manager.js

@@ -6,6 +6,7 @@ import path from "path";
 import readline from "readline";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
+import { fileURLToPath } from "url";
 export const GITHUB_REPO = "muonroi/muonroi-cli";
 export const RELEASES_API = `https://api.github.com/repos/${GITHUB_REPO}/releases`;
 export const SCRIPT_INSTALL_METHOD = "script";
@@ -99,6 +100,111 @@ export function parseChecksumsFile(contents) {
     }
     return result;
 }
+/** Absolute filesystem path of THIS module, normalized to forward slashes. */
+function runningModulePath() {
+    try {
+        return fileURLToPath(import.meta.url).replace(/\\/g, "/");
+    }
+    catch {
+        return (process.argv[1] ?? "").replace(/\\/g, "/");
+    }
+}
+/** Walk up from `startDir` looking for a `.git` entry; return the repo root or null. */
+function findGitRoot(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 30 && dir; i++) {
+        if (fs.existsSync(path.join(dir, ".git")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Detect how the running muonroi-cli was installed by inspecting the location
+ * of this module on disk plus the runtime. Pure path inspection — no I/O beyond
+ * the install.json check, so it is safe to call on the hot path.
+ */
+export function detectInstallMethod(homeDir = os.homedir()) {
+    if (loadScriptInstallMetadata(homeDir))
+        return "script";
+    const modPath = runningModulePath();
+    const importUrl = (import.meta.url || "").replace(/\\/g, "/");
+    // Bun single-file compiled executable embeds modules under a virtual root
+    // (e.g. "/$bunfs/" or "/~BUN/"), so the module path is not a real fs path.
+    if (importUrl.includes("/$bunfs/") || importUrl.includes("/~BUN/") || modPath.includes("/$bunfs/")) {
+        return "compiled";
+    }
+    // Bun's global install root: ~/.bun/install/global/node_modules/muonroi-cli/...
+    if (modPath.includes("/.bun/install/global/"))
+        return "bun-global";
+    if (/\/node_modules\/muonroi-cli\//.test(modPath)) {
+        return modPath.includes("/.bun/") ? "bun-global" : "npm-global";
+    }
+    // Not under node_modules and not launched by node/bun → standalone binary.
+    const exeBase = ((process.execPath || "").replace(/\\/g, "/").split("/").pop() ?? "").toLowerCase();
+    if (!modPath.includes("/node_modules/") && !/^(node|bun)(\.exe)?$/.test(exeBase)) {
+        return "compiled";
+    }
+    // Linked/source build run from a git checkout (e.g. `bun link`, a symlinked
+    // global bin pointing at the repo, or `bun run src/index.ts`). The "update"
+    // here is a rebuild, not a package-manager swap.
+    if (modPath && !modPath.includes("/node_modules/") && findGitRoot(path.dirname(modPath))) {
+        return "dev-link";
+    }
+    return "unknown";
+}
+/** Package-manager command that updates muonroi-cli for the given method, or null. */
+export function getUpdateCommandForMethod(method) {
+    switch (method) {
+        case "bun-global":
+            return "bun add -g muonroi-cli@latest";
+        case "npm-global":
+            return "npm install -g muonroi-cli@latest";
+        default:
+            return null;
+    }
+}
+/**
+ * Top-level update entry point. Routes to the script-managed updater for
+ * install.sh installs, and returns the correct package-manager command for
+ * bun/npm global installs (rather than the misleading "reinstall via install.sh"
+ * dead-end). We do NOT auto-spawn the package manager: on Windows overwriting the
+ * files of the live process is unreliable, so we hand the user an exact command
+ * to run from a fresh terminal.
+ */
+export async function runManagedUpdate(currentVersion) {
+    const method = detectInstallMethod();
+    if (method === "script")
+        return runScriptManagedUpdate(currentVersion);
+    const cmd = getUpdateCommandForMethod(method);
+    if (cmd) {
+        const pm = method === "bun-global" ? "bun" : "npm";
+        return {
+            success: true,
+            output: `Installed via ${pm} (global package). To update, run this in a fresh terminal:\n\n  ${cmd}\n\nThen restart muonroi-cli.`,
+        };
+    }
+    if (method === "compiled") {
+        const target = getReleaseTargetForPlatform();
+        const asset = target?.assetName ?? "the release asset for your platform";
+        return {
+            success: true,
+            output: `Standalone binary install. Download the latest ${asset} from https://github.com/${GITHUB_REPO}/releases/latest and replace the current binary, or rebuild from source.`,
+        };
+    }
+    if (method === "dev-link") {
+        const root = findGitRoot(path.dirname(runningModulePath()));
+        const target = root ?? "the muonroi-cli checkout";
+        return {
+            success: true,
+            output: `Running a linked/source build from ${target}. To update, rebuild it:\n\n  git -C "${target}" pull && bun install && bun run build\n\nThen restart muonroi-cli. (If you also use the compiled muonroi-cli-dev binary, rebuild that separately.)`,
+        };
+    }
+    return notScriptManaged("update");
+}
 export async function runScriptManagedUpdate(currentVersion) {
     const context = getScriptInstallContext();
     if (!context)

package/dist/src/utils/update-checker.js

@@ -1,6 +1,6 @@
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
-import { fetchLatestReleaseVersion, runScriptManagedUpdate } from "./install-manager.js";
+import { fetchLatestReleaseVersion, runManagedUpdate } from "./install-manager.js";
 export async function checkForUpdate(currentVersion) {
     try {
         const latestVersion = await fetchLatestReleaseVersion();
@@ -17,6 +17,6 @@ export async function checkForUpdate(currentVersion) {
     }
 }
 export function runUpdate(currentVersion) {
-    return runScriptManagedUpdate(currentVersion);
+    return runManagedUpdate(currentVersion);
 }
 //# sourceMappingURL=update-checker.js.map

package/dist/src/utils/update-checker.test.js

@@ -95,12 +95,12 @@ describe("checkForUpdate", () => {
     });
 });
 describe("runUpdate", () => {
-    it("returns success when the script-managed updater succeeds", async () => {
+    it("returns success when the managed updater succeeds", async () => {
         vi.doMock("./install-manager", async () => {
             const actual = await vi.importActual("./install-manager");
             return {
                 ...actual,
-                runScriptManagedUpdate: vi.fn().mockResolvedValue({ success: true, output: "Updated to Grok 2.0.0." }),
+                runManagedUpdate: vi.fn().mockResolvedValue({ success: true, output: "Updated to muonroi-cli 2.0.0." }),
             };
         });
         const { runUpdate } = await importModule();
@@ -108,12 +108,12 @@ describe("runUpdate", () => {
         expect(result.success).toBe(true);
         expect(result.output).toContain("Updated");
     });
-    it("returns failure when the script-managed updater fails", async () => {
+    it("returns failure when the managed updater fails", async () => {
         vi.doMock("./install-manager", async () => {
             const actual = await vi.importActual("./install-manager");
             return {
                 ...actual,
-                runScriptManagedUpdate: vi.fn().mockResolvedValue({ success: false, output: "permission denied" }),
+                runManagedUpdate: vi.fn().mockResolvedValue({ success: false, output: "permission denied" }),
             };
         });
         const { runUpdate } = await importModule();
@@ -122,4 +122,17 @@ describe("runUpdate", () => {
         expect(result.output).toContain("permission denied");
     });
 });
+describe("getUpdateCommandForMethod", () => {
+    it("maps bun/npm global installs to the right update command", async () => {
+        const { getUpdateCommandForMethod } = await import("./install-manager.js");
+        expect(getUpdateCommandForMethod("bun-global")).toBe("bun add -g muonroi-cli@latest");
+        expect(getUpdateCommandForMethod("npm-global")).toBe("npm install -g muonroi-cli@latest");
+    });
+    it("returns null for methods without a package-manager command", async () => {
+        const { getUpdateCommandForMethod } = await import("./install-manager.js");
+        expect(getUpdateCommandForMethod("script")).toBeNull();
+        expect(getUpdateCommandForMethod("compiled")).toBeNull();
+        expect(getUpdateCommandForMethod("unknown")).toBeNull();
+    });
+});
 //# sourceMappingURL=update-checker.test.js.map

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.6",
+  "version": "1.7.1",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",

package/dist/src/gsd/__tests__/complexity.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/gsd/complexity.d.ts

@@ -1,28 +0,0 @@
-/**
- * src/gsd/complexity.ts
- *
- * Heuristic complexity scorer for incoming prompts.
- * Maps a raw user prompt to one of three tiers that drive the GSD directive
- * injected by layer4:
- *
- *   - "heavy"    → multi-file / multi-repo / architectural / "do everything"
- *                  Triggers the full discuss → research → verify → plan → impl → verify flow.
- *   - "standard" → ordinary feature/bugfix work. GSD-quick mindset.
- *   - "quick"    → trivial single-shot tasks (typo, rename, read-and-explain).
- *
- * The scorer is intentionally cheap: regex + length checks. It runs inside the
- * 200ms PIL budget and must never throw.
- */
-export type ComplexityTier = "quick" | "standard" | "heavy";
-export interface ComplexitySignal {
-    /** Short tag identifying which heuristic fired (e.g. "multi-repo", "wholesale"). */
-    tag: string;
-    /** Weight contributed to the score. Positive = heavier, negative = lighter. */
-    weight: number;
-}
-export interface ComplexityResult {
-    tier: ComplexityTier;
-    score: number;
-    signals: ComplexitySignal[];
-}
-export declare function scoreComplexity(prompt: string): ComplexityResult;