@agent-relay/factory 0.1.62 → 0.1.64

package/dist/orchestrator/factory.js

@@ -5,6 +5,7 @@ import { FactoryConfigSchema } from '../config/schema.js';
 import { linearByStatePath, linearByIdPath, linearByUuidPath } from '../constants/linear.js';
 import { stateResolutionFromIds } from '../linear/state-resolver.js';
 import { GithubMergeGate, closeProbePr } from '../github/index.js';
+import { factoryGithubIssueCommentDraftName, isFactoryGithubIssueCommentDraftName, isFactoryGithubOperationDraftName, } from '../github/writeback-paths.js';
 import { VerificationPipeline } from '../environments/verification-pipeline.js';
 import { factoryWorktreeIssueSlug, factoryWorktreePath } from '../git/agent-worktree.js';
 import { InMemoryStateStore } from '../state/in-memory-state-store.js';
@@ -12,13 +13,14 @@ import { containsExplicitIssueReference, containsIssueKey, factoryBranchBelongsT
 import { normalizeLogger, normalizeLogValue, setSafeErrorStack, stringifyLogValue } from '../logging.js';
 import { isInFactoryScope } from '../safety/factory-scope.js';
 import { dispatchRelayflowForChangeEvent } from '../dispatch/relayflow-registry.js';
+import { dispatchAgentIdentityKey } from '../dispatch/work-unit-identity.js';
 import { deriveDescriptorsFromMount, prescriptiveInstructions, } from '@agent-relay/integration-prompts';
 import { parseGithubHumanInputRequest, renderAgentTask, } from '../dispatch/templates.js';
 import { resolveTestGuidance } from '../dispatch/test-guidance.js';
-import { HeuristicTriage, TieredTriage, babysitterSpec, isShapeLabel, scopeFromLabels } from '../triage/index.js';
+import { HeuristicTriage, TieredTriage, babysitterSpec, isShapeLabel, scopeFromLabels, swarmChannel, swarmMemberSlugs, swarmTaskFor } from '../triage/index.js';
 import { agentNameForRole, sanitizeAgentSlug } from '../triage/agent-names.js';
 import { isResourceSubscriptionsUnavailable } from '../subscriptions/index.js';
-import { GhCliGithubWriteback, MountGithubRead, MountLinearWriteback, MountSlackWriteback, slackChannelAliases, slackChannelSegment } from '../writeback/index.js';
+import { AppGithubWriteback, FACTORY_GITHUB_STATUS_LABELS, GhCliGithubWriteback, MountGithubRead, MountLinearWriteback, MountSlackWriteback, slackChannelAliases, slackChannelSegment } from '../writeback/index.js';
 import { parseSlackThreadReply, slackThreadReplyGlob } from '../subscriptions/slack-filter.js';
 import { asRecord, parseJsonContent, stableHash, wrappedPayload } from '../writeback/shared.js';
 import { issueKey, } from './batch-tracker.js';
@@ -29,6 +31,8 @@ import { readFactoryInFlightRegistry, terminatePids } from './reaper.js';
 import { createFactoryCloudEventV1, factoryCloudReleaseReasonV1, } from '../observability/events.js';
 import { boundedRunCostTotal, CostLedger } from '../cost/ledger.js';
 import { createTicketDispatchDelivery } from '../delivery/ticket-dispatch.js';
+import { canonicalTrajectorySessionRef, renderTrajectoryPointer, stripTrajectoryPointers, } from '../trajectory.js';
+import { FleetControlPlaneCircuit, FleetControlPlaneCircuitOpenError, guardFleetControlPlane, } from '../fleet/control-plane-circuit.js';
 class ClarificationWakeLeaseLostError extends Error {
 }
 class ClarificationQuestionDeliveryLeaseLostError extends Error {
@@ -143,8 +147,32 @@ const STARTUP_AGENT_EXIT_DRAIN_TIMEOUT_MS = 30_000;
 const RECONCILED_AGENT_EXIT_CONCURRENCY = 4;
 const SLACK_EVENT_WATERMARK_CACHE_MS = 60_000;
 const SLACK_CONVERSATION_TURN_LEASE_MS = 60_000;
+// Both receipt leases guard an in-flight Slack writeback, and no fixed lease can
+// cover one: MountSlackWriteback budgets 90s for the confirm alone, on top of an
+// unbounded writeFile. Sizing them past that worst case would only trade a stolen
+// claim for a stranded one — a lease long enough to survive the slowest write is
+// equally long enough to hold the receipt hostage to a dead holder. So these
+// bound the *idle* claim and #withRenewedProviderLease extends them for exactly
+// as long as the write they cover is still running.
+const SLACK_REPLY_ACKNOWLEDGEMENT_LEASE_MS = 60_000;
+const SLACK_TERMINAL_RECEIPT_CLAIM_LEASE_MS = 60_000;
+// Renewal without a ceiling is the same defect from the other side: a heartbeat
+// that extends the claim for as long as the write runs also extends it forever
+// when the write never returns, and nothing else can reclaim the receipt short
+// of a restart. So renewal is bounded past the slowest write this daemon budgets
+// for — MountSlackWriteback's 90s confirm on top of its writeFile — and beyond
+// that the write is not slow, it is wedged: the heartbeat stops, the idle lease
+// runs out, and the retry that owns the queued replies can take them back.
+const SLACK_PROVIDER_LEASE_MAX_RENEWAL_MS = 5 * 60_000;
 const SLACK_CONVERSATION_TURN_RETRY_MS = 1_000;
 const SLACK_REPLY_ROUTE_RETRY_MS = 1_000;
+// One pass drains the whole chain (#slackReplyRoutes holds only the newest
+// route per key and every route awaits its predecessor). The extra passes only
+// exist so the drain can prove quiescence rather than assume it.
+const SLACK_REPLY_ROUTE_DRAIN_PASSES = 8;
+const SLACK_TERMINAL_THREAD_GRACE_MS = 24 * 60 * 60_000;
+const SLACK_TERMINAL_RECEIPT_RETRY_MS = 1_000;
+const SLACK_TERMINAL_RECEIPT_RETRY_MAX_MS = 5 * 60_000;
 const MERGE_GATE_MAX_ATTEMPTS = 12;
 const MERGE_GATE_POLL_DELAY_MS = 10_000;
 const MAX_LABEL_IMPLEMENTERS = 4;
@@ -212,6 +240,25 @@ class DispatchLifecycleOwnedElsewhereError extends Error {
         this.leaseUntilMs = leaseUntilMs;
     }
 }
+/**
+ * The durable dispatch-lifecycle claim was refused for one work unit: its
+ * record is already terminal, or another publisher currently holds the lease.
+ * Both are facts about that single unit — the rest of the pass is unaffected —
+ * so the readiness loop skips it and keeps going (#292).
+ *
+ * Typed rather than left as a plain `Error` so the loop can classify it by
+ * construction instead of by matching on `Refusing to dispatch ...` text.
+ */
+class DispatchLifecycleClaimRefusedError extends Error {
+    issueKey;
+    refusal;
+    constructor(issueKey, refusal, message) {
+        super(message);
+        this.issueKey = issueKey;
+        this.refusal = refusal;
+        this.name = 'DispatchLifecycleClaimRefusedError';
+    }
+}
 const realClock = {
     now: () => Date.now(),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -224,6 +271,7 @@ export class FactoryLoop {
     #mount;
     #states;
     #fleet;
+    #fleetControlPlane;
     #ticketDispatchDelivery;
     #triage;
     #linear;
@@ -262,6 +310,19 @@ export class FactoryLoop {
     #dispatchInFlight = new Map();
     #slackWatchers = new Map();
     #slackWatcherStarts = new Map();
+    #slackTerminalWatchExpiryTimers = new Map();
+    #slackTerminalReceiptRetryTimers = new Map();
+    #terminalSlackWatchIssues = new Set();
+    /**
+     * The one in-memory record of "this work unit has an in-flight Slack side
+     * effect". Both ordinary reply routes and the writebacks the terminal fence
+     * issues on their behalf register here, because this map is what the terminal
+     * drain waits on: anything that touches Slack for a work unit without
+     * registering is invisible to the drain, and the watcher teardown that follows
+     * a successful drain then pulls that effect's retry timer out from under it.
+     */
+    #slackReplyRoutes = new Map();
+    #slackReplyRouteDrains = new Set();
     #slackConversationTurns;
     #slackConversationOwner = `${process.pid}:${randomUUID()}`;
     #githubIssueCommentWatchers = new Map();
@@ -435,6 +496,11 @@ export class FactoryLoop {
     #discoverySweepRenewTimer;
     #discoverySweepRenewalInFlight;
     #discoverySweepLeaseLost = false;
+    // Registry/heartbeat paths the in-flight runLoop iteration would use. A
+    // per-item dispatch failure now skips instead of aborting the pass (#292),
+    // so the loop's catch no longer runs the failure-handoff reaper for it; the
+    // pass reaps inline and must write to the same paths runLoop would.
+    #loopReapPaths;
     #discoveryOverloadError;
     #resolvedIssueSource;
     #integrationInstructions;
@@ -452,7 +518,6 @@ export class FactoryLoop {
         // synced records (state.name but no state.id) without the states catalog.
         this.#states = ports.stateResolution ?? stateResolutionFromIds(config.stateIds, config.linear.states);
         installFactoryDraftPredicate(this.#mount, config);
-        this.#fleet = ports.fleet;
         this.#ticketDispatchDelivery = ports.ticketDispatchDelivery ?? createTicketDispatchDelivery({
             mountRoot: config.localMountRoot,
         });
@@ -461,7 +526,7 @@ export class FactoryLoop {
             safety: config.safety,
         });
         this.#githubWritebackProvided = Boolean(ports.githubWriteback);
-        this.#githubWriteback = ports.githubWriteback ?? new GhCliGithubWriteback();
+        this.#githubWriteback = ports.githubWriteback ?? defaultGithubWriteback(config, ports.mount);
         this.#slack = config.slack ? MountSlackWriteback(ports.mount, config.slack) : ports.slack;
         this.#github = ports.github ?? MountGithubRead(ports.mount);
         this.#mergeGate = ports.mergeGate ?? new GithubMergeGate();
@@ -483,6 +548,13 @@ export class FactoryLoop {
         this.#probePrResolver = ports.probePrResolver ?? ((issue) => this.#resolveIssuePr(issue));
         this.#logger = normalizeLogger(ports.logger ?? console);
         this.#clock = ports.clock ?? realClock;
+        this.#fleetControlPlane = new FleetControlPlaneCircuit({
+            timeoutMs: config.fleetHealth.rosterTimeoutMs,
+            failureThreshold: config.fleetHealth.failureThreshold,
+            resetTimeoutMs: config.fleetHealth.resetTimeoutMs,
+            now: () => this.#clock.now(),
+        });
+        this.#fleet = guardFleetControlPlane(ports.fleet, this.#fleetControlPlane);
         this.#processIdentityReader = ports.processIdentityReader ?? readProcessIdentity;
         this.#processFinder = ports.processFinder ?? ((agentName, opts) => findAgentProcessByName(agentName, {
             readProcessIdentity: this.#processIdentityReader,
@@ -590,11 +662,32 @@ export class FactoryLoop {
         this.#batchView = batch;
         return batch;
     }
+    /**
+     * Resolves once this issue's durable dispatch row reaches a terminal phase,
+     * and reports which one. A caller that turns the run into an exit code needs
+     * the phase: a dispatch that hit capacity returns an empty hold result and
+     * schedules a durable retry, so the pre-wait result says nothing about how
+     * the run actually ended.
+     *
+     * `undefined` means no terminal phase was observed — there was no lifecycle
+     * row to wait on, or the wait ended because Factory is stopping.
+     */
     async waitForDispatchTerminal(issue) {
         const key = issueKey(issue);
         const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
-        if (lifecycle && isTerminalDispatchLifecycle(lifecycle))
-            return;
+        // No durable row means this dispatch never claimed a lifecycle: a
+        // dependency park, a triage escalation, and a label refusal all return
+        // before the claim. Nothing can ever become terminal, so polling would
+        // never stop and the caller would never produce an exit code at all.
+        if (!lifecycle)
+            return undefined;
+        if (isTerminalDispatchLifecycle(lifecycle))
+            return lifecycle.phase;
+        // Capture the phase at the moment this waiter observes it. The waiters are
+        // shared across callers of one row and carry no payload, so a re-read after
+        // the fact can race lifecycle cleanup or a reopened dispatch for the same
+        // issue and report a different run — or none.
+        let observedPhase;
         await new Promise((resolve) => {
             let settled = false;
             let timer;
@@ -603,10 +696,11 @@ export class FactoryLoop {
                 waiters = new Set();
                 this.#dispatchTerminalWaiters.set(key, waiters);
             }
-            const finish = () => {
+            const finish = (phase) => {
                 if (settled)
                     return;
                 settled = true;
+                observedPhase = phase;
                 if (timer)
                     clearTimeout(timer);
                 const current = this.#dispatchTerminalWaiters.get(key);
@@ -629,7 +723,7 @@ export class FactoryLoop {
                 try {
                     const latest = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
                     if (latest && isTerminalDispatchLifecycle(latest)) {
-                        this.#resolveDispatchTerminalWaiters(issue);
+                        this.#resolveDispatchTerminalWaiters(issue, latest.phase);
                         return;
                     }
                     if (latest?.phase === 'waiting-for-human' && this.#startMode === 'dispatch-owner') {
@@ -659,6 +753,10 @@ export class FactoryLoop {
             };
             void poll();
         });
+        // `observedPhase` is whatever resolved THIS waiter. It stays undefined only
+        // when the wait ended without a terminal resolution at all — Factory is
+        // stopping — which is exactly what `undefined` reports.
+        return observedPhase;
     }
     async start(opts = {}) {
         if (this.#started) {
@@ -871,6 +969,14 @@ export class FactoryLoop {
             await this.#boundedStopTeardown('factory subscription unsubscribe', () => subscription?.unsubscribe());
             await Promise.all([...this.#slackWatchers.values()].map((watcher) => watcher.stop()));
             this.#slackWatchers.clear();
+            for (const timer of this.#slackTerminalWatchExpiryTimers.values())
+                clearTimeout(timer);
+            this.#slackTerminalWatchExpiryTimers.clear();
+            for (const timer of this.#slackTerminalReceiptRetryTimers.values())
+                clearTimeout(timer);
+            this.#slackTerminalReceiptRetryTimers.clear();
+            this.#terminalSlackWatchIssues.clear();
+            this.#slackReplyRouteDrains.clear();
             await Promise.all([...this.#githubIssueCommentWatchers.values()].map((watcher) => watcher.stop()));
             this.#githubIssueCommentWatchers.clear();
             this.#githubIssueCommentWatchStates.clear();
@@ -1831,8 +1937,30 @@ export class FactoryLoop {
             }
         }
     }
+    async #assertFleetControlPlaneAvailable() {
+        try {
+            await this.#fleet.roster();
+            this.#increment('fleetControlPlaneProbeSuccesses');
+        }
+        catch (error) {
+            const health = this.#fleetControlPlane.status();
+            this.#increment('fleetControlPlaneProbeFailures');
+            if (health.state === 'open')
+                this.#increment('fleetControlPlaneCircuitOpen');
+            this.#logger.error?.('[factory] fleet control plane unavailable; dispatch paused', {
+                state: health.state,
+                consecutiveFailures: health.consecutiveFailures,
+                retryAtMs: health.retryAtMs,
+                error: health.lastError ?? 'unknown control-plane failure',
+            });
+            throw contextualError('Factory dispatch paused because the fleet control plane is unavailable', error);
+        }
+    }
     async #runOnceWithDiscoveryFence(opts) {
         const sweepStartedAtMs = this.#clock.now();
+        if (!(opts.dryRun ?? this.#config.dryRun)) {
+            await this.#assertFleetControlPlaneAvailable();
+        }
         let claim = await this.#state.claimDiscoverySweep(this.#workspaceId, this.#discoverySweepOwner, this.#clock.now(), DISCOVERY_SWEEP_LEASE_MS);
         if (!claim.acquired && claim.reason === 'backoff') {
             const delayMs = Math.max(0, claim.state.backoffUntilMs - this.#clock.now());
@@ -1989,6 +2117,10 @@ export class FactoryLoop {
                     reason: entry.reason,
                 });
             };
+            // Backstop for the skip-by-default catch below: see #292. Reset only by
+            // a completed dispatch, so the name says "since a dispatch" rather than
+            // "consecutive" — a benign classified skip in between does not clear it.
+            let unclassifiedFailuresSinceDispatch = 0;
             let lastReadyReadProgressAtMs = this.#clock.now();
             let readyIssueReads = 0;
             const issueEntries = [];
@@ -2086,19 +2218,10 @@ export class FactoryLoop {
                     }
                     const decision = await this.triageIssue(issue);
                     triaged.push(decision);
-                    let result;
-                    try {
-                        result = await this.dispatch(decision, { dryRun });
-                    }
-                    catch (error) {
-                        if (!(error instanceof LiveDispatchStateChangedError))
-                            throw error;
-                        recordSkip({ issue: decision.issue, reason: 'live state changed during dispatch' });
-                        this.#logger.info?.('[factory] skipped issue whose live state changed during dispatch', {
-                            issue: decision.issue.key,
-                        });
-                        continue;
-                    }
+                    const result = await this.dispatch(decision, { dryRun });
+                    // A completed dispatch — even one that parks or escalates the issue —
+                    // proves the pipeline still works, so the fuse below starts over.
+                    unclassifiedFailuresSinceDispatch = 0;
                     if (result.agents.length === 0 && !dryRun) {
                         const reason = result.hold?.kind === 'dependency-cycle'
                             ? `dependency cycle detected: ${result.hold.cycle?.join(' -> ') ?? 'unknown cycle'}`
@@ -2111,6 +2234,52 @@ export class FactoryLoop {
                         dispatched.push(result);
                     }
                 }
+                catch (error) {
+                    // #292: issues in a pass are independent work units, so a failure
+                    // that is about ONE unit costs that unit and nothing else. Only the
+                    // conditions named in `#isPassFatalFailure` — the ones where
+                    // continuing the pass is meaningless — abort the whole sweep.
+                    if (this.#isPassFatalFailure(error, dryRun))
+                        throw error;
+                    if (!isClassifiedPerItemDispatchFailure(error)) {
+                        unclassifiedFailuresSinceDispatch += 1;
+                        // A pass-wide fault can arrive disguised as a run of per-item
+                        // faults. Skipping every unit would then hand back a green report
+                        // that dispatched nothing, which is the same silent wedge #292 is
+                        // about, wearing the opposite costume. Fail the pass loudly so
+                        // `readinessReconcile.lastError` carries the cause.
+                        if (unclassifiedFailuresSinceDispatch >= UNCLASSIFIED_DISPATCH_FAILURE_LIMIT) {
+                            throw contextualError(`Aborting readiness pass after ${unclassifiedFailuresSinceDispatch} unclassified dispatch failures without a successful dispatch`, error);
+                        }
+                        this.#increment('dispatchItemFailuresSkipped');
+                        // The raw message is operator-facing only; the run report carries
+                        // the sanitized classification from `perItemDispatchSkipReason`.
+                        this.#logger.warn?.('[factory] skipped a work unit whose dispatch failed; continuing the pass', {
+                            issue: issueRef(issue).key,
+                            unclassifiedFailuresSinceDispatch,
+                            error: describeError(error).errorMessage,
+                        });
+                        this.#error(error, issueRef(issue));
+                        // The failure may have left half-spawned agents behind. runLoop's
+                        // catch used to reap them because this error aborted the pass;
+                        // now that the pass survives, the reap has to happen here or the
+                        // agents leak until the next failed iteration.
+                        await this.#reapDispatchFailureHandoffsNow();
+                    }
+                    else {
+                        // Not an error — the unit simply cannot be dispatched right now —
+                        // so this stays out of `counters.errors` and gets its own counter
+                        // instead, or a terminal-lifecycle backlog would be invisible to
+                        // anyone watching only `dispatchItemFailuresSkipped`.
+                        this.#increment('dispatchItemsSkippedUndispatchable');
+                        this.#logger.info?.('[factory] skipped a work unit that cannot be dispatched right now', {
+                            issue: issueRef(issue).key,
+                            error: describeError(error).errorMessage,
+                        });
+                    }
+                    recordSkip({ issue: issueRef(issue), reason: perItemDispatchSkipReason(error) });
+                    continue;
+                }
                 finally {
                     if (recoveredIdentity)
                         this.#reconciledGithubInProgress.delete(recoveredIdentity);
@@ -2144,6 +2313,79 @@ export class FactoryLoop {
             }
         }
     }
+    /**
+     * Whether a failure raised while processing ONE work unit must abort the
+     * whole readiness pass instead of skipping that unit.
+     *
+     * The default is the opposite, and that inversion is the fix for #292.
+     * Issues in a pass are independent work units: a failure that is *about one
+     * unit* — its dispatch-lifecycle record, its live state, a provider fault on
+     * its own writeback — costs that unit and nothing else. Before this, every
+     * error except `LiveDispatchStateChangedError` escaped the `for` loop, so a
+     * single issue whose lifecycle record had gone terminal stopped all dispatch
+     * indefinitely, every pass.
+     *
+     * A condition belongs here only when continuing the pass is meaningless or
+     * actively harmful — when the failure is about the *pass*, not the item:
+     *
+     * - The discovery sweep lease is gone. Another process now owns this
+     *   workspace's sweep, so every remaining read throws the same way and each
+     *   one would be recorded as an ordinary per-issue skip. The run report
+     *   would then claim a clean pass over work this process no longer has the
+     *   right to touch.
+     * - Relayfile signalled overload for this sweep. The backend is shedding
+     *   load; grinding through the remaining units makes it worse, and
+     *   `#runOnceWithDiscoveryFence` is going to rethrow this at the fence
+     *   anyway.
+     * - The factory is stopping. Teardown is in progress and dispatching more
+     *   agents now leaks them past the shutdown deadline.
+     * - The fleet control-plane circuit is no longer closed, **on a live pass**.
+     *   Dispatch is globally paused — the same condition
+     *   `#assertFleetControlPlaneAvailable` refuses to *start* a live pass on,
+     *   so it must also stop one already in flight. A dry run is exempt: it
+     *   never calls that admission gate and never spawns, so a paused control
+     *   plane is irrelevant to it rather than fatal to it. Without the
+     *   exemption, one live pass that trips the circuit would poison every
+     *   later dry run — including the boot gate's own `run-once --dry-run`
+     *   probe, turning a recoverable circuit-open condition into a failed boot.
+     *   That is a nastier version of the wedge this whole change removes.
+     *
+     * Deliberately NOT here: JavaScript builtin error types. Classifying
+     * "programmer faults" such as `TypeError` as fatal is the obvious next rule
+     * and it is a trap — Node reports a failed `fetch` as `TypeError: fetch
+     * failed`, which is precisely the transient per-item roster lookup that
+     * wedged the second instance (#291). A rule keyed on builtin types would
+     * have preserved that outage verbatim.
+     *
+     * Everything else — a refused lifecycle claim, a terminal lifecycle record,
+     * a transient network fault on one issue — is per-item: record a skip and
+     * keep going. The unclassified-failure fuse in `#performRunOnce` is the
+     * backstop for a pass-wide fault that does not announce itself as one.
+     */
+    #isPassFatalFailure(error, dryRun) {
+        // Sweep-scoped: these are about this process's right or ability to run the
+        // pass at all, so they hold for a dry run exactly as for a live one.
+        if (this.#discoverySweepLeaseLost || this.#discoveryOverloadError !== undefined || this.#stopping) {
+            return true;
+        }
+        // Fleet-scoped, and therefore live-only. See the doc comment above.
+        return !dryRun && this.#isFleetControlPlaneHalted(error);
+    }
+    /**
+     * Whether dispatch is globally paused by the fleet control-plane circuit.
+     *
+     * Two reads, because the circuit announces itself two different ways. The
+     * state read covers `guardedMutation`, which records a mutation's own
+     * transport failure and rethrows the *original* error rather than the
+     * circuit-open type — converting it there would be wrong, since the mutation
+     * may already have reached the broker and callers key spawn-failure handling
+     * off that original error. The type check covers a rejection raised without
+     * any state transition, such as an already-open circuit refusing admission.
+     */
+    #isFleetControlPlaneHalted(error) {
+        return this.#fleetControlPlane.status().state !== 'closed' ||
+            wrapsErrorOfType(error, FleetControlPlaneCircuitOpenError);
+    }
     #startDiscoverySweepRenewal(epoch) {
         this.#discoverySweepRenewTimer = setInterval(() => {
             if (this.#discoverySweepRenewalInFlight || this.#discoverySweepLeaseLost)
@@ -2699,7 +2941,7 @@ export class FactoryLoop {
             await this.#state.clearBabysitterSession(this.#workspaceId, issueKey(lifecycle.issue));
             this.#dispatchLifecycleEpochs.delete(key);
             this.#abandonedDispatchReasons.delete(key);
-            this.#resolveDispatchTerminalWaiters(lifecycle.issue);
+            this.#resolveDispatchTerminalWaiters(lifecycle.issue, 'abandoned');
             await this.#writeInFlightRegistry().catch((error) => {
                 this.#logger.warn?.('[factory] failed to rewrite registry after orphaned claim release', {
                     issue: issue.key,
@@ -3027,6 +3269,7 @@ export class FactoryLoop {
         const maxConsecutiveFailures = Math.min(5, Math.max(1, Math.trunc(opts.maxConsecutiveFailures ?? this.#config.loop.maxConsecutiveFailures)));
         const heartbeatPath = opts.heartbeatPath ?? this.#config.loop.heartbeatPath;
         const registryPath = opts.registryPath ?? this.#config.loop.registryPath;
+        this.#loopReapPaths = { heartbeatPath, registryPath };
         const reports = [];
         let consecutiveFailures = 0;
         let completed = false;
@@ -3054,6 +3297,16 @@ export class FactoryLoop {
                     reports.push(failedIterationReport(error, opts.dryRun ?? this.#config.dryRun));
                     await this.#reapDispatchFailureHandoffsNow(heartbeatPath, registryPath);
                     await this.#writeLoopHeartbeat(heartbeatPath, registryPath, 'running', iteration + 1, maxIterations);
+                    const fleetControlPlane = this.#fleetControlPlane.status();
+                    if (fleetControlPlane.state !== 'closed') {
+                        this.#increment('loopCircuitBreaks');
+                        this.#logger.error?.('[factory] stopping loop because dispatch is paused by the fleet control-plane circuit', {
+                            state: fleetControlPlane.state,
+                            consecutiveFailures: fleetControlPlane.consecutiveFailures,
+                            retryAtMs: fleetControlPlane.retryAtMs,
+                        });
+                        throw new FleetControlPlaneCircuitOpenError(fleetControlPlane.retryAtMs ?? this.#clock.now(), fleetControlPlane.state);
+                    }
                     if (consecutiveFailures >= maxConsecutiveFailures) {
                         this.#increment('loopCircuitBreaks');
                         this.#logger.error?.('[factory] stopping loop after consecutive iteration failures', {
@@ -3072,6 +3325,7 @@ export class FactoryLoop {
             return reports;
         }
         finally {
+            this.#loopReapPaths = undefined;
             if (!completed) {
                 await this.#writeLoopHeartbeat(heartbeatPath, registryPath, 'stopping', reports.length, maxIterations);
             }
@@ -3209,6 +3463,13 @@ export class FactoryLoop {
             };
         }
         this.#clearDependencyPark(batch, dispatchDecision.issue);
+        // Event-driven and direct dispatches do not necessarily pass through issue
+        // discovery. Admit them before creating previews, claiming a lifecycle, or
+        // consuming a dispatch attempt. The mutation proxy probes again at the
+        // actual spawn/resume boundary so a later control-plane fault still fails
+        // closed.
+        if (!dryRun)
+            await this.#assertFleetControlPlaneAvailable();
         const durableDispatch = !dryRun && this.#usesDurableDispatchLifecycle();
         // Local dispatches need the same deterministic branch identity as remote
         // ones. Without it, every worker starts in the configured shared checkout
@@ -3512,6 +3773,7 @@ export class FactoryLoop {
                 capacityBlocked: parked.capacityBlocked,
             })) ?? [],
             counters: { ...this.#counters },
+            fleetControlPlane: this.#fleetControlPlane.status(),
             slackDegraded: this.#slackDegraded,
             slackDegradedReason: this.#slackDegradedReason,
             eventListener: this.#eventListenerStatus(),
@@ -4066,10 +4328,11 @@ export class FactoryLoop {
             seed.decision = decisionWithLifecycleBranches(seed.decision, seed.runId);
         const claim = await this.#state.claimDispatchLifecycle(this.#workspaceId, key, seed, this.#dispatchLifecycleOwner, this.#clock.now(), DISPATCH_LIFECYCLE_LEASE_MS);
         if (!claim.acquired || !claim.lease) {
-            const reason = isTerminalDispatchLifecycle(claim.lifecycle)
+            const terminal = isTerminalDispatchLifecycle(claim.lifecycle);
+            const reason = terminal
                 ? 'dispatch lifecycle is already terminal'
                 : `dispatch lifecycle is owned by ${claim.lifecycle.lease?.owner ?? 'another publisher'}`;
-            throw new Error(`Refusing to dispatch ${decision.issue.key}: ${reason}`);
+            throw new DispatchLifecycleClaimRefusedError(decision.issue.key, terminal ? 'terminal' : 'owned-elsewhere', `Refusing to dispatch ${decision.issue.key}: ${reason}`);
         }
         this.#dispatchLifecycleEpochs.set(claim.key ?? key, claim.lease.epoch);
         this.#hydrateCostLedger(claim.lifecycle);
@@ -4415,12 +4678,25 @@ export class FactoryLoop {
             }
             for (const agent of lifecycle.agents) {
                 const previousAgent = previous?.agents.find((candidate) => candidate.name === agent.name);
-                if (previousAgent?.releasedAtMs !== undefined)
-                    agent.releasedAtMs = previousAgent.releasedAtMs;
+                // The in-flight record is authoritative for release state: the stamp
+                // now lives on the tracked agent and round-trips through the lifecycle,
+                // so a still-released agent brings its own stamp here. Inheriting the
+                // previous row's stamp instead would refile a respawned worker as
+                // released — a respawn reuses both the agent name and the deterministic
+                // invocation id, so neither can tell the generations apart — and every
+                // consumer that filters on `releasedAtMs` would then treat a live
+                // worker as gone.
                 if (previousAgent?.costUsage)
                     agent.costUsage = structuredClone(previousAgent.costUsage);
-                if (releasedAgentNames.has(agent.name))
-                    agent.releasedAtMs ??= this.#clock.now();
+                if (releasedAgentNames.has(agent.name)) {
+                    const releasedAtMs = agent.releasedAtMs ?? this.#clock.now();
+                    agent.releasedAtMs = releasedAtMs;
+                    // Keep the record the single source of the stamp, so the next save
+                    // carries it without having to read it back off the durable row.
+                    const tracked = record.agents.get(agent.name);
+                    if (tracked)
+                        tracked.releasedAtMs ??= releasedAtMs;
+                }
             }
             const saved = await this.#state.saveDispatchLifecycle(this.#workspaceId, key, this.#dispatchLifecycleOwner, epoch, this.#clock.now(), lifecycle);
             if (!saved) {
@@ -4448,10 +4724,14 @@ export class FactoryLoop {
             return true;
         });
     }
-    #resolveDispatchTerminalWaiters(issue) {
+    // Every caller of this knows the phase the row settled in, and each waiter
+    // must be handed it directly. A waiter that instead re-read the shared row
+    // after release could see it cleared, or see the next dispatch for the same
+    // issue, and classify the wrong run.
+    #resolveDispatchTerminalWaiters(issue, phase) {
         const key = issueKey(issue);
         for (const resolve of this.#dispatchTerminalWaiters.get(key) ?? [])
-            resolve();
+            resolve(phase);
         this.#dispatchTerminalWaiters.delete(key);
     }
     #scheduleDispatchLifecycleRetry(record) {
@@ -4538,7 +4818,7 @@ export class FactoryLoop {
         if (!lifecycle)
             return;
         if (isTerminalDispatchLifecycle(lifecycle)) {
-            this.#resolveDispatchTerminalWaiters(lifecycle.issue);
+            this.#resolveDispatchTerminalWaiters(lifecycle.issue, lifecycle.phase);
             return;
         }
         if (lifecycle.phase === 'waiting-for-human')
@@ -4915,11 +5195,11 @@ export class FactoryLoop {
         for (const [name] of record.agents) {
             this.#fleet.markAgentTerminal?.(name, 'durable-dispatch-abandoned');
         }
-        await this.#stopSlackWatcher(record.issue);
+        await this.#retireSlackWatcher(record);
         await this.#stopGithubIssueCommentWatcherForIssue(record.issue);
         await this.#writeInFlightRegistry();
         this.#increment('dispatchLifecycleStaleIssuesAbandoned');
-        this.#resolveDispatchTerminalWaiters(record.issue);
+        this.#resolveDispatchTerminalWaiters(record.issue, 'abandoned');
         this.#logger.info?.('[factory] abandoned durable dispatch whose live issue is no longer ready', {
             issue: record.issue.key,
             reason,
@@ -4995,7 +5275,7 @@ export class FactoryLoop {
         this.#increment(releaseReason === 'issue-human-review' ? 'humanReview' : 'done');
         this.#emit('issue-done', { issue: record.issue });
         await this.#writeInFlightRegistry();
-        this.#resolveDispatchTerminalWaiters(record.issue);
+        this.#resolveDispatchTerminalWaiters(record.issue, 'complete');
         return true;
     }
     async #assertDispatchLifecycleOwner(record) {
@@ -6019,6 +6299,7 @@ export class FactoryLoop {
             registryPath,
             eventListener: this.#eventListenerStatus(),
             readinessReconcile: this.#readinessReconcileStatus(),
+            fleetControlPlane: this.#fleetControlPlane.status(),
         };
         await mkdir(dirname(path), { recursive: true });
         await writeFile(path, `${JSON.stringify(heartbeat, null, 2)}\n`, 'utf8');
@@ -6037,7 +6318,7 @@ export class FactoryLoop {
             },
         });
     }
-    async #reapDispatchFailureHandoffsNow(heartbeatPath, registryPath) {
+    async #reapDispatchFailureHandoffsNow(heartbeatPath = this.#loopReapPaths?.heartbeatPath ?? this.#config.loop.heartbeatPath, registryPath = this.#loopReapPaths?.registryPath ?? this.#config.loop.registryPath) {
         const handoffs = await this.#state.listFailureHandoffs(this.#workspaceId);
         if (handoffs.length === 0) {
             return;
@@ -6277,6 +6558,22 @@ export class FactoryLoop {
             }
             try {
                 await this.#fleet.release(agentName, reason);
+                // Invalidate the spawn memory the moment the release is confirmed, so a
+                // retry for the same deterministic invocation spawns a real worker
+                // instead of inheriting this one's claim. Shutdown is excluded on
+                // purpose: nothing is being retried there, and a takeover must still be
+                // free to adopt agents this process merely stopped supervising.
+                if (record && batch && context !== 'stop') {
+                    const releasedInvocationId = batch.recordRelease(record, agentName, this.#clock.now());
+                    if (releasedInvocationId) {
+                        this.#logger.debug?.('[factory] released agent invocation is no longer dispatchable', {
+                            issue: record.issue.key,
+                            agentName,
+                            reason,
+                            invocationId: releasedInvocationId,
+                        });
+                    }
+                }
                 if (record)
                     await this.#reportAgent(record, tracked, 'agent.released', { releaseReason: reason });
             }
@@ -6506,7 +6803,10 @@ export class FactoryLoop {
         const batch = await this.#batch();
         const invocationId = batch.invocationIdFor(record.issue, spec);
         const existing = record.agents.get(spec.name);
-        if (existing?.result) {
+        // A released placement keeps its bookkeeping entry, but it is not a worker.
+        // Answering with its old spawn result here would report a synthetic success
+        // for a process that no longer exists.
+        if (existing?.result && existing.releasedAtMs === undefined) {
             this.#scheduleHeldAgentDeadline(record);
             return { name: existing.result?.name ?? spec.name };
         }
@@ -6556,6 +6856,7 @@ export class FactoryLoop {
             result = await this.#fleet.spawn({
                 name: spec.name,
                 capability: spec.capability,
+                identityKey: dispatchAgentIdentityKey(record.issue, spec.role),
                 node: spec.node ?? 'self',
                 repo: spec.repo,
                 task: spec.task,
@@ -6657,6 +6958,16 @@ export class FactoryLoop {
                 return;
             }
         }
+        // Swarm workers share the lead's checkout and lifecycle branch. If a worker
+        // exit reached the publication/completion paths below, whichever worker
+        // finished first would publish whatever partial state was on the shared
+        // branch and mark every swarm member "done" via the shared-branch PR probe,
+        // releasing the still-working lead. The lead alone is authoritative for
+        // publication and completion in a swarm.
+        if (exiting?.spec.swarmRole === 'worker') {
+            this.#increment('swarmWorkerExitsSuppressed');
+            return;
+        }
         if (isCompletionReason(reason)) {
             if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
                 openOnly: this.#config.babysitter.enabled,
@@ -6901,6 +7212,7 @@ export class FactoryLoop {
                     const result = await this.#fleet.spawn({
                         name: tracked.spec.name,
                         capability: tracked.spec.capability,
+                        identityKey: dispatchAgentIdentityKey(record.issue, tracked.spec.role),
                         node: tracked.result?.node ?? tracked.spec.node ?? 'self',
                         repo: tracked.spec.repo,
                         task: tracked.spec.task,
@@ -7024,6 +7336,7 @@ export class FactoryLoop {
     }
     async #publishImplementerPullRequest(record, implementer, opts = {}) {
         const key = `${issueKey(record.issue)}:${implementer.spec.repo}`;
+        const trajectorySessionRef = canonicalTrajectorySessionRef(implementer.sessionRef);
         const expectedHeadRef = implementer.spec.branch;
         if (!expectedHeadRef) {
             throw new Error(`Refusing to publish ${record.issue.key}: implementer has no Factory-derived branch`);
@@ -7089,7 +7402,7 @@ export class FactoryLoop {
             expectedHeadRef,
             baseRef,
             title: `${issue.key}: ${issue.title}`,
-            body: githubPullRequestBody(issue, implementer.spec.preview),
+            body: githubPullRequestBody(issue, implementer.spec.preview, trajectorySessionRef),
             ...(implementer.sessionRef ? { sessionRef: implementer.sessionRef } : {}),
         });
         const published = result.author
@@ -7678,7 +7991,7 @@ export class FactoryLoop {
         await this.#recordDispatchTerminal(record.issue);
         const next = (await this.#batch()).complete(record.issue);
         await this.#drainReadyClarificationWake();
-        await this.#stopSlackWatcher(record.issue);
+        await this.#retireSlackWatcher(record);
         await this.#stopGithubIssueCommentWatcherForIssue(record.issue);
         await this.#writeInFlightRegistry();
         if (next) {
@@ -7782,6 +8095,7 @@ export class FactoryLoop {
         const result = await this.#fleet.resume({
             name,
             sessionRef: tracked.sessionRef,
+            identityKey: dispatchAgentIdentityKey(record.issue, tracked.spec.role),
             node: tracked.result?.node ?? tracked.spec.node ?? 'self',
             capability: tracked.spec.capability,
             repo: tracked.spec.repo,
@@ -7910,6 +8224,7 @@ export class FactoryLoop {
                 const result = await this.#fleet.spawn({
                     name: replacementSpec.name,
                     capability: replacementSpec.capability,
+                    identityKey: dispatchAgentIdentityKey(record.issue, replacementSpec.role),
                     node: tracked.result?.node ?? replacementSpec.node ?? 'self',
                     repo: replacementSpec.repo,
                     task: replacementSpec.task,
@@ -9377,6 +9692,15 @@ export class FactoryLoop {
                         previewStartCommand: spec.preview?.startCommand,
                     } : {}),
                     ...(this.#fleet.lifecycleActionName ? { lifecycleActionName: this.#fleet.lifecycleActionName } : {}),
+                    ...(spec.swarmRole && spec.channel ? {
+                        swarm: {
+                            role: spec.swarmRole,
+                            channel: spec.channel,
+                            otherMemberNames: decision.implementers
+                                .filter((implementer) => implementer.channel === spec.channel && implementer.name !== spec.name)
+                                .map((implementer) => implementer.name),
+                        },
+                    } : {}),
                 }),
             };
         };
@@ -10897,7 +11221,7 @@ export class FactoryLoop {
             });
             return;
         }
-        const issue = await this.#findMergeAdvanceIssueForPr(snapshot);
+        const issue = await this.#findMergeAdvanceIssueForPr(snapshot, repo);
         if (!issue) {
             this.#increment('mergedPrAdvanceNoIssue');
             return;
@@ -10952,7 +11276,7 @@ export class FactoryLoop {
             this.#error(error, issueRef(issue));
         }
     }
-    async #findMergeAdvanceIssueForPr(snapshot) {
+    async #findMergeAdvanceIssueForPr(snapshot, eventRepo) {
         // An issue is "upstream" of a merge if it sits in the agent-implementing or
         // human-review role for its team. UUIDs are globally unique, so the reverse
         // role lookup covers every team without per-team scoping here.
@@ -10961,16 +11285,34 @@ export class FactoryLoop {
             return role === 'agentImplementing' || role === 'humanReview';
         };
         let best;
+        let ambiguous = false;
         const scanStartedAtMs = this.#clock.now();
         // This no-record path runs after agents are released, so there is no
         // tracked PR identity left. Keep the scan simple and prefer branch identity
         // over title/body references to avoid "related to AR-N" body false positives.
         const githubSource = await this.#issueSource() === 'github';
+        // A GitHub-native issue key is a bare number; the same number exists
+        // independently in every configured repository. Only a same-repo candidate
+        // may complete the merge, so a merged PR in one repo can never close an
+        // unrelated issue that happens to share its number in another. #276.
+        const eventRepoKey = validGithubRepo(eventRepo) ? eventRepo.toLowerCase() : undefined;
+        if (githubSource && !eventRepoKey) {
+            this.#logger.warn?.('[factory] merge advance skipped: event repo is not identifiable', {
+                prNumber: snapshot.number,
+            });
+            return undefined;
+        }
         const paths = githubSource ? await this.#githubIssuePaths() : await this.#listRelayfileTree(ISSUE_ROOT, 'merge advance issue scan');
         for (const path of paths) {
             if (githubSource ? !isGithubIssueFilePath(path) : !isIssueFilePath(path)) {
                 continue;
             }
+            if (githubSource) {
+                const issueParts = githubIssuePathParts(path);
+                if (!issueParts || `${issueParts.owner}/${issueParts.repo}`.toLowerCase() !== eventRepoKey) {
+                    continue;
+                }
+            }
             const issue = await this.#readIssue(path);
             if (!issue || (githubSource
                 ? issue.state?.name?.trim().toLowerCase() === 'closed'
@@ -10983,10 +11325,27 @@ export class FactoryLoop {
             const score = prSnapshotIssueMatchScore(snapshot, issue.key);
             if (score > 0 && (!best || score > best.score)) {
                 best = { issue, score };
+                ambiguous = false;
+            }
+            else if (score > 0 && best && score === best.score) {
+                ambiguous = true;
             }
         }
+        // Fail-closed on a tie. A silent first-wins on unrelated same-score
+        // candidates is the exact class of quiet corruption we are removing.
+        if (ambiguous) {
+            this.#increment('mergedPrAdvanceAmbiguous');
+            this.#logger.warn?.('[factory] merge advance skipped: multiple candidates tied on match score', {
+                prNumber: snapshot.number,
+                eventRepo,
+                matchedIssue: best?.issue.key,
+                matchScore: best?.score,
+            });
+            return undefined;
+        }
         this.#logger.debug?.(`[factory] scanned ${githubSource ? 'GitHub' : 'Linear'} issues for merged PR advance`, {
             prNumber: snapshot.number,
+            eventRepo,
             durationMs: this.#clock.now() - scanStartedAtMs,
             matchedIssue: best?.issue.key,
             matchScore: best?.score,
@@ -11592,7 +11951,7 @@ export class FactoryLoop {
             }
             if (!await this.#saveDispatchLifecycle(record, 'releasing', undefined, releaseReason))
                 return;
-            await this.#stopSlackWatcher(record.issue);
+            await this.#retireSlackWatcher(record);
             await this.#stopGithubIssueCommentWatcherForIssue(record.issue);
             await this.#recordDispatchTerminal(record.issue);
             await this.#finishDurableRelease(record, releaseReason);
@@ -12070,6 +12429,21 @@ export class FactoryLoop {
             return;
         }
         const key = issueKey(record.issue);
+        const previousWatch = (await this.#state.listSlackThreadWatches(this.#workspaceId))
+            .find(([watchKey]) => watchKey === key)?.[1];
+        if (previousWatch?.kind === 'terminal-grace') {
+            // A reopened work unit needs a fresh dispatch notification and a fresh
+            // conversation. Do not let the old grace-period watcher (or its expiry
+            // timer) capture and later tear down the new dispatch.
+            if (!await this.#stopSlackWatcher(record.issue)) {
+                // Fail closed. An undrained reply route still holds the retired thread
+                // and would bind it to this dispatch, delivering a stale human reply to
+                // fresh work. Leave the fence up; the next reconcile retries the drain.
+                this.#logger.warn?.('[factory] deferring Slack dispatch thread for reopened work unit; in-flight reply route not drained', { issue: record.issue.key });
+                this.#increment('slackDispatchThreadsDeferredUndrainedReply');
+                return;
+            }
+        }
         const existingThread = await this.#persistedSlackThread(key);
         const watcherStart = this.#slackWatcherStarts.get(key);
         if (existingThread || watcherStart) {
@@ -12152,11 +12526,13 @@ export class FactoryLoop {
         if (existing) {
             const sessionRef = owned?.tracked.sessionRef;
             const agentName = owned ? (owned.tracked.result?.name ?? owned.name) : undefined;
+            let rebound = false;
             if (owned && sessionRef &&
-                (agentName !== existing.agent.name || (options.forceAgentRebind === true && sessionRef !== existing.agent.sessionRef))) {
-                const rebound = await this.#state.rebindConversationSession(this.#workspaceId, conversationId, {
+                (!existing.agent || agentName !== existing.agent.name || (options.forceAgentRebind === true && sessionRef !== existing.agent.sessionRef))) {
+                rebound = await this.#state.rebindConversationSession(this.#workspaceId, conversationId, {
                     name: agentName,
                     sessionRef,
+                    role: owned.tracked.spec.role,
                     node: owned.tracked.result?.node ?? owned.tracked.spec.node,
                     capability: owned.tracked.spec.capability,
                     repo: owned.tracked.spec.repo,
@@ -12167,39 +12543,39 @@ export class FactoryLoop {
             }
             if (existing.pending.length > 0 || existing.delivery) {
                 const waiting = await this.#state.getWaitingClarification(this.#workspaceId, issueKey(existing.issue));
-                if (!waiting)
+                if (!waiting && (existing.agent || rebound))
                     this.#slackConversationTurns.schedule(conversationId);
             }
             return;
         }
         const sessionRef = owned?.tracked.sessionRef;
-        if (!owned || !sessionRef) {
-            this.#increment('slackConversationSessionsSkippedMissingSession');
-            return;
-        }
         const channelDir = await this.#slackChannelDir() ?? this.#config.slack?.channel;
         if (!channelDir)
             return;
-        const agentName = owned.tracked.result?.name ?? owned.name;
+        const agentName = owned ? (owned.tracked.result?.name ?? owned.name) : undefined;
         const reserved = await this.#state.reserveConversationSession(this.#workspaceId, conversationId, {
             provider: 'slack',
             issue: { ...record.issue },
             externalId: threadId,
             context: { channelDir },
-            agent: {
-                name: agentName,
-                sessionRef,
-                node: owned.tracked.result?.node ?? owned.tracked.spec.node,
-                capability: owned.tracked.spec.capability,
-                repo: owned.tracked.spec.repo,
-                clonePath: owned.tracked.spec.clonePath,
-            },
+            ...(owned && sessionRef && agentName ? { agent: {
+                    name: agentName,
+                    sessionRef,
+                    role: owned.tracked.spec.role,
+                    node: owned.tracked.result?.node ?? owned.tracked.spec.node,
+                    capability: owned.tracked.spec.capability,
+                    repo: owned.tracked.spec.repo,
+                    clonePath: owned.tracked.spec.clonePath,
+                } } : {}),
             history: [],
             processedMessageIds: [],
+            acknowledgedMessageIds: [],
+            acknowledgementClaims: {},
             pending: [],
         });
-        if (reserved)
-            this.#increment('slackConversationSessionsOwned');
+        if (reserved) {
+            this.#increment(owned && sessionRef ? 'slackConversationSessionsOwned' : 'slackConversationSessionsReservedUnowned');
+        }
     }
     // Called right after a babysitter is spawned/reattached for an issue's PR so
     // an already-owned Slack conversation session (reserved earlier by the
@@ -12227,11 +12603,15 @@ export class FactoryLoop {
         const claimed = await this.#state.claimConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId, this.#clock.now(), SLACK_CONVERSATION_TURN_LEASE_MS);
         if (!claimed?.delivery) {
             const current = await this.#state.getConversationSession(this.#workspaceId, conversationId);
-            if (current && (current.pending.length > 0 || current.delivery)) {
+            if (current?.agent && (current.pending.length > 0 || current.delivery)) {
                 this.#slackConversationTurns.schedule(conversationId, SLACK_CONVERSATION_TURN_RETRY_MS);
             }
             return;
         }
+        if (!claimed.agent) {
+            await this.#state.releaseConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId);
+            return;
+        }
         if (!await this.#ownsActiveSlackConversationIssue(claimed.issue)) {
             await this.#state.releaseConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId);
             this.#increment('slackConversationTurnsSuppressedStaleOwner');
@@ -12252,9 +12632,20 @@ export class FactoryLoop {
         }, Math.max(1_000, Math.floor(SLACK_CONVERSATION_TURN_LEASE_MS / 3)));
         heartbeat.unref?.();
         try {
+            // Sessions bound after this field was introduced carry their role
+            // durably, so resume never depends on a live lookup by the agent's
+            // current name — which a since-completed rename (e.g. babysitter
+            // retarget) can otherwise leave unresolvable forever. Older
+            // already-persisted sessions fall back to the live lookup.
+            const conversationRole = claimed.agent.role
+                ?? (await this.#batch()).getIssueByAgent(claimed.agent.name)?.agents.get(claimed.agent.name)?.spec.role;
+            if (!conversationRole) {
+                throw new Error(`Cannot resume ${claimed.agent.name}: its dispatch role is unavailable for identity proof`);
+            }
             const result = await this.#fleet.resume({
                 name: claimed.agent.name,
                 sessionRef: claimed.agent.sessionRef,
+                identityKey: dispatchAgentIdentityKey(claimed.issue, conversationRole),
                 node: claimed.agent.node ?? 'self',
                 capability: claimed.agent.capability,
                 repo: claimed.agent.repo,
@@ -12304,10 +12695,13 @@ export class FactoryLoop {
         }
     }
     async #recordSlackConversationResume(session, result) {
+        const sessionAgent = session.agent;
+        if (!sessionAgent)
+            return;
         const record = (await this.#batch()).getIssue(session.issue);
         if (!record)
             return;
-        const entry = [...record.agents.entries()].find(([name, tracked]) => name === session.agent.name || tracked.result?.name === session.agent.name);
+        const entry = [...record.agents.entries()].find(([name, tracked]) => name === sessionAgent.name || tracked.result?.name === sessionAgent.name);
         if (!entry)
             return;
         const [previousName, tracked] = entry;
@@ -12633,7 +13027,14 @@ export class FactoryLoop {
                 `Question: ${triageEscalationQuestion(decision, issue)}`,
             ].join('\n'),
         });
-        await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId);
+        const key = issueKey(decision.issue);
+        await this.#state.setSlackThread(this.#workspaceId, key, root.threadId);
+        await this.#state.setSlackThreadWatch(this.#workspaceId, key, {
+            kind: 'triage',
+            issue: { ...decision.issue },
+            decision: structuredClone(decision),
+            threadId: root.threadId,
+        });
         const replayedResult = await this.#watchSlackThread(escalationWatchRecord(decision), root.threadId);
         this.#recordSlackWritebackSuccess('triage-escalation');
         return replayedResult;
@@ -12699,6 +13100,11 @@ export class FactoryLoop {
                 if (!reply || !reply.isThreadReply || reply.threadTs !== threadId || reply.channelDir !== channelDir) {
                     return;
                 }
+                if (allowPreExisting &&
+                    options.replayAfterMs !== undefined &&
+                    slackMessageReceivedAtMs(reply.messageTs, Number.MAX_SAFE_INTEGER) < options.replayAfterMs) {
+                    return;
+                }
                 const replyMessageKey = `${reply.threadTs}:${reply.messageTs}`;
                 if (seenReplyMessages.has(replyMessageKey)) {
                     this.#logger.debug?.('[factory] suppressed duplicate Slack reply message', { issue: record.issue.key, path });
@@ -12877,6 +13283,47 @@ export class FactoryLoop {
                 this.#slackConversationTurns.schedule(conversationId);
             }
         }
+        for (const [key, watch] of await this.#state.listSlackThreadWatches(this.#workspaceId)) {
+            if (this.#slackWatchers.has(key) || this.#slackWatcherStarts.has(key))
+                continue;
+            if (watch.kind === 'terminal-grace' && watch.expiresAtMs <= this.#clock.now()) {
+                await this.#stopSlackWatcher(watch.issue);
+                continue;
+            }
+            await this.#state.setSlackThread(this.#workspaceId, key, watch.threadId);
+            const watchRecord = escalationWatchRecord(watch.decision);
+            if (watch.kind === 'terminal-grace') {
+                const retiredAtMs = terminalSlackWatchRetiredAtMs(watch);
+                if (watch.retiredAtMs !== retiredAtMs) {
+                    await this.#state.setSlackThreadWatch(this.#workspaceId, key, { ...watch, retiredAtMs });
+                }
+                this.#terminalSlackWatchIssues.add(key);
+                const conversationId = slackConversationId(watch.threadId);
+                await this.#slackConversationTurns.cancel(conversationId);
+                try {
+                    await this.#surfaceUndeliveredSlackConversation(watch.threadId);
+                    await this.#state.clearConversationSession(this.#workspaceId, conversationId);
+                }
+                catch (error) {
+                    // The undelivered-reply receipt needs Slack writeback, which may be
+                    // unavailable at startup. That is retryable state maintenance for this
+                    // one thread, not a reason to abandon rehydration: aborting here would
+                    // leave every remaining thread watched by nobody. Keep the queued
+                    // replies (clearing them now would drop replies nobody was told about)
+                    // and carry on re-arming.
+                    this.#logger.warn?.('[factory] failed to settle undelivered Slack replies for terminal watch; will retry', { issue: watch.issue.key, error });
+                    this.#increment('slackTerminalWatchReceiptsDeferred');
+                    this.#scheduleSlackTerminalReceiptRetry(watch.issue, watch.threadId, watch.expiresAtMs);
+                }
+                await this.#rearmSlackWatcher(watchRecord, watch.threadId, {
+                    replayConversationReplies: true,
+                    replayAfterMs: retiredAtMs,
+                });
+                this.#scheduleSlackTerminalWatchExpiry(watch.issue, watch.expiresAtMs);
+                continue;
+            }
+            await this.#rearmSlackWatcher(watchRecord, watch.threadId, { replayConversationReplies: true });
+        }
         await this.#sweepWaitingClarifications();
         for (const [, waiting] of await this.#state.listWaitingClarifications(this.#workspaceId)) {
             if (!waiting.threadId)
@@ -13022,8 +13469,73 @@ export class FactoryLoop {
         this.#clarificationSweepTimer = timer;
         this.#clarificationSweepDueAtMs = dueAtMs;
     }
+    // The terminal fence is the only thing that makes an in-flight reply route
+    // answer "no active agent" instead of binding the retired thread to whatever
+    // dispatch owns this key. Routes are chained per work unit, so awaiting the
+    // newest one drains every reply queued behind it.
+    async #drainSlackReplyRoutes(key) {
+        // Snapshotting #slackReplyRoutes is not enough on its own. A reply handler
+        // that is still inside its mount read when the drain starts registers its
+        // route *after* the snapshot, so it would run once the fence is gone and
+        // bind the retired thread to the next dispatch — the same escape one level
+        // in. Bar *routing* for this key first (the bar and the registration are
+        // both synchronous, so nothing can slip between them), then drain whatever
+        // is already chained, then prove the set is empty before reporting success.
+        // A barred reply still answers the human, and that writeback registers here
+        // like any other effect, so the extra passes are what pick it up: quiescence
+        // means every effect this work unit started has settled, not merely the ones
+        // that existed when the drain began.
+        const nested = this.#slackReplyRouteDrains.has(key);
+        this.#slackReplyRouteDrains.add(key);
+        try {
+            for (let pass = 0; pass < SLACK_REPLY_ROUTE_DRAIN_PASSES; pass += 1) {
+                const route = this.#slackReplyRoutes.get(key);
+                if (!route)
+                    return true;
+                try {
+                    await route;
+                }
+                catch (error) {
+                    // A route that *rejects* is not drained: the watcher replays it after
+                    // SLACK_REPLY_ROUTE_RETRY_MS, and that replay would land on the next
+                    // dispatch. Fail closed and let the caller keep the fence up rather
+                    // than leak a stale human reply onto fresh work.
+                    this.#logger.warn?.('[factory] in-flight Slack reply route did not drain; keeping terminal Slack fence', { issue: key, error });
+                    this.#increment('slackReplyRouteDrainsFailed');
+                    return false;
+                }
+                // The owner clears its own entry when it settles; retiring it here too
+                // keeps the loop monotonic if that finally has not run yet.
+                if (this.#slackReplyRoutes.get(key) === route)
+                    this.#slackReplyRoutes.delete(key);
+            }
+            // Not provably quiescent. Fail closed for the same reason as a rejection.
+            this.#logger.warn?.('[factory] Slack reply routes did not quiesce; keeping terminal Slack fence', { issue: key });
+            this.#increment('slackReplyRouteDrainsFailed');
+            return false;
+        }
+        finally {
+            if (!nested)
+                this.#slackReplyRouteDrains.delete(key);
+        }
+    }
     async #stopSlackWatcher(issue) {
         const key = issueKey(issue);
+        // Drain before clearing the fence. Clearing it first lets a reply that is
+        // already mid-route — or one queued behind it — fall through the fence check
+        // in #routeSlackConversationAnswerUnlocked and rebind the retired thread to
+        // the next dispatch of this work unit.
+        if (!await this.#drainSlackReplyRoutes(key))
+            return false;
+        this.#terminalSlackWatchIssues.delete(key);
+        const expiryTimer = this.#slackTerminalWatchExpiryTimers.get(key);
+        if (expiryTimer)
+            clearTimeout(expiryTimer);
+        this.#slackTerminalWatchExpiryTimers.delete(key);
+        const receiptRetryTimer = this.#slackTerminalReceiptRetryTimers.get(key);
+        if (receiptRetryTimer)
+            clearTimeout(receiptRetryTimer);
+        this.#slackTerminalReceiptRetryTimers.delete(key);
         const watcher = this.#slackWatchers.get(key);
         this.#slackWatchers.delete(key);
         const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
@@ -13034,6 +13546,259 @@ export class FactoryLoop {
             await this.#state.clearConversationSession(this.#workspaceId, conversationId);
         }
         await this.#state.clearSlackThread(this.#workspaceId, key);
+        await this.#state.clearSlackThreadWatch(this.#workspaceId, key);
+        return true;
+    }
+    async #retireSlackWatcher(record) {
+        const key = issueKey(record.issue);
+        const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
+        if (!threadId) {
+            await this.#stopSlackWatcher(record.issue);
+            return;
+        }
+        const existingWatch = (await this.#state.listSlackThreadWatches(this.#workspaceId))
+            .find(([watchKey]) => watchKey === key)?.[1];
+        const retiredAtMs = existingWatch?.kind === 'terminal-grace'
+            ? terminalSlackWatchRetiredAtMs(existingWatch)
+            : this.#clock.now();
+        const expiresAtMs = existingWatch?.kind === 'terminal-grace'
+            ? existingWatch.expiresAtMs
+            : retiredAtMs + SLACK_TERMINAL_THREAD_GRACE_MS;
+        await this.#state.setSlackThreadWatch(this.#workspaceId, key, {
+            kind: 'terminal-grace',
+            issue: { ...record.issue },
+            decision: structuredClone(record.decision),
+            threadId,
+            retiredAtMs,
+            expiresAtMs,
+        });
+        // A terminal thread must never retain a resumable session for an agent that
+        // has already exited. Keep only the exact-thread listener so a late human
+        // reply receives the explicit no-active-agent writeback below.
+        this.#terminalSlackWatchIssues.add(key);
+        await this.#slackReplyRoutes.get(key)?.catch(() => undefined);
+        const conversationId = slackConversationId(threadId);
+        await this.#slackConversationTurns.cancel(conversationId);
+        try {
+            await this.#surfaceUndeliveredSlackConversation(threadId);
+            await this.#state.clearConversationSession(this.#workspaceId, conversationId);
+        }
+        catch (error) {
+            // The receipt fails whenever another handler holds the claim or Slack
+            // writeback is down — neither is a reason to abort retirement. Callers
+            // reach here having already committed the terminal phase and dropped the
+            // pending abandon reason, so a rejection escaping would strand the
+            // registry rewrite, the GitHub watcher stop, and the queued next dispatch
+            // with nothing left to re-run them. Keep the queued replies and let the
+            // retry that owns this receipt settle it inside the grace window.
+            this.#logger.warn?.('[factory] failed to settle undelivered Slack replies while retiring the watcher; will retry', { issue: record.issue.key, error });
+            this.#increment('slackTerminalWatchReceiptsDeferred');
+            this.#scheduleSlackTerminalReceiptRetry(record.issue, threadId, expiresAtMs);
+        }
+        if (!this.#slackWatchers.has(key) && !this.#stopping) {
+            await this.#rearmSlackWatcher(record, threadId);
+        }
+        this.#scheduleSlackTerminalWatchExpiry(record.issue, expiresAtMs);
+        this.#increment('slackTerminalWatchersRetained');
+    }
+    // The durable half of the same record. Every caller here follows the receipt
+    // with a state write (clearing the session), and those two cannot be one
+    // durable step: when the state write fails, the retry that owns it must not
+    // read "replies still queued" as "the human has not been told" and post the
+    // notice again. So the receipt is claimed before the provider write and marked
+    // posted after it, and a retry finds it already settled.
+    async #surfaceUndeliveredSlackConversation(threadId) {
+        const conversationId = slackConversationId(threadId);
+        const session = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        const pendingCount = session
+            ? session.pending.length + (session.delivery?.messages.length ?? 0)
+            : 0;
+        if (pendingCount === 0)
+            return;
+        if (session?.terminalReceipt?.posted) {
+            this.#increment('slackTerminalReceiptsAlreadySettled');
+            return;
+        }
+        if (!this.#slack)
+            throw new Error(`Slack thread ${threadId} cannot surface undelivered replies without writeback`);
+        const claimId = randomUUID();
+        if (!await this.#state.claimConversationTerminalReceipt(this.#workspaceId, conversationId, claimId, this.#clock.now(), SLACK_TERMINAL_RECEIPT_CLAIM_LEASE_MS)) {
+            const current = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+            if (current?.terminalReceipt?.posted) {
+                this.#increment('slackTerminalReceiptsAlreadySettled');
+                return;
+            }
+            // Another handler is mid-write. Fail closed so the queued replies survive
+            // for whoever settles them rather than racing a second notice onto the
+            // same thread.
+            throw new Error(`Slack thread ${threadId} terminal receipt is claimed by another handler; retrying`);
+        }
+        const noun = pendingCount === 1 ? 'reply' : 'replies';
+        const slack = this.#slack;
+        try {
+            await this.#withRenewedProviderLease('terminal Slack receipt', SLACK_TERMINAL_RECEIPT_CLAIM_LEASE_MS, () => this.#state.renewConversationTerminalReceipt(this.#workspaceId, conversationId, claimId, this.#clock.now()), () => slack.reply(threadId, `Factory could not deliver ${pendingCount} queued ${noun} because this work unit no longer has an active agent. Please continue on the linked issue or pull request.`));
+        }
+        catch (error) {
+            await this.#state.releaseConversationTerminalReceipt(this.#workspaceId, conversationId, claimId);
+            throw error;
+        }
+        if (!await this.#state.completeConversationTerminalReceipt(this.#workspaceId, conversationId, claimId)) {
+            throw new Error(`Slack thread ${threadId} terminal receipt could not be recorded`);
+        }
+        this.#increment('slackConversationRepliesSurfacedTerminal');
+    }
+    // A claim only means something for as long as it outlives the work it covers.
+    // A provider write can legitimately run past a fixed lease, at which point the
+    // claim stops protecting the write it was taken for and a second handler can
+    // post the same thing to the same human. Renewing on a heartbeat scopes the
+    // lease to the work instead of to a guessed duration, and leaves the idle
+    // timeout short enough that a holder that dies mid-write still frees it.
+    //
+    // The heartbeat is bounded on both ends, because a renewal loop that never
+    // stops is a lock with no owner check: a provider write that hangs would hold
+    // the receipt past every retry and past shutdown, and the human whose reply is
+    // queued behind it would be told nothing until the process restarts. So it
+    // stops at the ceiling and it stops when this daemon is stopping, and either
+    // way it says so — from there the claim ages out on its own idle lease and
+    // becomes reclaimable. The write may still land afterwards and duplicate the
+    // notice; a reply nobody can ever reclaim is the worse of the two.
+    async #withRenewedProviderLease(label, leaseMs, renew, run) {
+        const renewUntilMs = this.#clock.now() + SLACK_PROVIDER_LEASE_MAX_RENEWAL_MS;
+        let renewalStopped = false;
+        let renewalInFlight = false;
+        const stopRenewing = (counter, reason) => {
+            renewalStopped = true;
+            this.#increment(counter);
+            this.#logger.warn?.(`[factory] ${label} lease will not be renewed further (${reason}); ` +
+                'its claim expires and the queued replies return to whoever retries them');
+        };
+        const heartbeat = setInterval(() => {
+            if (renewalInFlight || renewalStopped)
+                return;
+            if (this.#stopping) {
+                stopRenewing('slackProviderReceiptLeaseRenewalsStoppedForShutdown', 'shutting down');
+                return;
+            }
+            if (this.#clock.now() >= renewUntilMs) {
+                stopRenewing('slackProviderReceiptLeaseRenewalsExpired', `provider write exceeded ${SLACK_PROVIDER_LEASE_MAX_RENEWAL_MS}ms`);
+                return;
+            }
+            renewalInFlight = true;
+            void renew()
+                .then((renewed) => {
+                if (renewed)
+                    return;
+                // Losing the lease mid-write is not recoverable from in here: the
+                // write may already have landed. Stop renewing and let the caller's
+                // completion check fail closed, which keeps the queued replies for
+                // whoever holds the claim now.
+                renewalStopped = true;
+                this.#increment('slackProviderReceiptLeasesLost');
+                this.#logger.warn?.(`[factory] ${label} lease was lost while its provider write was in flight`);
+            })
+                .catch((error) => this.#logger.warn?.(`[factory] ${label} lease renewal failed`, {
+                error: describeError(error).errorMessage,
+            }))
+                .finally(() => { renewalInFlight = false; });
+        }, Math.max(1_000, Math.floor(leaseMs / 3)));
+        heartbeat.unref?.();
+        try {
+            return await run();
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+    }
+    // A terminal receipt that could not be written leaves the queued replies
+    // pending with the human who wrote them told nothing. That is retryable
+    // maintenance this daemon owns, not work to leave for the next restart: the
+    // grace watch is the only window in which the receipt can still land on the
+    // retired thread, so keep reattempting inside it and give up when it closes.
+    #scheduleSlackTerminalReceiptRetry(issue, threadId, expiresAtMs, attempt = 0) {
+        if (this.#stopping)
+            return;
+        const key = issueKey(issue);
+        const existing = this.#slackTerminalReceiptRetryTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        this.#slackTerminalReceiptRetryTimers.delete(key);
+        const remainingMs = expiresAtMs - this.#clock.now();
+        if (remainingMs <= 0) {
+            this.#increment('slackTerminalWatchReceiptsAbandoned');
+            return;
+        }
+        const backoffMs = Math.min(SLACK_TERMINAL_RECEIPT_RETRY_MAX_MS, SLACK_TERMINAL_RECEIPT_RETRY_MS * 2 ** Math.min(attempt, 16));
+        const timer = setTimeout(() => {
+            this.#slackTerminalReceiptRetryTimers.delete(key);
+            void this.#retrySlackTerminalReceipt(issue, threadId, attempt);
+        }, Math.max(0, Math.min(backoffMs, remainingMs)));
+        timer.unref?.();
+        this.#slackTerminalReceiptRetryTimers.set(key, timer);
+    }
+    async #retrySlackTerminalReceipt(issue, threadId, attempt) {
+        if (this.#stopping)
+            return;
+        const key = issueKey(issue);
+        const watch = (await this.#state.listSlackThreadWatches(this.#workspaceId))
+            .find(([watchKey]) => watchKey === key)?.[1];
+        // The grace watch is gone (expired, or the work unit reopened): the thread
+        // this receipt would settle no longer exists, so there is nothing to say.
+        if (watch?.kind !== 'terminal-grace' || watch.threadId !== threadId)
+            return;
+        try {
+            await this.#surfaceUndeliveredSlackConversation(threadId);
+            await this.#state.clearConversationSession(this.#workspaceId, slackConversationId(threadId));
+            this.#increment('slackTerminalWatchReceiptsRecovered');
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] terminal Slack receipt retry failed; rescheduling', {
+                issue: issue.key,
+                error,
+            });
+            this.#increment('slackTerminalWatchReceiptRetryFailures');
+            this.#scheduleSlackTerminalReceiptRetry(issue, threadId, watch.expiresAtMs, attempt + 1);
+        }
+    }
+    #scheduleSlackTerminalWatchExpiry(issue, expiresAtMs, retryDelayMs) {
+        if (this.#stopping)
+            return;
+        const key = issueKey(issue);
+        const existing = this.#slackTerminalWatchExpiryTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.#slackTerminalWatchExpiryTimers.delete(key);
+            void this.#expireSlackTerminalWatcher(issue, expiresAtMs).catch((error) => {
+                this.#logger.warn?.('[factory] failed to expire terminal Slack reply watcher; retrying', {
+                    issue: issue.key,
+                    error,
+                });
+                this.#scheduleSlackTerminalWatchExpiry(issue, expiresAtMs, SLACK_REPLY_ROUTE_RETRY_MS);
+            });
+        }, retryDelayMs ?? Math.max(0, expiresAtMs - this.#clock.now()));
+        timer.unref?.();
+        this.#slackTerminalWatchExpiryTimers.set(key, timer);
+    }
+    async #expireSlackTerminalWatcher(issue, expiresAtMs) {
+        const key = issueKey(issue);
+        const watch = (await this.#state.listSlackThreadWatches(this.#workspaceId))
+            .find(([watchKey]) => watchKey === key)?.[1];
+        if (watch?.kind !== 'terminal-grace' || watch.expiresAtMs !== expiresAtMs)
+            return;
+        if (watch.expiresAtMs > this.#clock.now()) {
+            this.#scheduleSlackTerminalWatchExpiry(issue, watch.expiresAtMs);
+            return;
+        }
+        // #stopSlackWatcher fails closed when an in-flight reply route will not
+        // drain, leaving the watch and its terminal fence in place. Counting that as
+        // an expiration retires the watch in the metrics while the real one lives
+        // on unwatched by any expiry timer, so reschedule and count only on success.
+        if (!await this.#stopSlackWatcher(issue)) {
+            this.#increment('slackTerminalWatchExpiriesDeferred');
+            this.#scheduleSlackTerminalWatchExpiry(issue, expiresAtMs, SLACK_REPLY_ROUTE_RETRY_MS);
+            return;
+        }
+        this.#increment('slackTerminalWatchersExpired');
     }
     async #readSlackReply(path) {
         try {
@@ -13098,33 +13863,147 @@ export class FactoryLoop {
             await this.#wakeWaitingClarification(clarificationKey, claimed);
             return;
         }
+        return await this.#routeSlackConversationAnswer(record, reply, text, clarificationKey);
+    }
+    async #routeSlackConversationAnswer(record, reply, text, clarificationKey) {
+        if (this.#slackReplyRouteDrains.has(clarificationKey)) {
+            // The terminal fence for this work unit is being drained right now.
+            // Registering an ordinary route here would put it past the drain's
+            // snapshot and run it once the fence is gone. Answer it the way the fence
+            // would have — but as a tracked effect, because this writeback is still a
+            // side effect of this work unit. Left untracked it is the same escape one
+            // level further in: the drain reports quiescence without it, the watcher
+            // stop clears the retry timer that owns this reply, and a slow or failed
+            // receipt leaves the human told nothing at all.
+            this.#increment('slackReplyRoutesFencedDuringDrain');
+            return await this.#trackSlackWorkUnitEffect(clarificationKey, async () => {
+                await this.#writeUnroutableSlackReply(reply.threadTs);
+                return undefined;
+            });
+        }
+        return await this.#trackSlackWorkUnitEffect(clarificationKey, () => this.#routeSlackConversationAnswerUnlocked(record, reply, text, clarificationKey));
+    }
+    // Every Slack side effect a work unit makes on its own behalf runs through
+    // here, so #slackReplyRoutes stays the single record the terminal drain
+    // consults. Effects are chained per work unit: awaiting the newest one drains
+    // everything queued behind it, and a rejection propagates to the drain, which
+    // fails closed rather than tearing the effect's retry path down.
+    async #trackSlackWorkUnitEffect(key, run) {
+        const preceding = this.#slackReplyRoutes.get(key);
+        const effect = (async () => {
+            await preceding?.catch(() => undefined);
+            return await run();
+        })();
+        this.#slackReplyRoutes.set(key, effect);
+        try {
+            return await effect;
+        }
+        finally {
+            if (this.#slackReplyRoutes.get(key) === effect)
+                this.#slackReplyRoutes.delete(key);
+        }
+    }
+    async #routeSlackConversationAnswerUnlocked(record, reply, text, clarificationKey) {
+        if (this.#terminalSlackWatchIssues.has(clarificationKey)) {
+            await this.#writeUnroutableSlackReply(reply.threadTs);
+            return;
+        }
         const conversationId = slackConversationId(reply.threadTs);
-        const conversation = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        let conversation = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        let liveRecord;
+        if (!conversation) {
+            liveRecord = (await this.#batch()).getIssue(record.issue);
+            if (liveRecord && !liveRecord.dryRun) {
+                await this.#ensureSlackConversationSession(liveRecord, reply.threadTs);
+                conversation = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+            }
+        }
         if (conversation && issueKey(conversation.issue) === clarificationKey) {
+            const replyId = `${reply.threadTs}:${reply.messageTs}`;
             const queued = await this.#state.appendConversationMessage(this.#workspaceId, conversationId, {
-                id: `${reply.threadTs}:${reply.messageTs}`,
+                id: replyId,
                 text,
                 receivedAtMs: slackMessageReceivedAtMs(reply.messageTs, this.#clock.now()),
                 providerSequence: reply.messageTs,
                 author: reply.author,
             });
-            if (!queued) {
+            const durable = queued ?? await this.#state.getConversationSession(this.#workspaceId, conversationId);
+            if (!durable || !durable.processedMessageIds.includes(replyId)) {
+                throw new Error(`Slack reply ${replyId} was not durably queued`);
+            }
+            if (!(durable.acknowledgedMessageIds ?? []).includes(replyId)) {
+                const acknowledgementClaimId = randomUUID();
+                const acknowledgementClaimed = await this.#state.claimConversationMessageAcknowledgement(this.#workspaceId, conversationId, replyId, acknowledgementClaimId, this.#clock.now(), SLACK_REPLY_ACKNOWLEDGEMENT_LEASE_MS);
+                if (acknowledgementClaimed) {
+                    try {
+                        if (!this.#slack)
+                            throw new Error(`Slack reply ${replyId} cannot be acknowledged without writeback`);
+                        const owner = durable.agent?.role === 'babysitter'
+                            ? 'the PR babysitter'
+                            : durable.agent
+                                ? 'the issue implementer'
+                                : 'an issue agent';
+                        const receipt = durable.agent
+                            ? `Factory received this reply and durably queued it for ${owner}.`
+                            : 'Factory received and durably stored this reply; it will route when an issue agent is resumable.';
+                        const slack = this.#slack;
+                        // Same lease scope as the terminal receipt: this claim covers a
+                        // provider write that can outrun any fixed duration, so it is
+                        // renewed for as long as that write is actually running.
+                        await this.#withRenewedProviderLease('Slack reply acknowledgement', SLACK_REPLY_ACKNOWLEDGEMENT_LEASE_MS, () => this.#state.renewConversationMessageAcknowledgement(this.#workspaceId, conversationId, replyId, acknowledgementClaimId, this.#clock.now()), () => slack.reply(reply.threadTs, receipt));
+                        if (!await this.#state.completeConversationMessageAcknowledgement(this.#workspaceId, conversationId, replyId, acknowledgementClaimId)) {
+                            throw new Error(`Slack reply ${replyId} receipt could not be recorded`);
+                        }
+                        this.#increment('slackConversationRepliesAcknowledged');
+                    }
+                    catch (error) {
+                        await this.#state.releaseConversationMessageAcknowledgement(this.#workspaceId, conversationId, replyId, acknowledgementClaimId);
+                        throw error;
+                    }
+                }
+                else {
+                    const acknowledgementState = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+                    if (!(acknowledgementState?.acknowledgedMessageIds ?? []).includes(replyId)) {
+                        throw new Error(`Slack reply ${replyId} receipt is claimed by another handler; retrying`);
+                    }
+                }
+            }
+            if (queued) {
+                this.#increment('slackConversationRepliesQueued');
+            }
+            else {
                 this.#increment('slackConversationDuplicateRepliesSuppressed');
-                return;
             }
-            this.#increment('slackConversationRepliesQueued');
-            this.#slackConversationTurns.schedule(conversationId);
+            const pending = durable.pending.some((message) => message.id === replyId) ||
+                Boolean(durable.delivery?.messages.some((message) => message.id === replyId));
+            if (pending && durable.agent) {
+                this.#slackConversationTurns.schedule(conversationId);
+            }
+            else if (pending) {
+                this.#increment('slackConversationRepliesWaitingForOwner');
+            }
             return;
         }
-        const liveRecord = (await this.#batch()).getIssue(record.issue);
+        liveRecord ??= (await this.#batch()).getIssue(record.issue);
         if (!liveRecord || liveRecord.dryRun) {
             if (isTriageEscalationWatchRecord(record)) {
                 return await this.#handleTriageEscalationSlackAnswer(record, text);
             }
-            this.#increment('slackAnswersIgnoredNoInFlight');
+            await this.#writeUnroutableSlackReply(reply.threadTs);
             return;
         }
         this.#increment('slackAnswersIgnoredNoConversationSession');
+        if (this.#slack) {
+            await this.#slack.reply(reply.threadTs, 'Factory received this reply but could not create a durable agent route. It will remain replayable; please also continue on the linked issue or pull request.');
+            this.#increment('slackAnswersUnroutableVisible');
+        }
+    }
+    async #writeUnroutableSlackReply(threadId) {
+        this.#increment('slackAnswersIgnoredNoInFlight');
+        if (!this.#slack)
+            return;
+        await this.#slack.reply(threadId, 'Factory received this reply but could not route it because this work unit no longer has an active agent. Please continue on the linked issue or pull request.');
+        this.#increment('slackAnswersUnroutableVisible');
     }
     async #wakeWaitingClarification(key, waiting) {
         const existing = this.#clarificationWakeInFlight.get(key);
@@ -13414,6 +14293,7 @@ export class FactoryLoop {
                 const resumed = await this.#fleet.resume({
                     name,
                     sessionRef: tracked.sessionRef,
+                    identityKey: dispatchAgentIdentityKey(waiting.issue, tracked.spec.role),
                     node: tracked.result?.node ?? tracked.spec.node ?? 'self',
                     capability: tracked.spec.capability,
                     repo: tracked.spec.repo,
@@ -13444,6 +14324,7 @@ export class FactoryLoop {
         return await this.#fleet.spawn({
             name,
             capability: tracked.spec.capability,
+            identityKey: dispatchAgentIdentityKey(waiting.issue, tracked.spec.role),
             node: tracked.result?.node ?? tracked.spec.node ?? 'self',
             task,
             workflow: tracked.spec.workflow,
@@ -13494,6 +14375,7 @@ export class FactoryLoop {
         const batch = await this.#batch();
         if (batch.isInFlight(record.issue) || batch.isQueued(record.issue)) {
             this.#increment('slackTriageAnswersIgnoredAlreadyActive');
+            await this.#state.clearSlackThreadWatch(this.#workspaceId, issueKey(record.issue));
             return;
         }
         if (await this.#dispatchBlockReason(record.issue)) {
@@ -13510,6 +14392,10 @@ export class FactoryLoop {
             if (hasDispatchableRoute(decision)) {
                 this.#pendingSlackClarifications.set(issueKey(decision.issue), text);
                 const result = await this.#startOrQueueSlackClarifiedDecision(dispatchAfterSlackClarification(decision, escalationReason));
+                const active = await this.#batch();
+                if (result || active.isInFlight(decision.issue) || active.isQueued(decision.issue)) {
+                    await this.#state.clearSlackThreadWatch(this.#workspaceId, issueKey(record.issue));
+                }
                 this.#increment('slackTriageAnswersDispatchedWithRemainingEscalation');
                 return result;
             }
@@ -13522,6 +14408,10 @@ export class FactoryLoop {
         }
         this.#pendingSlackClarifications.set(issueKey(decision.issue), text);
         const result = await this.#startOrQueueSlackClarifiedDecision(decision);
+        const active = await this.#batch();
+        if (result || active.isInFlight(decision.issue) || active.isQueued(decision.issue)) {
+            await this.#state.clearSlackThreadWatch(this.#workspaceId, issueKey(record.issue));
+        }
         this.#increment('slackTriageAnswersDispatched');
         return result;
     }
@@ -13757,6 +14647,15 @@ export class FactoryLoop {
         return hasTitlePrefix(issue.title, FACTORY_E2E_MARKER);
     }
 }
+const defaultGithubWriteback = (config, mount) => {
+    if (config.github.identity !== 'app') {
+        return new GhCliGithubWriteback();
+    }
+    if (!mount.githubWrite) {
+        throw new Error('GitHub identity "app" requires a connected workspace GitHub App lifecycle write path; refusing to fall back to the local gh user');
+    }
+    return new AppGithubWriteback(mount.githubWrite);
+};
 export function parseLinearIssue(path, content) {
     const parsed = parseJsonContent(content);
     const payload = wrappedPayload(parsed);
@@ -14352,13 +15251,19 @@ function labelDerivedDispatchDecision(liveIssue, decision, config) {
             maxImplementers,
         };
     }
-    const implementers = routesByLabel.routes.map(({ slug, route }) => routeImplementerSpec(liveIssue, config, slug, route));
-    const selectedRoutes = scope === 'single' ? routesByLabel.routes.slice(0, 1) : routesByLabel.routes;
+    // Swarm always shares one checkout (lead + workers collaborate live over a
+    // shared relay channel), so — like single/workflow — only the first matched
+    // label route is used; it is never fanned out across repo labels like team.
+    const selectedRoutes = scope === 'single' || scope === 'swarm'
+        ? routesByLabel.routes.slice(0, 1)
+        : routesByLabel.routes;
     const selectedImplementers = scope === 'team'
-        ? implementers
+        ? routesByLabel.routes.map(({ slug, route }) => routeImplementerSpec(liveIssue, config, slug, route))
         : scope === 'single'
-            ? implementers.slice(0, 1)
-            : [];
+            ? routesByLabel.routes.slice(0, 1).map(({ slug, route }) => routeImplementerSpec(liveIssue, config, slug, route))
+            : scope === 'swarm'
+                ? routeSwarmImplementerSpecs(liveIssue, config, selectedRoutes[0]?.route, maxImplementers)
+                : [];
     const routes = selectedRoutes.map(({ route }) => route);
     const workflow = scope === 'workflow'
         ? routeWorkflowSpec(liveIssue, config, selectedRoutes, decision.workflow)
@@ -14487,6 +15392,24 @@ function routeImplementerSpec(issue, config, slug, route) {
         node: 'self',
     };
 }
+function routeSwarmImplementerSpecs(issue, config, route, maxImplementers) {
+    if (!route) {
+        return [];
+    }
+    const channel = swarmChannel(issue);
+    return swarmMemberSlugs(maxImplementers).map((slug) => ({
+        name: agentNameForRole(issue, 'impl', { repo: route.repo, discriminator: slug }),
+        role: 'implementer',
+        capability: config.agentCapabilities.implementer,
+        model: config.models.implementer,
+        task: swarmTaskFor(issue, route, slug, channel),
+        repo: route.repo,
+        clonePath: route.clonePath,
+        channel,
+        swarmRole: slug === 'lead' ? 'lead' : 'worker',
+        node: 'self',
+    }));
+}
 function decisionWithLifecycleBranches(decision, runId, opts = {}) {
     const implementerBranch = (spec) => {
         const runSuffix = `-${runId.slice(0, 8)}`;
@@ -15633,12 +16556,123 @@ const isAllowedFactoryDraft = async (path, content, opts, mount, config) => {
     if (/^\/slack\/channels\/[^/]+\/messages\/.+/u.test(path)) {
         return true;
     }
-    if (isFactoryGithubWritebackPath(path)) {
+    if (await isAllowedFactoryGithubDraft(path, content, opts, mount, config))
         return true;
+    return false;
+};
+const isFactoryGithubAuthoredArtifactPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
+export const isAllowedFactoryGithubArtifactDraft = (path, opts) => opts?.guarded === true && isFactoryGithubAuthoredArtifactPath(path);
+const factoryGithubIssueWriteTarget = (path) => {
+    const match = /^\/github\/repos\/([^/]+)\/([^/]+)\/issues\/([1-9]\d*)(?:\.json|\/(comments|labels)\/([^/]+))$/iu.exec(path);
+    if (!match?.[1] || !match[2] || !match[3])
+        return undefined;
+    const child = match[4];
+    const filename = match[5];
+    if (child === 'comments' && (!filename || !isFactoryGithubIssueCommentDraftName(filename)))
+        return undefined;
+    if (child === 'labels' && (!filename || !isFactoryGithubOperationDraftName(filename)))
+        return undefined;
+    try {
+        return {
+            owner: decodeURIComponent(match[1]),
+            repo: decodeURIComponent(match[2]),
+            number: Number(match[3]),
+            kind: child === 'comments' ? 'comment' : child === 'labels' ? 'label-operation' : 'issue-update',
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
+const factoryGithubRepositoryLabelWriteTarget = (path) => {
+    const match = /^\/github\/repos\/([^/]+)\/([^/]+)\/labels\/([^/]+)$/iu.exec(path);
+    if (!match?.[1] || !match[2] || !match[3] || !isFactoryGithubOperationDraftName(match[3]))
+        return undefined;
+    try {
+        return { owner: decodeURIComponent(match[1]), repo: decodeURIComponent(match[2]) };
+    }
+    catch {
+        return undefined;
+    }
+};
+const githubLifecycleLabel = (name) => Object.values(FACTORY_GITHUB_STATUS_LABELS).find((label) => label.name === name);
+const hasExactKeys = (value, keys) => {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+};
+const isAllowedFactoryGithubIssueWriteContent = (kind, content) => {
+    const value = asRecord(content);
+    if (!value)
+        return false;
+    if (kind === 'issue-update') {
+        return hasExactKeys(value, ['state']) && value.state === 'closed';
+    }
+    if (kind === 'comment') {
+        return hasExactKeys(value, ['body']) && typeof value.body === 'string' && value.body.trim().length > 0;
+    }
+    if (value.operation === 'add') {
+        return hasExactKeys(value, ['labels', 'operation']) &&
+            Array.isArray(value.labels) && value.labels.length === 1 && Boolean(githubLifecycleLabel(value.labels[0]));
+    }
+    return value.operation === 'remove' && hasExactKeys(value, ['label', 'operation']) && Boolean(githubLifecycleLabel(value.label));
+};
+const isAllowedFactoryGithubRepositoryLabelContent = (content) => {
+    const value = asRecord(content);
+    if (!value || !hasExactKeys(value, ['color', 'description', 'name']))
+        return false;
+    const expected = githubLifecycleLabel(value.name);
+    return Boolean(expected && expected.color === value.color && expected.description === value.description);
+};
+/**
+ * Last-resort mount guard for Factory-authored GitHub drafts. PR/ref paths are
+ * intrinsically Factory-owned. Issue mutations additionally require a current
+ * in-scope issue projection in one of Relayfile's supported repository layouts.
+ */
+export const isAllowedFactoryGithubDraft = async (path, content, opts, mount, config) => {
+    if (!opts?.guarded)
+        return false;
+    if (isAllowedFactoryGithubArtifactDraft(path, opts))
+        return true;
+    const repositoryLabelTarget = factoryGithubRepositoryLabelWriteTarget(path);
+    if (repositoryLabelTarget) {
+        const repoPath = `/github/repos/${encodeURIComponent(repositoryLabelTarget.owner)}/${encodeURIComponent(repositoryLabelTarget.repo)}/`;
+        return isConfiguredGithubRepoPath(repoPath, config) && isAllowedFactoryGithubRepositoryLabelContent(content);
+    }
+    const target = factoryGithubIssueWriteTarget(path);
+    if (!target)
+        return false;
+    if (!isAllowedFactoryGithubIssueWriteContent(target.kind, content))
+        return false;
+    if (target.kind === 'comment') {
+        const body = asRecord(content)?.body;
+        const draftName = path.slice(path.lastIndexOf('/') + 1);
+        if (typeof body !== 'string' || draftName !== factoryGithubIssueCommentDraftName(body))
+            return false;
+    }
+    const repoPath = `/github/repos/${encodeURIComponent(target.owner)}/${encodeURIComponent(target.repo)}`;
+    if (!isConfiguredGithubRepoPath(`${repoPath}/`, config))
+        return false;
+    const compactRepo = `${encodeURIComponent(target.owner)}__${encodeURIComponent(target.repo)}`;
+    const candidates = [
+        `${repoPath}/issues/by-id/${target.number}.json`,
+        `/github/repos/${compactRepo}/issues/by-id/${target.number}.json`,
+        `${repoPath}/issues/${target.number}/meta.json`,
+        `/github/repos/${compactRepo}/issues/${target.number}/meta.json`,
+        `${repoPath}/issues/${target.number}.json`,
+        `/github/repos/${compactRepo}/issues/${target.number}.json`,
+    ];
+    for (const candidate of candidates) {
+        try {
+            const issue = parseGithubFactoryIssue(candidate, (await mount.readFile(candidate)).content);
+            return issue.state?.name === 'open' && isInFactoryScope(issue, config.safety);
+        }
+        catch {
+            // Try the next canonical/alias shape. Any total miss fails closed.
+        }
     }
     return false;
 };
-const isFactoryGithubWritebackPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
 const isIssuePathInFactoryScope = async (mount, path, config) => {
     try {
         return isInFactoryScope(parseLinearIssue(path, (await mount.readFile(path)).content), config.safety);
@@ -15888,8 +16922,8 @@ const normalizeGithubRepo = (repo, defaultOwner) => {
     }
     return `${owner}/${repo}`;
 };
-const githubPullRequestBody = (issue, preview) => [
-    issue.description,
+const githubPullRequestBody = (issue, preview, sessionRef) => [
+    stripTrajectoryPointers(issue.description),
     '',
     isGithubIssue(issue) && /^\d+$/u.test(issue.key)
         ? `Fixes #${issue.key}`
@@ -15899,7 +16933,25 @@ const githubPullRequestBody = (issue, preview) => [
         `Live preview: ${preview.url}`,
         'Access: Tailscale tailnet membership and the tailnet grants/ACLs are required; this URL is not public.',
     ] : []),
+    '',
+    renderTrajectoryPointer({
+        ...trajectoryWorkUnitForIssue(issue),
+        sessionRef,
+    }),
 ].join('\n').trim();
+const trajectoryWorkUnitForIssue = (issue) => {
+    const github = githubIssueSourceRef(issue);
+    if (github) {
+        return {
+            workUnitId: `${github.owner}/${github.repo}#${github.number}`,
+            workUnitSurface: 'github',
+        };
+    }
+    if (isRealLinearIssue(issue)) {
+        return { workUnitId: issue.key, workUnitSurface: 'linear' };
+    }
+    return { workUnitId: `factory:${issue.uuid}`, workUnitSurface: 'factory' };
+};
 // The broker rejects re-registering a name it never released on exit
 // (relay#1116-family) with a 500 "agent '<name>' already exists". Detect it from
 // the structured payload or the message so resume can treat it as terminal
@@ -15928,6 +16980,9 @@ const slackMessageReceivedAtMs = (messageTs, fallback) => {
     const seconds = Number(messageTs);
     return Number.isFinite(seconds) && seconds > 0 ? Math.floor(seconds * 1_000) : fallback;
 };
+const terminalSlackWatchRetiredAtMs = (watch) => typeof watch.retiredAtMs === 'number' && Number.isFinite(watch.retiredAtMs)
+    ? watch.retiredAtMs
+    : Math.max(0, watch.expiresAtMs - SLACK_TERMINAL_THREAD_GRACE_MS);
 const eventIdentity = (event) => {
     const record = event;
     const rawId = record.id ?? record.event_id ?? record.seq;
@@ -16091,6 +17146,7 @@ const cloneTrackedAgent = (tracked) => ({
     result: tracked.result ? { ...tracked.result } : undefined,
     sessionRef: tracked.sessionRef,
     unreachableWakeResumedSessionRef: tracked.unreachableWakeResumedSessionRef,
+    releasedAtMs: tracked.releasedAtMs,
 });
 const durableBabysitterTrackedAgent = (session, capability = 'spawn:claude') => ({
     spec: {
@@ -16167,7 +17223,11 @@ const lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequ
     decision: structuredClone(record.decision),
     dryRun: record.dryRun,
     phase,
-    agents: [...record.agents].map(([name, tracked]) => ({ name, tracked: cloneTrackedAgent(tracked) })),
+    agents: [...record.agents].map(([name, tracked]) => ({
+        name,
+        tracked: cloneTrackedAgent(tracked),
+        ...(tracked.releasedAtMs !== undefined ? { releasedAtMs: tracked.releasedAtMs } : {}),
+    })),
     invocationIds: [...record.invocationIds],
     result: record.result ? structuredClone(record.result) : undefined,
     ...(record.dispatchClaim ? { dispatchClaim: { ...record.dispatchClaim } } : {}),
@@ -16182,7 +17242,13 @@ const inFlightRecordFromLifecycle = (lifecycle) => ({
     issue: { ...lifecycle.issue },
     decision: structuredClone(lifecycle.decision),
     dryRun: lifecycle.dryRun,
-    agents: new Map(lifecycle.agents.map((agent) => [agent.name, cloneTrackedAgent(agent.tracked)])),
+    // Release state has to survive takeover with the agents themselves. Without
+    // it the rebuilt record reads a released placement as a live worker and the
+    // spawn gate answers for a process that no longer exists.
+    agents: new Map(lifecycle.agents.map((agent) => [agent.name, {
+            ...cloneTrackedAgent(agent.tracked),
+            releasedAtMs: agent.releasedAtMs ?? agent.tracked.releasedAtMs,
+        }])),
     invocationIds: new Set(lifecycle.invocationIds),
     result: lifecycle.result ? structuredClone(lifecycle.result) : undefined,
     ...(lifecycle.dispatchClaim ? { dispatchClaim: { ...lifecycle.dispatchClaim } } : {}),
@@ -16209,7 +17275,14 @@ const triageEscalationReason = (decision) => {
     }
     return `${reasons.join(' and ')}${decision.rationale ? `: ${decision.rationale}` : ''}`;
 };
-class LiveDispatchStateChangedError extends Error {
+/**
+ * The dispatch claim race: another writer changed the issue's live state
+ * between this process reading it and writing back, so the dispatch was
+ * abandoned. Exported so callers outside this module — notably the CLI, which
+ * turns it into a distinct exit code — can recognize it by type rather than by
+ * matching on `error.name`, and so tests can construct a genuine instance.
+ */
+export class LiveDispatchStateChangedError extends Error {
     issueKey;
     constructor(issueKey) {
         super(`Live state changed before writeback for ${issueKey}`);
@@ -16217,6 +17290,59 @@ class LiveDispatchStateChangedError extends Error {
         this.issueKey = issueKey;
     }
 }
+/** Whether a thrown value is a {@link LiveDispatchStateChangedError}. */
+export function isLiveDispatchStateChangedError(error) {
+    return error instanceof LiveDispatchStateChangedError;
+}
+/** How deep to follow `cause` when classifying a wrapped failure. */
+const PASS_FATAL_CAUSE_DEPTH = 4;
+/**
+ * Whether `error`, or anything it wraps, is an instance of `type`.
+ * `contextualError` and the fleet control-plane guard both rethrow wrapped, so
+ * classification has to follow the cause chain rather than trust the outermost
+ * type.
+ */
+const wrapsErrorOfType = (error, type, depth = 0) => {
+    if (depth > PASS_FATAL_CAUSE_DEPTH || !(error instanceof Error))
+        return false;
+    if (error instanceof type)
+        return true;
+    return wrapsErrorOfType(error.cause, type, depth + 1);
+};
+/**
+ * How many *unclassified* per-item failures without an intervening successful
+ * dispatch end the pass. Named per-item conditions (a lifecycle claim refusal,
+ * a live-state race) never count toward it and never reset it: those
+ * legitimately affect many units at once and are exactly the benign case #292
+ * asks the loop to survive, so they are neither evidence of a pass-wide fault
+ * nor evidence against one.
+ */
+const UNCLASSIFIED_DISPATCH_FAILURE_LIMIT = 5;
+/**
+ * Failures the loop recognizes as belonging to one work unit. They are always
+ * skippable and are exempt from the consecutive-failure fuse.
+ */
+const isClassifiedPerItemDispatchFailure = (error) => error instanceof LiveDispatchStateChangedError ||
+    error instanceof DispatchLifecycleClaimRefusedError;
+/**
+ * The run-report reason recorded for a work unit the pass could not dispatch.
+ *
+ * `factory run-once` serializes the whole report to stdout, so this string is
+ * a public surface: it stays a fixed classification plus an allowlisted error
+ * class name, never raw provider text or filesystem paths. The full message
+ * goes to the operator log instead, the same split
+ * `describeControlPlaneError` makes for circuit state.
+ */
+const perItemDispatchSkipReason = (error) => {
+    if (error instanceof LiveDispatchStateChangedError)
+        return 'live state changed during dispatch';
+    if (error instanceof DispatchLifecycleClaimRefusedError) {
+        return error.refusal === 'terminal'
+            ? 'dispatch lifecycle already terminal'
+            : 'dispatch lifecycle owned by another publisher';
+    }
+    return `dispatch failed (${telemetryErrorClass(error)})`;
+};
 const triageEscalationQuestion = (decision, issue) => {
     const routedRepos = decision.routes.map((route) => route.repo).filter(Boolean);
     const subject = issue?.title?.trim() || decision.issue.key;