agent-dealer 1.2.7 → 1.2.9

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

@@ -151,7 +151,12 @@ function fakeGithub(opts = {}) {
             if (number == null && !branch) {
                 throw new Error("fakeGithub.checksSnapshot requires an explicit number or branch — bare checks lookup is the NOT-82 bug");
             }
-            return opts.checks ?? "success";
+            // NOT-311: a function lets one test flip CI mid-wait (pending → success) so the
+            // deferred re-poll can prove the wait closes without a fresh agent session.
+            return typeof opts.checks === "function" ? opts.checks() : (opts.checks ?? "success");
+        },
+        async hasPullRequestWorkflow() {
+            return opts.pullRequestWorkflow ?? null;
         },
         async publishReview() {
             throw new Error("publishReview is unused by the developer effect");
@@ -530,6 +535,8 @@ test("checks_failed: CI failure after a clean push/PR retries without a human ac
     await pump(1);
     const issue = getIssue(issueId);
     assert.equal(issue.status, "developing");
+    assert.equal(issue.ciAttempts, 1, "a checks_failed retry spends the CI budget");
+    assert.equal(issue.infraAttempts, 0, "a checks_failed retry never touches the infra budget");
     assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer").length, 0);
     const kinds = listArtifactsForIssue(issueId).map((a) => a.kind);
     const evidence = listArtifactsForIssue(issueId).find((a) => a.kind === "checks_evidence");
@@ -540,12 +547,159 @@ test("checks_failed: CI failure after a clean push/PR retries without a human ac
     assert.ok(kinds.includes("implementation_conclusion"), "conclusion must survive a post-session verification failure");
     assert.ok(kinds.includes("developer_transcript"), "raw trace must survive a post-session verification failure");
 });
-test("timed_out (checks poll): checks stay pending past the poll deadline", async () => {
+test("NOT-311: checks_pending — checks still pending at the poll deadline defers, spending no attempt", async () => {
+    // Previously this returned `timed_out`, spending an infra attempt on a session that
+    // had already ended cleanly. Now the item waits on backoff and re-polls.
     const issueId = await makeIssue();
     registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github: fakeGithub({ checks: "pending" }) }));
     startWorkflow(issueId);
     await pump(1);
+    const issue = getIssue(issueId);
+    assert.equal(issue.status, "developing");
+    assert.equal(issue.infraAttempts, 0, "a CI wait spends no infra attempt");
+    assert.equal(issue.currentRound, 1, "a CI wait must not spend a review round");
+    assert.match(issue.currentIntent ?? "", /Waiting for CI \(running\) - no attempt spent/);
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer").length, 0, "no review handoff on unverified CI");
+    const items = listWorkItemsForIssue(issueId);
+    assert.equal(items.length, 1);
+    assert.equal(items[0].status, "pending", "the item waits, it is not finished or dead-lettered");
+    assert.equal(items[0].attemptCount, 0, "the claim-time attempt bump is reverted");
+    assert.ok(Date.parse(items[0].availableAt) > Date.parse(items[0].updatedAt), "the re-poll is gated behind a backoff");
+    const deferredPayload = JSON.parse(items[0].payloadJson ?? "{}");
+    assert.equal(deferredPayload.publishOnly, true, "the re-poll takes the no-agent publish path, not a fresh spawn");
+    assert.equal(deferredPayload.branch, issueBranchName(issueId));
+    assert.ok(deferredPayload.checksWaitStartedAt, "the wait anchors its ceiling at the first poll");
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0);
+    const events = listWorkflowEventsForIssue(issueId);
+    const deferrals = events.filter((e) => e.type === "worker.deferred");
+    assert.ok(deferrals.length > 0);
+    assert.equal(JSON.parse(deferrals[0].payloadJson ?? "{}").outcome, "checks_pending");
+    assert.equal(events.some((e) => e.type === "worker.failed"), false, "a CI wait is not a failure");
+    const completed = events.find((e) => e.type === "checks.completed");
+    assert.ok(completed, "the wait still records a checks.completed milestone");
+    assert.equal(JSON.parse(completed.payloadJson ?? "{}").snapshot, "timeout");
+});
+test("NOT-311: the deferred CI wait re-polls through publish-only and hands off once CI passes", async () => {
+    // First run waits (pending), the deferred re-poll sees success and reaches review —
+    // all without spawning a second agent session and without spending infra attempts.
+    let ci = "pending";
+    let spawns = 0;
+    const countingSpawn = async (input) => {
+        spawns++;
+        return commitingSpawn(input);
+    };
+    // A short backoff (set before the first deferral computes its `until`) lets the
+    // second pump actually pick the waiting item back up.
+    const prevBase = process.env.DECK_OUTAGE_BACKOFF_BASE_MS;
+    const prevMax = process.env.DECK_OUTAGE_BACKOFF_MAX_MS;
+    process.env.DECK_OUTAGE_BACKOFF_BASE_MS = "10";
+    process.env.DECK_OUTAGE_BACKOFF_MAX_MS = "10";
+    try {
+        const issueId = await makeIssue();
+        registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: countingSpawn, github: fakeGithub({ checks: () => ci }) }));
+        startWorkflow(issueId);
+        await pump(1);
+        assert.equal(getIssue(issueId).status, "developing");
+        assert.equal(getIssue(issueId).infraAttempts, 0);
+        const deferred = listWorkItemsForIssue(issueId)[0];
+        assert.equal(deferred.status, "pending");
+        // Fast-forward past the deferral backoff, then let CI pass.
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        ci = "success";
+        await pump(1);
+        const issue = getIssue(issueId);
+        assert.equal(issue.status, "reviewing", "the re-poll hands off once CI passes");
+        assert.equal(issue.infraAttempts, 0, "waiting plus a passing re-poll still spends nothing");
+        assert.equal(spawns, 1, "the re-poll must not spawn a second agent session");
+        assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer" && i.status === "pending").length, 1);
+    }
+    finally {
+        if (prevBase === undefined)
+            delete process.env.DECK_OUTAGE_BACKOFF_BASE_MS;
+        else
+            process.env.DECK_OUTAGE_BACKOFF_BASE_MS = prevBase;
+        if (prevMax === undefined)
+            delete process.env.DECK_OUTAGE_BACKOFF_MAX_MS;
+        else
+            process.env.DECK_OUTAGE_BACKOFF_MAX_MS = prevMax;
+    }
+});
+test("NOT-311: none with a pull_request workflow on the base waits (no review handoff)", async () => {
+    const issueId = await makeIssue();
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github: fakeGithub({ checks: "none", pullRequestWorkflow: true }) }));
+    startWorkflow(issueId);
+    await pump(1);
+    const issue = getIssue(issueId);
+    assert.equal(issue.status, "developing");
+    assert.equal(issue.infraAttempts, 0, "an unregistered-CI wait spends no infra attempt");
+    assert.match(issue.currentIntent ?? "", /Waiting for CI \(queued\) - no attempt spent/);
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer").length, 0, "no review handoff on 'no checks yet'");
+    const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
+    assert.ok(completed);
+    const payload = JSON.parse(completed.payloadJson ?? "{}");
+    assert.equal(payload.snapshot, "none");
+    assert.equal(payload.reason, "none_with_workflow");
+});
+test("NOT-311: none with no pull_request workflow on the base proceeds as today", async () => {
+    const issueId = await makeIssue();
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github: fakeGithub({ checks: "none", pullRequestWorkflow: false }) }));
+    startWorkflow(issueId);
+    await pump(1);
+    const issue = getIssue(issueId);
+    assert.equal(issue.status, "reviewing", "no configured CI still hands off");
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer" && i.status === "pending").length, 1);
+    const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
+    assert.ok(completed);
+    const payload = JSON.parse(completed.payloadJson ?? "{}");
+    assert.equal(payload.snapshot, "none");
+    assert.equal(payload.reason, "none_no_workflow");
+});
+test("NOT-311: none with an unknown workflow answer waits fail-closed", async () => {
+    // The adapter cannot read the base (or has no such method): 'no checks yet' must
+    // never read as a pass.
+    const issueId = await makeIssue();
+    const github = fakeGithub({ checks: "none", pullRequestWorkflow: null });
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github }));
+    startWorkflow(issueId);
+    await pump(1);
     assert.equal(getIssue(issueId).status, "developing");
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer").length, 0);
+    const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
+    assert.equal(JSON.parse(completed.payloadJson ?? "{}").reason, "none_with_workflow");
+});
+test("NOT-311: past CHECKS_WAIT_CEILING_MS the wait escalates naming the PR and head SHA", async () => {
+    // A zero ceiling makes the very first wait already past it — no clock to inject,
+    // no sleeping: the deferral reports escalated and a policy_escalation lands.
+    const prev = process.env.CHECKS_WAIT_CEILING_MS;
+    process.env.CHECKS_WAIT_CEILING_MS = "0";
+    try {
+        const issueId = await makeIssue();
+        registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github: fakeGithub({ checks: "pending" }) }));
+        startWorkflow(issueId);
+        await pump(1);
+        const issue = getIssue(issueId);
+        assert.equal(issue.status, "needs_human");
+        assert.equal(issue.infraAttempts, 0, "a ceiling escalation spends no infra attempt");
+        const actions = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+        assert.equal(actions.length, 1);
+        assert.equal(actions[0].actionType, "policy_escalation");
+        // The wait never hands off, so the issue row carries no PR/SHA — the milestone
+        // and the human action do.
+        const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
+        assert.ok(completed);
+        const msPayload = JSON.parse(completed.payloadJson ?? "{}");
+        assert.equal(msPayload.reason, "pending_ceiling");
+        assert.ok(msPayload.prNumber, "the milestone names the PR");
+        assert.ok(msPayload.headSha, "the milestone names the head SHA");
+        assert.match(actions[0].reason, new RegExp(`CI did not complete on ${msPayload.headSha}`));
+        assert.match(actions[0].reason, new RegExp(`PR #${msPayload.prNumber}`));
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.CHECKS_WAIT_CEILING_MS;
+        else
+            process.env.CHECKS_WAIT_CEILING_MS = prev;
+    }
 });
 test("NOT-255: a non-draft PR with otherwise-verified identity hands off cleanly (just-failed retry_merge)", async () => {
     // A merge-failure escalation is reachable from `retry_merge`, which undrafts the PR
@@ -2079,7 +2233,9 @@ test("NOT-252: checks_failed enriches checks_evidence and the retry prompt with
     registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: evolvingSpawn, github }));
     startWorkflow(issueId);
     await pump(1);
-    assert.equal(getIssue(issueId).status, "developing", "enriched checks_failed still retries on the infra budget");
+    assert.equal(getIssue(issueId).status, "developing", "enriched checks_failed still retries on the CI budget");
+    assert.equal(getIssue(issueId).ciAttempts, 1, "the enriched retry spends ci_attempts");
+    assert.equal(getIssue(issueId).infraAttempts, 0, "the enriched retry leaves infra_attempts alone");
     const evidence = listArtifactsForIssue(issueId).find((a) => a.kind === "checks_evidence");
     assert.ok(evidence, "enriched checks_failed persists checks_evidence");
     const content = JSON.parse(evidence.contentJson);
@@ -2138,3 +2294,132 @@ test("NOT-252: publish-only retry on checks_failed enriches evidence and the nex
     assert.match(prompts[1], /publish-checks/);
     assert.match(prompts[1], /is not in this registry/);
 });
+test("NOT-313: three CI repair attempts then a CI-specific escalation — infra_attempts stays 0", async () => {
+    // Exit-predicate loop: the CI budget (default 3) buys three repair attempts;
+    // the fourth consecutive checks_failed escalates with a CI-specific reason.
+    const issueId = await makeIssue();
+    const prompts = [];
+    let call = 0;
+    const evolvingSpawn = async (input) => {
+        call++;
+        prompts.push(input.prompt);
+        fs.writeFileSync(path.join(input.cwd, "feature.txt"), `implemented attempt ${call}\n`);
+        git(input.cwd, "add", ".");
+        git(input.cwd, "-c", "user.email=agent@test", "-c", "user.name=Agent", "commit", "-q", "-m", `implement ${call}`);
+        return { exitCode: 0, transcript: "Implementation conclusion: added the widget.", logPath: "/dev/null", timedOut: false };
+    };
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: evolvingSpawn, github: fakeGithub({ checks: "failure" }) }));
+    startWorkflow(issueId);
+    await pump(1); // failure #1 → CI repair attempt 1
+    assert.equal(getIssue(issueId).status, "developing");
+    assert.equal(getIssue(issueId).ciAttempts, 1);
+    assert.equal(getIssue(issueId).infraAttempts, 0);
+    await pump(1); // failure #2 → CI repair attempt 2
+    assert.equal(getIssue(issueId).status, "developing");
+    assert.equal(getIssue(issueId).ciAttempts, 2);
+    assert.equal(getIssue(issueId).infraAttempts, 0);
+    assert.match(prompts[1], /CI repair attempt 1 of 3/);
+    await pump(1); // failure #3 → CI repair attempt 3
+    assert.equal(getIssue(issueId).status, "developing");
+    assert.equal(getIssue(issueId).ciAttempts, 3);
+    assert.equal(getIssue(issueId).infraAttempts, 0);
+    assert.match(prompts[2], /CI repair attempt 2 of 3/);
+    await pump(1); // failure #4 → budget spent → escalate
+    const issue = getIssue(issueId);
+    assert.equal(issue.status, "needs_human");
+    assert.equal(issue.ciAttempts, 3, "the escalation itself spends no further CI attempt");
+    assert.equal(issue.infraAttempts, 0, "four CI failures never touched the infra budget");
+    assert.match(prompts[3], /CI repair attempt 3 of 3/);
+    const action = listHumanActionsForIssue(issueId).find((a) => a.status === "open");
+    assert.ok(action, "the exhausted CI budget raises a human action");
+    assert.equal(action.actionType, "policy_escalation");
+    assert.match(action.reason, /CI checks still failing after 3 repair attempts \(limit 3\)/);
+    assert.doesNotMatch(action.reason, /infra-attempt limit reached/);
+});
+test("NOT-315: a failing dependency install is a worktree-setup failure with the stderr tail — the session is not spawned", async () => {
+    // Hermetic repo: the shared fixture carries no package.json (so the step would skip
+    // before the runner is ever invoked), so this test cuts its own repo + remote whose
+    // main tip declares npm dependencies — the fresh worktree then really triggers the install.
+    const npmRepo = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-deveff-npm-repo-"));
+    const npmRemote = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-deveff-npm-remote-"));
+    try {
+        git(npmRepo, "init", "-q", "-b", "main");
+        git(npmRepo, "config", "user.email", "test@example.com");
+        git(npmRepo, "config", "user.name", "Test");
+        fs.writeFileSync(path.join(npmRepo, "README.md"), "hello\n");
+        fs.writeFileSync(path.join(npmRepo, "package.json"), JSON.stringify({ name: "wt", version: "1.0.0" }));
+        fs.writeFileSync(path.join(npmRepo, "package-lock.json"), JSON.stringify({ name: "wt", lockfileVersion: 3, packages: {} }));
+        git(npmRepo, "add", ".");
+        git(npmRepo, "commit", "-q", "-m", "init");
+        execFileSync("git", ["init", "-q", "--bare", "-b", "main", npmRemote]);
+        git(npmRepo, "remote", "add", "origin", npmRemote);
+        git(npmRepo, "push", "-q", "origin", "main");
+        const devAgent = createAgent({ name: `dev-${Math.random()}`, runtime: "claude_code", deckId: "00000000-0000-4000-a000-000000000099" });
+        const revAgent = createAgent({ name: `rev-${Math.random()}`, runtime: "claude_code", deckId: "00000000-0000-4000-a000-000000000099" });
+        const issueId = createIssue({
+            title: "Add widget",
+            description: "Build the widget.",
+            acceptanceCriteria: "Widget renders.",
+            repo: npmRepo,
+            baseBranch: "main",
+            developerAgentId: devAgent.id,
+            reviewerAgentId: revAgent.id,
+            maxReviewRounds: 3,
+            maxInfraAttempts: 3,
+            source: "manual"
+        }).id;
+        let spawnCalls = 0;
+        const neverSpawn = async () => {
+            spawnCalls++;
+            return { exitCode: 0, transcript: "", logPath: "/dev/null", timedOut: false };
+        };
+        let depsCalls = 0;
+        const failingDeps = async () => {
+            depsCalls++;
+            const err = new Error("npm ci exited");
+            err.stderr = "npm error code EAI_AGAIN\nnpm error registry unreachable (sandbox has no network)\n";
+            throw err;
+        };
+        registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: neverSpawn, github: fakeGithub(), depsRunner: failingDeps }));
+        startWorkflow(issueId);
+        await pump(1);
+        assert.equal(depsCalls, 1, "the worktree declares npm deps, so the install must run exactly once");
+        assert.equal(spawnCalls, 0, "the session must not spawn when dependency provisioning fails");
+        const issue = getIssue(issueId);
+        assert.equal(issue.status, "developing", "adapter_failure retries on the infra budget");
+        const dev = listWorkerSessionsForIssue(issueId).find((s) => s.role === "developer");
+        // adapter_failure never spawned, so the session row goes terminal (done) with the
+        // setup failure recorded as its reason — like every other adapter_failure.
+        assert.ok(dev.status === "done" || dev.status === "failed", `terminal session, got ${dev.status}`);
+        const reason = JSON.parse(dev.errorJson ?? "{}").reason ?? dev.errorJson ?? "";
+        assert.match(reason, /worktree setup failed/);
+        assert.match(reason, /dependency install failed: /);
+        assert.match(reason, /registry unreachable/);
+    }
+    finally {
+        fs.rmSync(npmRepo, { recursive: true, force: true });
+        fs.rmSync(npmRemote, { recursive: true, force: true });
+    }
+});
+test("NOT-315: a skipped dependency install still emits worktree.deps_ready with ran/skipped and durationMs", async () => {
+    // The fixture repo carries no package.json, so the step skips (no package.json) and
+    // the fake runner is never called — the milestone must still record the skip.
+    const issueId = await makeIssue();
+    let depsCalls = 0;
+    const countingDeps = async () => {
+        depsCalls++;
+        return { stdout: "", stderr: "" };
+    };
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, { deckCallTool: okDeckCallTool, spawn: commitingSpawn, github: fakeGithub(), depsRunner: countingDeps }));
+    startWorkflow(issueId);
+    await pump(1);
+    assert.equal(getIssue(issueId).status, "reviewing", "a skipped install must not block handoff");
+    assert.equal(depsCalls, 0, "no package.json means the runner is never invoked");
+    const { listWorkflowEventsForIssue: listEvents } = await import("../repository/workflow-events.js");
+    const depsEvent = listEvents(issueId).find((e) => e.type === "worktree.deps_ready");
+    assert.ok(depsEvent, "expected a worktree.deps_ready milestone");
+    const payload = JSON.parse(depsEvent.payloadJson);
+    assert.equal(payload.ran, false);
+    assert.match(String(payload.reason ?? ""), /no package\.json/);
+    assert.ok(typeof payload.durationMs === "number" && payload.durationMs >= 0);
+});

package/bundle/server/dist/coordinator/execution-report.js

@@ -151,6 +151,12 @@ export function classifyFailureReason(reason) {
     const text = (reason ?? "").trim();
     if (!text)
         return { code: "unknown", domain: "unknown", confidence: "low" };
+    // NOT-307: an idle-watchdog kill names itself ("made no progress … idle timeout").
+    // Checked before the timeout rules: the reason contains both "timeout" and "tool"
+    // ("last tool: …"), which would otherwise misread as tool_test_timeout.
+    if (/made no progress|killed on the idle timeout/i.test(text)) {
+        return { code: "muse_no_progress", domain: "infrastructure", confidence: "high" };
+    }
     // A bare timeout with no tool/test in flight is unknown by rule — do not guess.
     if (/timed? ?out|deadline/i.test(text) && !/tool|test|jest|vitest|pytest|subprocess|command/i.test(text)) {
         return { code: "unknown", domain: "unknown", confidence: "low" };

package/bundle/server/dist/coordinator/execution-report.test.js

@@ -88,6 +88,13 @@ test("classifier keeps ambiguous timeouts unknown", () => {
     assert.equal(classifyFailureReason(null).code, "unknown");
     assert.equal(classifyFailureReason("").code, "unknown");
 });
+test("NOT-307: classifier reads an idle-watchdog kill as muse_no_progress", () => {
+    const reason = "Developer session made no progress for 20 minutes. (last tool: npm_test) Killed on the idle timeout.";
+    const got = classifyFailureReason(reason);
+    assert.equal(got.code, "muse_no_progress");
+    assert.equal(got.domain, "infrastructure");
+    assert.equal(got.confidence, "high");
+});
 test("classifier anchors keep author/release/unrelated spawn out of buckets", () => {
     // `auth` must not match "author"; `lease` must not match "release"/"please".
     assert.equal(classifyFailureReason("the author released a fix").code, "unknown");

package/bundle/server/dist/coordinator/failure-cause.js

@@ -329,6 +329,27 @@ export function classifyAttemptFailure(input) {
             rawReason: rawReason || "Agent Deck failure.",
         });
     }
+    // NOT-307: an idle-watchdog kill is a specific, high-confidence infrastructure
+    // cause — never `unknown`. It sorts after log evidence (an auth/429 already on
+    // record names an earlier, more specific root cause for the same stall) but
+    // before the outcome-level timeout guess, so a hung tool/test in flight does not
+    // demote the stall to `tool_test_timeout`. The raw reason carries the idle
+    // minutes and the last tool name, reusing the recorded reason when it already
+    // names them (reasonForSessionCrash writes them at kill time).
+    if (input.idleTimedOut) {
+        const minutes = typeof input.idleForMs === "number" && Number.isFinite(input.idleForMs) && input.idleForMs >= 0
+            ? Math.max(1, Math.round(input.idleForMs / 60_000))
+            : null;
+        const alreadySpecific = /made no progress/i.test(rawReason);
+        signals.push({
+            code: "muse_no_progress",
+            confidence: "high",
+            evidenceSource: "outcome_kind",
+            rawReason: alreadySpecific
+                ? rawReason
+                : `Muse developer session made no progress${minutes !== null ? ` for ${minutes} minute${minutes === 1 ? "" : "s"}` : ""} (last tool: ${input.lastToolName ?? "none"}).${rawReason ? ` ${rawReason}` : ""}`,
+        });
+    }
     const outcomeSignal = detectOutcomeSignal(outcomeKind, rawReason, {
         timedOut,
         toolInFlight,
@@ -413,6 +434,36 @@ function agentCompletedEvidence(workerSessionId) {
     }
     return out;
 }
+/**
+ * NOT-307: idle-watchdog evidence read back out of `worker_sessions.metadata_json`
+ * (written by the developer effect for every Muse session). Silence duration is
+ * measured against `occurredAtMs` — the kill/completion time — from the recorded
+ * `lastActivityAt`. Anything unparseable reads as no idle evidence, never a throw.
+ */
+export function museStallFromMetadata(metadataJson, occurredAtMs) {
+    const none = { idleTimedOut: false, idleForMs: null, lastToolName: null };
+    if (!metadataJson)
+        return none;
+    try {
+        const parsed = JSON.parse(metadataJson);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return none;
+        const rec = parsed;
+        if (rec.idleTimedOut !== true)
+            return none;
+        const lastToolName = typeof rec.lastToolName === "string" ? rec.lastToolName : null;
+        let idleForMs = null;
+        if (occurredAtMs !== null && Number.isFinite(occurredAtMs) && typeof rec.lastActivityAt === "string") {
+            const at = Date.parse(rec.lastActivityAt);
+            if (Number.isFinite(at) && occurredAtMs >= at)
+                idleForMs = occurredAtMs - at;
+        }
+        return { idleTimedOut: true, idleForMs, lastToolName };
+    }
+    catch {
+        return none;
+    }
+}
 /**
  * Backfill-on-read for legacy rows: classify from existing session error/log
  * evidence without mutating any append-only event. Always quality "inferred" —
@@ -421,6 +472,9 @@ function agentCompletedEvidence(workerSessionId) {
 export function backfillCausesForSession(session, opts) {
     const agent = agentCompletedEvidence(session.id);
     const outcomeKind = opts?.outcomeKind ?? null;
+    const occurredAt = opts?.occurredAt ?? session.completedAt ?? session.updatedAt;
+    const occurredAtMs = occurredAt ? Date.parse(occurredAt) : NaN;
+    const stall = museStallFromMetadata(session.metadataJson ?? null, Number.isFinite(occurredAtMs) ? occurredAtMs : null);
     return classifyAttemptFailure({
         outcomeKind,
         sessionErrorJson: session.errorJson,
@@ -428,8 +482,11 @@ export function backfillCausesForSession(session, opts) {
         runtime: session.runtime,
         exitCode: session.exitCode ?? agent.exitCode,
         timedOut: outcomeKind === "timed_out" || agent.timedOut,
+        idleTimedOut: stall.idleTimedOut || undefined,
+        idleForMs: stall.idleForMs,
+        lastToolName: stall.lastToolName,
         hostSuspended: agent.hostSuspended,
-        occurredAt: opts?.occurredAt ?? session.completedAt ?? session.updatedAt,
+        occurredAt,
         eventCursor: opts?.eventCursor ?? null,
         sessionId: session.id,
         eventId: opts?.eventId ?? null,
@@ -449,6 +506,9 @@ export function recordCausesForWorkerFailedEvent(opts) {
         const session = opts.event.workerSessionId ? getWorkerSession(opts.event.workerSessionId) : null;
         const agent = agentCompletedEvidence(opts.event.workerSessionId);
         const outcomeTimedOut = opts.outcomeKind === "timed_out";
+        const occurredAtMs = Date.parse(opts.event.ts);
+        // NOT-307: an idle kill's stall evidence rides on the session row's metadata.
+        const stall = museStallFromMetadata(session?.metadataJson ?? null, Number.isFinite(occurredAtMs) ? occurredAtMs : null);
         const causes = classifyAttemptFailure({
             outcomeKind: opts.outcomeKind,
             outcomeReason: opts.outcomeReason,
@@ -458,6 +518,9 @@ export function recordCausesForWorkerFailedEvent(opts) {
             runtime: session?.runtime ?? undefined,
             exitCode: session?.exitCode ?? agent.exitCode,
             timedOut: outcomeTimedOut || agent.timedOut,
+            idleTimedOut: stall.idleTimedOut || undefined,
+            idleForMs: stall.idleForMs,
+            lastToolName: stall.lastToolName,
             hostSuspended: agent.hostSuspended,
             recovery: opts.recovery,
             occurredAt: opts.event.ts,

package/bundle/server/dist/coordinator/failure-cause.test.js

@@ -8,7 +8,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { classifyAttemptFailure, orderAttemptCauses, } from "./failure-cause.js";
+import { backfillCausesForSession, classifyAttemptFailure, museStallFromMetadata, orderAttemptCauses, } from "./failure-cause.js";
 import { PRESUMED_DEAD_REASON } from "./failure-reason.js";
 function writeLog(body) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-failure-cause-"));
@@ -274,6 +274,97 @@ test("reclaimed session with provider/auth log evidence keeps it primary", () =>
     assert.equal(reclaimedAuth[0].primary, true);
     assert.equal(reclaimedAuth.find((c) => c.code === "coordinator_crash")?.primary, false);
 });
+// NOT-307: an idle-watchdog kill classifies as muse_no_progress (infrastructure,
+// high confidence) instead of unknown — with the idle minutes and last tool name
+// in the raw reason — even when a tool was in flight (a hung tool is still a stall).
+test("idle-watchdog kill classifies as muse_no_progress, not unknown", () => {
+    const idle = primary(classifyAttemptFailure({
+        outcomeKind: "timed_out",
+        outcomeReason: "Developer session made no progress for 20 minutes. (last tool: npm_test) Killed on the idle timeout.",
+        timedOut: true,
+        idleTimedOut: true,
+        idleForMs: 20 * 60_000,
+        lastToolName: "npm_test",
+    }));
+    assert.equal(idle.code, "muse_no_progress");
+    assert.equal(idle.domain, "infrastructure");
+    assert.equal(idle.confidence, "high");
+    assert.match(idle.rawReason, /20 minutes/);
+    assert.match(idle.rawReason, /npm_test/);
+});
+test("idle kill beats the tool_test_timeout guess and the unknown fallback", () => {
+    // A hung test in flight plus an idle kill: still the stall, not the tool timeout.
+    const hungTool = primary(classifyAttemptFailure({
+        outcomeKind: "timed_out",
+        outcomeReason: "vitest run timed out after 30000ms",
+        timedOut: true,
+        toolInFlight: true,
+        idleTimedOut: true,
+        idleForMs: 21 * 60_000,
+        lastToolName: "vitest",
+    }));
+    assert.equal(hungTool.code, "muse_no_progress");
+    // A bare timed_out with no idle evidence still classifies as before (unknown here).
+    const plain = primary(classifyAttemptFailure({ outcomeKind: "timed_out", timedOut: true }));
+    assert.equal(plain.code, "unknown");
+});
+test("idle kill composes the reason when the recorded text lacks minutes and tool", () => {
+    const composed = primary(classifyAttemptFailure({
+        outcomeKind: "timed_out",
+        outcomeReason: "Developer session timed out.",
+        timedOut: true,
+        idleTimedOut: true,
+        idleForMs: 22 * 60_000,
+        lastToolName: null,
+    }));
+    assert.equal(composed.code, "muse_no_progress");
+    assert.match(composed.rawReason, /22 minutes/);
+    assert.match(composed.rawReason, /last tool: none/);
+    assert.match(composed.rawReason, /Developer session timed out\./);
+});
+// NOT-307: stall evidence round-trips through worker_sessions.metadata_json —
+// the record/backfill paths read the same five fields the developer effect wrote.
+test("museStallFromMetadata reads idle evidence, and ignores anything else", () => {
+    const at = Date.parse("2026-10-01T19:40:00.000Z");
+    const stall = museStallFromMetadata(JSON.stringify({
+        lastActivityAt: "2026-10-01T19:20:00.000Z",
+        toolCallCount: 24,
+        lastToolName: "npm_test",
+        firstOutputMs: 900,
+        idleTimedOut: true,
+    }), at);
+    assert.equal(stall.idleTimedOut, true);
+    assert.equal(stall.idleForMs, 20 * 60_000);
+    assert.equal(stall.lastToolName, "npm_test");
+    assert.deepEqual(museStallFromMetadata(null, at).idleTimedOut, false);
+    assert.deepEqual(museStallFromMetadata("not-json{", at).idleTimedOut, false);
+    assert.deepEqual(museStallFromMetadata(JSON.stringify({ idleTimedOut: false }), at).idleTimedOut, false, "a clean session's metadata is not idle evidence");
+    assert.deepEqual(museStallFromMetadata(JSON.stringify({ idleTimedOut: true }), null).idleForMs, null, "no kill time means no measured silence");
+});
+test("backfill over an idle-kill row classifies muse_no_progress", () => {
+    const causes = backfillCausesForSession({
+        id: "s-idle-backfill",
+        errorJson: JSON.stringify({
+            reason: "Developer session made no progress for 20 minutes. (last tool: npm_test) Killed on the idle timeout.",
+        }),
+        logPath: null,
+        runtime: "muse_code",
+        exitCode: 124,
+        completedAt: "2026-10-01T19:40:00.000Z",
+        updatedAt: "2026-10-01T19:40:00.000Z",
+        metadataJson: JSON.stringify({
+            lastActivityAt: "2026-10-01T19:20:00.000Z",
+            toolCallCount: 24,
+            lastToolName: "npm_test",
+            firstOutputMs: 900,
+            idleTimedOut: true,
+        }),
+    }, { outcomeKind: "timed_out" });
+    const found = primary(causes);
+    assert.equal(found.code, "muse_no_progress");
+    assert.equal(found.quality, "inferred");
+    assert.match(found.rawReason, /20 minutes/);
+});
 test("usage-capped and tool-timeout evidence map to capacity/task", () => {
     const capped = primary(classifyAttemptFailure({ outcomeKind: "usage_capped", outcomeReason: "claude_code usage capped — plan limit rejected" }));
     assert.equal(capped.code, "provider_capacity_rate_limit");

package/bundle/server/dist/coordinator/failure-reason.js

@@ -184,6 +184,13 @@ export function reasonForSessionCrash(opts) {
     const classified = classifyRunnerLogFailure(opts.logPath, opts.runtime);
     if (classified)
         return classified;
+    if (opts.timedOut && opts.idle) {
+        const mins = typeof opts.idle.minutes === "number" && Number.isFinite(opts.idle.minutes)
+            ? ` for ${opts.idle.minutes} minute${opts.idle.minutes === 1 ? "" : "s"}`
+            : "";
+        const tool = opts.idle.lastToolName ? ` (last tool: ${opts.idle.lastToolName})` : " (no tool call seen)";
+        return `Developer session made no progress${mins}.${tool} Killed on the idle timeout.`;
+    }
     return opts.timedOut ? "Developer session timed out." : "Developer session failed or crashed.";
 }
 function outcomeExplicitReason(outcome) {

package/bundle/server/dist/coordinator/failure-reason.test.js

@@ -206,6 +206,20 @@ test("NOT-133: a worker.failed event for an auth death carries the auth reason",
 test("reasonForSessionCrash falls back when log is clean", () => {
     assert.equal(reasonForSessionCrash({ timedOut: false, logPath: writeLog('{"type":"result"}\n') }), "Developer session failed or crashed.");
 });
+test("NOT-307: reasonForSessionCrash names the idle minutes and last tool on an idle kill", () => {
+    assert.equal(reasonForSessionCrash({
+        timedOut: true,
+        logPath: writeLog('{"type":"result"}\n'),
+        idle: { minutes: 20, lastToolName: "npm_test" },
+    }), "Developer session made no progress for 20 minutes. (last tool: npm_test) Killed on the idle timeout.");
+    assert.equal(reasonForSessionCrash({
+        timedOut: true,
+        logPath: writeLog('{"type":"result"}\n'),
+        idle: { minutes: null, lastToolName: null },
+    }), "Developer session made no progress. (no tool call seen) Killed on the idle timeout.");
+    // Wall-clock timeouts read exactly as before when no idle info is given.
+    assert.equal(reasonForSessionCrash({ timedOut: true, logPath: writeLog('{"type":"result"}\n') }), "Developer session timed out.");
+});
 test("parseErrorJsonReason reads recovery presumed-dead shape", () => {
     assert.equal(parseErrorJsonReason(JSON.stringify({ reason: PRESUMED_DEAD_REASON })), PRESUMED_DEAD_REASON);
 });