@agent-relay/factory 0.1.26 → 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';
@@ -129,6 +131,11 @@ export class FactoryLoop {
     #githubIssueCommentWatchers = new Map();
     #githubIssueCommentWatchStates = new Map();
     #githubIssueCommentQueues = new Map();
+    #githubIssueAuthors = new Map();
+    #githubIssueAuthorLookups = new Map();
+    #slackReporterUserIds = new Map();
+    #slackReporterUserIdLookups = new Map();
+    #reconciledGithubInProgress = new Set();
     #resolvedSlackChannelDir;
     #slackChannelDirRefresh;
     // Agents we've already logged an ambiguous-PID-lookup warning for, so the
@@ -947,12 +954,16 @@ export class FactoryLoop {
             return { dispatchRelayflow: true };
         }
         if (isGithubIssueFilePath(path)) {
-            const sourceKey = `github:${path}`;
+            const parts = githubIssuePathParts(path);
+            const sourceKey = parts
+                ? `github:${githubIssueIdentity(parts.owner, parts.repo, parts.number)}`
+                : `github:${path}`;
             if (seenIssueKeys.has(sourceKey)) {
                 this.#increment('liveDuplicateIssueEventsSuppressed');
-                this.#logger.debug?.('[factory] suppressed duplicate live GitHub issue event in current drain', {
+                this.#logger.debug?.('[factory] suppressed duplicate live GitHub issue alias in current drain', {
                     id: event.id,
                     path,
+                    issue: parts ? sourceKey.slice('github:'.length) : undefined,
                 });
                 return { dispatchRelayflow: false };
             }
@@ -1130,8 +1141,18 @@ 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 key = issueStateKey(issueRef(issue));
+        const issueKey = issueStateKey(issueRef(issue));
+        const key = opts.openOnly ? `${issueKey}:open` : issueKey;
         const now = this.#clock.now();
         const cached = this.#probePrResolvedCache.get(key);
         if (cached && cached.expiresAtMs > now) {
@@ -1176,12 +1197,16 @@ export class FactoryLoop {
                 await this.#ensureGithubIngestionReady();
             }
             const paths = await this.#readyIssuePaths();
+            const orphanRecovery = issueSource === 'github'
+                ? await this.#githubOrphanRecoveryContext()
+                : undefined;
             const pulled = [];
             const triaged = [];
             const dispatched = [];
             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;
@@ -1191,40 +1216,108 @@ 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;
                 }
                 pulled.push(issueRef(issue));
-                const dispatchBlock = await this.#dispatchBlockReason(issue);
-                if (dispatchBlock) {
-                    skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
-                    continue;
+                const wasReady = this.#isIssueReady(issue);
+                const labels = isGithubIssue(issue)
+                    ? new Set(issue.labels.map((label) => label.trim().toLowerCase()))
+                    : undefined;
+                const requiredLabel = this.#config.safety.requireLabel.trim().toLowerCase();
+                const mayRecoverGithubOrphan = !wasReady &&
+                    !dryRun &&
+                    issueSource === 'github' &&
+                    Boolean(orphanRecovery) &&
+                    Boolean(requiredLabel) &&
+                    Boolean(labels?.has(requiredLabel)) &&
+                    Boolean(labels?.has('factory:in-progress')) &&
+                    !labels?.has('factory:human-review');
+                if (!mayRecoverGithubOrphan) {
+                    const dispatchBlock = await this.#dispatchBlockReason(issue);
+                    if (dispatchBlock) {
+                        skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
+                        continue;
+                    }
                 }
                 const batch = await this.#batch();
                 if (batch.isInFlight(issue) || batch.isQueued(issue)) {
                     skipped.push({ issue: issueRef(issue), reason: 'already tracked' });
                     continue;
                 }
-                if (!this.#isIssueReady(issue)) {
+                const recoveredOrphan = mayRecoverGithubOrphan &&
+                    await this.#reconcileOrphanedGithubInProgress(issue, orphanRecovery, dryRun);
+                if (!wasReady && !recoveredOrphan) {
+                    if (mayRecoverGithubOrphan) {
+                        const dispatchBlock = await this.#dispatchBlockReason(issue);
+                        if (dispatchBlock) {
+                            skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
+                            continue;
+                        }
+                    }
                     skipped.push({ issue: issueRef(issue), reason: 'live state is not ready-for-agent' });
                     continue;
                 }
-                if (!isInFactoryScope(issue, this.#config.safety)) {
-                    skipped.push({ issue: issueRef(issue), reason: 'not factory-e2e scope' });
-                    continue;
-                }
-                if (!isDispatchableIssue(issue)) {
-                    skipped.push({ issue: issueRef(issue), reason: 'not reconciled real Linear issue' });
-                    continue;
-                }
-                const decision = await this.triageIssue(issue);
-                triaged.push(decision);
-                const result = await this.dispatch(decision, { dryRun });
-                if (result.agents.length === 0 && !dryRun) {
-                    skipped.push({ issue: decision.issue, reason: 'queued or escalated' });
+                const recoveredIdentity = recoveredOrphan ? githubIssueRefIdentity(issueRef(issue)) : undefined;
+                try {
+                    if (recoveredOrphan) {
+                        const dispatchBlock = await this.#dispatchBlockReason(issue);
+                        if (dispatchBlock) {
+                            skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
+                            continue;
+                        }
+                    }
+                    if (!isInFactoryScope(issue, this.#config.safety)) {
+                        skipped.push({ issue: issueRef(issue), reason: 'not factory-e2e scope' });
+                        continue;
+                    }
+                    if (!isDispatchableIssue(issue)) {
+                        skipped.push({ issue: issueRef(issue), reason: 'not reconciled real Linear issue' });
+                        continue;
+                    }
+                    const decision = await this.triageIssue(issue);
+                    triaged.push(decision);
+                    let result;
+                    try {
+                        result = await this.dispatch(decision, { dryRun });
+                    }
+                    catch (error) {
+                        if (!(error instanceof LiveDispatchStateChangedError))
+                            throw error;
+                        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' });
+                    }
+                    else {
+                        dispatched.push(result);
+                    }
                 }
-                else {
-                    dispatched.push(result);
+                finally {
+                    if (recoveredIdentity)
+                        this.#reconciledGithubInProgress.delete(recoveredIdentity);
                 }
             }
             report = { pulled, triaged, dispatched, skipped, dryRun, slackDegraded: this.#slackDegraded };
@@ -1255,6 +1348,242 @@ export class FactoryLoop {
             }
         }
     }
+    async #githubOrphanRecoveryContext() {
+        try {
+            const [registry, roster, lifecycles, waitingClarifications] = await Promise.all([
+                readFactoryInFlightRegistry(this.#config.loop.registryPath),
+                this.#fleet.roster(),
+                this.#state.listDispatchLifecycles(this.#workspaceId),
+                this.#state.listWaitingClarifications(this.#workspaceId),
+            ]);
+            const onlineAgents = new Set(roster.agents.map((agent) => agent.name));
+            const activeIssueIdentities = new Set();
+            for (const [, lifecycle] of lifecycles) {
+                if (isTerminalDispatchLifecycle(lifecycle))
+                    continue;
+                const identity = githubIssueRefIdentity(lifecycle.issue);
+                if (identity)
+                    activeIssueIdentities.add(identity);
+            }
+            for (const [, waiting] of waitingClarifications) {
+                const identity = githubIssueRefIdentity(waiting.issue);
+                if (identity)
+                    activeIssueIdentities.add(identity);
+            }
+            for (const agent of registry?.agents ?? []) {
+                if (!onlineAgents.has(agent.name) || !agent.issue)
+                    continue;
+                const identity = githubIssueRefIdentity(agent.issue);
+                if (identity)
+                    activeIssueIdentities.add(identity);
+            }
+            return {
+                activeIssueIdentities,
+                onlineAgentNames: onlineAgents,
+            };
+        }
+        catch (error) {
+            this.#increment('githubOrphanRecoveryContextFailures');
+            this.#logger.warn?.('[factory] could not establish orphan-recovery safety context; preserving in-progress issues', {
+                error: describeError(error).errorMessage,
+            });
+            return undefined;
+        }
+    }
+    async #reconcileOrphanedGithubInProgress(issue, context, dryRun) {
+        if (dryRun || !context || !isGithubIssue(issue))
+            return false;
+        const labels = new Set(issue.labels.map((label) => label.trim().toLowerCase()));
+        const required = this.#config.safety.requireLabel.trim().toLowerCase();
+        if (!required ||
+            !labels.has(required) ||
+            !labels.has('factory:in-progress') ||
+            labels.has('factory:human-review'))
+            return false;
+        const identity = githubIssueRefIdentity(issueRef(issue));
+        if (!identity ||
+            context.activeIssueIdentities.has(identity) ||
+            [...context.onlineAgentNames].some((name) => githubAgentNameMatchesIssue(name, issue))) {
+            this.#increment('githubOrphanRecoveriesBlockedActive');
+            return false;
+        }
+        const getProviderStatus = this.#githubWriteback.getIssueStatus;
+        if (!getProviderStatus) {
+            this.#increment('githubOrphanRecoveryStatusLookupUnavailable');
+            return false;
+        }
+        let providerStatus;
+        try {
+            providerStatus = await getProviderStatus.call(this.#githubWriteback, issue);
+        }
+        catch (error) {
+            this.#increment('githubOrphanRecoveryStatusLookupFailures');
+            this.#logger.warn?.('[factory] could not verify provider-authoritative GitHub issue status; preserving it', {
+                issue: issue.key,
+                error: describeError(error).errorMessage,
+            });
+            return false;
+        }
+        if (!providerStatus || providerStatus === 'human-review') {
+            this.#increment('githubOrphanRecoveriesBlockedProviderStatus');
+            return false;
+        }
+        let openPr;
+        try {
+            openPr = await this.#openCompletionPr(issue);
+        }
+        catch (error) {
+            this.#increment('githubOrphanRecoveryPrProbeFailures');
+            this.#logger.warn?.('[factory] could not prove an in-progress GitHub issue has no open PR; preserving it', {
+                issue: issue.key,
+                error: describeError(error).errorMessage,
+            });
+            return false;
+        }
+        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?.(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;
+        }
+        try {
+            if (providerStatus === 'in-progress') {
+                await this.#githubWriteback.setStatus(issue, 'ready');
+            }
+            // A crashed dispatch may leave its durable attempt marked in-flight even
+            // after every agent and lifecycle disappeared. Only clear that stale bit
+            // after all provider, agent, lifecycle, and open-PR safety checks pass.
+            await this.#clearDispatchInFlight(issue);
+            this.#reconciledGithubInProgress.add(identity);
+            this.#increment('githubOrphanedInProgressRecovered');
+            this.#logger.warn?.('[factory] recovered orphaned GitHub in-progress issue for redispatch', {
+                issue: issue.key,
+                path: issue.path,
+            });
+            return true;
+        }
+        catch (error) {
+            this.#increment('githubOrphanRecoveryWritebackFailures');
+            this.#logger.warn?.('[factory] failed to clear orphaned GitHub lifecycle status; preserving in-progress issue', {
+                issue: issue.key,
+                error: describeError(error).errorMessage,
+            });
+            return false;
+        }
+    }
+    async #openCompletionPr(issue) {
+        if (this.#customProbePrResolver) {
+            return await this.#probePrResolver(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), {
             count: (paths) => paths.length,
@@ -1576,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);
@@ -1615,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.
@@ -1767,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);
@@ -1904,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);
@@ -1940,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))
@@ -2159,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);
         }
     }
@@ -2185,11 +2553,14 @@ export class FactoryLoop {
         if (githubState === 'closed') {
             return false;
         }
-        if (issue.labels.some((label) => GITHUB_LIFECYCLE_LABELS.has(label.trim().toLowerCase()))) {
+        const labels = new Set(issue.labels.map((label) => label.trim().toLowerCase()));
+        if (labels.has('factory:human-review'))
+            return false;
+        const identity = githubIssueRefIdentity(issueRef(issue));
+        if (labels.has('factory:in-progress') && (!identity || !this.#reconciledGithubInProgress.has(identity)))
             return false;
-        }
         const required = this.#config.safety.requireLabel.trim().toLowerCase();
-        return Boolean(required) && issue.labels.some((label) => label.trim().toLowerCase() === required);
+        return Boolean(required) && labels.has(required);
     }
     async #postIssueComment(issue, body) {
         if (isGithubIssue(issue)) {
@@ -2274,12 +2645,22 @@ export class FactoryLoop {
     }
     async #githubIssuePaths() {
         try {
-            const issuePaths = new Set();
+            const issuePaths = new Map();
             for (const root of githubIssueScanRoots(this.#config)) {
                 const paths = await this.#listRelayfileTree(root, 'GitHub issue ingestion');
                 for (const path of paths) {
-                    if (githubIssuePathParts(path) !== undefined) {
-                        issuePaths.add(path);
+                    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');
+                        }
                     }
                     else if (githubIssueDirectoryPathParts(path) !== undefined) {
                         // listTree returns the issue directory entry alongside its
@@ -2291,11 +2672,10 @@ export class FactoryLoop {
                     }
                     else if (isGithubIssueTreePath(path)) {
                         this.#increment('githubIssuesIgnoredByPathRegex');
-                        this.#logger.debug?.('[factory] ignored GitHub issue path with unsupported relayfile shape', { path });
                     }
                 }
             }
-            return [...issuePaths].sort();
+            return [...issuePaths.values()].sort();
         }
         catch (error) {
             this.#increment('githubIssueListFailures');
@@ -3084,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
@@ -3136,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;
@@ -3305,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)
@@ -3334,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,
@@ -3362,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)
@@ -3566,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);
@@ -3583,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) {
@@ -3593,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) {
@@ -3656,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);
@@ -4274,7 +4771,7 @@ export class FactoryLoop {
         const correlationId = githubEscalationCorrelationId('agent-question', record.issue, question.question);
         const issue = await this.#readIssue(record.issue.path);
         const source = issue ? githubIssueSourceRef(issue) : undefined;
-        const authorizedAuthor = issue ? githubIssueAuthor(issue) : undefined;
+        const authorizedAuthor = issue ? await this.#resolveGithubIssueAuthor(issue) : undefined;
         if (!issue || !source || !authorizedAuthor) {
             this.#surfaceEscalationDeliveryFailure('agent-question', record.issue, correlationId, fallbackReason
                 ? `${fallbackReason}; no GitHub issue write path with an identifiable issue reporter is available`
@@ -4439,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);
@@ -4770,7 +5275,7 @@ export class FactoryLoop {
         };
         const correlationId = githubEscalationCorrelationId('agent-question', record.issue, `${comment.commentId}:${question.question}`);
         const issue = await this.#readIssue(record.issue.path);
-        const authorizedAuthor = issue ? githubIssueAuthor(issue) : undefined;
+        const authorizedAuthor = issue ? await this.#resolveGithubIssueAuthor(issue) : undefined;
         if (!authorizedAuthor) {
             this.#increment('githubAgentQuestionsIgnoredMissingAuthorizedAuthor');
             this.#surfaceEscalationDeliveryFailure('agent-question', record.issue, correlationId, 'source GitHub issue has no identifiable reporter authorized to answer the durable question');
@@ -4880,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);
     }
@@ -5015,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')
@@ -5648,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;
         }
@@ -5720,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
                 ? {
@@ -5854,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);
@@ -6403,11 +6931,11 @@ 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 ? githubIssueAuthor(issue) : undefined;
+        const authorizedAuthor = issue ? await this.#resolveGithubIssueAuthor(issue) : undefined;
         if (!issue || !source || !authorizedAuthor) {
             this.#surfaceEscalationDeliveryFailure('triage', decision.issue, correlationId, 'no Slack channel or GitHub issue write path with an identifiable issue reporter is available');
             return;
@@ -6482,8 +7010,12 @@ export class FactoryLoop {
             return;
         const source = githubIssueSourceRef(issue);
         const stakeholderMentions = slackMentions(this.#config.slack.stakeholderUserIds);
-        const reporter = githubIssueAuthor(issue);
-        const audience = [stakeholderMentions, reporter ? `GitHub reporter: @${reporter}.` : undefined]
+        const reporter = await this.#resolveGithubIssueAuthor(issue);
+        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
@@ -6494,13 +7026,122 @@ 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);
         this.#increment('triageEscalationsMirroredToSlack');
         this.#recordSlackWritebackSuccess('triage-escalation-mirror');
     }
+    async #resolveGithubIssueAuthor(issue) {
+        const embeddedAuthor = githubIssueAuthor(issue);
+        if (embeddedAuthor)
+            return embeddedAuthor;
+        const source = githubIssueSourceRef(issue);
+        const lookup = this.#githubWriteback.getIssueAuthor;
+        if (!source || !lookup)
+            return undefined;
+        const key = githubIssueSourceKey(source);
+        if (this.#githubIssueAuthors.has(key)) {
+            return this.#githubIssueAuthors.get(key);
+        }
+        const existing = this.#githubIssueAuthorLookups.get(key);
+        if (existing)
+            return existing;
+        const pending = lookup.call(this.#githubWriteback, issue)
+            .then((author) => {
+            const normalized = author?.trim() || undefined;
+            this.#githubIssueAuthors.set(key, normalized);
+            if (normalized) {
+                this.#increment('githubIssueAuthorsResolvedFromProvider');
+            }
+            return normalized;
+        })
+            .catch((error) => {
+            this.#increment('githubIssueAuthorLookupFailures');
+            this.#logger.warn?.('[factory] provider-authoritative GitHub issue author lookup failed', {
+                owner: source.owner,
+                repo: source.repo,
+                issue: source.number,
+                error: describeError(error).errorMessage,
+            });
+            return undefined;
+        })
+            .finally(() => {
+            this.#githubIssueAuthorLookups.delete(key);
+        });
+        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;
@@ -6512,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);
@@ -7651,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'));
@@ -7908,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;
@@ -8136,6 +8797,26 @@ export const githubIssuePathParts = (path) => {
         slug: match[7],
     };
 };
+const githubIssueIdentity = (owner, repo, number) => `${owner.toLowerCase()}/${repo.toLowerCase()}#${number}`;
+const githubIssueRefIdentity = (issue) => {
+    const parts = githubIssuePathParts(issue.path);
+    return parts ? githubIssueIdentity(parts.owner, parts.repo, parts.number) : undefined;
+};
+const githubIssuePathPreference = (path) => {
+    if (path.includes('/issues/by-id/'))
+        return 0;
+    if (path.endsWith('/meta.json'))
+        return 1;
+    if (path.endsWith('.json'))
+        return 2;
+    return 3;
+};
+const githubAgentNameMatchesIssue = (name, issue) => {
+    const parts = githubIssuePathParts(issue.path);
+    if (!parts)
+        return false;
+    return name.startsWith(`ar-${parts.number}-`) && name.endsWith(`-${sanitizeAgentSlug(parts.repo)}`);
+};
 const githubIssueCommentPathParts = (path) => {
     const match = path.match(/^\/github\/repos\/(?:([^/]+)\/([^/]+)|([A-Za-z0-9-]+)__([^/]+))\/issues\/(\d+)(?:__[^/]*)?\/comments\/([^/]+?)(?:\.json|\/(?:meta|metadata)\.json)$/u);
     const owner = match?.[1] ?? match?.[3];
@@ -8295,18 +8976,29 @@ const resolveIssuePrFromMount = async (mount, config, issue, opts = {}) => {
             if (!path.endsWith('.json'))
                 continue;
             const pr = await readProbePrCandidate(mount, path);
+            if (opts.openOnly && normalizePrState(pr?.state) !== 'OPEN')
+                continue;
             const score = pr
                 ? issuePrMatchScore(pr, issue, opts.titleMarker ?? config.safety.requireTitlePrefix, 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];
 };
 const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
     const candidates = [];
+    let lookupFailures = 0;
     for (const repo of reposFromConfig(config)) {
         let payload;
         try {
@@ -8318,30 +9010,37 @@ 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),
             ]);
             if (!result.stdout.trim()) {
+                lookupFailures += 1;
                 logger?.warn?.('[factory] gh PR resolver returned empty output', { issue: issue.key, repo });
                 continue;
             }
             payload = parseJsonContent(result.stdout);
         }
         catch (error) {
+            lookupFailures += 1;
             logger?.warn?.('[factory] gh PR resolver failed', { issue: issue.key, repo, error });
             continue;
         }
         if (!Array.isArray(payload)) {
+            lookupFailures += 1;
             logger?.warn?.('[factory] gh PR resolver returned non-array payload', { issue: issue.key, repo });
             continue;
         }
         if (payload.length >= PROBE_PR_GH_CANDIDATE_LIMIT) {
             logger?.warn?.('[factory] gh PR resolver hit candidate limit', { issue: issue.key, repo, limit: PROBE_PR_GH_CANDIDATE_LIMIT });
+            if (opts.failOnLookupError)
+                lookupFailures += 1;
         }
         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;
             const score = issuePrMatchScore(pr, issue, opts.titleMarker ?? config.safety.requireTitlePrefix, opts);
             if (score <= 0)
@@ -8350,14 +9049,20 @@ 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',
             });
         }
     }
-    return candidates.sort((a, b) => b.score - a.score ||
+    const resolved = candidates.sort((a, b) => b.score - a.score ||
         Number(b.open) - Number(a.open) ||
         b.prNumber - a.prNumber)[0];
+    if (!resolved && opts.failOnLookupError && lookupFailures > 0) {
+        throw new Error(`Unable to confirm open pull request state for ${issue.key} in ${lookupFailures} configured repository lookup(s)`);
+    }
+    return resolved;
 };
 const reposFromConfig = (config) => {
     const repos = new Set([
@@ -8452,6 +9157,8 @@ const readProbePrCandidate = async (mount, path) => {
             body: stringValue(payload.body) ?? '',
             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 {
@@ -8472,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;
@@ -8486,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;
@@ -8800,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;
@@ -8882,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);
@@ -9269,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) => ({
@@ -9396,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.`,