@agent-relay/factory 0.1.25 → 0.1.27

package/dist/orchestrator/factory.js

@@ -5,6 +5,7 @@ import { FactoryConfigSchema } from '../config/schema.js';
 import { linearByStatePath, linearByIdPath, linearByUuidPath } from '../constants/linear.js';
 import { stateResolutionFromIds } from '../linear/state-resolver.js';
 import { GithubMergeGate, closeProbePr } from '../github/index.js';
+import { factoryWorktreePath } from '../git/agent-worktree.js';
 import { InMemoryStateStore } from '../state/in-memory-state-store.js';
 import { containsExplicitIssueReference, containsIssueKey } from '../issue-key-match.js';
 import { normalizeLogger, normalizeLogValue, setSafeErrorStack, stringifyLogValue } from '../logging.js';
@@ -116,6 +117,7 @@ export class FactoryLoop {
     #state;
     #workspaceId;
     #relayflows;
+    #worktrees;
     #batchView;
     #batchReady;
     #listeners = new Map();
@@ -127,6 +129,9 @@ export class FactoryLoop {
     #githubIssueCommentWatchers = new Map();
     #githubIssueCommentWatchStates = new Map();
     #githubIssueCommentQueues = new Map();
+    #githubIssueAuthors = new Map();
+    #githubIssueAuthorLookups = new Map();
+    #reconciledGithubInProgress = new Set();
     #resolvedSlackChannelDir;
     #slackChannelDirRefresh;
     // Agents we've already logged an ambiguous-PID-lookup warning for, so the
@@ -149,6 +154,7 @@ export class FactoryLoop {
     #dispatchTerminalWaiters = new Map();
     #dispatchLifecycleRetryTimers = new Map();
     #dispatchLifecycleDrives = new Set();
+    #localReleaseCheckpoints = new Map();
     #dispatchLifecycleRenewTimer;
     #clarificationSweepTimer;
     #clarificationSweepDueAtMs;
@@ -251,6 +257,7 @@ export class FactoryLoop {
         this.#terminationGraceMs = ports.terminationGraceMs;
         this.#workspaceId = config.workspaceId ?? 'default';
         this.#relayflows = ports.relayflows;
+        this.#worktrees = ports.worktrees;
         this.#state = ports.stateStore ?? new InMemoryStateStore({
             batchSize: config.batchSize,
             agentQuestionDedupeLimit: AGENT_QUESTION_DEDUPE_LIMIT,
@@ -943,12 +950,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 };
             }
@@ -1127,7 +1138,8 @@ export class FactoryLoop {
         });
     }
     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) {
@@ -1172,6 +1184,9 @@ 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 = [];
@@ -1181,7 +1196,9 @@ export class FactoryLoop {
             for (const path of paths) {
                 const issue = await this.#readIssue(path);
                 readyIssueReads += 1;
-                lastReadyReadProgressAtMs = this.#logTimedProgress('[factory] Linear ready issue read progress', startedAtMs, lastReadyReadProgressAtMs, { read: readyIssueReads, total: paths.length, path });
+                lastReadyReadProgressAtMs = this.#logTimedProgress(this.#config.issueSource === 'github'
+                    ? '[factory] GitHub ready issue read progress'
+                    : '[factory] Linear ready issue read progress', startedAtMs, lastReadyReadProgressAtMs, { read: readyIssueReads, total: paths.length, path });
                 if (issue && issueSource === 'linear') {
                     await this.#recordCanonicalIssueState(issue);
                 }
@@ -1189,36 +1206,74 @@ export class FactoryLoop {
                     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);
+                    const result = await this.dispatch(decision, { dryRun });
+                    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 };
@@ -1249,6 +1304,140 @@ 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 hasOpenPr;
+        try {
+            hasOpenPr = await this.#hasOpenCompletionPr(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 (hasOpenPr) {
+            this.#increment('githubOrphanRecoveriesBlockedOpenPr');
+            this.#logger.info?.('[factory] preserved in-progress GitHub issue because a matching open PR exists', {
+                issue: issue.key,
+            });
+            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 #hasOpenCompletionPr(issue) {
+        if (this.#customProbePrResolver) {
+            return Boolean(await this.#probePrResolver(issue));
+        }
+        return Boolean(await this.#resolveIssuePr(issue, {
+            titleMarker: FACTORY_E2E_MARKER,
+            openOnly: true,
+            failOnLookupError: true,
+        }));
+    }
     async #listRelayfileTree(prefix, phase) {
         return this.#withRelayfileOperation('listTree', { phase, prefix }, () => this.#mount.listTree(prefix), {
             count: (paths) => paths.length,
@@ -1499,9 +1688,15 @@ export class FactoryLoop {
         // happen before a remote lifecycle is first claimed so takeover cannot
         // recover a persisted minimal triage task after a crash in this gap.
         const durableRemoteDispatch = !dryRun && this.#fleet.placementLocality === 'remote';
-        const lifecycleRunId = durableRemoteDispatch ? randomUUID() : undefined;
+        // Local dispatches need the same deterministic branch identity as remote
+        // ones. Without it, every worker starts in the configured shared checkout
+        // and concurrent issues can switch each other back to the base branch.
+        const isolateLocalWorktree = this.#fleet.placementLocality === 'local' && Boolean(this.#worktrees);
+        const lifecycleRunId = !dryRun && (durableRemoteDispatch || isolateLocalWorktree) ? randomUUID() : undefined;
         if (lifecycleRunId) {
-            dispatchDecision = decisionWithLifecycleBranches(dispatchDecision, lifecycleRunId);
+            dispatchDecision = decisionWithLifecycleBranches(dispatchDecision, lifecycleRunId, {
+                isolateLocalWorktree,
+            });
         }
         dispatchDecision = await this.#withRenderedDispatchTasks(dispatchDecision, liveIssue);
         if (durableRemoteDispatch) {
@@ -1553,6 +1748,7 @@ export class FactoryLoop {
                         name: spawned.name,
                         tracked: cloneTrackedAgent(tracked),
                         persistedAtMs: this.#clock.now(),
+                        worktree: this.#agentWorktree(record, tracked.spec),
                     });
                 }
                 agents.push({ name: spawned.name, role: spec.role });
@@ -1597,7 +1793,12 @@ export class FactoryLoop {
             return result;
         }
         catch (error) {
-            await this.#persistDispatchFailureReaperHandoff(record, spawnedForReaperHandoff);
+            // A spawn can fail after the broker accepted it but before its ack
+            // reached Factory. Include every planned worktree agent, not only the
+            // 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');
@@ -1605,6 +1806,20 @@ export class FactoryLoop {
             if (!failedState?.terminal)
                 this.#scheduleDispatchLifecycleRetry(record);
             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.
+            if (worktreesTornDown) {
+                try {
+                    await this.#writeInFlightRegistry();
+                }
+                catch (registryError) {
+                    this.#logger.warn?.('[factory] failed to rewrite registry after dispatch worktree teardown', {
+                        issue: record.issue,
+                        error: describeError(registryError).errorMessage,
+                    });
+                }
+            }
             throw error;
         }
     }
@@ -1815,6 +2030,31 @@ export class FactoryLoop {
         }, DISPATCH_LIFECYCLE_RETRY_MS);
         this.#dispatchLifecycleRetryTimers.set(key, timer);
     }
+    #scheduleReleaseRetry(record, reason) {
+        if (this.#fleet.placementLocality === 'remote') {
+            this.#scheduleDispatchLifecycleRetry(record);
+            return;
+        }
+        const key = issueKey(record.issue);
+        if (this.#stopping || this.#dispatchLifecycleRetryTimers.has(key))
+            return;
+        const timer = setTimeout(() => {
+            this.#dispatchLifecycleRetryTimers.delete(key);
+            const drive = this.#finishDurableRelease(record, reason)
+                .then(() => undefined)
+                .catch((error) => {
+                this.#logger.warn?.('[factory] local completion cleanup retry failed', {
+                    issue: record.issue.key,
+                    error: describeError(error).errorMessage,
+                });
+                this.#scheduleReleaseRetry(record, reason);
+            })
+                .finally(() => this.#dispatchLifecycleDrives.delete(drive));
+            this.#dispatchLifecycleDrives.add(drive);
+        }, DISPATCH_LIFECYCLE_RETRY_MS);
+        timer.unref?.();
+        this.#dispatchLifecycleRetryTimers.set(key, timer);
+    }
     async #driveDispatchLifecycle(key) {
         if (this.#stopping)
             return;
@@ -1965,12 +2205,12 @@ export class FactoryLoop {
     }
     async #finishDurableRelease(record, releaseReason) {
         const batch = await this.#batch();
-        const next = this.#fleet.placementLocality === 'remote' ? undefined : batch.complete(record.issue);
         const reason = releaseReason ?? (this.#config.terminalState === 'human-review' ? 'issue-human-review' : 'issue-done');
-        const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue));
+        const releaseKey = issueKey(record.issue);
+        const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, releaseKey);
         const released = new Set(lifecycle?.agents
             .filter((agent) => agent.releasedAtMs !== undefined)
-            .map((agent) => agent.name) ?? []);
+            .map((agent) => agent.name) ?? this.#localReleaseCheckpoints.get(releaseKey) ?? []);
         const failed = [];
         for (const agent of record.agents) {
             if (released.has(agent[0]))
@@ -1981,19 +2221,37 @@ export class FactoryLoop {
                 continue;
             }
             released.add(agent[0]);
+            if (this.#fleet.placementLocality === 'local') {
+                this.#localReleaseCheckpoints.set(releaseKey, new Set(released));
+            }
             // Persist each acknowledged release independently. A takeover retries
             // only agents whose release did not reach a fenced durable checkpoint.
             if (!await this.#saveDispatchLifecycle(record, 'releasing', undefined, reason, released))
                 return false;
         }
-        if (next)
-            await this.dispatch(next.decision, { dryRun: next.dryRun });
         await this.#writeInFlightRegistry();
         if (failed.length > 0) {
             this.#increment('dispatchLifecycleReleaseRetries');
-            this.#scheduleDispatchLifecycleRetry(record);
+            this.#scheduleReleaseRetry(record, reason);
+            return false;
+        }
+        // The PR branch is already pushed and the babysitter has declared the
+        // current PR green with review feedback addressed. Release is now fenced,
+        // so no agent can race cleanup of the shared per-issue worktree.
+        try {
+            await this.#cleanupAgentWorktrees(record);
+        }
+        catch {
+            // Completion remains in-flight until the isolated checkout is gone.
+            // Remote lifecycles retry from their durable `releasing` phase; local
+            // lifecycles retain this record and retry directly from the same fence.
+            this.#scheduleReleaseRetry(record, reason);
             return false;
         }
+        const next = this.#fleet.placementLocality === 'remote' ? undefined : batch.complete(record.issue);
+        this.#localReleaseCheckpoints.delete(releaseKey);
+        if (next)
+            await this.dispatch(next.decision, { dryRun: next.dryRun });
         // Terminal lifecycle saves intentionally relinquish the owner epoch. Clear
         // the babysitter's durable ownership/wake/critical state while that epoch
         // is still valid so a later reopened issue cannot inherit a stale PR owner.
@@ -2110,11 +2368,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)) {
@@ -2199,12 +2460,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
@@ -2220,7 +2491,7 @@ export class FactoryLoop {
                     }
                 }
             }
-            return [...issuePaths].sort();
+            return [...issuePaths.values()].sort();
         }
         catch (error) {
             this.#increment('githubIssueListFailures');
@@ -2470,6 +2741,7 @@ export class FactoryLoop {
         try {
             const protectedPids = await this.#protectedPids();
             let registryChanged = false;
+            const readyToClear = new Set();
             for (const [key, handoff] of handoffs) {
                 const roots = await this.#terminationRoots(handoff.name, handoff.tracked, protectedPids);
                 if (roots.pids.length === 0 && roots.status === 'unresolved') {
@@ -2482,8 +2754,6 @@ export class FactoryLoop {
                         unresolvedAgeMs,
                     });
                     if (unresolvedAgeMs >= DISPATCH_FAILURE_HANDOFF_UNRESOLVED_TTL_MS) {
-                        await this.#state.clearFailureHandoff(this.#workspaceId, key);
-                        registryChanged = true;
                         this.#increment('dispatchFailureReaperHandoffsDroppedStaleUnresolved');
                         this.#logger.warn?.('[factory] dropped stale unresolved dispatch-failed handoff', {
                             agentName: handoff.name,
@@ -2493,6 +2763,7 @@ export class FactoryLoop {
                         });
                         try {
                             await this.#fleet.release(handoff.name, 'dispatch failed');
+                            readyToClear.add(key);
                         }
                         catch (error) {
                             this.#logger.warn?.('[factory] failed to release unresolved dispatch-failure handoff after pruning', {
@@ -2526,16 +2797,55 @@ export class FactoryLoop {
                     }
                 }
                 if (!blockingSkip) {
-                    await this.#state.clearFailureHandoff(this.#workspaceId, key);
-                    registryChanged = true;
                     try {
                         await this.#fleet.release(handoff.name, 'dispatch failed');
+                        readyToClear.add(key);
                     }
                     catch (error) {
                         this.#logger.warn?.(`[factory] failed to release ${handoff.name} after dispatch-failure reap`, error);
                     }
                 }
             }
+            if (readyToClear.size > 0) {
+                const worktreeGroups = new Map();
+                for (const entry of handoffs) {
+                    const worktreePath = entry[1].worktree?.worktreePath;
+                    if (!worktreePath)
+                        continue;
+                    const group = worktreeGroups.get(worktreePath) ?? [];
+                    group.push(entry);
+                    worktreeGroups.set(worktreePath, group);
+                }
+                for (const group of worktreeGroups.values()) {
+                    if (!group.every(([key]) => readyToClear.has(key)))
+                        continue;
+                    try {
+                        await this.#cleanupFailureHandoffWorktrees(group.map(([, handoff]) => handoff));
+                    }
+                    catch (error) {
+                        this.#increment('agentWorktreeCleanupFailures');
+                        this.#logger.warn?.('[factory] retained dispatch-failure handoff after worktree cleanup failed', {
+                            issue: group[0]?.[1].issue,
+                            worktreePath: group[0]?.[1].worktree?.worktreePath,
+                            error: describeError(error).errorMessage,
+                        });
+                        continue;
+                    }
+                    for (const [key] of group) {
+                        await this.#state.clearFailureHandoff(this.#workspaceId, key);
+                        readyToClear.delete(key);
+                        registryChanged = true;
+                    }
+                }
+                // Legacy and non-worktree handoffs can be cleared directly once their
+                // process is gone and the broker accepted the release.
+                for (const [key, handoff] of handoffs) {
+                    if (!readyToClear.has(key) || handoff.worktree)
+                        continue;
+                    await this.#state.clearFailureHandoff(this.#workspaceId, key);
+                    registryChanged = true;
+                }
+            }
             if (registryChanged) {
                 await this.#writeInFlightRegistry(registryPath, heartbeatPath);
             }
@@ -2750,6 +3060,62 @@ export class FactoryLoop {
             this.#error(error, record.issue);
         }
     }
+    #dispatchFailureHandoffs(record, acknowledged) {
+        const handoffs = new Map(acknowledged.map((handoff) => [handoff.name, handoff]));
+        if (!this.#worktrees)
+            return [...handoffs.values()];
+        for (const [name, tracked] of record.agents) {
+            const worktree = this.#agentWorktree(record, tracked.spec);
+            if (!worktree)
+                continue;
+            const existing = handoffs.get(name);
+            handoffs.set(name, {
+                issue: record.issue,
+                name,
+                tracked: cloneTrackedAgent(tracked),
+                persistedAtMs: existing?.persistedAtMs ?? this.#clock.now(),
+                worktree,
+            });
+        }
+        return [...handoffs.values()];
+    }
+    async #teardownFailedDispatchWorktrees(handoffs) {
+        if (!this.#worktrees || !handoffs.some((handoff) => handoff.worktree))
+            return false;
+        const failed = await this.#releaseAndTerminateAgents(handoffs.map((handoff) => [handoff.name, handoff.tracked]), 'dispatch failed', 'completion');
+        if (failed.length > 0)
+            return false;
+        try {
+            await this.#cleanupFailureHandoffWorktrees(handoffs);
+            for (const handoff of handoffs) {
+                await this.#state.clearFailureHandoff(this.#workspaceId, registryHandoffKey(handoff.issue, handoff.name));
+            }
+            return true;
+        }
+        catch (error) {
+            // Keep the durable handoffs. The loop reaper will retry cleanup only
+            // after it has reconfirmed every agent sharing the checkout is gone.
+            this.#increment('agentWorktreeCleanupFailures');
+            this.#logger.warn?.('[factory] retained dispatch-failure handoffs after worktree cleanup failed', {
+                issue: handoffs[0]?.issue,
+                error: describeError(error).errorMessage,
+            });
+            return false;
+        }
+    }
+    async #cleanupFailureHandoffWorktrees(handoffs) {
+        if (!this.#worktrees)
+            return;
+        const unique = new Map();
+        for (const handoff of handoffs) {
+            if (handoff.worktree)
+                unique.set(handoff.worktree.worktreePath, handoff.worktree);
+        }
+        for (const worktree of unique.values()) {
+            await this.#worktrees.cleanup(worktree);
+            this.#increment('agentWorktreesCleaned');
+        }
+    }
     async #writeInFlightRegistry(path = this.#config.loop.registryPath, heartbeatPath = this.#config.loop.heartbeatPath, empty = false) {
         const updatedAtMs = this.#clock.now();
         const agents = [];
@@ -2844,6 +3210,7 @@ export class FactoryLoop {
             }
             return { name: spec.name };
         }
+        await this.#prepareAgentWorktree(record, spec);
         let result;
         try {
             result = await this.#fleet.spawn({
@@ -3061,6 +3428,7 @@ export class FactoryLoop {
             else {
                 const invocationId = `${batch.invocationIdFor(record.issue, tracked.spec)}:restart:${this.#clock.now()}`;
                 try {
+                    await this.#prepareAgentWorktree(record, tracked.spec);
                     const result = await this.#fleet.spawn({
                         name: tracked.spec.name,
                         capability: tracked.spec.capability,
@@ -3190,6 +3558,66 @@ export class FactoryLoop {
         });
         return result;
     }
+    async #prepareAgentWorktree(record, spec) {
+        const worktree = this.#agentWorktree(record, spec);
+        if (!worktree || !this.#worktrees)
+            return;
+        try {
+            await this.#worktrees.prepare(worktree);
+            this.#increment('agentWorktreesPrepared');
+        }
+        catch (error) {
+            throw contextualError(`Unable to prepare isolated worktree for ${record.issue.key}/${spec.repo} at ${worktree.worktreePath}`, error);
+        }
+    }
+    #agentWorktree(record, spec) {
+        if (!spec.baseClonePath || !spec.clonePath || spec.baseClonePath === spec.clonePath)
+            return undefined;
+        const implementer = record.decision.implementers.find((candidate) => candidate.repo === spec.repo && candidate.branch)
+            ?? [...record.agents.values()]
+                .map((tracked) => tracked.spec)
+                .find((candidate) => candidate.repo === spec.repo && candidate.role === 'implementer' && candidate.branch);
+        const branch = spec.branch ?? implementer?.branch;
+        if (!branch)
+            return undefined;
+        return {
+            repo: spec.repo,
+            issueKey: record.issue.key,
+            baseClonePath: spec.baseClonePath,
+            worktreePath: spec.clonePath,
+            branch,
+        };
+    }
+    async #cleanupAgentWorktrees(record) {
+        if (!this.#worktrees)
+            return;
+        const unique = new Map();
+        for (const tracked of record.agents.values()) {
+            const worktree = this.#agentWorktree(record, tracked.spec);
+            if (worktree)
+                unique.set(worktree.worktreePath, worktree);
+        }
+        const failures = [];
+        for (const worktree of unique.values()) {
+            try {
+                await this.#worktrees.cleanup(worktree);
+                this.#increment('agentWorktreesCleaned');
+            }
+            catch (error) {
+                failures.push(`${worktree.worktreePath}: ${describeError(error).errorMessage}`);
+                this.#increment('agentWorktreeCleanupFailures');
+                this.#logger.warn?.('[factory] failed to clean completed issue worktree', {
+                    issue: record.issue.key,
+                    repo: worktree.repo,
+                    worktreePath: worktree.worktreePath,
+                    error: describeError(error).errorMessage,
+                });
+            }
+        }
+        if (failures.length > 0) {
+            throw new Error(`Factory worktree cleanup incomplete for ${record.issue.key}: ${failures.join('; ')}`);
+        }
+    }
     async #confirmPublishedRemotePullRequest(repo, result, expectedHeadRef) {
         const parts = githubRepoParts(repo);
         if (!parts)
@@ -3377,6 +3805,7 @@ export class FactoryLoop {
         if (!tracked.sessionRef) {
             return;
         }
+        await this.#prepareAgentWorktree(record, tracked.spec);
         const result = await this.#fleet.resume({
             name,
             sessionRef: tracked.sessionRef,
@@ -3619,7 +4048,7 @@ export class FactoryLoop {
         catch {
             // The initiator logs Slack watcher startup failures.
         }
-        const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
+        const threadId = await this.#persistedSlackThread(key);
         if (!threadId) {
             this.#increment('agentQuestionsSkippedMissingThread');
             this.#logger.warn?.('[factory] agent question has no Slack dispatch thread', {
@@ -3847,7 +4276,7 @@ export class FactoryLoop {
             return undefined;
         }
         const key = issueKey(record.issue);
-        const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
+        const threadId = await this.#persistedSlackThread(key);
         if (!threadId) {
             this.#increment('agentQuestionReleaseSkippedMissingThread');
             return undefined;
@@ -3900,7 +4329,7 @@ export class FactoryLoop {
             issue: { ...record.issue },
             decision: structuredClone(record.decision),
             dryRun: record.dryRun,
-            threadId: await this.#state.getSlackThread(this.#workspaceId, key),
+            threadId: await this.#persistedSlackThread(key),
             questionSource: 'github',
             askerName: question.agentName,
             question: question.question,
@@ -3926,7 +4355,7 @@ export class FactoryLoop {
             this.#increment('agentQuestionSlackMirrorsSkippedDegraded');
             return;
         }
-        const threadId = await this.#state.getSlackThread(this.#workspaceId, issueKey(record.issue));
+        const threadId = await this.#persistedSlackThread(issueKey(record.issue));
         if (!threadId) {
             this.#increment('agentQuestionSlackMirrorsSkippedMissingThread');
             return;
@@ -4041,7 +4470,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`
@@ -4537,7 +4966,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');
@@ -4701,7 +5130,8 @@ export class FactoryLoop {
                 implementerNames,
                 integrationsMountRoot: this.#integrationsMountRoot(),
                 integrationInstructions,
-                branchName: spec.branch,
+                branchName: spec.branch ?? decision.implementers.find((candidate) => candidate.repo === spec.repo)?.branch,
+                branchPrepared: Boolean(spec.baseClonePath && spec.clonePath && spec.baseClonePath !== spec.clonePath),
                 agentName: spec.name,
             }),
         });
@@ -5483,7 +5913,20 @@ export class FactoryLoop {
             }
             const route = record.decision.routes.find((candidate) => candidate.repo === prRef.repo)
                 ?? record.decision.routes[0];
-            const spec = babysitterSpec(issue, this.#config, route);
+            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.branch)?.branch;
+            const spec = sharedCheckout
+                ? {
+                    ...initialSpec,
+                    baseClonePath: sharedCheckout.baseClonePath,
+                    clonePath: sharedCheckout.clonePath,
+                    ...(implementerBranch ? { branch: implementerBranch } : {}),
+                }
+                : initialSpec;
             const reviewer = [...record.agents.values()].find((agent) => agent.spec.role === 'reviewer');
             const reviewerName = reviewer?.result?.name ?? reviewer?.spec.name
                 ?? agentNameForRole(issue, 'review', { repo: route?.repo ?? prRef.repo });
@@ -5493,7 +5936,7 @@ export class FactoryLoop {
             const integrationInstructions = await this.#resolveIntegrationInstructions();
             const task = renderAgentTask({
                 issue: templateIssueFromRecord(record, issue),
-                route: route ?? { repo: prRef.repo },
+                route: { ...(route ?? { repo: prRef.repo }), clonePath: spec.clonePath },
                 role: 'babysitter',
                 config: { mergePolicy: this.#config.mergePolicy, terminalState: this.#config.terminalState },
                 reviewerName,
@@ -5502,6 +5945,8 @@ export class FactoryLoop {
                 slackDispatchThread: await this.#slackDispatchThreadFor(record),
                 integrationsMountRoot: this.#integrationsMountRoot(),
                 integrationInstructions,
+                branchName: spec.branch,
+                branchPrepared: Boolean(spec.baseClonePath && spec.clonePath && spec.baseClonePath !== spec.clonePath),
                 agentName: spec.name,
             });
             const spawned = await this.#spawnAgent(record, {
@@ -5670,6 +6115,7 @@ export class FactoryLoop {
             return;
         }
         this.#completionInFlight.add(completionKey);
+        let releaseReasonForRetry;
         try {
             if (!await this.#assertDispatchLifecycleOwner(record))
                 return;
@@ -5755,6 +6201,7 @@ export class FactoryLoop {
                 await this.#runCompletionMergeGate(issue);
             }
             const releaseReason = humanReview ? 'issue-human-review' : 'issue-done';
+            releaseReasonForRetry = releaseReason;
             if (this.#fleet.placementLocality === 'remote') {
                 // Durable capacity is released as soon as terminal writeback is
                 // acknowledged. Agent cleanup remains fenced/retryable in `releasing`.
@@ -5771,7 +6218,10 @@ export class FactoryLoop {
         }
         catch (error) {
             this.#error(error, record.issue);
-            this.#scheduleDispatchLifecycleRetry(record);
+            if (releaseReasonForRetry)
+                this.#scheduleReleaseRetry(record, releaseReasonForRetry);
+            else
+                this.#scheduleDispatchLifecycleRetry(record);
         }
         finally {
             this.#completionInFlight.delete(completionKey);
@@ -6025,6 +6475,19 @@ export class FactoryLoop {
         this.#lastObservedSlackEventAtMs = this.#clock.now();
         this.#increment('slackWebhookEventsObserved');
     }
+    async #persistedSlackThread(key) {
+        const threadId = await this.#state.getSlackThread(this.#workspaceId, key);
+        if (!threadId || /^\d+[._]\d+$/u.test(threadId))
+            return threadId;
+        // Older Factory versions persisted the Relayfile draft client id when the
+        // acknowledged file had not yet reconciled its provider payload. Slack
+        // cannot use that value as thread_ts. Drop it so the caller establishes a
+        // fresh provider-backed root instead of producing invalid_thread_ts.
+        await this.#state.clearSlackThread(this.#workspaceId, key);
+        this.#increment('invalidSlackThreadsCleared');
+        this.#logger.warn?.('[factory] cleared invalid persisted Slack thread id', { issue: key });
+        return undefined;
+    }
     async #ensureSlackDispatchThread(record, result) {
         if (!this.#slack || !this.#config.slack || result.dryRun) {
             return;
@@ -6033,7 +6496,7 @@ export class FactoryLoop {
             return;
         }
         const key = issueKey(record.issue);
-        const existingThread = await this.#state.getSlackThread(this.#workspaceId, key);
+        const existingThread = await this.#persistedSlackThread(key);
         const watcherStart = this.#slackWatcherStarts.get(key);
         if (existingThread || watcherStart) {
             try {
@@ -6086,6 +6549,16 @@ export class FactoryLoop {
         if (dryRun) {
             return;
         }
+        // A source GitHub issue is the durable stakeholder record. Keep both the
+        // question and authorized response there, then mirror the escalation once
+        // to Slack for stakeholder visibility without making Slack a competing
+        // clarification workflow.
+        const sourceIssue = await this.#readIssue(decision.issue.path);
+        if (sourceIssue && githubIssueSourceRef(sourceIssue)) {
+            const result = await this.#escalateTriageToGithub(decision, reason);
+            await this.#mirrorGithubTriageEscalationToSlack(decision, sourceIssue, reason);
+            return result;
+        }
         if (!this.#slack || !this.#config.slack) {
             return await this.#escalateTriageToGithub(decision, reason);
         }
@@ -6093,7 +6566,7 @@ export class FactoryLoop {
             return;
         }
         const key = issueKey(decision.issue);
-        const existingThread = await this.#state.getSlackThread(this.#workspaceId, key);
+        const existingThread = await this.#persistedSlackThread(key);
         const watcherStart = this.#slackWatcherStarts.get(key);
         if (existingThread || watcherStart) {
             try {
@@ -6130,7 +6603,7 @@ export class FactoryLoop {
         const correlationId = githubEscalationCorrelationId('triage', decision.issue, question);
         const issue = await this.#readIssue(decision.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('triage', decision.issue, correlationId, 'no Slack channel or GitHub issue write path with an identifiable issue reporter is available');
             return;
@@ -6146,7 +6619,7 @@ export class FactoryLoop {
         }
         try {
             await this.#githubWriteback.postComment(issue, [
-                `Factory needs clarification before dispatching ${decision.issue.key}.`,
+                `@${authorizedAuthor}, Factory needs clarification before dispatching ${decision.issue.key}.`,
                 `Reason: ${reason}`,
                 `Question: ${question}`,
                 `Authorized responder: @${authorizedAuthor} (the issue reporter).`,
@@ -6161,15 +6634,119 @@ export class FactoryLoop {
             this.#surfaceEscalationDeliveryFailure('triage', decision.issue, correlationId, 'GitHub issue comment writeback failed', error);
         }
     }
+    async #mirrorGithubTriageEscalationToSlack(decision, issue, reason) {
+        if (!this.#slack || !this.#config.slack)
+            return;
+        if (await this.#shouldSkipSlackWriteback('triage-escalation-mirror')) {
+            this.#increment('triageEscalationSlackMirrorsSkippedDegraded');
+            return;
+        }
+        const key = issueKey(decision.issue);
+        const existingThread = await this.#persistedSlackThread(key);
+        const inFlight = this.#slackWatcherStarts.get(key);
+        if (existingThread || inFlight) {
+            if (inFlight) {
+                try {
+                    await inFlight;
+                }
+                catch {
+                    // The initiator records the optional mirror failure.
+                }
+            }
+            this.#increment('triageEscalationSlackMirrorDuplicatesSuppressed');
+            return;
+        }
+        const start = this.#postGithubTriageSlackMirror(decision, issue, reason);
+        this.#slackWatcherStarts.set(key, start);
+        try {
+            await start;
+        }
+        catch (error) {
+            this.#markSlackWritebackFailure('triage-escalation-mirror', error);
+            this.#increment('triageEscalationSlackMirrorFailures');
+            this.#logger.warn?.('[factory] optional GitHub triage Slack mirror failed', {
+                issue: decision.issue.key,
+                error: describeError(error).errorMessage,
+            });
+        }
+        finally {
+            this.#slackWatcherStarts.delete(key);
+        }
+    }
+    async #postGithubTriageSlackMirror(decision, issue, reason) {
+        if (!this.#slack || !this.#config.slack)
+            return;
+        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]
+            .filter((part) => Boolean(part))
+            .join(' ');
+        const replyInstruction = source?.url
+            ? `Reply on the GitHub issue so Factory can resume: ${source.url}`
+            : 'Reply on the source GitHub issue so Factory can resume.';
+        const root = await this.#slack.postThread({
+            channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
+            text: [
+                `${audience ? `${audience} ` : ''}${decision.issue.key}: factory triage escalation for ${issue.title}`,
+                `Reason: ${reason}`,
+                `Question: ${triageEscalationQuestion(decision)} ${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 #postAndWatchSlackEscalationThread(decision, reason) {
         if (!this.#slack || !this.#config.slack) {
             return;
         }
         const issue = await this.#readIssue(decision.issue.path);
+        const stakeholderMentions = slackMentions(this.#config.slack.stakeholderUserIds);
         const root = await this.#slack.postThread({
             channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
             text: [
-                `${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
+                `${stakeholderMentions ? `${stakeholderMentions} ` : ''}${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
                 `Reason: ${reason}`,
                 `Question: ${triageEscalationQuestion(decision)}`,
             ].join('\n'),
@@ -6362,7 +6939,7 @@ export class FactoryLoop {
             }
             let threadId;
             try {
-                threadId = await this.#state.getSlackThread(this.#workspaceId, key);
+                threadId = await this.#persistedSlackThread(key);
             }
             catch (error) {
                 this.#logger.warn?.('[factory] unable to read persisted Slack thread during watcher rehydration', { issue: record.issue.key, error });
@@ -6857,6 +7434,7 @@ export class FactoryLoop {
     }
     async #resumeOrColdStartClarificationAgent(name, tracked, waiting) {
         const task = clarificationResumeTask(tracked.spec.task, waiting);
+        await this.#prepareAgentWorktree(waitingRecord(waiting), tracked.spec);
         if (tracked.sessionRef) {
             try {
                 const resumed = await this.#fleet.resume({
@@ -7066,7 +7644,7 @@ export class FactoryLoop {
         if (!this.#config.slack) {
             return undefined;
         }
-        const threadId = await this.#state.getSlackThread(this.#workspaceId, issueKey(record.issue));
+        const threadId = await this.#persistedSlackThread(issueKey(record.issue));
         const channel = await this.#slackChannelDir() ?? this.#config.slack.channel;
         return threadId
             ? { channel, threadId, mountRoot: this.#integrationsMountRoot() }
@@ -7607,36 +8185,35 @@ function routeImplementerSpec(issue, config, slug, route) {
         node: 'self',
     };
 }
-function decisionWithLifecycleBranches(decision, runId) {
-    const withBranch = (spec) => {
+function decisionWithLifecycleBranches(decision, runId, opts = {}) {
+    const implementerBranch = (spec) => {
+        const runSuffix = `-${runId.slice(0, 8)}`;
+        const stem = `${sanitizeAgentSlug(decision.issue.key)}-${sanitizeAgentSlug(spec.repo)}`
+            .slice(0, 120 - 'factory/'.length - runSuffix.length);
+        return `factory/${stem}${runSuffix}`;
+    };
+    const branchByRepo = new Map(decision.implementers.map((spec) => [spec.repo, implementerBranch(spec)]));
+    const withBranch = (spec, branch) => {
+        const baseClonePath = spec.baseClonePath ?? spec.clonePath;
+        const clonePath = opts.isolateLocalWorktree && baseClonePath && branch
+            ? factoryWorktreePath(baseClonePath, decision.issue.key, spec.repo, runId)
+            : spec.clonePath;
         const lifecycleSpec = {
             ...spec,
+            ...(opts.isolateLocalWorktree && baseClonePath && branch ? { baseClonePath, clonePath } : {}),
             // The same persisted lifecycle reuses this id after takeover, while a
             // genuine reopen gets a new id and cannot replay an old placement ack.
             invocationId: `factory:${decision.issue.key}:${runId}:${spec.role}:${sanitizeAgentSlug(spec.name)}`,
         };
-        if (spec.role !== 'implementer')
-            return lifecycleSpec;
-        const runSuffix = `-${runId.slice(0, 8)}`;
-        const stem = `${sanitizeAgentSlug(decision.issue.key)}-${sanitizeAgentSlug(spec.repo)}`
-            .slice(0, 120 - 'factory/'.length - runSuffix.length);
-        const branch = `factory/${stem}${runSuffix}`;
-        return {
-            ...lifecycleSpec,
-            branch,
-            task: [
-                spec.task,
-                '',
-                `Factory publication branch: ${branch}`,
-                'Before editing, create or reset that exact branch from the repository default branch. Commit and push only that branch.',
-            ].join('\n'),
-        };
+        return branch ? { ...lifecycleSpec, branch } : lifecycleSpec;
     };
     return {
         ...structuredClone(decision),
-        implementers: decision.implementers.map(withBranch),
-        reviewer: withBranch(decision.reviewer),
-        ...(decision.workflow ? { workflow: withBranch(decision.workflow) } : {}),
+        implementers: decision.implementers.map((spec) => withBranch(spec, branchByRepo.get(spec.repo))),
+        reviewer: withBranch(decision.reviewer, branchByRepo.get(decision.reviewer.repo)),
+        ...(decision.workflow
+            ? { workflow: withBranch(decision.workflow, branchByRepo.get(decision.workflow.repo)) }
+            : {}),
     };
 }
 function routeReviewerSpec(issue, config, route, reviewer) {
@@ -7736,12 +8313,21 @@ function taskForDispatch(issue, route, role) {
         issue.description,
     ].join('\n\n');
 }
-const templateIssueFromRecord = (record, issue) => ({
-    key: issue?.key ?? record.issue.key,
-    title: issue?.title ?? record.issue.key,
-    description: issue?.description ?? '',
-    github: issue ? githubIssueSourceRef(issue) : undefined,
-});
+const templateIssueFromRecord = (record, issue) => {
+    const github = issue ? githubIssueSourceRef(issue) : undefined;
+    const reporter = issue ? githubIssueAuthor(issue) : undefined;
+    return {
+        key: issue?.key ?? record.issue.key,
+        title: issue?.title ?? record.issue.key,
+        description: issue?.description ?? '',
+        github: github
+            ? {
+                ...github,
+                ...(reporter ? { reporter } : {}),
+            }
+            : undefined,
+    };
+};
 const routeForSpec = (decision, spec) => {
     const route = decision.routes.find((candidate) => candidate.repo === spec.repo && candidate.clonePath === spec.clonePath) ?? decision.routes.find((candidate) => candidate.repo === spec.repo);
     return {
@@ -7786,6 +8372,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];
@@ -7945,6 +8551,8 @@ 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;
@@ -7957,6 +8565,7 @@ const resolveIssuePrFromMount = async (mount, config, issue, opts = {}) => {
 };
 const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
     const candidates = [];
+    let lookupFailures = 0;
     for (const repo of reposFromConfig(config)) {
         let payload;
         try {
@@ -7973,26 +8582,33 @@ const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
                 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))
                 continue;
+            if (opts.openOnly && normalizePrState(pr.state) !== 'OPEN')
+                continue;
             const score = issuePrMatchScore(pr, issue, opts.titleMarker ?? config.safety.requireTitlePrefix, opts);
             if (score <= 0)
                 continue;
@@ -8005,9 +8621,13 @@ const resolveIssuePrFromGh = async (run, config, issue, opts = {}, logger) => {
             });
         }
     }
-    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([
@@ -8102,6 +8722,7 @@ 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),
         };
     }
     catch {
@@ -8717,12 +9338,10 @@ const isAgentAlreadyExistsError = (error) => {
     return /already exists/iu.test(message);
 };
 const defaultRestartPolicy = (spec) => 
-// Implementers and babysitters are both long-running and resumable — the
-// babysitter shepherds an open PR over many CI/review cycles, so an abnormal
-// exit should resume its session rather than drop the PR. The reviewer is
-// short-lived and keeps the fleet default.
+// Factory owns durable resume/respawn decisions. Broker-level retries race
+// that lifecycle and can re-register the same name before Factory resumes it.
 spec.role === 'implementer' || spec.role === 'babysitter'
-    ? { maxRestarts: 3, strategy: 'resume' }
+    ? { maxRestarts: 0 }
     : spec.restartPolicy;
 const slackPayloadTs = (threadId) => threadId.replace(/_/g, '.');
 const slackChannelMessagesPrefix = (channelDir) => `/slack/channels/${channelDir}/messages/`;