@agent-relay/factory 0.1.60 → 0.1.62

package/dist/orchestrator/factory.js

@@ -137,6 +137,8 @@ const DISPATCH_LIFECYCLE_RENEW_MS = 60_000;
 const DISPATCH_LIFECYCLE_RETRY_MS = 1_000;
 const DISPATCH_WRITEBACK_MAX_ATTEMPTS = 3;
 const DISPATCH_WRITEBACK_RETRY_MS = 250;
+const HELD_PAST_DEADLINE_RELEASE_REASON = 'held-past-deadline';
+const HELD_DEADLINE_OVERDUE_RETRY_MS = 1_000;
 const STARTUP_AGENT_EXIT_DRAIN_TIMEOUT_MS = 30_000;
 const RECONCILED_AGENT_EXIT_CONCURRENCY = 4;
 const SLACK_EVENT_WATERMARK_CACHE_MS = 60_000;
@@ -152,6 +154,7 @@ const REMOTE_OPERATION_PROGRESS_INTERVAL_MS = 15_000;
 const REMOTE_OPERATION_SLOW_WARN_MS = 30_000;
 const DISCOVERY_SWEEP_LEASE_MS = 5 * 60_000;
 const DISCOVERY_SWEEP_RENEW_MS = 30_000;
+const READINESS_RECONCILE_FAILURE_THRESHOLD = 3;
 const DISCOVERY_CHANGE_EVENT_LIMIT = 1_000;
 const DISCOVERY_OVERLOAD_BACKOFF_MAX_MS = 5 * 60_000;
 const GITHUB_FACTORY_LABEL = 'factory';
@@ -310,6 +313,9 @@ export class FactoryLoop {
     #dispatchClaimStatuses = new Map();
     #localReleaseCheckpoints = new Map();
     #dispatchLifecycleRenewTimer;
+    #heldAgentDeadlineTimer;
+    #heldAgentDeadlineDueAtMs;
+    #heldAgentDeadlineSweepInFlight;
     #clarificationSweepTimer;
     #clarificationSweepDueAtMs;
     #clarificationSweepInFlight;
@@ -341,6 +347,12 @@ export class FactoryLoop {
     #readinessReconcileTimer;
     #readinessReconcileInFlight;
     #readinessReconcileIntervalMs = 60_000;
+    #readinessReconcileConsecutiveFailures = 0;
+    #readinessReconcileLastDurationMs;
+    #readinessReconcileLastStartedAtMs;
+    #readinessReconcileLastCompletedAtMs;
+    #readinessReconcileLastFailureAtMs;
+    #readinessReconcileLastError;
     #liveEventQueue = [];
     #liveEventDrainScheduled = false;
     #liveEventDrainActive = false;
@@ -419,7 +431,9 @@ export class FactoryLoop {
     #runOnceInFlightDryRun;
     #discoverySession;
     #discoverySweepEpoch;
+    #discoverySweepStartedAtMs;
     #discoverySweepRenewTimer;
+    #discoverySweepRenewalInFlight;
     #discoverySweepLeaseLost = false;
     #discoveryOverloadError;
     #resolvedIssueSource;
@@ -785,6 +799,11 @@ export class FactoryLoop {
         if (this.#dispatchLifecycleRenewTimer)
             clearInterval(this.#dispatchLifecycleRenewTimer);
         this.#dispatchLifecycleRenewTimer = undefined;
+        if (this.#heldAgentDeadlineTimer)
+            clearTimeout(this.#heldAgentDeadlineTimer);
+        this.#heldAgentDeadlineTimer = undefined;
+        this.#heldAgentDeadlineDueAtMs = undefined;
+        await this.#heldAgentDeadlineSweepInFlight;
         for (const timer of this.#dispatchLifecycleRetryTimers.values())
             clearTimeout(timer);
         this.#dispatchLifecycleRetryTimers.clear();
@@ -1122,24 +1141,40 @@ export class FactoryLoop {
         this.#readinessReconcileTimer.unref?.();
     }
     async #reconcileReadyIssues() {
+        const startedAtMs = this.#clock.now();
+        this.#readinessReconcileLastStartedAtMs = startedAtMs;
         this.#increment('readinessReconcileSweeps');
         this.#logger.info?.('[factory] periodic readiness reconciliation started', {
             intervalMs: this.#readinessReconcileIntervalMs,
         });
         try {
             const report = await this.runOnce();
+            this.#readinessReconcileConsecutiveFailures = 0;
+            this.#readinessReconcileLastDurationMs = this.#elapsedSince(startedAtMs);
+            this.#readinessReconcileLastCompletedAtMs = this.#clock.now();
+            this.#readinessReconcileLastError = undefined;
             this.#logger.info?.('[factory] periodic readiness reconciliation completed', {
+                durationMs: this.#readinessReconcileLastDurationMs,
                 candidates: report.pulled.length,
                 dispatched: report.dispatched.length,
                 skipped: report.skipped.length,
             });
         }
         catch (error) {
+            const errorMessage = describeError(error).errorMessage;
+            this.#readinessReconcileConsecutiveFailures += 1;
+            this.#readinessReconcileLastDurationMs = this.#elapsedSince(startedAtMs);
+            this.#readinessReconcileLastFailureAtMs = this.#clock.now();
+            this.#readinessReconcileLastError = errorMessage;
             this.#increment('readinessReconcileErrors');
             this.#logger.warn?.('[factory] periodic readiness reconciliation failed; retry remains scheduled', {
-                error: describeError(error).errorMessage,
+                error: errorMessage,
+                durationMs: this.#readinessReconcileLastDurationMs,
+                consecutiveFailures: this.#readinessReconcileConsecutiveFailures,
+                degraded: this.#readinessReconcileConsecutiveFailures >= READINESS_RECONCILE_FAILURE_THRESHOLD,
             });
         }
+        await this.#refreshLiveHeartbeat();
     }
     #scheduleLivePoll(delayMs, options) {
         if (this.#livePollTimer || !this.#started)
@@ -1797,6 +1832,7 @@ export class FactoryLoop {
         }
     }
     async #runOnceWithDiscoveryFence(opts) {
+        const sweepStartedAtMs = this.#clock.now();
         let claim = await this.#state.claimDiscoverySweep(this.#workspaceId, this.#discoverySweepOwner, this.#clock.now(), DISCOVERY_SWEEP_LEASE_MS);
         if (!claim.acquired && claim.reason === 'backoff') {
             const delayMs = Math.max(0, claim.state.backoffUntilMs - this.#clock.now());
@@ -1812,6 +1848,8 @@ export class FactoryLoop {
         if (!claim.acquired || !claim.lease) {
             this.#increment('discoverySweepsSkippedInFlight');
             this.#logger.info?.('[factory] skipped discovery because another process owns the sweep lease', {
+                owner: claim.state.lease?.owner,
+                epoch: claim.state.lease?.epoch,
                 leaseUntilMs: claim.state.lease?.leaseUntilMs,
             });
             return {
@@ -1823,7 +1861,23 @@ export class FactoryLoop {
                 discoveryDeferred: 'sweep-in-flight',
             };
         }
+        if (claim.reclaimedLease) {
+            this.#increment('discoverySweepOrphanTakeovers');
+            this.#logger.warn?.('[factory] reclaimed discovery sweep lease from a stopped process', {
+                owner: claim.lease.owner,
+                epoch: claim.lease.epoch,
+                previousOwner: claim.reclaimedLease.owner,
+                previousEpoch: claim.reclaimedLease.epoch,
+                previousLeaseUntilMs: claim.reclaimedLease.leaseUntilMs,
+            });
+        }
+        this.#logger.info?.('[factory] discovery sweep lease claimed', {
+            owner: claim.lease.owner,
+            epoch: claim.lease.epoch,
+            leaseUntilMs: claim.lease.leaseUntilMs,
+        });
         this.#discoverySweepEpoch = claim.lease.epoch;
+        this.#discoverySweepStartedAtMs = sweepStartedAtMs;
         this.#discoverySweepLeaseLost = false;
         this.#discoveryOverloadError = undefined;
         this.#startDiscoverySweepRenewal(claim.lease.epoch);
@@ -1834,6 +1888,11 @@ export class FactoryLoop {
             if (this.#discoveryOverloadError)
                 throw this.#discoveryOverloadError;
             const checkpoint = await this.#finalizeDiscoveryCheckpoint();
+            // Do not clear the durable lease while a renewal can still be waiting on
+            // the same state-file lock. A late renewal that observes the completed
+            // (lease-less) checkpoint is a false lease-loss signal and can poison an
+            // otherwise successful reconcile cycle.
+            await this.#stopDiscoverySweepRenewal();
             if (this.#discoverySweepLeaseLost) {
                 throw new Error('discovery sweep lease was lost before checkpoint commit');
             }
@@ -1841,9 +1900,16 @@ export class FactoryLoop {
             leaseReleased = completed;
             if (!completed)
                 throw new Error('discovery sweep lease was lost before completion');
+            this.#logger.info?.('[factory] discovery sweep checkpoint committed', {
+                owner: claim.lease.owner,
+                epoch: claim.lease.epoch,
+                durationMs: this.#elapsedSince(sweepStartedAtMs),
+                checkpointUpdatedAtMs: checkpoint?.updatedAtMs,
+            });
             return report;
         }
         catch (error) {
+            await this.#stopDiscoverySweepRenewal();
             const overload = relayfileOverload(error);
             if (overload) {
                 const consecutiveOverloads = claim.state.consecutiveOverloads + 1;
@@ -1868,11 +1934,10 @@ export class FactoryLoop {
             throw error;
         }
         finally {
-            if (this.#discoverySweepRenewTimer)
-                clearInterval(this.#discoverySweepRenewTimer);
-            this.#discoverySweepRenewTimer = undefined;
+            await this.#stopDiscoverySweepRenewal();
             this.#discoverySession = undefined;
             this.#discoverySweepEpoch = undefined;
+            this.#discoverySweepStartedAtMs = undefined;
             this.#discoveryOverloadError = undefined;
             // This sweep is over either way (committed, deferred, or lease lost) —
             // a stale `true` here would otherwise make every #listRelayfileTree
@@ -2080,27 +2145,69 @@ export class FactoryLoop {
         }
     }
     #startDiscoverySweepRenewal(epoch) {
-        let renewalInFlight = false;
         this.#discoverySweepRenewTimer = setInterval(() => {
-            if (renewalInFlight || this.#discoverySweepLeaseLost)
+            if (this.#discoverySweepRenewalInFlight || this.#discoverySweepLeaseLost)
                 return;
-            renewalInFlight = true;
-            void this.#state.renewDiscoverySweep(this.#workspaceId, this.#discoverySweepOwner, epoch, this.#clock.now(), DISCOVERY_SWEEP_LEASE_MS).then((renewed) => {
-                if (!renewed && this.#discoverySweepEpoch === epoch) {
-                    this.#discoverySweepLeaseLost = true;
-                    this.#increment('discoverySweepLeaseLosses');
-                    this.#logger.warn?.('[factory] discovery sweep lease renewal was rejected; fencing further tree requests');
+            const renewal = this.#renewDiscoverySweepLease(epoch);
+            this.#discoverySweepRenewalInFlight = renewal;
+            void renewal.finally(() => {
+                if (this.#discoverySweepRenewalInFlight === renewal) {
+                    this.#discoverySweepRenewalInFlight = undefined;
                 }
-            }).catch((error) => {
-                this.#logger.warn?.('[factory] discovery sweep lease renewal failed; retaining the current lease window', {
-                    error: describeError(error).errorMessage,
-                });
-            }).finally(() => {
-                renewalInFlight = false;
             });
         }, DISCOVERY_SWEEP_RENEW_MS);
         this.#discoverySweepRenewTimer.unref?.();
     }
+    async #renewDiscoverySweepLease(epoch) {
+        const requestedAtMs = this.#clock.now();
+        try {
+            let renewal;
+            if (this.#state.renewDiscoverySweepWithDetails) {
+                renewal = await this.#state.renewDiscoverySweepWithDetails(this.#workspaceId, this.#discoverySweepOwner, epoch, requestedAtMs, DISCOVERY_SWEEP_LEASE_MS);
+            }
+            else {
+                const renewed = await this.#state.renewDiscoverySweep(this.#workspaceId, this.#discoverySweepOwner, epoch, requestedAtMs, DISCOVERY_SWEEP_LEASE_MS);
+                renewal = renewed
+                    ? {
+                        renewed: true,
+                        lease: {
+                            owner: this.#discoverySweepOwner,
+                            epoch,
+                            leaseUntilMs: requestedAtMs + DISCOVERY_SWEEP_LEASE_MS,
+                        },
+                    }
+                    : { renewed: false, reason: 'unknown' };
+            }
+            if (!renewal.renewed && this.#discoverySweepEpoch === epoch) {
+                this.#discoverySweepLeaseLost = true;
+                this.#increment('discoverySweepLeaseLosses');
+                this.#logger.warn?.('[factory] discovery sweep lease renewal was rejected; fencing further tree requests', {
+                    reason: renewal.reason,
+                    requestedOwner: this.#discoverySweepOwner,
+                    requestedEpoch: epoch,
+                    requestedAtMs,
+                    elapsedMs: this.#elapsedSince(this.#discoverySweepStartedAtMs ?? requestedAtMs),
+                    observedOwner: renewal.observedLease?.owner,
+                    observedEpoch: renewal.observedLease?.epoch,
+                    observedLeaseUntilMs: renewal.observedLease?.leaseUntilMs,
+                });
+            }
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] discovery sweep lease renewal failed; retaining the current lease window', {
+                owner: this.#discoverySweepOwner,
+                epoch,
+                requestedAtMs,
+                error: describeError(error).errorMessage,
+            });
+        }
+    }
+    async #stopDiscoverySweepRenewal() {
+        if (this.#discoverySweepRenewTimer)
+            clearInterval(this.#discoverySweepRenewTimer);
+        this.#discoverySweepRenewTimer = undefined;
+        await this.#discoverySweepRenewalInFlight;
+    }
     async #prepareDiscoverySession(claim) {
         const checkpoint = structuredClone(claim.state.checkpoint ?? {
             trees: {},
@@ -3282,7 +3389,7 @@ export class FactoryLoop {
                 await this.#notifyTicketDispatch(dispatchDecision, liveIssue, record, result);
             }
             if (!dryRun) {
-                await this.#ensureSlackDispatchThread(record, result);
+                await this.#ensureSlackDispatchThread(record, result, liveIssue);
             }
             return result;
         }
@@ -3375,6 +3482,7 @@ export class FactoryLoop {
     }
     status() {
         const batch = this.#batchView;
+        const nowMs = this.#clock.now();
         const inFlightDispatches = batch?.inFlight
             .filter((record) => !record.dryRun)
             .map((record) => ({
@@ -3389,7 +3497,7 @@ export class FactoryLoop {
             claim: {
                 ...(record.dispatchClaim ?? this.#dispatchClaimStatuses.get(issueKey(record.issue)) ?? {
                     state: 'pending',
-                    updatedAtMs: this.#clock.now(),
+                    updatedAtMs: nowMs,
                 }),
             },
         })) ?? [];
@@ -3407,6 +3515,8 @@ export class FactoryLoop {
             slackDegraded: this.#slackDegraded,
             slackDegradedReason: this.#slackDegradedReason,
             eventListener: this.#eventListenerStatus(),
+            readinessReconcile: this.#readinessReconcileStatus(),
+            heldAgents: batch?.inFlight.flatMap((record) => heldAgentsForRecord(record, nowMs, this.#config.dispatch.agentHoldTimeoutMs, this.#config.terminalState)) ?? [],
         };
     }
     #eventListenerStatus() {
@@ -3427,6 +3537,34 @@ export class FactoryLoop {
         }
         return { state: 'starting' };
     }
+    #readinessReconcileStatus() {
+        const consecutiveFailures = this.#readinessReconcileConsecutiveFailures;
+        const state = this.#startMode !== 'live'
+            ? 'not-running'
+            : consecutiveFailures >= READINESS_RECONCILE_FAILURE_THRESHOLD
+                ? 'degraded'
+                : consecutiveFailures > 0
+                    ? 'retrying'
+                    : 'healthy';
+        return {
+            state,
+            consecutiveFailures,
+            failureThreshold: READINESS_RECONCILE_FAILURE_THRESHOLD,
+            ...(this.#readinessReconcileLastDurationMs !== undefined
+                ? { lastDurationMs: this.#readinessReconcileLastDurationMs }
+                : {}),
+            ...(this.#readinessReconcileLastStartedAtMs !== undefined
+                ? { lastStartedAtMs: this.#readinessReconcileLastStartedAtMs }
+                : {}),
+            ...(this.#readinessReconcileLastCompletedAtMs !== undefined
+                ? { lastCompletedAtMs: this.#readinessReconcileLastCompletedAtMs }
+                : {}),
+            ...(this.#readinessReconcileLastFailureAtMs !== undefined
+                ? { lastFailureAtMs: this.#readinessReconcileLastFailureAtMs }
+                : {}),
+            ...(this.#readinessReconcileLastError ? { lastError: this.#readinessReconcileLastError } : {}),
+        };
+    }
     on(event, listener) {
         let listeners = this.#listeners.get(event);
         if (!listeners) {
@@ -3687,6 +3825,7 @@ export class FactoryLoop {
                     });
                 }
             }
+            this.#rescheduleHeldAgentDeadlineSweep();
         }
         catch (error) {
             this.#logger.warn?.('[factory] failed to re-adopt durable in-flight agents', { error });
@@ -3799,6 +3938,93 @@ export class FactoryLoop {
         }, DISPATCH_LIFECYCLE_RENEW_MS);
         this.#dispatchLifecycleRenewTimer.unref?.();
     }
+    #scheduleHeldAgentDeadline(record) {
+        if (this.#stopping || record.dryRun || record.heldSinceAtMs === undefined || record.agents.size === 0)
+            return;
+        const dueAtMs = record.heldSinceAtMs + this.#config.dispatch.agentHoldTimeoutMs;
+        if (this.#heldAgentDeadlineTimer &&
+            this.#heldAgentDeadlineDueAtMs !== undefined &&
+            this.#heldAgentDeadlineDueAtMs <= dueAtMs)
+            return;
+        if (this.#heldAgentDeadlineTimer)
+            clearTimeout(this.#heldAgentDeadlineTimer);
+        this.#heldAgentDeadlineDueAtMs = dueAtMs;
+        const remainingMs = dueAtMs - this.#clock.now();
+        // An overdue lifecycle can temporarily be fenced by another owner. Avoid
+        // a zero-delay reschedule loop while its lease is being reclaimed.
+        const delayMs = remainingMs <= 0
+            ? HELD_DEADLINE_OVERDUE_RETRY_MS
+            : Math.min(remainingMs, 2_147_483_647);
+        this.#heldAgentDeadlineTimer = setTimeout(() => {
+            this.#heldAgentDeadlineTimer = undefined;
+            this.#heldAgentDeadlineDueAtMs = undefined;
+            const sweep = this.#sweepHeldAgentDeadlines()
+                .catch((error) => {
+                this.#logger.warn?.('[factory] held-agent deadline sweep failed; retrying', {
+                    error: describeError(error).errorMessage,
+                });
+            })
+                .finally(() => {
+                if (this.#heldAgentDeadlineSweepInFlight === sweep)
+                    this.#heldAgentDeadlineSweepInFlight = undefined;
+                this.#rescheduleHeldAgentDeadlineSweep();
+            });
+            this.#heldAgentDeadlineSweepInFlight = sweep;
+        }, delayMs);
+        this.#heldAgentDeadlineTimer.unref?.();
+    }
+    #rescheduleHeldAgentDeadlineSweep() {
+        if (this.#stopping)
+            return;
+        for (const record of this.#batchView?.inFlight ?? [])
+            this.#scheduleHeldAgentDeadline(record);
+    }
+    async #sweepHeldAgentDeadlines() {
+        const nowMs = this.#clock.now();
+        const timeoutMs = this.#config.dispatch.agentHoldTimeoutMs;
+        for (const record of [...(await this.#batch()).inFlight]) {
+            const heldSinceAtMs = record.heldSinceAtMs;
+            if (record.dryRun ||
+                heldSinceAtMs === undefined ||
+                record.agents.size === 0 ||
+                nowMs - heldSinceAtMs < timeoutMs)
+                continue;
+            const key = issueKey(record.issue);
+            if (this.#abandonedDispatchReasons.has(key))
+                continue;
+            if (this.#usesDurableDispatchLifecycle()) {
+                const lifecycle = await this.#state.getDispatchLifecycle(this.#workspaceId, key);
+                if (!lifecycle || isTerminalDispatchLifecycle(lifecycle))
+                    continue;
+                // Terminal writeback already won the race. Finish its normal release
+                // reason instead of relabeling an acknowledged completion as a timeout.
+                if (lifecycle.phase === 'releasing') {
+                    await this.#finishDurableRelease(record, lifecycle.releaseReason);
+                    continue;
+                }
+                if (!await this.#assertDispatchLifecycleOwner(record))
+                    continue;
+            }
+            const heldForMs = Math.max(0, this.#clock.now() - heldSinceAtMs);
+            const details = {
+                issue: record.issue.key,
+                heldForMs,
+                holdTimeoutMs: timeoutMs,
+                waitingForTerminalState: this.#config.terminalState,
+                reason: HELD_PAST_DEADLINE_RELEASE_REASON,
+                agents: [...record.agents.keys()].sort(),
+            };
+            this.#logger.warn?.('[factory] releasing agents held past deadline', details);
+            await this.#abandonStuckDispatch(record, HELD_PAST_DEADLINE_RELEASE_REASON);
+            const lifecycle = this.#usesDurableDispatchLifecycle()
+                ? await this.#state.getDispatchLifecycle(this.#workspaceId, key)
+                : undefined;
+            if (!lifecycle || isTerminalDispatchLifecycle(lifecycle)) {
+                this.#increment('heldPastDeadlineReleases');
+                this.#logger.warn?.('[factory] released agents held past deadline', details);
+            }
+        }
+    }
     async #renewDispatchLifecycles() {
         for (const [key, epoch] of [...this.#dispatchLifecycleEpochs]) {
             const renewed = await this.#state.renewDispatchLifecycle(this.#workspaceId, key, this.#dispatchLifecycleOwner, epoch, this.#clock.now(), DISPATCH_LIFECYCLE_LEASE_MS);
@@ -4164,6 +4390,7 @@ export class FactoryLoop {
         });
     }
     async #saveDispatchLifecycle(record, phase, pullRequest, releaseReason, releasedAgentNames = new Set(), telemetry = {}) {
+        record.lifecyclePhase = phase;
         if (record.dryRun || !this.#usesDurableDispatchLifecycle())
             return true;
         if (isTerminalDispatchPhase(phase))
@@ -4367,6 +4594,7 @@ export class FactoryLoop {
         const batch = await this.#batch();
         const durableRecord = inFlightRecordFromLifecycle(lifecycle);
         const record = lifecycle.phase === 'releasing' ? durableRecord : batch.restore(durableRecord);
+        this.#scheduleHeldAgentDeadline(record);
         if (!await this.#assertDispatchLifecycleOwner(record))
             return;
         if (acquiredNow && this.#config.babysitter.enabled)
@@ -5790,6 +6018,7 @@ export class FactoryLoop {
             updatedAtMs,
             registryPath,
             eventListener: this.#eventListenerStatus(),
+            readinessReconcile: this.#readinessReconcileStatus(),
         };
         await mkdir(dirname(path), { recursive: true });
         await writeFile(path, `${JSON.stringify(heartbeat, null, 2)}\n`, 'utf8');
@@ -6214,7 +6443,7 @@ export class FactoryLoop {
         const updatedAtMs = this.#clock.now();
         const agents = [];
         const seenAgents = new Set();
-        const appendAgent = async (issue, agentName, tracked) => {
+        const appendAgent = async (issue, agentName, tracked, hold) => {
             const key = registryHandoffKey(issue, agentName);
             if (seenAgents.has(key)) {
                 return;
@@ -6240,6 +6469,12 @@ export class FactoryLoop {
                 ...(fleetTracked?.invocationId ? { invocationId: fleetTracked.invocationId } : {}),
                 ...(fleetTracked?.node ? { node: fleetTracked.node } : {}),
                 ...(dispatchClaim ? { dispatchClaim: { ...dispatchClaim } } : {}),
+                ...(hold?.heldSinceAtMs !== undefined ? {
+                    heldSinceAtMs: hold.heldSinceAtMs,
+                    holdDeadlineAtMs: hold.heldSinceAtMs + this.#config.dispatch.agentHoldTimeoutMs,
+                    waitingForTerminalState: this.#config.terminalState,
+                    ...(hold.lifecyclePhase ? { lifecyclePhase: hold.lifecyclePhase } : {}),
+                } : {}),
             });
         };
         if (!empty) {
@@ -6250,7 +6485,7 @@ export class FactoryLoop {
                     this.#dispatchClaimStatuses.set(issueKey(record.issue), record.dispatchClaim);
                 }
                 for (const [agentName, tracked] of record.agents) {
-                    await appendAgent(record.issue, agentName, tracked);
+                    await appendAgent(record.issue, agentName, tracked, record);
                 }
             }
         }
@@ -6272,6 +6507,7 @@ export class FactoryLoop {
         const invocationId = batch.invocationIdFor(record.issue, spec);
         const existing = record.agents.get(spec.name);
         if (existing?.result) {
+            this.#scheduleHeldAgentDeadline(record);
             return { name: existing.result?.name ?? spec.name };
         }
         if (!batch.shouldSpawn(record, invocationId)) {
@@ -6298,6 +6534,7 @@ export class FactoryLoop {
         const rosterAgent = roster.agents.find((agent) => agent.name === spec.name);
         if (rosterAgent) {
             const trackedPlacement = this.#fleet.trackedAgents?.().get(spec.name);
+            record.heldSinceAtMs ??= this.#clock.now();
             batch.recordSpawn(record, spec, invocationId, {
                 name: spec.name,
                 sessionRef: existing?.sessionRef ?? spec.sessionRef,
@@ -6307,6 +6544,7 @@ export class FactoryLoop {
             if (!await this.#saveDispatchLifecycle(record, 'dispatching')) {
                 throw new Error(`Dispatch lifecycle ownership lost after adopting ${spec.name}`);
             }
+            this.#scheduleHeldAgentDeadline(record);
             const adopted = record.agents.get(spec.name);
             if (adopted)
                 await this.#reportAgent(record, adopted, 'agent.adopted');
@@ -6339,10 +6577,12 @@ export class FactoryLoop {
                     : 'agent_spawn_failed',
             });
         }
+        record.heldSinceAtMs ??= this.#clock.now();
         batch.recordSpawn(record, spec, invocationId, result);
         if (!await this.#saveDispatchLifecycle(record, 'dispatching')) {
             throw new Error(`Dispatch lifecycle ownership lost after spawning ${spec.name}`);
         }
+        this.#scheduleHeldAgentDeadline(record);
         const spawned = record.agents.get(result.name);
         if (spawned)
             await this.#reportAgent(record, spawned, 'agent.spawned');
@@ -7301,7 +7541,10 @@ export class FactoryLoop {
         try {
             const thread = await this.#slackDispatchThreadFor(record);
             if (thread && this.#slack) {
-                await this.#slack.reply(thread.threadId, `:warning: ${record.issue.key}: the implementer exited without opening a PR (after a retry). It needs a human look.`);
+                const issue = await this.#readIssue(record.issue.path);
+                if (!issue)
+                    return;
+                await this.#slack.reply(thread.threadId, `:warning: ${slackIssueSubject(issue, slackNotificationRepos(record.decision))}\nThe implementer exited without opening a PR after a retry; this needs a human look.`);
             }
         }
         catch (error) {
@@ -7362,6 +7605,8 @@ export class FactoryLoop {
     // record leaves the batch.
     async #abandonStuckDispatch(record, reason) {
         const key = issueKey(record.issue);
+        const heldPastDeadline = reason === HELD_PAST_DEADLINE_RELEASE_REASON;
+        const agentReleaseReason = heldPastDeadline ? HELD_PAST_DEADLINE_RELEASE_REASON : 'issue-abandoned';
         this.#abandonedDispatchReasons.set(key, reason);
         if (!await this.#saveDispatchLifecycle(record, 'abandoning', undefined, reason, new Set(), { cancellationReason: 'dispatch_failed' })) {
             this.#increment('abandonedDispatchReleaseRetries');
@@ -7387,9 +7632,9 @@ export class FactoryLoop {
         }
         const agents = [...record.agents];
         for (const [agentName, tracked] of agents) {
-            if (tracked.spec.role === 'implementer')
+            if (!heldPastDeadline && tracked.spec.role === 'implementer')
                 continue;
-            this.#fleet.markAgentTerminal?.(agentName, `implementer-terminal:${reason}`);
+            this.#fleet.markAgentTerminal?.(agentName, heldPastDeadline ? HELD_PAST_DEADLINE_RELEASE_REASON : `implementer-terminal:${reason}`);
         }
         const worktreeHandoffs = this.#dispatchFailureHandoffs(record, []);
         let cleanupComplete = true;
@@ -7402,13 +7647,13 @@ export class FactoryLoop {
             const worktreeAgentNames = new Set(worktreeHandoffs.map((handoff) => handoff.name));
             const nonWorktreeAgents = agents.filter(([name]) => !worktreeAgentNames.has(name));
             if (nonWorktreeAgents.length > 0) {
-                const failed = await this.#releaseAndTerminateAgents(nonWorktreeAgents, 'issue-abandoned', 'completion');
+                const failed = await this.#releaseAndTerminateAgents(nonWorktreeAgents, agentReleaseReason, 'completion');
                 cleanupComplete = failed.length === 0;
             }
-            cleanupComplete = await this.#teardownFailedDispatchWorktrees(worktreeHandoffs) && cleanupComplete;
+            cleanupComplete = await this.#teardownFailedDispatchWorktrees(worktreeHandoffs, agentReleaseReason) && cleanupComplete;
         }
         else if (agents.length > 0) {
-            const failed = await this.#releaseAndTerminateAgents(agents, 'issue-abandoned', 'completion');
+            const failed = await this.#releaseAndTerminateAgents(agents, agentReleaseReason, 'completion');
             cleanupComplete = failed.length === 0;
         }
         if (!cleanupComplete) {
@@ -7997,7 +8242,11 @@ export class FactoryLoop {
             return await this.#postAgentQuestionToGithub(record, question, 'no Slack dispatch thread exists');
         }
         try {
-            await this.#slack.reply(threadId, agentQuestionSlackText(record.issue, question, this.#config.slack.stakeholderUserIds));
+            const issue = await this.#readIssue(record.issue.path);
+            if (!issue) {
+                throw new Error(`Unable to describe Slack question notification for unreadable issue ${record.issue.key}`);
+            }
+            await this.#slack.reply(threadId, agentQuestionSlackText(issue, question, this.#config.slack.stakeholderUserIds, slackNotificationRepos(record.decision)));
             this.#increment('agentQuestionsPostedToSlack');
             this.#recordSlackWritebackSuccess('agent-question');
             return true;
@@ -8099,10 +8348,13 @@ export class FactoryLoop {
             return await this.#deliverClarificationQuestionToGithub(key, claimed, `Slack writeback is degraded${this.#slackDegradedReason ? `: ${this.#slackDegradedReason}` : ''}`);
         }
         try {
-            await this.#slack.reply(claimed.threadId, agentQuestionSlackText(claimed.issue, {
+            if (!claimedIssue) {
+                throw new Error(`Unable to describe Slack question notification for unreadable issue ${claimed.issue.key}`);
+            }
+            await this.#slack.reply(claimed.threadId, agentQuestionSlackText(claimedIssue, {
                 agentName: claimed.askerName,
                 question: claimed.question,
-            }, this.#config.slack.stakeholderUserIds));
+            }, this.#config.slack.stakeholderUserIds, slackNotificationRepos(claimed.decision)));
             const completed = await this.#state.completeClarificationQuestionDelivery(this.#workspaceId, key, this.#clarificationWakeOwner, this.#clock.now());
             if (!completed) {
                 this.#increment('clarificationQuestionDeliveryOwnershipLost');
@@ -8300,7 +8552,11 @@ export class FactoryLoop {
             return;
         }
         try {
-            await this.#slack.reply(threadId, agentQuestionSlackText(record.issue, question, this.#config.slack.stakeholderUserIds));
+            const issue = await this.#readIssue(record.issue.path);
+            if (!issue) {
+                throw new Error(`Unable to describe Slack question mirror for unreadable issue ${record.issue.key}`);
+            }
+            await this.#slack.reply(threadId, agentQuestionSlackText(issue, question, this.#config.slack.stakeholderUserIds, slackNotificationRepos(record.decision)));
             this.#increment('agentQuestionsMirroredToSlack');
             this.#recordSlackWritebackSuccess('agent-question-mirror');
         }
@@ -9395,7 +9651,7 @@ export class FactoryLoop {
                 prMetaShowsMerged(snapshot) &&
                 prSnapshotIssueMatchScore(snapshot, session.issue.key) >= 30) {
                 await this.#state.clearBabysitterSession(this.#workspaceId, persistedKey);
-                await this.#advanceMergedPrToDone(snapshot, record);
+                await this.#advanceMergedPrToDone(snapshot, session.repo, record);
                 this.#increment('babysitterOwnershipRestoreMerged');
                 this.#logger.info?.('[factory] completed restored lifecycle whose pull request was already merged', {
                     issue: session.issue.key,
@@ -10516,7 +10772,7 @@ export class FactoryLoop {
         if (owned) {
             if (prMetaShowsMerged(snapshot)) {
                 if (owned.record)
-                    await this.#advanceMergedPrToDone(snapshot, owned.record);
+                    await this.#advanceMergedPrToDone(snapshot, repo, owned.record);
                 else
                     await this.#cancelBabysitterWake(owned.key);
                 return;
@@ -10572,7 +10828,7 @@ export class FactoryLoop {
             return;
         }
         if (prMetaShowsMerged(snapshot)) {
-            await this.#advanceMergedPrToDone(snapshot, record);
+            await this.#advanceMergedPrToDone(snapshot, repo, record);
             return;
         }
         if (!this.#config.babysitter.enabled) {
@@ -10630,9 +10886,15 @@ export class FactoryLoop {
         }
         return best?.record;
     }
-    async #advanceMergedPrToDone(snapshot, record) {
+    async #advanceMergedPrToDone(snapshot, repo, record) {
+        const mergedPullRequest = { repo, number: snapshot.number, url: snapshot.url };
         if (record) {
-            await this.#completeIssue(record, { targetState: 'done', runMergeGate: false, completionReason: 'pr-merged' });
+            await this.#completeIssue(record, {
+                targetState: 'done',
+                runMergeGate: false,
+                completionReason: 'pr-merged',
+                mergedPullRequest,
+            });
             return;
         }
         const issue = await this.#findMergeAdvanceIssueForPr(snapshot);
@@ -10670,11 +10932,13 @@ export class FactoryLoop {
                     const channel = await this.#slackChannelDir();
                     if (channel) {
                         const systemOfRecord = githubIssue ? 'GitHub issue closed' : 'Linear state set to Done';
+                        const subject = slackIssueSubject(issue, [repo]);
+                        const pullRequest = slackPullRequestLink(mergedPullRequest);
                         const root = await this.#slack.postThread({
                             channel,
-                            text: `${issue.key}: PR merged; ${systemOfRecord}.`,
+                            text: `${subject}\nPR merged · ${pullRequest} · ${systemOfRecord}`,
                         });
-                        await this.#slack.reply(root.threadId, `${issue.key}: ${systemOfRecord}.`);
+                        await this.#slack.reply(root.threadId, `${subject}\n${systemOfRecord} · ${pullRequest}`);
                         this.#recordSlackWritebackSuccess('merge-done-thread');
                     }
                 }
@@ -11280,20 +11544,26 @@ export class FactoryLoop {
             }
             if (!await this.#saveDispatchLifecycle(record, 'writeback-applied'))
                 return;
-            if (this.#slack && this.#config.slack && !await this.#shouldSkipSlackWriteback('completion-thread')) {
+            if (issue && this.#slack && this.#config.slack && !await this.#shouldSkipSlackWriteback('completion-thread')) {
                 try {
                     const channel = await this.#slackChannelDir();
                     if (channel) {
                         const merged = opts.completionReason === 'pr-merged';
                         const systemOfRecord = githubIssue ? 'GitHub status' : 'Linear state';
-                        const completionText = merged
-                            ? `${record.issue.key}: PR merged; ${systemOfRecord} set to ${statusLabel}.`
-                            : `${record.issue.key}: factory agents completed${humanReview ? '; awaiting human review' : ''}.\nStatus: ${statusLabel}\nMerge policy: ${this.#config.mergePolicy}`;
-                        const stateText = merged
-                            ? `${record.issue.key}: ${systemOfRecord} set to ${statusLabel}.`
-                            : humanReview
-                                ? `${record.issue.key}: awaiting human review; ${systemOfRecord} set to ${statusLabel}.`
-                                : `${record.issue.key}: ${systemOfRecord} set to ${statusLabel}.`;
+                        const pullRequests = await this.#slackPullRequestRefs(record, opts.mergedPullRequest ? [opts.mergedPullRequest] : []);
+                        const pullRequestLinks = pullRequests.map(slackPullRequestLink).join(' · ');
+                        const subject = slackIssueSubject(issue, slackNotificationRepos(record.decision));
+                        const stateResult = githubIssue && merged && !humanReview
+                            ? 'GitHub issue closed'
+                            : `${systemOfRecord} set to ${statusLabel}`;
+                        const completionText = [
+                            subject,
+                            merged
+                                ? `PR merged${pullRequestLinks ? ` · ${pullRequestLinks}` : ''} · ${stateResult}`
+                                : `Completed${humanReview ? ' · awaiting human review' : ''}${pullRequestLinks ? ` · ${pullRequestLinks}` : ''}`,
+                            ...(!merged ? [`Status: ${statusLabel} · Merge policy: ${this.#config.mergePolicy}`] : []),
+                        ].join('\n');
+                        const stateText = `${subject}\n${stateResult}${pullRequestLinks ? ` · ${pullRequestLinks}` : ''}`;
                         const root = await this.#slack.postThread({
                             channel,
                             text: completionText,
@@ -11769,7 +12039,30 @@ export class FactoryLoop {
         this.#logger.warn?.('[factory] cleared invalid persisted Slack thread id', { issue: key });
         return undefined;
     }
-    async #ensureSlackDispatchThread(record, result) {
+    async #slackPullRequestRefs(record, additional = []) {
+        const lifecycle = await this.#state
+            .getDispatchLifecycle(this.#workspaceId, issueKey(record.issue))
+            .catch(() => undefined);
+        const lifecycleRefs = publishedPullRequests(lifecycle).map((receipt) => ({
+            repo: receipt.repo,
+            number: receipt.number,
+            url: receipt.url,
+        }));
+        const trackedRefs = [...record.agents.values()]
+            .map((tracked) => tracked.spec.ownedPullRequest)
+            .filter((ref) => Boolean(ref))
+            .map((ref) => ({ repo: ref.repo, number: ref.number }));
+        const babysitterRefs = [...this.#babysitterPr.entries()]
+            .filter(([key]) => issueKey(this.#babysitterIssueRefs.get(key) ?? record.issue) === issueKey(record.issue))
+            .map(([, ref]) => ({ repo: ref.repo, number: ref.prNumber }));
+        return uniqueSlackPullRequestRefs([
+            ...additional,
+            ...lifecycleRefs,
+            ...babysitterRefs,
+            ...trackedRefs,
+        ]);
+    }
+    async #ensureSlackDispatchThread(record, result, sourceIssue) {
         if (!this.#slack || !this.#config.slack || result.dryRun) {
             return;
         }
@@ -11805,7 +12098,7 @@ export class FactoryLoop {
             }
             return;
         }
-        const start = this.#postAndWatchSlackDispatchThread(record, result);
+        const start = this.#postAndWatchSlackDispatchThread(record, result, sourceIssue);
         this.#slackWatcherStarts.set(key, start);
         try {
             await start;
@@ -11818,19 +12111,24 @@ export class FactoryLoop {
             this.#slackWatcherStarts.delete(key);
         }
     }
-    async #postAndWatchSlackDispatchThread(record, result) {
+    async #postAndWatchSlackDispatchThread(record, result, sourceIssue) {
         if (!this.#slack || !this.#config.slack) {
             return;
         }
-        const previews = uniquePreviewReferences(result.previews ?? []);
+        const issue = sourceIssue ?? await this.#readIssue(record.issue.path);
+        if (!issue) {
+            throw new Error(`Unable to describe Slack dispatch notification for unreadable issue ${record.issue.key}`);
+        }
+        const previews = uniquePreviewReferences(result.previews ?? this.#previewReferences.get(issueKey(record.issue)) ?? []);
+        const repos = slackNotificationRepos(record.decision);
         const root = await this.#slack.postThread({
             channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
             text: [
-                `${record.issue.key}: factory agents dispatched.`,
-                `State: ${result.stateId ?? 'dispatching'} · Agents: ${result.agents.map((agent) => agent.name).join(', ') || 'none'}`,
+                slackIssueSubject(issue, repos),
+                `Dispatched · ${result.agents.map((agent) => agent.name).join(', ') || 'no agents'} · Repos: ${slackRepoList(repos)}`,
                 ...(previews.length > 0
                     ? [previews.map((preview) => `Live preview (${preview.repo}, tailnet access required): ${preview.url}`).join(' · ')]
-                    : []),
+                    : [`State: ${result.stateId ?? 'dispatching'}`]),
             ].join('\n'),
         });
         await this.#state.setSlackThread(this.#workspaceId, issueKey(record.issue), root.threadId);
@@ -12193,13 +12491,13 @@ export class FactoryLoop {
             .filter((part) => Boolean(part))
             .join(' ');
         const replyInstruction = source?.url
-            ? `Reply on the GitHub issue so Factory can resume: ${source.url}`
+            ? 'Reply on the linked GitHub issue so Factory can resume.'
             : '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}`,
+                `${audience ? `${audience} ` : ''}${slackIssueSubject(issue, slackNotificationRepos(decision))}`,
+                `Triage blocked · Reason: ${reason}`,
                 `Question: ${triageEscalationQuestion(decision, issue)} ${replyInstruction}`,
             ].join('\n'),
         });
@@ -12323,12 +12621,15 @@ export class FactoryLoop {
             return;
         }
         const issue = await this.#readIssue(decision.issue.path);
+        if (!issue) {
+            throw new Error(`Unable to describe Slack triage escalation for unreadable issue ${decision.issue.key}`);
+        }
         const stakeholderMentions = slackMentions(this.#config.slack.stakeholderUserIds);
         const root = await this.#slack.postThread({
             channel: await this.#slackChannelDir() ?? this.#config.slack.channel,
             text: [
-                `${stakeholderMentions ? `${stakeholderMentions} ` : ''}${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
-                `Reason: ${reason}`,
+                `${stakeholderMentions ? `${stakeholderMentions} ` : ''}${slackIssueSubject(issue, slackNotificationRepos(decision))}`,
+                `Triage blocked · Reason: ${reason}`,
                 `Question: ${triageEscalationQuestion(decision, issue)}`,
             ].join('\n'),
         });
@@ -12671,7 +12972,11 @@ export class FactoryLoop {
                 waitingAgeMs,
             });
             try {
-                await this.#slack.reply(waiting.threadId, clarificationStaleSlackText(escalated, this.#config.slack.stakeholderUserIds));
+                const issue = await this.#readIssue(escalated.issue.path);
+                if (!issue) {
+                    throw new Error(`Unable to describe stale Slack clarification for unreadable issue ${escalated.issue.key}`);
+                }
+                await this.#slack.reply(waiting.threadId, clarificationStaleSlackText(escalated, issue, this.#config.slack.stakeholderUserIds));
                 const completed = await this.#state.completeClarificationEscalation(this.#workspaceId, key, this.#clarificationWakeOwner, this.#clock.now());
                 if (!completed) {
                     this.#increment('clarificationEscalationOwnershipLost');
@@ -12935,6 +13240,9 @@ export class FactoryLoop {
                 this.#increment('clarificationWakesQueuedForCapacity');
                 return;
             }
+            // A human-answer wake starts a new agent-hold generation. Time spent
+            // parked with the previous team released must not consume its deadline.
+            record.heldSinceAtMs = undefined;
             if (!await this.#saveDispatchLifecycle(record, 'dispatching')) {
                 batch.complete(waiting.issue);
                 await this.#state.releaseClarificationWake(this.#workspaceId, key, this.#clarificationWakeOwner);
@@ -12964,8 +13272,10 @@ export class FactoryLoop {
                         }
                         : await this.#resumeOrColdStartClarificationAgent(parked.name, tracked, waiting);
                     const invocationId = batch.invocationIdFor(record.issue, tracked.spec);
+                    record.heldSinceAtMs ??= this.#clock.now();
                     batch.recordSpawn(record, tracked.spec, invocationId, result);
                     await this.#saveDispatchLifecycle(record, 'dispatching');
+                    this.#scheduleHeldAgentDeadline(record);
                     const live = record.agents.get(result.name);
                     if (live) {
                         resumed.push([result.name, live]);
@@ -13784,6 +14094,82 @@ function dispatchIssueUrl(issue) {
         ?? stringValue(source?.url)
         ?? issue.path;
 }
+const SLACK_ISSUE_TITLE_MAX_LENGTH = 120;
+function slackEscapeText(value) {
+    return value
+        .replace(/&/gu, '&amp;')
+        .replace(/</gu, '&lt;')
+        .replace(/>/gu, '&gt;');
+}
+function slackLinkUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            return undefined;
+        return url.toString()
+            .replace(/\|/gu, '%7C')
+            .replace(/</gu, '%3C')
+            .replace(/>/gu, '%3E');
+    }
+    catch {
+        return undefined;
+    }
+}
+function truncateSlackIssueTitle(title) {
+    const normalized = title.replace(/\s+/gu, ' ').trim() || 'Untitled issue';
+    const characters = Array.from(normalized);
+    if (characters.length <= SLACK_ISSUE_TITLE_MAX_LENGTH)
+        return normalized;
+    return `${characters.slice(0, SLACK_ISSUE_TITLE_MAX_LENGTH - 1).join('').trimEnd()}…`;
+}
+function slackRepoName(repo) {
+    const normalized = repo.trim().replace(/^\/+|\/+$/gu, '');
+    return normalized.slice(normalized.lastIndexOf('/') + 1) || normalized || 'unknown repo';
+}
+function slackNotificationRepos(decision) {
+    const repos = [
+        ...decision.routes.map((route) => route.repo),
+        ...decision.implementers.map((implementer) => implementer.repo),
+    ];
+    return [...new Map(repos
+            .filter((repo) => Boolean(repo.trim()))
+            .map((repo) => [repo.trim().toLowerCase(), repo.trim()])).values()];
+}
+function slackRepoList(repos) {
+    const names = [...new Set(repos.map(slackRepoName))];
+    return slackEscapeText(names.join(', ') || 'unknown repo');
+}
+function slackIssueSubject(issue, repos = []) {
+    const githubSource = githubIssueSourceRef(issue);
+    const githubPath = githubIssuePathParts(issue.path);
+    const githubIdentity = githubSource ?? githubPath;
+    const payload = wrappedPayload(issue.raw);
+    const source = asRecord(payload.source);
+    const fallbackIssueUrl = githubIdentity
+        ? `https://github.com/${githubIdentity.owner}/${githubIdentity.repo}/issues/${githubIdentity.number}`
+        : `https://linear.app/issue/${encodeURIComponent(issue.key)}`;
+    const issueUrl = slackLinkUrl(githubSource?.url
+        ?? stringValue(payload.url)
+        ?? stringValue(payload.html_url)
+        ?? stringValue(source?.url)
+        ?? fallbackIssueUrl) ?? fallbackIssueUrl;
+    const repoNames = [...new Set(repos.map(slackRepoName))];
+    const label = githubIdentity
+        ? `${githubIdentity.repo}#${githubIdentity.number}`
+        : `${repoNames.join(', ') || 'unknown repo'} · ${issue.key}`;
+    return `<${issueUrl}|${slackEscapeText(label)}> — ${slackEscapeText(truncateSlackIssueTitle(issue.title))}`;
+}
+function slackPullRequestLink(pullRequest) {
+    const fallbackUrl = `https://github.com/${pullRequest.repo}/pull/${pullRequest.number}`;
+    const url = slackLinkUrl(pullRequest.url ?? fallbackUrl) ?? fallbackUrl;
+    const label = `${slackRepoName(pullRequest.repo)}#${pullRequest.number}`;
+    return `<${url}|${slackEscapeText(label)}>`;
+}
+function uniqueSlackPullRequestRefs(refs) {
+    return [...new Map(refs
+            .filter((ref) => Boolean(ref.repo.trim()) && Number.isSafeInteger(ref.number) && ref.number > 0)
+            .map((ref) => [`${ref.repo.trim().toLowerCase()}#${ref.number}`, { ...ref, repo: ref.repo.trim() }])).values()];
+}
 function ticketDispatchNotificationText(payload) {
     return `${payload.summary}\n${JSON.stringify(payload)}`;
 }
@@ -15722,6 +16108,28 @@ const durableBabysitterTrackedAgent = (session, capability = 'spawn:claude') =>
 });
 const isTerminalDispatchLifecycle = (lifecycle) => lifecycle.phase === 'complete' || lifecycle.phase === 'abandoned';
 const isTerminalDispatchPhase = (phase) => phase === 'complete' || phase === 'abandoned';
+const heldAgentsForRecord = (record, nowMs, holdTimeoutMs, terminalState) => {
+    if (record.dryRun || record.heldSinceAtMs === undefined)
+        return [];
+    const heldSinceAtMs = record.heldSinceAtMs;
+    const holdDeadlineAtMs = heldSinceAtMs + holdTimeoutMs;
+    const heldForMs = Math.max(0, nowMs - heldSinceAtMs);
+    return [...record.agents]
+        .filter(([, tracked]) => Boolean(tracked.result))
+        .map(([name, tracked]) => ({
+        name,
+        role: tracked.spec.role,
+        issue: { ...record.issue },
+        ...(record.lifecyclePhase ? { lifecyclePhase: record.lifecyclePhase } : {}),
+        waitingForTerminalState: terminalState,
+        heldSince: new Date(heldSinceAtMs).toISOString(),
+        heldSinceAtMs,
+        heldForMs,
+        holdDeadline: new Date(holdDeadlineAtMs).toISOString(),
+        holdDeadlineAtMs,
+        pastDeadline: nowMs >= holdDeadlineAtMs,
+    }));
+};
 const costUsageGroupId = (runId, tracked) => JSON.stringify([runId, tracked.spec.invocationId ?? tracked.spec.name]);
 const costEntryId = (groupId, model) => JSON.stringify([groupId, model]);
 const publishedPullRequests = (lifecycle) => {
@@ -15767,6 +16175,7 @@ const lifecycleFromInFlightRecord = (record, runId, phase, updatedAtMs, pullRequ
     ...(pullRequest ? { pullRequest: { ...pullRequest } } : {}),
     ...(releaseReason ? { releaseReason } : {}),
     ...(cost ? { cost: structuredClone(cost) } : {}),
+    ...(record.heldSinceAtMs !== undefined ? { heldSinceAtMs: record.heldSinceAtMs } : {}),
     updatedAtMs,
 });
 const inFlightRecordFromLifecycle = (lifecycle) => ({
@@ -15777,6 +16186,10 @@ const inFlightRecordFromLifecycle = (lifecycle) => ({
     invocationIds: new Set(lifecycle.invocationIds),
     result: lifecycle.result ? structuredClone(lifecycle.result) : undefined,
     ...(lifecycle.dispatchClaim ? { dispatchClaim: { ...lifecycle.dispatchClaim } } : {}),
+    heldSinceAtMs: lifecycle.heldSinceAtMs ?? (lifecycle.agents.some((agent) => agent.releasedAtMs === undefined)
+        ? lifecycle.updatedAtMs
+        : undefined),
+    lifecyclePhase: lifecycle.phase,
 });
 const dispatchResultFromLifecycle = (lifecycle) => lifecycle.result ? structuredClone(lifecycle.result) : {
     issue: { ...lifecycle.issue },
@@ -15971,14 +16384,14 @@ const slackUserIdMatchingIdentity = (payload, identity) => {
         ? userId
         : undefined;
 };
-const agentQuestionSlackText = (issue, question, stakeholderUserIds = []) => [
-    slackMentions(stakeholderUserIds),
-    `${issue.key}: ${question.agentName} needs input.`,
+const agentQuestionSlackText = (issue, question, stakeholderUserIds = [], repos = []) => [
+    `${slackMentions(stakeholderUserIds) ?? ''} ${slackIssueSubject(issue, repos)}`.trim(),
+    `${question.agentName} needs input.`,
     `Question: ${question.question}`,
 ].filter((line) => Boolean(line)).join('\n');
-const clarificationStaleSlackText = (waiting, stakeholderUserIds = []) => [
-    slackMentions(stakeholderUserIds),
-    `${waiting.issue.key} has been parked for seven days without a reply.`,
+const clarificationStaleSlackText = (waiting, issue, stakeholderUserIds = []) => [
+    `${slackMentions(stakeholderUserIds) ?? ''} ${slackIssueSubject(issue, slackNotificationRepos(waiting.decision))}`.trim(),
+    'This issue has been parked for seven days without a reply.',
     `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, '\\$&');