@agent-relay/factory 0.1.27 → 0.1.28

package/dist/orchestrator/factory.js

@@ -45,6 +45,8 @@ const PUBLISHED_PR_CONFIRM_ATTEMPTS = 20;
 const PUBLISHED_PR_CONFIRM_DELAY_MS = 100;
 const SLACK_REPLY_EVENTS_LIMIT = 100;
 const SLACK_REPLY_POLL_INTERVAL_MS = 5_000;
+const SLACK_IDENTITY_MESSAGE_SCAN_LIMIT = 250;
+const SLACK_IDENTITY_READ_BATCH_SIZE = 25;
 const AGENT_QUESTION_DEDUPE_LIMIT = 500;
 const AGENT_NEEDS_INPUT_MARKER = '[factory-needs-input]';
 const LEGACY_AGENT_NEEDS_INPUT_MARKER = 'FACTORY_NEEDS_INPUT';
@@ -131,6 +133,8 @@ export class FactoryLoop {
     #githubIssueCommentQueues = new Map();
     #githubIssueAuthors = new Map();
     #githubIssueAuthorLookups = new Map();
+    #slackReporterUserIds = new Map();
+    #slackReporterUserIdLookups = new Map();
     #reconciledGithubInProgress = new Set();
     #resolvedSlackChannelDir;
     #slackChannelDirRefresh;
@@ -1137,6 +1141,15 @@ export class FactoryLoop {
             titleMarker: FACTORY_E2E_MARKER,
         });
     }
+    async #openPrForIssue(issue) {
+        if (this.#customProbePrResolver) {
+            return this.#probePrResolver(issue);
+        }
+        return this.#resolveIssuePr(issue, {
+            titleMarker: FACTORY_E2E_MARKER,
+            openOnly: true,
+        });
+    }
     async #resolveIssuePr(issue, opts = {}) {
         const issueKey = issueStateKey(issueRef(issue));
         const key = opts.openOnly ? `${issueKey}:open` : issueKey;
@@ -1193,6 +1206,7 @@ export class FactoryLoop {
             const skipped = [];
             let lastReadyReadProgressAtMs = this.#clock.now();
             let readyIssueReads = 0;
+            const issueEntries = [];
             for (const path of paths) {
                 const issue = await this.#readIssue(path);
                 readyIssueReads += 1;
@@ -1202,6 +1216,24 @@ export class FactoryLoop {
                 if (issue && issueSource === 'linear') {
                     await this.#recordCanonicalIssueState(issue);
                 }
+                issueEntries.push({ path, issue });
+            }
+            if (issueSource === 'github') {
+                // New ready work must not sit behind a long sequence of stale
+                // in-progress recoveries. Load the canonical snapshots first, then
+                // prioritize genuinely ready issues over orphan-recovery candidates.
+                // Within either bucket, resume the most recently changed provider work
+                // first so a just-interrupted dispatch does not sit behind an old
+                // numeric backlog of leaked in-progress labels.
+                issueEntries.sort((left, right) => {
+                    const readiness = Number(Boolean(right.issue && this.#isIssueReady(right.issue))) -
+                        Number(Boolean(left.issue && this.#isIssueReady(left.issue)));
+                    if (readiness !== 0)
+                        return readiness;
+                    return githubIssueUpdatedAtMs(right.issue) - githubIssueUpdatedAtMs(left.issue);
+                });
+            }
+            for (const { issue } of issueEntries) {
                 if (!issue) {
                     continue;
                 }
@@ -1263,7 +1295,19 @@ export class FactoryLoop {
                     }
                     const decision = await this.triageIssue(issue);
                     triaged.push(decision);
-                    const result = await this.dispatch(decision, { dryRun });
+                    let result;
+                    try {
+                        result = await this.dispatch(decision, { dryRun });
+                    }
+                    catch (error) {
+                        if (!(error instanceof LiveDispatchStateChangedError))
+                            throw error;
+                        skipped.push({ issue: decision.issue, reason: 'live state changed during dispatch' });
+                        this.#logger.info?.('[factory] skipped issue whose live state changed during dispatch', {
+                            issue: decision.issue.key,
+                        });
+                        continue;
+                    }
                     if (result.agents.length === 0 && !dryRun) {
                         skipped.push({ issue: decision.issue, reason: 'queued or escalated' });
                     }
@@ -1384,9 +1428,9 @@ export class FactoryLoop {
             this.#increment('githubOrphanRecoveriesBlockedProviderStatus');
             return false;
         }
-        let hasOpenPr;
+        let openPr;
         try {
-            hasOpenPr = await this.#hasOpenCompletionPr(issue);
+            openPr = await this.#openCompletionPr(issue);
         }
         catch (error) {
             this.#increment('githubOrphanRecoveryPrProbeFailures');
@@ -1396,10 +1440,27 @@ export class FactoryLoop {
             });
             return false;
         }
-        if (hasOpenPr) {
+        if (openPr) {
+            let adopted = false;
+            try {
+                adopted = await this.#adoptOrphanedGithubPullRequest(issue, openPr);
+            }
+            catch (error) {
+                this.#increment('githubOrphanedPullRequestAdoptionFailures');
+                this.#logger.warn?.('[factory] could not adopt orphaned in-progress GitHub issue at its open PR', {
+                    issue: issue.key,
+                    repo: openPr.repo,
+                    prNumber: openPr.prNumber,
+                    error: describeError(error).errorMessage,
+                });
+            }
             this.#increment('githubOrphanRecoveriesBlockedOpenPr');
-            this.#logger.info?.('[factory] preserved in-progress GitHub issue because a matching open PR exists', {
+            this.#logger.info?.(adopted
+                ? '[factory] adopted orphaned in-progress GitHub issue at its existing PR'
+                : '[factory] preserved in-progress GitHub issue because a matching open PR exists', {
                 issue: issue.key,
+                repo: openPr.repo,
+                prNumber: openPr.prNumber,
             });
             return false;
         }
@@ -1428,15 +1489,100 @@ export class FactoryLoop {
             return false;
         }
     }
-    async #hasOpenCompletionPr(issue) {
+    async #openCompletionPr(issue) {
         if (this.#customProbePrResolver) {
-            return Boolean(await this.#probePrResolver(issue));
+            return await this.#probePrResolver(issue);
         }
-        return Boolean(await this.#resolveIssuePr(issue, {
+        return await this.#resolveIssuePr(issue, {
             titleMarker: FACTORY_E2E_MARKER,
             openOnly: true,
             failOnLookupError: true,
-        }));
+        });
+    }
+    async #adoptOrphanedGithubPullRequest(issue, pr) {
+        if (!this.#config.babysitter.enabled ||
+            pr.draft === true ||
+            !pr.headRef?.startsWith('factory/') ||
+            !factoryBranchMatchesIssue(pr.headRef, issue.key))
+            return false;
+        const triaged = await this.triageIssue(issue);
+        const routed = labelDerivedDispatchDecision(issue, triaged, this.#config);
+        if (!routed.ok)
+            return false;
+        const route = routed.decision.routes.find((candidate) => normalizeGithubRepo(candidate.repo, this.#config.repos.org).toLowerCase() === pr.repo.toLowerCase());
+        if (!route)
+            return false;
+        let decision = routed.decision;
+        if (this.#worktrees && route.clonePath) {
+            const worktreePath = factoryWorktreePath(route.clonePath, issue.key, route.repo, stableHash(`${pr.repo}#${pr.prNumber}:${pr.headRef}`));
+            decision = {
+                ...decision,
+                implementers: decision.implementers.map((spec) => spec.repo === route.repo
+                    ? {
+                        ...spec,
+                        baseClonePath: route.clonePath,
+                        clonePath: worktreePath,
+                        branch: pr.headRef,
+                    }
+                    : spec),
+            };
+        }
+        const durableRemoteAdoption = this.#fleet.placementLocality === 'remote';
+        const publishedPr = {
+            repo: pr.repo,
+            number: pr.prNumber,
+            url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
+            headRef: pr.headRef,
+        };
+        if (durableRemoteAdoption) {
+            const claim = await this.#claimDispatchLifecycle(decision, false, randomUUID(), {
+                phase: 'published',
+                pullRequest: publishedPr,
+            });
+            decision = structuredClone(claim.lifecycle.decision);
+            if (claim.lifecycle.phase === 'queued') {
+                this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(claim.lifecycle));
+                this.#increment('queued');
+                this.#increment('githubOrphanedPullRequestsAdopted');
+                return true;
+            }
+        }
+        const batch = await this.#batch();
+        const record = batch.start(decision, false);
+        if (!record) {
+            if (durableRemoteAdoption) {
+                const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(decision.issue));
+                if (durable) {
+                    this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(durable));
+                    this.#increment('githubOrphanedPullRequestsAdopted');
+                    return true;
+                }
+            }
+            return false;
+        }
+        await this.#ensureBabysitter(record, {
+            repo: pr.repo,
+            prNumber: pr.prNumber,
+            url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
+            path: pr.path,
+            headRef: pr.headRef,
+        });
+        const babysitter = [...record.agents.values()].find((tracked) => tracked.spec.role === 'babysitter');
+        if (!babysitter) {
+            if (durableRemoteAdoption)
+                this.#scheduleDispatchLifecycleRetry(record);
+            else
+                batch.abandon(record.issue);
+            return false;
+        }
+        record.result = {
+            issue: record.issue,
+            agents: [{ name: babysitter.result?.name ?? babysitter.spec.name, role: 'babysitter' }],
+            dryRun: false,
+        };
+        await this.#writeInFlightRegistry();
+        this.#increment('githubOrphanedPullRequestsAdopted');
+        return true;
     }
     async #listRelayfileTree(prefix, phase) {
         return this.#withRelayfileOperation('listTree', { phase, prefix }, () => this.#mount.listTree(prefix), {
@@ -1759,7 +1905,7 @@ export class FactoryLoop {
             if (!dryRun) {
                 const issue = await this.#readIssue(dispatchDecision.issue.path);
                 if (!issue || !this.#isIssueReady(issue)) {
-                    throw new Error(`Live state changed before writeback for ${dispatchDecision.issue.key}`);
+                    throw new LiveDispatchStateChangedError(dispatchDecision.issue.key);
                 }
                 try {
                     await this.#postIssueComment(issue, comment);
@@ -1798,14 +1944,33 @@ export class FactoryLoop {
             // acknowledged spawns, so cleanup never races a name-only survivor.
             const failureHandoffs = this.#dispatchFailureHandoffs(record, spawnedForReaperHandoff);
             await this.#persistDispatchFailureReaperHandoff(record, failureHandoffs);
-            const worktreesTornDown = await this.#teardownFailedDispatchWorktrees(failureHandoffs);
-            await this.#recordDispatchFailure(decision.issue);
-            const failedState = await this.#state.getDispatchAttempts(this.#workspaceId, decision.issue.key);
-            await this.#saveDispatchLifecycle(record, failedState?.terminal ? 'abandoned' : 'retryable');
+            let worktreesTornDown = await this.#teardownFailedDispatchWorktrees(failureHandoffs);
+            const liveStateChanged = error instanceof LiveDispatchStateChangedError;
+            if (liveStateChanged && !failureHandoffs.some((handoff) => handoff.worktree)) {
+                const failed = await this.#releaseAndTerminateAgents(failureHandoffs.map((handoff) => [handoff.name, handoff.tracked]), 'live dispatch state changed', 'completion');
+                if (failed.length === 0) {
+                    for (const handoff of failureHandoffs) {
+                        await this.#state.clearFailureHandoff(this.#workspaceId, registryHandoffKey(handoff.issue, handoff.name));
+                    }
+                    worktreesTornDown = failureHandoffs.length > 0;
+                }
+            }
+            let failedState;
+            if (liveStateChanged) {
+                await this.#clearDispatchInFlight(decision.issue);
+                await this.#saveDispatchLifecycle(record, 'abandoned');
+                this.#increment('dispatchLiveStateRaces');
+            }
+            else {
+                await this.#recordDispatchFailure(decision.issue);
+                failedState = await this.#state.getDispatchAttempts(this.#workspaceId, decision.issue.key);
+                await this.#saveDispatchLifecycle(record, failedState?.terminal ? 'abandoned' : 'retryable');
+            }
             batch.abandon(decision.issue);
-            if (!failedState?.terminal)
+            if (!liveStateChanged && !failedState?.terminal)
                 this.#scheduleDispatchLifecycleRetry(record);
-            this.#error(error, decision.issue);
+            if (!liveStateChanged)
+                this.#error(error, decision.issue);
             // The teardown runs while the record still exists so it can safely
             // derive every shared checkout. Rewrite the registry only after abandon
             // removes those agents from the ordinary in-flight view.
@@ -1950,18 +2115,20 @@ export class FactoryLoop {
             this.#dispatchLifecycleRenewTimer = undefined;
         }
     }
-    async #claimDispatchLifecycle(decision, dryRun, preparedRunId) {
+    async #claimDispatchLifecycle(decision, dryRun, preparedRunId, initial = {}) {
         const key = issueKey(decision.issue);
         const seed = {
             runId: preparedRunId ?? randomUUID(),
             issue: { ...decision.issue },
             decision: structuredClone(decision),
             dryRun,
-            phase: 'dispatching',
+            phase: initial.phase ?? 'dispatching',
             agents: [],
             invocationIds: [],
             updatedAtMs: this.#clock.now(),
         };
+        if (initial.pullRequest)
+            seed.pullRequest = initial.pullRequest;
         if (!preparedRunId)
             seed.decision = decisionWithLifecycleBranches(seed.decision, seed.runId);
         const claim = await this.#state.claimDispatchLifecycle(this.#workspaceId, key, seed, this.#dispatchLifecycleOwner, this.#clock.now(), DISPATCH_LIFECYCLE_LEASE_MS);
@@ -2087,7 +2254,19 @@ export class FactoryLoop {
             if (!promoted || promoted.phase !== 'dispatching') {
                 throw new Error(`durable dispatch ${lifecycle.issue.key} lost its promoted lifecycle`);
             }
-            lifecycle = promoted;
+            if (promoted.pullRequest) {
+                const promotedRecord = inFlightRecordFromLifecycle(promoted);
+                if (!await this.#saveDispatchLifecycle(promotedRecord, 'published', promoted.pullRequest))
+                    return;
+                const published = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
+                if (!published || published.phase !== 'published') {
+                    throw new Error(`durable dispatch ${lifecycle.issue.key} lost its published PR during promotion`);
+                }
+                lifecycle = published;
+            }
+            else {
+                lifecycle = promoted;
+            }
         }
         const batch = await this.#batch();
         const durableRecord = inFlightRecordFromLifecycle(lifecycle);
@@ -2123,7 +2302,7 @@ export class FactoryLoop {
             const implementer = [...record.agents.values()].find((agent) => agent.spec.role === 'implementer');
             if (!implementer)
                 throw new Error(`durable dispatch ${record.issue.key} has no implementer to publish`);
-            const published = await this.#publishImplementerPullRequest(record, implementer);
+            const published = await this.#publishImplementerPullRequest(record, implementer, { reconcileExisting: true });
             if (!published)
                 throw new Error(`durable dispatch ${record.issue.key} did not produce a pull request`);
             if (!await this.#saveDispatchLifecycle(record, 'published', published))
@@ -2342,6 +2521,12 @@ export class FactoryLoop {
             }
         }
         catch (error) {
+            if (error instanceof LiveDispatchStateChangedError) {
+                this.#logger.info?.('[factory] ignored issue event whose live state changed during dispatch', {
+                    issue: error.issueKey,
+                });
+                return;
+            }
             this.#logger.error?.('[factory] failed to handle issue change', error);
         }
     }
@@ -2487,7 +2672,6 @@ export class FactoryLoop {
                     }
                     else if (isGithubIssueTreePath(path)) {
                         this.#increment('githubIssuesIgnoredByPathRegex');
-                        this.#logger.debug?.('[factory] ignored GitHub issue path with unsupported relayfile shape', { path });
                     }
                 }
             }
@@ -3280,7 +3464,9 @@ export class FactoryLoop {
             }
         }
         if (isCompletionReason(reason)) {
-            if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record)) {
+            if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
+                openOnly: this.#config.babysitter.enabled,
+            })) {
                 if (this.#config.babysitter.enabled)
                     await this.#ensureBabysitterForIssue(record);
                 else
@@ -3332,7 +3518,9 @@ export class FactoryLoop {
             return;
         }
         try {
-            if (tracked.spec.role === 'implementer' && await this.#issueHasCompletionPr(record)) {
+            if (tracked.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
+                openOnly: this.#config.babysitter.enabled,
+            })) {
                 if (this.#config.babysitter.enabled) {
                     await this.#ensureBabysitterForIssue(record);
                     return;
@@ -3501,7 +3689,7 @@ export class FactoryLoop {
             return undefined;
         }
     }
-    async #publishImplementerPullRequest(record, implementer) {
+    async #publishImplementerPullRequest(record, implementer, opts = {}) {
         const key = `${issueKey(record.issue)}:${implementer.spec.repo}`;
         const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
         if (durable?.pullRequest)
@@ -3530,6 +3718,21 @@ export class FactoryLoop {
             ? sourceRepoParts.owner
             : undefined;
         const repo = normalizeGithubRepo(implementer.spec.repo, this.#config.repos.org ?? sourceOwner);
+        const expectedHeadRef = implementer.spec.branch ?? remoteBranch;
+        if (opts.reconcileExisting && expectedHeadRef) {
+            const existing = await this.#openPullRequestByHead(repo, expectedHeadRef);
+            if (existing) {
+                this.#publishedPullRequests.set(key, existing);
+                this.#increment('githubPullRequestsReconciled');
+                this.#logger.info?.('[factory] reconciled existing PR from implementer branch', {
+                    issue: issue.key,
+                    repo: existing.repo,
+                    prNumber: existing.number,
+                    url: existing.url,
+                });
+                return existing;
+            }
+        }
         const baseRef = await this.#githubDefaultBranch(repo);
         const result = await githubWrite.publishPullRequest({
             repo,
@@ -3558,6 +3761,52 @@ export class FactoryLoop {
         });
         return result;
     }
+    async #openPullRequestByHead(repo, expectedHeadRef) {
+        const parts = githubRepoParts(repo);
+        if (!parts)
+            return undefined;
+        const roots = [
+            `/github/repos/${encodeURIComponent(parts.owner)}/${encodeURIComponent(parts.repo)}/pulls/`,
+            `/github/repos/${encodeURIComponent(parts.owner)}__${encodeURIComponent(parts.repo)}/pulls/`,
+        ];
+        const candidates = [];
+        for (const root of roots) {
+            let paths;
+            try {
+                paths = await this.#mount.listTree(root);
+            }
+            catch {
+                continue;
+            }
+            for (const path of paths) {
+                const pathParts = githubPullPathParts(path);
+                if (!pathParts ||
+                    pathParts.owner.toLowerCase() !== parts.owner.toLowerCase() ||
+                    pathParts.repo.toLowerCase() !== parts.repo.toLowerCase())
+                    continue;
+                try {
+                    const snapshot = parsePullSnapshot((await this.#mount.readFile(path)).content, pathParts.number);
+                    const state = snapshot?.state?.trim().toUpperCase();
+                    if (!snapshot ||
+                        snapshot.headRef !== expectedHeadRef ||
+                        state !== 'OPEN' ||
+                        snapshot.draft !== false ||
+                        snapshot.merged === true)
+                        continue;
+                    candidates.push({
+                        repo,
+                        number: snapshot.number,
+                        url: snapshot.url ?? `https://github.com/${repo}/pull/${snapshot.number}`,
+                        headRef: expectedHeadRef,
+                    });
+                }
+                catch {
+                    // A partially materialized PR record cannot prove exact ownership.
+                }
+            }
+        }
+        return candidates.sort((a, b) => b.number - a.number)[0];
+    }
     async #prepareAgentWorktree(record, spec) {
         const worktree = this.#agentWorktree(record, spec);
         if (!worktree || !this.#worktrees)
@@ -3762,12 +4011,37 @@ export class FactoryLoop {
     // the release-driven exit event so it cannot re-trigger a resume before the
     // record leaves the batch.
     async #abandonStuckDispatch(record, reason) {
-        const remaining = [...record.agents].filter(([, tracked]) => tracked.spec.role !== 'implementer');
-        for (const [agentName] of remaining) {
+        const agents = [...record.agents];
+        for (const [agentName, tracked] of agents) {
+            if (tracked.spec.role === 'implementer')
+                continue;
             this.#fleet.markAgentTerminal?.(agentName, `implementer-terminal:${reason}`);
         }
-        if (remaining.length > 0) {
-            await this.#releaseAndTerminateAgents(remaining, 'issue-abandoned', 'completion');
+        const worktreeHandoffs = this.#dispatchFailureHandoffs(record, []);
+        let cleanupComplete = true;
+        if (worktreeHandoffs.length > 0) {
+            // A terminal no-PR dispatch no longer owns useful work. Fence and release
+            // every agent sharing the checkout before removing it. If release or
+            // cleanup fails, the durable handoff reaper retains responsibility rather
+            // than leaving an invisible orphan under .factory-worktrees.
+            await this.#persistDispatchFailureReaperHandoff(record, worktreeHandoffs);
+            const worktreeAgentNames = new Set(worktreeHandoffs.map((handoff) => handoff.name));
+            const nonWorktreeAgents = agents.filter(([name]) => !worktreeAgentNames.has(name));
+            if (nonWorktreeAgents.length > 0) {
+                const failed = await this.#releaseAndTerminateAgents(nonWorktreeAgents, 'issue-abandoned', 'completion');
+                cleanupComplete = failed.length === 0;
+            }
+            cleanupComplete = await this.#teardownFailedDispatchWorktrees(worktreeHandoffs) && cleanupComplete;
+        }
+        else if (agents.length > 0) {
+            const failed = await this.#releaseAndTerminateAgents(agents, 'issue-abandoned', 'completion');
+            cleanupComplete = failed.length === 0;
+        }
+        if (!cleanupComplete) {
+            this.#increment('abandonedDispatchReleaseRetries');
+            this.#scheduleAbandonedDispatchRetry(record, reason);
+            await this.#writeInFlightRegistry();
+            return;
         }
         await this.#recordDispatchTerminal(record.issue);
         const next = (await this.#batch()).complete(record.issue);
@@ -3779,7 +4053,24 @@ export class FactoryLoop {
             await this.dispatch(next.decision, { dryRun: next.dryRun });
         }
     }
-    async #issueHasCompletionPr(record) {
+    #scheduleAbandonedDispatchRetry(record, reason) {
+        const key = issueKey(record.issue);
+        if (this.#stopping || this.#dispatchLifecycleRetryTimers.has(key))
+            return;
+        const timer = setTimeout(() => {
+            this.#dispatchLifecycleRetryTimers.delete(key);
+            void this.#abandonStuckDispatch(record, reason).catch((error) => {
+                this.#logger.warn?.('[factory] abandoned dispatch cleanup retry failed', {
+                    issue: record.issue.key,
+                    error: describeError(error).errorMessage,
+                });
+                this.#scheduleAbandonedDispatchRetry(record, reason);
+            });
+        }, DISPATCH_LIFECYCLE_RETRY_MS);
+        timer.unref?.();
+        this.#dispatchLifecycleRetryTimers.set(key, timer);
+    }
+    async #issueHasCompletionPr(record, opts = {}) {
         try {
             const issue = await this.#readIssue(record.issue.path);
             if (!issue) {
@@ -3789,7 +4080,9 @@ export class FactoryLoop {
             // work isn't review-ready, so an implementer exiting with only a draft PR
             // must NOT mark the issue done / release agents — mirror the
             // #sweepPrStateCompletions draft guard, which keeps draft-PR issues in flight.
-            const pr = await this.#completionPrForIssue(issue);
+            const pr = opts.openOnly
+                ? await this.#openPrForIssue(issue)
+                : await this.#completionPrForIssue(issue);
             return Boolean(pr && !pr.draft);
         }
         catch (error) {
@@ -3852,11 +4145,19 @@ export class FactoryLoop {
     }
     async #handleDeliveryFailed(info) {
         const critical = await this.#state.consumeCritical(this.#workspaceId, info.msgId ?? '');
+        if (!critical) {
+            this.#increment('nonCriticalDeliveryFailuresIgnored');
+            return;
+        }
         const record = (await this.#batch()).getIssueByAgent(info.to);
-        const issue = critical?.issue ?? record?.issue;
+        const issue = critical.issue ?? record?.issue;
         const error = new Error(`Critical delivery failed to ${info.to}${info.reason ? `: ${info.reason}` : ''}`);
         this.#error(error, issue);
-        if (critical && this.#fleet.waitForInjected) {
+        if (isTerminalDeliveryFailure(info.reason)) {
+            this.#increment('criticalDeliveryTerminalFailures');
+            return;
+        }
+        if (this.#fleet.waitForInjected) {
             try {
                 const ack = await this.#waitForInjectedAndSubmit(critical.input);
                 await this.#state.recordCritical(this.#workspaceId, ack.eventId, critical);
@@ -4635,6 +4936,14 @@ export class FactoryLoop {
         else {
             watch.issue = { ...record.issue };
             watch.detectAgentQuestions = true;
+            const humanReplyDispatch = record.decision.rationale.includes('Human answered the GitHub triage escalation');
+            if (!triageEscalationReason(record.decision) && !humanReplyDispatch) {
+                const pendingCount = watch.pending.length;
+                watch.pending = watch.pending.filter((pending) => pending.kind !== 'triage');
+                if (watch.pending.length < pendingCount) {
+                    this.#increment('triageEscalationsSupersededByActionableIssue');
+                }
+            }
         }
         if (this.#githubIssueCommentWatchers.has(key)) {
             const normalizedWatch = normalizeGithubIssueCommentWatch(watch);
@@ -5076,7 +5385,7 @@ export class FactoryLoop {
             return false;
         }
         this.#pendingGithubClarifications.set(issueKey(decision.issue), text);
-        const result = await this.#startOrQueueGithubClarifiedDecision(decision);
+        const result = await this.#startOrQueueGithubClarifiedDecision(dispatchAfterGithubClarification(decision, 'human clarification resolved triage'));
         this.#increment('githubTriageAnswersDispatched');
         return Boolean(result) || (await this.#batch()).isQueued(decision.issue);
     }
@@ -5211,6 +5520,23 @@ export class FactoryLoop {
                 this.#increment('babysitterOwnershipRestoreSkippedNonOwner');
                 continue;
             }
+            const snapshot = await this.#readPrSnapshot(session);
+            const guard = snapshot ? prMetaAllowsHumanReview(snapshot) : undefined;
+            if (!snapshot || !guard?.ok || prSnapshotIssueMatchScore(snapshot, session.issue.key) < 30) {
+                await this.#state.clearBabysitterSession(this.#workspaceId, persistedKey);
+                this.#increment('babysitterOwnershipRestoreStale');
+                this.#logger.warn?.('[factory] discarded stale babysitter ownership during restore', {
+                    issue: session.issue.key,
+                    repo: session.repo,
+                    prNumber: session.prNumber,
+                    reason: !snapshot
+                        ? 'authoritative PR meta is unavailable'
+                        : !guard?.ok
+                            ? guard?.reason
+                            : 'PR branch does not identify the issue',
+                });
+                continue;
+            }
             const record = batch.getIssue(session.issue);
             const tracked = record?.agents.get(session.agentName)
                 ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter')
@@ -5844,7 +6170,7 @@ export class FactoryLoop {
         if (!issue) {
             return;
         }
-        const pr = await this.#completionPrForIssue(issue);
+        const pr = await this.#openPrForIssue(issue);
         if (!pr || pr.draft) {
             return;
         }
@@ -5916,8 +6242,10 @@ export class FactoryLoop {
             const initialSpec = babysitterSpec(issue, this.#config, route);
             const sharedCheckout = [...record.agents.values()]
                 .map((agent) => agent.spec)
-                .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath);
-            const implementerBranch = record.decision.implementers
+                .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath)
+                ?? record.decision.implementers
+                    .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath);
+            const implementerBranch = prRef.headRef ?? record.decision.implementers
                 .find((candidate) => candidate.repo === initialSpec.repo && candidate.branch)?.branch;
             const spec = sharedCheckout
                 ? {
@@ -6050,7 +6378,11 @@ export class FactoryLoop {
         if (!ref) {
             return undefined;
         }
-        const candidatePaths = ref.path ? [ref.path] : await this.#pullMetaPathsFor(ref.repo, ref.prNumber);
+        return await this.#readPrSnapshot(ref);
+    }
+    async #readPrSnapshot(ref) {
+        const discoveredPaths = await this.#pullMetaPathsFor(ref.repo, ref.prNumber);
+        const candidatePaths = [...new Set([ref.path, ...discoveredPaths].filter((path) => Boolean(path)))];
         for (const path of candidatePaths) {
             try {
                 const snapshot = parsePullSnapshot((await this.#mount.readFile(path)).content, ref.prNumber);
@@ -6599,9 +6931,9 @@ export class FactoryLoop {
         }
     }
     async #escalateTriageToGithub(decision, reason) {
-        const question = triageEscalationQuestion(decision);
-        const correlationId = githubEscalationCorrelationId('triage', decision.issue, question);
         const issue = await this.#readIssue(decision.issue.path);
+        const question = triageEscalationQuestion(decision, issue);
+        const correlationId = githubEscalationCorrelationId('triage', decision.issue, question);
         const source = issue ? githubIssueSourceRef(issue) : undefined;
         const authorizedAuthor = issue ? await this.#resolveGithubIssueAuthor(issue) : undefined;
         if (!issue || !source || !authorizedAuthor) {
@@ -6679,7 +7011,11 @@ export class FactoryLoop {
         const source = githubIssueSourceRef(issue);
         const stakeholderMentions = slackMentions(this.#config.slack.stakeholderUserIds);
         const reporter = await this.#resolveGithubIssueAuthor(issue);
-        const audience = [stakeholderMentions, reporter ? `GitHub reporter: @${reporter}.` : undefined]
+        const reporterSlackUserId = reporter ? await this.#resolveSlackUserIdForGithubReporter(reporter) : undefined;
+        const reporterAudience = reporter
+            ? `GitHub reporter: ${reporterSlackUserId ? `<@${reporterSlackUserId}>` : `${reporter} (GitHub)`}.`
+            : undefined;
+        const audience = [stakeholderMentions, reporterAudience]
             .filter((part) => Boolean(part))
             .join(' ');
         const replyInstruction = source?.url
@@ -6690,7 +7026,7 @@ export class FactoryLoop {
             text: [
                 `${audience ? `${audience} ` : ''}${decision.issue.key}: factory triage escalation for ${issue.title}`,
                 `Reason: ${reason}`,
-                `Question: ${triageEscalationQuestion(decision)} ${replyInstruction}`,
+                `Question: ${triageEscalationQuestion(decision, issue)} ${replyInstruction}`,
             ].join('\n'),
         });
         await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId);
@@ -6737,6 +7073,75 @@ export class FactoryLoop {
         this.#githubIssueAuthorLookups.set(key, pending);
         return pending;
     }
+    async #resolveSlackUserIdForGithubReporter(reporter) {
+        const identity = normalizedCrossProviderIdentity(reporter);
+        if (!identity)
+            return undefined;
+        if (this.#slackReporterUserIds.has(identity)) {
+            return this.#slackReporterUserIds.get(identity);
+        }
+        const existing = this.#slackReporterUserIdLookups.get(identity);
+        if (existing)
+            return existing;
+        const pending = this.#findSlackUserIdByIdentity(identity)
+            .then((userId) => {
+            this.#slackReporterUserIds.set(identity, userId);
+            if (userId)
+                this.#increment('slackReporterIdentitiesResolved');
+            return userId;
+        })
+            .catch(() => {
+            this.#slackReporterUserIds.set(identity, undefined);
+            this.#increment('slackReporterIdentityLookupFailures');
+            return undefined;
+        })
+            .finally(() => {
+            this.#slackReporterUserIdLookups.delete(identity);
+        });
+        this.#slackReporterUserIdLookups.set(identity, pending);
+        return pending;
+    }
+    async #findSlackUserIdByIdentity(identity) {
+        const list = async (prefix) => {
+            try {
+                return await this.#mount.listTree(prefix);
+            }
+            catch {
+                return [];
+            }
+        };
+        const [userPaths, channelPaths] = await Promise.all([
+            list('/slack/users'),
+            list('/slack/channels'),
+        ]);
+        const candidates = [
+            ...userPaths.filter(isSlackIdentityRecordPath),
+            ...channelPaths
+                .filter(isSlackIdentityRecordPath)
+                .sort((left, right) => slackIdentityPathTimestamp(right) - slackIdentityPathTimestamp(left))
+                .slice(0, SLACK_IDENTITY_MESSAGE_SCAN_LIMIT),
+        ];
+        const matches = new Set();
+        for (let offset = 0; offset < candidates.length; offset += SLACK_IDENTITY_READ_BATCH_SIZE) {
+            const batch = candidates.slice(offset, offset + SLACK_IDENTITY_READ_BATCH_SIZE);
+            const records = await Promise.all(batch.map(async (path) => {
+                try {
+                    return wrappedPayload((await this.#mount.readFile(path)).content);
+                }
+                catch {
+                    return undefined;
+                }
+            }));
+            for (const payload of records) {
+                const userId = payload ? slackUserIdMatchingIdentity(payload, identity) : undefined;
+                if (userId)
+                    matches.add(userId);
+                if (matches.size > 1)
+                    return undefined;
+            }
+        }
+        return matches.size === 1 ? [...matches][0] : undefined;
+    }
     async #postAndWatchSlackEscalationThread(decision, reason) {
         if (!this.#slack || !this.#config.slack) {
             return;
@@ -6748,7 +7153,7 @@ export class FactoryLoop {
             text: [
                 `${stakeholderMentions ? `${stakeholderMentions} ` : ''}${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
                 `Reason: ${reason}`,
-                `Question: ${triageEscalationQuestion(decision)}`,
+                `Question: ${triageEscalationQuestion(decision, issue)}`,
             ].join('\n'),
         });
         await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId);
@@ -7887,6 +8292,16 @@ const githubIssueAsFactoryIssue = (issue) => {
         },
     };
 };
+const githubIssueUpdatedAtMs = (issue) => {
+    if (!issue || !isGithubIssue(issue))
+        return 0;
+    const payload = wrappedPayload(issue.raw);
+    const updatedAt = stringValue(payload.updated_at) ?? stringValue(payload.updatedAt);
+    if (!updatedAt)
+        return 0;
+    const parsed = Date.parse(updatedAt);
+    return Number.isFinite(parsed) ? parsed : 0;
+};
 export async function readFactoryLoopHeartbeat(path = DEFAULT_FACTORY_LOOP_HEARTBEAT_PATH) {
     try {
         return parseJsonContent(await readFile(path, 'utf8'));
@@ -8144,19 +8559,29 @@ function githubUrlCandidates(value) {
     return [...candidates];
 }
 function labelRoutesForIssue(issue, config) {
-    const githubReadinessLabel = isGithubIssue(issue) ? config.safety.requireLabel.trim().toLowerCase() : undefined;
-    const labels = uniqueNormalizedLabels(issue.labels).filter((label) => !isShapeLabel(label) &&
+    const githubIssue = isGithubIssue(issue);
+    const githubReadinessLabel = githubIssue ? config.safety.requireLabel.trim().toLowerCase() : undefined;
+    const candidateLabels = uniqueNormalizedLabels(issue.labels).filter((label) => !isShapeLabel(label) &&
         label.toLowerCase() !== githubReadinessLabel &&
-        (!isGithubIssue(issue) || !GITHUB_LIFECYCLE_LABELS.has(label.toLowerCase())));
+        (!githubIssue || !GITHUB_LIFECYCLE_LABELS.has(label.toLowerCase())));
+    const labels = [];
     const routes = [];
     const offendingLabels = [];
     const seenRepos = new Set();
-    for (const label of labels) {
+    for (const label of candidateLabels) {
         const entry = findLabelRoute(config.repos.byLabel, label);
         if (!entry) {
-            offendingLabels.push(label);
+            // GitHub repositories commonly carry metadata labels such as `bug` and
+            // `enhancement`; only explicitly configured repo labels participate in
+            // routing. Linear labels remain authoritative and therefore fail closed
+            // when unmapped.
+            if (!githubIssue) {
+                labels.push(label);
+                offendingLabels.push(label);
+            }
             continue;
         }
+        labels.push(label);
         const repo = entry.repo;
         if (seenRepos.has(repo)) {
             continue;
@@ -8558,7 +8983,15 @@ const resolveIssuePrFromMount = async (mount, config, issue, opts = {}) => {
                 : 0;
             if (!pr || score <= 0)
                 continue;
-            candidates.push({ repo, prNumber: pr.number, draft: pr.draft, score });
+            candidates.push({
+                repo,
+                prNumber: pr.number,
+                draft: pr.draft,
+                headRef: pr.headRef,
+                url: pr.url,
+                path,
+                score,
+            });
         }
     }
     return candidates.sort((a, b) => b.score - a.score || b.prNumber - a.prNumber)[0];
@@ -8577,7 +9010,7 @@ const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
                 '--state',
                 'all',
                 '--json',
-                'number,title,body,headRefName,isDraft,state',
+                'number,title,body,headRefName,isDraft,state,url',
                 '--limit',
                 String(PROBE_PR_GH_CANDIDATE_LIMIT),
             ]);
@@ -8605,7 +9038,7 @@ const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
         }
         for (const entry of payload) {
             const pr = ghProbePrCandidate(entry);
-            if (!pr || !containsIssueKey(pr.headRef, issue.key))
+            if (!pr || !factoryBranchMatchesIssue(pr.headRef, issue.key))
                 continue;
             if (opts.openOnly && normalizePrState(pr.state) !== 'OPEN')
                 continue;
@@ -8616,6 +9049,8 @@ const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
                 repo,
                 prNumber: pr.number,
                 draft: pr.draft,
+                headRef: pr.headRef,
+                url: pr.url,
                 score,
                 open: normalizePrState(pr.state) === 'OPEN',
             });
@@ -8723,6 +9158,7 @@ const readProbePrCandidate = async (mount, path) => {
             headRef: refName(payload.headRef) ?? refName(payload.head) ?? stringValue(payload.head_ref) ?? '',
             draft: booleanValue(payload.isDraft) ?? booleanValue(payload.draft),
             state: stringValue(payload.state),
+            url: stringValue(payload.url) ?? stringValue(payload.html_url),
         };
     }
     catch {
@@ -8743,12 +9179,13 @@ const ghProbePrCandidate = (value) => {
         headRef: stringValue(payload.headRefName) ?? '',
         draft: booleanValue(payload.isDraft),
         state: stringValue(payload.state),
+        url: stringValue(payload.url),
     };
 };
 const issuePrMatchScore = (pr, issue, marker, opts = {}) => {
     if (opts.requireTitleMarker && !hasTitlePrefix(pr.title, marker))
         return 0;
-    if (containsIssueKey(pr.headRef, issue.key))
+    if (factoryBranchMatchesIssue(pr.headRef, issue.key))
         return 30;
     if (containsIssueKey(pr.title, issue.key))
         return 20;
@@ -8757,6 +9194,10 @@ const issuePrMatchScore = (pr, issue, marker, opts = {}) => {
     return 0;
 };
 const hasTitlePrefix = (title, marker) => title === marker || title.startsWith(`${marker} `);
+const factoryBranchMatchesIssue = (headRef, issueKey) => /^\d+$/u.test(issueKey)
+    ? headRef.toLowerCase() === `factory/${issueKey.toLowerCase()}` ||
+        headRef.toLowerCase().startsWith(`factory/${issueKey.toLowerCase()}-`)
+    : containsIssueKey(headRef, issueKey);
 const normalizePrState = (state) => state?.toUpperCase();
 const failClosedGhRunner = async () => ({ stdout: '[]' });
 const ISSUE_KEY_PATTERN = /^[A-Z]+-\d+$/u;
@@ -9071,7 +9512,7 @@ const babysitterCriticalIssueMatches = (signalKey, issue) => {
         Number(match[3]) === parts.number;
 };
 const prSnapshotIssueMatchScore = (snapshot, issueKey) => {
-    if (containsIssueKey(snapshot.headRef ?? '', issueKey))
+    if (factoryBranchMatchesIssue(snapshot.headRef ?? '', issueKey))
         return 30;
     if (containsIssueKey(snapshot.title ?? '', issueKey))
         return 20;
@@ -9153,7 +9594,7 @@ const isAllowedFactoryDraft = async (path, content, opts, mount, config) => {
     }
     return false;
 };
-const isFactoryGithubWritebackPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/refs%2Fheads%2F[^/]+\.json|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
+const isFactoryGithubWritebackPath = (path) => /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path);
 const isIssuePathInFactoryScope = async (mount, path, config) => {
     try {
         return isInFactoryScope(parseLinearIssue(path, (await mount.readFile(path)).content), config.safety);
@@ -9540,25 +9981,27 @@ const triageEscalationReason = (decision) => {
     }
     return `${reasons.join(' and ')}${decision.rationale ? `: ${decision.rationale}` : ''}`;
 };
-const triageEscalationQuestion = (decision) => {
+class LiveDispatchStateChangedError extends Error {
+    issueKey;
+    constructor(issueKey) {
+        super(`Live state changed before writeback for ${issueKey}`);
+        this.name = 'LiveDispatchStateChangedError';
+        this.issueKey = issueKey;
+    }
+}
+const triageEscalationQuestion = (decision, issue) => {
     const routedRepos = decision.routes.map((route) => route.repo).filter(Boolean);
+    const subject = issue?.title?.trim() || decision.issue.key;
+    const details = `For "${subject}", please reply with: (1) the exact user flow—where it starts, required inputs/actions, and the successful result; (2) permissions, validation, failure behavior, important edge cases, and anything out of scope; and (3) observable acceptance checks or tests. Say "use reasonable product defaults" for anything Factory may decide. After an authorized GitHub reply, Factory will dispatch agents; successful work will be opened as a pull request.`;
     if (routedRepos.length === 0) {
-        return [
-            'Which repository or repositories should handle this issue?',
-            'Please include the intended approach and the acceptance criteria/tests the agent should satisfy.',
-        ].join(' ');
+        return `Which repository or repositories should handle this issue? ${details}`;
     }
     if (decision.thin) {
-        return [
-            `Factory matched ${routedRepos.join(', ')}.`,
-            'Please clarify the concrete expected behavior, constraints, and acceptance criteria/tests before dispatch.',
-        ].join(' ');
+        return `Factory matched ${routedRepos.join(', ')}. ${details}`;
     }
-    return [
-        `Factory matched ${routedRepos.join(', ')}, but triage confidence is low.`,
-        'Please confirm the intended repo/approach or correct the route before dispatch.',
-    ].join(' ');
+    return `Factory matched ${routedRepos.join(', ')}, but triage confidence is low. Please confirm that repository and intended approach, or provide the correct route. ${details}`;
 };
+const isTerminalDeliveryFailure = (reason) => /worker[_ -]?(?:exited|disappeared)|max delivery retries exceeded/iu.test(reason ?? '');
 const isTriageEscalationWatchRecord = (record) => record.agents.size === 0 && record.invocationIds.size === 0 && triageEscalationReason(record.decision) !== undefined;
 const hasDispatchableRoute = (decision) => decision.routes.length > 0 && dispatchSpecs(decision).length > 0;
 const dispatchAfterSlackClarification = (decision, escalationReason) => ({
@@ -9667,6 +10110,36 @@ const slackMentions = (userIds) => {
         .map((id) => `<@${id}>`);
     return mentions.length > 0 ? mentions.join(' ') : undefined;
 };
+const normalizedCrossProviderIdentity = (value) => value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, '');
+const isSlackIdentityRecordPath = (path) => path.endsWith('.json') && (path.startsWith('/slack/users/') ||
+    path.startsWith('/slack/channels/'));
+const slackIdentityPathTimestamp = (path) => {
+    const timestamps = [...path.matchAll(/(?:^|\/)(\d{10})[_\.][0-9]+/gu)];
+    return Number(timestamps.at(-1)?.[1] ?? 0);
+};
+const slackUserIdMatchingIdentity = (payload, identity) => {
+    if (payload.is_bot === true ||
+        payload.user_is_bot === true ||
+        payload.is_deleted === true ||
+        payload.deleted === true)
+        return undefined;
+    const userId = stringValue(payload.id) ?? stringValue(payload.user);
+    if (!userId || !/^[UW][A-Z0-9]+$/u.test(userId))
+        return undefined;
+    const email = stringValue(payload.email) ?? stringValue(payload.user_email);
+    const aliases = [
+        stringValue(payload.name),
+        stringValue(payload.real_name),
+        stringValue(payload.display_name),
+        stringValue(payload.user_name),
+        stringValue(payload.user_real_name),
+        stringValue(payload.user_display_name),
+        email?.split('@')[0],
+    ];
+    return aliases.some((alias) => alias && normalizedCrossProviderIdentity(alias) === identity)
+        ? userId
+        : undefined;
+};
 const agentQuestionSlackText = (issue, question, stakeholderUserIds = []) => [
     slackMentions(stakeholderUserIds),
     `${issue.key}: ${question.agentName} needs input.`,