@sagentlab/navarch-runtime 0.1.116 → 0.1.118

package/dist/adapters/muse.cjs

@@ -0,0 +1,433 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.museAdapter = exports.MUSE_HOST_GUARD_MESSAGE = void 0;
+exports.runMuseAdapter = runMuseAdapter;
+exports.sumMuseSessionCost = sumMuseSessionCost;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const version_cjs_1 = require("../version.cjs");
+const CANCEL_GRACE_MS = 2_000;
+const SHUTDOWN_GRACE_MS = 30_000;
+const TERMINATE_GRACE_MS = 2_000;
+exports.MUSE_HOST_GUARD_MESSAGE = "Muse Code cannot yet prove Navarch's host worktree boundary. Use a custom " +
+    "NAVARCH_SANDBOX_MODE=docker image with Muse installed, or explicitly set " +
+    "NAVARCH_WORKTREE_GUARD=off only on an otherwise isolated machine.";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function count(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise((done) => { resolve = done; });
+    return { promise, resolve };
+}
+async function waitWithin(promise, ms) {
+    let timer;
+    await Promise.race([promise, new Promise((resolve) => { timer = setTimeout(resolve, ms); })]);
+    clearTimeout(timer);
+}
+/**
+ * Muse Session Protocol through the pinned official SDK's framed Connection.
+ * Own the child here (rather than the facade's private child) so Navarch can
+ * register its PID, stream raw output and kill its complete process group.
+ * The facade intentionally does not forward session-scoped MCP configuration.
+ * No `exec --json` fallback: its event contract is a different surface.
+ */
+async function runMuseAdapter(options) {
+    const empty = { exitCode: null, timedOut: false, killedByLeaseLoss: false, stdout: "", stderr: "" };
+    if (options.signal?.aborted)
+        return { ...empty, killedByLeaseLoss: true };
+    if (!options.dockerExec && options.museHostGuard !== false)
+        throw new Error(exports.MUSE_HOST_GUARD_MESSAGE);
+    if (!options.cwd || !node_path_1.default.isAbsolute(options.cwd))
+        throw new Error("Muse requires an absolute session worktree.");
+    if (options.extraArgs.some((arg) => /^(--yolo|--disable-sandbox|--disable-approval)(=|$)/.test(arg))) {
+        throw new Error("Muse permission and sandbox bypass flags are not supported by Navarch.");
+    }
+    const sourceServers = await readMcpServers(options.mcpConfigPath, options.env);
+    const sdk = await import("@muse-code/sdk");
+    const bridge = await prepareBridge(sourceServers, options);
+    try {
+        return await runMuseProcess(options, bridge.servers, sdk);
+    }
+    finally {
+        if (bridge.dir)
+            await node_fs_1.promises.rm(bridge.dir, { recursive: true, force: true });
+    }
+}
+async function runMuseProcess(options, mcpServers, sdk) {
+    const child = spawnMuse(options);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdin.on("error", () => undefined); // A dead host is handled by its exit/EOF.
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killedByLeaseLoss = false;
+    let processCode = null;
+    let sessionId;
+    let turnId;
+    let durable = false;
+    let terminal;
+    let authError;
+    let protocolFailed = false;
+    const closed = deferred();
+    const stopped = deferred();
+    const completed = deferred();
+    const items = new Map();
+    const usage = new Map();
+    const pending = [];
+    let cancelling;
+    const diagnostic = (message) => { stderr += `${stderr ? "\n" : ""}${message}`; };
+    child.on("error", (error) => { diagnostic(`Muse process failed: ${error.message}`); closed.resolve(); });
+    child.on("exit", (code) => {
+        processCode = code;
+        // A descendant may keep stdio open after its root exits.
+        if (!options.dockerExec)
+            (0, kill_agent_cjs_1.killAgent)(child);
+    });
+    child.on("close", (code) => { processCode = code; closed.resolve(); });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+        options.onActivity?.();
+        options.onOutput?.("stderr", chunk);
+    });
+    const connection = new sdk.Connection({
+        incoming: (async function* () {
+            for await (const chunk of child.stdout) {
+                const text = String(chunk);
+                stdout += text;
+                options.onActivity?.();
+                options.onOutput?.("stdout", text);
+                yield text;
+            }
+        })(),
+        write: (chunk) => new Promise((resolve, reject) => {
+            child.stdin.write(chunk, (error) => error ? reject(error) : resolve());
+        }),
+    });
+    const cancel = () => cancelling ??= (async () => {
+        if (sessionId && turnId) {
+            // Admission is not cancellation completion. Give the host a bounded
+            // chance to settle before killing; never keep a lost lease alive.
+            void connection.command("turn/cancel", { sessionId, turnId }, { maxAttempts: 1 }).catch(() => undefined);
+            await waitWithin(Promise.race([completed.promise, closed.promise]), CANCEL_GRACE_MS);
+        }
+        if (options.dockerExec) {
+            await options.dockerExec.runner.run("docker", ["kill", options.dockerExec.containerName], { timeoutMs: 10_000 }).catch(() => undefined);
+        }
+        (0, kill_agent_cjs_1.killAgent)(child);
+    })();
+    const stop = () => { stopped.resolve(); void cancel(); };
+    const onAbort = () => { killedByLeaseLoss = true; stop(); };
+    const timer = options.timeoutMs > 0 ? setTimeout(() => { timedOut = true; stop(); }, options.timeoutMs) : undefined;
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted)
+        onAbort();
+    const consume = (notification) => {
+        const params = record(notification.params);
+        if (!params || params.sessionId !== sessionId)
+            return;
+        if (notification.method === "view/gap") {
+            protocolFailed = true;
+            diagnostic("Muse event stream has a gap; refusing an incomplete result.");
+            stop();
+            return;
+        }
+        if (notification.method === "item/completed") {
+            const item = record(params.item);
+            if (!item || item.turnId !== turnId || item.kind !== "agentMessage" || typeof item.itemId !== "string")
+                return;
+            const previous = items.get(item.itemId);
+            if (!previous || Number(item.revision) >= Number(previous.revision))
+                items.set(item.itemId, item);
+        }
+        else if (params.turnId === turnId && notification.method === "session/tokenUsage") {
+            if (typeof params.viewCursor === "string")
+                usage.set(params.viewCursor, params);
+        }
+        else if (params.turnId === turnId && notification.method === "turn/completed") {
+            terminal = params;
+            const error = record(params.error);
+            if (params.terminal === "failed" && error?.kind === "authRequired") {
+                authError = "Muse authentication is required. Open muse and run /login on this machine.";
+            }
+            completed.resolve();
+        }
+    };
+    connection.onNotification((notification) => {
+        if (!turnId) {
+            // Events can precede the acknowledgement. Do not assume commandId is
+            // turnId; use the authoritative ack, then drain in wire order.
+            if (pending.length >= 10_000) {
+                protocolFailed = true;
+                diagnostic("Muse sent too many events before acknowledging the turn.");
+                stop();
+            }
+            else
+                pending.push(notification);
+        }
+        else
+            consume(notification);
+    });
+    connection.onProtocolError(() => {
+        protocolFailed = true;
+        diagnostic("Muse sent an invalid MSP frame; refusing to continue.");
+        stop();
+    });
+    // Unattended agents cannot invent approval or answer interactive questions.
+    // denyUnmatched is also selected below; unexpected requests abort the turn.
+    connection.onServerRequest(async () => {
+        protocolFailed = true;
+        diagnostic("Muse requested interactive approval or input; operator action is required.");
+        stop();
+        throw new sdk.MspError({ code: -32601, message: "Navarch cannot approve interactive requests", data: { kind: "methodNotFound", retryable: false } });
+    });
+    try {
+        options.onProcessStarted?.(child.pid);
+        const run = async () => {
+            const initialized = await connection.request("initialize", {
+                clientInfo: { name: "navarch_runtime", version: version_cjs_1.RUNTIME_VERSION },
+                capabilities: { requestedCapabilities: Object.keys(mcpServers).length ? ["sessionMcp"] : [], userInputDialogs: false },
+            });
+            const schema = record(initialized.schema);
+            if (typeof schema?.fingerprint !== "string")
+                throw new Error("Muse initialization did not provide a schema fingerprint.");
+            if (sdk.checkServedFingerprint(schema.fingerprint))
+                diagnostic("Muse schema fingerprint differs from the pinned SDK; unknown fields are tolerated.");
+            if (Object.keys(mcpServers).length && (!Array.isArray(initialized.grantedCapabilities) || !initialized.grantedCapabilities.includes("sessionMcp"))) {
+                throw new Error("Muse did not grant sessionMcp; the task cannot run without its lease-scoped tools.");
+            }
+            durable = initialized.sessionDurability === undefined || initialized.sessionDurability === "durable";
+            connection.notify("initialized");
+            await connection.flush();
+            if (timedOut || killedByLeaseLoss || protocolFailed)
+                return;
+            const config = Object.keys(mcpServers).length ? { mcpServers } : undefined;
+            const opened = options.resumeSessionId
+                ? await connection.command("session/resume", { sessionId: options.resumeSessionId, excludeItems: true, ...(config ? { config } : {}) }, { maxAttempts: 1 })
+                : await connection.command("session/start", {
+                    workspaceRoot: options.cwd,
+                    approvalMode: "denyUnmatched",
+                    ...(options.model && options.model !== "default" ? { modelId: options.model } : {}),
+                    ...(config ? { config } : {}),
+                }, { maxAttempts: 1 });
+            const session = record(opened.session);
+            if (typeof session?.sessionId !== "string" || typeof session.workspaceRoot !== "string"
+                || !node_path_1.default.isAbsolute(session.workspaceRoot) || await node_fs_1.promises.realpath(session.workspaceRoot) !== await node_fs_1.promises.realpath(options.cwd)
+                || session.activeTurnId !== null) {
+                throw new Error("Muse returned an unexpected session identity, worktree, or active turn.");
+            }
+            if (options.resumeSessionId && session.sessionId !== options.resumeSessionId)
+                throw new Error("Muse resumed a different session.");
+            sessionId = session.sessionId;
+            if (options.resumeSessionId) {
+                if (!durable)
+                    throw new Error("Muse cannot resume this session on an ephemeral host.");
+                if (record(opened.history)?.mode !== "none")
+                    throw new Error("Muse resume returned unexpected history; refusing replay.");
+                await connection.command("session/setApprovalMode", { sessionId, mode: "denyUnmatched" }, { maxAttempts: 1 });
+                if (options.model && options.model !== "default" && session.modelId !== options.model) {
+                    throw new Error("Muse resumed with a different model than the dispatched policy.");
+                }
+            }
+            // An older host may ignore additive fields. Prove the selected approval
+            // posture before sending any model-visible prompt.
+            let approvalMode = options.resumeSessionId ? undefined : record(session.approvalMode)?.mode;
+            if (approvalMode !== "denyUnmatched" && durable) {
+                const state = await connection.request("session/read", { sessionId, excludeItems: true });
+                approvalMode = record(record(state.session)?.approvalMode)?.mode;
+            }
+            if (approvalMode !== "denyUnmatched") {
+                throw new Error("Muse did not confirm denyUnmatched approval mode; refusing to start a turn.");
+            }
+            if (timedOut || killedByLeaseLoss || protocolFailed)
+                return;
+            const ack = await connection.command("turn/start", {
+                sessionId,
+                input: [{ type: "text", text: options.prompt }],
+                ...(options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}),
+            }, { maxAttempts: 1 });
+            if (typeof ack.turnId !== "string" || ack.disposition !== "started")
+                throw new Error("Muse did not start the requested turn.");
+            turnId = ack.turnId;
+            for (const notification of pending.splice(0))
+                consume(notification);
+            await Promise.race([completed.promise, connection.closed]);
+            if (!terminal && !timedOut && !killedByLeaseLoss)
+                throw new Error("Muse closed before the turn completed.");
+        };
+        await Promise.race([run(), stopped.promise]);
+    }
+    catch (error) {
+        if (error instanceof sdk.MspError && error.kind === "authRequired") {
+            authError = "Muse authentication is required. Open muse and run /login on this machine.";
+        }
+        if (!timedOut && !killedByLeaseLoss)
+            diagnostic(error instanceof Error ? error.message : "Muse protocol request failed.");
+    }
+    finally {
+        await cancelling;
+        // EOF releases Muse's writer lease. A bounded shutdown always reaps the
+        // child, including a host that ignores EOF or died during a request.
+        child.stdin.end();
+        await waitWithin(Promise.race([closed.promise, stopped.promise]), SHUTDOWN_GRACE_MS);
+        await cancelling;
+        if (child.exitCode === null && child.signalCode === null) {
+            (0, kill_agent_cjs_1.killAgent)(child, "SIGTERM");
+            await waitWithin(closed.promise, TERMINATE_GRACE_MS);
+            if (child.exitCode === null && child.signalCode === null)
+                (0, kill_agent_cjs_1.killAgent)(child);
+            if (options.dockerExec)
+                await options.dockerExec.runner.run("docker", ["kill", options.dockerExec.containerName], { timeoutMs: 10_000 }).catch(() => undefined);
+            await waitWithin(closed.promise, TERMINATE_GRACE_MS);
+        }
+        // The root may have exited while detached shell/MCP descendants remain.
+        // Reap our owned host process group even after a clean root exit.
+        if (!options.dockerExec)
+            (0, kill_agent_cjs_1.killAgent)(child);
+        await waitWithin(closed.promise, TERMINATE_GRACE_MS);
+        await connection.close().catch(() => undefined);
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+    }
+    if (processCode === 5)
+        diagnostic("This Muse build has the experimental SDK/serve surface disabled. No CLI fallback was attempted.");
+    const successful = !protocolFailed && terminal?.terminal === "completed" && processCode === 0;
+    if (terminal && terminal.terminal !== "completed" && !timedOut && !killedByLeaseLoss && !authError) {
+        diagnostic(`Muse turn did not complete successfully (${String(terminal.terminal)}).`);
+    }
+    const reportText = [...items.values()].flatMap((item) => typeof item.text === "string" ? [item.text] : []).join("\n").trim();
+    return {
+        exitCode: timedOut || killedByLeaseLoss ? null : successful ? 0 : processCode === null ? null : 1,
+        timedOut, killedByLeaseLoss, stdout, stderr,
+        ...(reportText ? { reportText } : {}),
+        ...(authError ? { authError } : {}),
+        ...(durable && sessionId && terminal ? { agentSessionId: sessionId } : {}),
+        ...normalizedUsage([...usage.values()], !options.resumeSessionId),
+    };
+}
+function normalizedUsage(events, fresh) {
+    if (!events.length)
+        return {};
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let cacheHitTokensIn = 0;
+    let completeCache = true;
+    for (const event of events) {
+        const usage = record(event.usage);
+        const input = count(event.promptTokens);
+        const output = count(usage?.outputTokens);
+        if (input === undefined || output === undefined)
+            return {}; // No fabricated partial total.
+        tokensIn += input;
+        tokensOut += output;
+        const cache = count(usage?.cacheReadTokens);
+        if (cache === undefined || cache > input)
+            completeCache = false;
+        else
+            cacheHitTokensIn += cache;
+    }
+    if (!Number.isSafeInteger(tokensIn) || !Number.isSafeInteger(tokensOut))
+        return {};
+    const cost = record(record(events.at(-1)?.cumulative)?.cost);
+    return {
+        tokensIn, tokensOut,
+        ...(completeCache ? { cacheHitTokensIn } : {}),
+        ...(cost?.partial === false && typeof cost.usd === "number" && Number.isFinite(cost.usd) && cost.usd >= 0
+            ? { sessionCostUsd: cost.usd, ...(fresh ? { costUsd: cost.usd } : {}) } : {}),
+    };
+}
+/** Replace each provider session's cumulative estimate, never sum it per turn. */
+function sumMuseSessionCost(attempts) {
+    const sessions = new Map();
+    attempts.forEach((attempt, index) => sessions.set(attempt.agentSessionId ?? `attempt:${index}`, attempt.sessionCostUsd));
+    if (!sessions.size || [...sessions.values()].some((cost) => cost === undefined))
+        return undefined;
+    return [...sessions.values()].reduce((sum, cost) => sum + cost, 0);
+}
+async function prepareBridge(source, options) {
+    if (!Object.keys(source).length)
+        return { servers: {} };
+    if (!options.mcpMetadataDir || !node_path_1.default.isAbsolute(options.mcpMetadataDir))
+        throw new Error("Muse MCP needs a task-owned metadata directory.");
+    const dir = await node_fs_1.promises.mkdtemp(node_path_1.default.join(options.mcpMetadataDir, "muse-mcp-"));
+    try {
+        const configPath = node_path_1.default.join(dir, "servers.json");
+        const content = JSON.stringify(source);
+        await node_fs_1.promises.writeFile(configPath, content, { mode: 0o600 });
+        const digest = (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+        const servers = Object.fromEntries(Object.keys(source).map((name) => [name, {
+                transport: "stdio", framing: "lineDelimitedJson", mode: "required",
+                command: options.dockerExec ? "navarch-muse-mcp-bridge" : process.execPath,
+                args: [...(options.dockerExec ? [] : [node_path_1.default.resolve(__dirname, "../../bin/muse-mcp-bridge.cjs")]), configPath, name, digest],
+            }]));
+        return { servers, dir };
+    }
+    catch (error) {
+        await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function readMcpServers(configPath, env) {
+    if (!configPath)
+        return {};
+    const parsed = record(JSON.parse(await node_fs_1.promises.readFile(configPath, "utf8")));
+    const source = record(parsed?.mcpServers);
+    if (!source)
+        throw new Error("Muse MCP configuration must contain mcpServers.");
+    const result = Object.create(null);
+    const strings = (value) => {
+        const entries = value === undefined ? {} : record(value);
+        if (!entries)
+            throw new Error("Muse MCP environment/headers must be string maps.");
+        return Object.fromEntries(Object.entries(entries).map(([key, raw]) => {
+            if (typeof raw !== "string")
+                throw new Error("Muse MCP environment/headers must be string maps.");
+            const name = raw.match(/^\{env:([A-Z_][A-Z0-9_]*)\}$/)?.[1];
+            const value = name ? env[name] ?? process.env[name] : raw;
+            if (value === undefined)
+                throw new Error(`Muse MCP configuration references missing environment variable ${name}.`);
+            return [key, value];
+        }));
+    };
+    for (const [name, value] of Object.entries(source)) {
+        const server = record(value);
+        if (!server)
+            throw new Error("Muse MCP server configuration is invalid.");
+        const url = server.httpUrl ?? server.url;
+        if (typeof url === "string" && /^https?:\/\//.test(url) && (!server.type || ["http", "streamable-http"].includes(String(server.type)))) {
+            result[name] = { transport: "streamableHttp", url, headers: strings(server.headers), mode: "required" };
+        }
+        else if (typeof server.command === "string" && (!server.type || server.type === "stdio") && (!server.args || Array.isArray(server.args) && server.args.every((arg) => typeof arg === "string"))) {
+            result[name] = { transport: "stdio", command: server.command, args: server.args, env: strings(server.env), mode: "required" };
+        }
+        else
+            throw new Error("Muse MCP server transport is unsupported; no servers were silently dropped.");
+    }
+    return result;
+}
+function spawnMuse(options) {
+    const env = { ...process.env, ...options.env };
+    delete env.MUSE_PERMISSION_PROFILE_FAIL_OPEN;
+    const args = ["serve", ...options.extraArgs];
+    if (!options.dockerExec)
+        return (0, node_child_process_1.spawn)(options.bin, args, { cwd: options.cwd, env, detached: process.platform !== "win32", stdio: "pipe" });
+    return (0, node_child_process_1.spawn)("docker", [
+        "exec", "-i", ...Object.keys(options.env).filter((name) => name !== "MUSE_PERMISSION_PROFILE_FAIL_OPEN").flatMap((name) => ["--env", name]),
+        options.dockerExec.containerName, "sh", "-c",
+        '[ ! -f /tmp/session.env ] || . /tmp/session.env; unset MUSE_PERMISSION_PROFILE_FAIL_OPEN; cd "$1" || exit 1; shift; exec "$@"',
+        "sh", options.cwd, options.bin, ...args,
+    ], { env, detached: process.platform !== "win32", stdio: "pipe" });
+}
+// Read-only Navi conversations are deliberately absent: an approval mode is
+// not a filesystem read boundary, and the SDK cannot yet prove that contract.
+exports.museAdapter = { agentType: "muse", run: runMuseAdapter };

package/dist/agent-auth.cjs

@@ -43,7 +43,8 @@ function matchingLine(text) {
 function detectAgentAuthFailure(result) {
     if (result.killedByLeaseLoss || result.timedOut || result.capacityError)
         return null;
-    if (result.authError)
+    // Muse exposes authRequired as a typed terminal error, never assistant prose.
+    if (result.authError && result.exitCode !== 0)
         return { detail: result.authError };
     const claude = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stdout) ?? (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stderr);
     if (claude) {

package/dist/config.cjs

@@ -10,6 +10,7 @@ exports.opencodeBlockedOnHost = opencodeBlockedOnHost;
 exports.loadRuntimeConfig = loadRuntimeConfig;
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
+const muse_cjs_1 = require("./adapters/muse.cjs");
 const sandbox_profile_cjs_1 = require("./sandbox-profile.cjs");
 /** Published image containing git, GitHub CLI, and the pinned Claude Code CLI. */
 exports.DEFAULT_SANDBOX_IMAGE = "ghcr.io/sagentlab/navarch-sandbox-agent:0.1.0";
@@ -25,6 +26,7 @@ exports.RUNTIME_AGENT_TYPES = [
     "opencode",
     "acp",
     "qoder",
+    "muse",
     "pi-local",
 ];
 function isRuntimeAgentType(value) {
@@ -116,10 +118,13 @@ function loadRuntimeConfig(env = process.env) {
         ? sandboxMode === "host" && !worktreeGuard
         : runtime === "antigravity"
             ? process.platform !== "win32" && !opencodeBlockedOnHost(sandboxMode, worktreeGuard)
-            : runtime !== "opencode" || !opencodeBlockedOnHost(sandboxMode, worktreeGuard));
+            : (runtime !== "opencode" && runtime !== "muse") || !opencodeBlockedOnHost(sandboxMode, worktreeGuard));
     if (requestedRuntimes.includes("pi-local") && runnableRuntimes.length === 0) {
         throw new Error("Pi (local) requires NAVARCH_SANDBOX_MODE=host and NAVARCH_WORKTREE_GUARD=off");
     }
+    if (requestedRuntimes.includes("muse") && runnableRuntimes.length === 0) {
+        throw new Error(muse_cjs_1.MUSE_HOST_GUARD_MESSAGE);
+    }
     if (requestedRuntimes.includes("antigravity") && runnableRuntimes.length === 0) {
         if (process.platform === "win32")
             throw new Error("Antigravity's private lease MCP relay requires a Linux or macOS worker; Windows is unsupported.");
@@ -168,6 +173,8 @@ function loadRuntimeConfig(env = process.env) {
         piExtraArgs: envList(env, "NAVARCH_PI_EXTRA_ARGS", []),
         qoderBin: env.NAVARCH_QODER_BIN ?? "qoder",
         qoderExtraArgs: envList(env, "NAVARCH_QODER_EXTRA_ARGS", []),
+        museBin: env.NAVARCH_MUSE_BIN ?? "muse",
+        museExtraArgs: envList(env, "NAVARCH_MUSE_EXTRA_ARGS", []),
         gitAuthorName: env.NAVARCH_GIT_AUTHOR_NAME ?? "sagentlab",
         gitAuthorEmail: env.NAVARCH_GIT_AUTHOR_EMAIL ?? "z@sagentlab.com",
         mcpConfigPath: env.NAVARCH_MCP_CONFIG_PATH ?? null,

package/dist/conversation/capability.cjs

@@ -40,7 +40,7 @@ function conversationCapability(config) {
 }
 /** Per-adapter support table for docs and diagnostics (host sandbox, guard on, feature enabled). */
 function conversationSupportMatrix() {
-    const agents = ["claude-code", "codex", "gemini", "antigravity", "opencode", "acp", "qoder", "pi-local", "pi"];
+    const agents = ["claude-code", "codex", "gemini", "antigravity", "opencode", "acp", "qoder", "muse", "pi-local", "pi"];
     return agents.map((agentType) => ({
         agentType,
         capability: conversationCapability({

package/dist/exit-conditions.cjs

@@ -22,7 +22,7 @@ exports.mapExitCondition = mapExitCondition;
 exports.AGENT_AUTH_FAILURE_PREFIX = "Coding agent authentication failed";
 function agentAuthFailureReport(detail) {
     return `${exports.AGENT_AUTH_FAILURE_PREFIX}: ${detail} ` +
-        "Log the coding agent in again on this machine (`claude /login`, `codex login`, or an interactive `agy` session), then resume the agent.";
+        "Log the coding agent in again on this machine (`claude /login`, `codex login`, an interactive `agy` session, or open `muse` and run `/login`), then resume the agent.";
 }
 /**
  * Best-effort parse of `claude -p --output-format json` (or `stream-json`,