@agent-relay/factory 0.1.38 → 0.1.39

package/dist/orchestrator/factory.js

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