muonroi-cli 1.8.0 → 1.8.1

package/dist/src/storage/workspaces.js

@@ -8,14 +8,14 @@ export function ensureWorkspace(cwd) {
     const now = new Date().toISOString();
     const id = createHash("sha1").update(resolved.scopeKey).digest("hex").slice(0, 16);
     const db = getDatabase();
-    db.prepare(`
-    INSERT INTO workspaces (id, scope_key, canonical_path, git_root, display_name, last_seen_at)
-    VALUES (@id, @scope_key, @canonical_path, @git_root, @display_name, @last_seen_at)
-    ON CONFLICT(scope_key) DO UPDATE SET
-      canonical_path = excluded.canonical_path,
-      git_root = excluded.git_root,
-      display_name = excluded.display_name,
-      last_seen_at = excluded.last_seen_at
+    db.prepare(`
+    INSERT INTO workspaces (id, scope_key, canonical_path, git_root, display_name, last_seen_at)
+    VALUES (@id, @scope_key, @canonical_path, @git_root, @display_name, @last_seen_at)
+    ON CONFLICT(scope_key) DO UPDATE SET
+      canonical_path = excluded.canonical_path,
+      git_root = excluded.git_root,
+      display_name = excluded.display_name,
+      last_seen_at = excluded.last_seen_at
   `).run({
         id,
         scope_key: resolved.scopeKey,
@@ -25,10 +25,10 @@ export function ensureWorkspace(cwd) {
         last_seen_at: now,
     });
     const row = db
-        .prepare(`
-    SELECT id, scope_key, canonical_path, git_root, display_name, last_seen_at
-    FROM workspaces
-    WHERE scope_key = ?
+        .prepare(`
+    SELECT id, scope_key, canonical_path, git_root, display_name, last_seen_at
+    FROM workspaces
+    WHERE scope_key = ?
   `)
         .get(resolved.scopeKey);
     if (!row) {

package/dist/src/tools/native-tools.js

@@ -236,6 +236,7 @@ export function registerNativeMuonroiTools(tools, opts = {}) {
                 goal: { type: "string" },
                 llm: { type: "string" },
                 turns: { type: "number" },
+                mockLlmDir: { type: "string", description: "Use 'none' to run child TUI against real LLM APIs" },
             },
             required: ["mode"],
         }),
@@ -247,7 +248,15 @@ export function registerNativeMuonroiTools(tools, opts = {}) {
                 const { getModelInfo } = await import("../models/registry.js");
                 if (!getModelInfo(input.llm))
                     return errLine("unknown_model", `llm '${input.llm}' is not in catalog.json`);
-                return json({ runId: jm.start({ kind: "agentic", goal: input.goal, llm: input.llm, turns: input.turns }) });
+                return json({
+                    runId: jm.start({
+                        kind: "agentic",
+                        goal: input.goal,
+                        llm: input.llm,
+                        turns: input.turns,
+                        mockLlmDir: input.mockLlmDir,
+                    }),
+                });
             }
             return json({
                 runId: jm.start({ kind: "tier1", since: input?.since, max: input?.max, emit: input?.emit, out: input?.out }),

package/dist/src/tools/registry.d.ts

@@ -15,6 +15,7 @@ interface ToolRegistryOpts {
     listDelegations?: () => Promise<ToolResult>;
     killDelegation?: (id: string) => Promise<ToolResult>;
     modelId?: string;
+    consultParentSession?: (question: string) => Promise<string>;
     /**
      * When false, the 3 vision-proxy tools (analyze_image, ask_vision_proxy,
      * list_vision_cache) are omitted even for vision-proxy models. Used by the

package/dist/src/tools/registry.js

@@ -150,7 +150,8 @@ export function createBuiltinTools(bash, mode, opts) {
         description: "Execute a shell command. Output is automatically cached — every call returns a " +
             "run_id you can re-query via bash_output_get(run_id, mode=tail|head|grep|lines). " +
             "Do NOT pipe `| tail`, `| head`, `| grep`, or `> file` — that hides output from " +
-            "the cache. Run unpiped and slice via bash_output_get instead. For collecting system info (OS, versions, cwd layout, git, disk, processes) batch with ; or && in ONE call, e.g. 'uname -a; node -v; bun --version; ls -la | head -15; git status --short; df -h .; ps aux | head -5'. Set background=true for long-running processes (dev servers, watchers).",
+            "the cache. Run unpiped and slice via bash_output_get instead. For collecting system info (OS, versions, cwd layout, git, disk, processes) batch with ; or && in ONE call, e.g. 'uname -a; node -v; bun --version; ls -la | head -15; git status --short; df -h .; ps aux | head -5'. Set background=true for long-running processes (dev servers, watchers). " +
+            'Avoid nesting double-quotes inline for database queries/scripts (e.g. executing raw SQL via `sqlite3 db "SELECT..."`) since they can fail parsing in shell environments; write query scripts to a temporary file first and run them.',
         inputSchema: jsonSchema({
             type: "object",
             properties: {
@@ -504,6 +505,27 @@ export function createBuiltinTools(bash, mode, opts) {
                 },
             });
         }
+        // consult_parent_session
+        if (opts?.consultParentSession) {
+            const consultParentSession = opts.consultParentSession;
+            tools.consult_parent_session = dynamicTool({
+                description: "Consult the parent session for supervision or guidance when stuck, when needing clarification on the overall goal, or when encountering critical errors. ONLY available in sub-sessions.",
+                inputSchema: jsonSchema({
+                    type: "object",
+                    properties: {
+                        question: {
+                            type: "string",
+                            description: "The specific question or issue you need the parent session to advise on.",
+                        },
+                    },
+                    required: ["question"],
+                }),
+                execute: async (input) => {
+                    const result = await consultParentSession(input.question);
+                    return result;
+                },
+            });
+        }
         // delegate
         if (opts?.runDelegation) {
             const runDelegation = opts.runDelegation;
@@ -653,7 +675,13 @@ export function createBuiltinTools(bash, mode, opts) {
                             return "[ee_unavailable] Experience Engine returned no response (server down, timeout, circuit open, or unconfigured) and the artifact is not in this session's local cache. Proceed without EE recall — re-read the source directly if you need the elided content.";
                         }
                         recordRehydration("ee");
-                        return truncateOutput(JSON.stringify(resp));
+                        const points = resp.points ?? [];
+                        const bestHit = points[0];
+                        if (bestHit) {
+                            const matchedId = query.match(/(?:id\s*=\s*|id\s*\b)([a-zA-Z0-9_:-]+)/i)?.[1] ?? "unknown";
+                            return truncateOutput(`[tool-artifact id=${matchedId} — rehydrated from Experience Engine]\n${bestHit.text}`);
+                        }
+                        return `[tool-artifact — not found in Experience Engine]`;
                     }
                     // General recall → /api/recall (recallMode, [id col] index + surface).
                     const { recallEE, formatRecallForAgent } = await import("../ee/search.js");

package/dist/src/types/index.d.ts

@@ -419,7 +419,7 @@ export interface ModelInfo {
     supportsVision?: boolean;
 }
 export type AgentMode = "agent" | "plan" | "ask";
-export type SessionStatus = "active" | "completed" | "archived";
+export type SessionStatus = "active" | "completed" | "archived" | "abandoned";
 export type UsageSource = "message" | "title" | "task" | "delegation" | "council" | "other";
 export interface WorkspaceInfo {
     id: string;

package/dist/src/ui/slash/council-inspect.js

@@ -37,10 +37,10 @@ export const handleCouncilInspectSlash = async (args) => {
     }
     // Load all system messages for this session — parameterized query prevents SQL injection (T-17-04)
     const rows = db
-        .prepare(`SELECT role, message_json, seq, created_at
-       FROM messages
-       WHERE session_id = ?
-         AND role = 'system'
+        .prepare(`SELECT role, message_json, seq, created_at
+       FROM messages
+       WHERE session_id = ?
+         AND role = 'system'
        ORDER BY seq ASC`)
         .all(sessionId);
     if (rows.length === 0) {

package/dist/src/ui/slash/expand.js

@@ -30,11 +30,24 @@ export const handleExpandSlash = async (_args, ctx) => {
     const latestFile = snapshots[snapshots.length - 1];
     const latestPath = path.join(historyDir, latestFile);
     const content = await fs.readFile(latestPath, "utf8");
+    // Attempt to read the corresponding .json file for structured messages restore
+    let jsonContent = "";
+    const jsonPath = latestPath.replace(/\.md$/, ".json");
+    try {
+        jsonContent = await fs.readFile(jsonPath, "utf8");
+        await fs.unlink(jsonPath).catch(() => { });
+    }
+    catch {
+        // no JSON snapshot found (legacy md-only snapshot)
+    }
     // Delete the snapshot file (prevent double-expand per Pitfall 5)
     await fs.unlink(latestPath);
     // Count lines for summary
     const lines = content.split("\n").length;
-    // Return signal for orchestrator to restore messages
+    if (jsonContent) {
+        return `__EXPAND_JSON__\n${jsonContent}\nRestored from ${latestFile} (${lines} lines). Previous compaction reversed.\n${content}`;
+    }
+    // Return signal for orchestrator to restore messages (legacy text fallback)
     return `__EXPAND__\nRestored from ${latestFile} (${lines} lines). Previous compaction reversed.\n${content}`;
 };
 // Self-register on module import

package/dist/src/utils/__tests__/compaction-caps.test.js

@@ -78,25 +78,25 @@ describe("compaction cap getters — production contract (G4 drift guard)", () =
         });
     });
     describe("budget getters (env override → user-settings → default)", () => {
-        it("getSubAgentBudgetChars: default 120_000 when env unset and no user override", () => {
+        it("getSubAgentBudgetChars: default 240_000 when env unset and no user override", () => {
             // Deterministic on a clean checkout / CI (no user-settings.json). When a
             // dev machine HAS an explicit override the getter must honor it instead —
             // the default-drift case is what CI guards.
             const override = loadUserSettings().subAgentBudgetChars;
-            if (typeof override === "number" && override >= 20_000 && override <= 600_000) {
+            if (typeof override === "number" && override >= 20_000 && override <= 5_000_000) {
                 expect(getSubAgentBudgetChars()).toBe(Math.floor(override));
             }
             else {
-                expect(getSubAgentBudgetChars()).toBe(120_000);
+                expect(getSubAgentBudgetChars()).toBe(240_000);
             }
         });
-        it("getTopLevelToolBudgetChars: default 200_000 when env unset and no user override", () => {
+        it("getTopLevelToolBudgetChars: default 400_000 when env unset and no user override", () => {
             const override = loadUserSettings().topLevelToolBudgetChars;
-            if (typeof override === "number" && override >= 50_000 && override <= 1_500_000) {
+            if (typeof override === "number" && override >= 50_000 && override <= 10_000_000) {
                 expect(getTopLevelToolBudgetChars()).toBe(Math.floor(override));
             }
             else {
-                expect(getTopLevelToolBudgetChars()).toBe(200_000);
+                expect(getTopLevelToolBudgetChars()).toBe(400_000);
             }
         });
         it("honor valid in-range env overrides (env short-circuits user-settings)", () => {
@@ -106,16 +106,16 @@ describe("compaction cap getters — production contract (G4 drift guard)", () =
             expect(getTopLevelToolBudgetChars()).toBe(800_000);
         });
         it("reject out-of-range env (result stays within the documented range)", () => {
-            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "999999999"; // > 600_000
+            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "999999999"; // > 5_000_000
             const sub = getSubAgentBudgetChars();
             expect(sub).not.toBe(999_999_999);
             expect(sub).toBeGreaterThanOrEqual(20_000);
-            expect(sub).toBeLessThanOrEqual(600_000);
+            expect(sub).toBeLessThanOrEqual(5_000_000);
             process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS = "1000"; // < 50_000
             const top = getTopLevelToolBudgetChars();
             expect(top).not.toBe(1000);
             expect(top).toBeGreaterThanOrEqual(50_000);
-            expect(top).toBeLessThanOrEqual(1_500_000);
+            expect(top).toBeLessThanOrEqual(10_000_000);
         });
     });
 });

package/dist/src/utils/__tests__/llm-deadline.test.js

@@ -1,11 +1,23 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { withDeadlineRace, withTimeoutSignal } from "../llm-deadline.js";
+async function advanceTimersAsync(ms) {
+    if (typeof vi.advanceTimersByTimeAsync === "function") {
+        await vi.advanceTimersByTimeAsync(ms);
+    }
+    else {
+        vi.advanceTimersByTime(ms);
+        // Flush microtasks in Bun/older Node
+        for (let i = 0; i < 20; i++) {
+            await Promise.resolve();
+        }
+    }
+}
 describe("withDeadlineRace", () => {
     beforeEach(() => vi.useFakeTimers());
     afterEach(() => vi.useRealTimers());
     it("resolves with the value when fn settles before the deadline", async () => {
         const p = withDeadlineRace(async () => "ok", 1000, "test-call");
-        await vi.advanceTimersByTimeAsync(10);
+        await advanceTimersAsync(10);
         await expect(p).resolves.toBe("ok");
     });
     it("rejects with a labelled timeout error when fn exceeds the deadline", async () => {
@@ -14,7 +26,7 @@ describe("withDeadlineRace", () => {
         // of whether the underlying SDK honours its abort signal.
         const p = withDeadlineRace(() => new Promise(() => { }), 500, "plan_debate");
         const assertion = expect(p).rejects.toThrow(/plan_debate exceeded 500ms deadline/);
-        await vi.advanceTimersByTimeAsync(600);
+        await advanceTimersAsync(600);
         await assertion;
     });
 });
@@ -29,7 +41,7 @@ describe("withTimeoutSignal", () => {
     it("aborts the signal once the timeout elapses", async () => {
         const { signal } = withTimeoutSignal(undefined, 200);
         expect(signal.aborted).toBe(false);
-        await vi.advanceTimersByTimeAsync(250);
+        await advanceTimersAsync(250);
         expect(signal.aborted).toBe(true);
     });
     it("aborts immediately when the parent signal is already aborted", () => {
@@ -49,7 +61,7 @@ describe("withTimeoutSignal", () => {
     it("cleanup clears the timer so the signal never aborts afterwards", async () => {
         const { signal, cleanup } = withTimeoutSignal(undefined, 200);
         cleanup();
-        await vi.advanceTimersByTimeAsync(500);
+        await advanceTimersAsync(500);
         expect(signal.aborted).toBe(false);
     });
 });

package/dist/src/utils/__tests__/logger.test.d.ts

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

package/dist/src/utils/__tests__/logger.test.js

@@ -0,0 +1,115 @@
+import * as fs from "fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { logger, redactObject, redactSecrets } from "../logger.js";
+vi.mock("fs", () => ({
+    appendFileSync: vi.fn(),
+    existsSync: vi.fn(() => true),
+    mkdirSync: vi.fn(),
+}));
+function setTuiActive(active) {
+    globalThis.__muonroiTuiActive = active;
+}
+function clearTuiActive() {
+    delete globalThis.__muonroiTuiActive;
+}
+describe("logger utility", () => {
+    let logSpy;
+    let warnSpy;
+    let errorSpy;
+    beforeEach(() => {
+        logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+        errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        vi.mocked(fs.appendFileSync).mockClear();
+        vi.mocked(fs.existsSync).mockClear();
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.mkdirSync).mockClear();
+        clearTuiActive();
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        warnSpy.mockRestore();
+        errorSpy.mockRestore();
+        clearTuiActive();
+    });
+    describe("redactSecrets", () => {
+        it("redacts openai keys", () => {
+            const msg = "sending request with key sk-proj12345678901234567890123456";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+        it("redacts google keys", () => {
+            const msg = "sending request with key AIzaSyA1B2C3D4E5F6G7H8I9J0K1L2M3N4O5P6Q";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+        it("redacts xai keys", () => {
+            const msg = "sending request with key xai-proj12345678901234567890123456";
+            expect(redactSecrets(msg)).toBe("sending request with key [REDACTED_API_KEY]");
+        });
+    });
+    describe("redactObject", () => {
+        it("redacts sensitive fields in an object recursively", () => {
+            const raw = {
+                name: "test",
+                apiKey: "sk-proj1234567890",
+                nested: {
+                    secretToken: "some-secret",
+                    plainVal: "hello",
+                },
+                arr: ["item1", "sk-proj12345678901234567890123456"],
+            };
+            const expected = {
+                name: "test",
+                apiKey: "[REDACTED]",
+                nested: {
+                    secretToken: "[REDACTED]",
+                    plainVal: "hello",
+                },
+                arr: ["item1", "[REDACTED_API_KEY]"],
+            };
+            expect(redactObject(raw)).toEqual(expected);
+        });
+    });
+    describe("logger functionality in CLI mode", () => {
+        it("logs info messages to console.log", () => {
+            logger.info("cli", "test message", { val: 42 });
+            expect(logSpy).toHaveBeenCalledTimes(1);
+            const callArg = logSpy.mock.calls[0][0];
+            expect(callArg).toContain("[INFO]");
+            expect(callArg).toContain("[CLI]");
+            expect(callArg).toContain("test message");
+            expect(callArg).toContain('{"val":42}');
+        });
+        it("logs warn messages to console.warn", () => {
+            logger.warn("orchestrator", "warning message");
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            const callArg = warnSpy.mock.calls[0][0];
+            expect(callArg).toContain("[WARN]");
+            expect(callArg).toContain("[ORCHESTRATOR]");
+            expect(callArg).toContain("warning message");
+        });
+        it("logs error messages to console.error", () => {
+            logger.error("storage", "error message");
+            expect(errorSpy).toHaveBeenCalledTimes(1);
+            const callArg = errorSpy.mock.calls[0][0];
+            expect(callArg).toContain("[ERROR]");
+            expect(callArg).toContain("[STORAGE]");
+            expect(callArg).toContain("error message");
+        });
+    });
+    describe("logger functionality in TUI mode", () => {
+        it("does not log to console, but appends to debug.log", () => {
+            setTuiActive(true);
+            logger.info("ui", "render component", { id: "main" });
+            expect(logSpy).not.toHaveBeenCalled();
+            expect(fs.appendFileSync).toHaveBeenCalledTimes(1);
+            const filePath = vi.mocked(fs.appendFileSync).mock.calls[0][0];
+            const logContent = vi.mocked(fs.appendFileSync).mock.calls[0][1];
+            expect(filePath).toContain("debug.log");
+            expect(logContent).toContain("[INFO]");
+            expect(logContent).toContain("[UI]");
+            expect(logContent).toContain("render component");
+            expect(logContent).toContain('{"id":"main"}');
+        });
+    });
+});
+//# sourceMappingURL=logger.test.js.map

package/dist/src/utils/__tests__/settings-agent-first.test.d.ts

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

package/dist/src/utils/__tests__/settings-agent-first.test.js

@@ -0,0 +1,48 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+describe("UserSettings.agentFirst", () => {
+    const tmpHome = path.join(os.tmpdir(), `muonroi-cli-agentfirst-${process.pid}-${Date.now()}`);
+    const origHome = process.env.HOME;
+    const origUserProfile = process.env.USERPROFILE;
+    let saveUserSettings;
+    let loadUserSettings;
+    beforeEach(async () => {
+        fs.mkdirSync(tmpHome, { recursive: true });
+        process.env.HOME = tmpHome;
+        process.env.USERPROFILE = tmpHome;
+        vi.resetModules();
+        const mod = await import("../settings.js");
+        saveUserSettings = mod.saveUserSettings;
+        loadUserSettings = mod.loadUserSettings;
+        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
+        if (fs.existsSync(settingsPath))
+            fs.rmSync(settingsPath, { force: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+        if (origHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = origHome;
+        if (origUserProfile === undefined)
+            delete process.env.USERPROFILE;
+        else
+            process.env.USERPROFILE = origUserProfile;
+    });
+    it("persists agentFirst, maxToolRounds, hardMaxToolRounds, maxLlmCallsPerTurn", () => {
+        saveUserSettings({
+            agentFirst: true,
+            maxToolRounds: 150,
+            hardMaxToolRounds: 250,
+            maxLlmCallsPerTurn: 80,
+        });
+        const loaded = loadUserSettings();
+        expect(loaded.agentFirst).toBe(true);
+        expect(loaded.maxToolRounds).toBe(150);
+        expect(loaded.hardMaxToolRounds).toBe(250);
+        expect(loaded.maxLlmCallsPerTurn).toBe(80);
+    });
+});
+//# sourceMappingURL=settings-agent-first.test.js.map

package/dist/src/utils/clipboard-image.js

@@ -25,24 +25,24 @@ function readWin32() {
     try {
         const escaped = tmpFile.replace(/\\/g, "\\\\");
         // Run in STA thread with retry — clipboard can be locked by other processes
-        const ps = `
-      Add-Type -AssemblyName System.Windows.Forms
-      Add-Type -AssemblyName System.Drawing
-      $maxRetries = 3
-      $img = $null
-      for ($i = 0; $i -lt $maxRetries; $i++) {
-        try {
-          $img = [System.Windows.Forms.Clipboard]::GetImage()
-          if ($img -ne $null) { break }
-        } catch {
-          # clipboard locked — wait and retry
-        }
-        Start-Sleep -Milliseconds 100
-      }
-      if ($img -ne $null) {
-        $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png)
-        $img.Dispose()
-      }
+        const ps = `
+      Add-Type -AssemblyName System.Windows.Forms
+      Add-Type -AssemblyName System.Drawing
+      $maxRetries = 3
+      $img = $null
+      for ($i = 0; $i -lt $maxRetries; $i++) {
+        try {
+          $img = [System.Windows.Forms.Clipboard]::GetImage()
+          if ($img -ne $null) { break }
+        } catch {
+          # clipboard locked — wait and retry
+        }
+        Start-Sleep -Milliseconds 100
+      }
+      if ($img -ne $null) {
+        $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png)
+        $img.Dispose()
+      }
     `;
         const result = spawnSync("powershell", ["-NoProfile", "-STA", "-Command", ps], { timeout: 8000 });
         if (result.error || result.status !== 0)
@@ -81,11 +81,11 @@ function readDarwin() {
         const pngpaste = spawnSync("pngpaste", [tmpFile], { timeout: 5000 });
         if (pngpaste.status !== 0) {
             spawnSync("screencapture", ["-c", "-x"]);
-            const osascript = `
-        set imgData to the clipboard as «class PNGf»
-        set f to open for access POSIX file "${tmpFile}" with write permission
-        write imgData to f
-        close access f
+            const osascript = `
+        set imgData to the clipboard as «class PNGf»
+        set f to open for access POSIX file "${tmpFile}" with write permission
+        write imgData to f
+        close access f
       `;
             spawnSync("osascript", ["-e", osascript], { timeout: 5000 });
         }

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

@@ -49,6 +49,7 @@ export declare function getReleaseTargetForPlatform(platform?: NodeJS.Platform,
 export declare function loadScriptInstallMetadata(homeDir?: string): ScriptInstallMetadata | null;
 export declare function saveScriptInstallMetadata(metadata: ScriptInstallMetadata, homeDir?: string): void;
 export declare function getScriptInstallContext(homeDir?: string): ScriptInstallContext | null;
+export declare function fetchLatestGitTag(gitDir: string): Promise<string | null>;
 export declare function fetchLatestReleaseVersion(): Promise<string | null>;
 export declare function parseChecksumsFile(contents: string): Map<string, string>;
 /**

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

@@ -1,4 +1,4 @@
-import { spawn } from "child_process";
+import { exec, spawn } from "child_process";
 import { createHash } from "crypto";
 import fs from "fs";
 import os from "os";
@@ -83,6 +83,34 @@ export function getScriptInstallContext(homeDir = os.homedir()) {
     }
     return null;
 }
+export function fetchLatestGitTag(gitDir) {
+    return new Promise((resolve) => {
+        exec(`git -C "${gitDir}" ls-remote --tags origin`, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const lines = stdout.split(/\r?\n/);
+            let maxVersion = null;
+            for (const line of lines) {
+                const match = line.match(/refs\/tags\/(v?[0-9]+\.[0-9]+\.[0-9]+[^\s]*)$/);
+                if (!match)
+                    continue;
+                let tag = match[1];
+                if (tag.endsWith("^{}")) {
+                    tag = tag.slice(0, -3);
+                }
+                const version = normalizeReleaseVersion(tag);
+                if (!version)
+                    continue;
+                if (!maxVersion || semverGt(version, maxVersion)) {
+                    maxVersion = version;
+                }
+            }
+            resolve(maxVersion);
+        });
+    });
+}
 export async function fetchLatestReleaseVersion() {
     const release = await fetchReleaseJson(`${RELEASES_API}/latest`);
     return release ? normalizeReleaseVersion(release.tag_name) : null;
@@ -179,31 +207,66 @@ export async function runManagedUpdate(currentVersion) {
     const method = detectInstallMethod();
     if (method === "script")
         return runScriptManagedUpdate(currentVersion);
+    const root = findGitRoot(path.dirname(runningModulePath()));
+    let latestVersion = null;
+    if (method === "dev-link" && root) {
+        latestVersion = await fetchLatestGitTag(root);
+    }
+    else {
+        latestVersion = await fetchLatestReleaseVersion();
+    }
+    const normalizedCurrent = semverValid(currentVersion);
+    let statusHeader = "";
+    let hasUpdate = false;
+    if (latestVersion && normalizedCurrent) {
+        hasUpdate = semverGt(latestVersion, normalizedCurrent);
+        if (hasUpdate) {
+            statusHeader = `A new version of muonroi-cli is available!\n  Current version: v${normalizedCurrent}\n  Latest version: v${latestVersion}\n\n`;
+        }
+        else {
+            statusHeader = `You are already up to date!\n  Current version: v${normalizedCurrent}\n  Latest version: v${latestVersion}\n\n`;
+        }
+    }
+    else if (normalizedCurrent) {
+        statusHeader = `Current version: v${normalizedCurrent}\nUnable to check the latest version from GitHub.\n\n`;
+    }
     const cmd = getUpdateCommandForMethod(method);
     if (cmd) {
         const pm = method === "bun-global" ? "bun" : "npm";
+        const instruction = hasUpdate
+            ? `To update, run this in a fresh terminal:\n\n  ${cmd}\n\nThen restart muonroi-cli.`
+            : `If you want to reinstall, run this in a fresh terminal:\n\n  ${cmd}`;
         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.`,
+            output: `${statusHeader}${instruction}`,
         };
     }
     if (method === "compiled") {
         const target = getReleaseTargetForPlatform();
         const asset = target?.assetName ?? "the release asset for your platform";
+        const instruction = hasUpdate
+            ? `Download the latest ${asset} from https://github.com/${GITHUB_REPO}/releases/latest and replace the current binary, or rebuild from source.`
+            : `If you want to reinstall, download the latest ${asset} from https://github.com/${GITHUB_REPO}/releases/latest and replace the current binary.`;
         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.`,
+            output: `${statusHeader}${instruction}`,
         };
     }
     if (method === "dev-link") {
-        const root = findGitRoot(path.dirname(runningModulePath()));
         const target = root ?? "the muonroi-cli checkout";
+        const instruction = hasUpdate
+            ? `To update, pull the latest changes and rebuild:\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.)`
+            : `To rebuild your local installation:\n\n  git -C "${target}" pull && bun install && bun run build\n\nThen restart muonroi-cli.`;
         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.)`,
+            output: `${statusHeader}${instruction}`,
         };
     }
-    return notScriptManaged("update");
+    const fallback = notScriptManaged("update");
+    return {
+        success: fallback.success,
+        output: `${statusHeader}${fallback.output}`,
+    };
 }
 export async function runScriptManagedUpdate(currentVersion) {
     const context = getScriptInstallContext();
@@ -348,7 +411,13 @@ async function fetchReleaseJson(url) {
     try {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-        const res = await fetch(url, { signal: controller.signal, headers: { Accept: "application/vnd.github+json" } });
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "muonroi-cli",
+            },
+        });
         clearTimeout(timer);
         return res.ok ? (await res.json()) : null;
     }