@agent-relay/factory 0.1.36 → 0.1.38

package/dist/orchestrator/factory.js

@@ -85,6 +85,7 @@ const STOP_TEARDOWN_TIMEOUT_MS = 2_500;
 const DISPATCH_LIFECYCLE_LEASE_MS = 5 * 60_000;
 const DISPATCH_LIFECYCLE_RENEW_MS = 60_000;
 const DISPATCH_LIFECYCLE_RETRY_MS = 1_000;
+const STARTUP_AGENT_EXIT_DRAIN_TIMEOUT_MS = 30_000;
 const SLACK_EVENT_WATERMARK_CACHE_MS = 60_000;
 const MERGE_GATE_MAX_ATTEMPTS = 12;
 const MERGE_GATE_POLL_DELAY_MS = 10_000;
@@ -99,6 +100,8 @@ const GITHUB_MIRROR_TITLE_PREFIX = '[factory]';
 const GITHUB_MIRROR_SOURCE_PREFIX = 'Source: ';
 export const DEFAULT_FACTORY_LOOP_HEARTBEAT_PATH = '/tmp/factory-run/factory-loop-heartbeat.json';
 export const DEFAULT_FACTORY_LOOP_REGISTRY_PATH = '/tmp/factory-run/factory-loop-registry.json';
+class DispatchLifecycleCapacityError extends Error {
+}
 const realClock = {
     now: () => Date.now(),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -119,6 +122,7 @@ export class FactoryLoop {
     #probeCloser;
     #probePrResolver;
     #customProbePrResolver;
+    #hasProbePrGhRunner;
     #probePrGhRunner;
     #logger;
     #clock;
@@ -129,6 +133,7 @@ export class FactoryLoop {
     #terminationGraceMs;
     #babysitterWakeUnreachableEscalateMs;
     #babysitterWakeUnreachableRetryMs;
+    #startupAgentExitDrainTimeoutMs;
     #state;
     #workspaceId;
     #relayflows;
@@ -145,6 +150,7 @@ export class FactoryLoop {
     #githubIssueCommentWatchers = new Map();
     #githubIssueCommentWatchStates = new Map();
     #githubIssueCommentQueues = new Map();
+    #githubIssueCommentReplays = new Map();
     #githubIssueAuthors = new Map();
     #githubIssueAuthorLookups = new Map();
     #githubIssuePreferredPaths = new Map();
@@ -174,6 +180,7 @@ export class FactoryLoop {
     #dispatchTerminalWaiters = new Map();
     #dispatchLifecycleRetryTimers = new Map();
     #dispatchLifecycleDrives = new Set();
+    #dispatchLifecycleCapacityWaitLogged = new Set();
     #localReleaseCheckpoints = new Map();
     #dispatchLifecycleRenewTimer;
     #clarificationSweepTimer;
@@ -210,15 +217,19 @@ export class FactoryLoop {
     #completionSweepTimer;
     #completionSweepActive = false;
     #completionInFlight = new Set();
+    #agentExitsInFlight = new Map();
     #agentLifecycleSignalsInFlight = new Map();
-    // Composite issue identities for which a babysitter has already been spawned, so repeated PR
-    // webhooks / agent-exit safety nets don't respawn it.
+    #startupAgentAdoptionActive = false;
+    // Composite issue + PR identities for which a babysitter has already been spawned, so repeated
+    // webhooks / agent-exit safety nets don't respawn it while multi-repository issues retain one
+    // owner per PR.
     #babysitterSpawned = new Set();
     #babysitterSpawnInFlight = new Map();
-    // Composite issue identity -> the open PR the babysitter is shepherding, including the
+    // Composite issue + PR identity -> the open PR the babysitter is shepherding, including the
     // webhook-fed mount path so readiness can re-read PR meta without a gh call.
     #babysitterPr = new Map();
     #babysitterIssueRefs = new Map();
+    #babysitterReady = new Set();
     #babysitterWakeStates = new Map();
     // A babysitter announces this fence before invoking destructive git tooling
     // and clears it afterward. Event text can be broker-delivered while a prompt
@@ -265,6 +276,7 @@ export class FactoryLoop {
         this.#mergeGate = ports.mergeGate ?? new GithubMergeGate();
         this.#probeCloser = ports.probeCloser ?? closeProbePr;
         this.#customProbePrResolver = Boolean(ports.probePrResolver);
+        this.#hasProbePrGhRunner = Boolean(ports.probePrGhRunner);
         this.#probePrGhRunner = ports.probePrGhRunner ?? failClosedGhRunner;
         this.#probePrResolver = ports.probePrResolver ?? ((issue) => this.#resolveIssuePr(issue));
         this.#logger = normalizeLogger(ports.logger ?? console);
@@ -279,6 +291,7 @@ export class FactoryLoop {
         this.#terminationGraceMs = ports.terminationGraceMs;
         this.#babysitterWakeUnreachableEscalateMs = ports.babysitterWakeUnreachableEscalateMs ?? BABYSITTER_WAKE_UNREACHABLE_ESCALATE_MS;
         this.#babysitterWakeUnreachableRetryMs = ports.babysitterWakeUnreachableRetryMs ?? BABYSITTER_WAKE_UNREACHABLE_RETRY_MS;
+        this.#startupAgentExitDrainTimeoutMs = ports.startupAgentExitDrainTimeoutMs ?? STARTUP_AGENT_EXIT_DRAIN_TIMEOUT_MS;
         this.#workspaceId = config.workspaceId ?? 'default';
         this.#relayflows = ports.relayflows;
         this.#worktrees = ports.worktrees;
@@ -459,9 +472,33 @@ export class FactoryLoop {
             this.#error(new Error(`${GITHUB_ISSUE_ROOT} sub-root is not mounted`));
             return;
         }
-        this.#wireFleetEvents();
-        await this.#adoptInFlightAgents();
-        await this.#restoreBabysitterOwnership();
+        const live = (opts.mode ?? 'live') === 'live';
+        // Capture the legacy registry before the first live heartbeat rewrites it.
+        // Durable lifecycle rows are authoritative, but this fallback is still
+        // required to adopt workers started by pre-lifecycle Factory versions.
+        const legacyRegistry = live
+            ? await readFactoryInFlightRegistry(this.#config.loop.registryPath)
+            : undefined;
+        if (live)
+            await this.#startLiveHeartbeat();
+        this.#startupAgentAdoptionActive = true;
+        try {
+            this.#wireFleetEvents();
+            await this.#adoptInFlightAgents(legacyRegistry);
+            this.#startupAgentAdoptionActive = false;
+            if (this.#config.babysitter.enabled) {
+                // Re-run the idempotent receipt fold after adoption returns. This
+                // catches records restored by lifecycle work that completed while the
+                // startup roster drain was in progress.
+                await this.#reconcileRestoredBabysitterReceipts();
+            }
+        }
+        catch (error) {
+            this.#startupAgentAdoptionActive = false;
+            if (live)
+                await this.#stopLiveHeartbeat('stopping');
+            throw error;
+        }
         if (opts.mode === 'dispatch-owner') {
             this.#started = true;
             this.#scheduleDispatchLifecycleRenewal();
@@ -473,7 +510,7 @@ export class FactoryLoop {
             await this.#rearmGithubIssueCommentWatchers();
             return;
         }
-        if ((opts.mode ?? 'live') === 'live') {
+        if (live) {
             this.#started = true;
             try {
                 await this.#startLiveSubscription(issueSource, opts.liveSubscription);
@@ -533,6 +570,12 @@ export class FactoryLoop {
         this.#completionSweepTimer = undefined;
         this.#stoppingHeartbeatRefreshActive = await this.#stopLiveHeartbeat('stopping');
         try {
+            // Relinquish durable ownership before waiting on mount-backed lifecycle
+            // drives. A slow Relayfile scan must not consume the shutdown deadline
+            // while every issue remains fenced to a publisher that is already
+            // stopping. The owner/epoch fence makes any late completion from those
+            // drives harmless; a second sweep below catches claims racing this one.
+            await this.#releaseOwnedDispatchLifecycleLeases();
             await Promise.allSettled([...this.#dispatchLifecycleDrives]);
             // Fence every source of new clarification work before touching the fleet.
             // A wake already past the fence is allowed to unwind, and is awaited
@@ -549,15 +592,13 @@ export class FactoryLoop {
             await this.#drainClarificationWakesForStop();
             this.#clarificationIntents.clear();
             await this.#drainBabysitterWakesForStop();
+            await this.#drainAgentExitsInFlight();
             // Durable relay placements must survive an owner restart so a successor
             // can adopt them. The one-shot/daemon stop path releases only
             // non-durable (local/internal) records; terminal completion performs the
             // normal remote release before clearing the lifecycle.
             await this.#releaseInFlightAgents('factory-stopped', { preserveDurable: true });
-            for (const [key, epoch] of [...this.#dispatchLifecycleEpochs]) {
-                await this.#state.releaseDispatchLifecycleLease(this.#workspaceId, key, this.#dispatchLifecycleOwner, epoch);
-            }
-            this.#dispatchLifecycleEpochs.clear();
+            await this.#releaseOwnedDispatchLifecycleLeases();
             if (this.#livePollTimer)
                 clearTimeout(this.#livePollTimer);
             this.#livePollTimer = undefined;
@@ -567,6 +608,7 @@ export class FactoryLoop {
             this.#babysitterSpawned.clear();
             this.#babysitterPr.clear();
             this.#babysitterIssueRefs.clear();
+            this.#babysitterReady.clear();
             this.#babysitterCriticalAgents.clear();
             const subscription = this.#subscription;
             this.#subscription = undefined;
@@ -594,6 +636,14 @@ export class FactoryLoop {
             this.#stoppingHeartbeatRefreshActive = false;
         }
     }
+    async #releaseOwnedDispatchLifecycleLeases() {
+        for (const [key, epoch] of [...this.#dispatchLifecycleEpochs]) {
+            await this.#state.releaseDispatchLifecycleLease(this.#workspaceId, key, this.#dispatchLifecycleOwner, epoch);
+            if (this.#dispatchLifecycleEpochs.get(key) === epoch) {
+                this.#dispatchLifecycleEpochs.delete(key);
+            }
+        }
+    }
     async #drainClarificationWakesForStop() {
         // A wake may add its promise just as the sweep that discovered it settles.
         // Re-snapshot until the map is empty rather than assuming one await is a
@@ -638,7 +688,6 @@ export class FactoryLoop {
     }
     async #startLiveSubscription(issueSource, overrides = {}) {
         const options = this.#liveOptions(overrides);
-        await this.#startLiveHeartbeat();
         this.#liveConnectStartedAtMs = this.#clock.now();
         this.#liveReplaySkewMarginMs = options.replaySkewMarginMs;
         const highWatermark = await this.#currentEventHighWatermark();
@@ -1095,6 +1144,10 @@ export class FactoryLoop {
         this.#completionSweepTimer.unref?.();
     }
     async #sweepPrStateCompletions(reason) {
+        // This timer is also the durable safety net for fleet exit events missed
+        // while the event loop was busy (for example during a large startup pull).
+        // Keep reconciliation active even when babysitters own PR completion.
+        await this.#fleet.reconcileTrackedAgents?.();
         // When the babysitter owns PR-open, completion is driven by PR webhooks +
         // the babysitter's readiness signal (see #handlePrChange / #handleAgentExit),
         // not this polling sweep. Disabling it here is what makes the babysitter path
@@ -1130,6 +1183,10 @@ export class FactoryLoop {
                         this.#probePrGhBackoffUntilMs.set(issueStateKey(issueRef(issue)), this.#clock.now() + PROBE_PR_GH_BACKOFF_MS);
                         return undefined;
                     }
+                    if (record.decision.implementers.length > 1 && !await this.#allImplementersHaveCompletionPr(record)) {
+                        this.#increment('completionSweepMissingPr');
+                        return undefined;
+                    }
                     return { record, pr };
                 }));
                 for (const candidate of candidates) {
@@ -1241,6 +1298,7 @@ export class FactoryLoop {
                     await this.#recordCanonicalIssueState(issue);
                 }
                 issueEntries.push({ path, issue });
+                await this.#refreshLiveHeartbeatIfDue();
             }
             if (issueSource === 'github') {
                 // New ready work must not sit behind a long sequence of stale
@@ -1258,6 +1316,7 @@ export class FactoryLoop {
                 });
             }
             for (const { issue } of issueEntries) {
+                await this.#refreshLiveHeartbeatIfDue();
                 if (!issue) {
                     continue;
                 }
@@ -1672,6 +1731,7 @@ export class FactoryLoop {
             url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
             path: pr.path,
             headRef,
+            authoritative: true,
         });
         const babysitter = [...record.agents.values()].find((tracked) => tracked.spec.role === 'babysitter');
         if (!babysitter) {
@@ -1906,15 +1966,9 @@ export class FactoryLoop {
             this.#error(error, decision.issue);
             throw error;
         }
-        const escalationReason = triageEscalationReason(decision);
-        if (escalationReason) {
-            const replayedResult = await this.#escalateTriage(decision, escalationReason, dryRun);
-            this.#recordTriageEscalation(decision, escalationReason);
-            return replayedResult ?? { issue: decision.issue, agents: [], dryRun };
-        }
-        // TODO(AR-274 follow-up): short-circuit LLM triage once label-derived
-        // routes are authoritative for dispatch identity.
-        const labelDispatch = labelDerivedDispatchDecision(liveIssue, decision, this.#config);
+        const labelDispatch = opts.labelsValidated
+            ? { ok: true, decision }
+            : labelDerivedDispatchDecision(liveIssue, decision, this.#config);
         if (!labelDispatch.ok) {
             const comment = labelDispatchFailureComment(decision.issue, labelDispatch);
             this.#logger.warn?.('[factory] skipped dispatch due to invalid repo labels', {
@@ -1940,10 +1994,16 @@ export class FactoryLoop {
             }
             return { issue: decision.issue, agents: [], comments: [comment], dryRun };
         }
-        let dispatchDecision = labelDispatch.decision;
+        let dispatchDecision = authoritativeRoutedDecision(decision, labelDispatch.decision);
         // A valid label resolution clears any prior failure notice so a later
         // regression posts a fresh, actionable comment instead of being deduped.
         this.#labelDispatchFailures.delete(issueStateKey(dispatchDecision.issue));
+        const escalationReason = triageEscalationReason(dispatchDecision);
+        if (escalationReason) {
+            const replayedResult = await this.#escalateTriage(dispatchDecision, escalationReason, dryRun);
+            this.#recordTriageEscalation(dispatchDecision, escalationReason);
+            return replayedResult ?? { issue: dispatchDecision.issue, agents: [], dryRun };
+        }
         // Full task rendering is part of the durable spawn specification. It must
         // happen before a remote lifecycle is first claimed so takeover cannot
         // recover a persisted minimal triage task after a crash in this gap.
@@ -2134,7 +2194,25 @@ export class FactoryLoop {
     #wireFleetEvents() {
         if (!this.#offAgentExit) {
             this.#offAgentExit = this.#fleet.onAgentExit((name, reason) => {
-                void this.#handleAgentExit(name, reason);
+                // Internal broker subscriptions replay historical exits immediately.
+                // Ignore that pre-hydration history; the roster reconcile below runs
+                // after durable records are restored and is the authoritative signal.
+                if (this.#startupAgentAdoptionActive)
+                    return;
+                // Broker replay can deliver an old exit immediately when the listener
+                // is installed, before durable agents are restored. Queue a later
+                // roster-reconciled exit behind it instead of dropping the newer event.
+                const previous = this.#agentExitsInFlight.get(name) ?? Promise.resolve();
+                const handling = previous
+                    .catch(() => undefined)
+                    .then(async () => await this.#handleAgentExit(name, reason))
+                    .catch((error) => this.#error(error))
+                    .finally(() => {
+                    if (this.#agentExitsInFlight.get(name) === handling) {
+                        this.#agentExitsInFlight.delete(name);
+                    }
+                });
+                this.#agentExitsInFlight.set(name, handling);
             });
         }
         if (!this.#offDeliveryFailed) {
@@ -2167,12 +2245,16 @@ export class FactoryLoop {
     // in the durable lifecycle store, restore their full batch/spec association,
     // then reconcile once so exits that happened while this process was down are
     // handled instead of being dropped as unknown agents.
-    async #adoptInFlightAgents() {
+    async #adoptInFlightAgents(legacyRegistry) {
         try {
             const batch = await this.#batch();
             const agents = [];
             let hasNonterminalDurableLifecycle = false;
-            for (const [key, lifecycle] of await this.#state.listDispatchLifecycles(this.#workspaceId)) {
+            const durableLifecycles = await this.#state.listDispatchLifecycles(this.#workspaceId);
+            this.#logger.info?.('[factory] durable startup adoption loaded', {
+                lifecycles: durableLifecycles.length,
+            });
+            for (const [key, lifecycle] of durableLifecycles) {
                 if (isTerminalDispatchLifecycle(lifecycle))
                     continue;
                 hasNonterminalDurableLifecycle = true;
@@ -2212,7 +2294,7 @@ export class FactoryLoop {
             // records existed. It preserves observation, but only new lifecycle rows
             // carry enough decision/spec state to process the reconciled exit.
             if (agents.length === 0 && !hasNonterminalDurableLifecycle) {
-                const registry = await readFactoryInFlightRegistry(this.#config.loop.registryPath);
+                const registry = legacyRegistry ?? await readFactoryInFlightRegistry(this.#config.loop.registryPath);
                 agents.push(...(registry?.agents ?? [])
                     .filter((agent) => agent.invocationId || agent.node)
                     .map((agent) => ({ name: agent.name, invocationId: agent.invocationId, node: agent.node })));
@@ -2220,14 +2302,73 @@ export class FactoryLoop {
             if (agents.length > 0 && this.#fleet.hydrateTracked) {
                 this.#fleet.hydrateTracked(agents);
             }
+            if (this.#config.babysitter.enabled) {
+                // Restore and reconcile exact PR ownership before asking the fleet to
+                // report missing agents. Otherwise a stale weak-match babysitter from
+                // the lifecycle can be resumed before its independently durable,
+                // metadata-validated replacement session becomes authoritative.
+                await this.#restoreBabysitterOwnership();
+                await this.#reconcileRestoredBabysitterReceipts();
+            }
             this.#scheduleDispatchLifecycleRenewal();
-            if (this.#fleet.hydrateTracked)
+            if (this.#fleet.hydrateTracked) {
+                this.#startupAgentAdoptionActive = false;
+                this.#logger.info?.('[factory] durable startup roster reconciliation started', {
+                    agents: agents.map((agent) => agent.name),
+                });
                 await this.#fleet.reconcileTrackedAgents?.();
+                this.#logger.info?.('[factory] durable startup roster reconciliation completed', {
+                    pendingExits: [...this.#agentExitsInFlight.keys()].filter((name) => agents.some((agent) => agent.name === name)),
+                });
+                // Fleet callbacks are intentionally synchronous at the port boundary,
+                // but recovery work is asynchronous (issue reads, worktree restore,
+                // PR publication). Finish exits discovered by the startup reconcile
+                // before the full ready-issue backfill can monopolize mount I/O.
+                const exitNames = new Set(agents.map((agent) => agent.name));
+                const drained = await this.#drainAgentExitsInFlight(exitNames, this.#startMode === 'live' ? this.#startupAgentExitDrainTimeoutMs : undefined);
+                if (drained) {
+                    this.#logger.info?.('[factory] durable startup reconciled exits drained');
+                }
+                else {
+                    this.#increment('startupAgentExitDrainTimeouts');
+                    this.#logger.warn?.('[factory] startup agent exit reconciliation is still running; continuing ready-issue discovery', {
+                        timeoutMs: this.#startupAgentExitDrainTimeoutMs,
+                        pendingExits: [...this.#agentExitsInFlight.keys()].filter((name) => exitNames.has(name)),
+                    });
+                }
+            }
         }
         catch (error) {
             this.#logger.warn?.('[factory] failed to re-adopt durable in-flight agents', { error });
         }
     }
+    async #drainAgentExitsInFlight(names, timeoutMs) {
+        const drain = async () => {
+            for (;;) {
+                const pending = [...this.#agentExitsInFlight]
+                    .filter(([name]) => !names || names.has(name))
+                    .map(([, handling]) => handling);
+                if (pending.length === 0)
+                    return;
+                await Promise.allSettled(pending);
+            }
+        };
+        if (timeoutMs === undefined) {
+            await drain();
+            return true;
+        }
+        let timer;
+        const completed = await Promise.race([
+            drain().then(() => true),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+                timer.unref?.();
+            }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+        return completed;
+    }
     #scheduleDispatchLifecycleRenewal() {
         if (this.#dispatchLifecycleRenewTimer || this.#dispatchLifecycleEpochs.size === 0)
             return;
@@ -2373,7 +2514,9 @@ export class FactoryLoop {
             return false;
         }
         const previous = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
-        const lifecycle = lifecycleFromInFlightRecord(record, previous?.runId ?? randomUUID(), phase, this.#clock.now(), pullRequest ?? previous?.pullRequest, releaseReason ?? previous?.releaseReason);
+        const pullRequests = mergePublishedPullRequests(previous, pullRequest);
+        const primaryPullRequest = primaryPublishedPullRequest(previous, pullRequest, pullRequests);
+        const lifecycle = lifecycleFromInFlightRecord(record, previous?.runId ?? randomUUID(), phase, this.#clock.now(), primaryPullRequest, pullRequests, releaseReason ?? previous?.releaseReason);
         for (const agent of lifecycle.agents) {
             const previouslyReleasedAtMs = previous?.agents.find((candidate) => candidate.name === agent.name)?.releasedAtMs;
             if (previouslyReleasedAtMs !== undefined)
@@ -2417,11 +2560,27 @@ export class FactoryLoop {
         const timer = setTimeout(() => {
             this.#dispatchLifecycleRetryTimers.delete(key);
             const drive = this.#driveDispatchLifecycle(key)
+                .then(() => {
+                this.#dispatchLifecycleCapacityWaitLogged.delete(key);
+            })
                 .catch((error) => {
-                this.#logger.warn?.('[factory] durable dispatch lifecycle retry failed', {
-                    issue: record.issue.key,
-                    error: describeError(error).errorMessage,
-                });
+                if (error instanceof DispatchLifecycleCapacityError) {
+                    if (!this.#dispatchLifecycleCapacityWaitLogged.has(key)) {
+                        this.#dispatchLifecycleCapacityWaitLogged.add(key);
+                        this.#increment('dispatchLifecycleCapacityWaits');
+                        this.#logger.warn?.('[factory] durable dispatch is queued for batch capacity; retries remain active', {
+                            issue: record.issue.key,
+                            retryMs: DISPATCH_LIFECYCLE_RETRY_MS,
+                        });
+                    }
+                }
+                else {
+                    this.#dispatchLifecycleCapacityWaitLogged.delete(key);
+                    this.#logger.warn?.('[factory] durable dispatch lifecycle retry failed', {
+                        issue: record.issue.key,
+                        error: describeError(error).errorMessage,
+                    });
+                }
                 this.#scheduleDispatchLifecycleRetry(record);
             })
                 .finally(() => this.#dispatchLifecycleDrives.delete(drive));
@@ -2480,7 +2639,7 @@ export class FactoryLoop {
         if (lifecycle.phase === 'queued') {
             const epoch = this.#dispatchLifecycleEpochs.get(key);
             if (epoch === undefined || !await this.#state.promoteDispatchLifecycle(this.#workspaceId, key, this.#dispatchLifecycleOwner, epoch, this.#clock.now())) {
-                throw new Error(`durable dispatch ${lifecycle.issue.key} is waiting for batch capacity`);
+                throw new DispatchLifecycleCapacityError(`durable dispatch ${lifecycle.issue.key} is waiting for batch capacity`);
             }
             const promoted = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
             if (!promoted || promoted.phase !== 'dispatching') {
@@ -2516,6 +2675,8 @@ export class FactoryLoop {
                 })));
                 await this.#fleet.reconcileTrackedAgents?.();
             }
+            if (this.#config.babysitter.enabled)
+                await this.#reconcileRestoredBabysitterReceipts(record);
             return;
         }
         if (lifecycle.phase === 'parking') {
@@ -2531,31 +2692,48 @@ export class FactoryLoop {
             return;
         }
         if (lifecycle.phase === 'publishing') {
-            const implementer = [...record.agents.values()].find((agent) => agent.spec.role === 'implementer');
-            if (!implementer)
+            const implementers = [...record.agents.values()].filter((agent) => agent.spec.role === 'implementer');
+            if (implementers.length === 0)
                 throw new Error(`durable dispatch ${record.issue.key} has no implementer to publish`);
-            const published = await this.#publishImplementerPullRequest(record, implementer, { reconcileExisting: true });
-            if (!published)
-                throw new Error(`durable dispatch ${record.issue.key} did not produce a pull request`);
-            if (!await this.#saveDispatchLifecycle(record, 'published', published))
+            const publishedReceipts = [];
+            for (const implementer of implementers) {
+                const published = await this.#publishImplementerPullRequest(record, implementer, { reconcileExisting: true });
+                if (!published)
+                    throw new Error(`durable dispatch ${record.issue.key} did not produce a pull request for ${implementer.spec.repo}`);
+                publishedReceipts.push(published);
+                if (!await this.#saveDispatchLifecycle(record, 'publishing', published))
+                    return;
+            }
+            if (!await this.#saveDispatchLifecycle(record, 'published'))
                 return;
             if (this.#config.babysitter.enabled) {
-                await this.#ensureBabysitter(record, {
-                    repo: published.repo,
-                    prNumber: published.number,
-                    url: published.url,
-                });
+                for (const receipt of publishedReceipts) {
+                    await this.#ensureBabysitter(record, {
+                        repo: receipt.repo,
+                        prNumber: receipt.number,
+                        url: receipt.url,
+                        headRef: receipt.headRef,
+                        authoritative: true,
+                    });
+                }
                 return;
             }
             await this.#completeIssue(record);
             return;
         }
         if (lifecycle.phase === 'published' && this.#config.babysitter.enabled && lifecycle.pullRequest) {
-            await this.#ensureBabysitter(record, {
-                repo: lifecycle.pullRequest.repo,
-                prNumber: lifecycle.pullRequest.number,
-                url: lifecycle.pullRequest.url,
-            });
+            for (const receipt of lifecycle.pullRequests ?? [lifecycle.pullRequest]) {
+                await this.#ensureBabysitter(record, {
+                    repo: receipt.repo,
+                    prNumber: receipt.number,
+                    url: receipt.url,
+                    headRef: receipt.headRef,
+                    authoritative: true,
+                });
+            }
+            return;
+        }
+        if (lifecycle.phase === 'published' && !await this.#allImplementersHaveCompletionPr(record)) {
             return;
         }
         if (lifecycle.phase === 'published' || lifecycle.phase === 'writeback-applied') {
@@ -2726,7 +2904,7 @@ export class FactoryLoop {
         // the babysitter's durable ownership/wake/critical state while that epoch
         // is still valid so a later reopened issue cannot inherit a stale PR owner.
         if (this.#usesDurableDispatchLifecycle() && this.#config.babysitter.enabled) {
-            await this.#cancelBabysitterWake(issueKey(record.issue));
+            await this.#cancelBabysittersForIssue(record.issue);
         }
         if (!await this.#saveDispatchLifecycle(record, 'complete'))
             return false;
@@ -2796,18 +2974,20 @@ export class FactoryLoop {
                 return;
             }
             const decision = await this.triageIssue(issue);
-            const escalationReason = triageEscalationReason(decision);
+            const routed = labelDerivedDispatchDecision(issue, decision, this.#config);
+            const escalationDecision = routed.ok ? authoritativeRoutedDecision(decision, routed.decision) : decision;
+            const escalationReason = triageEscalationReason(escalationDecision);
             if (escalationReason) {
-                await this.#escalateTriage(decision, escalationReason, this.#config.dryRun);
-                this.#recordTriageEscalation(decision, escalationReason);
+                await this.#escalateTriage(escalationDecision, escalationReason, this.#config.dryRun);
+                this.#recordTriageEscalation(escalationDecision, escalationReason);
                 return;
             }
             if (batch.canStart()) {
-                await this.dispatch(decision, { dryRun: this.#config.dryRun });
+                await this.dispatch(escalationDecision, { dryRun: this.#config.dryRun, labelsValidated: routed.ok });
             }
             else {
-                if (batch.queue(decision, this.#config.dryRun)) {
-                    this.#emit('issue-queued', { issue: decision.issue });
+                if (batch.queue(escalationDecision, this.#config.dryRun)) {
+                    this.#emit('issue-queued', { issue: escalationDecision.issue });
                 }
             }
         }
@@ -2889,6 +3069,7 @@ export class FactoryLoop {
             await this.#handleGithubIssueChange(path, { ...opts, candidates });
             processed += 1;
             lastProgressAtMs = this.#logTimedProgress('[factory] GitHub issue ingestion progress', startedAtMs, lastProgressAtMs, { processed, total: paths.length, path });
+            await this.#refreshLiveHeartbeatIfDue();
         }
         this.#logger.info?.('[factory] GitHub issue ingestion completed', {
             dryRun: opts.dryRun ?? false,
@@ -2916,6 +3097,7 @@ export class FactoryLoop {
         let scanned = 0;
         let lastProgressAtMs = startedAtMs;
         for (const path of await this.#listRelayfileTree(ISSUE_ROOT, 'GitHub mirror candidate loading')) {
+            await this.#refreshLiveHeartbeatIfDue();
             if (!isLinearIssueMirrorCandidatePath(path)) {
                 continue;
             }
@@ -2936,33 +3118,54 @@ export class FactoryLoop {
     async #githubIssuePaths() {
         try {
             const issuePaths = new Map();
-            for (const root of githubIssueScanRoots(this.#config)) {
-                const paths = await this.#listRelayfileTree(root, 'GitHub issue ingestion');
-                for (const path of paths) {
-                    const parts = githubIssuePathParts(path);
-                    if (parts) {
-                        const identity = githubIssueIdentity(parts.owner, parts.repo, parts.number);
-                        const existing = issuePaths.get(identity);
-                        if (!existing || githubIssuePathPreference(path) < githubIssuePathPreference(existing)) {
-                            if (existing)
+            for (const { owner, repo } of configuredGithubRepoParts(this.#config)) {
+                const indexedPaths = await this.#githubIssuePathsFromIndex(owner, repo);
+                const roots = githubIssueRepoRoots(owner, repo);
+                // Keep the fallback roots as separate batches. Flattening a very large
+                // provider result is synchronous work and can starve the durable loop
+                // heartbeat before the bounded scan below gets a chance to yield.
+                const pathBatches = indexedPaths
+                    ? [indexedPaths]
+                    : await Promise.all(roots.map(async (root) => await this.#listRelayfileTree(root, 'GitHub issue ingestion')));
+                if (indexedPaths) {
+                    this.#increment('githubIssueIndexReposUsed');
+                }
+                else {
+                    this.#increment('githubIssueIndexFallbacks');
+                }
+                for (const paths of pathBatches) {
+                    for (let index = 0; index < paths.length; index += 1) {
+                        const path = paths[index];
+                        const parts = githubIssuePathParts(path);
+                        if (parts) {
+                            const identity = githubIssueIdentity(parts.owner, parts.repo, parts.number);
+                            const existing = issuePaths.get(identity);
+                            if (!existing || githubIssuePathPreference(path) < githubIssuePathPreference(existing)) {
+                                if (existing)
+                                    this.#increment('githubIssueAliasPathsSuppressed');
+                                issuePaths.set(identity, path);
+                            }
+                            else {
                                 this.#increment('githubIssueAliasPathsSuppressed');
-                            issuePaths.set(identity, path);
+                            }
                         }
-                        else {
-                            this.#increment('githubIssueAliasPathsSuppressed');
+                        else if (githubIssueDirectoryPathParts(path) !== undefined) {
+                            // listTree returns the issue directory entry alongside its
+                            // meta.json file; githubIssuePathParts() already collected the
+                            // file, so skip the directory to avoid reading the same issue
+                            // twice in one backfill pass. Directory paths are only meaningful
+                            // for live change events, not the tree scan.
+                            continue;
+                        }
+                        else if (isGithubIssueTreePath(path)) {
+                            this.#increment('githubIssuesIgnoredByPathRegex');
+                        }
+                        if ((index + 1) % LIVE_EVENT_DRAIN_BATCH_SIZE === 0) {
+                            await this.#refreshLiveHeartbeatIfDue();
+                            await liveEventYield();
                         }
                     }
-                    else if (githubIssueDirectoryPathParts(path) !== undefined) {
-                        // listTree returns the issue directory entry alongside its
-                        // meta.json file; githubIssuePathParts() already collected the
-                        // file, so skip the directory to avoid reading the same issue
-                        // twice in one backfill pass. Directory paths are only meaningful
-                        // for live change events, not the tree scan.
-                        continue;
-                    }
-                    else if (isGithubIssueTreePath(path)) {
-                        this.#increment('githubIssuesIgnoredByPathRegex');
-                    }
+                    await this.#refreshLiveHeartbeatIfDue();
                 }
             }
             for (const [identity, path] of issuePaths) {
@@ -2978,6 +3181,41 @@ export class FactoryLoop {
             return [];
         }
     }
+    async #githubIssuePathsFromIndex(owner, repo) {
+        const indexPath = `${GITHUB_ISSUE_ROOT}/${owner}/${repo}/issues/_index.json`;
+        let parsed;
+        try {
+            const { content } = await this.#readRelayfileFile(indexPath, 'GitHub issue index discovery');
+            parsed = parseJsonContent(content);
+        }
+        catch {
+            return undefined;
+        }
+        if (!Array.isArray(parsed))
+            return undefined;
+        const requiredLabel = this.#config.safety.requireLabel.trim().toLowerCase();
+        if (!requiredLabel)
+            return undefined;
+        const paths = [];
+        for (const entry of parsed) {
+            const row = asRecord(entry);
+            const number = row?.number;
+            const state = typeof row?.state === 'string' ? row.state.trim().toLowerCase() : undefined;
+            const labels = row?.labels;
+            // Labels were added to the public GitHub issue index contract after the
+            // first index version. Fall back for the entire repository if any row is
+            // legacy or malformed so an eligible issue can never be filtered out.
+            if (!Number.isSafeInteger(number) || Number(number) <= 0 || !state || !Array.isArray(labels) ||
+                !labels.every((label) => typeof label === 'string')) {
+                return undefined;
+            }
+            if (state !== 'open' || !labels.some((label) => label.trim().toLowerCase() === requiredLabel)) {
+                continue;
+            }
+            paths.push(`${GITHUB_ISSUE_ROOT}/${owner}__${repo}/issues/by-id/${number}.json`);
+        }
+        return paths;
+    }
     async #handleGithubIssueChange(path, opts = {}) {
         if (this.#githubIngestionEnabled === false || !isGithubIssueFilePath(path)) {
             return;
@@ -3815,6 +4053,13 @@ export class FactoryLoop {
             }
             return;
         }
+        const tracingReconciledExit = reason === 'reconciled-missing';
+        if (tracingReconciledExit) {
+            this.#logger.info?.('[factory] reconciled agent exit recovery started', {
+                issue: record.issue.key,
+                name,
+            });
+        }
         if (!await this.#assertDispatchLifecycleOwner(record)) {
             this.#logger.warn?.('[factory] ignored agent exit after durable lifecycle ownership was lost', {
                 issue: record.issue.key,
@@ -3822,6 +4067,8 @@ export class FactoryLoop {
             });
             return;
         }
+        if (tracingReconciledExit)
+            this.#logger.info?.('[factory] reconciled agent exit ownership confirmed', { issue: record.issue.key, name });
         // The issue-comment subscription and the fleet exit callback are separate
         // event streams. Reconcile comments that are already durable in the mount
         // before interpreting a clean exit as task completion, so an agent that
@@ -3830,9 +4077,13 @@ export class FactoryLoop {
             this.#increment('githubQuestionExitsSuppressed');
             return;
         }
+        if (tracingReconciledExit)
+            this.#logger.info?.('[factory] reconciled agent exit question replay completed', { issue: record.issue.key, name });
         const exiting = record.agents.get(name);
         if (exiting)
             await this.#reportAgent(record, exiting, 'agent.exited', { releaseReason: reason });
+        if (tracingReconciledExit)
+            this.#logger.info?.('[factory] reconciled agent exit telemetry completed', { issue: record.issue.key, name });
         if (this.#usesDurableDispatchLifecycle()) {
             const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
             if (lifecycle?.phase === 'parking') {
@@ -3843,10 +4094,10 @@ export class FactoryLoop {
         if (isCompletionReason(reason)) {
             if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
                 openOnly: this.#config.babysitter.enabled,
-            })) {
+            }, exiting)) {
                 if (this.#config.babysitter.enabled)
                     await this.#ensureBabysitterForIssue(record);
-                else
+                else if (await this.#allImplementersHaveCompletionPr(record))
                     await this.#completeIssue(record);
                 return;
             }
@@ -3873,13 +4124,14 @@ export class FactoryLoop {
                 // itself finishing means it believes the PR is ready, so re-check and
                 // advance to Human Review.
                 if (exiting?.spec.role === 'babysitter') {
-                    await this.#maybeAdvanceToHumanReview(record);
+                    await this.#maybeAdvanceToHumanReview(record, name);
                 }
                 else if (publishedPr) {
                     await this.#ensureBabysitter(record, {
                         repo: publishedPr.repo,
                         prNumber: publishedPr.number,
                         url: publishedPr.url,
+                        authoritative: true,
                     });
                 }
                 else {
@@ -3887,7 +4139,8 @@ export class FactoryLoop {
                 }
                 return;
             }
-            await this.#completeIssue(record);
+            if (await this.#allImplementersHaveCompletionPr(record))
+                await this.#completeIssue(record);
             return;
         }
         const tracked = exiting;
@@ -3895,14 +4148,59 @@ export class FactoryLoop {
             return;
         }
         try {
-            if (tracked.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
-                openOnly: this.#config.babysitter.enabled,
-            })) {
+            const hasCompletionPr = tracked.spec.role === 'implementer'
+                ? await this.#issueHasCompletionPr(record, {
+                    openOnly: this.#config.babysitter.enabled,
+                }, tracked)
+                : false;
+            if (tracingReconciledExit) {
+                this.#logger.info?.('[factory] reconciled agent exit completion PR lookup completed', {
+                    issue: record.issue.key,
+                    name,
+                    hasCompletionPr,
+                });
+            }
+            if (hasCompletionPr) {
+                let reconciledPr;
+                if (tracingReconciledExit && tracked.spec.role === 'implementer') {
+                    // A restart can discover that the implementer is gone after its PR
+                    // reached GitHub but before the durable receipt was saved. Persist the
+                    // exact existing-branch receipt before handing off to a babysitter;
+                    // otherwise the lifecycle remains `running` forever and consumes a
+                    // batch slot even though useful implementation work has finished.
+                    if (!await this.#saveDispatchLifecycle(record, 'publishing'))
+                        return;
+                    try {
+                        reconciledPr = await this.#publishImplementerPullRequest(record, tracked, {
+                            reconcileExisting: true,
+                        });
+                        if (reconciledPr && !await this.#saveDispatchLifecycle(record, 'published', reconciledPr))
+                            return;
+                    }
+                    catch (error) {
+                        this.#increment('githubPullRequestPublishFailures');
+                        this.#error(error, record.issue);
+                        this.#scheduleDispatchLifecycleRetry(record);
+                        return;
+                    }
+                }
                 if (this.#config.babysitter.enabled) {
-                    await this.#ensureBabysitterForIssue(record);
+                    if (reconciledPr) {
+                        await this.#ensureBabysitter(record, {
+                            repo: reconciledPr.repo,
+                            prNumber: reconciledPr.number,
+                            url: reconciledPr.url,
+                            headRef: reconciledPr.headRef,
+                            authoritative: true,
+                        });
+                    }
+                    else {
+                        await this.#ensureBabysitterForIssue(record);
+                    }
                     return;
                 }
-                await this.#completeIssue(record);
+                if (await this.#allImplementersHaveCompletionPr(record))
+                    await this.#completeIssue(record);
                 return;
             }
             // The implementer's turn ended without a PR of record. Agents reliably
@@ -3915,6 +4213,8 @@ export class FactoryLoop {
             // ahead of base, clone gone) it returns undefined and we fall through.
             if (tracked.spec.role === 'implementer') {
                 await this.#saveDispatchLifecycle(record, 'publishing');
+                if (tracingReconciledExit)
+                    this.#logger.info?.('[factory] reconciled agent exit PR publication started', { issue: record.issue.key, name });
                 const publishedPr = await this.#tryPublishImplementerPr(record, tracked);
                 if (publishedPr) {
                     await this.#saveDispatchLifecycle(record, 'published', publishedPr);
@@ -3923,10 +4223,12 @@ export class FactoryLoop {
                             repo: publishedPr.repo,
                             prNumber: publishedPr.number,
                             url: publishedPr.url,
+                            authoritative: true,
                         });
                     }
                     else {
-                        await this.#completeIssue(record);
+                        if (await this.#allImplementersHaveCompletionPr(record))
+                            await this.#completeIssue(record);
                     }
                     return;
                 }
@@ -4045,6 +4347,10 @@ export class FactoryLoop {
             return undefined;
         }
         try {
+            // A missed exit can be reconciled after the worker checkout was pruned.
+            // Re-create its deterministic worktree from the retained local branch so
+            // publication can still push/read the completed commit.
+            await this.#prepareAgentWorktree(record, implementer.spec);
             const published = await this.#publishImplementerPullRequest(record, implementer);
             if (published) {
                 this.#increment('implementerPrsPublishedOnExit');
@@ -4069,8 +4375,6 @@ export class FactoryLoop {
     async #publishImplementerPullRequest(record, implementer, opts = {}) {
         const key = `${issueKey(record.issue)}:${implementer.spec.repo}`;
         const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
-        if (durable?.pullRequest)
-            return durable.pullRequest;
         const cached = this.#publishedPullRequests.get(key);
         if (cached)
             return cached;
@@ -4095,7 +4399,11 @@ export class FactoryLoop {
             ? sourceRepoParts.owner
             : undefined;
         const repo = normalizeGithubRepo(implementer.spec.repo, this.#config.repos.org ?? sourceOwner);
+        const durableReceipt = publishedPullRequests(durable).find((receipt) => receipt.repo.toLowerCase() === repo.toLowerCase());
         const expectedHeadRef = implementer.spec.branch ?? remoteBranch;
+        if (durableReceipt &&
+            (!opts.reconcileExisting || !expectedHeadRef || durableReceipt.headRef === expectedHeadRef))
+            return durableReceipt;
         if (opts.reconcileExisting && expectedHeadRef) {
             const existing = await this.#openPullRequestByHead(repo, expectedHeadRef);
             if (existing) {
@@ -4139,6 +4447,44 @@ export class FactoryLoop {
         return result;
     }
     async #openPullRequestByHead(repo, expectedHeadRef) {
+        if (this.#hasProbePrGhRunner) {
+            try {
+                const result = await this.#probePrGhRunner([
+                    'pr',
+                    'list',
+                    '--repo',
+                    repo,
+                    '--head',
+                    expectedHeadRef,
+                    '--state',
+                    'open',
+                    '--json',
+                    'number,url,headRefName,isDraft',
+                    '--limit',
+                    '10',
+                ]);
+                const payload = parseJsonContent(result.stdout);
+                if (Array.isArray(payload)) {
+                    const candidates = payload.flatMap((entry) => {
+                        const candidate = asRecord(entry);
+                        const number = numberValue(candidate?.number);
+                        const url = stringValue(candidate?.url);
+                        const headRef = stringValue(candidate?.headRefName);
+                        if (!number || !url || headRef !== expectedHeadRef || candidate?.isDraft !== false)
+                            return [];
+                        return [{ repo, number, url, headRef }];
+                    });
+                    return candidates.sort((a, b) => b.number - a.number)[0];
+                }
+            }
+            catch (error) {
+                this.#logger.warn?.('[factory] exact-head gh PR lookup failed; falling back to mounted metadata', {
+                    repo,
+                    headRef: expectedHeadRef,
+                    error: describeError(error).errorMessage,
+                });
+            }
+        }
         const parts = githubRepoParts(repo);
         if (!parts)
             return undefined;
@@ -4450,12 +4796,22 @@ export class FactoryLoop {
         timer.unref?.();
         this.#dispatchLifecycleRetryTimers.set(key, timer);
     }
-    async #issueHasCompletionPr(record, opts = {}) {
+    async #issueHasCompletionPr(record, opts = {}, implementer) {
         try {
             const issue = await this.#readIssue(record.issue.path);
             if (!issue) {
                 return false;
             }
+            if (implementer?.spec.branch && record.decision.implementers.length > 1) {
+                const sourceOwner = record.issue.path
+                    ? githubIssuePathParts(record.issue.path)?.owner
+                    : undefined;
+                const repo = normalizeGithubRepo(implementer.spec.repo, this.#config.repos.org ?? sourceOwner);
+                const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+                if (publishedPullRequests(lifecycle).some((receipt) => receipt.repo.toLowerCase() === repo.toLowerCase()))
+                    return true;
+                return Boolean(await this.#openPullRequestByHead(repo, implementer.spec.branch));
+            }
             // Only a NON-DRAFT (ready) PR counts as completion. A draft PR means the
             // work isn't review-ready, so an implementer exiting with only a draft PR
             // must NOT mark the issue done / release agents — mirror the
@@ -4474,11 +4830,30 @@ export class FactoryLoop {
             return false;
         }
     }
+    async #allImplementersHaveCompletionPr(record, opts = {}) {
+        const implementers = [...record.agents.values()].filter((agent) => agent.spec.role === 'implementer');
+        if (implementers.length === 0)
+            return false;
+        if (implementers.length === 1)
+            return true;
+        const completed = await Promise.all(implementers.map(async (implementer) => this.#issueHasCompletionPr(record, opts, implementer)));
+        return completed.every(Boolean);
+    }
     async #resumeTrackedAgent(record, name, tracked) {
         if (!tracked.sessionRef) {
             return;
         }
+        this.#logger.debug?.('[factory] tracked agent resume preparation started', {
+            issue: record.issue.key,
+            name,
+            role: tracked.spec.role,
+        });
         await this.#prepareAgentWorktree(record, tracked.spec);
+        this.#logger.debug?.('[factory] tracked agent resume spawn started', {
+            issue: record.issue.key,
+            name,
+            role: tracked.spec.role,
+        });
         const result = await this.#fleet.resume({
             name,
             sessionRef: tracked.sessionRef,
@@ -4487,6 +4862,12 @@ export class FactoryLoop {
             repo: tracked.spec.repo,
             clonePath: tracked.spec.clonePath,
         });
+        this.#logger.debug?.('[factory] tracked agent resume spawn completed', {
+            issue: record.issue.key,
+            name,
+            resumedName: result.name,
+            role: tracked.spec.role,
+        });
         tracked.result = {
             ...result,
             node: result.node ?? tracked.result?.node,
@@ -4495,34 +4876,156 @@ export class FactoryLoop {
         tracked.sessionRef = result.sessionRef ?? tracked.sessionRef;
         record.agents.delete(name);
         record.agents.set(result.name, tracked);
-        if (tracked.spec.role === 'babysitter') {
-            this.#babysitterCriticalAgents.delete(name);
-            const ref = this.#babysitterPr.get(issueKey(record.issue));
-            if (ref) {
-                ref.agentName = result.name;
-                for (const [wakeKey, state] of this.#babysitterWakeStates) {
-                    if (issueKey(state.issue) !== issueKey(record.issue))
-                        continue;
-                    if (state.timer)
-                        clearTimeout(state.timer);
-                    this.#babysitterWakeStates.delete(wakeKey);
-                    state.timer = undefined;
-                    state.agentName = result.name;
-                    state.tracked = tracked;
-                    if (state.deferredSubmitTargets) {
-                        state.deferredSubmitTargets = undefined;
-                        state.deliveringKinds = undefined;
-                        state.kinds.add('pull-request-state');
-                        await this.#recordPendingBabysitterWake(state);
+        await this.#retargetBabysitterAgent(record, name, tracked);
+        this.#logger.debug?.('[factory] tracked agent resume ownership retargeted', {
+            issue: record.issue.key,
+            name,
+            resumedName: result.name,
+            role: tracked.spec.role,
+        });
+        await this.#reportAgent(record, tracked, 'agent.resumed');
+    }
+    async #retargetBabysitterAgent(record, previousName, tracked) {
+        if (tracked.spec.role !== 'babysitter')
+            return;
+        const currentName = tracked.result?.name ?? tracked.spec.name;
+        this.#babysitterCriticalAgents.delete(previousName);
+        const ownership = [...this.#babysitterPr.entries()]
+            .find(([, candidate]) => candidate.agentName === previousName);
+        const [ownershipKey, ref] = ownership ?? [];
+        if (!ref)
+            return;
+        ref.agentName = currentName;
+        // Resuming a session commonly preserves its Relaycast name. Iterate a
+        // snapshot because deleting and re-inserting that same key while walking
+        // the live Map would append it to the iterator again indefinitely.
+        for (const [wakeKey, state] of [...this.#babysitterWakeStates]) {
+            if (state.agentName !== previousName)
+                continue;
+            if (state.timer)
+                clearTimeout(state.timer);
+            this.#babysitterWakeStates.delete(wakeKey);
+            state.timer = undefined;
+            state.agentName = currentName;
+            state.tracked = tracked;
+            if (state.deferredSubmitTargets) {
+                state.deferredSubmitTargets = undefined;
+                state.deliveringKinds = undefined;
+                state.kinds.add('pull-request-state');
+                await this.#recordPendingBabysitterWake(state);
+            }
+            this.#babysitterWakeStates.set(babysitterWakeKey(record.issue, ref), state);
+            if (state.kinds.size > 0)
+                this.#scheduleBabysitterWake(state, BABYSITTER_EVENT_COALESCE_MS);
+        }
+        await this.#persistBabysitterSession(record.issue, ref, tracked, ownershipKey);
+    }
+    async #recoverUnreachableBabysitter(state) {
+        const batch = await this.#batch();
+        const record = batch.getIssueByAgent(state.agentName);
+        const tracked = record?.agents.get(state.agentName);
+        if (!record || !tracked || tracked.spec.role !== 'babysitter')
+            return false;
+        if (!await this.#assertIssueDispatchLifecycleOwner(record.issue))
+            return false;
+        const previousName = state.agentName;
+        this.#fleet.markAgentTerminal?.(previousName, 'babysitter-unreachable');
+        try {
+            await this.#fleet.release(previousName, 'babysitter-unreachable');
+            this.#logger.debug?.('[factory] unreachable babysitter release completed', {
+                issue: record.issue.key,
+                babysitter: previousName,
+            });
+        }
+        catch (error) {
+            // An unresolvable Relaycast identity is frequently already absent from
+            // placement too. Release is best-effort; the fresh spawn below is the
+            // recovery operation that matters.
+            this.#increment('babysitterUnreachableReleaseFailures');
+            this.#logger.warn?.('[factory] unreachable babysitter release failed; attempting session recovery', {
+                issue: record.issue.key,
+                babysitter: previousName,
+                error: describeError(error).errorMessage,
+            });
+        }
+        try {
+            const configuredCapability = this.#config.agentCapabilities.babysitter;
+            const capabilityChanged = tracked.spec.capability !== configuredCapability;
+            if (tracked.sessionRef && !capabilityChanged) {
+                await this.#resumeTrackedAgent(record, previousName, tracked);
+            }
+            else {
+                const invocationId = `${batch.invocationIdFor(record.issue, tracked.spec)}:unreachable:${this.#clock.now()}`;
+                const { sessionRef: _staleSessionRef, ...persistedSpec } = tracked.spec;
+                const replacementSpec = capabilityChanged
+                    ? {
+                        ...persistedSpec,
+                        capability: configuredCapability,
+                        model: this.#config.models.babysitter,
                     }
-                    this.#babysitterWakeStates.set(babysitterWakeKey(record.issue, ref), state);
-                    if (state.kinds.size > 0)
-                        this.#scheduleBabysitterWake(state, BABYSITTER_EVENT_COALESCE_MS);
+                    : persistedSpec;
+                await this.#prepareAgentWorktree(record, replacementSpec);
+                const result = await this.#fleet.spawn({
+                    name: replacementSpec.name,
+                    capability: replacementSpec.capability,
+                    node: tracked.result?.node ?? replacementSpec.node ?? 'self',
+                    repo: replacementSpec.repo,
+                    task: replacementSpec.task,
+                    model: replacementSpec.model,
+                    cwd: replacementSpec.clonePath,
+                    invocationId,
+                    restartPolicy: defaultRestartPolicy(replacementSpec),
+                    channel: replacementSpec.channel,
+                });
+                batch.recordSpawn(record, replacementSpec, invocationId, result);
+                const restarted = record.agents.get(result.name);
+                if (!restarted)
+                    throw new Error(`Recovered babysitter ${result.name} was not tracked`);
+                await this.#retargetBabysitterAgent(record, previousName, restarted);
+                await this.#reportAgent(record, restarted, 'agent.resumed');
+                if (capabilityChanged) {
+                    this.#increment('babysitterCapabilityMigrations');
+                    this.#logger.info?.('[factory] cold-started unreachable babysitter on configured capability', {
+                        issue: record.issue.key,
+                        babysitter: result.name,
+                        previousCapability: tracked.spec.capability,
+                        capability: configuredCapability,
+                    });
                 }
-                await this.#persistBabysitterSession(record.issue, ref, tracked);
             }
+            this.#logger.debug?.('[factory] unreachable babysitter replacement started', {
+                issue: record.issue.key,
+                previousBabysitter: previousName,
+                babysitter: state.agentName,
+            });
+            await this.#writeInFlightRegistry();
+            this.#logger.debug?.('[factory] unreachable babysitter registry refreshed', {
+                issue: record.issue.key,
+                babysitter: state.agentName,
+            });
+            if (!await this.#saveDispatchLifecycle(record, 'running'))
+                return false;
+            this.#increment('babysitterEventWakeUnreachableRecoveries');
+            this.#logger.info?.('[factory] restarted unreachable babysitter session', {
+                issue: record.issue.key,
+                repo: state.repo,
+                prNumber: state.prNumber,
+                previousBabysitter: previousName,
+                babysitter: state.agentName,
+            });
+            return true;
+        }
+        catch (error) {
+            this.#increment('babysitterEventWakeUnreachableRecoveryFailures');
+            this.#logger.warn?.('[factory] failed to restart unreachable babysitter session', {
+                issue: record.issue.key,
+                repo: state.repo,
+                prNumber: state.prNumber,
+                babysitter: previousName,
+                error: describeError(error).errorMessage,
+            });
+            return false;
         }
-        await this.#reportAgent(record, tracked, 'agent.resumed');
     }
     async #handleDeliveryFailed(info) {
         const critical = await this.#state.consumeCritical(this.#workspaceId, info.msgId ?? '');
@@ -4586,7 +5089,7 @@ export class FactoryLoop {
                 return;
             }
             this.#increment('agentLifecycleReadySignals');
-            await this.#maybeAdvanceToHumanReview(record);
+            await this.#maybeAdvanceToHumanReview(record, signal.name);
             return;
         }
         if (tracked.spec.role === 'babysitter') {
@@ -4686,7 +5189,7 @@ export class FactoryLoop {
                     this.#increment('prReadySignalsIgnoredIssueMismatch');
                     return;
                 }
-                await this.#maybeAdvanceToHumanReview(record);
+                await this.#maybeAdvanceToHumanReview(record, ready.agentName);
                 return;
             }
         }
@@ -5504,13 +6007,25 @@ export class FactoryLoop {
         }
     }
     async #replayGithubIssueComments(key) {
+        const active = this.#githubIssueCommentReplays.get(key);
+        if (active)
+            return await active;
+        const replay = this.#runGithubIssueCommentReplay(key).finally(() => {
+            if (this.#githubIssueCommentReplays.get(key) === replay) {
+                this.#githubIssueCommentReplays.delete(key);
+            }
+        });
+        this.#githubIssueCommentReplays.set(key, replay);
+        return await replay;
+    }
+    async #runGithubIssueCommentReplay(key) {
         const watch = this.#githubIssueCommentWatchStates.get(key);
         if (!watch)
             return;
         const comments = [];
         const sinceCommentId = githubCommentNumericId(watch.sinceCommentId ?? watch.lastSeenCommentId);
         const processedCommentIds = new Set(watch.processedCommentIds ?? []);
-        for (const path of await this.#githubIssueCommentPaths(watch.source)) {
+        for (const path of await this.#githubIssueCommentPaths(watch.source, watch.issue.path)) {
             const parts = githubIssueCommentPathParts(path);
             const id = parts ? githubCommentNumericId(parts.commentId) : undefined;
             if (id !== undefined && id > sinceCommentId && !processedCommentIds.has(String(id))) {
@@ -5537,14 +6052,25 @@ export class FactoryLoop {
             }
         }
     }
-    async #githubIssueCommentPaths(source) {
+    async #githubIssueCommentPaths(source, issuePath) {
         const paths = new Set();
         const owner = encodeURIComponent(source.owner);
         const repo = encodeURIComponent(source.repo);
-        for (const prefix of [
-            `${GITHUB_ISSUE_ROOT}/${owner}/${repo}/issues`,
-            `${GITHUB_ISSUE_ROOT}/${owner}__${repo}/issues`,
-        ]) {
+        const issueParts = issuePath ? githubIssuePathParts(issuePath) : undefined;
+        const canonicalIssueRoot = issuePath
+            && issueParts?.owner.toLowerCase() === source.owner.toLowerCase()
+            && issueParts.repo.toLowerCase() === source.repo.toLowerCase()
+            && issueParts.number === source.number
+            && /\/(?:meta|metadata)\.json$/u.test(issuePath)
+            ? dirname(issuePath)
+            : undefined;
+        const prefixes = canonicalIssueRoot
+            ? [canonicalIssueRoot]
+            : [
+                `${GITHUB_ISSUE_ROOT}/${owner}/${repo}/issues`,
+                `${GITHUB_ISSUE_ROOT}/${owner}__${repo}/issues`,
+            ];
+        for (const prefix of prefixes) {
             try {
                 for (const path of await this.#mount.listTree(prefix)) {
                     const parts = githubIssueCommentPathParts(path);
@@ -5941,7 +6467,8 @@ export class FactoryLoop {
     async #restoreBabysitterOwnership() {
         const batch = await this.#batch();
         for (const [persistedKey, session] of await this.#state.listBabysitterSessions(this.#workspaceId)) {
-            if (persistedKey !== issueKey(session.issue) ||
+            const ownershipKey = babysitterOwnershipKey(session.issue, session);
+            if ((persistedKey !== issueKey(session.issue) && persistedKey !== ownershipKey) ||
                 !validGithubRepo(session.repo) ||
                 !validPrNumber(session.prNumber) ||
                 !session.agentName) {
@@ -5970,20 +6497,30 @@ export class FactoryLoop {
                 continue;
             }
             const record = batch.getIssue(session.issue);
-            const tracked = record?.agents.get(session.agentName)
-                ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter')
+            const trackedEntry = record?.agents.has(session.agentName)
+                ? [session.agentName, record.agents.get(session.agentName)]
+                : [...(record?.agents.entries() ?? [])].find(([, agent]) => agent.spec.role === 'babysitter' &&
+                    githubPrIdentity(agent.spec.ownedPullRequest?.repo ?? '', agent.spec.ownedPullRequest?.number ?? 0) ===
+                        githubPrIdentity(session.repo, session.prNumber));
+            const tracked = trackedEntry?.[1]
                 ?? durableBabysitterTrackedAgent(session, this.#config.agentCapabilities.babysitter);
+            if (record && !trackedEntry)
+                record.agents.set(session.agentName, tracked);
             const ref = {
                 repo: session.repo,
                 prNumber: session.prNumber,
                 path: session.path,
                 agentName: session.agentName,
             };
-            this.#babysitterPr.set(persistedKey, ref);
-            this.#babysitterIssueRefs.set(persistedKey, { ...session.issue });
-            this.#babysitterSpawned.add(persistedKey);
+            this.#babysitterPr.set(ownershipKey, ref);
+            this.#babysitterIssueRefs.set(ownershipKey, { ...session.issue });
+            this.#babysitterSpawned.add(ownershipKey);
             if (session.critical)
                 this.#babysitterCriticalAgents.add(session.agentName);
+            if (persistedKey !== ownershipKey) {
+                await this.#state.setBabysitterSession(this.#workspaceId, ownershipKey, session);
+                await this.#state.clearBabysitterSession(this.#workspaceId, persistedKey);
+            }
             this.#increment('babysitterOwnershipRestored');
             const pendingKinds = session.pendingKinds.filter(isBabysitterWakeKind);
             if (pendingKinds.length > 0) {
@@ -5992,6 +6529,74 @@ export class FactoryLoop {
             }
         }
     }
+    async #reconcileRestoredBabysitterReceipts(onlyRecord) {
+        const records = onlyRecord ? [onlyRecord] : (await this.#batch()).inFlight;
+        for (const record of records) {
+            if (!await this.#assertIssueDispatchLifecycleOwner(record.issue))
+                continue;
+            const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+            // Babysitter sessions are independently durable and restore only after
+            // their mounted PR metadata passes the open/draft/issue-identity guard.
+            // Fold those validated receipts back into the lifecycle on takeover.
+            // This closes the crash gap where the babysitter session persisted but
+            // the lifecycle PR receipt did not, and lets exact ownership retire any
+            // earlier weak-match babysitter for the same repository. The lifecycle's
+            // own exact receipts are authoritative independently of the session
+            // index: session restoration can legitimately be delayed or skipped
+            // while mounted PR metadata converges, but that must never preserve a
+            // superseded weak-match babysitter already disproved by publication.
+            const authoritative = new Map();
+            for (const receipt of lifecycle?.pullRequests ?? (lifecycle?.pullRequest ? [lifecycle.pullRequest] : [])) {
+                if (!receipt.repo || !validPrNumber(receipt.number) || !receipt.url || !receipt.headRef)
+                    continue;
+                const identity = githubPrIdentity(receipt.repo, receipt.number);
+                if (identity)
+                    authoritative.set(identity, { ...receipt });
+            }
+            const restored = [...this.#babysitterPr.entries()]
+                .filter(([ownershipKey, ref]) => ref.agentName && issueKey(this.#babysitterIssueRefs.get(ownershipKey) ?? record.issue) === issueKey(record.issue))
+                .map(([, ref]) => ref);
+            for (const receipt of restored) {
+                if (!receipt.repo || !validPrNumber(receipt.prNumber))
+                    continue;
+                const snapshot = await this.#readPrSnapshot(receipt);
+                const headRef = snapshot?.headRef ?? record.decision.implementers
+                    .find((implementer) => implementer.repo.toLowerCase() === receipt.repo.toLowerCase())?.branch;
+                if (!headRef)
+                    continue;
+                const identity = githubPrIdentity(receipt.repo, receipt.prNumber);
+                if (!identity)
+                    continue;
+                authoritative.set(identity, {
+                    repo: receipt.repo,
+                    number: receipt.prNumber,
+                    url: snapshot?.url ?? `https://github.com/${receipt.repo}/pull/${receipt.prNumber}`,
+                    headRef,
+                    ...(receipt.path ? { path: receipt.path } : {}),
+                });
+            }
+            if (authoritative.size > 0) {
+                this.#logger.debug?.('[factory] reconciling authoritative babysitter receipts', {
+                    issue: record.issue.key,
+                    lifecycleReceipts: lifecycle?.pullRequests?.map((receipt) => receipt.number) ?? [],
+                    restoredReceipts: restored.map((receipt) => receipt.prNumber),
+                    authoritativeReceipts: [...authoritative.values()].map((receipt) => receipt.number),
+                });
+                await this.#retireBabysittersOutsideCurrentRoutes(record);
+            }
+            for (const published of authoritative.values()) {
+                if (!await this.#saveDispatchLifecycle(record, 'running', published))
+                    return;
+                await this.#ensureBabysitter(record, {
+                    repo: published.repo,
+                    prNumber: published.number,
+                    url: published.url,
+                    path: published.path,
+                    authoritative: true,
+                });
+            }
+        }
+    }
     async #drainBabysitterWakesForStop() {
         for (const state of this.#babysitterWakeStates.values()) {
             state.cancelled = true;
@@ -6006,12 +6611,13 @@ export class FactoryLoop {
         }
         this.#babysitterWakeStates.clear();
     }
-    async #cancelBabysitterWake(issueIdentity) {
-        const issue = this.#babysitterIssueRefs.get(issueIdentity);
+    async #cancelBabysitterWake(ownershipKey) {
+        const issue = this.#babysitterIssueRefs.get(ownershipKey);
+        const ref = this.#babysitterPr.get(ownershipKey);
         const mayClearDurable = !this.#usesDurableDispatchLifecycle()
             || Boolean(issue && await this.#assertIssueDispatchLifecycleOwner(issue));
         for (const [key, state] of this.#babysitterWakeStates) {
-            if (issueKey(state.issue) !== issueIdentity)
+            if (!ref || babysitterOwnershipKey(state.issue, state) !== ownershipKey)
                 continue;
             state.cancelled = true;
             delete state.tracked.spec.pendingPullRequestWake;
@@ -6020,11 +6626,19 @@ export class FactoryLoop {
             this.#babysitterWakeStates.delete(key);
             this.#babysitterCriticalAgents.delete(state.agentName);
         }
-        this.#babysitterPr.delete(issueIdentity);
-        this.#babysitterIssueRefs.delete(issueIdentity);
-        this.#babysitterSpawned.delete(issueIdentity);
+        this.#babysitterPr.delete(ownershipKey);
+        this.#babysitterIssueRefs.delete(ownershipKey);
+        this.#babysitterSpawned.delete(ownershipKey);
+        this.#babysitterReady.delete(ownershipKey);
         if (mayClearDurable)
-            await this.#state.clearBabysitterSession(this.#workspaceId, issueIdentity);
+            await this.#state.clearBabysitterSession(this.#workspaceId, ownershipKey);
+    }
+    async #cancelBabysittersForIssue(issue) {
+        const wanted = issueKey(issue);
+        const keys = [...this.#babysitterIssueRefs.entries()]
+            .filter(([, candidate]) => issueKey(candidate) === wanted)
+            .map(([key]) => key);
+        await Promise.all(keys.map(async (key) => this.#cancelBabysitterWake(key)));
     }
     async #routeBabysitterEvent(path, extraKinds = []) {
         const event = githubBabysitterEventPathParts(path);
@@ -6086,7 +6700,7 @@ export class FactoryLoop {
                 const tracked = record?.agents.get(ref.agentName)
                     ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter')
                     ?? durableBabysitterTrackedAgent({ issue, repo: ref.repo, prNumber: ref.prNumber, path: ref.path, agentName: ref.agentName, critical: false, pendingKinds: [] }, this.#config.agentCapabilities.babysitter);
-                return { issue, record, ref, tracked };
+                return { key, issue, record, ref, tracked };
             }
         }
         return undefined;
@@ -6125,13 +6739,16 @@ export class FactoryLoop {
         // Owner lookup and queueing straddle async mount/state reads. Revalidate
         // the exact composite owner so a concurrent close/merge cancellation can
         // never recreate durable state from a stale child event.
-        const current = this.#babysitterPr.get(issueKey(issue));
+        const ownershipKey = babysitterOwnershipKey(issue, ref);
+        const current = this.#babysitterPr.get(ownershipKey);
         if (!current ||
             current.agentName !== ref.agentName ||
             githubPrIdentity(current.repo, current.prNumber) !== githubPrIdentity(ref.repo, ref.prNumber)) {
             this.#increment('babysitterEventsIgnoredStaleOwner');
             return;
         }
+        // Any new event invalidates a prior readiness assertion for this exact PR.
+        this.#babysitterReady.delete(ownershipKey);
         const key = babysitterWakeKey(issue, ref);
         let state = this.#babysitterWakeStates.get(key);
         if (!state) {
@@ -6177,18 +6794,18 @@ export class FactoryLoop {
                 kinds: [...kinds].sort(compareBabysitterWakeKinds),
             };
         }
-        await this.#persistBabysitterSession(state.issue, this.#babysitterPr.get(issueKey(state.issue)) ?? {
+        await this.#persistBabysitterSession(state.issue, this.#babysitterPr.get(babysitterOwnershipKey(state.issue, state)) ?? {
             repo: state.repo,
             prNumber: state.prNumber,
             agentName: state.agentName,
         }, state.tracked);
     }
-    async #persistBabysitterSession(issue, ref, tracked) {
+    async #persistBabysitterSession(issue, ref, tracked, ownershipKey = babysitterOwnershipKey(issue, ref)) {
         if (!await this.#assertIssueDispatchLifecycleOwner(issue)) {
             throw new Error(`Babysitter lifecycle ownership lost for ${issue.key}`);
         }
         const pending = tracked?.spec.pendingPullRequestWake;
-        await this.#state.setBabysitterSession(this.#workspaceId, issueKey(issue), {
+        await this.#state.setBabysitterSession(this.#workspaceId, ownershipKey, {
             issue: { ...issue },
             repo: ref.repo,
             prNumber: ref.prNumber,
@@ -6273,6 +6890,7 @@ export class FactoryLoop {
                 await this.#fleet.sendMessage(input);
                 state.unreachableSinceMs = undefined;
                 state.unreachableEscalated = false;
+                state.unreachableRecoveryAfterMs = undefined;
                 if (this.#stopping || state.cancelled) {
                     state.deliveringKinds = undefined;
                     return;
@@ -6288,6 +6906,7 @@ export class FactoryLoop {
                 // registration-lag backoff state accumulated by prior failures.
                 state.unreachableSinceMs = undefined;
                 state.unreachableEscalated = false;
+                state.unreachableRecoveryAfterMs = undefined;
                 targets = ack.targets.length > 0 ? [...new Set(ack.targets)] : [input.to];
             }
             if (this.#stopping || state.cancelled)
@@ -6343,21 +6962,23 @@ export class FactoryLoop {
                 // unreachable window so a later genuine registration lag starts fresh.
                 state.unreachableSinceMs = undefined;
                 state.unreachableEscalated = false;
+                state.unreachableRecoveryAfterMs = undefined;
             }
             const unreachableMs = state.unreachableSinceMs !== undefined
                 ? this.#clock.now() - state.unreachableSinceMs
                 : 0;
             if (registrationLag && unreachableMs >= this.#babysitterWakeUnreachableEscalateMs) {
                 // The agent is up but its relay identity never became resolvable. Stop
-                // the tight 1s loop: back off to a slow cadence (still eventually
-                // recovering if the agent finally enrolls) and flag it once so an
-                // operator can intervene (e.g. re-spawn / restart) instead of the
-                // failure spinning silently forever.
+                // the tight 1s loop, reconcile once, and restart the session. A recovery
+                // cooldown prevents a still-converging Relaycast registration from
+                // turning that restart into another tight loop.
                 state.nextDelayMs = this.#babysitterWakeUnreachableRetryMs;
                 if (!state.unreachableEscalated) {
                     state.unreachableEscalated = true;
+                    await this.#fleet.reconcileTrackedAgents?.();
+                    this.#increment('babysitterEventWakeUnreachableReconciliations');
                     this.#increment('babysitterEventWakeUnreachableEscalations');
-                    this.#logger.warn?.('[factory] babysitter unreachable past grace window; slowing wake retries and flagging for human attention', {
+                    this.#logger.warn?.('[factory] babysitter unreachable past grace window; reconciling and restarting its session', {
                         issue: state.issue.key,
                         repo: state.repo,
                         prNumber: state.prNumber,
@@ -6367,6 +6988,19 @@ export class FactoryLoop {
                         error: describeError(error).errorMessage,
                     });
                 }
+                if (state.unreachableRecoveryAfterMs === undefined ||
+                    this.#clock.now() >= state.unreachableRecoveryAfterMs) {
+                    state.unreachableRecoveryAfterMs = this.#clock.now() + this.#babysitterWakeUnreachableRetryMs;
+                    if (await this.#recoverUnreachableBabysitter(state)) {
+                        // Probe the newly registered identity promptly. If Relaycast still
+                        // cannot resolve it, the recovery cooldown above prevents another
+                        // teardown loop and the next attempt uses the slow cadence.
+                        state.nextDelayMs = BABYSITTER_EVENT_RETRY_MS;
+                    }
+                }
+                else {
+                    state.nextDelayMs = Math.max(BABYSITTER_EVENT_RETRY_MS, state.unreachableRecoveryAfterMs - this.#clock.now());
+                }
             }
             else {
                 state.nextDelayMs = BABYSITTER_EVENT_RETRY_MS;
@@ -6454,18 +7088,17 @@ export class FactoryLoop {
         // only and can never redirect a live babysitter.
         const owned = await this.#babysitterOwnerFor(repo, snapshot.number);
         if (owned) {
-            const ownedKey = issueKey(owned.issue);
             if (prMetaShowsMerged(snapshot)) {
                 if (owned.record)
                     await this.#advanceMergedPrToDone(snapshot, owned.record);
                 else
-                    await this.#cancelBabysitterWake(ownedKey);
+                    await this.#cancelBabysitterWake(owned.key);
                 return;
             }
             if (!this.#config.babysitter.enabled)
                 return;
             if (snapshot.state && snapshot.state.trim().toUpperCase() !== 'OPEN') {
-                await this.#cancelBabysitterWake(ownedKey);
+                await this.#cancelBabysitterWake(owned.key);
                 return;
             }
             if (snapshot.draft)
@@ -6474,8 +7107,23 @@ export class FactoryLoop {
             return;
         }
         const record = this.#inFlightIssueForPrSnapshot(snapshot, await this.#batch(), repo);
-        const babysitterKey = record ? issueKey(record.issue) : undefined;
+        const babysitterKey = record ? babysitterOwnershipKey(record.issue, { repo, prNumber: snapshot.number }) : undefined;
         const existing = babysitterKey ? this.#babysitterPr.get(babysitterKey) : undefined;
+        const sameRepoOwner = record
+            ? [...this.#babysitterPr.entries()].find(([key, candidate]) => issueKey(this.#babysitterIssueRefs.get(key) ?? record.issue) === issueKey(record.issue) &&
+                candidate.repo.toLowerCase() === repo.toLowerCase())?.[1]
+            : undefined;
+        if (sameRepoOwner && githubPrIdentity(sameRepoOwner.repo, sameRepoOwner.prNumber) !== githubPrIdentity(repo, snapshot.number)) {
+            this.#increment('babysitterEventsIgnoredOwnershipMismatch');
+            this.#logger.warn?.('[factory] ignored PR event that conflicts with established babysitter ownership', {
+                issue: record?.issue.key,
+                ownedRepo: sameRepoOwner.repo,
+                ownedPrNumber: sameRepoOwner.prNumber,
+                eventRepo: repo,
+                eventPrNumber: snapshot.number,
+            });
+            return;
+        }
         if (existing && githubPrIdentity(existing.repo, existing.prNumber) !== githubPrIdentity(repo, snapshot.number)) {
             this.#increment('babysitterEventsIgnoredOwnershipMismatch');
             this.#logger.warn?.('[factory] ignored PR event that conflicts with established babysitter ownership', {
@@ -6641,8 +7289,21 @@ export class FactoryLoop {
     // probe resolver and spawn the babysitter. Triggered by an implementer exiting
     // after opening its PR (an event, not a poll).
     async #ensureBabysitterForIssue(record) {
-        if (this.#babysitterSpawned.has(issueKey(record.issue))) {
-            return;
+        if (this.#usesDurableDispatchLifecycle()) {
+            const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+            const receipts = lifecycle?.pullRequests ?? (lifecycle?.pullRequest ? [lifecycle.pullRequest] : []);
+            if (receipts.length > 0) {
+                for (const receipt of receipts) {
+                    await this.#ensureBabysitter(record, {
+                        repo: receipt.repo,
+                        prNumber: receipt.number,
+                        url: receipt.url,
+                        headRef: receipt.headRef,
+                        authoritative: true,
+                    });
+                }
+                return;
+            }
         }
         const issue = await this.#readIssue(record.issue.path);
         if (!issue) {
@@ -6655,11 +7316,14 @@ export class FactoryLoop {
         await this.#ensureBabysitter(record, { repo: pr.repo, prNumber: pr.prNumber });
     }
     async #ensureBabysitter(record, prRef) {
-        const babysitterKey = issueKey(record.issue);
+        const babysitterKey = babysitterOwnershipKey(record.issue, prRef);
         if (!await this.#assertIssueDispatchLifecycleOwner(record.issue)) {
             this.#increment('babysitterLifecycleOwnershipRejected');
             return;
         }
+        const replacedSuperseded = prRef.authoritative
+            ? await this.#retireSupersededBabysitters(record, prRef)
+            : false;
         this.#babysitterIssueRefs.set(babysitterKey, { ...record.issue });
         const existing = this.#babysitterPr.get(babysitterKey);
         if (existing && githubPrIdentity(existing.repo, existing.prNumber) !== githubPrIdentity(prRef.repo, prRef.prNumber)) {
@@ -6684,7 +7348,9 @@ export class FactoryLoop {
                 settled.path = prRef.path;
             return;
         }
-        const trackedBabysitter = [...record.agents.entries()].find(([, agent]) => agent.spec.role === 'babysitter');
+        const wantedPr = githubPrIdentity(prRef.repo, prRef.prNumber);
+        const trackedBabysitter = [...record.agents.entries()].find(([, agent]) => agent.spec.role === 'babysitter' &&
+            githubPrIdentity(agent.spec.ownedPullRequest?.repo ?? '', agent.spec.ownedPullRequest?.number ?? 0) === wantedPr);
         if (trackedBabysitter) {
             const [trackedName, tracked] = trackedBabysitter;
             const owned = tracked.spec.ownedPullRequest;
@@ -6718,6 +7384,12 @@ export class FactoryLoop {
             const route = record.decision.routes.find((candidate) => candidate.repo === prRef.repo)
                 ?? record.decision.routes[0];
             const initialSpec = babysitterSpec(issue, this.#config, route);
+            if (replacedSuperseded || [...this.#babysitterIssueRefs.entries()].some(([key, candidate]) => key !== babysitterKey && issueKey(candidate) === issueKey(record.issue))) {
+                initialSpec.name = agentNameForRole(issue, 'babysit', {
+                    repo: prRef.repo,
+                    discriminator: `${sanitizeAgentSlug(prRef.repo)}-${prRef.prNumber}`,
+                });
+            }
             const sharedCheckout = [...record.agents.values()]
                 .map((agent) => agent.spec)
                 .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath)
@@ -6814,24 +7486,129 @@ export class FactoryLoop {
             }
         }
     }
+    async #retireSupersededBabysitters(record, prRef) {
+        const wanted = githubPrIdentity(prRef.repo, prRef.prNumber);
+        const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+        const trackedAgents = new Map([
+            ...(lifecycle?.agents ?? [])
+                .filter((agent) => agent.releasedAtMs === undefined)
+                .map((agent) => [agent.name, cloneTrackedAgent(agent.tracked)]),
+            ...record.agents,
+        ]);
+        const superseded = [...trackedAgents.entries()].filter(([, tracked]) => {
+            const owned = tracked.spec.ownedPullRequest;
+            return tracked.spec.role === 'babysitter' &&
+                owned?.repo.toLowerCase() === prRef.repo.toLowerCase() &&
+                githubPrIdentity(owned.repo, owned.number) !== wanted;
+        });
+        for (const [agentName, tracked] of superseded) {
+            const owned = tracked.spec.ownedPullRequest;
+            const failed = await this.#releaseAndTerminateAgents([[agentName, tracked]], 'superseded-pr-receipt', 'completion');
+            if (failed.length > 0) {
+                this.#increment('supersededBabysitterReleaseFailures');
+                throw new Error(`Failed to release superseded babysitter ${agentName}`);
+            }
+            if (owned) {
+                const staleKey = babysitterOwnershipKey(record.issue, {
+                    repo: owned.repo,
+                    prNumber: owned.number,
+                });
+                await this.#cancelBabysitterWake(staleKey);
+                if (await this.#assertIssueDispatchLifecycleOwner(record.issue)) {
+                    await this.#state.clearBabysitterSession(this.#workspaceId, staleKey);
+                }
+            }
+            record.agents.delete(agentName);
+            this.#babysitterCriticalAgents.delete(agentName);
+            this.#increment('supersededBabysittersReleased');
+            this.#logger.info?.('[factory] released babysitter superseded by exact PR receipt', {
+                issue: record.issue.key,
+                babysitter: agentName,
+                previousRepo: owned?.repo,
+                previousPrNumber: owned?.number,
+                repo: prRef.repo,
+                prNumber: prRef.prNumber,
+            });
+        }
+        if (superseded.length > 0) {
+            const latest = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+            if (latest && !await this.#saveDispatchLifecycle(record, latest.phase)) {
+                throw new Error(`Failed to persist superseded babysitter cleanup for ${record.issue.key}`);
+            }
+        }
+        return superseded.length > 0;
+    }
+    async #retireBabysittersOutsideCurrentRoutes(record) {
+        const wantedRepos = new Set(record.decision.implementers.map((implementer) => implementer.repo.toLowerCase()));
+        const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+        const trackedAgents = new Map([
+            ...(lifecycle?.agents ?? [])
+                .filter((agent) => agent.releasedAtMs === undefined)
+                .map((agent) => [agent.name, cloneTrackedAgent(agent.tracked)]),
+            ...record.agents,
+        ]);
+        const unrouted = [...trackedAgents.entries()].filter(([, tracked]) => {
+            const owned = tracked.spec.ownedPullRequest;
+            return tracked.spec.role === 'babysitter' &&
+                Boolean(owned) &&
+                !wantedRepos.has(owned.repo.toLowerCase());
+        });
+        for (const [agentName, tracked] of unrouted) {
+            const owned = tracked.spec.ownedPullRequest;
+            const failed = await this.#releaseAndTerminateAgents([[agentName, tracked]], 'superseded-pr-route', 'completion');
+            if (failed.length > 0) {
+                this.#increment('supersededBabysitterReleaseFailures');
+                throw new Error(`Failed to release unrouted babysitter ${agentName}`);
+            }
+            if (owned) {
+                const staleKey = babysitterOwnershipKey(record.issue, {
+                    repo: owned.repo,
+                    prNumber: owned.number,
+                });
+                await this.#cancelBabysitterWake(staleKey);
+                if (await this.#assertIssueDispatchLifecycleOwner(record.issue)) {
+                    await this.#state.clearBabysitterSession(this.#workspaceId, staleKey);
+                }
+            }
+            record.agents.delete(agentName);
+            this.#babysitterCriticalAgents.delete(agentName);
+            this.#increment('supersededBabysittersReleased');
+            this.#logger.info?.('[factory] released babysitter outside the current dispatch routes', {
+                issue: record.issue.key,
+                babysitter: agentName,
+                previousRepo: owned?.repo,
+                previousPrNumber: owned?.number,
+                currentRepos: [...wantedRepos],
+            });
+        }
+        if (unrouted.length > 0) {
+            const latest = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+            if (latest && !await this.#saveDispatchLifecycle(record, latest.phase)) {
+                throw new Error(`Failed to persist unrouted babysitter cleanup for ${record.issue.key}`);
+            }
+        }
+    }
     // The babysitter owns the readiness verdict (CI green + conflicts resolved +
     // review comments addressed) — it sees the per-event PR webhook data in its
     // sandbox, exactly like AgentWorkforce/agents review. It signals readiness by
     // invoking the lifecycle action with `kind: ready`. The orchestrator trusts that signal and only
     // guards on the PR's OWN webhook-fed meta (still open, not a draft, not already
     // merged) before flipping the issue to Human Review. No `gh` call.
-    async #maybeAdvanceToHumanReview(record) {
+    async #maybeAdvanceToHumanReview(record, agentName) {
         if (this.#completionInFlight.has(issueKey(record.issue))) {
             return;
         }
-        if (!this.#babysitterPr.has(issueKey(record.issue))) {
+        const ownership = [...this.#babysitterPr.entries()].find(([key, ref]) => ref.agentName === agentName && issueKey(this.#babysitterIssueRefs.get(key) ?? record.issue) === issueKey(record.issue));
+        if (!ownership) {
             this.#increment('babysitterReadinessGuardBlocked');
             this.#logger.info?.('[factory] babysitter ready signal ignored; PR ownership is no longer active', {
                 issue: record.issue.key,
+                babysitter: agentName,
             });
             return;
         }
-        const snapshot = await this.#readBabysatPrSnapshot(record);
+        const [ownershipKey, ref] = ownership;
+        const snapshot = await this.#readPrSnapshot(ref);
         if (!snapshot) {
             this.#increment('babysitterReadinessGuardBlocked');
             this.#logger.info?.('[factory] babysitter ready signal ignored; authoritative PR meta is unavailable', {
@@ -6848,6 +7625,25 @@ export class FactoryLoop {
             });
             return;
         }
+        this.#babysitterReady.add(ownershipKey);
+        await this.#ensureBabysitterForIssue(record);
+        const owners = [...this.#babysitterIssueRefs.entries()]
+            .filter(([, issue]) => issueKey(issue) === issueKey(record.issue))
+            .map(([key]) => key);
+        const expectedPrOwners = new Set(record.decision.implementers.map((implementer) => implementer.repo)).size;
+        if (owners.length < expectedPrOwners) {
+            this.#increment('babysitterReadinessWaitingForPeers');
+            this.#logger.info?.('[factory] babysitter ready; waiting for remaining repository PRs', {
+                issue: record.issue.key,
+                repo: ref.repo,
+                prNumber: ref.prNumber,
+            });
+            return;
+        }
+        if (owners.length === 0 || owners.some((key) => !this.#babysitterReady.has(key))) {
+            this.#increment('babysitterReadinessWaitingForPeers');
+            return;
+        }
         this.#increment('babysitterReadinessReady');
         this.#logger.info?.('[factory] babysitter signalled PR ready; advancing to human review', {
             issue: record.issue.key,
@@ -6859,7 +7655,8 @@ export class FactoryLoop {
     // exact path captured when the babysitter was spawned; otherwise scans the
     // repo's pulls subtree for the PR number across known layout shapes.
     async #readBabysatPrSnapshot(record) {
-        const ref = this.#babysitterPr.get(issueKey(record.issue));
+        const ref = [...this.#babysitterPr.entries()]
+            .find(([key]) => issueKey(this.#babysitterIssueRefs.get(key) ?? record.issue) === issueKey(record.issue))?.[1];
         if (!ref) {
             return undefined;
         }
@@ -6909,7 +7706,9 @@ export class FactoryLoop {
         if (babysatSnapshot && prMetaShowsMerged(babysatSnapshot)) {
             return true;
         }
-        const pr = this.#babysitterPr.get(issueKey(record.issue)) ?? await this.#completionPrForIssue(issue);
+        const pr = [...this.#babysitterPr.entries()]
+            .find(([key]) => issueKey(this.#babysitterIssueRefs.get(key) ?? record.issue) === issueKey(record.issue))?.[1]
+            ?? await this.#completionPrForIssue(issue);
         if (!pr) {
             return false;
         }
@@ -7045,9 +7844,7 @@ export class FactoryLoop {
             const stateKey = issueStateKey(record.issue);
             this.#probePrGhBackoffUntilMs.delete(stateKey);
             this.#probePrResolvedCache.delete(stateKey);
-            this.#babysitterSpawned.delete(completionKey);
-            this.#babysitterPr.delete(completionKey);
-            await this.#cancelBabysitterWake(completionKey);
+            await this.#cancelBabysittersForIssue(record.issue);
             const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue)).catch(() => undefined);
             if (!this.#usesDurableDispatchLifecycle() || (durable && isTerminalDispatchLifecycle(durable))) {
                 for (const publishedKey of this.#publishedPullRequests.keys()) {
@@ -8944,6 +9741,19 @@ function dispatchSpecs(decision) {
     }
     return [...decision.implementers, decision.reviewer];
 }
+function authoritativeRoutedDecision(triaged, routed) {
+    if (triaged.confidence !== 'low' || triaged.routes.length > 0 || routed.routes.length === 0) {
+        return routed;
+    }
+    return {
+        ...routed,
+        confidence: 'high',
+        rationale: [
+            routed.routes.map((route) => route.rationale).filter(Boolean).join(' '),
+            'Repository identity was resolved authoritatively from the live issue labels or GitHub source repository.',
+        ].filter(Boolean).join(' '),
+    };
+}
 function labelDerivedDispatchDecision(liveIssue, decision, config) {
     const routesByLabel = labelRoutesForIssue(liveIssue, config);
     if (routesByLabel.labels.length === 0) {
@@ -10072,6 +10882,7 @@ const decodeGithubPathSegment = (value) => {
 const validGithubRepo = (repo) => /^[A-Za-z0-9](?:[A-Za-z0-9_.-]{0,99})\/[A-Za-z0-9_.-]{1,100}$/u.test(repo);
 const validPrNumber = (value) => Number.isInteger(value) && value > 0;
 const githubPrIdentity = (repo, prNumber) => validGithubRepo(repo) && validPrNumber(prNumber) ? `${repo.toLowerCase()}#${prNumber}` : undefined;
+const babysitterOwnershipKey = (issue, ref) => `${issueKey(issue)}:${githubPrIdentity(ref.repo, ref.prNumber) ?? 'invalid'}`;
 const recordMatchesGithubRepo = (record, eventRepo, defaultOwner) => {
     if (!validGithubRepo(eventRepo))
         return false;
@@ -10088,7 +10899,7 @@ const recordMatchesGithubRepo = (record, eventRepo, defaultOwner) => {
         }
     });
 };
-const babysitterWakeKey = (issue, ref) => `${issueKey(issue)}:${githubPrIdentity(ref.repo, ref.prNumber) ?? 'invalid'}:${ref.agentName}`;
+const babysitterWakeKey = (issue, ref) => `${babysitterOwnershipKey(issue, ref)}:${ref.agentName}`;
 const BABYSITTER_WAKE_KIND_ORDER = [
     'changes-requested',
     'review-comment',
@@ -10612,7 +11423,32 @@ const durableBabysitterTrackedAgent = (session, capability = 'spawn:claude') =>
     result: { name: session.agentName },
 });
 const isTerminalDispatchLifecycle = (lifecycle) => lifecycle.phase === 'complete' || lifecycle.phase === 'abandoned';
-const lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequest, releaseReason) => ({
+const publishedPullRequests = (lifecycle) => {
+    const receipts = [
+        ...(lifecycle?.pullRequests ?? []).filter(Boolean),
+        ...(lifecycle?.pullRequest ? [lifecycle.pullRequest] : []),
+    ];
+    return [...new Map(receipts.map((receipt) => [
+            `${receipt.repo.toLowerCase()}#${receipt.number}`,
+            { ...receipt },
+        ])).values()];
+};
+const mergePublishedPullRequests = (lifecycle, receipt) => {
+    const receipts = publishedPullRequests(lifecycle);
+    if (receipt)
+        receipts.push(receipt);
+    return [...new Map(receipts.map((candidate) => [
+            candidate.repo.toLowerCase(),
+            { ...candidate },
+        ])).values()];
+};
+const primaryPublishedPullRequest = (previous, receipt, receipts) => {
+    if (receipt &&
+        (!previous?.pullRequest || previous.pullRequest.repo.toLowerCase() === receipt.repo.toLowerCase()))
+        return receipt;
+    return previous?.pullRequest ?? receipt ?? receipts[0];
+};
+const lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequest, pullRequests = [], releaseReason) => ({
     runId,
     issue: { ...record.issue },
     decision: structuredClone(record.decision),
@@ -10621,6 +11457,7 @@ const lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequ
     agents: [...record.agents].map(([name, tracked]) => ({ name, tracked: cloneTrackedAgent(tracked) })),
     invocationIds: [...record.invocationIds],
     result: record.result ? structuredClone(record.result) : undefined,
+    ...(pullRequests.length > 0 ? { pullRequests: pullRequests.map((receipt) => ({ ...receipt })) } : {}),
     ...(pullRequest ? { pullRequest: { ...pullRequest } } : {}),
     ...(releaseReason ? { releaseReason } : {}),
     updatedAtMs,