agent-dealer 1.2.7 → 1.2.9

package/bundle/server/dist/adapters/muse-visual-qa.js

@@ -0,0 +1,114 @@
+// packages/server/src/adapters/muse-visual-qa.ts
+//
+// NOT-303: Muse Dev visual-QA screenshot-path preflight.
+//
+// `Google Chrome.app` headless cannot run inside a Muse developer session: every
+// launch aborts at macOS process registration
+// (`TransformProcessType -> _RegisterApplication`, SIGABRT/exit 134, no output, no
+// file) under the Muse sandbox, and `--no-sandbox` only disables Chrome's own
+// sandbox so it cannot help. Evidence:
+// `docs/evaluations/muse-code/chrome-headless-screenshot.md`.
+//
+// This module resolves, coordinator-side and before the session starts, which
+// screenshot path a Muse developer worker gets. It never launches a browser and
+// never touches the sandbox: the default verdict is unusable-with-reason (fail
+// loud, so the worker reads it in its prompt instead of discovering the abort
+// mid-session). Only an operator pre-installed non-AppKit headless shell,
+// pointed at by `MUSE_HEADLESS_SHELL_BIN`, flips the verdict — the binary cannot
+// be fetched in-session because the developer sandbox network is `restricted`.
+//
+// Deliberately NOT covered: widening the Muse sandbox, a coordinator-side
+// screenshot step, and how Cursor/Claude/Codex workers run Chrome.
+import fs from "node:fs";
+import path from "node:path";
+/** Operator override: absolute path to a pre-installed headless shell binary. */
+export const MUSE_HEADLESS_SHELL_BIN_ENV = "MUSE_HEADLESS_SHELL_BIN";
+/** Phase 1 evidence behind the default verdict. */
+export const MUSE_VISUAL_QA_DOC = "docs/evaluations/muse-code/chrome-headless-screenshot.md";
+/** The abort every `Google Chrome.app` headless launch dies with in-sandbox. */
+export const MUSE_CHROME_APP_ABORT = "TransformProcessType -> _RegisterApplication (SIGABRT, exit 134)";
+/**
+ * Resolve the screenshot path for a Muse developer worker. Pure apart from the
+ * injected `exists` probe; never spawns anything (probing `Google Chrome.app`
+ * would only mint another crash report).
+ */
+export function checkMuseVisualQa(opts = {}) {
+    const env = opts.env ?? process.env;
+    const exists = opts.exists ?? fs.existsSync;
+    const configured = env[MUSE_HEADLESS_SHELL_BIN_ENV]?.trim() || null;
+    if (configured) {
+        if (!path.isAbsolute(configured)) {
+            return {
+                usable: false,
+                binary: null,
+                args: [],
+                reason: `${MUSE_HEADLESS_SHELL_BIN_ENV} must be an absolute path (got a non-absolute value) — ` +
+                    `no headless shell configured, and Google Chrome.app headless aborts in-session ` +
+                    `(${MUSE_CHROME_APP_ABORT}); see ${MUSE_VISUAL_QA_DOC}`,
+            };
+        }
+        if (!exists(configured)) {
+            return {
+                usable: false,
+                binary: null,
+                args: [],
+                reason: `headless shell not found at ${MUSE_HEADLESS_SHELL_BIN_ENV} (${configured}) — ` +
+                    `no screenshot path is installed, and Google Chrome.app headless aborts in-session ` +
+                    `(${MUSE_CHROME_APP_ABORT}); see ${MUSE_VISUAL_QA_DOC}`,
+            };
+        }
+        return {
+            usable: true,
+            binary: configured,
+            args: ["--screenshot=<png>", "--window-size=1280,800"],
+            reason: `pre-installed headless shell at ${configured}`,
+        };
+    }
+    return {
+        usable: false,
+        binary: null,
+        args: [],
+        reason: `no headless shell installed (${MUSE_HEADLESS_SHELL_BIN_ENV} is unset — it must be ` +
+            `pre-installed on the host because the developer sandbox network is restricted), and ` +
+            `Google Chrome.app headless aborts in-session (${MUSE_CHROME_APP_ABORT}); ` +
+            `see ${MUSE_VISUAL_QA_DOC}`,
+    };
+}
+function chromeAppWarningLines() {
+    return [
+        `- Never launch \`Google Chrome.app\` headless here: every launch aborts at startup`,
+        `  (${MUSE_CHROME_APP_ABORT}, no output, no file) under the Muse sandbox.`,
+        `  \`--no-sandbox\` only disables Chrome's own sandbox and cannot help.`,
+    ];
+}
+/**
+ * Worker-prompt section for a Muse developer session. The unusable variant tells
+ * the worker not to burn steps probing and to close with an explicit
+ * `Visual QA: not run` conclusion line, so review evidence states it instead of
+ * reading a missing screenshot as a pass.
+ */
+export function museVisualQaPromptSection(status) {
+    if (status.usable && status.binary) {
+        return [
+            `## Visual QA (screenshots)`,
+            `A pre-installed headless shell is available: \`${status.binary}\`. For UI-visible`,
+            `changes, capture a screenshot with`,
+            `\`${status.binary} ${[...status.args, "<page-url>"].join(" ")}\``,
+            `saving the PNG into the worktree, and commit it with your change.`,
+            ...chromeAppWarningLines(),
+            `End your implementation conclusion with a \`Visual QA:\` line —`,
+            `\`Visual QA: verified (<png path>, exit <code>)\` or \`Visual QA: not run (<reason>)\`.`,
+            ``,
+        ];
+    }
+    return [
+        `## Visual QA (screenshots)`,
+        `Headless visual QA does not work inside this session — do not spend steps probing it:`,
+        ...chromeAppWarningLines(),
+        `- ${status.reason}`,
+        `Visual QA is out of scope for this session: never read the absence of a screenshot as`,
+        `a pass. End your implementation conclusion with a \`Visual QA:\` line —`,
+        `\`Visual QA: not run (<short reason>)\` — so the review evidence states it explicitly.`,
+        ``,
+    ];
+}

package/bundle/server/dist/adapters/muse-visual-qa.test.js

@@ -0,0 +1,68 @@
+// packages/server/src/adapters/muse-visual-qa.test.ts
+//
+// NOT-303: the Muse Dev screenshot-path preflight. The unusable verdict must fail
+// loudly — naming the RegisterApplication abort and the missing binary — instead
+// of letting the worker discover it mid-session.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { checkMuseVisualQa, MUSE_HEADLESS_SHELL_BIN_ENV, museVisualQaPromptSection, } from "./muse-visual-qa.js";
+test("unset override: unusable, naming the Chrome.app abort and the missing binary", () => {
+    const status = checkMuseVisualQa({ env: {}, exists: () => false });
+    assert.equal(status.usable, false);
+    assert.equal(status.binary, null);
+    assert.match(status.reason, /RegisterApplication/);
+    assert.match(status.reason, /MUSE_HEADLESS_SHELL_BIN/);
+});
+test("configured but absent binary: unusable, naming the path", () => {
+    const status = checkMuseVisualQa({
+        env: { [MUSE_HEADLESS_SHELL_BIN_ENV]: "/opt/headless/chrome-headless-shell" },
+        exists: () => false,
+    });
+    assert.equal(status.usable, false);
+    assert.equal(status.binary, null);
+    assert.match(status.reason, /\/opt\/headless\/chrome-headless-shell/);
+    assert.match(status.reason, /RegisterApplication/);
+});
+test("configured but non-absolute value: unusable, not treated as a binary", () => {
+    const status = checkMuseVisualQa({
+        env: { [MUSE_HEADLESS_SHELL_BIN_ENV]: "relative/bin" },
+        exists: () => true,
+    });
+    assert.equal(status.usable, false);
+    assert.equal(status.binary, null);
+    assert.match(status.reason, /absolute path/);
+});
+test("pre-installed binary present: usable with binary and screenshot flags", () => {
+    const status = checkMuseVisualQa({
+        env: { [MUSE_HEADLESS_SHELL_BIN_ENV]: "/opt/headless/chrome-headless-shell" },
+        exists: (p) => p === "/opt/headless/chrome-headless-shell",
+    });
+    assert.equal(status.usable, true);
+    assert.equal(status.binary, "/opt/headless/chrome-headless-shell");
+    assert.ok(status.args.some((a) => a.startsWith("--screenshot=")));
+});
+test("unusable prompt section: forbids Chrome.app probing, declares out of scope, requires the conclusion line", () => {
+    const lines = museVisualQaPromptSection(checkMuseVisualQa({ env: {}, exists: () => false }));
+    const text = lines.join("\n");
+    assert.match(text, /## Visual QA/);
+    assert.match(text, /Google Chrome\.app/);
+    assert.match(text, /RegisterApplication/);
+    assert.match(text, /do not spend steps probing/i);
+    assert.match(text, /out of scope/i);
+    assert.match(text, /Visual QA: not run/);
+    assert.doesNotMatch(text, /--disable-sandbox/);
+    assert.doesNotMatch(text, /--yolo/);
+});
+test("usable prompt section: names the binary and still forbids Google Chrome.app", () => {
+    const lines = museVisualQaPromptSection({
+        usable: true,
+        binary: "/opt/headless/chrome-headless-shell",
+        args: ["--screenshot=<png>", "--window-size=1280,800"],
+        reason: "pre-installed headless shell",
+    });
+    const text = lines.join("\n");
+    assert.match(text, /\/opt\/headless\/chrome-headless-shell/);
+    assert.match(text, /--screenshot=<png>/);
+    assert.match(text, /Google Chrome\.app/);
+    assert.match(text, /Visual QA:/);
+});

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

@@ -0,0 +1,96 @@
+// packages/server/src/adapters/worktree-deps.ts
+//
+// NOT-315: provision dependencies in a fresh developer worktree before the
+// session spawns. The Muse builder sandbox has no network (restricted mode:
+// DNS and loopback listen() both fail), so an in-session `npm install` can
+// never work — the coordinator runs it here instead, outside the sandbox,
+// with network.
+//
+// Only npm is in scope: a lockfile for another package manager (or no
+// lockfile at all) skips the step with a logged reason, never a failure.
+// A failed or timed-out install throws — the caller turns that into a
+// visible `adapter_failure` worktree-setup failure (retryable on the existing
+// infra-retry path), never a silent skip.
+//
+// The command runner is an injectable seam so tests prove the exact argv/cwd
+// without spending network or touching a registry.
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+/** Default bound for `npm ci` in a fresh worktree (NOT-315). */
+export const DEFAULT_WORKTREE_DEPS_TIMEOUT_MS = 5 * 60_000;
+/** Bounded timeout for the install step; env override for tests/operators. */
+export function worktreeDepsTimeoutMs() {
+    const raw = Number(process.env.WORKTREE_DEPS_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_WORKTREE_DEPS_TIMEOUT_MS;
+}
+/** Exact install invocation — asserted by tests, never drifted silently. */
+export const NPM_CI_ARGS = ["ci", "--prefer-offline", "--no-audit", "--no-fund"];
+/** Lockfiles that mean "another package manager owns this worktree" — npm is out of scope. */
+const NON_NPM_LOCKFILES = ["pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"];
+/** Last bytes of install output kept in the failure reason (a full log would drown routing). */
+const STDERR_TAIL_CHARS = 2000;
+const defaultRunner = async (cmd, args, opts) => run(cmd, [...args], { cwd: opts.cwd, timeout: opts.timeoutMs });
+/** Keep the failure reason actionable: the tail of what npm actually printed. */
+export function stderrTail(err) {
+    const e = err;
+    const raw = (typeof e?.stderr === "string" && e.stderr.trim() ? e.stderr : null) ??
+        (typeof e?.stdout === "string" && e.stdout.trim() ? e.stdout : null) ??
+        (typeof e?.message === "string" && e.message ? e.message : String(err));
+    const trimmed = raw.trim();
+    return trimmed.length > STDERR_TAIL_CHARS ? trimmed.slice(-STDERR_TAIL_CHARS) : trimmed;
+}
+/**
+ * Run `npm ci` in `worktreePath` when the checkout declares npm dependencies
+ * that are not installed yet. Returns whether the install ran (with its
+ * duration) or why it was skipped. Throws
+ * `dependency install failed: <stderr tail>` when the install itself fails or
+ * times out — the caller surfaces that as a worktree-setup `adapter_failure`.
+ */
+export async function ensureWorktreeDeps(worktreePath, opts = {}) {
+    const startedAt = Date.now();
+    const skipped = (reason) => ({
+        ran: false,
+        reason,
+        durationMs: Date.now() - startedAt,
+    });
+    if (fs.existsSync(path.join(worktreePath, "node_modules"))) {
+        return skipped("node_modules present");
+    }
+    if (!fs.existsSync(path.join(worktreePath, "package.json"))) {
+        return skipped("no package.json");
+    }
+    for (const lock of NON_NPM_LOCKFILES) {
+        if (fs.existsSync(path.join(worktreePath, lock))) {
+            return skipped(`non-npm lockfile ${lock} present; only npm is in scope`);
+        }
+    }
+    if (!fs.existsSync(path.join(worktreePath, "package-lock.json"))) {
+        return skipped("no lockfile");
+    }
+    const timeoutMs = opts.timeoutMs ?? worktreeDepsTimeoutMs();
+    const runner = opts.runner ?? defaultRunner;
+    try {
+        await runner("npm", NPM_CI_ARGS, { cwd: worktreePath, timeoutMs });
+    }
+    catch (err) {
+        // A failed `npm ci` (or a timeout kill mid-reify) can leave a
+        // partial/empty node_modules behind. The setup failure retries on the
+        // infra path, which reuses the leftover worktree — and a leftover
+        // node_modules would make the retry skip the install and hand the builder
+        // broken deps. Remove it so the retry reinstalls from scratch; the removal
+        // itself is best-effort and must never mask the install error.
+        try {
+            fs.rmSync(path.join(worktreePath, "node_modules"), { recursive: true, force: true });
+        }
+        catch {
+            // keep the original install error below
+        }
+        const killed = err?.killed === true;
+        const prefix = killed ? `timed out after ${timeoutMs}ms: ` : "";
+        throw new Error(`dependency install failed: ${prefix}${stderrTail(err)}`);
+    }
+    return { ran: true, durationMs: Date.now() - startedAt };
+}

package/bundle/server/dist/adapters/worktree-deps.test.js

@@ -0,0 +1,144 @@
+// packages/server/src/adapters/worktree-deps.test.ts
+//
+// NOT-315: the pre-spawn dependency step runs `npm ci` exactly once when the
+// worktree declares npm dependencies, skips otherwise, and surfaces install
+// failures with the stderr tail — all against a fake runner, never a registry.
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ensureWorktreeDeps, NPM_CI_ARGS } from "./worktree-deps.js";
+let dirs = [];
+function makeWorktree(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-wt-deps-"));
+    dirs.push(dir);
+    for (const [name, content] of Object.entries(files)) {
+        fs.writeFileSync(path.join(dir, name), content);
+    }
+    return dir;
+}
+after(() => {
+    for (const dir of dirs)
+        fs.rmSync(dir, { recursive: true, force: true });
+    dirs = [];
+});
+const PKG = JSON.stringify({ name: "wt", version: "1.0.0" });
+const LOCK = JSON.stringify({ name: "wt", lockfileVersion: 3, packages: {} });
+function recordingRunner(calls) {
+    return async (cmd, args, opts) => {
+        calls.push({ cmd, args: [...args], cwd: opts.cwd, timeoutMs: opts.timeoutMs });
+        return { stdout: "", stderr: "" };
+    };
+}
+test("lockfile present and node_modules absent -> install runs once with the expected args and cwd", async () => {
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    const calls = [];
+    const result = await ensureWorktreeDeps(dir, { runner: recordingRunner(calls), timeoutMs: 1234 });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].cmd, "npm");
+    assert.deepEqual(calls[0].args, [...NPM_CI_ARGS]);
+    assert.deepEqual(calls[0].args, ["ci", "--prefer-offline", "--no-audit", "--no-fund"]);
+    assert.equal(calls[0].cwd, dir);
+    assert.equal(calls[0].timeoutMs, 1234);
+    assert.equal(result.ran, true);
+    if (result.ran)
+        assert.ok(typeof result.durationMs === "number" && result.durationMs >= 0);
+});
+test("node_modules present -> skipped without running anything", async () => {
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    fs.mkdirSync(path.join(dir, "node_modules"));
+    const calls = [];
+    const result = await ensureWorktreeDeps(dir, { runner: recordingRunner(calls) });
+    assert.equal(calls.length, 0);
+    assert.equal(result.ran, false);
+    if (!result.ran)
+        assert.match(result.reason, /node_modules/);
+    assert.ok(typeof result.durationMs === "number" && result.durationMs >= 0);
+});
+test("no lockfile -> skipped without running anything", async () => {
+    const dir = makeWorktree({ "package.json": PKG });
+    const calls = [];
+    const result = await ensureWorktreeDeps(dir, { runner: recordingRunner(calls) });
+    assert.equal(calls.length, 0);
+    assert.equal(result.ran, false);
+    if (!result.ran)
+        assert.match(result.reason, /no lockfile/);
+});
+test("no package.json -> skipped without running anything", async () => {
+    const dir = makeWorktree({ "README.md": "hello\n" });
+    const calls = [];
+    const result = await ensureWorktreeDeps(dir, { runner: recordingRunner(calls) });
+    assert.equal(calls.length, 0);
+    assert.equal(result.ran, false);
+});
+test("another package manager's lockfile -> skipped without running anything", async () => {
+    for (const lock of ["pnpm-lock.yaml", "yarn.lock", "bun.lockb"]) {
+        const dir = makeWorktree({ "package.json": PKG, [lock]: "lock\n" });
+        const calls = [];
+        const result = await ensureWorktreeDeps(dir, { runner: recordingRunner(calls) });
+        assert.equal(calls.length, 0, `${lock} must not trigger npm`);
+        assert.equal(result.ran, false);
+        if (!result.ran)
+            assert.match(result.reason, /non-npm lockfile/);
+    }
+});
+test("a failing install throws with the stderr tail", async () => {
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    const failing = async () => {
+        const err = new Error("npm ci exited");
+        err.stderr = "npm error code E500\nnpm error registry exploded on line 42\n";
+        throw err;
+    };
+    await assert.rejects(() => ensureWorktreeDeps(dir, { runner: failing }), (err) => {
+        assert.match(err.message, /^dependency install failed: /);
+        assert.match(err.message, /registry exploded on line 42/);
+        return true;
+    });
+});
+test("a timed-out install throws with the same dependency-install prefix", async () => {
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    const timingOut = async () => {
+        throw new Error("npm ci timed out after 300000ms — network or registry may be down");
+    };
+    await assert.rejects(() => ensureWorktreeDeps(dir, { runner: timingOut }), (err) => {
+        assert.match(err.message, /^dependency install failed: /);
+        assert.match(err.message, /timed out/);
+        return true;
+    });
+});
+test("a failing install removes a leftover node_modules so an infra retry reinstalls", async () => {
+    // npm ci that dies mid-reify (or is SIGTERM-killed by the execFile timeout)
+    // can leave a partial node_modules behind; the retry reuses the leftover
+    // worktree, so the husk must be gone or the retry would skip the install.
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    const failing = async (_cmd, _args, opts) => {
+        fs.mkdirSync(path.join(opts.cwd, "node_modules", "half-written-pkg"), { recursive: true });
+        fs.writeFileSync(path.join(opts.cwd, "node_modules", "half-written-pkg", "index.js"), "partial\n");
+        const err = new Error("npm ci exited");
+        err.stderr = "npm error code E500\nnpm error registry exploded on line 42\n";
+        throw err;
+    };
+    await assert.rejects(() => ensureWorktreeDeps(dir, { runner: failing }), (err) => {
+        assert.match(err.message, /^dependency install failed: /);
+        assert.match(err.message, /registry exploded on line 42/);
+        return true;
+    });
+    assert.equal(fs.existsSync(path.join(dir, "node_modules")), false, "partial node_modules must be removed");
+});
+test("a killed (timed-out) install names the timeout in the reason", async () => {
+    const dir = makeWorktree({ "package.json": PKG, "package-lock.json": LOCK });
+    const killed = async () => {
+        // Shape of a real execFile timeout: killed by SIGTERM with little stderr.
+        const err = new Error("Command failed: npm ci --prefer-offline --no-audit --no-fund");
+        err.killed = true;
+        err.signal = "SIGTERM";
+        throw err;
+    };
+    await assert.rejects(() => ensureWorktreeDeps(dir, { runner: killed, timeoutMs: 4321 }), (err) => {
+        assert.match(err.message, /^dependency install failed: /);
+        assert.match(err.message, /timed out after 4321ms/);
+        return true;
+    });
+    assert.equal(fs.existsSync(path.join(dir, "node_modules")), false);
+});

package/bundle/server/dist/capacity/muse-probe.js

@@ -91,6 +91,44 @@ export function hasFreshMuseCapacityPair(nowMs = Date.now()) {
 function museProbeDiagnosticLogPath() {
     return path.join(getDataDir(), "capacity", "muse-probe.log");
 }
+const MUSE_PROBE_FAILURE_MESSAGE_MAX = 300;
+const MUSE_PROBE_FAILURE_KIND_MAX = 100;
+/** Keep the diagnostic log one JSON object per line and free of anything
+ * beyond kind + message: strip control characters, then truncate. */
+function sanitizeFailureText(value, max) {
+    return value.replace(/[\x00-\x1f\x7f]/g, "").slice(0, max);
+}
+function failureDetailFromTurn(failure) {
+    if (!failure)
+        return null;
+    return {
+        kind: sanitizeFailureText(failure.kind, MUSE_PROBE_FAILURE_KIND_MAX),
+        message: sanitizeFailureText(failure.message, MUSE_PROBE_FAILURE_MESSAGE_MAX),
+    };
+}
+function failureDetailFromError(err) {
+    let message;
+    if (err instanceof Error) {
+        message = err.message;
+    }
+    else if (typeof err === "string") {
+        message = err;
+    }
+    else {
+        try {
+            message = JSON.stringify(err) ?? "unknown error";
+        }
+        catch {
+            message = "unknown error";
+        }
+    }
+    if (!message)
+        message = "unknown error";
+    return {
+        kind: "exception",
+        message: sanitizeFailureText(message, MUSE_PROBE_FAILURE_MESSAGE_MAX),
+    };
+}
 function appendMuseProbeDiagnostic(nowMs, result) {
     try {
         const file = museProbeDiagnosticLogPath();
@@ -134,6 +172,7 @@ export async function runMuseCapacityProbe(nowMs = Date.now(), opts = {}) {
                 admitted: false,
                 terminal: null,
                 failureKind: "unadmitted",
+                failureDetail: null,
                 windowsUpdated: [],
                 durationMs: Date.now() - startedRealMs,
             };
@@ -142,28 +181,33 @@ export async function runMuseCapacityProbe(nowMs = Date.now(), opts = {}) {
             await host.readUsage();
             const checkNowMs = Math.max(nowMs, Date.now());
             const ok = hasFreshMuseCapacityPair(checkNowMs);
+            const failureKind = ok
+                ? null
+                : turn.timedOut
+                    ? "timeout"
+                    : turn.failure !== null
+                        ? "turn_failed"
+                        : "no_windows";
             result = {
                 ok,
                 admitted: true,
                 terminal: turn.terminal,
-                failureKind: ok
-                    ? null
-                    : turn.timedOut
-                        ? "timeout"
-                        : turn.failure !== null
-                            ? "turn_failed"
-                            : "no_windows",
+                failureKind,
+                failureDetail: failureKind === "turn_failed" || failureKind === "timeout"
+                    ? failureDetailFromTurn(turn.failure)
+                    : null,
                 windowsUpdated: ok ? ["rolling_all_models", "weekly_all_models"] : [],
                 durationMs: Date.now() - startedRealMs,
             };
         }
     }
-    catch {
+    catch (err) {
         result = {
             ok: false,
             admitted: false,
             terminal: null,
             failureKind: "exception",
+            failureDetail: failureDetailFromError(err),
             windowsUpdated: [],
             durationMs: Date.now() - startedRealMs,
         };
@@ -173,7 +217,10 @@ export async function runMuseCapacityProbe(nowMs = Date.now(), opts = {}) {
             await host.shutdown().catch(() => undefined);
     }
     appendMuseProbeDiagnostic(nowMs, result);
-    const outcome = result.ok ? "ok" : `failed: ${result.failureKind ?? "unknown"}`;
+    const detail = result.failureDetail !== null
+        ? ` (${result.failureDetail.kind}: ${result.failureDetail.message})`
+        : "";
+    const outcome = result.ok ? "ok" : `failed: ${result.failureKind ?? "unknown"}${detail}`;
     console.error(`[muse-capacity] fallback ${outcome}`);
     return result;
 }