@agent-relay/factory 0.1.37 → 0.1.39

package/dist/orchestrator/factory.js

@@ -13,11 +13,15 @@ import { isInFactoryScope } from '../safety/factory-scope.js';
 import { dispatchRelayflowForChangeEvent } from '../dispatch/relayflow-registry.js';
 import { deriveDescriptorsFromMount, prescriptiveInstructions, } from '@agent-relay/integration-prompts';
 import { parseGithubHumanInputRequest, renderAgentTask, } from '../dispatch/templates.js';
+import { resolveTestGuidance } from '../dispatch/test-guidance.js';
 import { HeuristicTriage, TieredTriage, babysitterSpec, isShapeLabel, scopeFromLabels } from '../triage/index.js';
 import { agentNameForRole, sanitizeAgentSlug } from '../triage/agent-names.js';
 import { GhCliGithubWriteback, MountGithubRead, MountLinearWriteback, MountSlackWriteback, slackChannelAliases, slackChannelSegment } from '../writeback/index.js';
+import { parseSlackThreadReply, slackThreadReplyGlob } from '../subscriptions/slack-filter.js';
 import { asRecord, parseJsonContent, stableHash, wrappedPayload } from '../writeback/shared.js';
-import { issueKey } from './batch-tracker.js';
+import { issueKey, } from './batch-tracker.js';
+import { dependencyIdentity, findDependencyCycle, parseBlockedBy, resolveDependency, } from './dependencies.js';
+import { CoalescedTaskQueue } from './coalesced-task-queue.js';
 import { findAgentProcessByName, readProcessIdentity } from './process-identity.js';
 import { readFactoryInFlightRegistry, terminatePids } from './reaper.js';
 import { createFactoryCloudEventV1, factoryCloudReleaseReasonV1, } from '../observability/events.js';
@@ -85,7 +89,11 @@ 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 SLACK_CONVERSATION_TURN_LEASE_MS = 60_000;
+const SLACK_CONVERSATION_TURN_RETRY_MS = 1_000;
+const SLACK_REPLY_ROUTE_RETRY_MS = 1_000;
 const MERGE_GATE_MAX_ATTEMPTS = 12;
 const MERGE_GATE_POLL_DELAY_MS = 10_000;
 const MAX_LABEL_IMPLEMENTERS = 4;
@@ -99,6 +107,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)),
@@ -113,7 +123,9 @@ export class FactoryLoop {
     #fleet;
     #triage;
     #linear;
+    #github;
     #githubWriteback;
+    #githubWritebackProvided;
     #slack;
     #mergeGate;
     #probeCloser;
@@ -130,6 +142,7 @@ export class FactoryLoop {
     #terminationGraceMs;
     #babysitterWakeUnreachableEscalateMs;
     #babysitterWakeUnreachableRetryMs;
+    #startupAgentExitDrainTimeoutMs;
     #state;
     #workspaceId;
     #relayflows;
@@ -143,6 +156,8 @@ export class FactoryLoop {
     #dispatchInFlight = new Map();
     #slackWatchers = new Map();
     #slackWatcherStarts = new Map();
+    #slackConversationTurns;
+    #slackConversationOwner = `${process.pid}:${randomUUID()}`;
     #githubIssueCommentWatchers = new Map();
     #githubIssueCommentWatchStates = new Map();
     #githubIssueCommentQueues = new Map();
@@ -164,6 +179,13 @@ export class FactoryLoop {
     // issue (or the comment writeback's own change event) does not re-post the
     // same notice every cycle. Cleared once the issue dispatches successfully.
     #labelDispatchFailures = new Map();
+    // Provider snapshots loaded during discovery, keyed by collision-safe
+    // owner/repo#number identity. GitHub-native records outrank Linear mirrors.
+    #dependencyIssues = new Map();
+    #terminalDependencyIdentities = new Set();
+    #dependencyParkNotices = new Map();
+    #dependencyGithubPathsByIdentity;
+    #dependencyLinearTreeLoaded = false;
     #pendingSlackClarifications = new Map();
     #pendingGithubClarifications = new Map();
     #clarificationIntents = new Map();
@@ -176,6 +198,7 @@ export class FactoryLoop {
     #dispatchTerminalWaiters = new Map();
     #dispatchLifecycleRetryTimers = new Map();
     #dispatchLifecycleDrives = new Set();
+    #dispatchLifecycleCapacityWaitLogged = new Set();
     #localReleaseCheckpoints = new Map();
     #dispatchLifecycleRenewTimer;
     #clarificationSweepTimer;
@@ -265,9 +288,10 @@ export class FactoryLoop {
         this.#linear = ports.linear ?? MountLinearWriteback(ports.mount, {
             safety: config.safety,
         });
+        this.#githubWritebackProvided = Boolean(ports.githubWriteback);
         this.#githubWriteback = ports.githubWriteback ?? new GhCliGithubWriteback();
         this.#slack = config.slack ? MountSlackWriteback(ports.mount, config.slack) : ports.slack;
-        void (ports.github ?? MountGithubRead(ports.mount));
+        this.#github = ports.github ?? MountGithubRead(ports.mount);
         this.#mergeGate = ports.mergeGate ?? new GithubMergeGate();
         this.#probeCloser = ports.probeCloser ?? closeProbePr;
         this.#customProbePrResolver = Boolean(ports.probePrResolver);
@@ -286,6 +310,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;
@@ -298,6 +323,19 @@ export class FactoryLoop {
             this.#batchView = batch;
             return batch;
         });
+        this.#slackConversationTurns = new CoalescedTaskQueue({
+            delayMs: config.slack?.conversationCoalesceMs ?? 750,
+            run: async (conversationId) => this.#resumeSlackConversationTurn(conversationId),
+            onError: (error, conversationId) => {
+                this.#logger.warn?.('[factory] Slack conversation turn failed', {
+                    conversationId,
+                    error: describeError(error).errorMessage,
+                });
+                if (!this.#stopping) {
+                    this.#slackConversationTurns.schedule(conversationId, SLACK_CONVERSATION_TURN_RETRY_MS);
+                }
+            },
+        });
         this.#wireFleetEvents();
     }
     async #resolveIntegrationInstructions() {
@@ -480,7 +518,12 @@ export class FactoryLoop {
             this.#wireFleetEvents();
             await this.#adoptInFlightAgents(legacyRegistry);
             this.#startupAgentAdoptionActive = false;
-            await this.#restoreBabysitterOwnership();
+            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;
@@ -559,6 +602,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
@@ -581,10 +630,7 @@ export class FactoryLoop {
             // 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;
@@ -612,6 +658,7 @@ export class FactoryLoop {
             this.#offAgentMessage?.();
             this.#offAgentLifecycleSignal?.();
             await Promise.allSettled([...this.#agentLifecycleSignalsInFlight.values()]);
+            await this.#slackConversationTurns.stop();
             this.#offAgentExit = undefined;
             this.#offDeliveryFailed = undefined;
             this.#offAgentMessage = undefined;
@@ -622,6 +669,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
@@ -1248,6 +1303,13 @@ export class FactoryLoop {
         this.#logger.info?.('[factory] run-once started', { dryRun });
         let report;
         try {
+            this.#dependencyIssues.clear();
+            // Terminal observations are only a live-cycle cache. Rebuild them from
+            // current provider snapshots (or merged PR metadata) so a reopened issue
+            // cannot remain permanently resolved after an earlier close event.
+            this.#terminalDependencyIdentities.clear();
+            this.#dependencyGithubPathsByIdentity = undefined;
+            this.#dependencyLinearTreeLoaded = false;
             const issueSource = await this.#issueSource();
             if (issueSource === 'linear') {
                 await this.#ingestGithubIssues({ dryRun });
@@ -1370,7 +1432,12 @@ export class FactoryLoop {
                         continue;
                     }
                     if (result.agents.length === 0 && !dryRun) {
-                        skipped.push({ issue: decision.issue, reason: 'queued or escalated' });
+                        const reason = result.hold?.kind === 'dependency-cycle'
+                            ? `dependency cycle detected: ${result.hold.cycle?.join(' -> ') ?? 'unknown cycle'}`
+                            : result.hold?.kind === 'dependency'
+                                ? `parked on dependencies: ${result.hold.blockers?.join(', ') ?? 'unresolved dependency'}`
+                                : 'queued or escalated';
+                        skipped.push({ issue: decision.issue, reason });
                     }
                     else {
                         dispatched.push(result);
@@ -1709,6 +1776,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) {
@@ -1981,6 +2049,26 @@ export class FactoryLoop {
             this.#recordTriageEscalation(dispatchDecision, escalationReason);
             return replayedResult ?? { issue: dispatchDecision.issue, agents: [], dryRun };
         }
+        const dependencyAdmission = await this.#dependencyAdmission(liveIssue, dispatchDecision);
+        if (dependencyAdmission.blockers.length > 0 || dependencyAdmission.cycle) {
+            batch.queue(dispatchDecision, dryRun, dependencyAdmission);
+            const parked = batch.getParked(dispatchDecision.issue);
+            if (!parked)
+                throw new Error(`dependency admission failed to park ${dispatchDecision.issue.key}`);
+            const comment = await this.#reportDependencyPark(liveIssue, parked, dryRun);
+            return {
+                issue: dispatchDecision.issue,
+                agents: [],
+                comments: [comment],
+                dryRun,
+                hold: {
+                    kind: parked.cycle ? 'dependency-cycle' : 'dependency',
+                    blockers: parked.blockers.map((blocker) => blocker.label),
+                    cycle: parked.cycle ? [...parked.cycle] : undefined,
+                },
+            };
+        }
+        this.#clearDependencyPark(batch, dispatchDecision.issue);
         // 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.
@@ -2008,7 +2096,12 @@ export class FactoryLoop {
                 this.#scheduleDispatchLifecycleRetry(queuedRecord);
                 this.#increment('queued');
                 this.#emit('issue-queued', { issue: dispatchDecision.issue });
-                return lifecycleClaim.lifecycle.result ?? { issue: dispatchDecision.issue, agents: [], dryRun };
+                return lifecycleClaim.lifecycle.result ?? {
+                    issue: dispatchDecision.issue,
+                    agents: [],
+                    dryRun,
+                    hold: { kind: 'capacity' },
+                };
             }
             if (!lifecycleClaim.created) {
                 const restored = batch.restore(inFlightRecordFromLifecycle(lifecycleClaim.lifecycle));
@@ -2019,12 +2112,12 @@ export class FactoryLoop {
         if (!durableDispatch)
             this.#consumePendingDispatchClarifications(dispatchDecision.issue);
         await this.#recordDispatchAttempt(dispatchDecision.issue);
-        const record = batch.start(dispatchDecision, dryRun);
+        const record = batch.start(dispatchDecision, dryRun, dependencyAdmission);
         if (!record) {
             await this.#clearDispatchInFlight(dispatchDecision.issue);
             this.#increment('queued');
             this.#emit('issue-queued', { issue: dispatchDecision.issue });
-            return { issue: dispatchDecision.issue, agents: [], dryRun };
+            return { issue: dispatchDecision.issue, agents: [], dryRun, hold: { kind: 'capacity' } };
         }
         if (record.result) {
             return record.result;
@@ -2152,6 +2245,12 @@ export class FactoryLoop {
         return {
             inFlight: batch?.inFlight.map((record) => record.issue) ?? [],
             queued: batch?.queued.map((queued) => queued.issue) ?? [],
+            parked: batch?.parked.map((parked) => ({
+                issue: parked.issue,
+                blockers: parked.blockers.map((blocker) => blocker.label),
+                cycle: parked.cycle ? [...parked.cycle] : undefined,
+                capacityBlocked: parked.capacityBlocked,
+            })) ?? [],
             counters: { ...this.#counters },
             slackDegraded: this.#slackDegraded,
             slackDegradedReason: this.#slackDegradedReason,
@@ -2279,6 +2378,14 @@ 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) {
                 this.#startupAgentAdoptionActive = false;
@@ -2293,23 +2400,50 @@ export class FactoryLoop {
                 // 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');
+                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) {
-        for (;;) {
-            const pending = [...this.#agentExitsInFlight]
-                .filter(([name]) => !names || names.has(name))
-                .map(([, handling]) => handling);
-            if (pending.length === 0)
-                return;
-            await Promise.allSettled(pending);
+    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)
@@ -2457,7 +2591,7 @@ export class FactoryLoop {
         }
         const previous = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
         const pullRequests = mergePublishedPullRequests(previous, pullRequest);
-        const primaryPullRequest = previous?.pullRequest ?? pullRequest ?? pullRequests[0];
+        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;
@@ -2502,11 +2636,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));
@@ -2563,9 +2713,22 @@ export class FactoryLoop {
             acquiredNow = true;
         }
         if (lifecycle.phase === 'queued') {
+            const liveIssue = await this.#readIssue(lifecycle.issue.path);
+            if (liveIssue) {
+                const dependencyAdmission = await this.#dependencyAdmission(liveIssue, lifecycle.decision);
+                const batch = await this.#batch();
+                if (dependencyAdmission.blockers.length > 0 || dependencyAdmission.cycle) {
+                    batch.queue(lifecycle.decision, lifecycle.dryRun, dependencyAdmission);
+                    const parked = batch.getParked(lifecycle.issue);
+                    if (parked)
+                        await this.#reportDependencyPark(liveIssue, parked, lifecycle.dryRun);
+                    return;
+                }
+                this.#clearDependencyPark(batch, lifecycle.issue);
+            }
             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') {
@@ -2601,6 +2764,8 @@ export class FactoryLoop {
                 })));
                 await this.#fleet.reconcileTrackedAgents?.();
             }
+            if (this.#config.babysitter.enabled)
+                await this.#reconcileRestoredBabysitterReceipts(record);
             return;
         }
         if (lifecycle.phase === 'parking') {
@@ -2637,6 +2802,7 @@ export class FactoryLoop {
                         prNumber: receipt.number,
                         url: receipt.url,
                         headRef: receipt.headRef,
+                        authoritative: true,
                     });
                 }
                 return;
@@ -2651,6 +2817,7 @@ export class FactoryLoop {
                     prNumber: receipt.number,
                     url: receipt.url,
                     headRef: receipt.headRef,
+                    authoritative: true,
                 });
             }
             return;
@@ -2876,6 +3043,9 @@ export class FactoryLoop {
             if (issue && !isGithubIssue(issue)) {
                 await this.#recordCanonicalIssueState(issue);
             }
+            if (issue && this.#dependencyIssueIsTerminal(issue)) {
+                await this.#markDependencyTerminalAndReconcile(issue);
+            }
             if (!issue || !this.#isIssueReady(issue)) {
                 return;
             }
@@ -2904,14 +3074,7 @@ export class FactoryLoop {
                 this.#recordTriageEscalation(escalationDecision, escalationReason);
                 return;
             }
-            if (batch.canStart()) {
-                await this.dispatch(escalationDecision, { dryRun: this.#config.dryRun, labelsValidated: routed.ok });
-            }
-            else {
-                if (batch.queue(escalationDecision, this.#config.dryRun)) {
-                    this.#emit('issue-queued', { issue: escalationDecision.issue });
-                }
-            }
+            await this.dispatch(escalationDecision, { dryRun: this.#config.dryRun, labelsValidated: routed.ok });
         }
         catch (error) {
             if (error instanceof LiveDispatchStateChangedError) {
@@ -3040,40 +3203,55 @@ 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 (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)
+            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');
-                    }
-                    if ((index + 1) % LIVE_EVENT_DRAIN_BATCH_SIZE === 0) {
-                        await this.#refreshLiveHeartbeatIfDue();
-                        await liveEventYield();
-                    }
+                    await this.#refreshLiveHeartbeatIfDue();
                 }
-                await this.#refreshLiveHeartbeatIfDue();
             }
             for (const [identity, path] of issuePaths) {
                 this.#githubIssuePreferredPaths.set(identity, path);
@@ -3088,6 +3266,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;
@@ -3097,13 +3310,17 @@ export class FactoryLoop {
             if (!ghIssue) {
                 return;
             }
+            const closed = githubIssueIsClosed(ghIssue);
+            if (closed) {
+                await this.#markDependencyTerminalAndReconcile(githubIssueAsFactoryIssue(ghIssue));
+            }
             if (await this.#issueSource() === 'github') {
-                if (!githubIssueIsClosed(ghIssue) && githubIssueHasFactoryLabel(ghIssue, this.#config.safety.requireLabel)) {
+                if (!closed && githubIssueHasFactoryLabel(ghIssue, this.#config.safety.requireLabel)) {
                     await this.#handleChange(ghIssue.path);
                 }
                 return;
             }
-            if (githubIssueIsClosed(ghIssue)) {
+            if (closed) {
                 const mirror = await this.#findGithubIssueMirror(ghIssue, opts.candidates);
                 if (mirror && !this.#states.isRole(mirror.stateId, 'done')) {
                     if (!opts.dryRun) {
@@ -3156,7 +3373,9 @@ export class FactoryLoop {
             for (const candidatePath of candidatePaths) {
                 try {
                     const { content } = await this.#readRelayfileFile(candidatePath, 'GitHub issue ingestion');
-                    return parseGithubIssue(candidatePath, content);
+                    const githubIssue = parseGithubIssue(candidatePath, content);
+                    this.#indexDependencyIssue(githubIssueAsFactoryIssue(githubIssue));
+                    return githubIssue;
                 }
                 catch (error) {
                     if (isMissingIssueFileError(error) && candidatePath !== candidatePaths.at(-1)) {
@@ -3245,6 +3464,248 @@ export class FactoryLoop {
         });
         return entry?.[0];
     }
+    #indexDependencyIssue(issue) {
+        if (!issue)
+            return;
+        const repo = dependencyRepoForIssue(issue, undefined, this.#config);
+        const identity = dependencyIdentityForIssue(issue, repo);
+        if (!identity)
+            return;
+        const rank = isGithubIssueFilePath(issue.path) ? 2 : 1;
+        const existing = this.#dependencyIssues.get(identity);
+        if (!existing || rank >= existing.rank) {
+            this.#dependencyIssues.set(identity, { issue, rank });
+            if (this.#dependencyIssueIsTerminal(issue)) {
+                this.#terminalDependencyIdentities.add(identity);
+            }
+            else {
+                this.#terminalDependencyIdentities.delete(identity);
+            }
+        }
+    }
+    async #dependencyAdmission(issue, decision) {
+        const declared = parseBlockedBy(issue.description);
+        if (declared.length === 0)
+            return { blockers: [] };
+        const currentRepo = dependencyRepoForIssue(issue, decision, this.#config);
+        const resolved = declared
+            .map((dependency) => resolveDependency(dependency, currentRepo))
+            .filter((dependency) => Boolean(dependency));
+        await this.#loadMissingDependencyIssues(resolved.map((dependency) => dependency.identity));
+        const resolvedTerminal = new Set();
+        for (const dependency of resolved) {
+            if (await this.#dependencyIsTerminalOrMerged(dependency.identity)) {
+                resolvedTerminal.add(dependency.identity);
+            }
+        }
+        const blockers = resolved
+            .filter((dependency) => !resolvedTerminal.has(dependency.identity))
+            .map((dependency) => {
+            const blocker = this.#dependencyIssues.get(dependency.identity)?.issue;
+            return {
+                identity: dependency.identity,
+                key: blocker ? issueKey(issueRef(blocker)) : dependency.identity,
+                label: dependency.label,
+            };
+        });
+        // A bare #N without a resolvable single repository is itself unresolved.
+        // Keep it visible and fail closed instead of guessing among routes.
+        for (const dependency of declared) {
+            if (dependency.repo || currentRepo)
+                continue;
+            blockers.push({
+                identity: `unresolved:${issueKey(decision.issue)}:${dependency.raw}`,
+                key: `unresolved:${dependency.raw}`,
+                label: `${dependency.raw} (repository unresolved)`,
+            });
+        }
+        const currentIdentity = dependencyIdentityForIssue(issue, currentRepo);
+        const cycle = currentIdentity
+            ? findDependencyCycle(currentIdentity, this.#dependencyGraph())
+            : undefined;
+        return { blockers, cycle };
+    }
+    async #loadMissingDependencyIssues(identities) {
+        const pending = [...new Set(identities)];
+        const expanded = new Set();
+        while (pending.length > 0) {
+            const identity = pending.shift();
+            if (expanded.has(identity))
+                continue;
+            expanded.add(identity);
+            if (!this.#dependencyIssues.has(identity)) {
+                // Startup discovery may use the ready-only GitHub issue index. A
+                // blocker is often closed, in progress, or deliberately unlabeled, so
+                // probe its stable by-id aliases directly before consulting that
+                // filtered discovery set.
+                const separator = identity.lastIndexOf('#');
+                const repoIdentity = identity.slice(0, separator);
+                const number = Number(identity.slice(separator + 1));
+                const configuredRepo = configuredGithubRepoParts(this.#config)
+                    .find(({ owner, repo }) => `${owner}/${repo}`.toLowerCase() === repoIdentity);
+                if (configuredRepo && Number.isSafeInteger(number) && number > 0) {
+                    const { owner, repo } = configuredRepo;
+                    for (const path of [
+                        `${GITHUB_ISSUE_ROOT}/${owner}__${repo}/issues/by-id/${number}.json`,
+                        `${GITHUB_ISSUE_ROOT}/${owner}/${repo}/issues/by-id/${number}.json`,
+                    ]) {
+                        await this.#readIssue(path);
+                        if (this.#dependencyIssues.has(identity))
+                            break;
+                    }
+                }
+            }
+            if (!this.#dependencyIssues.has(identity)) {
+                if (!this.#dependencyGithubPathsByIdentity) {
+                    this.#dependencyGithubPathsByIdentity = new Map();
+                    for (const path of await this.#githubIssuePaths()) {
+                        const parts = githubIssuePathParts(path);
+                        if (parts) {
+                            this.#dependencyGithubPathsByIdentity.set(githubIssueIdentity(parts.owner, parts.repo, parts.number), path);
+                        }
+                    }
+                }
+                const githubPath = this.#dependencyGithubPathsByIdentity.get(identity);
+                if (githubPath)
+                    await this.#readIssue(githubPath);
+            }
+            if (!this.#dependencyIssues.has(identity) && !this.#dependencyLinearTreeLoaded) {
+                // Linear paths do not encode the routed repository identity, so load
+                // the tree once and let #indexDependencyIssue build the composite map.
+                // The pass-scoped flag also lets every later blocked issue reuse the
+                // resulting dependency index instead of rescanning the full tree.
+                this.#dependencyLinearTreeLoaded = true;
+                for (const path of await this.#listRelayfileTree(ISSUE_ROOT, 'dependency blocker discovery')) {
+                    if (isIssueFilePath(path))
+                        await this.#readIssue(path);
+                }
+            }
+            const blocker = this.#dependencyIssues.get(identity)?.issue;
+            if (!blocker)
+                continue;
+            const repo = identity.slice(0, identity.lastIndexOf('#'));
+            for (const dependency of parseBlockedBy(blocker.description)) {
+                const resolved = resolveDependency(dependency, repo);
+                if (resolved && !expanded.has(resolved.identity))
+                    pending.push(resolved.identity);
+            }
+        }
+    }
+    #clearDependencyPark(batch, issue) {
+        batch.clearPark(issue);
+        this.#dependencyParkNotices.delete(issueKey(issue));
+    }
+    #dependencyGraph() {
+        const graph = new Map();
+        for (const [identity, { issue }] of this.#dependencyIssues) {
+            if (this.#dependencyIdentityIsTerminal(identity)) {
+                graph.set(identity, []);
+                continue;
+            }
+            const repo = identity.slice(0, identity.lastIndexOf('#'));
+            const dependencies = parseBlockedBy(issue.description)
+                .map((dependency) => resolveDependency(dependency, repo))
+                .filter((dependency) => Boolean(dependency))
+                .filter((dependency) => !this.#dependencyIdentityIsTerminal(dependency.identity))
+                .map((dependency) => dependency.identity);
+            graph.set(identity, [...new Set(dependencies)]);
+        }
+        return graph;
+    }
+    #dependencyIdentityIsTerminal(identity) {
+        if (this.#terminalDependencyIdentities.has(identity))
+            return true;
+        const issue = this.#dependencyIssues.get(identity)?.issue;
+        return Boolean(issue && this.#dependencyIssueIsTerminal(issue));
+    }
+    async #dependencyIsTerminalOrMerged(identity) {
+        if (this.#dependencyIdentityIsTerminal(identity))
+            return true;
+        const issue = this.#dependencyIssues.get(identity)?.issue;
+        if (!issue)
+            return false;
+        const repo = dependencyRepoForIssue(issue, undefined, this.#config);
+        if (!repo)
+            return false;
+        const pullRequest = await resolveIssuePrFromMount(this.#mount, this.#config, issue, {
+            allowLegacyGithubBranch: true,
+            repo,
+        });
+        if (normalizePrState(pullRequest?.state) !== 'MERGED')
+            return false;
+        this.#terminalDependencyIdentities.add(identity);
+        return true;
+    }
+    #dependencyIssueIsTerminal(issue) {
+        return isGithubIssue(issue)
+            ? githubFactoryIssueIsClosed(issue)
+            : this.#states.isRole(issue.stateId, 'done');
+    }
+    async #reportDependencyPark(issue, parked, dryRun) {
+        const cycle = parked.cycle?.join(' -> ');
+        const blockers = parked.blockers.map((blocker) => blocker.label);
+        const signature = JSON.stringify({ blockers, cycle, capacityBlocked: parked.capacityBlocked });
+        const marker = `<!-- factory-dependency-park:${stableHash(signature)} -->`;
+        const comment = parked.cycle
+            ? [
+                marker,
+                'Factory refused dispatch because it detected a dependency cycle.',
+                `Cycle: ${cycle}`,
+                blockers.length > 0 ? `Unresolved blockers: ${blockers.join(', ')}` : undefined,
+            ].filter((line) => Boolean(line)).join('\n')
+            : [
+                marker,
+                'Factory parked this issue because declared dependencies are unresolved.',
+                `Blocked by: ${blockers.join(', ')}`,
+                parked.capacityBlocked ? 'Capacity is also currently unavailable.' : undefined,
+            ].filter((line) => Boolean(line)).join('\n');
+        const key = issueKey(parked.issue);
+        if (dryRun || this.#dependencyParkNotices.get(key) === signature)
+            return comment;
+        this.#increment(parked.cycle ? 'dependencyCycles' : 'dependencyParks');
+        if (parked.cycle) {
+            this.#error(new Error(`Dependency cycle detected: ${cycle}`), parked.issue);
+        }
+        try {
+            await this.#postIssueComment(issue, comment);
+            this.#dependencyParkNotices.set(key, signature);
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] dependency park writeback skipped', {
+                issue: parked.issue.key,
+                error: describeError(error).errorMessage,
+            });
+        }
+        return comment;
+    }
+    async #markDependencyTerminalAndReconcile(issue) {
+        const repo = dependencyRepoForIssue(issue, undefined, this.#config);
+        const identity = dependencyIdentityForIssue(issue, repo);
+        if (!identity)
+            return;
+        this.#indexDependencyIssue(issue);
+        // A merge event can prove terminality before the issue snapshot reflects
+        // its new state, so apply the explicit observation after indexing it.
+        this.#terminalDependencyIdentities.add(identity);
+        const batch = await this.#batch();
+        this.#clearDependencyPark(batch, issueRef(issue));
+        const candidates = batch.parked.filter((parked) => parked.blockers.some((blocker) => blocker.identity === identity));
+        for (const parked of candidates) {
+            try {
+                const liveIssue = await this.#readIssue(parked.issue.path);
+                if (!liveIssue || !this.#isIssueReady(liveIssue))
+                    continue;
+                await this.dispatch(parked.decision, { dryRun: parked.dryRun });
+            }
+            catch (error) {
+                this.#logger.warn?.('[factory] dependency park reconciliation failed', {
+                    blocker: identity,
+                    issue: parked.issue.key,
+                    error: describeError(error).errorMessage,
+                });
+            }
+        }
+    }
     async #dispatchBlockReason(issue) {
         const key = issueStateKey(issue);
         const state = await this.#state.getDispatchAttempts(this.#workspaceId, key);
@@ -3529,12 +3990,14 @@ export class FactoryLoop {
             // (relayfile-adapters#205). The factory matches state by UUID, so backfill
             // the id from the name when the payload omitted it — otherwise every issue
             // reads as stateId='' and no role (incl. readyForAgent) ever matches.
+            let resolvedIssue = issue;
             if (issue && !issue.stateId && issue.state?.name) {
                 const backfilled = this.#states.idForName(issue.state.name, issue.team);
                 if (backfilled)
-                    return { ...issue, stateId: backfilled };
+                    resolvedIssue = { ...issue, stateId: backfilled };
             }
-            return issue;
+            this.#indexDependencyIssue(resolvedIssue);
+            return resolvedIssue;
         }
         catch (error) {
             if (isMissingIssueFileError(error) && isIssuePathUnderRoot(path)) {
@@ -3976,7 +4439,7 @@ export class FactoryLoop {
             let publishedPr;
             if (exiting?.spec.role === 'implementer' &&
                 !record.dryRun &&
-                (this.#mount.githubWrite || this.#mount.writebackTransport === 'relayfile-cloud')) {
+                this.#shouldAttemptPullRequestPublication()) {
                 try {
                     await this.#saveDispatchLifecycle(record, 'publishing');
                     publishedPr = await this.#publishImplementerPullRequest(record, exiting);
@@ -4003,6 +4466,7 @@ export class FactoryLoop {
                         repo: publishedPr.repo,
                         prNumber: publishedPr.number,
                         url: publishedPr.url,
+                        authoritative: true,
                     });
                 }
                 else {
@@ -4032,8 +4496,42 @@ export class FactoryLoop {
                 });
             }
             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;
                 }
                 if (await this.#allImplementersHaveCompletionPr(record))
@@ -4060,6 +4558,7 @@ export class FactoryLoop {
                             repo: publishedPr.repo,
                             prNumber: publishedPr.number,
                             url: publishedPr.url,
+                            authoritative: true,
                         });
                     }
                     else {
@@ -4175,11 +4674,14 @@ export class FactoryLoop {
     }
     // Publish a PR from the implementer's committed branch when it exited without
     // opening one. Best-effort and idempotent: returns undefined when there is no
-    // GitHub write path, no clone, or nothing publishable (no branch / no commits
-    // ahead of base — `#publishImplementerPullRequest` refuses head==base), so the
-    // caller falls back to its normal restart/conclude handling.
+    // clone or nothing publishable (no branch / no commits ahead of base —
+    // `#publishImplementerPullRequest` refuses head==base), so the caller falls
+    // back to its normal restart/conclude handling. Explicit app identity errors
+    // remain fail-closed and propagate to the lifecycle error path.
     async #tryPublishImplementerPr(record, implementer) {
-        if (record.dryRun || (!implementer.spec.clonePath && !implementer.spec.branch) || !this.#mount.githubWrite) {
+        if (record.dryRun ||
+            (!implementer.spec.clonePath && !implementer.spec.branch) ||
+            !this.#shouldAttemptPullRequestPublication()) {
             return undefined;
         }
         try {
@@ -4199,6 +4701,8 @@ export class FactoryLoop {
             return published;
         }
         catch (error) {
+            if (this.#config.github.identity === 'app' && !this.#mount.githubWrite)
+                throw error;
             this.#increment('exitPrPublishSkipped');
             this.#logger.warn?.('[factory] could not publish implementer PR on exit; falling back', {
                 issue: record.issue.key,
@@ -4214,10 +4718,7 @@ export class FactoryLoop {
         const cached = this.#publishedPullRequests.get(key);
         if (cached)
             return cached;
-        const githubWrite = this.#mount.githubWrite;
-        if (!githubWrite) {
-            throw new Error('GitHub write path not available on this mount — connect GitHub to your workspace');
-        }
+        const { identity, publisher } = this.#githubPullRequestPublisher();
         const remoteBranch = implementer.result?.locality === 'remote' && implementer.spec.branch
             ? implementer.spec.branch
             : undefined;
@@ -4236,9 +4737,10 @@ export class FactoryLoop {
             : 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 (durableReceipt &&
+            (!opts.reconcileExisting || !expectedHeadRef || durableReceipt.headRef === expectedHeadRef))
+            return durableReceipt;
         if (opts.reconcileExisting && expectedHeadRef) {
             const existing = await this.#openPullRequestByHead(repo, expectedHeadRef);
             if (existing) {
@@ -4254,32 +4756,67 @@ export class FactoryLoop {
             }
         }
         const baseRef = await this.#githubDefaultBranch(repo);
-        const result = await githubWrite.publishPullRequest({
+        const result = await publisher.publishPullRequest({
             repo,
             ...(remoteBranch ? { headRef: remoteBranch } : { clonePath: implementer.spec.clonePath }),
             baseRef,
             title: `${issue.key}: ${issue.title}`,
             body: githubPullRequestBody(issue),
         });
-        if (result.repo.toLowerCase() !== repo.toLowerCase() ||
-            result.headRef !== (remoteBranch ?? result.headRef) ||
-            !Number.isInteger(result.number) ||
-            result.number <= 0 ||
-            !result.url) {
+        const published = result.author
+            ? result
+            : { ...result, author: identity };
+        if (published.repo.toLowerCase() !== repo.toLowerCase() ||
+            published.headRef !== (remoteBranch ?? published.headRef) ||
+            !Number.isInteger(published.number) ||
+            published.number <= 0 ||
+            !published.url) {
             throw new Error(`GitHub PR publication returned an unexpected receipt for ${repo}/${remoteBranch ?? 'local HEAD'}`);
         }
         if (remoteBranch && this.#mount.writebackTransport === 'relayfile-cloud') {
-            await this.#confirmPublishedRemotePullRequest(repo, result, remoteBranch);
+            await this.#confirmPublishedRemotePullRequest(repo, published, remoteBranch);
         }
-        this.#publishedPullRequests.set(key, result);
+        this.#publishedPullRequests.set(key, published);
         this.#increment('githubPullRequestsPublished');
-        this.#logger.info?.('[factory] published PR through workspace GitHub connection', {
+        this.#logger.info?.('[factory] published PR', {
             issue: issue.key,
-            repo: result.repo,
-            prNumber: result.number,
-            url: result.url,
+            repo: published.repo,
+            prNumber: published.number,
+            url: published.url,
+            identity,
+            author: published.author,
         });
-        return result;
+        return published;
+    }
+    #githubPullRequestPublisher() {
+        const configured = this.#config.github.identity;
+        if (configured !== 'user' && this.#mount.githubWrite) {
+            return { identity: 'app', publisher: this.#mount.githubWrite };
+        }
+        if (configured === 'app') {
+            throw new Error('GitHub PR identity "app" requires a connected workspace GitHub App write path; refusing to fall back to the local gh user');
+        }
+        const publishPullRequest = this.#githubWriteback.publishPullRequest;
+        if (!publishPullRequest) {
+            throw new Error(`GitHub PR identity "${configured}" requires local gh user publication, but the configured GitHub writeback does not support it`);
+        }
+        return {
+            identity: 'user',
+            publisher: { publishPullRequest: publishPullRequest.bind(this.#githubWriteback) },
+        };
+    }
+    #shouldAttemptPullRequestPublication() {
+        if (this.#config.github.identity !== 'auto')
+            return true;
+        if (this.#mount.githubWrite)
+            return true;
+        // Fake mounts deliberately avoid invoking the host's real gh binary unless
+        // a publisher was injected. Every production mount (cloud or custom) still
+        // gets the configured auto fallback.
+        if (this.#mount.writebackTransport === 'test') {
+            return Boolean(this.#githubWritebackProvided && this.#githubWriteback.publishPullRequest);
+        }
+        return true;
     }
     async #openPullRequestByHead(repo, expectedHeadRef) {
         if (this.#hasProbePrGhRunner) {
@@ -4678,7 +5215,17 @@ export class FactoryLoop {
         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,
@@ -4687,6 +5234,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,
@@ -4695,35 +5248,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 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 (state.agentName !== name)
-                        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, ownershipKey);
             }
+            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 ?? '');
@@ -6083,27 +6757,38 @@ export class FactoryLoop {
         const implementerNames = decision.implementers.map((implementer) => implementer.name);
         const reviewerName = decision.reviewer.name;
         const integrationInstructions = await this.#resolveIntegrationInstructions();
-        const render = (spec) => ({
-            ...spec,
-            task: renderAgentTask({
+        const render = async (spec) => {
+            const route = routeForSpec(decision, spec);
+            const testGuidance = await resolveTestGuidance({
+                repoPath: route.clonePath,
                 issue: templateIssue,
-                route: routeForSpec(decision, spec),
-                role: spec.role,
-                config: { mergePolicy: this.#config.mergePolicy, terminalState: this.#config.terminalState },
-                reviewerName,
-                implementerNames,
-                integrationsMountRoot: this.#integrationsMountRoot(),
-                integrationInstructions,
-                branchName: spec.branch ?? decision.implementers.find((candidate) => candidate.repo === spec.repo)?.branch,
-                branchPrepared: Boolean(spec.baseClonePath && spec.clonePath && spec.baseClonePath !== spec.clonePath),
-                agentName: spec.name,
-                ...(this.#fleet.lifecycleActionName ? { lifecycleActionName: this.#fleet.lifecycleActionName } : {}),
-            }),
-        });
+                route,
+                previewUrl: previewUrlFromSpec(spec),
+            });
+            return {
+                ...spec,
+                task: renderAgentTask({
+                    issue: templateIssue,
+                    route,
+                    role: spec.role,
+                    config: { mergePolicy: this.#config.mergePolicy, terminalState: this.#config.terminalState },
+                    reviewerName,
+                    implementerNames,
+                    integrationsMountRoot: this.#integrationsMountRoot(),
+                    integrationInstructions,
+                    testGuidance,
+                    branchName: spec.branch ?? decision.implementers.find((candidate) => candidate.repo === spec.repo)?.branch,
+                    branchPrepared: Boolean(spec.baseClonePath && spec.clonePath && spec.baseClonePath !== spec.clonePath),
+                    agentName: spec.name,
+                    ...(this.#fleet.lifecycleActionName ? { lifecycleActionName: this.#fleet.lifecycleActionName } : {}),
+                }),
+            };
+        };
+        const rendered = await Promise.all([...decision.implementers, decision.reviewer].map(render));
         return {
             ...decision,
-            implementers: decision.implementers.map(render),
-            reviewer: render(decision.reviewer),
+            implementers: rendered.slice(0, decision.implementers.length),
+            reviewer: rendered[decision.implementers.length],
         };
     }
     #consumePendingDispatchClarifications(issue) {
@@ -6195,11 +6880,15 @@ 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))
+                        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,
@@ -6223,6 +6912,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;
@@ -6516,6 +7273,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;
@@ -6531,6 +7289,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)
@@ -6586,23 +7345,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,
@@ -6612,6 +7371,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;
@@ -6825,6 +7597,7 @@ export class FactoryLoop {
                 await this.#recordCanonicalIssueState({ ...issueRef(issue), stateId: doneStateId });
             }
             this.#emit('writeback-verified', { issue: issueRef(issue), path: issue.path });
+            await this.#markDependencyTerminalAndReconcile(issue);
             this.#increment('mergedPrAdvancedDone');
             this.#increment('done');
             this.#logger.info?.('[factory] merged PR advanced issue to Done', {
@@ -6910,6 +7683,7 @@ export class FactoryLoop {
                         prNumber: receipt.number,
                         url: receipt.url,
                         headRef: receipt.headRef,
+                        authoritative: true,
                     });
                 }
                 return;
@@ -6931,6 +7705,9 @@ export class FactoryLoop {
             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)) {
@@ -6974,6 +7751,7 @@ export class FactoryLoop {
             });
             this.#babysitterSpawned.add(babysitterKey);
             await this.#persistBabysitterSession(record.issue, this.#babysitterPr.get(babysitterKey), tracked);
+            await this.#retargetSlackConversationToBabysitter(record);
             return;
         }
         // Reserve up-front so concurrent PR events in a drain don't double-spawn.
@@ -6991,7 +7769,7 @@ 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))) {
+            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}`,
@@ -7020,9 +7798,19 @@ export class FactoryLoop {
                 .filter((agent) => agent.spec.role === 'implementer')
                 .map((agent) => agent.result?.name ?? agent.spec.name);
             const integrationInstructions = await this.#resolveIntegrationInstructions();
+            const templateIssue = templateIssueFromRecord(record, issue);
+            const prSummary = await this.#github.getPr(prRef.repo, prRef.prNumber).catch(() => undefined);
+            const taskRoute = { ...(route ?? { repo: prRef.repo }), clonePath: spec.clonePath ?? route?.clonePath };
+            const testGuidance = await resolveTestGuidance({
+                repoPath: taskRoute.clonePath,
+                issue: templateIssue,
+                route: taskRoute,
+                changedFiles: prSummary?.filesChanged,
+                previewUrl: previewUrlFromSpec(spec),
+            });
             const task = renderAgentTask({
-                issue: templateIssueFromRecord(record, issue),
-                route: { ...(route ?? { repo: prRef.repo }), clonePath: spec.clonePath },
+                issue: templateIssue,
+                route: taskRoute,
                 role: 'babysitter',
                 config: { mergePolicy: this.#config.mergePolicy, terminalState: this.#config.terminalState },
                 reviewerName,
@@ -7031,6 +7819,7 @@ export class FactoryLoop {
                 slackDispatchThread: await this.#slackDispatchThreadFor(record),
                 integrationsMountRoot: this.#integrationsMountRoot(),
                 integrationInstructions,
+                testGuidance,
                 branchName: spec.branch,
                 branchPrepared: Boolean(spec.baseClonePath && spec.clonePath && spec.baseClonePath !== spec.clonePath),
                 agentName: spec.name,
@@ -7049,6 +7838,7 @@ export class FactoryLoop {
                 agentName: tracked?.result?.name ?? spawned.name,
             });
             await this.#persistBabysitterSession(record.issue, this.#babysitterPr.get(babysitterKey), tracked);
+            await this.#retargetSlackConversationToBabysitter(record);
             await this.#writeInFlightRegistry();
             if (!await this.#saveDispatchLifecycle(record, 'running'))
                 return;
@@ -7093,6 +7883,108 @@ 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
@@ -7286,6 +8178,8 @@ export class FactoryLoop {
                     await this.#recordCanonicalIssueState({ ...record.issue, stateId: targetState });
                 }
                 this.#emit('writeback-verified', { issue: record.issue, path: issue.path });
+                if (!humanReview)
+                    await this.#markDependencyTerminalAndReconcile(issue);
             }
             if (!await this.#saveDispatchLifecycle(record, 'writeback-applied'))
                 return;
@@ -7445,8 +8339,8 @@ export class FactoryLoop {
         });
         this.#emit('error', { error, ...describeError(error), issue });
     }
-    #increment(name) {
-        this.#counters[name] = (this.#counters[name] ?? 0) + 1;
+    #increment(name, amount = 1) {
+        this.#counters[name] = (this.#counters[name] ?? 0) + amount;
     }
     #recordTriageEscalation(decision, reason) {
         this.#increment('triageEscalations');
@@ -7682,7 +8576,11 @@ export class FactoryLoop {
             // the reply watcher instead of returning early, otherwise human replies in
             // the existing thread are watched by nobody and silently dropped.
             if (existingThread) {
-                await this.#rearmSlackWatcher(record, existingThread);
+                const durableConversation = await this.#state.getConversationSession(this.#workspaceId, slackConversationId(existingThread));
+                await this.#ensureSlackConversationSession(record, existingThread);
+                await this.#rearmSlackWatcher(record, existingThread, {
+                    replayConversationReplies: Boolean(durableConversation),
+                });
             }
             return;
         }
@@ -7712,9 +8610,223 @@ export class FactoryLoop {
             ].join('\n'),
         });
         await this.#state.setSlackThread(this.#workspaceId, issueKey(record.issue), root.threadId);
+        await this.#ensureSlackConversationSession(record, root.threadId);
         await this.#watchSlackThread(record, root.threadId);
         this.#recordSlackWritebackSuccess('dispatch-thread');
     }
+    // Once a PR is open, the babysitter is the one driving further conversation
+    // with the human — prefer it over the implementer that originally opened the
+    // Slack thread, matching the pre-conversation-resume routing that sent human
+    // replies to both roles once a PR existed.
+    #slackConversationOwnerCandidate(record) {
+        const candidates = [...record.agents.entries()].map(([name, tracked]) => ({ name, tracked }));
+        return candidates.find(({ tracked }) => tracked.spec.role === 'babysitter' && Boolean(tracked.sessionRef))
+            ?? candidates.find(({ tracked }) => tracked.spec.role === 'implementer' && Boolean(tracked.sessionRef));
+    }
+    async #ensureSlackConversationSession(record, threadId, options = {}) {
+        const conversationId = slackConversationId(threadId);
+        const owned = this.#slackConversationOwnerCandidate(record);
+        const existing = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        if (existing) {
+            const sessionRef = owned?.tracked.sessionRef;
+            const agentName = owned ? (owned.tracked.result?.name ?? owned.name) : undefined;
+            if (owned && sessionRef &&
+                (agentName !== existing.agent.name || (options.forceAgentRebind === true && sessionRef !== existing.agent.sessionRef))) {
+                const rebound = await this.#state.rebindConversationSession(this.#workspaceId, conversationId, {
+                    name: agentName,
+                    sessionRef,
+                    node: owned.tracked.result?.node ?? owned.tracked.spec.node,
+                    capability: owned.tracked.spec.capability,
+                    repo: owned.tracked.spec.repo,
+                    clonePath: owned.tracked.spec.clonePath,
+                });
+                if (rebound)
+                    this.#increment('slackConversationSessionsRebound');
+            }
+            if (existing.pending.length > 0 || existing.delivery) {
+                const waiting = await this.#state.getWaitingClarification(this.#workspaceId, issueKey(existing.issue));
+                if (!waiting)
+                    this.#slackConversationTurns.schedule(conversationId);
+            }
+            return;
+        }
+        const sessionRef = owned?.tracked.sessionRef;
+        if (!owned || !sessionRef) {
+            this.#increment('slackConversationSessionsSkippedMissingSession');
+            return;
+        }
+        const channelDir = await this.#slackChannelDir() ?? this.#config.slack?.channel;
+        if (!channelDir)
+            return;
+        const agentName = owned.tracked.result?.name ?? owned.name;
+        const reserved = await this.#state.reserveConversationSession(this.#workspaceId, conversationId, {
+            provider: 'slack',
+            issue: { ...record.issue },
+            externalId: threadId,
+            context: { channelDir },
+            agent: {
+                name: agentName,
+                sessionRef,
+                node: owned.tracked.result?.node ?? owned.tracked.spec.node,
+                capability: owned.tracked.spec.capability,
+                repo: owned.tracked.spec.repo,
+                clonePath: owned.tracked.spec.clonePath,
+            },
+            history: [],
+            processedMessageIds: [],
+            pending: [],
+        });
+        if (reserved)
+            this.#increment('slackConversationSessionsOwned');
+    }
+    // Called right after a babysitter is spawned/reattached for an issue's PR so
+    // an already-owned Slack conversation session (reserved earlier by the
+    // implementer) retargets onto the babysitter for the next turn, instead of
+    // resuming a session the babysitter has taken over from.
+    async #retargetSlackConversationToBabysitter(record) {
+        if (!this.#slack || !this.#config.slack)
+            return;
+        const threadId = await this.#persistedSlackThread(issueKey(record.issue));
+        if (!threadId)
+            return;
+        await this.#ensureSlackConversationSession(record, threadId, { forceAgentRebind: true });
+    }
+    async #scheduleSlackConversationIfPending(threadId) {
+        const conversationId = slackConversationId(threadId);
+        const session = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        if (session && (session.pending.length > 0 || session.delivery)) {
+            this.#slackConversationTurns.schedule(conversationId);
+        }
+    }
+    async #resumeSlackConversationTurn(conversationId) {
+        if (this.#stopping)
+            return;
+        const claimId = randomUUID();
+        const claimed = await this.#state.claimConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId, this.#clock.now(), SLACK_CONVERSATION_TURN_LEASE_MS);
+        if (!claimed?.delivery) {
+            const current = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+            if (current && (current.pending.length > 0 || current.delivery)) {
+                this.#slackConversationTurns.schedule(conversationId, SLACK_CONVERSATION_TURN_RETRY_MS);
+            }
+            return;
+        }
+        if (!await this.#ownsActiveSlackConversationIssue(claimed.issue)) {
+            await this.#state.releaseConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId);
+            this.#increment('slackConversationTurnsSuppressedStaleOwner');
+            return;
+        }
+        let leaseLost = false;
+        let renewalInFlight = false;
+        const heartbeat = setInterval(() => {
+            if (renewalInFlight || leaseLost || this.#stopping)
+                return;
+            renewalInFlight = true;
+            void this.#state.renewConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId, this.#clock.now()).then((renewed) => { leaseLost = !renewed; })
+                .catch((error) => this.#logger.warn?.('[factory] Slack conversation lease renewal failed', {
+                conversationId,
+                error: describeError(error).errorMessage,
+            }))
+                .finally(() => { renewalInFlight = false; });
+        }, Math.max(1_000, Math.floor(SLACK_CONVERSATION_TURN_LEASE_MS / 3)));
+        heartbeat.unref?.();
+        try {
+            const result = await this.#fleet.resume({
+                name: claimed.agent.name,
+                sessionRef: claimed.agent.sessionRef,
+                node: claimed.agent.node ?? 'self',
+                capability: claimed.agent.capability,
+                repo: claimed.agent.repo,
+                clonePath: claimed.agent.clonePath,
+                task: slackConversationResumeTask(claimed),
+            });
+            const completed = await this.#state.completeConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId, { name: result.name, sessionRef: result.sessionRef });
+            // The token-fenced state mutation is authoritative. A renewal already
+            // queued behind this completion can observe the cleared delivery and set
+            // leaseLost even though completion committed successfully.
+            if (!completed) {
+                this.#increment('slackConversationTurnOwnershipLost');
+                return;
+            }
+            await this.#recordSlackConversationResume(claimed, result);
+            this.#increment('slackConversationTurnsResumed');
+            if (claimed.delivery.messages.length > 1) {
+                this.#increment('slackConversationRepliesCoalesced', claimed.delivery.messages.length - 1);
+            }
+        }
+        catch (error) {
+            try {
+                await this.#state.releaseConversationTurn(this.#workspaceId, conversationId, this.#slackConversationOwner, claimId);
+            }
+            catch (releaseError) {
+                this.#logger.warn?.('[factory] Slack conversation claim release failed; waiting for lease recovery', {
+                    conversationId,
+                    error: describeError(releaseError).errorMessage,
+                });
+            }
+            this.#increment('slackConversationTurnResumeFailures');
+            this.#logger.warn?.('[factory] Slack conversation resume failed; retaining the turn for retry', {
+                issue: claimed.issue.key,
+                threadId: claimed.externalId,
+                sessionRef: claimed.agent.sessionRef,
+                error: describeError(error).errorMessage,
+            });
+            this.#slackConversationTurns.schedule(conversationId, SLACK_CONVERSATION_TURN_RETRY_MS);
+            return;
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+        const remaining = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        if (remaining && (remaining.pending.length > 0 || remaining.delivery)) {
+            this.#slackConversationTurns.schedule(conversationId);
+        }
+    }
+    async #recordSlackConversationResume(session, result) {
+        const record = (await this.#batch()).getIssue(session.issue);
+        if (!record)
+            return;
+        const entry = [...record.agents.entries()].find(([name, tracked]) => name === session.agent.name || tracked.result?.name === session.agent.name);
+        if (!entry)
+            return;
+        const [previousName, tracked] = entry;
+        tracked.result = {
+            ...tracked.result,
+            ...result,
+            node: result.node ?? tracked.result?.node,
+            locality: result.locality ?? tracked.result?.locality,
+        };
+        tracked.sessionRef = result.sessionRef ?? tracked.sessionRef;
+        if (result.name !== previousName) {
+            record.agents.delete(previousName);
+            record.agents.set(result.name, tracked);
+        }
+        try {
+            await this.#writeInFlightRegistry();
+            await this.#saveDispatchLifecycle(record, 'running');
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] Slack conversation resume bookkeeping failed', {
+                issue: session.issue.key,
+                agent: result.name,
+                error: describeError(error).errorMessage,
+            });
+        }
+    }
+    async #ownsActiveSlackConversationIssue(issue) {
+        if (!(await this.#batch()).getIssue(issue))
+            return false;
+        const key = issueKey(issue);
+        const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
+        if (!lifecycle)
+            return true;
+        if (lifecycle.phase === 'releasing' || isTerminalDispatchLifecycle(lifecycle))
+            return false;
+        if (!lifecycle.lease)
+            return false;
+        return lifecycle.lease.owner === this.#dispatchLifecycleOwner &&
+            lifecycle.lease.epoch === this.#dispatchLifecycleEpochs.get(key) &&
+            lifecycle.lease.leaseUntilMs > this.#clock.now();
+    }
     async #escalateTriage(decision, reason, dryRun) {
         if (dryRun) {
             return;
@@ -7999,7 +9111,7 @@ export class FactoryLoop {
         this.#recordSlackWritebackSuccess('triage-escalation');
         return replayedResult;
     }
-    async #watchSlackThread(record, threadId) {
+    async #watchSlackThread(record, threadId, options = {}) {
         if (!this.#config.slack) {
             return;
         }
@@ -8011,12 +9123,14 @@ export class FactoryLoop {
         const messagesPrefix = slackChannelMessagesPrefix(channelDir);
         const preExistingPaths = new Set();
         const preExistingPathOrder = [];
+        const preExistingEvents = [];
         const seenReplies = new Set();
         const seenReplyMessages = new Set();
         let missingIdentityLogged = false;
         let cursor;
         let stopped = false;
         let pollTimer;
+        const routeRetryTimers = new Map();
         const markPreExisting = async () => {
             try {
                 const page = await this.#mount.getEvents({ limit: SLACK_REPLY_EVENTS_LIMIT });
@@ -8026,6 +9140,7 @@ export class FactoryLoop {
                     if (path && path.startsWith(messagesPrefix)) {
                         preExistingPaths.add(path);
                         preExistingPathOrder.push(path);
+                        preExistingEvents.push(event);
                     }
                 }
             }
@@ -8033,7 +9148,8 @@ export class FactoryLoop {
                 this.#logger.warn?.('[factory] unable to seed Slack reply watcher event cursor', error);
             }
         };
-        const handle = async (event) => {
+        const handle = async (event, allowPreExisting = false) => {
+            const routeRetryKey = eventIdentity(event) ?? changeEventPath(event) ?? randomUUID();
             try {
                 // Polling-fallback / degraded-sync events can lack `resource.path`
                 // despite the SDK type. Skip them quietly so one malformed event never
@@ -8049,7 +9165,7 @@ export class FactoryLoop {
                         this.#logger.warn?.('[factory] Slack reply event missing stable identity; falling back to path/content dedupe');
                     }
                 }
-                if (preExistingPaths.has(path)) {
+                if (!allowPreExisting && preExistingPaths.has(path)) {
                     return;
                 }
                 const reply = await this.#readSlackReply(path);
@@ -8066,21 +9182,34 @@ export class FactoryLoop {
                     this.#logger.debug?.('[factory] suppressed duplicate Slack reply payload', { issue: record.issue.key, path });
                     return;
                 }
-                seenReplies.add(replyKey);
                 if (reply.isBot) {
+                    seenReplies.add(replyKey);
+                    seenReplyMessages.add(replyMessageKey);
                     return;
                 }
-                seenReplyMessages.add(replyMessageKey);
                 await this.#routeSlackAnswerToImplementers(record, reply);
+                // Acknowledge in memory only after the durable route succeeds. A read or
+                // state-store failure must remain replayable by the poll/subscription.
+                seenReplies.add(replyKey);
+                seenReplyMessages.add(replyMessageKey);
             }
             catch (error) {
                 this.#logger.error?.('[factory] failed to handle Slack reply event', error);
+                if (!stopped && !routeRetryTimers.has(routeRetryKey)) {
+                    const retryTimer = setTimeout(() => {
+                        routeRetryTimers.delete(routeRetryKey);
+                        if (!stopped)
+                            void handle(event, true);
+                    }, SLACK_REPLY_ROUTE_RETRY_MS);
+                    retryTimer.unref?.();
+                    routeRetryTimers.set(routeRetryKey, retryTimer);
+                }
             }
         };
         await markPreExisting();
         let subscription;
         try {
-            subscription = this.#mount.subscribe([`${messagesPrefix}**`], (event) => {
+            subscription = this.#mount.subscribe([slackThreadReplyGlob(channelDir)], (event) => {
                 // Receipt time is independent of the provider-authored sync timestamp.
                 // A healthy webhook can therefore override a frozen advisory status
                 // without trusting the same field that declared the provider stale.
@@ -8120,9 +9249,16 @@ export class FactoryLoop {
                     clearTimeout(pollTimer);
                     pollTimer = undefined;
                 }
+                for (const retryTimer of routeRetryTimers.values())
+                    clearTimeout(retryTimer);
+                routeRetryTimers.clear();
                 await this.#boundedStopTeardown('Slack reply subscription unsubscribe', () => subscription?.unsubscribe());
             },
         });
+        if (options.replayConversationReplies) {
+            for (const event of preExistingEvents)
+                await handle(event, true);
+        }
         return await this.#replayLatestSlackTriageAnswer(record, threadId, channelDir, preExistingPathOrder);
     }
     async #replayLatestSlackTriageAnswer(record, threadId, channelDir, preExistingPaths) {
@@ -8151,13 +9287,13 @@ export class FactoryLoop {
     // exists (persisted thread id) but has no in-process watcher. #watchSlackThread
     // is itself idempotent on #slackWatchers; the guard here keeps the counter (and
     // the seeding getEvents call) limited to genuine re-arms.
-    async #rearmSlackWatcher(record, threadId) {
+    async #rearmSlackWatcher(record, threadId, options = {}) {
         const key = issueKey(record.issue);
         if (this.#slackWatchers.has(key) || this.#slackWatcherStarts.has(key)) {
             return;
         }
         try {
-            await this.#watchSlackThread(record, threadId);
+            await this.#watchSlackThread(record, threadId, options);
             this.#increment('slackWatchersRearmed');
         }
         catch (error) {
@@ -8172,7 +9308,8 @@ export class FactoryLoop {
         if (!this.#slack || !this.#config.slack) {
             return;
         }
-        for (const record of (await this.#batch()).inFlight) {
+        const batch = await this.#batch();
+        for (const record of batch.inFlight) {
             if (record.dryRun) {
                 continue;
             }
@@ -8191,7 +9328,27 @@ export class FactoryLoop {
             if (!threadId) {
                 continue;
             }
-            await this.#rearmSlackWatcher(record, threadId);
+            const durableConversation = await this.#state.getConversationSession(this.#workspaceId, slackConversationId(threadId));
+            await this.#ensureSlackConversationSession(record, threadId);
+            await this.#rearmSlackWatcher(record, threadId, {
+                replayConversationReplies: Boolean(durableConversation),
+            });
+        }
+        for (const [conversationId, session] of await this.#state.listConversationSessions(this.#workspaceId)) {
+            if (session.provider !== 'slack')
+                continue;
+            const threadId = session.externalId;
+            const record = batch.getIssue(session.issue);
+            const key = issueKey(session.issue);
+            if (record && !record.dryRun && !this.#slackWatchers.has(key) && !this.#slackWatcherStarts.has(key)) {
+                await this.#state.setSlackThread(this.#workspaceId, key, threadId);
+                await this.#ensureSlackConversationSession(record, threadId);
+                await this.#rearmSlackWatcher(record, threadId, { replayConversationReplies: true });
+            }
+            const waiting = await this.#state.getWaitingClarification(this.#workspaceId, key);
+            if (record && !waiting && (session.pending.length > 0 || session.delivery)) {
+                this.#slackConversationTurns.schedule(conversationId);
+            }
         }
         await this.#sweepWaitingClarifications();
         for (const [, waiting] of await this.#state.listWaitingClarifications(this.#workspaceId)) {
@@ -8338,13 +9495,19 @@ export class FactoryLoop {
         const key = issueKey(issue);
         const watcher = this.#slackWatchers.get(key);
         this.#slackWatchers.delete(key);
-        await this.#state.clearSlackThread(this.#workspaceId, key);
+        const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
         await watcher?.stop();
+        if (threadId) {
+            const conversationId = slackConversationId(threadId);
+            await this.#slackConversationTurns.cancel(conversationId);
+            await this.#state.clearConversationSession(this.#workspaceId, conversationId);
+        }
+        await this.#state.clearSlackThread(this.#workspaceId, key);
     }
     async #readSlackReply(path) {
         try {
             const { content } = await this.#mount.readFile(path);
-            return parseSlackReply(path, content, this.#config.slack?.botUserId ?? 'U0B2596R7EZ');
+            return parseSlackThreadReply(path, content, this.#config.slack?.botUserId ?? 'U0B2596R7EZ');
         }
         catch (error) {
             this.#logger.warn?.(`Unable to read Slack reply ${path}`, error);
@@ -8367,20 +9530,61 @@ export class FactoryLoop {
             return;
         }
         if (waiting?.threadId === reply.threadTs) {
+            const replyId = `${reply.threadTs}:${reply.messageTs}`;
             const claimed = await this.#state.claimClarificationReply(this.#workspaceId, clarificationKey, {
-                id: `${reply.threadTs}:${reply.messageTs}`,
+                id: replyId,
                 text,
-                receivedAtMs: this.#clock.now(),
+                receivedAtMs: slackMessageReceivedAtMs(reply.messageTs, this.#clock.now()),
                 source: 'slack',
+                author: reply.author,
             });
             if (!claimed) {
-                this.#increment('clarificationDuplicateWakesSuppressed');
+                const currentWaiting = await this.#state.getWaitingClarification(this.#workspaceId, clarificationKey);
+                if (currentWaiting?.reply?.id === replyId) {
+                    this.#increment('clarificationDuplicateWakesSuppressed');
+                    return;
+                }
+                // The first reply wakes the parked clarification team. Additional
+                // rapid-fire replies are ordinary conversation turns and must not be
+                // discarded merely because the one-shot clarification slot is full.
+                const conversationId = slackConversationId(reply.threadTs);
+                const queued = await this.#state.appendConversationMessage(this.#workspaceId, conversationId, {
+                    id: replyId,
+                    text,
+                    receivedAtMs: slackMessageReceivedAtMs(reply.messageTs, this.#clock.now()),
+                    providerSequence: reply.messageTs,
+                    author: reply.author,
+                });
+                if (queued) {
+                    this.#increment('slackConversationRepliesQueued');
+                }
+                else {
+                    this.#increment('slackConversationDuplicateRepliesSuppressed');
+                }
                 return;
             }
             this.#increment('clarificationRepliesClaimed');
             await this.#wakeWaitingClarification(clarificationKey, claimed);
             return;
         }
+        const conversationId = slackConversationId(reply.threadTs);
+        const conversation = await this.#state.getConversationSession(this.#workspaceId, conversationId);
+        if (conversation && issueKey(conversation.issue) === clarificationKey) {
+            const queued = await this.#state.appendConversationMessage(this.#workspaceId, conversationId, {
+                id: `${reply.threadTs}:${reply.messageTs}`,
+                text,
+                receivedAtMs: slackMessageReceivedAtMs(reply.messageTs, this.#clock.now()),
+                providerSequence: reply.messageTs,
+                author: reply.author,
+            });
+            if (!queued) {
+                this.#increment('slackConversationDuplicateRepliesSuppressed');
+                return;
+            }
+            this.#increment('slackConversationRepliesQueued');
+            this.#slackConversationTurns.schedule(conversationId);
+            return;
+        }
         const liveRecord = (await this.#batch()).getIssue(record.issue);
         if (!liveRecord || liveRecord.dryRun) {
             if (isTriageEscalationWatchRecord(record)) {
@@ -8389,23 +9593,7 @@ export class FactoryLoop {
             this.#increment('slackAnswersIgnoredNoInFlight');
             return;
         }
-        if (!this.#fleet.sendInput) {
-            return;
-        }
-        // Route human replies to the implementers AND the babysitter — once a PR is
-        // open the babysitter is the one chatting with the human about it.
-        const recipients = [...liveRecord.agents.values()]
-            .filter((agent) => agent.spec.role === 'implementer' || agent.spec.role === 'babysitter')
-            .map((agent) => agent.result?.name ?? agent.spec.name)
-            .filter((name) => Boolean(name));
-        if (recipients.length === 0) {
-            this.#increment('slackAnswersIgnoredNoImplementer');
-            return;
-        }
-        for (const recipient of new Set(recipients)) {
-            await this.#injectSlackReplyEvent(recipient, liveRecord.issue, text);
-            this.#increment('slackAnswersInjected');
-        }
+        this.#increment('slackAnswersIgnoredNoConversationSession');
     }
     async #wakeWaitingClarification(key, waiting) {
         const existing = this.#clarificationWakeInFlight.get(key);
@@ -8561,10 +9749,15 @@ export class FactoryLoop {
                 await renewLease();
                 await this.#writeInFlightRegistry();
                 await this.#saveDispatchLifecycle(record, 'running');
+                if (waiting.threadId) {
+                    await this.#ensureSlackConversationSession(record, waiting.threadId, { forceAgentRebind: true });
+                }
                 await renewLease();
                 const completed = await this.#state.completeClarificationWake(this.#workspaceId, key, this.#clarificationWakeOwner);
                 if (!completed)
                     throw new ClarificationWakeLeaseLostError('clarification wake completion lost ownership');
+                if (waiting.threadId)
+                    await this.#scheduleSlackConversationIfPending(waiting.threadId);
                 this.#increment('clarificationTeamsWoken');
                 this.#logger.info?.('[factory] restarted team after human clarification', {
                     issue: waiting.issue.key,
@@ -8804,14 +9997,6 @@ export class FactoryLoop {
             this.#emit('issue-queued', { issue: decision.issue });
         }
     }
-    // Route ordinary Slack conversation into a live agent framed as the
-    // <integration-event> the spawn prompt tells it to expect (not an ambiguous
-    // "Slack reply for ..." keystroke), so the agent recognizes it as the awaited
-    // event. (A broker confirmed-delivery path via waitForInjected is a possible
-    // robustness follow-up.)
-    async #injectSlackReplyEvent(recipient, issue, text) {
-        await this.#fleet.sendInput?.(recipient, slackReplyEvent(issue, text));
-    }
     // Absolute path to the local .integrations mount the daemon manages. The mount
     // is created at the daemon's cwd (see ensureLocalMount), and spawned agents run
     // in their repo clonePath, so writeback paths handed to agents must be absolute
@@ -9211,6 +10396,57 @@ const githubIssueSourceRef = (issue) => {
     }
     return { owner, repo, number: number, url };
 };
+function dependencyRepoForIssue(issue, decision, config) {
+    const source = githubIssueSourceRef(issue);
+    if (source)
+        return `${source.owner}/${source.repo}`;
+    const mirroredRepo = githubMirrorRepoForIssue(issue);
+    if (mirroredRepo)
+        return mirroredRepo;
+    const normalize = (repo) => {
+        if (!repo)
+            return undefined;
+        try {
+            return normalizeGithubRepo(repo, config.repos.org);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const decisionRepos = new Set((decision?.routes ?? [])
+        .map((route) => normalize(route.repo))
+        .filter((repo) => Boolean(repo)));
+    if (decisionRepos.size === 1)
+        return [...decisionRepos][0];
+    if (decisionRepos.size > 1)
+        return undefined;
+    const labels = new Set(issue.labels.map((label) => label.trim().toLowerCase()));
+    const labelRepos = new Set(Object.entries(config.repos.byLabel)
+        .filter(([label]) => labels.has(label.trim().toLowerCase()))
+        .map(([, repo]) => normalize(repo))
+        .filter((repo) => Boolean(repo)));
+    if (labelRepos.size === 1)
+        return [...labelRepos][0];
+    if (labelRepos.size > 1)
+        return undefined;
+    const projectRepo = issue.project
+        ? Object.entries(config.repos.byProject)
+            .find(([project]) => project.trim().toLowerCase() === issue.project.trim().toLowerCase())?.[1]
+        : undefined;
+    return normalize(projectRepo) ?? normalize(config.repos.default);
+}
+function dependencyIdentityForIssue(issue, repo) {
+    const source = githubIssueSourceRef(issue);
+    if (source)
+        return dependencyIdentity(`${source.owner}/${source.repo}`, source.number);
+    const pathParts = githubIssuePathParts(issue.path);
+    if (pathParts)
+        return dependencyIdentity(`${pathParts.owner}/${pathParts.repo}`, pathParts.number);
+    const number = Number(issue.key.match(/(\d+)$/u)?.[1]);
+    return repo && Number.isSafeInteger(number) && number > 0
+        ? dependencyIdentity(repo, number)
+        : undefined;
+}
 const githubIssueAuthor = (issue) => {
     const payload = wrappedPayload(issue.raw);
     const source = asRecord(payload.source);
@@ -9612,10 +10848,14 @@ const routeForSpec = (decision, spec) => {
     const route = decision.routes.find((candidate) => candidate.repo === spec.repo && candidate.clonePath === spec.clonePath) ?? decision.routes.find((candidate) => candidate.repo === spec.repo);
     return {
         repo: spec.repo,
-        clonePath: spec.clonePath,
+        clonePath: spec.clonePath ?? route?.clonePath,
         rationale: route?.rationale,
     };
 };
+const previewUrlFromSpec = (spec) => {
+    const previewUrl = spec.previewUrl;
+    return typeof previewUrl === 'string' && previewUrl.trim() ? previewUrl.trim() : undefined;
+};
 const repoMapFromConfig = (config) => {
     const repos = new Set([
         ...Object.values(config.repos.byLabel),
@@ -9829,7 +11069,7 @@ const linearIssueMirrorsGithubIssue = (issue, ghIssue) => {
 const resolveIssuePrFromMount = async (mount, config, issue, opts = {}) => {
     const candidates = [];
     const listErrors = [];
-    for (const repo of reposFromConfig(config)) {
+    for (const repo of opts.repo ? [opts.repo] : reposFromConfig(config)) {
         const paths = new Set();
         for (const root of githubPullRoots(repo)) {
             try {
@@ -10054,7 +11294,7 @@ const readProbePrCandidate = async (mount, path) => {
                 booleanValue(payload.crossRepository) ??
                 (headRepo && baseRepo ? headRepo.toLowerCase() !== baseRepo.toLowerCase() : undefined),
             draft: booleanValue(payload.isDraft) ?? booleanValue(payload.draft),
-            state: stringValue(payload.state),
+            state: booleanValue(payload.merged) === true ? 'MERGED' : stringValue(payload.state),
             url: stringValue(payload.url) ?? stringValue(payload.html_url),
         };
     }
@@ -10749,8 +11989,12 @@ const defaultRestartPolicy = (spec) =>
 spec.role === 'implementer' || spec.role === 'reviewer' || spec.role === 'babysitter'
     ? { maxRestarts: 0 }
     : spec.restartPolicy;
-const slackPayloadTs = (threadId) => threadId.replace(/_/g, '.');
 const slackChannelMessagesPrefix = (channelDir) => `/slack/channels/${channelDir}/messages/`;
+const slackConversationId = (threadId) => `slack:${threadId}`;
+const slackMessageReceivedAtMs = (messageTs, fallback) => {
+    const seconds = Number(messageTs);
+    return Number.isFinite(seconds) && seconds > 0 ? Math.floor(seconds * 1_000) : fallback;
+};
 const eventIdentity = (event) => {
     const record = event;
     const rawId = record.id ?? record.event_id ?? record.seq;
@@ -10947,6 +12191,12 @@ const mergePublishedPullRequests = (lifecycle, receipt) => {
             { ...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 },
@@ -10974,28 +12224,6 @@ const dispatchResultFromLifecycle = (lifecycle) => lifecycle.result ? structured
     agents: lifecycle.agents.map(({ name, tracked }) => ({ name, role: tracked.spec.role })),
     dryRun: lifecycle.dryRun,
 };
-const parseSlackReply = (path, content, botUserId) => {
-    const raw = asRecord(parseJsonContent(content)) ?? {};
-    const payload = wrappedPayload(raw);
-    const channelDir = path.match(/^\/slack\/channels\/([^/]+)\//u)?.[1] ?? '';
-    const pathMatch = path.match(/^\/slack\/channels\/[^/]+\/messages\/([^/]+)(?:\/replies\/([^/]+))?/u);
-    const parentFromPath = pathMatch?.[2] ? slackPayloadTs(pathMatch[1]) : undefined;
-    const messageFromPath = slackPayloadTs(pathMatch?.[2] ?? pathMatch?.[1] ?? '');
-    const messageTs = stringValue(payload.ts) ?? messageFromPath;
-    const threadTs = stringValue(payload.thread_ts) ?? parentFromPath;
-    if (!channelDir || !threadTs || !messageTs) {
-        return undefined;
-    }
-    return {
-        channelDir,
-        threadTs,
-        messageTs,
-        text: stringValue(payload.text) ?? '',
-        isThreadReply: Boolean(parentFromPath) || threadTs !== messageTs,
-        isBot: isOwnSlackBotReply(payload, botUserId),
-        raw,
-    };
-};
 const triageEscalationReason = (decision) => {
     const reasons = [];
     if (decision.confidence === 'low') {
@@ -11068,11 +12296,6 @@ const issueWithGithubClarification = (issue, text) => ({
         text,
     ].join('\n'),
 });
-const slackAnswerInput = (issue, text) => `Slack reply for ${issue.key}:\n${text}\r`;
-// The human's Slack-thread reply, framed as an <integration-event> the agent is
-// told (at spawn) to expect — a recognizable injected event, not an ambiguous
-// keystroke. Trailing CR submits it to the agent's PTY.
-const slackReplyEvent = (issue, text) => `<integration-event source="slack" issue="${issue.key}">\nHuman reply in the Slack thread:\n${text}\n</integration-event>\r`;
 const clarificationResumeTask = (baseTask, waiting) => {
     const reply = waiting.reply;
     return [
@@ -11084,6 +12307,27 @@ const clarificationResumeTask = (baseTask, waiting) => {
         'Re-hydrate from the issue, branch, worktree, and any open PR, then continue the task. Do not repeat completed work.',
     ].join('\n');
 };
+const slackConversationResumeTask = (session) => {
+    const delivered = session.delivery?.messages ?? [];
+    const renderMessages = (messages) => messages
+        .map((message, index) => `${index + 1}. ${message.author ? `${message.author}: ` : ''}${message.text}`)
+        .join('\n');
+    return [
+        `Continue the existing ${session.issue.key} session for one turn in its Factory-owned Slack thread.`,
+        `Slack channel mount: /slack/channels/${session.context.channelDir ?? 'unknown'}`,
+        `Slack thread timestamp: ${session.externalId}`,
+        'The session history, issue, branch, worktree, and open PR remain authoritative. Re-hydrate current repository state before changing code and do not repeat completed work.',
+        ...(session.history.length > 0
+            ? ['', 'Earlier human messages in this Slack conversation:', renderMessages(session.history.slice(-20))]
+            : []),
+        '',
+        'New human messages coalesced into this turn, in order:',
+        renderMessages(delivered),
+        '',
+        'Address every new message. Reply in the same Slack thread through the connected Slack mount/writeback surface, then continue or report the issue work as appropriate.',
+        'This input was supplied atomically as a fresh resume task. Do not request or depend on live PTY/session injection.',
+    ].join('\n');
+};
 const isFactoryQuestionTarget = (target) => {
     const normalized = target.trim().replace(/^@/u, '').toLowerCase();
     return normalized === 'broker' || normalized === 'factory';
@@ -11179,8 +12423,6 @@ const clarificationStaleSlackText = (waiting, stakeholderUserIds = []) => [
     `Question from ${waiting.askerName}: ${waiting.question} Reply in this thread to wake the saved agent team, or move the issue out of Agent Implementing to cancel the wake.`,
 ].filter((line) => Boolean(line)).join('\n');
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-const isOwnSlackBotReply = (payload, botUserId) => payload.user_is_bot === true ||
-    stringValue(payload.user) === botUserId;
 const unrefDelay = (ms) => new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
     timer.unref?.();