agent-dealer 1.2.5 → 1.2.6

package/bundle/server/dist/coordinator/muse-spawn.js

@@ -1,46 +1,29 @@
 // packages/server/src/coordinator/muse-spawn.ts
 //
-// NOT-181: the native Muse Code developer spawn. Wires the already-tested pieces — binary
-// resolution (cli-env.ts), argv (runners/muse-code-args.ts), JSONL/session-log parsing
-// (runners/muse-code-jsonl.ts) — into the existing developer-effect contract without changing
-// either side:
+// NOT-278: the native Muse Code developer spawn. Every deck-enabled Muse developer turn runs the
+// isolated `muse exec` lane: one exact, fail-closed per-attempt home built by
+// `prepareMuseAttempt` (runners/muse-config.ts) — settings.json with exactly one required
+// `agent-deck` server (deck/workspace headers), filtered env, stdin-only API key — verified
+// immediately before spawn and removed afterwards on every outcome.
 //
-//   1. a per-attempt config + data dir under the worktree (`.dealer-muse/<attempt>/`, kept out of
-//      git via info/exclude): `settings.json` with no MCP servers, a symlinked `auth.json`;
-//   2. `spawnCli` with `XDG_CONFIG_HOME`/`XDG_DATA_HOME` pointed at it;
-//   3. the on-disk session log (usage + confirmed model exist only there) read while the dir still
-//      exists, then the dir is removed on success *and* failure;
-//   4. the raw stdout archived next to the log, and the log itself rewritten as Claude/Cursor-shaped
-//      events, so every existing log reader (usage, result text, auth/usage-cap classification,
-//      activity strip) works unchanged.
+// The shared Muse serve host cannot carry per-session MCP configuration or deck/workspace
+// headers (`session/start` accepts only command, workspace, model, and approval mode), so the
+// serve lane is never used here. Fresh 5H/1W observation from the serve host is deliberately
+// suspended while deck-enabled work is forced to exec; capacity stays honest N/A/stale with
+// last-good rows preserved. Per-session Agent Deck support in the serve protocol is a non-goal.
 //
 // Muse cannot disable `cron_*` (NOT-177). The tool activity is checked here after the fact and
 // surfaced as `cronCalls`; the effect turns that into a `muse_cron_used` escalation. It detects,
 // it does not prevent.
-import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { MUSE_CODE_CONTRIBUTOR_MODEL } from "@agent-dealer/shared";
 import { resolveMuseAuthFile, resolveMuseBin } from "../cli-env.js";
-import { museVersionRequiredForWork } from "../adapters/muse-capability.js";
-import { ensureWorktreeExcluded } from "../adapters/worktree-exclude.js";
-import { buildMuseDeveloperInvocation } from "../runners/muse-code-args.js";
-import { buildMuseDeveloperSettings } from "../runners/muse-code-settings.js";
-import { normalizeMuseRun, parseMuseRun, } from "../runners/muse-code-jsonl.js";
-import { runMuseServeTurn } from "../runners/muse-serve-session.js";
+import { getAgentDeckMcpUrl } from "../adapters/agent-deck.js";
+import { getWorkerMcpConfigDir } from "../paths.js";
+import { prepareMuseAttempt, } from "../runners/muse-config.js";
+import { parseMuseRun, } from "../runners/muse-code-jsonl.js";
 import { spawnCli } from "../runners/spawn-cli.js";
-/**
- * NOT-270: execution lane selection. Default is the server-owned serve host
- * (real turns through it are the NOT-269 precondition for 5H/1W capacity).
- * `AGENT_DEALER_MUSE_RUNNER=exec` forces the legacy `muse exec` subprocess
- * lane — the operator escape hatch if the serve lane ever misbehaves in
- * production (capacity then reads honest N/A until serve runs again).
- */
-function museServeLaneEnabled() {
-    return process.env.AGENT_DEALER_MUSE_RUNNER !== "exec";
-}
-/** Worktree-relative home of every per-attempt Muse config/data dir. */
-export const MUSE_ATTEMPT_ROOT = ".dealer-muse";
 /**
  * Step cap when the profile sets no `maxTurns`. High on purpose (the PoC's value): the developer
  * wall-clock timeout is the real limit, the cap only stops a runaway loop.
@@ -82,32 +65,24 @@ function readSessionLog(dataDir, museSessionId) {
     };
     return visit(root, 0);
 }
-function prepareAttemptDirs(worktreePath) {
-    ensureWorktreeExcluded(worktreePath, `/${MUSE_ATTEMPT_ROOT}/`);
-    const root = path.join(worktreePath, MUSE_ATTEMPT_ROOT, randomUUID());
-    const configHome = path.join(root, "config");
-    const dataHome = path.join(root, "data");
-    fs.mkdirSync(path.join(configHome, "muse"), { recursive: true, mode: 0o700 });
-    fs.mkdirSync(dataHome, { recursive: true, mode: 0o700 });
-    // mkdir's mode is masked by the umask; the dirs hold a login symlink and the session log.
-    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 });
-    // Linked, never read or copied. Absent when the operator authenticates with META_API_KEY.
-    const auth = resolveMuseAuthFile();
-    if (fs.existsSync(auth))
-        fs.symlinkSync(auth, path.join(configHome, "muse", "auth.json"));
-    return { root, configHome, dataHome };
-}
-function removeAttemptDirs(worktreePath, root) {
-    fs.rmSync(root, { recursive: true, force: true });
+/**
+ * NOT-278: the attempt's credential. A saved login is linked, never read or copied; otherwise
+ * the API key travels on stdin only (`--api-key-stdin`, written once by the launcher and never
+ * logged). Missing credentials fail before spawn — nothing is written and no process starts.
+ */
+function resolveMuseCredential() {
+    const authFile = resolveMuseAuthFile();
     try {
-        fs.rmdirSync(path.join(worktreePath, MUSE_ATTEMPT_ROOT)); // only when no sibling attempt remains
+        if (fs.existsSync(authFile))
+            return { kind: "auth-file", path: authFile };
     }
     catch {
-        // not empty or already gone
+        // An unreadable auth path is the same as a missing one: fall through to the API key.
     }
+    const apiKey = process.env.META_API_KEY;
+    if (apiKey !== undefined && apiKey.trim() !== "")
+        return { kind: "api-key", apiKey };
+    throw new Error("Muse Code auth required: run `muse login` or set META_API_KEY");
 }
 function splitSpawnLog(raw) {
     const idx = raw.indexOf(STDERR_MARKER);
@@ -124,11 +99,9 @@ function splitSpawnLog(raw) {
  * safe point is contractual, not opportunistic — a recent Agents-page poll
  * must never skip it. This creates no model turn of its own (the capacity
  * client only ever sends the read-only handshake/`usage/read` allowlist)
- * and never affects the session result. Serve-lane turns observed the host,
- * so this hook is the final read that populates 5H/1W; after an exec-lane
- * fallback the host stays unobserved by construction (the NOT-269
- * structural precondition) and the read stays honest N/A with last-good
- * rows preserved.
+ * and never affects the session result. Exec-lane turns leave the host
+ * unobserved by construction (the NOT-269 structural precondition), so the
+ * read stays honest N/A with last-good rows preserved.
  */
 function refreshMuseCapacityAfterSession() {
     void (async () => {
@@ -144,138 +117,63 @@ function refreshMuseCapacityAfterSession() {
     })();
 }
 /**
- * NOT-270: run the real developer turn through the server-owned serve host.
- * Returns null when no turn was admitted (host unavailable, session/start
- * or turn/start rejected) — the caller then runs the legacy `muse exec`
- * lane. Never returns null after admission: an admitted turn is real work
- * and its verdict is reported honestly, never retried on the other lane.
+ * NOT-278: run the deck-enabled developer turn as one isolated `muse exec` attempt. Fails before
+ * spawn without a frozen profile deck (the effect already maps that to `deck_failure`; this is
+ * the defense in depth that keeps a deckless launch from ever reaching a child process).
+ *
+ * The attempt is built with `prepareMuseAttempt({ role: "developer", ... })` on a Dealer-owned
+ * base directory outside the worktree and outside OS temp (the worker MCP config root), with
+ * `agentDeck.url` set to the configured Agent Deck MCP endpoint ending in `/mcp` (overridable
+ * for deckless infra callers), `deckId` to the frozen profile value, and `workspace` to the
+ * real worktree path. Immediately before spawn the exact cwd/argv/env/stdin about to be
+ * launched is verified; the child receives exactly
+ * `attempt.env` (no `process.env` merge) and `attempt.stdin`, so ambient `META_API_KEY`,
+ * `MUSE_*`, `CODEX_HOME`, and unrelated variables can never reach it.
  *
- * The serve lane needs no per-attempt XDG config/data dirs: the host runs
- * under its own server-owned home (`prepareMuseServeHome` in
- * capacity/muse-host.ts — same worker settings as the exec lane's
- * per-attempt settings.json plus a symlink to the ambient login, so runner
- * and capacity can never diverge on identity or posture). `onSpawn` is
- * deliberately not called: there is no per-attempt pid to persist, and
- * recovery must never treat the shared host as an attempt process.
+ * Settings, data, and the auth link are removed in `finally` on success, Muse failure,
+ * timeout, abort, and spawn error — operator credentials are never touched.
  */
-async function runMuseServeLane(input, model, onAdmitted) {
-    const { getMuseCapacityHost } = await import("../capacity/muse-host.js");
-    const host = getMuseCapacityHost();
-    // NOT-277: admission gated on the capability check of the on-disk binary; a long-lived host can
-    // still run an older (possibly broken) build. Serve only on a host known to run the confirmed
-    // version (restarted onto it when idle); otherwise the work runs on the checked exec lane.
-    const required = museVersionRequiredForWork();
-    if (required === null)
-        return null;
-    if (required !== undefined && !(await host.ensureStartedOnVersion(required)))
-        return null;
-    // Only this call may fall back: it resolves `admitted:false` (or throws)
-    // strictly before any model work starts. Everything below runs after
-    // admission — the caller's no-double-execution rule (via onAdmitted)
-    // keeps those errors loud instead of falling back to exec.
-    const turn = await runMuseServeTurn({
-        host,
-        prompt: input.prompt,
-        model,
-        cwd: input.cwd,
-        timeoutMs: input.timeoutMs,
-        signal: input.signal,
-        onAdmitted: () => onAdmitted(),
-    });
-    if (!turn.admitted)
-        return null;
-    const cronCalls = turn.tools
-        .map((t) => t.name)
-        .filter((n) => n !== null && CRON_TOOL_RE.test(n));
-    const summary = {
-        museSessionId: turn.sessionId ?? randomUUID(),
-        confirmedModel: turn.confirmedModel,
-        usage: turn.usage,
-        failure: turn.failure,
-        cronCalls,
-        runCount: 1,
-        rawLogPath: null,
-    };
-    // Same normalized evidence both lanes write: the raw folded history, then
-    // the Claude/Cursor-shaped stream every existing log reader consumes.
-    const rawLogPath = `${input.logPath.replace(/\.ndjson$/, "")}.muse-raw.jsonl`;
-    try {
-        fs.writeFileSync(rawLogPath, `${turn.viewItems.map((i) => JSON.stringify(i)).join("\n")}\n`);
-        summary.rawLogPath = rawLogPath;
-    }
-    catch {
-        // evidence copy is best-effort; the normalized log below still carries the outcome
-    }
-    const events = normalizeMuseRun({
-        sessionId: summary.museSessionId,
-        confirmedModel: turn.confirmedModel,
-        tools: turn.tools,
-        finalText: turn.finalText,
-        usage: turn.usage,
-        failure: turn.failure,
-    }).map((e) => e.type === "result" ? { ...e, muse: { ...summary, usage: turn.usage } } : e);
-    fs.writeFileSync(input.logPath, `${events.map((e) => JSON.stringify(e)).join("\n")}\n`);
-    // The real session above is the observation opportunity: kick the
-    // best-effort capacity refresh (no synthetic turn, never throws, never
-    // blocks this result).
-    refreshMuseCapacityAfterSession();
-    // A failed session must not read as success. 124 mirrors spawn-cli's
-    // timeout exit so timeout handling downstream sees the same signal.
-    const exitCode = turn.timedOut ? 124 : turn.failure ? 1 : turn.terminal === "completed" ? 0 : 1;
-    return {
-        exitCode,
-        transcript: turn.finalText ?? "",
-        logPath: input.logPath,
-        timedOut: turn.timedOut,
-        muse: summary,
-    };
-}
 export async function runMuseDeveloperSession(input) {
-    const model = input.model ?? MUSE_CODE_CONTRIBUTOR_MODEL;
-    const museSessionId = randomUUID();
-    // Serve-first: real turns through the owned host observe it (NOT-269
-    // precondition for 5H/1W). Pre-admission failure falls back to exec; an
-    // admitted turn never falls back — its errors propagate loudly instead of
-    // executing the work a second time on the exec lane.
-    // `AGENT_DEALER_MUSE_RUNNER=exec` skips the serve lane entirely
-    // (operator escape hatch).
-    if (museServeLaneEnabled() && !input.execLaneOnly) {
-        let admitted = false;
-        try {
-            const served = await runMuseServeLane(input, model, () => {
-                admitted = true;
-            });
-            if (served)
-                return served;
-        }
-        catch (err) {
-            if (admitted)
-                throw err;
-            // Pre-admission serve-lane error: fall through to the exec lane below.
-        }
+    const deckId = typeof input.deckId === "string" && input.deckId.trim() !== "" ? input.deckId : null;
+    if (!deckId) {
+        throw new Error("Muse developer session requires a frozen profile deckId — workers never start without one");
     }
-    const invocation = buildMuseDeveloperInvocation({
-        model,
-        maxModelSteps: input.maxModelSteps ?? DEFAULT_MUSE_MAX_MODEL_STEPS,
-        sessionId: museSessionId,
+    const model = input.model ?? MUSE_CODE_CONTRIBUTOR_MODEL;
+    const mcpUrl = typeof input.agentDeckUrl === "string" && input.agentDeckUrl.trim() !== ""
+        ? input.agentDeckUrl
+        : `${getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "")}/mcp`;
+    // prepareMuseAttempt validates everything (role controls, deck identity, credential shape,
+    // unsafe paths) and writes the per-attempt dir; it removes its own dir when setup fails.
+    const attempt = prepareMuseAttempt({
+        role: "developer",
+        worktreePath: input.cwd,
+        baseDir: getWorkerMcpConfigDir(),
+        agentDeck: { url: mcpUrl, deckId, workspace: input.cwd },
+        credential: resolveMuseCredential(),
+        sessionId: input.sessionId,
         prompt: input.prompt,
+        maxModelSteps: input.maxModelSteps ?? DEFAULT_MUSE_MAX_MODEL_STEPS,
     });
     const { logPath } = input;
-    const dirs = prepareAttemptDirs(input.cwd);
     let spawned;
     let sessionLog;
     try {
-        spawned = await spawnCli(input.sessionId, resolveMuseBin(), invocation.args, input.cwd, {
+        // The exact launch about to happen — a tampered settings file or a differing
+        // cwd/argv/env/stdin fails here, before any process exists.
+        attempt.verify({ cwd: attempt.cwd, argv: [...attempt.argv], env: { ...attempt.env }, stdin: attempt.stdin });
+        spawned = await spawnCli(input.sessionId, resolveMuseBin(), [...attempt.argv], attempt.cwd, {
             logPath,
             timeoutMs: input.timeoutMs,
-            env: { ...invocation.env, XDG_CONFIG_HOME: dirs.configHome, XDG_DATA_HOME: dirs.dataHome },
+            env: { ...attempt.env },
+            exactEnv: true,
+            stdin: attempt.stdin,
             signal: input.signal,
             onSpawn: input.onSpawn,
         });
-        sessionLog = readSessionLog(dirs.dataHome, museSessionId);
+        sessionLog = readSessionLog(attempt.env.XDG_DATA_HOME, input.sessionId);
     }
     finally {
-        removeAttemptDirs(input.cwd, dirs.root);
+        attempt.cleanup();
     }
     const rawLog = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : spawned.transcript;
     const { stdout, stderr } = splitSpawnLog(rawLog);
@@ -288,7 +186,7 @@ export async function runMuseDeveloperSession(input) {
     });
     const cronCalls = run.tools.map((t) => t.name).filter((n) => n !== null && CRON_TOOL_RE.test(n));
     const summary = {
-        museSessionId,
+        museSessionId: input.sessionId,
         confirmedModel: run.confirmedModel,
         usage: run.usage,
         failure: run.failure,

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

@@ -60,6 +60,7 @@ export function projectDeveloperRoute(route, currentStatus, round) {
                     ...("pushDivergence" in route && route.pushDivergence
                         ? { pushDivergence: route.pushDivergence }
                         : {}),
+                    ...(route.blockerFingerprint ? { blockerFingerprint: route.blockerFingerprint } : {}),
                 },
                 advance: "none",
             };

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

@@ -36,16 +36,18 @@ function scopeDecisionSection(note) {
  *
  * Workers never start without a deckId (fail-closed at admission/effect).
  */
-function noAgentDeckSection() {
+/**
+ * NOT-278: Muse cannot mechanically disable `cron_*`, so its developer prompt carries this
+ * prohibition on top of the standard deck bootstrap. A session that calls one is failed as
+ * `muse_cron_used` and escalated to the operator.
+ */
+function museCronProhibitionSection() {
     return [
-        `This session has no Agent Deck and no MCP servers. The Task and Acceptance criteria above are the complete brief — if they only reference a ticket id you cannot look it up, so say so in your conclusion instead of guessing.`,
         `Never call \`cron_create\`, \`cron_list\` or \`cron_delete\` and never schedule anything: a session that does is failed and escalated to the operator.`,
         ``,
     ];
 }
-function agentDeckSection(worktreePath, deckId, noAgentDeck) {
-    if (noAgentDeck)
-        return noAgentDeckSection();
+function agentDeckSection(worktreePath, deckId) {
     if (!deckId || !worktreePath) {
         return [
             `This session is misconfigured: Agent Deck is required but missing. Stop and report the bootstrap failure — do not improvise without the deck.`,
@@ -88,7 +90,9 @@ export function buildDeveloperPrompt(input) {
         parts.push(``);
     }
     parts.push(...guidanceSection(input.guidance));
-    parts.push(...agentDeckSection(input.worktreePath, input.deckId, input.noAgentDeck));
+    parts.push(...agentDeckSection(input.worktreePath, input.deckId));
+    if (input.museDeveloper)
+        parts.push(...museCronProhibitionSection());
     parts.push(`## Required`, 
     // NOT-115: encourage incremental commits so a mid-session death leaves less
     // uncommitted work for dirty_worktree escalation — soft mitigation only.

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

@@ -230,17 +230,25 @@ test("reviewer prompt deck section requires bind_workspace first, matching the d
     assert.match(prompt, /do not web-fetch Linear/);
     assert.doesNotMatch(prompt, /get_playbook\(/);
 });
-// NOT-181: a Muse Code worker has no Agent Deck, so it must not be told the session is
-// misconfigured (the deckless default) nor to bind a deck; it is told never to touch cron_*.
-test("NOT-181: noAgentDeck prompt states there is no deck/MCP and forbids cron_* instead of the misconfigured stop", () => {
-    const prompt = buildDeveloperPrompt({ taskSnapshot, round: 1, noAgentDeck: true, deckId: null, worktreePath: "/wt" });
-    assert.match(prompt, /no Agent Deck and no MCP servers/);
+// NOT-278: a Muse Code developer gets the standard Agent Deck bootstrap gate plus the
+// Muse-specific cron_* prohibition (detected post-run as muse_cron_used).
+test("NOT-278: museDeveloper prompt carries the standard deck bootstrap and forbids cron_*", () => {
+    const prompt = buildDeveloperPrompt({ taskSnapshot, round: 1, deckId: "deck-1", worktreePath: "/wt", museDeveloper: true });
+    assert.match(prompt, /bind_workspace\(\{ deckId: "deck-1", workspaceRoot: "\/wt" \}\)/);
+    assert.match(prompt, /bootstrap is a hard gate/i);
+    assert.match(prompt, /do not improvise without the deck/i);
+    assert.match(prompt, /call_service_tool/);
     assert.match(prompt, /cron_create/);
-    assert.doesNotMatch(prompt, /misconfigured/);
-    assert.doesNotMatch(prompt, /bind_workspace/);
+    assert.match(prompt, /cron_list/);
+    assert.match(prompt, /cron_delete/);
     assert.match(prompt, /do NOT push and do NOT open a pull request/);
 });
-test("NOT-181: without noAgentDeck a deckless prompt still fails closed", () => {
+test("NOT-278: a non-Muse developer prompt has the deck bootstrap but no cron prohibition", () => {
+    const prompt = buildDeveloperPrompt({ taskSnapshot, round: 1, deckId: "deck-1", worktreePath: "/wt" });
+    assert.match(prompt, /bind_workspace/);
+    assert.doesNotMatch(prompt, /cron_create/);
+});
+test("a deckless developer prompt still fails closed", () => {
     const prompt = buildDeveloperPrompt({ taskSnapshot, round: 1, deckId: null });
     assert.match(prompt, /misconfigured: Agent Deck is required but missing/);
 });

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

@@ -72,6 +72,7 @@ export function routeDeveloperOutcome(outcome, limits) {
                 next: "human_action",
                 actionType: "policy_escalation",
                 reason: `${outcome.reason} Recovery:\n${outcome.recoveryCommands.join("\n")}`,
+                ...(outcome.fingerprint ? { blockerFingerprint: outcome.fingerprint } : {}),
             };
         case "muse_cron_used":
             // Spends no budget and never retries: a policy breach the operator must look at, like a

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

@@ -99,6 +99,26 @@ test("worktree conflict always escalates immediately — never retried, regardle
     assert.match(reason, /old-session-developer/);
     assert.match(reason, /git status/);
 });
+test("NOT-280: worktree_conflict carries its blocker fingerprint through routing and projection to the action effect", async () => {
+    const { projectDeveloperRoute } = await import("./projection.js");
+    const outcome = {
+        kind: "worktree_conflict",
+        path: "/data/worktrees/old-session-developer",
+        reason: "Automatic salvage failed: git commit failed: hook rejected",
+        recoveryCommands: ["git status"],
+        fingerprint: "fp-1",
+    };
+    const result = routeDeveloperOutcome(outcome, REVIEW_ROUNDS_LEFT);
+    assert.equal(result.next, "human_action");
+    assert.equal(result.blockerFingerprint, "fp-1");
+    const { effect, advance } = projectDeveloperRoute(result, "developing", 1);
+    assert.equal(advance, "none", "a worktree blocker never spends any budget");
+    assert.equal(effect.kind, "human_action");
+    assert.equal(effect.blockerFingerprint, "fp-1");
+    const { fingerprint: _omit, ...legacy } = outcome;
+    const plain = routeDeveloperOutcome(legacy, REVIEW_ROUNDS_LEFT);
+    assert.equal("blockerFingerprint" in plain, false);
+});
 test("NOT-127: live_owner retries on the infra budget — never escalates as worktree_conflict", () => {
     const outcome = {
         kind: "live_owner",

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

@@ -37,7 +37,8 @@ export const realDeveloperSpawn = async (input) => {
     // any child process exists (the effect reports it as "could not start").
     assertWorktreeCwd(input.cwd);
     if (input.runtime === "muse_code") {
-        // Own argv, per-attempt XDG dirs and result parsing; deck/MCP are never wired for Muse.
+        // NOT-278: isolated deck-configured exec attempt (prepareMuseAttempt); the shared serve
+        // lane cannot carry per-session deck/workspace identity, so it is never used here.
         return runMuseDeveloperSession({
             ...input,
             maxModelSteps: input.maxModelSteps ?? undefined,

package/bundle/server/dist/coordinator/worktree-owner-liveness.js

@@ -70,6 +70,10 @@ function sessionLooksLive(session) {
  *
  * Returns alive if **any** candidate session for this path is live — basename predecessor
  * and every `worktree_path` match (see {@link listWorkerSessionsOwningWorktree}).
+ *
+ * NOT-280: a dead verdict names the most recently created candidate — the predecessor
+ * whose dirt a resume salvage is attributed to. No candidate at all stays a bare dead
+ * verdict (unknown owner), which keeps dirt on the fail-closed conflict path.
  */
 export function checkDeveloperWorktreeOwnerLiveness(worktreePath) {
     const candidates = listWorkerSessionsOwningWorktree(worktreePath);
@@ -78,5 +82,6 @@ export function checkDeveloperWorktreeOwnerLiveness(worktreePath) {
             return { state: "alive", sessionId: session.id };
         }
     }
-    return { state: "dead" };
+    const latest = [...candidates].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+    return latest ? { state: "dead", sessionId: latest.id } : { state: "dead" };
 }

package/bundle/server/dist/coordinator/worktree-owner-liveness.test.js

@@ -137,7 +137,8 @@ test("checkDeveloperWorktreeOwnerLiveness: terminal session with a dead pid is d
     patchRunningSession(session.id, { worktreePath: wt });
     recordSessionProcess(session.id, pid, COORDINATOR_PROCESS_OWNER, startTime);
     completeSession(session.id, { status: "failed", errorJson: JSON.stringify({ reason: "gone" }) });
-    assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), { state: "dead" });
+    // NOT-280: a proven-dead owner is named so a resume salvage can be tied to it.
+    assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), { state: "dead", sessionId: session.id });
 });
 test("checkDeveloperWorktreeOwnerLiveness: unknown path with no session is dead", () => {
     assert.deepEqual(checkDeveloperWorktreeOwnerLiveness("/repo/.agent-dealer-worktrees/no-such-session-developer"), { state: "dead" });

package/bundle/server/dist/repository/human-actions.js

@@ -144,6 +144,19 @@ export function updateOpenHumanAction(id, patch) {
         .run(patch.reason ?? null, patch.question ?? null, patch.evidence !== undefined ? JSON.stringify(patch.evidence) : null, id);
     return getHumanAction(id);
 }
+/**
+ * NOT-280: put a resolved action back to open, unchanged — used when a Resume ran into the
+ * exact same blocker again, so the operator keeps one action instead of an identical copy.
+ * Only touches resolved rows; returns null otherwise.
+ */
+export function reopenHumanAction(id) {
+    const info = getDb()
+        .prepare(`UPDATE human_actions SET
+        status = 'open', resolution_json = NULL, resolved_by = NULL, resolved_at = NULL
+      WHERE id = ? AND status = 'resolved'`)
+        .run(id);
+    return info.changes === 0 ? null : getHumanAction(id);
+}
 /** Run-scoped equivalent of `findOpenHumanAction` (NOT-95 — outbound-draft delivery
  * parking has no Issue). */
 export function findOpenHumanActionForRun(runId, actionType) {

package/bundle/server/dist/routes/index.js

@@ -12,6 +12,7 @@ import { refreshMuseCapacityIfStale } from "../capacity/muse-probe.js";
 import { refreshCodexCapacityIfStale } from "../capacity/codex-app-server.js";
 import { getCursorTeamBillingSnapshot, refreshCursorTeamBillingIfStale, } from "../capacity/cursor-team.js";
 import { getCursorIndividualBillingSnapshot, refreshCursorIndividualBillingIfStale, refreshCursorIndividualCapacityIfStale, } from "../capacity/cursor-individual.js";
+import { registerVersionRoute } from "./version.js";
 async function resolveDeckName(deckId) {
     if (!deckId)
         return null;
@@ -22,6 +23,7 @@ async function resolveDeckName(deckId) {
 }
 export async function registerRoutes(app) {
     app.get("/health", async () => ({ ok: true }));
+    registerVersionRoute(app);
     // NOT-159: process-lifetime Linear GraphQL counters (API-key bucket diagnostics).
     app.get("/api/debug/linear-usage", async () => getLinearUsageSnapshot());
     app.get("/api/runtimes/:runtime/models", async (req, reply) => {
@@ -77,14 +79,15 @@ export async function registerRoutes(app) {
     // NOT-268: Claude local-first ladder — one background refresh ingests
     // Claude Code's own free cache (plain file read, never a spawn) and then
     // considers the free `/usage` refresh without blocking the read: a
-    // bounded `claude -p "/usage"` call fires at most once per hour, only
-    // when every valid 5H/1W observation is older than 60 minutes, and only
-    // when enabled (default on; `AGENT_DEALER_CLAUDE_CAPACITY_REFRESH=off`
-    // disables it). `/usage` is a local slash-command — no model call, $0
-    // cost, ~300ms, verified live 2026-09-27 (the original design spawned a
-    // real model turn and was fixed after a live proof showed it never
-    // worked; see docs/RUNTIME_CAPACITY.md). Failures never break the read
-    // below.
+    // bounded `claude -p "/usage"` call fires at most once per 14 minutes,
+    // only when either valid 5H/1W observation is missing or at least 14
+    // minutes old (NOT-281 — checked per window so a fresh sibling never
+    // suppresses its stale twin), and only when enabled (default on;
+    // `AGENT_DEALER_CLAUDE_CAPACITY_REFRESH=off` disables it). `/usage` is a
+    // local slash-command — no model call, $0 cost, ~300ms, verified live
+    // 2026-09-27 (the original design spawned a real model turn and was
+    // fixed after a live proof showed it never worked; see
+    // docs/RUNTIME_CAPACITY.md). Failures never break the read below.
     app.get("/api/runtime-capacity", async () => {
         try {
             void refreshClaudeCapacityIfStale().catch(() => {

package/bundle/server/dist/routes/version.js

@@ -0,0 +1,30 @@
+// packages/server/src/routes/version.ts
+//
+// NOT-279: the running backend reports its own version. The CLI's installed version (and
+// the managed `current` symlink) can move ahead of a server that is still serving the old
+// build, so `agent-dealer status` must ask the live process instead of inferring from disk.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Read once at module load: the package this process was started from, not whatever is on
+ * disk later (a managed update may replace sibling install dirs while we keep running). */
+function readServerPackageVersion() {
+    try {
+        // src/routes/version.ts and dist/routes/version.js both sit two levels below package.json.
+        const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+const RUNNING_VERSION = readServerPackageVersion();
+const STARTED_AT = new Date().toISOString();
+export function registerVersionRoute(app) {
+    app.get("/api/version", async () => ({
+        version: RUNNING_VERSION,
+        pid: process.pid,
+        startedAt: STARTED_AT,
+    }));
+}

package/bundle/server/dist/routes/version.test.js

@@ -0,0 +1,21 @@
+// packages/server/src/routes/version.test.ts
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Fastify from "fastify";
+import { registerVersionRoute } from "./version.js";
+test("NOT-279: /api/version reports the running server package version and pid", async () => {
+    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    const expected = JSON.parse(fs.readFileSync(pkgPath, "utf8")).version;
+    const app = Fastify();
+    registerVersionRoute(app);
+    const res = await app.inject({ method: "GET", url: "/api/version" });
+    assert.equal(res.statusCode, 200);
+    const body = res.json();
+    assert.equal(body.version, expected);
+    assert.equal(body.pid, process.pid);
+    assert.ok(!Number.isNaN(Date.parse(body.startedAt)));
+    await app.close();
+});