muonroi-cli 1.8.0 → 1.8.3

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/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/install-manager.d.ts

@@ -49,7 +49,9 @@ 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 fetchLatestNpmVersion(pkgName?: string): 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

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,10 +83,59 @@ 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;
 }
+export async function fetchLatestNpmVersion(pkgName = "muonroi-cli") {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const res = await fetch(`https://registry.npmjs.org/${pkgName}/latest`, {
+            signal: controller.signal,
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "muonroi-cli",
+            },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.version ? semverValid(data.version) : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function parseChecksumsFile(contents) {
     const result = new Map();
     for (const rawLine of contents.split(/\r?\n/)) {
@@ -179,31 +228,72 @@ 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 if (method === "bun-global" || method === "npm-global") {
+        latestVersion = await fetchLatestNpmVersion("muonroi-cli");
+    }
+    else {
+        latestVersion = await fetchLatestReleaseVersion();
+        if (!latestVersion) {
+            latestVersion = await fetchLatestNpmVersion("muonroi-cli");
+        }
+    }
+    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 +438,15 @@ 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 token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "muonroi-cli",
+                ...(token ? { Authorization: `token ${token}` } : {}),
+            },
+        });
         clearTimeout(timer);
         return res.ok ? (await res.json()) : null;
     }

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

@@ -0,0 +1,28 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogNamespace = "cli" | "ui" | "orchestrator" | "storage" | "ee" | "mcp" | "pil" | "router";
+export interface LogContext {
+    elapsedMs?: number;
+    error?: Error | unknown;
+    [key: string]: unknown;
+}
+/**
+ * Checks if the given log level is enabled based on the current process level weight.
+ */
+export declare function isLogLevelEnabled(level: LogLevel): boolean;
+/**
+ * Redacts common patterns of API keys and credential strings from log messages.
+ */
+export declare function redactSecrets(str: string): string;
+/**
+ * Recursively redacts sensitive fields from context objects.
+ */
+export declare function redactObject(obj: unknown): unknown;
+/**
+ * Structured unified logging system.
+ */
+export declare const logger: {
+    debug(ns: LogNamespace, msg: string, ctx?: LogContext): void;
+    info(ns: LogNamespace, msg: string, ctx?: LogContext): void;
+    warn(ns: LogNamespace, msg: string, ctx?: LogContext): void;
+    error(ns: LogNamespace, msg: string, ctx?: LogContext): void;
+};

package/dist/src/utils/logger.js

@@ -0,0 +1,171 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const LEVEL_WEIGHTS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+// Default log level is 'info' unless explicitly configured.
+const CURRENT_WEIGHT = (() => {
+    const envLevel = process.env.MUONROI_LOG_LEVEL?.toLowerCase();
+    if (envLevel === "debug")
+        return LEVEL_WEIGHTS.debug;
+    if (envLevel === "info")
+        return LEVEL_WEIGHTS.info;
+    if (envLevel === "warn")
+        return LEVEL_WEIGHTS.warn;
+    if (envLevel === "error")
+        return LEVEL_WEIGHTS.error;
+    return LEVEL_WEIGHTS.info;
+})();
+/**
+ * Checks if the given log level is enabled based on the current process level weight.
+ */
+export function isLogLevelEnabled(level) {
+    return LEVEL_WEIGHTS[level] >= CURRENT_WEIGHT;
+}
+/**
+ * Redacts common patterns of API keys and credential strings from log messages.
+ */
+export function redactSecrets(str) {
+    return str
+        .replace(/\bsk-[A-Za-z0-9-_]{20,}\b/g, "[REDACTED_API_KEY]")
+        .replace(/\bxai-[A-Za-z0-9-_]{20,}\b/g, "[REDACTED_API_KEY]")
+        .replace(/\bAIzaSy[A-Za-z0-9-_]{30,}\b/g, "[REDACTED_API_KEY]");
+}
+/**
+ * Recursively redacts sensitive fields from context objects.
+ */
+export function redactObject(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj === "string") {
+        return redactSecrets(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(redactObject);
+    }
+    if (typeof obj === "object") {
+        const res = {};
+        for (const [k, v] of Object.entries(obj)) {
+            const lowerK = k.toLowerCase();
+            if (lowerK.includes("key") ||
+                lowerK.includes("secret") ||
+                lowerK.includes("token") ||
+                lowerK.includes("password") ||
+                lowerK.includes("auth")) {
+                res[k] = "[REDACTED]";
+            }
+            else {
+                res[k] = redactObject(v);
+            }
+        }
+        return res;
+    }
+    return obj;
+}
+/**
+ * Returns true if the interactive TUI is active, preventing console writes.
+ */
+function isTuiActive() {
+    try {
+        return globalThis.__muonroiTuiActive === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Writes logs safely to ~/.muonroi-cli/debug.log.
+ */
+function appendToFile(level, ns, msg, ctx) {
+    try {
+        const dir = path.join(os.homedir(), ".muonroi-cli");
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const logPath = path.join(dir, "debug.log");
+        const ts = new Date().toISOString();
+        const redactedCtx = ctx ? redactObject(ctx) : null;
+        const ctxStr = redactedCtx ? ` ${JSON.stringify(redactedCtx)}` : "";
+        const logLine = `[${ts}] [${level.toUpperCase()}] [${ns.toUpperCase()}] ${redactSecrets(msg)}${ctxStr}\n`;
+        fs.appendFileSync(logPath, logLine, "utf8");
+    }
+    catch {
+        /* fail-open */
+    }
+}
+/**
+ * Formats console log lines with colors.
+ */
+function formatConsole(level, ns, msg, ctx) {
+    const ts = new Date().toISOString().split("T")[1].slice(0, -1); // HH:MM:SS.mmm
+    const levelStr = level.toUpperCase();
+    const nsStr = ns.toUpperCase();
+    const cleanMsg = redactSecrets(msg);
+    const redactedCtx = ctx ? redactObject(ctx) : null;
+    const ctxStr = redactedCtx ? ` ${JSON.stringify(redactedCtx)}` : "";
+    // Apply colors for developer convenience in terminal logs (non-TUI)
+    let color = "\x1b[0m"; // Reset
+    if (level === "debug")
+        color = "\x1b[90m"; // Gray
+    if (level === "info")
+        color = "\x1b[32m"; // Green
+    if (level === "warn")
+        color = "\x1b[33m"; // Yellow
+    if (level === "error")
+        color = "\x1b[31m"; // Red
+    return `${color}[${ts}] [${levelStr}] [${nsStr}] ${cleanMsg}${ctxStr}\x1b[0m`;
+}
+/**
+ * Structured unified logging system.
+ */
+export const logger = {
+    debug(ns, msg, ctx) {
+        if (!isLogLevelEnabled("debug"))
+            return;
+        if (isTuiActive()) {
+            appendToFile("debug", ns, msg, ctx);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(formatConsole("debug", ns, msg, ctx));
+        }
+    },
+    info(ns, msg, ctx) {
+        if (!isLogLevelEnabled("info"))
+            return;
+        if (isTuiActive()) {
+            appendToFile("info", ns, msg, ctx);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(formatConsole("info", ns, msg, ctx));
+        }
+    },
+    warn(ns, msg, ctx) {
+        if (!isLogLevelEnabled("warn"))
+            return;
+        if (isTuiActive()) {
+            appendToFile("warn", ns, msg, ctx);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn(formatConsole("warn", ns, msg, ctx));
+        }
+    },
+    error(ns, msg, ctx) {
+        if (!isLogLevelEnabled("error"))
+            return;
+        if (isTuiActive()) {
+            appendToFile("error", ns, msg, ctx);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.error(formatConsole("error", ns, msg, ctx));
+        }
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/src/utils/settings.d.ts

@@ -75,6 +75,14 @@ export interface UserSettings {
      * defaultModel field stays as the hard pin for legacy paths.
      */
     defaultProvider?: ProviderId;
+    /** When true, the agent prioritizes task completion over strict runaway safety caps. */
+    agentFirst?: boolean;
+    /** Custom soft limit on the number of tool execution steps before pausing. */
+    maxToolRounds?: number;
+    /** Custom hard limit on the number of tool execution steps per turn. */
+    hardMaxToolRounds?: number;
+    /** Custom limit on the number of LLM call round-trips allowed in a single turn. */
+    maxLlmCallsPerTurn?: number;
     /** Shell used by the bash tool. On Windows, defaults to Git Bash when present. */
     shell?: ShellSettings;
     lsp?: LspSettings;
@@ -343,7 +351,7 @@ export declare function getTopLevelCompactKeepLast(): number;
  * higher default so single-tool turns are unaffected. Env override:
  * MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS.
  */
-export declare function getTopLevelToolBudgetChars(): number;
+export declare function getTopLevelToolBudgetChars(maxRounds?: number): number;
 export declare function getRoleModel(role: ModelRole): string | undefined;
 export declare function getRoleModels(): Partial<Record<ModelRole, string>>;
 export declare function getCouncilRounds(): number;

package/dist/src/utils/settings.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import { getEffectiveReasoningEffort, getFirstCatalogModel, getFirstCatalogProvider, getModelByTier, getModelIds, getModelInfo, MODELS, normalizeModelId, } from "../models/registry.js";
 import { apiBaseFor, PROVIDER_ENDPOINTS } from "../providers/endpoints.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
+import { logger } from "./logger.js";
 import { normalizeShellSettings } from "./shell.js";
 export function getCatalogDefaultModel() {
     const provider = getDefaultProvider();
@@ -79,18 +80,58 @@ function ensureDir(dir) {
     }
 }
 function readJson(filePath) {
-    try {
-        if (!fs.existsSync(filePath))
-            return null;
-        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return null;
+    const RETRIES = 5;
+    let lastErr;
+    for (let attempt = 0; attempt < RETRIES; attempt++) {
+        try {
+            if (!fs.existsSync(filePath))
+                return null;
+            return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            if (code === "EBUSY" || code === "EPERM" || err instanceof SyntaxError) {
+                logger.warn("cli", `Lock contention or syntax error reading ${path.basename(filePath)}, retrying (attempt ${attempt + 1}/${RETRIES})`, { error: err });
+                // Spin wait briefly to let the lock release or the write complete
+                const end = Date.now() + 20 * (attempt + 1);
+                while (Date.now() < end) {
+                    // busy wait
+                }
+            }
+            else {
+                return null;
+            }
+        }
     }
+    return null;
 }
 function writeJson(filePath, data) {
     ensureDir(path.dirname(filePath));
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+    const serialized = JSON.stringify(data, null, 2);
+    const RETRIES = 5;
+    let lastErr;
+    for (let attempt = 0; attempt < RETRIES; attempt++) {
+        try {
+            fs.writeFileSync(filePath, serialized, { mode: 0o600 });
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            if (code === "EBUSY" || code === "EPERM") {
+                logger.warn("cli", `Lock contention writing ${path.basename(filePath)}, retrying (attempt ${attempt + 1}/${RETRIES})`, { error: err });
+                const end = Date.now() + 20 * (attempt + 1);
+                while (Date.now() < end) {
+                    // busy wait
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    throw lastErr;
 }
 /**
  * Ensure the CLI's own project-local footprint (`.muonroi-cli/`) is gitignored
@@ -559,13 +600,13 @@ export function getSubAgentBudgetChars() {
     const envRaw = process.env.MUONROI_SUB_AGENT_BUDGET_CHARS;
     if (envRaw) {
         const n = Number(envRaw);
-        if (Number.isFinite(n) && n >= 20_000 && n <= 600_000)
+        if (Number.isFinite(n) && n >= 20_000 && n <= 5_000_000)
             return Math.floor(n);
     }
     const val = loadUserSettings().subAgentBudgetChars;
-    if (typeof val === "number" && val >= 20_000 && val <= 600_000)
+    if (typeof val === "number" && val >= 20_000 && val <= 5_000_000)
         return Math.floor(val);
-    return 120_000;
+    return 240_000;
 }
 /**
  * Stall watchdog timeout (ms) for streaming model calls: if the provider sends
@@ -694,24 +735,20 @@ export function getTopLevelCompactKeepLast() {
  * higher default so single-tool turns are unaffected. Env override:
  * MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS.
  */
-export function getTopLevelToolBudgetChars() {
+export function getTopLevelToolBudgetChars(maxRounds) {
     const envRaw = process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS;
     if (envRaw) {
         const n = Number(envRaw);
-        if (Number.isFinite(n) && n >= 50_000 && n <= 1_500_000)
+        if (Number.isFinite(n) && n >= 50_000 && n <= 10_000_000)
             return Math.floor(n);
     }
     const val = loadUserSettings().topLevelToolBudgetChars;
-    if (typeof val === "number" && val >= 50_000 && val <= 1_500_000)
+    if (typeof val === "number" && val >= 50_000 && val <= 10_000_000)
         return Math.floor(val);
-    // Phase C5 symmetry — lowered from 400_000 to 200_000 chars. Evidence from
-    // session f1eef338c784: top-level tool loop ran 49 turns consuming 3.4M
-    // input tokens before the budget cap (set at 400K chars) meaningfully
-    // constrained tool outputs. At 200K chars the 50% tier fires at 100K chars
-    // (~3 tool turns), and the 80% tier at 160K chars (~5 turns); small tasks
-    // (1-3 turns) are unaffected. The sub-agent budget is 120K, so 200K maintains
-    // a ~1.7x ratio reflecting the broader top-level conversation context.
-    return 200_000;
+    // Dynamically scale default based on maxRounds relative to default base (40)
+    const baseRounds = 40;
+    const scale = maxRounds && maxRounds > baseRounds ? maxRounds / baseRounds : 1;
+    return Math.floor(400_000 * scale);
 }
 export function getRoleModel(role) {
     return loadUserSettings().roleModels?.[role];