patchrelay 0.75.0 → 0.75.2

package/dist/event-retention.js

@@ -0,0 +1,100 @@
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { once } from "node:events";
+import { createGzip } from "node:zlib";
+export const DEFAULT_EVENT_RETENTION_DAYS = 7;
+const DEFAULT_BATCH_SIZE = 1_000;
+export async function runWebhookEventRetention(params) {
+    const retentionDays = params.options?.retentionDays
+        ?? params.config.database.eventRetentionDays
+        ?? DEFAULT_EVENT_RETENTION_DAYS;
+    const cutoffIso = computeRetentionCutoffIso(params.options?.now ?? new Date(), retentionDays);
+    const batchSize = Math.max(1, Math.floor(params.options?.batchSize ?? DEFAULT_BATCH_SIZE));
+    const archiveOldEvents = params.options?.archiveOldEvents ?? params.config.database.archiveOldEvents === true;
+    const archivePath = params.options?.archivePath ?? params.config.database.archivePath;
+    const dryRun = params.options?.dryRun === true;
+    let scanned = 0;
+    let archived = 0;
+    let deleted = 0;
+    let writer;
+    if (dryRun) {
+        const remaining = params.db.webhookEvents.countArchiveableEventsBefore(cutoffIso);
+        return {
+            cutoffIso,
+            scanned: remaining,
+            archived: 0,
+            deleted: 0,
+            remaining,
+            dryRun,
+        };
+    }
+    try {
+        if (archiveOldEvents) {
+            writer = await JsonlGzipArchiveWriter.create(resolveArchiveFilePath(archivePath, params.options?.now ?? new Date()));
+        }
+        while (true) {
+            const records = params.db.webhookEvents.listArchiveableEventsBefore(cutoffIso, batchSize);
+            if (records.length === 0)
+                break;
+            scanned += records.length;
+            if (writer) {
+                await writer.writeRecords(records);
+                archived += records.length;
+            }
+            deleted += params.db.webhookEvents.deleteWebhookEventsByIds(records.map((record) => record.id));
+            if (records.length < batchSize)
+                break;
+        }
+    }
+    finally {
+        await writer?.close();
+    }
+    const remaining = params.db.webhookEvents.countArchiveableEventsBefore(cutoffIso);
+    return {
+        cutoffIso,
+        scanned,
+        archived,
+        deleted,
+        remaining,
+        ...(writer?.filePath ? { archiveFile: writer.filePath } : {}),
+        dryRun,
+    };
+}
+export function computeRetentionCutoffIso(now, retentionDays) {
+    return new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+}
+function resolveArchiveFilePath(archivePath, now) {
+    const root = archivePath ?? path.join(process.cwd(), "archive");
+    const stamp = now.toISOString().replaceAll(":", "-").replaceAll(".", "-");
+    return path.join(root, "webhook-events", `${stamp}.jsonl.gz`);
+}
+class JsonlGzipArchiveWriter {
+    filePath;
+    gzip;
+    output;
+    constructor(filePath, gzip, output) {
+        this.filePath = filePath;
+        this.gzip = gzip;
+        this.output = output;
+    }
+    static async create(filePath) {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        const gzip = createGzip();
+        const output = createWriteStream(filePath, { flags: "wx" });
+        gzip.pipe(output);
+        return new JsonlGzipArchiveWriter(filePath, gzip, output);
+    }
+    async writeRecords(records) {
+        for (const record of records) {
+            const line = `${JSON.stringify(record)}\n`;
+            if (!this.gzip.write(line)) {
+                await once(this.gzip, "drain");
+            }
+        }
+    }
+    async close() {
+        this.gzip.end();
+        await once(this.output, "close");
+    }
+}

package/dist/idle-reconciliation.js

@@ -12,6 +12,10 @@ import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 import { buildPrStateUpdates } from "./reconcile-pr-state-updates.js";
 import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
+import { LinearIssueProjectionService } from "./linear-issue-projection.js";
+import { TerminalWakeReconciler } from "./terminal-wake-reconciler.js";
+const BLOCKED_DEPENDENCY_REFRESH_SUCCESS_BACKOFF_MS = 60_000;
+const BLOCKED_DEPENDENCY_REFRESH_FAILURE_BACKOFF_MS = 5 * 60_000;
 export class IdleIssueReconciler {
     db;
     config;
@@ -20,9 +24,13 @@ export class IdleIssueReconciler {
     feed;
     deployEvaluator;
     syncIssue;
+    linearProvider;
+    blockedDependencyRefreshAfter = new Map();
+    terminalWakeReconciler;
+    linearIssueProjection;
     constructor(db, config, wakeDispatcher, logger, feed, 
     // Injectable for tests; production uses the real `gh`-backed watcher.
-    deployEvaluator = evaluateDeploy, syncIssue) {
+    deployEvaluator = evaluateDeploy, syncIssue, linearProvider) {
         this.db = db;
         this.config = config;
         this.wakeDispatcher = wakeDispatcher;
@@ -30,6 +38,11 @@ export class IdleIssueReconciler {
         this.feed = feed;
         this.deployEvaluator = deployEvaluator;
         this.syncIssue = syncIssue;
+        this.linearProvider = linearProvider;
+        this.terminalWakeReconciler = new TerminalWakeReconciler(db, logger);
+        this.linearIssueProjection = linearProvider
+            ? new LinearIssueProjectionService(db, linearProvider, logger)
+            : undefined;
     }
     async reconcile() {
         // Wrap the entire reconcile pass in a dispatcher tick. Every
@@ -82,9 +95,21 @@ export class IdleIssueReconciler {
                 continue;
             await this.reconcileFromGitHub(issue);
         }
+        this.terminalWakeReconciler.reconcile();
         for (const issue of this.db.issues.listBlockedDelegatedIssues()) {
             if (!issue.delegatedToPatchRelay)
                 continue;
+            const dependencyKey = `${issue.projectId}::${issue.linearIssueId}`;
+            const refreshAfter = this.blockedDependencyRefreshAfter.get(dependencyKey);
+            if (this.linearIssueProjection) {
+                if (refreshAfter === undefined || refreshAfter <= Date.now()) {
+                    const refresh = await this.linearIssueProjection.refreshIssue(issue.projectId, issue.linearIssueId);
+                    this.blockedDependencyRefreshAfter.set(dependencyKey, Date.now() + (refresh.refreshed ? BLOCKED_DEPENDENCY_REFRESH_SUCCESS_BACKOFF_MS : BLOCKED_DEPENDENCY_REFRESH_FAILURE_BACKOFF_MS));
+                    if (!refresh.refreshed) {
+                        continue;
+                    }
+                }
+            }
             const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
                 this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {

package/dist/issue-session-projection-invalidator.js

@@ -1,9 +1,23 @@
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 export class ImmediateIssueSessionProjectionInvalidator {
     deps;
+    batchDepth = 0;
+    pendingProjections = new Map();
     constructor(deps) {
         this.deps = deps;
     }
+    batch(fn) {
+        this.batchDepth += 1;
+        try {
+            return fn();
+        }
+        finally {
+            this.batchDepth -= 1;
+            if (this.batchDepth === 0) {
+                this.flushPendingProjections();
+            }
+        }
+    }
     issueChanged(issue, options) {
         const dependents = this.deps.listDependents(issue.projectId, issue.linearIssueId);
         this.emitInvalidated("issue_changed", issue.projectId, issue.linearIssueId, issue.issueKey, 1 + dependents.length);
@@ -32,12 +46,26 @@ export class ImmediateIssueSessionProjectionInvalidator {
         this.projectIssueById(projectId, linearIssueId, "issue_session_events_changed");
     }
     projectIssueById(projectId, linearIssueId, reason) {
+        if (this.batchDepth > 0) {
+            this.queueProjection({ projectId, linearIssueId, reason });
+            return;
+        }
         const issue = this.deps.getIssue(projectId, linearIssueId);
         if (issue) {
             this.projectIssue(issue, reason);
         }
     }
     projectIssue(issue, reason, options) {
+        if (this.batchDepth > 0) {
+            this.queueProjection({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                issue,
+                reason,
+                ...(options ? { options } : {}),
+            });
+            return;
+        }
         const beforeWaitingReason = this.deps.getIssueSessionWaitingReason?.(issue.projectId, issue.linearIssueId);
         this.deps.projectIssue(issue, options);
         this.emitReprojected(reason, issue);
@@ -87,4 +115,32 @@ export class ImmediateIssueSessionProjectionInvalidator {
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
         });
     }
+    queueProjection(projection) {
+        const key = `${projection.projectId}::${projection.linearIssueId}`;
+        const current = this.pendingProjections.get(key);
+        this.pendingProjections.set(key, {
+            projectId: projection.projectId,
+            linearIssueId: projection.linearIssueId,
+            issue: projection.issue ?? current?.issue,
+            reason: projection.reason,
+            options: mergeProjectionOptions(current?.options, projection.options),
+        });
+    }
+    flushPendingProjections() {
+        const pending = Array.from(this.pendingProjections.values());
+        this.pendingProjections.clear();
+        for (const projection of pending) {
+            const issue = projection.issue ?? this.deps.getIssue(projection.projectId, projection.linearIssueId);
+            if (issue) {
+                this.projectIssue(issue, projection.reason, projection.options);
+            }
+        }
+    }
+}
+function mergeProjectionOptions(current, next) {
+    if (!current)
+        return next;
+    if (!next)
+        return current;
+    return { ...current, ...next };
 }

package/dist/linear-client.js

@@ -113,6 +113,45 @@ export class LinearGraphqlClient {
         }
         return this.mapIssue(response.issue);
     }
+    async listIssuesDelegatedTo(params) {
+        const teamIds = params.teamIds.filter((teamId) => teamId.trim().length > 0);
+        if (teamIds.length === 0) {
+            return [];
+        }
+        const first = Math.max(1, Math.min(params.first ?? 100, 100));
+        const issues = [];
+        let after;
+        do {
+            const response = await this.request(`
+        query PatchRelayDelegatedIssues($delegateId: ID!, $teamIds: [ID!], $first: Int!, $after: String) {
+          issues(
+            first: $first
+            after: $after
+            filter: {
+              delegate: { id: { eq: $delegateId } }
+              team: { id: { in: $teamIds } }
+            }
+          ) {
+            nodes {
+              ${LINEAR_ISSUE_SELECTION}
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+        `, {
+                delegateId: params.delegateId,
+                teamIds,
+                first,
+                after: after ?? null,
+            });
+            issues.push(...(response.issues.nodes ?? []).map((issue) => this.mapIssue(issue)));
+            after = response.issues.pageInfo.hasNextPage ? response.issues.pageInfo.endCursor ?? undefined : undefined;
+        } while (after);
+        return issues;
+    }
     async createIssue(params) {
         const response = await this.request(`
       mutation PatchRelayCreateIssue($input: IssueCreateInput!) {

package/dist/linear-issue-projection.js

@@ -0,0 +1,79 @@
+export class LinearIssueProjectionService {
+    db;
+    linearProvider;
+    logger;
+    constructor(db, linearProvider, logger) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+    }
+    async refreshIssue(projectId, linearIssueId) {
+        return refreshIssueFromLinear({
+            db: this.db,
+            linearProvider: this.linearProvider,
+            projectId,
+            linearIssueId,
+            logger: this.logger,
+        });
+    }
+}
+export async function refreshIssueFromLinear(params) {
+    const linear = await params.linearProvider.forProject(params.projectId).catch((error) => {
+        params.logger?.warn({
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Failed to resolve Linear client while refreshing issue projection");
+        return undefined;
+    });
+    if (!linear) {
+        return { refreshed: false, error: "linear_client_unavailable" };
+    }
+    try {
+        const liveIssue = await linear.getIssue(params.linearIssueId);
+        upsertLinearIssueProjection(params.db, params.projectId, liveIssue);
+        return { refreshed: true, liveIssue };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        params.logger?.warn({
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            error: message,
+        }, "Failed to refresh issue projection from Linear");
+        return { refreshed: false, error: message };
+    }
+}
+export function upsertLinearIssueProjection(db, projectId, liveIssue) {
+    replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue);
+    db.issues.replaceIssueParentLink({
+        projectId,
+        childLinearIssueId: liveIssue.id,
+        parentLinearIssueId: liveIssue.parentId ?? null,
+    });
+    db.issues.upsertIssue({
+        projectId,
+        linearIssueId: liveIssue.id,
+        ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+        ...(liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(liveIssue.description ? { description: liveIssue.description } : {}),
+        ...(liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+        ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+    });
+}
+export function replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue) {
+    db.issues.replaceIssueDependencies({
+        projectId,
+        linearIssueId: liveIssue.id,
+        blockers: liveIssue.blockedBy.map((blocker) => ({
+            blockerLinearIssueId: blocker.id,
+            ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+            ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+            ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+            ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+        })),
+    });
+}

package/dist/merged-linear-completion-reconciler.js

@@ -2,6 +2,7 @@ import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
+import { replaceIssueDependenciesFromLinearIssue } from "./linear-issue-projection.js";
 const COMPLETION_RECONCILE_WINDOW_MS = 60 * 60 * 1000;
 const COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS = 60 * 60 * 1000;
 const COMPLETION_RECONCILE_FAILURE_BACKOFF_MS = 5 * 60 * 1000;
@@ -45,17 +46,7 @@ export class MergedLinearCompletionReconciler {
             attemptedIssues += 1;
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
-                this.db.issues.replaceIssueDependencies({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    blockers: liveIssue.blockedBy.map((blocker) => ({
-                        blockerLinearIssueId: blocker.id,
-                        ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
-                        ...(blocker.title ? { blockerTitle: blocker.title } : {}),
-                        ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
-                        ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
-                    })),
-                });
+                replaceIssueDependenciesFromLinearIssue(this.db, issue.projectId, liveIssue);
                 const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
                 const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
                 if (issue.prState === "merged" || trustedNoPrDone) {

package/dist/queue-failure-policy.js

@@ -0,0 +1,11 @@
+const SQLITE_LOCK_RETRY_DELAYS_MS = [250, 1_000, 2_500, 5_000, 10_000];
+export function retrySqliteLockedQueueFailure(error, attempt) {
+    if (!isSqliteDatabaseLockedError(error)) {
+        return undefined;
+    }
+    const delayMs = SQLITE_LOCK_RETRY_DELAYS_MS[attempt - 1];
+    return delayMs === undefined ? undefined : { delayMs };
+}
+export function isSqliteDatabaseLockedError(error) {
+    return /\bdatabase is locked\b/i.test(error.message);
+}

package/dist/run-admission-controller.js

@@ -0,0 +1,23 @@
+export class RunAdmissionController {
+    db;
+    linearIssueProjection;
+    constructor(db, linearIssueProjection) {
+        this.db = db;
+        this.linearIssueProjection = linearIssueProjection;
+    }
+    async check(params) {
+        if (params.runType !== "implementation") {
+            return { allowed: true };
+        }
+        const knownDependencyRows = this.db.issues.listIssueDependencies(params.projectId, params.linearIssueId).length;
+        const refresh = await this.linearIssueProjection.refreshIssue(params.projectId, params.linearIssueId);
+        if (!refresh.refreshed && knownDependencyRows > 0) {
+            return { allowed: false, reason: "dependency_refresh_failed", knownDependencyRows };
+        }
+        const blockerCount = this.db.issues.countUnresolvedBlockers(params.projectId, params.linearIssueId);
+        if (blockerCount > 0) {
+            return { allowed: false, reason: "blocked", blockerCount };
+        }
+        return { allowed: true };
+    }
+}

package/dist/run-launcher.js

@@ -104,53 +104,55 @@ export class RunLauncher {
     }
     claimRun(params) {
         return this.db.issueSessions.withIssueSessionLease(params.item.projectId, params.item.issueId, params.leaseId, () => {
-            const fresh = this.db.issues.getIssue(params.item.projectId, params.item.issueId);
-            if (!fresh || fresh.activeRunId !== undefined)
-                return undefined;
-            const wakeIssue = params.materializeLegacyPendingWake(fresh, {
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                leaseId: params.leaseId,
-            });
-            const freshWake = params.resolveRunWake(wakeIssue);
-            if (!freshWake || freshWake.runType !== params.runType)
-                return undefined;
-            const created = this.db.runs.createRun({
-                issueId: fresh.id,
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                runType: params.runType,
-                ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
-                promptText: params.prompt,
-            });
-            const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
-                ? params.effectiveContext.failureHeadSha
-                : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
-            const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
-            this.db.issues.upsertIssue({
-                projectId: params.item.projectId,
-                linearIssueId: params.item.issueId,
-                pendingRunType: null,
-                pendingRunContextJson: null,
-                activeRunId: created.id,
-                branchName: params.branchName,
-                worktreePath: params.worktreePath,
-                factoryState: params.runType === "implementation" ? "implementing"
-                    : params.runType === "ci_repair" ? "repairing_ci"
-                        : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
-                            : params.runType === "queue_repair" ? "repairing_queue"
-                                : "implementing",
-                ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
-                    ? {
-                        lastAttemptedFailureSignature: failureSignature,
-                        lastAttemptedFailureHeadSha: failureHeadSha ?? null,
-                        lastAttemptedFailureAt: new Date().toISOString(),
-                    }
-                    : {}),
+            return this.db.batchIssueSessionProjections(() => {
+                const fresh = this.db.issues.getIssue(params.item.projectId, params.item.issueId);
+                if (!fresh || fresh.activeRunId !== undefined)
+                    return undefined;
+                const wakeIssue = params.materializeLegacyPendingWake(fresh, {
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    leaseId: params.leaseId,
+                });
+                const freshWake = params.resolveRunWake(wakeIssue);
+                if (!freshWake || freshWake.runType !== params.runType)
+                    return undefined;
+                const created = this.db.runs.createRun({
+                    issueId: fresh.id,
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    runType: params.runType,
+                    ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
+                    promptText: params.prompt,
+                });
+                const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
+                    ? params.effectiveContext.failureHeadSha
+                    : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
+                const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
+                this.db.issues.upsertIssue({
+                    projectId: params.item.projectId,
+                    linearIssueId: params.item.issueId,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                    activeRunId: created.id,
+                    branchName: params.branchName,
+                    worktreePath: params.worktreePath,
+                    factoryState: params.runType === "implementation" ? "implementing"
+                        : params.runType === "ci_repair" ? "repairing_ci"
+                            : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
+                                : params.runType === "queue_repair" ? "repairing_queue"
+                                    : "implementing",
+                    ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
+                        ? {
+                            lastAttemptedFailureSignature: failureSignature,
+                            lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                            lastAttemptedFailureAt: new Date().toISOString(),
+                        }
+                        : {}),
+                });
+                this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
+                this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
+                return created;
             });
-            this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
-            this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
-            return created;
         });
     }
     async launchTurn(params) {
@@ -186,6 +188,7 @@ export class RunLauncher {
             if (prepareResult.ran && prepareResult.exitCode !== 0) {
                 throw new Error(`prepare-worktree hook failed (exit ${prepareResult.exitCode}): ${prepareResult.stderr?.slice(0, 500) ?? ""}`);
             }
+            this.db.runs.updateLaunchPhase(params.run.id, "worktree_prepared");
             params.assertLaunchLease(params.run, "before starting the Codex turn");
             const compactThread = shouldCompactThread(params.issue, params.issueSession?.threadGeneration, params.effectiveContext);
             if (compactThread && params.issue.threadId) {
@@ -200,9 +203,11 @@ export class RunLauncher {
                 createdThreadForRun = true;
                 this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
             }
+            this.db.runs.updateLaunchPhase(params.run.id, "thread_started");
             try {
                 const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
                 turnId = turn.turnId;
+                this.db.runs.updateLaunchPhase(params.run.id, "turn_started");
             }
             catch (turnError) {
                 const msg = turnError instanceof Error ? turnError.message : String(turnError);
@@ -214,6 +219,7 @@ export class RunLauncher {
                     this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
                     const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
                     turnId = turn.turnId;
+                    this.db.runs.updateLaunchPhase(params.run.id, "turn_started");
                 }
                 else {
                     throw turnError;

package/dist/run-orchestrator.js

@@ -24,6 +24,8 @@ import { buildIssueTriageHash, IssueTriageService } from "./issue-triage.js";
 import { loadConfig } from "./config.js";
 import { CodexThreadMaterializingError, isThreadMaterializingError } from "./codex-thread-errors.js";
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
+import { LinearIssueProjectionService } from "./linear-issue-projection.js";
+import { RunAdmissionController } from "./run-admission-controller.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -64,6 +66,8 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    linearIssueProjection;
+    runAdmission;
     codexRuntimeConfig;
     threadPorts = {
         readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
@@ -133,7 +137,9 @@ export class RunOrchestrator {
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
         this.runWakePlanner = new RunWakePlanner(db);
-        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue));
+        this.linearIssueProjection = new LinearIssueProjectionService(db, linearProvider, logger);
+        this.runAdmission = new RunAdmissionController(db, this.linearIssueProjection);
+        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue), linearProvider);
         this.mergedLinearCompletionReconciler = new MergedLinearCompletionReconciler(db, linearProvider, logger);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
@@ -312,12 +318,21 @@ export class RunOrchestrator {
             return;
         }
         const { runType, context, resumeThread } = wake;
-        if (runType === "implementation" && this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId) > 0) {
-            const blockerCount = this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId);
+        const admission = await this.runAdmission.check({
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+            runType,
+        });
+        if (!admission.allowed) {
             this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(item.projectId, item.issueId);
             this.releaseIssueSessionLease(item.projectId, item.issueId);
-            this.emitRunSkipped(item, "blocked", issue, { runType, blockerCount });
-            this.logger.info({ issueKey: issue.issueKey }, "Skipped implementation launch because the issue is blocked");
+            this.emitRunSkipped(item, admission.reason, issue, { runType, ...admission });
+            if (admission.reason === "dependency_refresh_failed") {
+                this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, knownDependencyRows: admission.knownDependencyRows }, "Skipped implementation launch because dependency refresh failed for an issue with known blockers");
+            }
+            else {
+                this.logger.info({ issueKey: issue.issueKey, blockerCount: admission.blockerCount }, "Skipped implementation launch because the issue is blocked");
+            }
             return;
         }
         const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);