agent-dealer 1.2.5 → 1.2.7

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

@@ -25,10 +25,12 @@
 //   connection (`hasInflightExecution`): a capacity read must not SIGTERM
 //   an admitted turn.
 // - The host launches under a server-owned XDG home
-//   (`prepareMuseServeHome`): the same worker posture as the exec lane's
-//   per-attempt settings (no MCP servers, no subagents, no workflows, no
-//   reminders) plus a symlink to the ambient login, so serve-lane turns
-//   never inherit the operator's ambient config.
+//   (`prepareMuseServeHome`): the deckless worker base posture
+//   (`buildMuseBaseSettings` — no MCP servers, no subagents, no workflows,
+//   no reminders) plus a symlink to the ambient login, so the host never
+//   inherits the operator's ambient config. It runs no sessions; deck-enabled
+//   developer turns each carry their own required `agent-deck` server on the
+//   isolated exec lane.
 // - `usage/changed` is ingested as soon as received; the throttled
 //   on-demand `usage/read` on the same host is the final read.
 // - Restart/crash: usage state is process-local to the host, so a dead host
@@ -51,17 +53,16 @@
 //   for an hour.
 //
 // Execution precondition (NOT-269): only a host that observes the account's
-// provider traffic can answer `usage/read`. Real Dealer Muse turns run
-// through THIS host (`session/start` + `turn/start` via the execution lane
-// below, driven by runners/muse-serve-session.ts) — that traffic is the
-// observation, so the session-boundary refresh hook
-// (`refreshMuseCapacityAfterSession` in coordinator/muse-spawn.ts) is the
-// final `usage/read` that populates 5H/1W. If no genuine turn has populated
-// a complete current pair for an hour, `muse-probe.ts` may use its own host
-// for the bounded paid fallback. When the normal serve execution lane cannot
-// admit a developer turn, that session still falls back to the legacy
-// `muse exec` subprocess before any model work starts; last-good capacity
-// rows remain preserved.
+// provider traffic can answer `usage/read`. NOT-278 removed developer turns
+// from this host: every deck-enabled Muse developer turn runs the isolated
+// `muse exec` lane (coordinator/muse-spawn.ts), which cannot observe the
+// host, so the session-boundary refresh hook
+// (`refreshMuseCapacityAfterSession` in coordinator/muse-spawn.ts) stays
+// honest N/A with last-good rows preserved until a genuine turn observes
+// the host again. If no genuine turn has populated a complete current pair
+// for an hour, `muse-probe.ts` may use its own host for the bounded paid
+// fallback. Per-session Agent Deck support for the serve protocol is a
+// non-goal until the protocol can represent isolated session MCP identity.
 //
 // PRODUCT DECISION (2026-09-26, resolved via human_action on this ticket):
 // the runner migration is in scope for NOT-270, in this same PR, not a
@@ -94,7 +95,7 @@ import path from "node:path";
 import { MUSE_CLI_ENV, resolveMuseAuthFile, resolveMuseBin } from "../cli-env.js";
 import { getDataDir } from "../db/index.js";
 import { parseMuseVersion } from "../adapters/muse-capability.js";
-import { buildMuseDeveloperSettings } from "../runners/muse-code-settings.js";
+import { buildMuseBaseSettings } from "../runners/muse-config.js";
 import { MSP_USAGE_CHANGED, MUSE_CLIENT_INFO, MUSE_SERVE_ARGV, assertMuseExecMethod, assertMuseReadOnlyMethod, hasMuseCredential, ingestMuseUsagePayload, museCapacityTimeoutMs, museClassifyRpcError, museEvidenceRef, museRefreshThrottleMs, museUuidv7, noteMuseCapacityFailure, parseMuseRpcLine, } from "./muse.js";
 function readResolvedMuseVersion() {
     return new Promise((resolve) => {
@@ -114,16 +115,16 @@ export function resolveMuseHostCwd() {
     return dir;
 }
 /**
- * NOT-270 serve lane: the owned host must run workers under the same
- * posture as the exec lane's per-attempt settings — no MCP servers, no
- * subagent delegation, no workflows, no reminder child runs — so serve-lane
- * turns never inherit the operator's ambient MCP/subagent config. Builds a
- * server-owned config home carrying `buildMuseDeveloperSettings()` plus a
- * symlink to the ambient login (linked, never read or copied; absent when
- * the operator authenticates with META_API_KEY), and an isolated data home
- * for the host's own session/state. Mirrors the exec lane's per-attempt
- * dirs (`coordinator/muse-spawn.ts`), but process-scoped: one home per host
- * instance, reused across restarts, removed on shutdown.
+ * NOT-278: the owned host never runs a session — it only serves the read-only
+ * handshake/`usage/read` allowlist for capacity, and it is shared across decks, so it
+ * carries the deckless worker base posture (`buildMuseBaseSettings()`: no MCP servers, no
+ * subagent delegation, no workflows, no reminder child runs) and never inherits the
+ * operator's ambient MCP/subagent config. Builds a server-owned config home carrying those
+ * base settings plus a symlink to the ambient login (linked, never read or copied; absent
+ * when the operator authenticates with META_API_KEY), and an isolated data home for the
+ * host's own session/state. Deck-enabled developer turns run on the isolated exec lane
+ * (`coordinator/muse-spawn.ts`), each with its own required `agent-deck` server. Process-
+ * scoped: one home per host instance, reused across restarts, removed on shutdown.
  */
 export function prepareMuseServeHome(ambientAuthFile = resolveMuseAuthFile()) {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-serve-"));
@@ -135,7 +136,7 @@ export function prepareMuseServeHome(ambientAuthFile = resolveMuseAuthFile()) {
     fs.chmodSync(root, 0o700);
     fs.chmodSync(configHome, 0o700);
     fs.chmodSync(dataHome, 0o700);
-    fs.writeFileSync(path.join(configHome, "muse", "settings.json"), `${JSON.stringify(buildMuseDeveloperSettings(), null, 2)}\n`, { mode: 0o600 });
+    fs.writeFileSync(path.join(configHome, "muse", "settings.json"), `${JSON.stringify(buildMuseBaseSettings(), null, 2)}\n`, { mode: 0o600 });
     let authLinked = false;
     try {
         if (fs.existsSync(ambientAuthFile)) {
@@ -226,9 +227,9 @@ export class MuseCapacityHost {
     /**
      * Env for the host subprocess: the server-owned XDG home always wins over
      * inherited ambient config (the server process itself may run under an
-     * operator XDG home), so serve-lane workers never inherit ambient MCP
-     * servers, subagents, or workflows. Only an explicit XDG override in
-     * `opts.env` (tests) still wins.
+     * operator XDG home), so the host never inherits ambient MCP servers,
+     * subagents, or workflows. Only an explicit XDG override in `opts.env`
+     * (tests) still wins.
      */
     mergedEnv() {
         const home = this.ensureServeHome();
@@ -488,8 +489,9 @@ export class MuseCapacityHost {
     /**
      * NOT-277: start (or reuse) the host, and report whether it runs `version`. A live host on any
      * other (or an unknown) version is restarted onto the current on-disk binary when it is idle;
-     * while real turns are using it, it is left alone and this returns false (the caller runs its
-     * work on the exec lane instead). Never true for a host not known to run `version`.
+     * while the connection is in use it is left alone and this returns false. Never true for a
+     * host not known to run `version`. (NOT-278: no developer turn runs on the host any more —
+     * this only gates capacity reads, which are version-independent.)
      */
     async ensureStartedOnVersion(version) {
         if (!(await this.ensureStarted()))

package/bundle/server/dist/capacity/muse-host.test.js

@@ -473,9 +473,11 @@ test("serve host launches under a server-owned config home with worker settings"
         assert.ok(!String(rec.dataHome).includes(".config"), "data home is not the operator's");
         assert.equal(rec.settingsError, null, "settings.json parses on the launched host");
         const settings = rec.settings;
-        // Same worker posture as the exec lane's per-attempt settings: no MCP
-        // servers, no subagent delegation, no workflows, no reminder child runs.
-        assert.ok(!("mcpServers" in settings), "workers get no MCP servers");
+        // NOT-278: the host runs no sessions, so it carries the deckless worker base posture
+        // (`buildMuseBaseSettings`): no MCP servers, no subagent delegation, no workflows, no
+        // reminder child runs. Deck-enabled developer turns each carry their own required
+        // `agent-deck` server on the isolated exec lane.
+        assert.ok(!("mcpServers" in settings), "the host carries no MCP servers");
         const run = settings.run;
         assert.equal(run.workflow_trigger_mode, "off");
         assert.equal(run.subagent_delegation_mode, "off");

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

@@ -33,9 +33,10 @@ function claudeDisallowedTools(policy) {
 }
 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.
+        // Muse's developer argv is built by runners/muse-config.ts (`prepareMuseAttempt`,
+        // NOT-278) inside coordinator/muse-spawn.ts; it needs a per-attempt deck, 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") {

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

@@ -26,9 +26,11 @@ export function emitCheckpointObserved(ev) {
             samplingPrecisionMs: ev.samplingPrecisionMs ?? null,
             branch: ev.branch ?? null,
         },
-        idempotencyKey: ev.kind === "commit" && ev.origin === "salvage"
-            ? `checkpoint:${ev.workerSessionId}:commit:salvage`
-            : `checkpoint:${ev.workerSessionId}:${ev.kind}`,
+        idempotencyKey: ev.resumeSalvage && ev.observedSha
+            ? `checkpoint:resume-salvage:${ev.issueId}:${ev.observedSha}`
+            : ev.kind === "commit" && ev.origin === "salvage"
+                ? `checkpoint:${ev.workerSessionId}:commit:salvage`
+                : `checkpoint:${ev.workerSessionId}:${ev.kind}`,
     });
 }
 /**

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

@@ -167,3 +167,26 @@ test("checkpoints attribute per session across attempts of one issue", async ()
     assert.deepEqual(records.map((r) => r.sessionId).sort(), [sessionId, second.id].sort());
     assert.deepEqual(records.map((r) => r.observedSha).sort(), [COMMIT_SHA, "c".repeat(40)].sort());
 });
+test("NOT-280: resume-salvage checkpoints dedupe per issue on restart but never collide across issues with an identical commit SHA", async () => {
+    const a = await setup();
+    const b = await setup();
+    const emit = (ctx) => emitCheckpointObserved({
+        issueId: ctx.issueId,
+        workflowInstanceId: ctx.instanceId,
+        workerSessionId: ctx.sessionId,
+        role: "developer",
+        stage: "developing",
+        round: 1,
+        kind: "commit",
+        observedSha: COMMIT_SHA,
+        origin: "salvage",
+        resumeSalvage: true,
+    });
+    emit(a);
+    emit(a); // restart re-detecting the same saved tip
+    emit(b); // another issue whose salvage produced the identical commit object
+    assert.equal(checkpointsOf(a.issueId, "commit").length, 1, "restart never duplicates the row");
+    assert.equal(checkpointsOf(b.issueId, "commit").length, 1, "the second issue still gets its own checkpoint");
+    const [row] = listWorkflowEventsForIssue(b.issueId).filter((e) => e.type === "checkpoint.observed");
+    assert.equal(row.workerSessionId, b.sessionId, "tied to its own predecessor session");
+});

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

@@ -11,7 +11,7 @@ import { canTransitionIssue } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
 import { getIssue, incrementIssueRound, incrementIssueInfraAttempts, resetIssueInfraAttempts, grantReviewRetry, transitionIssue, } from "../repository/issues.js";
 import { appendWorkflowEvent, completeWorkflowInstance, getActiveWorkflowInstance, getWorkflowInstance, listWorkflowEventsForIssue, startWorkflowInstance, WorkflowAlreadyActiveError, } from "../repository/workflow-events.js";
-import { createHumanAction, findOpenHumanAction, getHumanAction, listHumanActionsForIssue, resolveHumanAction, updateOpenHumanAction, } from "../repository/human-actions.js";
+import { createHumanAction, findOpenHumanAction, getHumanAction, listHumanActionsForIssue, reopenHumanAction, resolveHumanAction, updateOpenHumanAction, } from "../repository/human-actions.js";
 import { pushLeaseToSha, readRemoteTip } from "../adapters/git-worktree.js";
 import { ensureIssueRepoCheckout } from "../adapters/managed-repo.js";
 import { reconcileFinding, resolveFindingsAbsentFromRound } from "../repository/findings.js";
@@ -28,7 +28,7 @@ import { reasonForWorkerFailedEvent } from "./failure-reason.js";
 import { recordCausesForWorkerFailedEvent } from "./failure-cause.js";
 import { routeDeveloperOutcome, routeReviewerOutcome, } from "./routing.js";
 import { projectDeveloperRoute, projectReviewerRoute } from "./projection.js";
-import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS, PUSH_DIVERGENCE_EVIDENCE_KEY, PUSH_DIVERGENCE_RESPONSE_OPTIONS, normalizeResolutionNote, parseHumanResolution, resolveHumanActionOutcome, } from "./human-resolution.js";
+import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS, PUSH_DIVERGENCE_EVIDENCE_KEY, PUSH_DIVERGENCE_RESPONSE_OPTIONS, WORKTREE_BLOCKER_EVIDENCE_KEY, normalizeResolutionNote, parseHumanResolution, resolveHumanActionOutcome, } from "./human-resolution.js";
 import { AUTO_MERGE_INTENT, finalizeAutoMerge } from "./auto-merge.js";
 import { externalMergeStateForIssue } from "./external-merge.js";
 import { detectNonConvergence, formatNonConvergenceReason, reviewHistoryFromEvents, } from "./non-convergence.js";
@@ -786,6 +786,19 @@ function applyEffect(issue, instance, effect, route, issueNow, ev, causativeItem
         const pushDivergence = actionType === "policy_escalation" && !resumeAsReviewer
             ? (effect.pushDivergence ?? null)
             : null;
+        // NOT-280: an unchanged worktree blocker (same fingerprint) lands on the action it
+        // already raised — still open, or reopened when a Resume changed nothing — instead of
+        // opening an identical one on every Resume.
+        const blockerFingerprint = effect.kind === "human_action" ? (effect.blockerFingerprint ?? null) : null;
+        if (blockerFingerprint) {
+            const same = sameBlockerAction(issue.id, blockerFingerprint);
+            if (same) {
+                ev.emit("human_action.requested", {
+                    payload: { actionType: same.actionType, actionId: same.id, reopened: true, blockerFingerprint },
+                });
+                return { ...base, humanActionId: same.id };
+            }
+        }
         const action = createHumanAction({
             issueId: issue.id,
             workflowInstanceId: instance.id,
@@ -796,7 +809,9 @@ function applyEffect(issue, instance, effect, route, issueNow, ev, causativeItem
                 ? { review: reviewerOutcome.result, ...(nonConvergence ? { nonConvergence } : {}) }
                 : pushDivergence
                     ? { [PUSH_DIVERGENCE_EVIDENCE_KEY]: pushDivergence }
-                    : undefined,
+                    : blockerFingerprint
+                        ? { [WORKTREE_BLOCKER_EVIDENCE_KEY]: { fingerprint: blockerFingerprint } }
+                        : undefined,
             // issueNow.headSha, not issue.headSha: a stale outcome that itself exhausted the
             // infra budget already patched the newly observed head onto the issue above — the
             // pre-transition issue param would still carry the stale SHA a "resume" must not reuse.
@@ -819,6 +834,51 @@ function applyEffect(issue, instance, effect, route, issueNow, ev, causativeItem
     }
     return base;
 }
+/**
+ * NOT-280: an action reopened for an unchanged blocker (`sameBlockerAction`) can be
+ * resumed again — each Resume of it needs its own work item, so later resolutions of the
+ * same action get an ordinal suffix. The first Resume keeps the plain action-keyed name.
+ */
+function resumeWorkItemKey(issueId, baseKey) {
+    const taken = new Set(listWorkItemsForIssue(issueId).map((w) => w.idempotencyKey));
+    if (!taken.has(baseKey))
+        return baseKey;
+    let n = 2;
+    while (taken.has(`${baseKey}:${n}`))
+        n++;
+    return `${baseKey}:${n}`;
+}
+/**
+ * NOT-280: the issue's most recent action, when it was raised for exactly this worktree
+ * blocker fingerprint and is either still open or was resolved by a Resume — reopened in
+ * that case. Anything else in between (another action, a different choice, a changed
+ * blocker) means state moved, so the caller raises a fresh action.
+ */
+function sameBlockerAction(issueId, fingerprint) {
+    const actions = listHumanActionsForIssue(issueId);
+    const latest = actions[actions.length - 1];
+    if (!latest?.evidenceJson)
+        return null;
+    try {
+        const evidence = JSON.parse(latest.evidenceJson);
+        if (evidence[WORKTREE_BLOCKER_EVIDENCE_KEY]?.fingerprint !== fingerprint)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    if (latest.status === "open")
+        return latest;
+    try {
+        const resolution = latest.resolutionJson ? JSON.parse(latest.resolutionJson) : null;
+        if (resolution?.choice !== "resume")
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return reopenHumanAction(latest.id);
+}
 /**
  * NOT-194: true when the action is a merge-failure escalation (evidence carries
  * `mergeFailure: true`). Pre-NOT-194 open merge-failure actions have no such evidence and
@@ -1292,6 +1352,7 @@ export function resolveHumanActionAndAdvance(actionId, resolvedBy, choice, opts)
         // Keyed on the resolved human action, not the round/attempt counters: a
         // "infra" resume resets infra_attempts to 0 every time, so a counter-based key would
         // collide across repeated escalate→resume cycles within the same round.
+        const resumeKey = resumeWorkItemKey(issue.id, `${instance.id}:${resumeAsReviewer ? "reviewer" : "developer"}:resume:${action.id}`);
         const next = resumeAsReviewer
             ? enqueueWorkItem({
                 issueId: issue.id,
@@ -1299,7 +1360,7 @@ export function resolveHumanActionAndAdvance(actionId, resolvedBy, choice, opts)
                 kind: "reviewer",
                 round: issueNow.currentRound,
                 payload: { inputSha: effectiveResumeHeadSha, profileSnapshot: queuedProfileSnapshot(issue, "reviewer") },
-                idempotencyKey: `${instance.id}:reviewer:resume:${action.id}`,
+                idempotencyKey: resumeKey,
             })
             : enqueueWorkItem({
                 issueId: issue.id,
@@ -1312,7 +1373,7 @@ export function resolveHumanActionAndAdvance(actionId, resolvedBy, choice, opts)
                     // payload — later rounds never see it.
                     ...(scopeDecisionNote ? { scopeDecisionNote } : {}),
                 },
-                idempotencyKey: `${instance.id}:developer:resume:${action.id}`,
+                idempotencyKey: resumeKey,
             });
         return {
             ok: true,

package/bundle/server/dist/coordinator/developer-effect.js

@@ -21,11 +21,11 @@ import { getTaskSnapshot } from "./commands.js";
 import { buildDeveloperPrompt } from "./prompts.js";
 import { guidanceForNextSession } from "./guidance.js";
 import { realDeveloperSpawn, developerSessionLogPath } from "./spawn.js";
-import { DEFAULT_BASE_FETCH_TIMEOUT_MS, fastForwardLocalBranchToSha, resolveDeveloperWorktree, safeRemoveWorktree, isWorktreeClean, commitsAhead, pushBranch, mergeBase, branchExists, pushBranchRef, revParseHead, revParseRef, fetchRef, salvageDirtyWorktree, dirtyWorktreeRecoveryCommands, withRepoLock, } from "../adapters/git-worktree.js";
+import { DEFAULT_BASE_FETCH_TIMEOUT_MS, fastForwardLocalBranchToSha, resolveDeveloperWorktree, safeRemoveWorktree, isWorktreeClean, commitsAhead, pushBranch, mergeBase, branchExists, pushBranchRef, revParseHead, revParseRef, fetchRef, salvageDirtyWorktree, dirtyWorktreeRecoveryCommands, withRepoLock, leftoverFingerprint, } from "../adapters/git-worktree.js";
 import { recordIssueBaseSha } from "../repository/issues.js";
 import { ensureIssueRepoCheckout, roleWorktreePathForResolution, resolveCheckoutBaseBranch, } from "../adapters/managed-repo.js";
 import { baseRefCandidates, inspectBranchProgress } from "./branch-progress.js";
-import { prepareWorkerDeckConnection, releaseWorkerDeckConnection } from "../adapters/agent-deck-bind.js";
+import { prepareWorkerDeckConnection, releaseWorkerDeckConnection, verifyWorkerDeckConnection } from "../adapters/agent-deck-bind.js";
 import { realGithubAdapter, pollPrChecks } from "../adapters/github.js";
 import { getWorkerSession, patchRunningSession, recordSessionProcess, setSessionInputSha } from "../repository/worker-sessions.js";
 import { COORDINATOR_PROCESS_OWNER, readProcessStartTime } from "./process-liveness.js";
@@ -675,7 +675,13 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             return { kind: "base_fetch_failed", reason: resolved.reason };
         }
         if (resolved.kind === "conflict") {
-            return { kind: "worktree_conflict", path: resolved.path, reason: resolved.reason, recoveryCommands: resolved.recoveryCommands };
+            return {
+                kind: "worktree_conflict",
+                path: resolved.path,
+                reason: resolved.reason,
+                recoveryCommands: resolved.recoveryCommands,
+                ...(resolved.fingerprint ? { fingerprint: resolved.fingerprint } : {}),
+            };
         }
         if (resolved.kind === "live_owner") {
             return {
@@ -687,6 +693,56 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
         }
         worktreePath = resolved.path;
         worktreeReused = resolved.kind === "reused";
+        if (resolved.kind === "reused" && resolved.salvage) {
+            // NOT-280: a dead predecessor's dirt was committed on the issue branch (or found
+            // already committed after a restart) — one durable checkpoint per salvage commit,
+            // tied to the predecessor session when Dealer still has its row.
+            // Unlike ordinary checkpoint evidence, this row is a deliverable: if it cannot be
+            // persisted (after one retry) the attempt stops before spawning, leaving the clean
+            // checkout and its salvage tip in place. The next Resume re-detects that tip
+            // (`recovered`) and retries the idempotent insert; an unchanged failure keeps the
+            // same fingerprint, so it reuses its human action instead of opening another.
+            const salvage = resolved.salvage;
+            const recordSalvage = () => emitCheckpointObserved({
+                issueId: issue.id,
+                workflowInstanceId: instance.id,
+                workerSessionId: getWorkerSession(salvage.predecessorSessionId)
+                    ? salvage.predecessorSessionId
+                    : sessionId,
+                role: "developer",
+                stage,
+                round,
+                kind: "commit",
+                observedSha: salvage.commitSha,
+                origin: "salvage",
+                branch: branchName,
+                resumeSalvage: true,
+            });
+            let checkpointError = null;
+            for (let attempt = 0; attempt < 2; attempt++) {
+                try {
+                    recordSalvage();
+                    checkpointError = null;
+                    break;
+                }
+                catch (err) {
+                    checkpointError = err;
+                }
+            }
+            if (checkpointError !== null) {
+                const reason = `Salvage tip ${salvage.commitSha.slice(0, 7)} of dead session ${salvage.predecessorSessionId}'s work ` +
+                    `was committed on ${branchName} at ${worktreePath}, but its durable checkpoint could not be recorded: ` +
+                    `${checkpointError instanceof Error ? checkpointError.message : String(checkpointError)}. ` +
+                    "The checkout was left intact; Resume retries the checkpoint without re-committing.";
+                return {
+                    kind: "worktree_conflict",
+                    path: worktreePath,
+                    reason,
+                    recoveryCommands: [`cd ${worktreePath}`, "git log --oneline -3", "# fix the Dealer database, then Resume"],
+                    fingerprint: await leftoverFingerprint(worktreePath, reason),
+                };
+            }
+        }
         if (resolved.kind === "created" && resolved.baseSha) {
             // NOT-197: record the true branch point while it is known — the verified handoff
             // re-checks it via merge-base, but crash/timeout progress inspection below already
@@ -729,8 +785,7 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
     // the spawn args' tool surface further down. They were resolved separately and had to
     // agree by inspection — the exact shape this stack exists to remove (NOT-134 review).
     const policy = snapshot?.permissionPolicy ?? roleCeiling("developer");
-    // NOT-181: Muse Code workers get no MCP servers and no Agent Deck — nothing is materialized,
-    // verified or released for them, whatever deck the profile happens to carry.
+    // NOT-278: every runtime, Muse included, is fail-closed without a deck — nothing spawns.
     const isMuse = runtime === "muse_code";
     let workerAuthority = null;
     // NOT-225: marks the setup/spawn boundary for the outer catch below. Only a throw
@@ -739,14 +794,14 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
     // adapter_failure path, since the session did start, run, and possibly commit.
     let sessionStarted = false;
     try {
-        if (!isMuse && !snapshot?.deckId) {
+        if (!snapshot?.deckId) {
             await bestEffortRemove(repoPath, worktreePath);
             return {
                 kind: "deck_failure",
                 reason: "Agent profile has no Agent Deck — workers never start without one",
             };
         }
-        if (!isMuse && snapshot?.deckId) {
+        if (!isMuse) {
             const prepared = await prepareWorkerDeckConnection({
                 deckId: snapshot.deckId,
                 worktreePath,
@@ -769,7 +824,27 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
                 deckId: snapshot.deckId,
             });
         }
-        if (taskBriefIsComplete(taskSnapshot) || isMuse) {
+        else {
+            // NOT-278: Muse runs the same live deck preflight without materializing a runtime MCP
+            // config — its settings.json comes only from `prepareMuseAttempt` in the spawn path.
+            // Same mapping: silence is `deck_unavailable`, a bad answer is `deck_failure`.
+            const verified = await verifyWorkerDeckConnection({
+                deckId: snapshot.deckId,
+                worktreePath,
+                callTool: deps.deckCallTool,
+            });
+            if (!verified.ok) {
+                await bestEffortRemove(repoPath, worktreePath);
+                return verified.kind === "deck_unavailable"
+                    ? { kind: "deck_unavailable", reason: verified.reason }
+                    : { kind: "deck_failure", reason: verified.reason };
+            }
+            milestone("deck.connected", `Developer · deck connected (round ${round})`, {
+                deckId: snapshot.deckId,
+            });
+        }
+        // NOT-278: Muse is deck-bound like every other runtime, so the same brief rule applies.
+        if (taskBriefIsComplete(taskSnapshot)) {
             milestone("brief.resolved", `Developer · brief ready (Task/AC complete)`, {
                 resolution: "task_complete",
             });
@@ -818,8 +893,8 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             priorConclusion,
             priorVerificationReceipt,
             worktreePath,
-            deckId: isMuse ? null : (snapshot?.deckId ?? null),
-            noAgentDeck: isMuse,
+            deckId: snapshot?.deckId ?? null,
+            museDeveloper: isMuse,
             guidance: guidance.length ? guidance : undefined,
             scopeDecisionNote,
         });
@@ -920,6 +995,9 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
                 effort: snapshot?.effort ?? null,
                 // Frozen profile budget → Muse's `--max-model-steps`; the other runtimes ignore it.
                 maxModelSteps: parsePhaseBudget(snapshot?.budgetJson)?.maxTurns ?? null,
+                // NOT-278: frozen profile deck → the Muse exec attempt (deck headers + pre-spawn
+                // verify). Other runtimes carry their deck via mcpConfigPath/mcpEnv and ignore this.
+                deckId: snapshot?.deckId ?? null,
                 prompt,
                 cwd: worktreePath,
                 timeoutMs: developerEffectConfig.sessionTimeoutMs,