@atolis-hq/wake 0.1.11 → 0.1.13

package/dist/src/core/tick-runner.js

@@ -1,12 +1,8 @@
-import { randomUUID } from 'node:crypto';
-import { rm } from 'node:fs/promises';
-import { isAbsolute, join, relative } from 'node:path';
 import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
 import { createProjectionUpdater } from './projection-updater.js';
 import { acquireFileLock } from '../lib/lock.js';
-import { createWorkId } from '../lib/work-id.js';
-import { CORRELATION_REGISTERED_EVENT, UNRESOLVED_WORK_ITEM_KEY, WORK_ITEM_CREATED_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
+import { CORRELATION_REGISTERED_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
 import { chooseAction as chooseWorkflowAction, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowLabelForWorkflowName, workflowNameForProjection, } from '../domain/workflows.js';
@@ -14,42 +10,18 @@ import { createEventEnvelope } from '../lib/event-log.js';
 import { branchNameForIssue } from '../domain/branch-naming.js';
 import { customCommandWorkspace, isCustomCommandAction } from '../domain/custom-commands.js';
 import { resolveQuotaPauseUntil } from './quota-backoff.js';
+import { createLabelsEvent, createPublishIntentEvent } from './event-builders.js';
+import { createOutbox } from './outbox.js';
+import { createEventResolver } from './event-resolver.js';
+import { createStaleRunReconciler } from './stale-run-reconciler.js';
+import { createWorkspaceCleanup } from './workspace-cleanup.js';
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
 }
-// `latestComment` is a sticky, per-work-item field: projection-updater.ts's
-// comment fold overwrites it unconditionally on every inbound comment
-// (any surface) and nothing ever resets it. So it means "the last comment
-// this work item has ever received," not "the comment that triggered the
-// currently completing run." Several needsWakeAction trigger paths (first
-// run, quota-failure retry, first workflow-stage pass) complete a run
-// with no fresh comment driving it at all — in those cases latestComment
-// may still be pointing at an older, already-handled comment from a
-// different surface (e.g. a PR) and must not be trusted as this run's
-// trigger. This mirrors policy-engine.ts's needsWakeAction "is there an
-// unhandled human comment" check exactly, so a comment is only treated as
-// having driven this run when it's human-authored and not yet the
-// candidate's own lastHandledCommentId (read from the pre-completion
-// projection passed in as `candidate`/`projection`, since the completion
-// event that would update lastHandledCommentId for *this* run hasn't been
-// folded yet at the point this runs).
-function isReviewThreadResourceUri(resourceUri) {
-    return resourceUri.split(':')[1] === 'pr-review-thread';
-}
 function isLateralReadOnlyAction(action, config) {
     return isCustomCommandAction(action, config);
 }
-function workspaceModeForCustomCommand(action, config) {
-    return customCommandWorkspace(action, config);
-}
-function isFreshTriggeringComment(candidate) {
-    const context = candidate.context;
-    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-    return (candidate.latestComment !== undefined &&
-        !candidate.latestComment.isBotAuthored &&
-        candidate.latestComment.id !== handledCommentId);
-}
 export function createTickRunner(deps) {
     const policy = createPolicyEngine();
     const lifecycle = createLifecycleService();
@@ -58,131 +30,34 @@ export function createTickRunner(deps) {
         resourceIndex: deps.resourceIndex,
         config: deps.config,
     });
-    function extractTokenCount(tokenUsage) {
-        if (tokenUsage === undefined) {
-            return undefined;
-        }
-        // Cache tokens dominate real usage and were previously dropped from this
-        // total entirely, understating the reported figure by roughly an order of
-        // magnitude (#135).
-        return (tokenUsage.inputTokens +
-            tokenUsage.outputTokens +
-            (tokenUsage.cacheCreationInputTokens ?? 0) +
-            (tokenUsage.cacheReadInputTokens ?? 0));
-    }
-    function formatCostUsd(costUsd) {
-        return `$${costUsd.toFixed(costUsd < 1 ? 4 : 2)}`;
-    }
-    function formatDuration(startedAtStr, finishedAtStr) {
-        const startedAt = new Date(startedAtStr);
-        const finishedAt = new Date(finishedAtStr);
-        const durationMs = finishedAt.getTime() - startedAt.getTime();
-        if (durationMs < 0 || !isFinite(durationMs))
-            return undefined;
-        const totalSeconds = Math.floor(durationMs / 1000);
-        const minutes = Math.floor(totalSeconds / 60);
-        const seconds = totalSeconds % 60;
-        if (minutes > 0) {
-            return `${minutes}m${seconds}s`;
-        }
-        return `${seconds}s`;
-    }
-    function formatTokenCount(count) {
-        if (count >= 1000000) {
-            return `${(count / 1000000).toFixed(1)}M`;
-        }
-        if (count >= 1000) {
-            return `${(count / 1000).toFixed(0)}k`;
-        }
-        return String(count);
-    }
-    function createPublishIntentEvent(input) {
-        const tokenCount = extractTokenCount(input.runnerResult.tokenUsage);
-        const duration = formatDuration(input.startedAt, input.occurredAt);
-        return createEventEnvelope({
-            eventId: `${input.runId}-publish-intent`,
-            workItemKey: input.projection.workItemKey,
-            streamScope: 'work-item',
-            direction: 'outbound',
-            sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.intent.requested',
-            sourceRefs: {
-                repo: input.projection.issue.repo,
-                issueNumber: input.projection.issue.number,
-                runId: input.runId,
-                // Carries the triggering comment's surface (set only when the human
-                // reply that woke this run came from a correlated PR/review-thread
-                // resource, per the ad1cf45 comment fold) through to the sink
-                // router, so createOutboundSinkRouter's kind-based routing (Task 11,
-                // sink-router.ts) can send the reply back to that surface instead of
-                // defaulting to the issue thread. Without this, every reply landed
-                // on the origin sink regardless of which surface triggered the run.
-                //
-                // Gated on isFreshTriggeringComment: latestComment is sticky (see
-                // that function's comment) and several run-completion paths (first
-                // run, quota retry, first workflow-stage pass) have no fresh
-                // comment behind them at all — for those, threading the stale
-                // latestComment.resourceUri would misroute the reply to whatever
-                // surface last happened to comment, even long after that comment
-                // was already replied to.
-                //
-                // Never threads a pr-review-thread surface specifically: this is
-                // Wake's own status, approval-request, or question card: a milestone
-                // message, not a targeted reply to one inline comment — burying it
-                // as a reply deep in a single review thread makes it easy to miss.
-                // Omitting resourceUri here falls back to sourceOrigin in
-                // sink-router.ts, landing it on the correlated issue (or, for a
-                // standalone PR-only work item, GitHub's shared issue/PR comments
-                // endpoint posts it as a top-level PR comment instead). Replies to
-                // individual review threads are the agent's own job now — see
-                // prompts/revise.md — via `gh api .../replies`, not this card.
-                ...(input.projection.latestComment?.resourceUri === undefined ||
-                    !isFreshTriggeringComment(input.projection) ||
-                    isReviewThreadResourceUri(input.projection.latestComment.resourceUri)
-                    ? {}
-                    : { resourceUri: input.projection.latestComment.resourceUri }),
-            },
-            occurredAt: input.occurredAt,
-            ingestedAt: input.occurredAt,
-            trigger: 'context-only',
-            payload: {
-                kind: input.sentinel === 'BLOCKED'
-                    ? 'question'
-                    : input.sentinel === 'AWAITING_APPROVAL'
-                        ? 'approval-request'
-                        : input.sentinel === 'FAILED'
-                            ? 'failure'
-                            : 'status-update',
-                origin: input.projection.origin ?? 'github',
-                body: input.parsedRunnerResult.body,
-                action: input.action,
-                sentinel: input.sentinel,
-                runId: input.runId,
-                ...(input.runnerResult.session_id === undefined
-                    ? {}
-                    : { sessionId: input.runnerResult.session_id }),
-                model: input.runnerResult.model,
-                cli: input.runnerResult.cli,
-                ...(input.runnerResult.routing === undefined
-                    ? {}
-                    : {
-                        runnerName: input.runnerResult.routing.runnerName,
-                        runnerKind: input.runnerResult.routing.runnerKind,
-                        runnerTier: input.runnerResult.routing.tier,
-                        runnerReason: input.runnerResult.routing.reason,
-                    }),
-                ...(duration === undefined ? {} : { duration }),
-                ...(tokenCount === undefined ? {} : { tokens: formatTokenCount(tokenCount) }),
-                ...(input.runnerResult.tokenUsage?.costUsd === undefined
-                    ? {}
-                    : { cost: formatCostUsd(input.runnerResult.tokenUsage.costUsd) }),
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-            },
-            derivedHints: {
-                stage: input.sentinel === 'DONE' ? 'done' : input.projection.wake.stage,
-            },
-        });
-    }
+    const { deliverOutboundEvent, retryUnconfirmedDeliveries } = createOutbox({
+        clock: deps.clock,
+        stateStore: deps.stateStore,
+        projectionUpdater,
+        ...(deps.outboundSink === undefined ? {} : { outboundSink: deps.outboundSink }),
+    });
+    const { ingestInboundEvents } = createEventResolver({
+        clock: deps.clock,
+        config: deps.config,
+        stateStore: deps.stateStore,
+        resourceIndex: deps.resourceIndex,
+        projectionUpdater,
+        qualifiesForMint: policy.qualifiesForMint,
+    });
+    const { reconcileStaleRunningRecords } = createStaleRunReconciler({
+        config: deps.config,
+        stateStore: deps.stateStore,
+        projectionUpdater,
+        runnerTimeoutMs,
+        deliverOutboundEvent,
+    });
+    const { cleanupClosedIssueWorkspaces } = createWorkspaceCleanup({
+        clock: deps.clock,
+        config: deps.config,
+        stateStore: deps.stateStore,
+        workspaceManager: deps.workspaceManager,
+        projectionUpdater,
+    });
     function isAwaitingApproval(projection) {
         return projection.context.lastRunSentinel === awaitingApprovalRunnerSentinel;
     }
@@ -207,48 +82,6 @@ export function createTickRunner(deps) {
     function hasLabel(projection, label) {
         return projection.issue.labels.includes(label);
     }
-    function shouldMarkPending(projection) {
-        if (!policy.isEligible(projection, deps.config)) {
-            return false;
-        }
-        const workflow = workflowForProjection(projection, deps.config);
-        if (workflow === null || !isKnownWorkflowStage(projection.wake.stage, workflow)) {
-            return false;
-        }
-        if (isAwaitingApproval(projection)) {
-            return (policy.resolveCustomCommandRequest(projection, deps.config) !== null ||
-                policy.resolveApprovalTransition(projection) !== null ||
-                policy.resolvePendingReviewFeedback(projection) !== null);
-        }
-        const nextAction = policy.resolveCustomCommandRequest(projection, deps.config)?.action ??
-            policy.chooseAction(projection, workflow) ??
-            policy.chooseRetryActionAfterHumanReply(projection);
-        return nextAction !== null && policy.needsWakeAction(projection, workflow);
-    }
-    function createLabelsEvent(input) {
-        return createEventEnvelope({
-            eventId: `${input.runId}-labels-${input.statusLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.stageLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.workflowLabel.replace(/[^a-z0-9]+/gi, '-')}`,
-            workItemKey: input.projection.workItemKey,
-            streamScope: 'work-item',
-            direction: 'outbound',
-            sourceSystem: 'wake',
-            sourceEventType: 'wake.labels.requested',
-            sourceRefs: {
-                repo: input.projection.issue.repo,
-                issueNumber: input.projection.issue.number,
-                runId: input.runId,
-            },
-            occurredAt: input.occurredAt,
-            ingestedAt: input.occurredAt,
-            trigger: 'context-only',
-            payload: {
-                statusLabel: input.statusLabel,
-                stageLabel: input.stageLabel,
-                workflowLabel: input.workflowLabel,
-                origin: input.projection.origin ?? 'github',
-            },
-        });
-    }
     // Closes the loop on #82's review feedback: rather than scrape a PR link
     // out of the agent's free text, the agent emits a `wake-artifacts` fence
     // (domain/schema.ts's parseRunnerArtifacts) and Wake verifies each claim
@@ -342,7 +175,7 @@ export function createTickRunner(deps) {
             const statusLabel = statusLabelForStage(projection.wake.stage);
             const stageLabel = stageLabelForStage(projection.wake.stage);
             const workflowLabel = workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config));
-            if (!shouldMarkPending(projection) ||
+            if (policy.resolveNextEligibleAction(projection, deps.config) === null ||
                 (hasLabel(projection, statusLabel) &&
                     hasLabel(projection, stageLabel) &&
                     hasLabel(projection, workflowLabel))) {
@@ -358,391 +191,9 @@ export function createTickRunner(deps) {
             }));
         }
     }
-    // Returns whichever of the two timestamps is unambiguously later, defaulting
-    // to `left`. `right` wins only if it is later by BOTH the actual instant and
-    // the lexicographic order rebuildFromEvents sorts on — the envelope schema is
-    // `z.string().datetime({ offset: true })`, so a timestamp may legally carry a
-    // non-UTC offset or differing sub-second precision, and lexicographic order
-    // alone is not a reliable proxy for chronology across those formats. Falling
-    // back to `left` (the source event's own exact string) is always safe: it
-    // ties with that event under localeCompare, and the stable sort then preserves
-    // append order, which puts the mint events after it — exactly what we need.
-    function laterTimestamp(left, right) {
-        const isLater = Date.parse(right) > Date.parse(left) && right.localeCompare(left) > 0;
-        return isLater ? right : left;
-    }
-    // The two internal events a mint (or a heal) appends after the source event
-    // that founded a work item: wake.workitem.created, then the
-    // wake.correlation.registered that claims the originating resource as this
-    // work item's primary representation. Their ids are derived from the work id,
-    // so re-emitting them is idempotent — appendEventEnvelope dedups on the id.
-    //
-    // Ordering and timestamps matter, and not only for readability. Both fold
-    // against the projection the source event creates, and applyEvent drops
-    // anything that folds while `current === null`. So they must never sort
-    // *before* that source event in rebuildFromEvents' globally-ordered replay —
-    // if they did, replay would silently discard the registration, leaving
-    // correlatedResources[] empty and the index unpopulated, while the events
-    // still on record stop any later tick from re-registering. Permanent,
-    // self-concealing loss (Task 5, round 3). Reading the clock here is already
-    // after pollEvents(), but that alone is not a guarantee: the source event's
-    // ingestedAt comes from the *source's* clock, which for a real source is
-    // another machine's and can legitimately run ahead of ours. Anchoring on the
-    // source event's own timestamp makes the ordering hold by construction rather
-    // than by clock agreement; appending the source event first means a tie
-    // resolves in its favour (the sort is stable, so equal timestamps keep append
-    // order).
-    function buildOriginCorrelationEvents(workItemKey, unkeyed, resourceUri) {
-        const mintedAt = laterTimestamp(unkeyed.ingestedAt, eventStampNow());
-        const sourceRefs = {
-            ...unkeyed.sourceRefs,
-            resourceUri,
-        };
-        const createdEvent = createEventEnvelope({
-            eventId: `${workItemKey}-created`,
-            workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: WORK_ITEM_CREATED_EVENT,
-            sourceRefs,
-            occurredAt: mintedAt,
-            ingestedAt: mintedAt,
-            trigger: 'context-only',
-            // The envelope's workItemKey already carries the identity.
-            payload: {},
-        });
-        const registeredEvent = createEventEnvelope({
-            eventId: `${workItemKey}-origin-correlation`,
-            workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: CORRELATION_REGISTERED_EVENT,
-            sourceRefs,
-            occurredAt: mintedAt,
-            ingestedAt: mintedAt,
-            trigger: 'context-only',
-            payload: {
-                resourceUri,
-                role: 'representation',
-                relation: 'primary',
-                provenance: 'wake-created',
-            },
-        });
-        return [createdEvent, registeredEvent];
-    }
-    // The central resolver (spec D1): sources name the *resource* an event came
-    // from and never the work item, so between pollEvents() and the append every
-    // inbound event's sourceRefs.resourceUri is resolved through the reverse
-    // index to the canonical workItemKey, minting a work item on a miss. This is
-    // the one mechanism — there is no founding-surface special case, and no
-    // resolution is ever cached in process memory between ticks (CLAUDE.md: the
-    // tick is a pure function of durable state; the index on disk *is* that
-    // state).
-    //
-    // Each resolved event carries whether it is already `persisted`, so the
-    // caller can skip re-appending it (appendEventEnvelope would only re-read it
-    // and hand back the same envelope). Minting *is* registration, so a freshly
-    // minted work item's correlatedResources[] is complete from its first event.
-    async function resolveInboundEvent(unkeyed) {
-        const { resourceUri } = unkeyed.sourceRefs;
-        if (resourceUri === undefined) {
-            // A programming error in the adapter, not a runtime condition to absorb.
-            // Guessing an identity here would silently fork a duplicate work item
-            // for work already in flight — exactly the corruption the reverse index
-            // exists to prevent — so fail loudly instead.
-            throw new Error(`cannot resolve inbound event ${unkeyed.eventId} from ${unkeyed.sourceSystem}: ` +
-                'sourceRefs.resourceUri is required for every unkeyed source event');
-        }
-        // An event we have already persisted was already resolved, on some earlier
-        // tick, and its stamped key is the durable answer. Re-resolving it through
-        // the index would be wrong as well as wasteful: if that work item has since
-        // retracted this resource, the index no longer holds it, the lookup misses,
-        // and a miss means mint — so a re-polled event (sources legitimately
-        // re-emit the same eventId, e.g. an unchanged issue) would fork a duplicate
-        // work item. Reusing the persisted key keeps resolution idempotent per
-        // event id, which is what the append-only log already promises.
-        const persisted = await deps.stateStore.readEventEnvelope(unkeyed.eventId);
-        if (persisted !== null) {
-            // Heal a partially minted work item. The index entry for a resource is
-            // written only when its origin wake.correlation.registered event is
-            // *folded*, several appends after the founding source event. A crash in
-            // that window leaves the source event durable — so this branch suppresses
-            // re-minting — while the index has no entry, and a later event on the
-            // same resource would miss the index and fork a duplicate work item
-            // (crash/restart safety, CLAUDE.md). If the index does not credit this
-            // event's work item *and* its origin correlation never landed, re-emit
-            // the mint tail (idempotent by id). The guard is the missing origin
-            // event, not merely an empty index: a deliberately *retracted* resource
-            // also resolves to undefined but keeps its origin-correlation event on
-            // record, and must not be silently re-registered.
-            const owner = await deps.resourceIndex.resolve(resourceUri);
-            if (persisted.workItemKey !== UNRESOLVED_WORK_ITEM_KEY &&
-                owner === undefined &&
-                (await deps.stateStore.readEventEnvelope(`${persisted.workItemKey}-origin-correlation`)) ===
-                    null) {
-                return [
-                    { envelope: persisted, persisted: true },
-                    ...buildOriginCorrelationEvents(persisted.workItemKey, unkeyed, resourceUri).map((envelope) => ({ envelope, persisted: false })),
-                ];
-            }
-            return [{ envelope: persisted, persisted: true }];
-        }
-        const existingWorkItemKey = await deps.resourceIndex.resolve(resourceUri);
-        if (existingWorkItemKey !== undefined) {
-            return [
-                {
-                    envelope: createEventEnvelope({ ...unkeyed, workItemKey: existingWorkItemKey }),
-                    persisted: false,
-                },
-            ];
-        }
-        // resourceUri itself misses the index (e.g. a review-thread comment's
-        // resourceUri is unique per thread, never registered on its own), but the
-        // adapter may have named a parent resource this one belongs to. Resolve
-        // through that instead of minting — and register this exact resourceUri
-        // as a secondary correlation so it's on record on the work item, even
-        // though (being secondary) it still won't shortcut future lookups via the
-        // index itself (ADR 0001 §5: the index is primary-only).
-        if (unkeyed.sourceRefs.parentResourceUri !== undefined) {
-            const parentWorkItemKey = await deps.resourceIndex.resolve(unkeyed.sourceRefs.parentResourceUri);
-            if (parentWorkItemKey !== undefined) {
-                const mintedAt = laterTimestamp(unkeyed.ingestedAt, eventStampNow());
-                return [
-                    {
-                        envelope: createEventEnvelope({ ...unkeyed, workItemKey: parentWorkItemKey }),
-                        persisted: false,
-                    },
-                    {
-                        envelope: createEventEnvelope({
-                            eventId: `${parentWorkItemKey}-correlation-${resourceUri.replace(/[^a-z0-9]+/gi, '-')}`,
-                            workItemKey: parentWorkItemKey,
-                            streamScope: 'work-item',
-                            direction: 'internal',
-                            sourceSystem: 'wake',
-                            sourceEventType: CORRELATION_REGISTERED_EVENT,
-                            sourceRefs: unkeyed.sourceRefs,
-                            occurredAt: mintedAt,
-                            ingestedAt: mintedAt,
-                            trigger: 'context-only',
-                            payload: {
-                                resourceUri,
-                                role: 'review',
-                                relation: 'secondary',
-                                provenance: 'detected',
-                            },
-                        }),
-                        persisted: false,
-                    },
-                ];
-            }
-        }
-        if (!policy.qualifiesForMint(unkeyed, deps.config)) {
-            return [
-                {
-                    envelope: createEventEnvelope({ ...unkeyed, workItemKey: UNRESOLVED_WORK_ITEM_KEY }),
-                    persisted: false,
-                },
-            ];
-        }
-        const workItemKey = createWorkId();
-        const keyed = createEventEnvelope({ ...unkeyed, workItemKey });
-        return [
-            { envelope: keyed, persisted: false },
-            ...buildOriginCorrelationEvents(workItemKey, unkeyed, resourceUri).map((envelope) => ({
-                envelope,
-                persisted: false,
-            })),
-        ];
-    }
-    async function ingestInboundEvents(unkeyedEvents) {
-        const ingested = [];
-        for (const unkeyed of unkeyedEvents) {
-            const resolved = await resolveInboundEvent(unkeyed);
-            // Fold what was actually persisted, never the in-memory copy:
-            // appendEventEnvelope is id-deduplicated and returns the *existing*
-            // envelope when one is already on record. Folding our own copy instead
-            // would let state/ diverge from events/ — and replay is defined by
-            // events/, so the divergence would only surface after a rebuild. An event
-            // already flagged `persisted` needs no second append: appendEventEnvelope
-            // would only re-read it off disk and hand back the same envelope, and
-            // every unchanged issue is re-polled every tick, so that read is the
-            // dominant redundant cost this branch avoids.
-            const events = [];
-            for (const { envelope, persisted } of resolved) {
-                events.push(persisted ? envelope : await deps.stateStore.appendEventEnvelope(envelope));
-            }
-            // Folded before the next event is resolved, because it is the fold of
-            // the registration event that writes the index entry the *next* event on
-            // the same resource resolves through. Deferring the fold to the end of
-            // the batch would let a second event for the same ticket miss and mint a
-            // duplicate work item. Every event in a poll batch shares the source's
-            // one ingestedAt, so folding per event preserves exactly the order a
-            // single batched fold would have produced.
-            await projectionUpdater.rebuildFromEvents(events);
-            ingested.push(...events);
-        }
-        return ingested;
-    }
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
-    function isPerIssueWorkspacePath(workspacePath) {
-        const workspacesRoot = join(deps.config.paths.wakeRoot, 'workspaces');
-        const rel = relative(workspacesRoot, workspacePath);
-        return !rel.startsWith('..') && !isAbsolute(rel) && rel.length > 0;
-    }
-    async function cleanupClosedIssueWorkspaces(projections) {
-        for (const projection of projections) {
-            const { workspacePath } = projection.wake;
-            if (projection.issue.state === 'closed' &&
-                workspacePath !== undefined &&
-                isPerIssueWorkspacePath(workspacePath)) {
-                try {
-                    await deps.workspaceManager.cleanupWorkspace({ workspacePath });
-                    if (!deps.config.transcripts.retainAfterWorkspaceCleanup) {
-                        await rm(deps.stateStore.paths.transcriptWorkDir(projection.workItemKey), {
-                            recursive: true,
-                            force: true,
-                        });
-                    }
-                }
-                catch (error) {
-                    const failedAt = eventStampNow();
-                    await deps.stateStore.appendEventEnvelope(createEventEnvelope({
-                        eventId: `workspace-cleanup-failed-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}`,
-                        workItemKey: projection.workItemKey,
-                        streamScope: 'work-item',
-                        direction: 'internal',
-                        sourceSystem: 'wake',
-                        sourceEventType: 'wake.workspace.cleanup-failed',
-                        sourceRefs: {
-                            repo: projection.issue.repo,
-                            issueNumber: projection.issue.number,
-                        },
-                        occurredAt: failedAt,
-                        ingestedAt: failedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            workspacePath,
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                    }));
-                    continue;
-                }
-                const cleanedAt = eventStampNow();
-                const cleanupEvent = createEventEnvelope({
-                    eventId: `workspace-cleaned-${projection.issue.repo.replace(/[^a-z0-9]+/gi, '-')}-${projection.issue.number}-${deps.clock.now().getTime()}`,
-                    workItemKey: projection.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'internal',
-                    sourceSystem: 'wake',
-                    sourceEventType: 'wake.workspace.cleaned',
-                    sourceRefs: {
-                        repo: projection.issue.repo,
-                        issueNumber: projection.issue.number,
-                    },
-                    occurredAt: cleanedAt,
-                    ingestedAt: cleanedAt,
-                    trigger: 'immediate',
-                    payload: { workspacePath },
-                });
-                await deps.stateStore.appendEventEnvelope(cleanupEvent);
-                await projectionUpdater.rebuildFromEvents([cleanupEvent]);
-            }
-        }
-    }
-    function isStaleRunningRecord(record, now) {
-        if (record.status !== 'running') {
-            return false;
-        }
-        const startedAtMs = Date.parse(record.startedAt);
-        if (!Number.isFinite(startedAtMs)) {
-            return true;
-        }
-        return now.getTime() - startedAtMs >= runnerTimeoutMs();
-    }
-    async function reconcileStaleRunningRecords(now) {
-        const finishedAt = now.toISOString();
-        const runRecords = await deps.stateStore.listRunRecords();
-        const staleRecords = runRecords.filter((record) => isStaleRunningRecord(record, now));
-        for (const record of staleRecords) {
-            // Run records carry the work item they belong to, so this is a direct
-            // O(1) read — no scan, no index, no source ambiguity. The record's
-            // repo/issueNumber are representation content and take no part in it.
-            const projection = await deps.stateStore.readIssueState(record.workItemKey);
-            const newerCompletedRun = runRecords.some((candidate) => candidate.workItemKey === record.workItemKey &&
-                candidate.runId !== record.runId &&
-                candidate.status !== 'running' &&
-                Date.parse(candidate.startedAt) > Date.parse(record.startedAt));
-            // Equivalent to the previous `projection?.wake.lastRunId !== record.runId`,
-            // spelled out so the non-null projection is available below for its
-            // workItemKey.
-            if (projection === null || projection.wake.lastRunId !== record.runId || newerCompletedRun) {
-                await deps.stateStore.writeRunRecord({
-                    ...record,
-                    status: 'superseded',
-                    finishedAt,
-                    summary: 'Stale running record was superseded by a newer run.',
-                    metadata: {
-                        ...record.metadata,
-                        reconciledBy: 'stale-running-record',
-                        supersededBy: projection?.wake.lastRunId,
-                    },
-                });
-                continue;
-            }
-            await deps.stateStore.writeRunRecord({
-                ...record,
-                status: 'failed',
-                finishedAt,
-                sentinel: 'FAILED',
-                summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
-                metadata: {
-                    ...record.metadata,
-                    reconciledBy: 'stale-running-record',
-                    timeoutMs: runnerTimeoutMs(),
-                },
-            });
-            const runCompletedEvent = createEventEnvelope({
-                eventId: `${record.runId}-stale-reconciled`,
-                workItemKey: projection.workItemKey,
-                streamScope: 'work-item',
-                direction: 'internal',
-                sourceSystem: 'wake',
-                sourceEventType: 'wake.run.completed',
-                sourceRefs: {
-                    repo: record.repo,
-                    issueNumber: record.issueNumber,
-                    runId: record.runId,
-                },
-                occurredAt: finishedAt,
-                ingestedAt: finishedAt,
-                trigger: 'immediate',
-                payload: {
-                    action: record.action,
-                    sentinel: 'FAILED',
-                    runId: record.runId,
-                    reason: 'runner:stale-timeout',
-                    ...(record.routing === undefined ? {} : { routing: record.routing }),
-                },
-            });
-            await deps.stateStore.appendEventEnvelope(runCompletedEvent);
-            await projectionUpdater.rebuildFromEvents([runCompletedEvent]);
-            const updatedProjection = await deps.stateStore.readIssueState(projection.workItemKey);
-            if (updatedProjection !== null) {
-                await deliverOutboundEvent(createLabelsEvent({
-                    projection: updatedProjection,
-                    runId: record.runId,
-                    statusLabel: 'wake:status.failed',
-                    stageLabel: stageLabelForStage(updatedProjection.wake.stage),
-                    workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(updatedProjection, deps.config)),
-                    occurredAt: finishedAt,
-                }));
-            }
-        }
-    }
     async function parkConfigDriftedProjections(projections) {
         let parked = false;
         for (const projection of projections) {
@@ -792,120 +243,6 @@ export function createTickRunner(deps) {
         }
         return parked;
     }
-    const outboxMaxAttempts = 3;
-    async function recordDeliveryFailure(intentEvent, err) {
-        const occurredAt = deps.clock.now().toISOString();
-        const failureEvent = createEventEnvelope({
-            eventId: `${intentEvent.eventId}-delivery-failed-${randomUUID()}`,
-            workItemKey: intentEvent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.failed',
-            sourceRefs: intentEvent.sourceRefs,
-            occurredAt,
-            ingestedAt: occurredAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: intentEvent.eventId,
-                intentEventType: intentEvent.sourceEventType,
-                error: err instanceof Error ? err.message : String(err),
-            },
-        });
-        await deps.stateStore.appendEventEnvelope(failureEvent);
-        await projectionUpdater.rebuildFromEvents([failureEvent]);
-    }
-    // Outbound delivery (comments, labels) is attempted independently of run-outcome
-    // recording: a delivery failure must never rewrite an already-recorded run result
-    // (S1), and must always leave a durable, retryable trace instead of being lost
-    // (E5). This never throws — failures become a `wake.publish.failed` event.
-    async function attemptDelivery(event) {
-        if (deps.outboundSink === undefined) {
-            return;
-        }
-        try {
-            const deliveryEvents = await deps.outboundSink.deliverIntent({ event });
-            for (const deliveryEvent of deliveryEvents) {
-                await deps.stateStore.appendEventEnvelope(deliveryEvent);
-            }
-            await projectionUpdater.rebuildFromEvents(deliveryEvents);
-            if (deliveryEvents.length === 0) {
-                // No confirmation event was produced (e.g. a no-op label update) but the
-                // sink did not throw. Record that delivery was attempted successfully so
-                // the outbox scan below does not retry it indefinitely.
-                const confirmedAt = deps.clock.now().toISOString();
-                const confirmedEvent = createEventEnvelope({
-                    eventId: `${event.eventId}-confirmed`,
-                    workItemKey: event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'internal',
-                    sourceSystem: 'wake',
-                    sourceEventType: 'wake.publish.confirmed',
-                    sourceRefs: event.sourceRefs,
-                    occurredAt: confirmedAt,
-                    ingestedAt: confirmedAt,
-                    trigger: 'context-only',
-                    payload: { intentEventId: event.eventId },
-                });
-                await deps.stateStore.appendEventEnvelope(confirmedEvent);
-            }
-        }
-        catch (err) {
-            await recordDeliveryFailure(event, err);
-        }
-    }
-    async function deliverOutboundEvent(event) {
-        await deps.stateStore.appendEventEnvelope(event);
-        await projectionUpdater.rebuildFromEvents([event]);
-        await attemptDelivery(event);
-    }
-    const outboundIntentEventTypes = new Set([
-        'wake.publish.intent.requested',
-        'wake.labels.requested',
-    ]);
-    const outboundConfirmationEventTypes = new Set([
-        'ticket.reply.published',
-        'ticket.labels.updated',
-        'wake.publish.confirmed',
-        'pr.comment.reply.published',
-        'pr.review-comment.reply.published',
-    ]);
-    // Adopts the outbox pattern: an intent is only considered delivered once a
-    // matching confirmation event exists. Anything left unconfirmed by a prior tick
-    // (e.g. the process crashed mid-delivery) is retried here, bounded so a
-    // permanently failing sink dead-letters instead of retrying forever.
-    async function retryUnconfirmedDeliveries() {
-        if (deps.outboundSink === undefined) {
-            return;
-        }
-        const events = await deps.stateStore.listEventEnvelopes();
-        const confirmedIntentIds = new Set();
-        const failureAttempts = new Map();
-        for (const event of events) {
-            const intentEventId = event.payload.intentEventId;
-            if (typeof intentEventId !== 'string') {
-                continue;
-            }
-            if (outboundConfirmationEventTypes.has(event.sourceEventType)) {
-                confirmedIntentIds.add(intentEventId);
-            }
-            if (event.sourceEventType === 'wake.publish.failed') {
-                failureAttempts.set(intentEventId, (failureAttempts.get(intentEventId) ?? 0) + 1);
-            }
-        }
-        for (const intent of events) {
-            if (!outboundIntentEventTypes.has(intent.sourceEventType)) {
-                continue;
-            }
-            if (confirmedIntentIds.has(intent.eventId)) {
-                continue;
-            }
-            if ((failureAttempts.get(intent.eventId) ?? 0) >= outboxMaxAttempts) {
-                continue;
-            }
-            await attemptDelivery(intent);
-        }
-    }
     async function runIntakeTick() {
         const lock = await acquireFileLock(deps.stateStore.paths.tickLockFile, {
             staleAfterMs: Math.min(runnerTimeoutMs(), 5 * 60 * 1000),
@@ -952,22 +289,7 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            const candidate = projections.find((issue) => {
-                if (!policy.isEligible(issue, deps.config)) {
-                    return false;
-                }
-                const workflow = workflowForProjection(issue, deps.config);
-                if (workflow === null || !isKnownWorkflowStage(issue.wake.stage, workflow)) {
-                    return false;
-                }
-                if (isAwaitingApproval(issue)) {
-                    return policy.needsWakeAction(issue, workflow);
-                }
-                const nextAction = policy.resolveCustomCommandRequest(issue, deps.config)?.action ??
-                    policy.chooseAction(issue, workflow) ??
-                    policy.chooseRetryActionAfterHumanReply(issue);
-                return nextAction !== null && policy.needsWakeAction(issue, workflow);
-            });
+            const candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
             if (candidate === undefined) {
                 return { status: 'idle' };
             }
@@ -1069,7 +391,7 @@ export function createTickRunner(deps) {
                 // back to a full fresh `implement` run and lost the PR-feedback
                 // context).
                 const nextAction = policy.resolveCustomCommandRequest(candidate, deps.config)?.action ??
-                    policy.chooseRetryActionAfterHumanReply(candidate) ??
+                    policy.chooseRetryActionAfterHumanReply(candidate, workflow) ??
                     workflowAction?.action ??
                     null;
                 if (nextAction === null) {
@@ -1079,7 +401,7 @@ export function createTickRunner(deps) {
                 command = policy.resolveCustomCommandRequest(candidate, deps.config)?.command;
                 claimedStage = workflowAction?.stage ?? candidate.wake.stage;
                 workspaceMode =
-                    workspaceModeForCustomCommand(action, deps.config) ?? workflowAction?.workspace ?? 'none';
+                    customCommandWorkspace(action, deps.config) ?? workflowAction?.workspace ?? 'none';
             }
             // Resolve routing (with sideways fallback across quota-paused runners,
             // #67) before claiming a run, so a fully-paused tier costs nothing more