agent-dealer 1.2.9 → 1.2.10

package/bundle/server/dist/coordinator/merge-conflict-sync.js

@@ -16,6 +16,16 @@
 // dismiss the approval the merge depended on in repos with dismiss-stale-
 // approvals; that retry failure then takes this same direct-escalation path.
 //
+// NOT-354 adds a second entry point, `checks_wait`: a developer PR that conflicts
+// with its base while Dealer waits for CI never gets checks (GitHub creates no
+// merge ref), so the developer effect runs this same sync instead of deferring
+// "Waiting for CI (queued)" forever. That entry stops at the push (no checks
+// poll, no merge retry — the deferred CI wait re-polls the pushed head) and does
+// not queue the repair round itself: the effect still holds its work item's
+// lease, so applyCompletion queues it through {@link queueConflictRepairRound}
+// while finishing that item. One sync per episode there too — a later conflict
+// after a checks-wait sync earns the repair round, never a second sync.
+//
 // Bound: at most one automatic sync + one conflict-repair round per
 // merge-failure episode. The episode resets on any resolved human action (a
 // retry_merge / repair click starts a fresh episode); the repair-spent marker is
@@ -38,7 +48,7 @@ import { MERGE_CONFLICT_FILES_EVIDENCE_KEY, MERGE_FAILURE_EVIDENCE_KEY, } from "
 import { getAgent } from "../repository/agents.js";
 import { getDb } from "../db/index.js";
 import { getIssue, incrementIssueRound, transitionIssue } from "../repository/issues.js";
-import { enqueueWorkItem, listWorkItemsForIssue, } from "../repository/work-items.js";
+import { enqueueWorkItem, finishWorkItem, listWorkItemsForIssue, } from "../repository/work-items.js";
 import { appendWorkflowEvent, getActiveWorkflowInstance, listWorkflowEventsForIssue, } from "../repository/workflow-events.js";
 import { addWorktree, DEFAULT_BASE_FETCH_TIMEOUT_MS, fastForwardLocalBranchToSha, fetchFreshBase, fetchReusedBranch, findWorktreeForBranch, isAncestor, isWorktreeClean, pruneWorktrees, removeWorktree, revParseHead, safeRemoveWorktree, } from "../adapters/git-worktree.js";
 import { classifyIssueRepo, worktreesRootForResolution, } from "../adapters/managed-repo.js";
@@ -180,6 +190,32 @@ export function conflictRepairSpent(issueId, instanceId) {
         ? { spent: true, files }
         : { spent: false, files: [] };
 }
+/**
+ * NOT-354: whether a checks-wait sync already pushed the base this episode (same
+ * episode rule as {@link conflictRepairSpent}). Merge-entry syncs never count —
+ * that path retries the merge in the same call, so it cannot sync twice.
+ */
+export function checksWaitSyncSpent(issueId, instanceId) {
+    const events = listWorkflowEventsForIssue(issueId).filter((e) => e.workflowInstanceId === instanceId);
+    let lastSync = -1;
+    let lastResolved = -1;
+    events.forEach((e, index) => {
+        if (e.type === "auto_merge.conflict_sync") {
+            try {
+                const payload = JSON.parse(e.payloadJson ?? "{}");
+                if (payload.entry === "checks_wait" && payload.outcome === "synced")
+                    lastSync = index;
+            }
+            catch {
+                // unreadable audit payload cannot mark a sync
+            }
+        }
+        else if (e.type === "human_action.resolved") {
+            lastResolved = index;
+        }
+    });
+    return lastSync > lastResolved;
+}
 /**
  * Mirrors commands.ts's `queuedProfileSnapshot` (kept local: auto-merge →
  * commands would close an import cycle — commands already imports auto-merge).
@@ -201,18 +237,20 @@ function conflictRepairWorkItemKey(issueId, instanceId, round) {
 }
 function auditSync(input, outcome, detail) {
     try {
+        const issue = getIssue(input.issueId);
         appendWorkflowEvent({
             issueId: input.issueId,
             workflowInstanceId: input.instanceId,
             workerSessionId: null,
             type: "auto_merge.conflict_sync",
             actorType: "system",
-            stage: "final_review",
-            round: getIssue(input.issueId)?.currentRound ?? null,
+            stage: input.entry === "merge" ? "final_review" : (issue?.status ?? "developing"),
+            round: issue?.currentRound ?? null,
             payload: {
                 outcome,
                 branch: input.branch,
                 baseBranch: input.baseBranch,
+                ...(input.entry === "merge" ? {} : { entry: input.entry }),
                 ...(detail ?? {}),
             },
         });
@@ -232,18 +270,34 @@ function formatFileList(files) {
  * with the conflict directive on the work-item payload for exactly this round.
  * Null when the issue left the merge park first (a racer won) — the caller
  * then falls back to today's escalation, which no-ops off-park itself.
+ *
+ * NOT-354 `checks_wait`: the issue is still in its developer stage (developing
+ * or repairing, which it keeps), and `finish` names the leased developer item
+ * the CI wait ran in — it is CAS-finished in the same transaction, so a lost
+ * lease queues nothing (null).
  */
-function queueConflictRepairRound(input) {
+export function queueConflictRepairRound(input) {
     return getDb().transaction(() => {
         const current = getIssue(input.issueId);
-        if (!current || current.status !== "final_review")
+        if (!current)
+            return null;
+        const fromStatuses = input.entry === "checks_wait" ? ["developing", "repairing"] : ["final_review"];
+        if (!fromStatuses.includes(current.status))
             return null;
         const active = getActiveWorkflowInstance(input.issueId);
         if (!active || active.id !== input.instanceId)
             return null;
+        if (input.finish &&
+            !finishWorkItem(input.finish.workItemId, input.finish.leaseToken, {
+                status: "done",
+                result: input.finish.result,
+            })) {
+            return null;
+        }
+        const toStatus = input.entry === "checks_wait" ? current.status : "repairing";
         const round = current.currentRound + 1;
         incrementIssueRound(input.issueId);
-        transitionIssue(input.issueId, "repairing", {
+        transitionIssue(input.issueId, toStatus, {
             currentOwner: "developer",
             currentIntent: `Resolving merge conflict with ${input.baseBranch} (round ${round})`,
         });
@@ -253,7 +307,7 @@ function queueConflictRepairRound(input) {
             workerSessionId: null,
             type: "repair.started",
             actorType: "system",
-            stage: "repairing",
+            stage: toStatus,
             round,
         });
         const directive = {
@@ -278,7 +332,7 @@ function queueConflictRepairRound(input) {
             workerSessionId: null,
             type: "auto_merge.conflict_repair_queued",
             actorType: "system",
-            stage: "repairing",
+            stage: toStatus,
             round,
             payload: {
                 baseBranch: input.baseBranch,
@@ -357,14 +411,27 @@ async function cleanupSyncCheckout(repoPath, syncPath) {
  * Runs the NOT-310 self-resolution for one not-mergeable failure. See the
  * module doc for the bound, the safety invariant, and the fail-closed shape:
  * every refusal returns `skipped` so the caller escalates exactly as today.
+ *
+ * `entry` defaults to the merge path; `checks_wait` (NOT-354) needs no
+ * `mergePr`, and its `mergeReason` is the whole escalation lead-in (there is no
+ * "Auto-merge failed" to report before review).
  */
 export async function runMergeConflictSync(opts) {
+    const entry = opts.entry ?? "merge";
+    const checksWait = entry === "checks_wait";
     const auditInput = {
         issueId: opts.issueId,
         instanceId: opts.instanceId,
         branch: opts.branch,
         baseBranch: opts.baseBranch,
+        entry,
     };
+    const lead = checksWait ? opts.mergeReason : `Auto-merge failed: ${opts.mergeReason}`;
+    // A merge failure's escalation offers retry_merge; a pre-review conflict has
+    // nothing to retry, so it keeps the default policy_escalation choices.
+    const escalationEvidence = checksWait
+        ? { checksConflict: true }
+        : { [MERGE_FAILURE_EVIDENCE_KEY]: true };
     const skip = (reason) => {
         auditSync(auditInput, "skipped", { reason });
         return { outcome: "skipped", reason };
@@ -373,8 +440,8 @@ export async function runMergeConflictSync(opts) {
         auditSync(auditInput, "failed", { detail });
         return {
             outcome: "escalate",
-            reason: `Auto-merge failed: ${opts.mergeReason} (base sync ${opts.baseBranch}: ${detail})`,
-            evidence: { [MERGE_FAILURE_EVIDENCE_KEY]: true },
+            reason: `${lead} (base sync ${opts.baseBranch}: ${detail})`,
+            evidence: escalationEvidence,
         };
     };
     // The conflict-repair round already ran for this episode and the merge still
@@ -387,15 +454,24 @@ export async function runMergeConflictSync(opts) {
             : "The conflicting files are unknown — the retry failed without a local merge.";
         return {
             outcome: "escalate",
-            reason: `Auto-merge failed: ${opts.mergeReason} ` +
+            reason: `${lead} ` +
                 `Dealer already synced ${opts.baseBranch} and ran one conflict-repair round; ` +
                 `the PR still conflicts. ${filesText}`,
             evidence: {
-                [MERGE_FAILURE_EVIDENCE_KEY]: true,
+                ...escalationEvidence,
                 [MERGE_CONFLICT_FILES_EVIDENCE_KEY]: spent.files,
             },
         };
     }
+    // NOT-354: a checks-wait sync already pushed this episode and the PR conflicts
+    // again (the base moved under it) — the one repair round re-syncs and resolves,
+    // never a second automatic sync.
+    if (checksWait && checksWaitSyncSpent(opts.issueId, opts.instanceId)) {
+        auditSync(auditInput, "repair_needed", { files: [], baseMovedAgain: true });
+        return { outcome: "repair_needed", files: [] };
+    }
+    if (!checksWait && !opts.mergePr)
+        return skip("merge entry requires mergePr");
     if (!opts.branch.trim())
         return skip("issue has no branch to sync");
     let repoPath;
@@ -532,6 +608,11 @@ export async function runMergeConflictSync(opts) {
         if (unmerged.length === 0) {
             return failed(`merge failed: ${mergeError.message}`);
         }
+        if (checksWait) {
+            const files = unmerged.slice(0, CONFLICTING_FILES_MAX);
+            auditSync(auditInput, "repair_needed", { files: unmerged });
+            return { outcome: "repair_needed", files };
+        }
         const queued = queueConflictRepairRound({
             issueId: opts.issueId,
             instanceId: opts.instanceId,
@@ -563,6 +644,13 @@ export async function runMergeConflictSync(opts) {
         const detail = err instanceof Error ? err.message : String(err);
         return failed(`could not push the synced branch: ${detail}`);
     }
+    // NOT-354: the checks-wait entry stops at the push — the deferred CI wait
+    // re-polls the pushed head through the normal publish-only path.
+    if (checksWait) {
+        await cleanupSyncCheckout(repoPath, syncPath);
+        auditSync(auditInput, "synced", { baseSha: base.sha, headSha: headAfterMerge, mergeChangedHead });
+        return { outcome: "synced", headSha: headAfterMerge };
+    }
     // Wait for checks on the new head exactly as the developer effect does, then
     // retry the merge once. A failed/timed-out poll escalates directly — retrying
     // the merge against red or unknown checks cannot succeed.

package/bundle/server/dist/coordinator/merge-conflict-sync.test.js

@@ -119,3 +119,193 @@ test("conflictRepairSpent ignores other issues/instances and malformed file list
     assert.equal(spent.spent, true);
     assert.deepEqual(spent.files, []);
 });
+// ---------------------------------------------------------------------------
+// NOT-354: the checks-wait entry — a developer PR that conflicts while Dealer
+// waits for CI. Real git (origin + managed clone); the sync's git shell-out is
+// recorded so the safety rules are asserted on the exact commands issued.
+const { execFileSync } = await import("node:child_process");
+const { checksWaitSyncSpent, defaultSyncGitExec, queueConflictRepairRound, runMergeConflictSync, setConflictSyncGitExecForTests, } = await import("./merge-conflict-sync.js");
+const { claimWorkItem, getWorkItem, listWorkItemsForIssue } = await import("../repository/work-items.js");
+const { getIssue } = await import("../repository/issues.js");
+/** origin + clone where `issue-1` is pushed, then origin/main moves. `conflict`
+ * makes the base edit the same line of shared.txt the branch edited. */
+function initChecksWaitRepos(conflict) {
+    const g = (cwd, ...args) => execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+    const origin = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not354-origin-"));
+    g(origin, "init", "-q", "-b", "main");
+    g(origin, "config", "user.email", "test@example.com");
+    g(origin, "config", "user.name", "Test");
+    fs.writeFileSync(path.join(origin, "shared.txt"), "line1\nline2\n");
+    g(origin, "add", ".");
+    g(origin, "commit", "-q", "-m", "A base");
+    const local = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not354-local-"));
+    fs.rmSync(local, { recursive: true, force: true });
+    execFileSync("git", ["clone", "-q", origin, local]);
+    g(local, "config", "user.email", "test@example.com");
+    g(local, "config", "user.name", "Test");
+    g(local, "checkout", "-q", "-b", "issue-1");
+    fs.writeFileSync(path.join(local, "shared.txt"), "line1\nfeature change\n");
+    g(local, "add", ".");
+    g(local, "commit", "-q", "-m", "B feature");
+    g(local, "push", "-q", "-u", "origin", "issue-1");
+    g(local, "checkout", "-q", "main");
+    if (conflict)
+        fs.writeFileSync(path.join(origin, "shared.txt"), "line1\nbase change\n");
+    else
+        fs.writeFileSync(path.join(origin, "other.txt"), "c\n");
+    g(origin, "add", ".");
+    g(origin, "commit", "-q", "-m", "C base moved (sibling PR merged)");
+    return { origin, local, baseMovedSha: g(origin, "rev-parse", "HEAD") };
+}
+function developingIssueIn(repo) {
+    const issueId = createIssue({
+        title: "Conflicting PR",
+        description: "d",
+        acceptanceCriteria: "It works",
+        repo,
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "manual",
+    }).id;
+    startWorkflow(issueId);
+    return { issueId, instanceId: getActiveWorkflowInstance(issueId).id };
+}
+function recordGit() {
+    const calls = [];
+    setConflictSyncGitExecForTests(async (args, opts) => {
+        calls.push(args);
+        return defaultSyncGitExec(args, opts);
+    });
+    return calls;
+}
+function assertSafeGit(calls) {
+    for (const args of calls) {
+        assert.ok(!args.includes("rebase"), `never rebase: git ${args.join(" ")}`);
+        if (args[0] === "push") {
+            assert.ok(args.every((a) => !/^(-f|--force)/.test(a) && !a.startsWith("+")), `push must never force: git ${args.join(" ")}`);
+        }
+    }
+}
+function contains(repo, sha, ref) {
+    try {
+        execFileSync("git", ["merge-base", "--is-ancestor", sha, ref], { cwd: repo });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const CHECKS_WAIT_REASON = "PR #7 conflicts with main (mergeable: CONFLICTING), so its CI cannot start.";
+test("NOT-354: checks_wait clean sync merges the base and plain-pushes, then never syncs twice in the episode", async () => {
+    const { origin, local, baseMovedSha } = initChecksWaitRepos(false);
+    const { issueId, instanceId } = developingIssueIn(local);
+    const calls = recordGit();
+    try {
+        const sync = {
+            issueId,
+            instanceId,
+            repo: local,
+            branch: "issue-1",
+            baseBranch: "main",
+            prNumber: 7,
+            mergeReason: CHECKS_WAIT_REASON,
+            entry: "checks_wait",
+        };
+        const first = await runMergeConflictSync(sync);
+        assert.equal(first.outcome, "synced");
+        const originTip = execFileSync("git", ["rev-parse", "issue-1"], { cwd: origin, encoding: "utf8" }).trim();
+        assert.equal(first.outcome === "synced" ? first.headSha : null, originTip, "reports the pushed head");
+        assert.equal(contains(origin, baseMovedSha, "issue-1"), true, "origin's branch now contains the moved base");
+        assert.equal(calls.filter((a) => a.includes("merge") && a.includes("origin/main")).length, 1);
+        assert.deepEqual(calls.filter((a) => a[0] === "push"), [["push", "-u", "origin", "HEAD:refs/heads/issue-1"]]);
+        assertSafeGit(calls);
+        assert.equal(checksWaitSyncSpent(issueId, instanceId), true);
+        const root = path.join(local, ".agent-dealer-worktrees");
+        const leftovers = fs.existsSync(root) ? fs.readdirSync(root).filter((e) => e.startsWith("merge-sync-")) : [];
+        assert.deepEqual(leftovers, []);
+        // The base moved again and the PR conflicts again: the episode's one sync is
+        // spent, so the repair round is due — and no git command runs.
+        const before = calls.length;
+        const second = await runMergeConflictSync(sync);
+        assert.deepEqual(second, { outcome: "repair_needed", files: [] });
+        assert.equal(calls.length, before, "no second sync");
+        assert.equal(getIssue(issueId).status, "developing", "the sync itself never moves the issue");
+    }
+    finally {
+        setConflictSyncGitExecForTests(null);
+    }
+});
+test("NOT-354: checks_wait textual conflict aborts without pushing, one repair round queues on the leased item, then escalates once with the files", async () => {
+    const { local, baseMovedSha } = initChecksWaitRepos(true);
+    const { issueId, instanceId } = developingIssueIn(local);
+    const calls = recordGit();
+    try {
+        const sync = {
+            issueId,
+            instanceId,
+            repo: local,
+            branch: "issue-1",
+            baseBranch: "main",
+            prNumber: 7,
+            mergeReason: CHECKS_WAIT_REASON,
+            entry: "checks_wait",
+        };
+        const first = await runMergeConflictSync(sync);
+        assert.deepEqual(first, { outcome: "repair_needed", files: ["shared.txt"] });
+        assert.equal(calls.filter((a) => a[0] === "push").length, 0, "a conflicted merge is never pushed");
+        assert.equal(contains(local, baseMovedSha, "issue-1"), false, "the merge was aborted");
+        assertSafeGit(calls);
+        // The developer item the CI wait ran in is still leased; the repair round
+        // queues while CAS-finishing it.
+        const leased = claimWorkItem("not354-test", { leaseMs: 60_000 });
+        assert.equal(leased.issueId, issueId);
+        assert.equal(queueConflictRepairRound({
+            issueId,
+            instanceId,
+            baseBranch: "main",
+            branch: "issue-1",
+            files: ["shared.txt"],
+            entry: "checks_wait",
+            finish: { workItemId: leased.id, leaseToken: "stale-token", result: {} },
+        }), null, "a lost lease queues nothing");
+        const queued = queueConflictRepairRound({
+            issueId,
+            instanceId,
+            baseBranch: "main",
+            branch: "issue-1",
+            files: ["shared.txt"],
+            entry: "checks_wait",
+            finish: { workItemId: leased.id, leaseToken: leased.leaseToken, result: {} },
+        });
+        assert.ok(queued);
+        assert.equal(getWorkItem(leased.id).status, "done");
+        const pending = listWorkItemsForIssue(issueId).filter((i) => i.status === "pending");
+        assert.equal(pending.length, 1);
+        assert.equal(pending[0].id, queued.id);
+        assert.deepEqual(JSON.parse(pending[0].payloadJson).conflictRepair, {
+            baseBranch: "main",
+            branch: "issue-1",
+            files: ["shared.txt"],
+        });
+        assert.equal(getIssue(issueId).status, "developing", "developing has no repairing edge — the stage is kept");
+        assert.equal(getIssue(issueId).currentRound, 2);
+        // The repair round's CI wait still sees a conflicting PR: escalate with the
+        // file list, no second sync.
+        const before = calls.length;
+        const again = await runMergeConflictSync(sync);
+        assert.equal(again.outcome, "escalate");
+        if (again.outcome === "escalate") {
+            assert.match(again.reason, /^PR #7 conflicts with main/);
+            assert.match(again.reason, /shared\.txt/);
+            assert.deepEqual(again.evidence.conflictingFiles, ["shared.txt"]);
+            assert.equal(again.evidence.mergeFailure, undefined);
+        }
+        assert.equal(calls.length, before, "no git command once the episode is spent");
+    }
+    finally {
+        setConflictSyncGitExecForTests(null);
+    }
+});

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

@@ -22,9 +22,9 @@ import { resolveMuseAuthFile, resolveMuseBin } from "../cli-env.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 { parseMuseRun, createMusePrimaryTerminalMatcher, } from "../runners/muse-code-jsonl.js";
 import { spawnCli } from "../runners/spawn-cli.js";
-import { museIdleTimeoutMs } from "./session-timeouts.js";
+import { museIdleTimeoutMs, museTerminalGraceMs } from "./session-timeouts.js";
 /**
  * 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.
@@ -40,6 +40,7 @@ export function museStallMetadata(summary) {
         lastToolName: summary.lastToolName,
         firstOutputMs: summary.firstOutputMs,
         idleTimedOut: summary.idleTimedOut,
+        lingeredAfterTerminal: summary.lingeredAfterTerminal,
     };
 }
 /** `sessions/YYYY/MM/DD/<session-id>/session.jsonl` under the attempt's data dir, if present. */
@@ -231,6 +232,10 @@ export async function runMuseDeveloperSession(input) {
     // NOT-307: silence bound for this session. Undefined disables the watchdog
     // (`MUSE_IDLE_TIMEOUT_MS=0`); only the Muse lane opts in.
     const idleTimeoutMs = museIdleTimeoutMs();
+    // NOT-342: post-terminal linger bound. Undefined disables (`MUSE_TERMINAL_GRACE_MS=0`).
+    // Stateful: only the primary run's terminal arms the grace (cron terminals must not).
+    const terminalGraceMs = museTerminalGraceMs();
+    const primaryTerminal = createMusePrimaryTerminalMatcher();
     try {
         // The exact launch about to happen — a tampered settings file or a differing
         // cwd/argv/env/stdin fails here, before any process exists.
@@ -250,6 +255,9 @@ export async function runMuseDeveloperSession(input) {
             onStdoutLine: (_line, atMs) => {
                 lineTs.push(atMs);
             },
+            terminalGrace: terminalGraceMs !== undefined
+                ? { isTerminalLine: primaryTerminal.isTerminalLine, graceMs: terminalGraceMs }
+                : undefined,
         });
         sessionLog = readSessionLog(attempt.env.XDG_DATA_HOME, input.sessionId);
     }
@@ -257,11 +265,16 @@ export async function runMuseDeveloperSession(input) {
         attempt.cleanup();
     }
     const rawLog = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : spawned.transcript;
+    // Only remap a linger kill to exit 0 when the primary run's terminal was actually
+    // seen — a spurious linger (e.g. armed on a secondary run) must keep the real
+    // signal exit so parseMuseRun does not invent a clean "exited 0 without terminal".
+    const lingerAsCleanExit = spawned.lingeredAfterTerminal && primaryTerminal.sawPrimaryTerminal();
+    const parseExit = spawned.timedOut ? null : lingerAsCleanExit ? 0 : spawned.exitCode;
     const { stdout, stderr } = splitSpawnLog(rawLog);
     const run = parseMuseRun({
         stdout,
         stderr,
-        exitCode: spawned.timedOut ? null : spawned.exitCode,
+        exitCode: parseExit,
         sessionLog,
         expectedModel: model,
         lineTs,
@@ -281,6 +294,7 @@ export async function runMuseDeveloperSession(input) {
         firstOutputMs: spawned.firstOutputMs,
         lastActivityAt: spawned.lastActivityAt,
         idleTimedOut: spawned.idleTimedOut,
+        lingeredAfterTerminal: spawned.lingeredAfterTerminal,
         toolCallCount: run.tools.length,
         lastToolName: run.tools.length > 0 ? (run.tools[run.tools.length - 1].name ?? null) : null,
     };
@@ -299,15 +313,19 @@ export async function runMuseDeveloperSession(input) {
     // best-effort capacity refresh (no synthetic turn, never throws, never
     // blocks this result).
     refreshMuseCapacityAfterSession();
+    const reportedExit = lingerAsCleanExit ? 0 : spawned.exitCode;
     return {
         // A failed session must not read as success just because Muse exited 0 (wrong model, no terminal event).
-        exitCode: run.failure && spawned.exitCode === 0 ? 1 : spawned.exitCode,
+        // A linger kill after a terminal event is not a timeout: classify via parseMuseRun (failed
+        // keeps its reason; completed is a normal completion) and report exit 0 unless the run failed.
+        exitCode: run.failure && reportedExit === 0 ? 1 : reportedExit,
         transcript: run.finalText ?? "",
         logPath,
         timedOut: spawned.timedOut,
         // NOT-307: an idle kill reads as a timeout downstream (same salvage, same
         // infra-retry budget) with the idle flag distinguishing the cause.
         idleTimedOut: spawned.idleTimedOut,
+        lingeredAfterTerminal: spawned.lingeredAfterTerminal,
         muse: summary,
     };
 }