agent-dealer 1.0.4 → 1.1.0

package/bundle/server/dist/adapters/agent-deck-bind.js

@@ -19,6 +19,7 @@ import { getAgentDeckMcpUrl } from "./agent-deck.js";
 import { getWorkerMcpConfigDir } from "../paths.js";
 import { resolveAmbientCodexHome } from "../cli-env.js";
 import { codexMcpServersTable } from "./codex-scoped-config.js";
+import { ensureWorktreeExcluded } from "./worktree-exclude.js";
 const CODEX_HOME_ENV_VAR = "CODEX_HOME";
 /**
  * NOT-136: a preflight call got no answer at all. Raised **only** where a call is awaited
@@ -187,32 +188,8 @@ function isCursorMcpTracked(worktreePath) {
     const result = gitCaptured(worktreePath, ["ls-files", "--error-unmatch", ".cursor/mcp.json"]);
     return result.ok;
 }
-/** Append `/.cursor/mcp.json` idempotently to git's info/exclude.
- *
- * Note: for a linked worktree, `git rev-parse --git-path info/exclude` resolves to the
- * *main* repository's `.git/info/exclude` (shared across all worktrees of that repo), not
- * a per-worktree file. The `/.cursor/mcp.json` pattern is still correct per worktree root;
- * we rewrite with a single occurrence so concurrent preparations can't leave duplicate lines. */
 function ensureCursorMcpExcluded(worktreePath) {
-    const excludePathResult = gitCaptured(worktreePath, ["rev-parse", "--git-path", "info/exclude"]);
-    if (!excludePathResult.ok) {
-        throw new Error(`could not resolve git info/exclude: ${excludePathResult.stderr || "unknown error"}`);
-    }
-    const excludePath = path.resolve(worktreePath, excludePathResult.stdout.trim());
-    fs.mkdirSync(path.dirname(excludePath), { recursive: true });
-    const line = "/.cursor/mcp.json";
-    let existing = "";
-    try {
-        existing = fs.readFileSync(excludePath, "utf8");
-    }
-    catch {
-        existing = "";
-    }
-    const kept = existing
-        .split(/\r?\n/)
-        .filter((l) => l.trim() !== "" && l.trim() !== line);
-    kept.push(line);
-    fs.writeFileSync(excludePath, `${kept.join("\n")}\n`, { mode: 0o644 });
+    ensureWorktreeExcluded(worktreePath, "/.cursor/mcp.json");
 }
 /**
  * Writes this attempt's deck-launch MCP config as the spawned worker's route to Agent Deck
@@ -226,6 +203,11 @@ async function materializeWorkerMcpConfig(opts) {
     const mcpBase = getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "");
     const mcpUrl = `${mcpBase}/mcp`;
     const headers = deckLaunchHeaders(opts.deckId, opts.worktreePath);
+    // Muse Code has no Agent Deck / MCP wiring (NOT-178 non-goal; NOT-181 owns it). Refuse before
+    // anything is written rather than fall through to the Claude config below.
+    if (opts.runtime === "muse_code") {
+        throw new Error("Muse Code does not support Agent Deck MCP configuration");
+    }
     if (opts.runtime === "codex_local") {
         const codexHome = path.join(getWorkerMcpConfigDir(), `codex-home-${opts.deckId.slice(0, 8)}-${randomUUID()}`);
         fs.mkdirSync(codexHome, { recursive: true, mode: 0o700 });
@@ -270,7 +252,7 @@ async function materializeWorkerMcpConfig(opts) {
         fs.writeFileSync(filePath, JSON.stringify({ mcpServers: { "agent-deck": { url: mcpUrl, headers } } }, null, 2) + "\n", { mode: 0o600 });
         return { mcpConfigPath: filePath };
     }
-    // claude_code
+    // claude_code — the only runtime left.
     const dir = getWorkerMcpConfigDir();
     const filePath = path.join(dir, `claude-mcp-${opts.deckId.slice(0, 8)}-${randomUUID()}.json`);
     try {

package/bundle/server/dist/adapters/agent-deck-bind.test.js

@@ -59,6 +59,24 @@ test("prepareWorkerDeckConnection verifies and writes a claude MCP config with d
         assert.equal(fs.existsSync(result.mcpConfigPath), false);
     }
 });
+test("prepareWorkerDeckConnection refuses Muse Code before writing any MCP config or verifying (NOT-178)", async () => {
+    let verifyCalled = false;
+    const result = await prepareWorkerDeckConnection({
+        policy: DENIED,
+        ...BASE_OPTS,
+        runtime: "muse_code",
+        verifyCallTool: async () => {
+            verifyCalled = true;
+            return textResult({ id: DECK });
+        },
+    });
+    assert.equal(result.ok, false);
+    if (!result.ok) {
+        assert.equal(result.kind, "infra_failure");
+        assert.match(result.reason, /Muse Code does not support Agent Deck MCP/);
+    }
+    assert.equal(verifyCalled, false);
+});
 test("prepareWorkerDeckConnection rejects when get_bound_deck reports a different deck", async () => {
     const result = await prepareWorkerDeckConnection({
         policy: DENIED,

package/bundle/server/dist/adapters/agent-health.js

@@ -1,12 +1,14 @@
 import { spawn, spawnSync } from "node:child_process";
-import { CODEX_AUTH_REMEDIATION, cursorAuthIssueFromOutput, runtimeAuthIssueFromOutput, } from "@agent-dealer/shared";
-import { claudeBinExists, cursorBinExists, resolveClaudeBin, cursorInvokeArgs, resolveCursorBin, resolveCodexBin, codexBinExists, } from "../cli-env.js";
+import fs from "node:fs";
+import { CODEX_AUTH_REMEDIATION, MUSE_AUTH_REMEDIATION, cursorAuthIssueFromOutput, runtimeAuthIssueFromOutput, } from "@agent-dealer/shared";
+import { claudeBinExists, cursorBinExists, resolveClaudeBin, cursorInvokeArgs, resolveCursorBin, resolveCodexBin, codexBinExists, resolveMuseBin, museBinExists, resolveMuseAuthFile, MUSE_CLI_ENV, } from "../cli-env.js";
 import { checkAgentDeckHealth, checkAgentDeckMcpRegistration, fetchDecks, } from "./agent-deck.js";
 import { runtimeAvailability } from "../repository/runtime-availability.js";
 const RUNTIME_LABEL = {
     claude_code: "Claude",
     cursor_local: "Cursor",
     codex_local: "Codex",
+    muse_code: "Muse Code",
 };
 function capHealthIssues(runtime) {
     const avail = runtimeAvailability(runtime);
@@ -60,11 +62,11 @@ function softRetryBackoffsMs() {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function defaultRunCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+function defaultRunCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, env = process.env) {
     return new Promise((resolve) => {
         const child = spawn(cmd, args, {
             stdio: ["ignore", "pipe", "pipe"],
-            env: process.env,
+            env,
         });
         let output = "";
         let settled = false;
@@ -101,8 +103,8 @@ let runCommandImpl = defaultRunCommand;
 export function setRunCommandForTests(fn) {
     runCommandImpl = fn ?? defaultRunCommand;
 }
-function runCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
-    return runCommandImpl(cmd, args, timeoutMs);
+function runCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, env) {
+    return runCommandImpl(cmd, args, timeoutMs, env);
 }
 /** Exported for tests — clears the shared github + runtime health caches and soft-fail streak. */
 export function clearAgentHealthCaches() {
@@ -182,6 +184,48 @@ async function cursorRuntimeIssues() {
     }
     return [softIssue];
 }
+/**
+ * Muse Code health (NOT-178). Three outcomes, nothing guessed:
+ *  - `cli_missing`: the spawn itself failed with ENOENT (or the resolved path does not exist);
+ *  - `runtime_auth`: no credential to run with — `META_API_KEY` unset and no saved login file
+ *    (the state whose `muse exec` stderr is captured in muse-exec-missing-credentials.txt);
+ *  - `runtime_unknown`: the version probe failed or timed out for any other reason.
+ *
+ * Muse has no offline `auth status` (NOT-177), and its only credential-validating call is a
+ * billed `muse exec`, so a *present* but expired login is not detectable here — it surfaces at
+ * the first run, which the same classifier reads from stderr. `auth.json` is tested for
+ * existence only, never read.
+ */
+async function museRuntimeIssues() {
+    const bin = resolveMuseBin();
+    const ver = await runCommand(bin, ["--version"], probeTimeoutMs(), {
+        ...process.env,
+        ...MUSE_CLI_ENV,
+    });
+    if (!ver.ok && (/\bENOENT\b/.test(ver.output) || (!ver.output.trim() && !museBinExists()))) {
+        return [
+            {
+                code: "cli_missing",
+                message: "Muse Code CLI not found — install Muse Code (`muse`) or set MUSE_CLI",
+            },
+        ];
+    }
+    if (!ver.ok) {
+        const detail = ver.timedOut
+            ? "timed out"
+            : (ver.output.trim().split("\n").slice(-1)[0] ?? "no output");
+        return [
+            {
+                code: "runtime_unknown",
+                message: `Could not determine Muse Code health — \`muse --version\` failed (${detail})`,
+            },
+        ];
+    }
+    if (!process.env.META_API_KEY && !fs.existsSync(resolveMuseAuthFile())) {
+        return [{ code: "runtime_auth", message: MUSE_AUTH_REMEDIATION }];
+    }
+    return [];
+}
 /** Exported for direct testing — bypasses the 60s cache in runtimeIssues(). */
 export async function runtimeIssuesUncached(runtime) {
     const issues = [];
@@ -234,6 +278,8 @@ export async function runtimeIssuesUncached(runtime) {
         }
         return issues;
     }
+    if (runtime === "muse_code")
+        return museRuntimeIssues();
     // NOT-157: Cursor auth probe distinguishes hard (classified logged-out / keychain) from
     // soft (timeout / unclassified probe flake). Soft path retries with backoff and holds a
     // recent healthy result across a single post-sleep streak.
@@ -355,6 +401,10 @@ function resolveMcpRegistration(mcpRegistered) {
 }
 function agentSpecificIssues(agent, agentDeckOnline, mcpRegistration, deckAccessResult) {
     const issues = [];
+    // NOT-181: a Muse Code worker gets no MCP servers and no Agent Deck, so a missing, offline or
+    // deleted deck cannot stop it. (The profile form still asks for one; Muse ignores it.)
+    if (agent.runtime === "muse_code")
+        return issues;
     if (!agent.deckId) {
         issues.push({
             code: "deck_missing",

package/bundle/server/dist/adapters/agent-health.test.js

@@ -34,6 +34,20 @@ describe("agent-health", { concurrency: false }, () => {
         assert.equal(result.issues.some((i) => i.code === "deck_missing"), true);
         assert.equal(result.healthy, false);
     });
+    // NOT-181: a Muse Code worker gets no MCP servers and no Agent Deck, so no deck problem may park it.
+    test("muse_code ignores deck state: no deck, offline deck or unreadable deck raises a deck issue", async () => {
+        const created = createAgent({ name: "muse-no-deck", runtime: "muse_code", deckId: randomUUID() });
+        getDb().prepare("UPDATE agents SET deck_id = NULL WHERE id = ?").run(created.id);
+        for (const [agent, online] of [
+            [getAgent(created.id), true],
+            [createAgent({ name: "muse-offline", runtime: "muse_code", deckId: randomUUID() }), false],
+            [createAgent({ name: "muse-stale", runtime: "muse_code", deckId: randomUUID() }), true],
+        ]) {
+            const result = await healthForAgent(agent, online, new Map(), true, FAILURE, NO_GITHUB);
+            assert.deepEqual(result.issues, [], agent.name);
+            assert.equal(result.healthy, true);
+        }
+    });
     test("agent deck offline: reports deck_offline, not deck_unauthorized", async () => {
         const agent = createAgent({
             name: "offline",
@@ -343,6 +357,91 @@ The keychain item is stuck. Delete it and sign in again:
             clearAgentHealthCaches();
         }
     });
+    // ---------------------------------------------------------------------------
+    // NOT-178: Muse Code health. Missing CLI, missing credentials and healthy classify distinctly;
+    // a probe that fails for any other reason is `runtime_unknown`, never a guessed auth failure.
+    // The missing-credentials remediation quotes the captured `muse exec` stderr
+    // (shared/src/fixtures/runtime-auth/muse-exec-missing-credentials.txt).
+    // ---------------------------------------------------------------------------
+    /** Stub `muse` that runs `body` and records the env it saw, so the pin can be asserted. */
+    function stubMuse(body) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-stub-"));
+        const bin = path.join(dir, "muse");
+        const envLog = path.join(dir, "env.log");
+        fs.writeFileSync(bin, `#!/bin/sh\necho "$MUSE_NO_AUTO_UPDATE" > ${JSON.stringify(envLog)}\n${body}\n`);
+        fs.chmodSync(bin, 0o755);
+        return { bin, envLog };
+    }
+    async function withMuseEnv(env, fn) {
+        const keys = ["MUSE_CLI", "META_API_KEY", "XDG_CONFIG_HOME"];
+        const prev = Object.fromEntries(keys.map((k) => [k, process.env[k]]));
+        process.env.MUSE_CLI = env.MUSE_CLI;
+        process.env.XDG_CONFIG_HOME = env.configHome;
+        if (env.META_API_KEY === undefined)
+            delete process.env.META_API_KEY;
+        else
+            process.env.META_API_KEY = env.META_API_KEY;
+        clearAgentHealthCaches();
+        try {
+            return await fn();
+        }
+        finally {
+            for (const k of keys) {
+                if (prev[k] === undefined)
+                    delete process.env[k];
+                else
+                    process.env[k] = prev[k];
+            }
+            clearAgentHealthCaches();
+        }
+    }
+    const emptyConfigHome = () => fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-cfg-"));
+    test("muse_code with a missing CLI reports cli_missing", async () => {
+        const missing = path.join(os.tmpdir(), `dealer-absent-muse-${randomUUID()}`);
+        const issues = await withMuseEnv({ MUSE_CLI: missing, META_API_KEY: "k", configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code"));
+        assert.deepEqual(issues.map((i) => i.code), ["cli_missing"]);
+        assert.match(issues[0].message, /Muse Code CLI not found/);
+    });
+    test("muse_code with no META_API_KEY and no saved login reports runtime_auth", async () => {
+        const stub = stubMuse(`cat ${JSON.stringify(path.join(FIXTURES, "muse-version.txt"))}`);
+        const issues = await withMuseEnv({ MUSE_CLI: stub.bin, configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code"));
+        assert.deepEqual(issues.map((i) => i.code), ["runtime_auth"]);
+        assert.match(issues[0].message, /muse login/);
+        assert.match(issues[0].message, /META_API_KEY/);
+    });
+    test("muse_code is healthy with a saved login file or a META_API_KEY", async () => {
+        const stub = stubMuse(`cat ${JSON.stringify(path.join(FIXTURES, "muse-version.txt"))}`);
+        const withLogin = emptyConfigHome();
+        fs.mkdirSync(path.join(withLogin, "muse"));
+        fs.writeFileSync(path.join(withLogin, "muse", "auth.json"), "{}");
+        assert.deepEqual(await withMuseEnv({ MUSE_CLI: stub.bin, configHome: withLogin }, () => runtimeIssuesUncached("muse_code")), []);
+        assert.deepEqual(await withMuseEnv({ MUSE_CLI: stub.bin, META_API_KEY: "k", configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code")), []);
+    });
+    test("muse probes run with MUSE_NO_AUTO_UPDATE=1 so the launcher cannot swap the pinned version", async () => {
+        const stub = stubMuse("echo 'Muse Code 1.3.0 (1.3.0-R3401.1)'");
+        delete process.env.MUSE_NO_AUTO_UPDATE;
+        await withMuseEnv({ MUSE_CLI: stub.bin, META_API_KEY: "k", configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code"));
+        assert.equal(fs.readFileSync(stub.envLog, "utf8").trim(), "1");
+    });
+    test("a muse probe that fails for any other reason is runtime_unknown, not a guessed auth failure", async () => {
+        const stub = stubMuse("echo 'panic: something else broke'; exit 3");
+        const issues = await withMuseEnv({ MUSE_CLI: stub.bin, configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code"));
+        assert.deepEqual(issues.map((i) => i.code), ["runtime_unknown"]);
+        assert.match(issues[0].message, /panic: something else broke/);
+        assert.doesNotMatch(issues[0].message, /muse login/);
+    });
+    test("a muse probe that hangs past the timeout is runtime_unknown", async () => {
+        const stub = stubMuse("sleep 30");
+        setCursorProbeTimingForTests({ timeoutMs: 150 });
+        try {
+            const issues = await withMuseEnv({ MUSE_CLI: stub.bin, META_API_KEY: "k", configHome: emptyConfigHome() }, () => runtimeIssuesUncached("muse_code"));
+            assert.deepEqual(issues.map((i) => i.code), ["runtime_unknown"]);
+            assert.match(issues[0].message, /timed out/);
+        }
+        finally {
+            setCursorProbeTimingForTests(null);
+        }
+    });
     test("claude MCP endpoint mismatch surfaces a distinct message, not the generic setup hint", async () => {
         const agent = createAgent({
             name: "claude-mcp-mismatch",

package/bundle/server/dist/adapters/linear-graphql.js

@@ -39,6 +39,13 @@ export class LinearHttpError extends Error {
         this.retryAfterMs = init.retryAfterMs;
     }
 }
+/** Thrown before any request is made; lets callers tell a missing key from an API failure. */
+export class LinearApiKeyMissingError extends Error {
+    constructor() {
+        super("LINEAR_API_KEY not set");
+        this.name = "LinearApiKeyMissingError";
+    }
+}
 export function parseLinearRateLimitHeaders(headers) {
     const out = {};
     const set = (key, name) => {
@@ -290,7 +297,7 @@ function logLinearTrace(operation, status, rateLimit) {
 export async function linearGraphqlRequest(opts) {
     const key = process.env.LINEAR_API_KEY;
     if (!key)
-        throw new Error("LINEAR_API_KEY not set");
+        throw new LinearApiKeyMissingError();
     let res;
     try {
         res = await fetch(LINEAR_API, {

package/bundle/server/dist/adapters/worktree-exclude.js

@@ -0,0 +1,40 @@
+// Keeps a coordinator-written path inside a worktree out of the worker's `git add` and out of the
+// clean-worktree check, without touching any tracked file. Shared by the Cursor MCP config
+// (agent-deck-bind.ts) and the per-attempt Muse config (coordinator/muse-spawn.ts).
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Append `line` (a root-anchored gitignore pattern such as `/.cursor/mcp.json`) idempotently to
+ * git's info/exclude.
+ *
+ * For a linked worktree, `git rev-parse --git-path info/exclude` resolves to the *main*
+ * repository's `.git/info/exclude` (shared across all worktrees of that repo), not a per-worktree
+ * file. A root-anchored pattern is still correct per worktree root; the file is rewritten with a
+ * single occurrence so concurrent preparations can't leave duplicate lines.
+ */
+export function ensureWorktreeExcluded(worktreePath, line) {
+    let excludePathOut;
+    try {
+        excludePathOut = execFileSync("git", ["-C", worktreePath, "rev-parse", "--git-path", "info/exclude"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const e = err;
+        throw new Error(`could not resolve git info/exclude: ${e.stderr || String(err) || "unknown error"}`);
+    }
+    const excludePath = path.resolve(worktreePath, excludePathOut.trim());
+    fs.mkdirSync(path.dirname(excludePath), { recursive: true });
+    let existing = "";
+    try {
+        existing = fs.readFileSync(excludePath, "utf8");
+    }
+    catch {
+        existing = "";
+    }
+    const kept = existing.split(/\r?\n/).filter((l) => l.trim() !== "" && l.trim() !== line);
+    kept.push(line);
+    fs.writeFileSync(excludePath, `${kept.join("\n")}\n`, { mode: 0o644 });
+}

package/bundle/server/dist/cli-env.js

@@ -101,3 +101,32 @@ export function codexBinExists() {
 export function resolveAmbientCodexHome() {
     return process.env.CODEX_HOME ?? path.join(process.env.HOME ?? os.homedir(), ".codex");
 }
+/**
+ * Resolve the Muse Code CLI (`muse`). `~/.local/bin/muse` is a launcher that re-execs the
+ * versioned `muse-bin-<version>`; callers must set `MUSE_NO_AUTO_UPDATE=1` (`MUSE_CLI_ENV`) or
+ * the launcher can swap the pinned version mid-fleet (NOT-177).
+ */
+export function resolveMuseBin() {
+    const home = process.env.HOME ?? os.homedir();
+    if (process.env.MUSE_CLI)
+        return process.env.MUSE_CLI;
+    return (firstExisting([
+        path.join(home, ".local/bin/muse"),
+        "/opt/homebrew/bin/muse",
+        "/usr/local/bin/muse",
+    ]) ?? "muse");
+}
+export function museBinExists() {
+    const bin = resolveMuseBin();
+    return bin !== "muse" ? fs.existsSync(bin) : false;
+}
+/** Env every Muse invocation carries so the launcher never self-updates (NOT-177 pin). */
+export const MUSE_CLI_ENV = { MUSE_NO_AUTO_UPDATE: "1" };
+/**
+ * Where Muse keeps its file-backed login (`$XDG_CONFIG_HOME/muse/auth.json`, else
+ * `~/.config/muse/auth.json`). Callers may test for existence only — never read it.
+ */
+export function resolveMuseAuthFile() {
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(process.env.HOME ?? os.homedir(), ".config");
+    return path.join(configHome, "muse", "auth.json");
+}

package/bundle/server/dist/coordinator/admission.js

@@ -17,7 +17,7 @@ import { runtimeAvailability } from "../repository/runtime-availability.js";
 import { getActiveWorkflowInstance } from "../repository/workflow-events.js";
 import { listWorkItemsForIssue } from "../repository/work-items.js";
 import { activeWorkflowConflictMessage, checkIssueReadiness, startWorkflowCore, StartPreconditionError, } from "./commands.js";
-import { blockerSnapshotFor, DEPENDENCY_STATE_UNAVAILABLE, isDependencyTracked, unsatisfiedBlockerReason, } from "./dependencies.js";
+import { blockerSnapshotFor, blockerUnavailableReason, DEPENDENCY_STATE_UNAVAILABLE, isDependencyTracked, unsatisfiedBlockerReason, } from "./dependencies.js";
 /** Statuses that occupy an admission slot (Decision 2). */
 export const occupyingStatuses = new Set(["developing", "reviewing", "repairing"]);
 /**
@@ -60,6 +60,13 @@ export function setAdmissionHealthCheckerForTests(checker) {
     healthChecker = checker;
 }
 async function defaultAgentHealth(agent, role, deckOnline) {
+    // NOT-178: Muse Code is a developer-only trial runtime — the reviewer stays Codex/Claude.
+    if (role === "reviewer" && agent.runtime === "muse_code") {
+        return {
+            ok: false,
+            reason: `reviewer unhealthy: ${agent.name} — Muse Code cannot be a reviewer (developer role only)`,
+        };
+    }
     // Unit/CI tests must not call real CLIs / Agent Deck — runners usually have no deck MCP.
     // Production leaves this unset. NOT-133 clears it so the real auth classifier still runs.
     if (process.env.AGENT_DEALER_SKIP_AGENT_HEALTH === "1") {
@@ -154,7 +161,7 @@ function blockedByDependency(issue, ctx) {
     const blockers = ctx.blockers.get(issue.externalId);
     // Absent means unknown, not unblocked (see BlockerSnapshot) — park until the next fetch.
     if (!blockers)
-        return { ok: false, reason: DEPENDENCY_STATE_UNAVAILABLE };
+        return { ok: false, reason: ctx.blockersUnavailableReason ?? DEPENDENCY_STATE_UNAVAILABLE };
     const reason = unsatisfiedBlockerReason(blockers);
     return reason ? { ok: false, reason } : { ok: true };
 }
@@ -215,7 +222,11 @@ export async function admitNext() {
         checkAgentDeckHealth(),
         blockerSnapshotFor(queuedIssues),
     ]);
-    const ctx = { deckOnline, blockers };
+    const ctx = {
+        deckOnline,
+        blockers,
+        blockersUnavailableReason: blockerUnavailableReason(),
+    };
     for (const entry of remaining) {
         const issue = getIssue(entry.issueId);
         if (!issue) {

package/bundle/server/dist/coordinator/admission.test.js

@@ -17,7 +17,7 @@ const { getActiveWorkflowInstance } = await import("../repository/workflow-event
 const { recordRuntimeAvailability, clearAllRuntimeAvailability } = await import("../repository/runtime-availability.js");
 const { enqueueIssue, enqueueIssueWithOutcome, dequeueIssue, listQueuedEntries, getQueuedEntryForIssue } = await import("../repository/queue-entries.js");
 const { startWorkflow } = await import("./commands.js");
-const { sequentialCapacityPolicy, occupyingStatuses, countOccupyingIssues, admitNext, setAdmissionHealthCheckerForTests, setCapacityPolicyForTests, resetCapacityPolicyForTests, resetEligibilityRulesForTests } = await import("./admission.js");
+const { sequentialCapacityPolicy, occupyingStatuses, countOccupyingIssues, admitNext, checkRoleAgentHealthy, setAdmissionHealthCheckerForTests, setCapacityPolicyForTests, resetCapacityPolicyForTests, resetEligibilityRulesForTests } = await import("./admission.js");
 before(() => migrate());
 beforeEach(() => {
     getDb().exec(`
@@ -343,6 +343,70 @@ test("NOT-133: a logged-out Cursor runtime is not admitted; it waits with an aut
         setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
     }
 });
+// NOT-178: an unhealthy Muse Code developer profile waits with a Muse-specific reason and
+// spends nothing — status stays ready, no workflow instance, no attempt. Runs the *real*
+// health checker against a stub CLI and an empty config home (no META_API_KEY, no auth.json).
+test("NOT-178: a Muse Code developer without credentials is refused at admission", async () => {
+    const { clearAgentHealthCaches } = await import("../adapters/agent-health.js");
+    const stubDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-stub-"));
+    const stub = path.join(stubDir, "muse");
+    fs.writeFileSync(stub, "#!/bin/sh\necho 'Muse Code 1.3.0 (1.3.0-R3401.1)'\n");
+    fs.chmodSync(stub, 0o755);
+    const saved = {
+        MUSE_CLI: process.env.MUSE_CLI,
+        XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        META_API_KEY: process.env.META_API_KEY,
+        SKIP: process.env.AGENT_DEALER_SKIP_AGENT_HEALTH,
+    };
+    process.env.MUSE_CLI = stub;
+    process.env.XDG_CONFIG_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-cfg-"));
+    delete process.env.META_API_KEY;
+    delete process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
+    setAdmissionHealthCheckerForTests(null);
+    clearAgentHealthCaches();
+    try {
+        const issue = readyIssue("muse-logged-out", {
+            runtimes: { dev: "muse_code", rev: "codex_local" },
+        });
+        enqueueIssue(issue.id);
+        assert.equal(await admitNext(), null);
+        assert.equal(getIssue(issue.id).status, "ready");
+        assert.equal(getActiveWorkflowInstance(issue.id), null);
+        const entry = getQueuedEntryForIssue(issue.id);
+        assert.equal(entry?.state, "queued");
+        assert.match(entry.waitReason, /developer unhealthy/);
+        assert.match(entry.waitReason, /muse login/);
+    }
+    finally {
+        for (const [key, value] of Object.entries({
+            MUSE_CLI: saved.MUSE_CLI,
+            XDG_CONFIG_HOME: saved.XDG_CONFIG_HOME,
+            META_API_KEY: saved.META_API_KEY,
+            AGENT_DEALER_SKIP_AGENT_HEALTH: saved.SKIP,
+        })) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+        clearAgentHealthCaches();
+        setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
+    }
+});
+// NOT-178: Muse Code is developer-only, so it is never a healthy reviewer — even with the
+// unit-test health skip on, and without probing the CLI.
+test("NOT-178: a Muse Code reviewer is refused regardless of CLI health", async () => {
+    const issue = readyIssue("muse-reviewer", { runtimes: { dev: "claude_code", rev: "muse_code" } });
+    setAdmissionHealthCheckerForTests(null);
+    try {
+        const result = await checkRoleAgentHealthy(getIssue(issue.id), "reviewer", { deckOnline: true });
+        assert.equal(result.ok, false);
+        assert.match(result.ok ? "" : result.reason, /reviewer unhealthy.*developer role only/);
+    }
+    finally {
+        setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
+    }
+});
 // NOT-156: reviewer health must not block developer admit; developer health still fails closed.
 test("NOT-156: developer healthy + reviewer unhealthy still admits and leases developer work", async () => {
     const { listWorkItemsForIssue } = await import("../repository/work-items.js");

package/bundle/server/dist/coordinator/args.js

@@ -32,6 +32,12 @@ function claudeDisallowedTools(policy) {
     return policy.outboundMutation ? [] : [DENY_SEND_TOOL];
 }
 function buildArgs(runtime, policy, prompt, model, mcpConfigPath, effort) {
+    if (runtime === "muse_code") {
+        // Muse's developer argv is built by runners/muse-code-args.ts inside coordinator/muse-spawn.ts
+        // (NOT-181); it needs a per-attempt session id and XDG dirs this pure builder has no place
+        // for. Falling through to the Claude arm below would spawn `muse` with Claude flags.
+        throw new Error("muse_code is not wired through the shared arg builder — its developer argv is built in coordinator/muse-spawn.ts");
+    }
     if (runtime === "codex_local") {
         const args = ["exec", "--json", "-s", policy.worktreeWrite ? "workspace-write" : "read-only"];
         // codex's read-only sandbox constrains shell/files but NOT configured MCP/plugin

package/bundle/server/dist/coordinator/args.test.js

@@ -130,3 +130,17 @@ test("buildDeveloperArgs for cursor_local has no separate effort flag (effort li
     assert.ok(!args.some((a) => a.includes("model_reasoning_effort")));
     assert.ok(!args.includes("-c"));
 });
+test("every runtime either builds developer args or is the not-yet-wired muse_code", async () => {
+    const { Runtime } = await import("@agent-dealer/shared");
+    for (const runtime of Runtime.options) {
+        if (runtime === "muse_code") {
+            // NOT-178 made Muse selectable but the runner is NOT-179/181. Falling through to the
+            // Claude flags would launch `muse` with arguments it does not understand.
+            assert.throws(() => buildDeveloperArgs(runtime, "prompt"), /not wired/);
+            assert.throws(() => buildReviewerArgs(runtime, "prompt"), /not wired/);
+        }
+        else {
+            assert.ok(buildDeveloperArgs(runtime, "prompt").includes("prompt"), runtime);
+        }
+    }
+});