@agent-relay/factory 0.1.35 → 0.1.37

package/dist/orchestrator/factory.js

@@ -62,6 +62,17 @@ const INJECTION_RETRY_ATTEMPT_TIMEOUT_MS = 15_000;
 const INJECTION_MAX_ATTEMPTS = 6;
 const BABYSITTER_EVENT_COALESCE_MS = 750;
 const BABYSITTER_EVENT_RETRY_MS = 1_000;
+// A babysitter wake fails with a "registration lag" error (agent_not_found /
+// recipient unavailable) both when a freshly spawned agent has not finished
+// enrolling AND when an agent is up but its relay identity never becomes
+// resolvable (e.g. a resumed agent whose relay enrollment silently dropped).
+// The two are indistinguishable per-attempt, so treating every such failure as
+// transient produced an unbounded 1s retry loop that never recovered. Once the
+// same wake has been failing this long, stop the tight loop: back off to a slow
+// cadence and flag the stuck babysitter once for human attention. Genuine
+// startup lag clears well within this window.
+const BABYSITTER_WAKE_UNREACHABLE_ESCALATE_MS = 120_000;
+const BABYSITTER_WAKE_UNREACHABLE_RETRY_MS = 60_000;
 const CLARIFICATION_WAKE_LEASE_MS = 60_000;
 const CLARIFICATION_WAKE_RETRY_MS = 1_000;
 const CLARIFICATION_PARK_RETRY_MS = 5_000;
@@ -108,6 +119,7 @@ export class FactoryLoop {
     #probeCloser;
     #probePrResolver;
     #customProbePrResolver;
+    #hasProbePrGhRunner;
     #probePrGhRunner;
     #logger;
     #clock;
@@ -116,6 +128,8 @@ export class FactoryLoop {
     #kill;
     #readChildPids;
     #terminationGraceMs;
+    #babysitterWakeUnreachableEscalateMs;
+    #babysitterWakeUnreachableRetryMs;
     #state;
     #workspaceId;
     #relayflows;
@@ -132,6 +146,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();
@@ -197,15 +212,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
@@ -252,6 +271,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);
@@ -264,6 +284,8 @@ export class FactoryLoop {
         this.#kill = ports.kill ?? process.kill;
         this.#readChildPids = ports.readChildPids;
         this.#terminationGraceMs = ports.terminationGraceMs;
+        this.#babysitterWakeUnreachableEscalateMs = ports.babysitterWakeUnreachableEscalateMs ?? BABYSITTER_WAKE_UNREACHABLE_ESCALATE_MS;
+        this.#babysitterWakeUnreachableRetryMs = ports.babysitterWakeUnreachableRetryMs ?? BABYSITTER_WAKE_UNREACHABLE_RETRY_MS;
         this.#workspaceId = config.workspaceId ?? 'default';
         this.#relayflows = ports.relayflows;
         this.#worktrees = ports.worktrees;
@@ -444,9 +466,28 @@ 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;
+            await this.#restoreBabysitterOwnership();
+        }
+        catch (error) {
+            this.#startupAgentAdoptionActive = false;
+            if (live)
+                await this.#stopLiveHeartbeat('stopping');
+            throw error;
+        }
         if (opts.mode === 'dispatch-owner') {
             this.#started = true;
             this.#scheduleDispatchLifecycleRenewal();
@@ -458,7 +499,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);
@@ -534,6 +575,7 @@ 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
@@ -552,6 +594,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;
@@ -623,7 +666,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();
@@ -1080,6 +1122,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
@@ -1115,6 +1161,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) {
@@ -1226,6 +1276,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
@@ -1243,6 +1294,7 @@ export class FactoryLoop {
                 });
             }
             for (const { issue } of issueEntries) {
+                await this.#refreshLiveHeartbeatIfDue();
                 if (!issue) {
                     continue;
                 }
@@ -1891,15 +1943,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', {
@@ -1925,10 +1971,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.
@@ -2119,7 +2171,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) {
@@ -2152,12 +2222,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;
@@ -2197,7 +2271,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 })));
@@ -2206,13 +2280,37 @@ export class FactoryLoop {
                 this.#fleet.hydrateTracked(agents);
             }
             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.
+                await this.#drainAgentExitsInFlight(new Set(agents.map((agent) => agent.name)));
+                this.#logger.info?.('[factory] durable startup reconciled exits drained');
+            }
         }
         catch (error) {
             this.#logger.warn?.('[factory] failed to re-adopt durable in-flight agents', { error });
         }
     }
+    async #drainAgentExitsInFlight(names) {
+        for (;;) {
+            const pending = [...this.#agentExitsInFlight]
+                .filter(([name]) => !names || names.has(name))
+                .map(([, handling]) => handling);
+            if (pending.length === 0)
+                return;
+            await Promise.allSettled(pending);
+        }
+    }
     #scheduleDispatchLifecycleRenewal() {
         if (this.#dispatchLifecycleRenewTimer || this.#dispatchLifecycleEpochs.size === 0)
             return;
@@ -2358,7 +2456,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 = previous?.pullRequest ?? pullRequest ?? pullRequests[0];
+        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)
@@ -2516,31 +2616,46 @@ 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,
+                    });
+                }
                 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,
+                });
+            }
+            return;
+        }
+        if (lifecycle.phase === 'published' && !await this.#allImplementersHaveCompletionPr(record)) {
             return;
         }
         if (lifecycle.phase === 'published' || lifecycle.phase === 'writeback-applied') {
@@ -2711,7 +2826,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;
@@ -2781,18 +2896,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 });
                 }
             }
         }
@@ -2874,6 +2991,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,
@@ -2901,6 +3019,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;
             }
@@ -2923,7 +3042,8 @@ export class FactoryLoop {
             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) {
+                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);
@@ -2948,7 +3068,12 @@ export class FactoryLoop {
                     else if (isGithubIssueTreePath(path)) {
                         this.#increment('githubIssuesIgnoredByPathRegex');
                     }
+                    if ((index + 1) % LIVE_EVENT_DRAIN_BATCH_SIZE === 0) {
+                        await this.#refreshLiveHeartbeatIfDue();
+                        await liveEventYield();
+                    }
                 }
+                await this.#refreshLiveHeartbeatIfDue();
             }
             for (const [identity, path] of issuePaths) {
                 this.#githubIssuePreferredPaths.set(identity, path);
@@ -3800,6 +3925,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,
@@ -3807,6 +3939,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
@@ -3815,9 +3949,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') {
@@ -3828,10 +3966,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;
             }
@@ -3858,7 +3996,7 @@ 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, {
@@ -3872,7 +4010,8 @@ export class FactoryLoop {
                 }
                 return;
             }
-            await this.#completeIssue(record);
+            if (await this.#allImplementersHaveCompletionPr(record))
+                await this.#completeIssue(record);
             return;
         }
         const tracked = exiting;
@@ -3880,14 +4019,25 @@ 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) {
                 if (this.#config.babysitter.enabled) {
                     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
@@ -3900,6 +4050,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);
@@ -3911,7 +4063,8 @@ export class FactoryLoop {
                         });
                     }
                     else {
-                        await this.#completeIssue(record);
+                        if (await this.#allImplementersHaveCompletionPr(record))
+                            await this.#completeIssue(record);
                     }
                     return;
                 }
@@ -4030,6 +4183,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');
@@ -4054,8 +4211,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;
@@ -4080,6 +4235,9 @@ 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());
+        if (durableReceipt)
+            return durableReceipt;
         const expectedHeadRef = implementer.spec.branch ?? remoteBranch;
         if (opts.reconcileExisting && expectedHeadRef) {
             const existing = await this.#openPullRequestByHead(repo, expectedHeadRef);
@@ -4124,6 +4282,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;
@@ -4435,12 +4631,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
@@ -4459,6 +4665,15 @@ 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;
@@ -4482,11 +4697,12 @@ export class FactoryLoop {
         record.agents.set(result.name, tracked);
         if (tracked.spec.role === 'babysitter') {
             this.#babysitterCriticalAgents.delete(name);
-            const ref = this.#babysitterPr.get(issueKey(record.issue));
+            const ownership = [...this.#babysitterPr.entries()].find(([, candidate]) => candidate.agentName === name);
+            const [ownershipKey, ref] = ownership ?? [];
             if (ref) {
                 ref.agentName = result.name;
                 for (const [wakeKey, state] of this.#babysitterWakeStates) {
-                    if (issueKey(state.issue) !== issueKey(record.issue))
+                    if (state.agentName !== name)
                         continue;
                     if (state.timer)
                         clearTimeout(state.timer);
@@ -4504,7 +4720,7 @@ export class FactoryLoop {
                     if (state.kinds.size > 0)
                         this.#scheduleBabysitterWake(state, BABYSITTER_EVENT_COALESCE_MS);
                 }
-                await this.#persistBabysitterSession(record.issue, ref, tracked);
+                await this.#persistBabysitterSession(record.issue, ref, tracked, ownershipKey);
             }
         }
         await this.#reportAgent(record, tracked, 'agent.resumed');
@@ -4571,7 +4787,7 @@ export class FactoryLoop {
                 return;
             }
             this.#increment('agentLifecycleReadySignals');
-            await this.#maybeAdvanceToHumanReview(record);
+            await this.#maybeAdvanceToHumanReview(record, signal.name);
             return;
         }
         if (tracked.spec.role === 'babysitter') {
@@ -4671,7 +4887,7 @@ export class FactoryLoop {
                     this.#increment('prReadySignalsIgnoredIssueMismatch');
                     return;
                 }
-                await this.#maybeAdvanceToHumanReview(record);
+                await this.#maybeAdvanceToHumanReview(record, ready.agentName);
                 return;
             }
         }
@@ -5489,13 +5705,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))) {
@@ -5522,14 +5750,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);
@@ -5926,7 +6165,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) {
@@ -5956,7 +6196,9 @@ export class FactoryLoop {
             }
             const record = batch.getIssue(session.issue);
             const tracked = record?.agents.get(session.agentName)
-                ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter')
+                ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter' &&
+                    githubPrIdentity(agent.spec.ownedPullRequest?.repo ?? '', agent.spec.ownedPullRequest?.number ?? 0) ===
+                        githubPrIdentity(session.repo, session.prNumber))
                 ?? durableBabysitterTrackedAgent(session, this.#config.agentCapabilities.babysitter);
             const ref = {
                 repo: session.repo,
@@ -5964,11 +6206,15 @@ export class FactoryLoop {
                 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) {
@@ -5991,12 +6237,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;
@@ -6005,11 +6252,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);
@@ -6071,7 +6326,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;
@@ -6110,13 +6365,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) {
@@ -6162,18 +6420,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,
@@ -6256,6 +6514,8 @@ export class FactoryLoop {
             let targets;
             if (!this.#fleet.waitForInjected) {
                 await this.#fleet.sendMessage(input);
+                state.unreachableSinceMs = undefined;
+                state.unreachableEscalated = false;
                 if (this.#stopping || state.cancelled) {
                     state.deliveringKinds = undefined;
                     return;
@@ -6267,6 +6527,10 @@ export class FactoryLoop {
             }
             else {
                 const ack = await this.#waitForInjectedWithRetry(input);
+                // Delivery confirmed: the target is reachable again, so clear any
+                // registration-lag backoff state accumulated by prior failures.
+                state.unreachableSinceMs = undefined;
+                state.unreachableEscalated = false;
                 targets = ack.targets.length > 0 ? [...new Set(ack.targets)] : [input.to];
             }
             if (this.#stopping || state.cancelled)
@@ -6313,14 +6577,52 @@ export class FactoryLoop {
                 });
             }
             this.#increment('babysitterEventWakeFailures');
-            this.#logger.warn?.('[factory] babysitter event wake failed; preserving it for retry', {
-                issue: state.issue.key,
-                repo: state.repo,
-                prNumber: state.prNumber,
-                babysitter: state.agentName,
-                error: describeError(error).errorMessage,
-            });
-            state.nextDelayMs = BABYSITTER_EVENT_RETRY_MS;
+            const registrationLag = isRegistrationLagInjectionError(error);
+            if (registrationLag) {
+                state.unreachableSinceMs ??= this.#clock.now();
+            }
+            else {
+                // A different failure mode (not "target unreachable") resets the
+                // unreachable window so a later genuine registration lag starts fresh.
+                state.unreachableSinceMs = undefined;
+                state.unreachableEscalated = false;
+            }
+            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.
+                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', {
+                        issue: state.issue.key,
+                        repo: state.repo,
+                        prNumber: state.prNumber,
+                        babysitter: state.agentName,
+                        unreachableMs,
+                        retryDelayMs: this.#babysitterWakeUnreachableRetryMs,
+                        error: describeError(error).errorMessage,
+                    });
+                }
+            }
+            else {
+                state.nextDelayMs = BABYSITTER_EVENT_RETRY_MS;
+                this.#logger.warn?.('[factory] babysitter event wake failed; preserving it for retry', {
+                    issue: state.issue.key,
+                    repo: state.repo,
+                    prNumber: state.prNumber,
+                    babysitter: state.agentName,
+                    error: describeError(error).errorMessage,
+                });
+            }
         }
     }
     async #submitBabysitterWakeTargets(targets) {
@@ -6397,18 +6699,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)
@@ -6417,8 +6718,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', {
@@ -6584,8 +6900,20 @@ 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,
+                    });
+                }
+                return;
+            }
         }
         const issue = await this.#readIssue(record.issue.path);
         if (!issue) {
@@ -6598,7 +6926,7 @@ 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;
@@ -6627,7 +6955,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;
@@ -6661,6 +6991,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 ([...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)
@@ -6763,18 +7099,21 @@ export class FactoryLoop {
     // 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', {
@@ -6791,6 +7130,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,
@@ -6802,7 +7160,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;
         }
@@ -6852,7 +7211,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;
         }
@@ -6988,9 +7349,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()) {
@@ -8887,6 +9246,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) {
@@ -10015,6 +10387,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;
@@ -10031,7 +10404,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',
@@ -10555,7 +10928,26 @@ 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 lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequest, pullRequests = [], releaseReason) => ({
     runId,
     issue: { ...record.issue },
     decision: structuredClone(record.decision),
@@ -10564,6 +10956,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,