patchrelay 0.8.9 → 0.9.0

package/dist/cli/data.js

@@ -4,11 +4,9 @@ import { CodexAppServerClient } from "../codex-app-server.js";
 import { PatchRelayDatabase } from "../db.js";
 import { WorktreeManager } from "../worktree-manager.js";
 import { CliOperatorApiClient } from "./operator-client.js";
-import { resolveWorkflowStage } from "../workflow-policy.js";
 function safeJsonParse(value) {
-    if (!value) {
+    if (!value)
         return undefined;
-    }
     try {
         const parsed = JSON.parse(value);
         return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
@@ -30,17 +28,10 @@ function summarizeThread(thread, latestTimestampSeen) {
         ...(latestTimestampSeen ? { latestTimestampSeen } : {}),
     };
 }
-function latestEventTimestamp(db, stageRunId) {
-    const events = db.stageEvents.listThreadEvents(stageRunId);
+function latestEventTimestamp(db, runId) {
+    const events = db.listThreadEvents(runId);
     return events.at(-1)?.createdAt;
 }
-function resolveStageFromState(config, projectId, stateName) {
-    const project = config.projects.find((entry) => entry.id === projectId);
-    if (!project) {
-        return undefined;
-    }
-    return resolveWorkflowStage(project, stateName);
-}
 export class CliDataAccess extends CliOperatorApiClient {
     config;
     db;
@@ -53,125 +44,103 @@ export class CliDataAccess extends CliOperatorApiClient {
         this.codex = options?.codex;
     }
     close() {
-        if (!this.codexStarted) {
+        if (!this.codexStarted)
             return;
-        }
         void this.codex?.stop();
         this.codexStarted = false;
     }
     async inspect(issueKey) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const ledger = this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        const workspace = this.getWorkspaceForIssue(issue, ledger);
-        const activeStageRun = this.getActiveStageRunForIssue(issue, ledger);
-        const latestStageRun = this.db.issueWorkflows.getLatestStageRunForIssue(issue.projectId, issue.linearIssueId);
-        const latestReport = latestStageRun?.reportJson ? JSON.parse(latestStageRun.reportJson) : undefined;
-        const latestSummary = safeJsonParse(latestStageRun?.summaryJson);
-        const live = activeStageRun?.threadId &&
-            (await this.readLiveSummary(activeStageRun.threadId, latestEventTimestamp(this.db, activeStageRun.id)).catch(() => undefined));
-        const statusNote = (live && live.latestAssistantMessage) ??
-            latestReport?.assistantMessages.at(-1) ??
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const activeRun = dbIssue.activeRunId ? this.db.getRun(dbIssue.activeRunId) : undefined;
+        const latestRun = this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const latestReport = latestRun?.reportJson ? JSON.parse(latestRun.reportJson) : undefined;
+        const latestSummary = safeJsonParse(latestRun?.summaryJson);
+        const statusNote = latestReport?.assistantMessages.at(-1) ??
             (typeof latestSummary?.latestAssistantMessage === "string" ? latestSummary.latestAssistantMessage : undefined) ??
-            (latestStageRun?.status === "failed" ? "Latest stage failed." : undefined) ??
-            (issue.desiredStage ? `Queued for ${issue.desiredStage}.` : undefined) ??
+            (latestRun?.status === "failed" ? "Latest run failed." : undefined) ??
             undefined;
         return {
             issue,
-            ...(workspace ? { workspace } : {}),
-            ...(activeStageRun ? { activeStageRun } : {}),
-            ...(latestStageRun ? { latestStageRun } : {}),
+            ...(activeRun ? { activeRun } : {}),
+            ...(!activeRun && latestRun ? { latestRun } : {}),
             ...(latestReport ? { latestReport } : {}),
             ...(latestSummary ? { latestSummary } : {}),
-            ...(live ? { live } : {}),
+            ...(dbIssue.prNumber ? { prNumber: dbIssue.prNumber } : {}),
+            ...(dbIssue.prReviewState ? { prReviewState: dbIssue.prReviewState } : {}),
             ...(statusNote ? { statusNote } : {}),
         };
     }
     async live(issueKey) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const stageRun = this.getActiveStageRunForIssue(issue);
-        if (!stageRun) {
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const run = dbIssue.activeRunId ? this.db.getRun(dbIssue.activeRunId) : undefined;
+        if (!run)
             return undefined;
-        }
-        const live = stageRun.threadId &&
-            (await this.readLiveSummary(stageRun.threadId, latestEventTimestamp(this.db, stageRun.id)).catch(() => undefined));
-        return {
-            issue,
-            stageRun,
-            ...(live ? { live } : {}),
-        };
+        const live = run.threadId &&
+            (await this.readLiveSummary(run.threadId, latestEventTimestamp(this.db, run.id)).catch(() => undefined));
+        return { issue, run, ...(live ? { live } : {}) };
     }
     report(issueKey, options) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const stages = this.db
-            .issueWorkflows.listStageRunsForIssue(issue.projectId, issue.linearIssueId)
-            .filter((stageRun) => {
-            if (options?.stageRunId !== undefined && stageRun.id !== options.stageRunId) {
+        const runs = this.db
+            .listRunsForIssue(issue.projectId, issue.linearIssueId)
+            .filter((run) => {
+            if (options?.runId !== undefined && run.id !== options.runId)
                 return false;
-            }
-            if (options?.stage !== undefined && stageRun.stage !== options.stage) {
+            if (options?.runType !== undefined && run.runType !== options.runType)
                 return false;
-            }
             return true;
         })
             .reverse()
-            .map((stageRun) => ({
-            stageRun,
-            ...(stageRun.reportJson ? { report: JSON.parse(stageRun.reportJson) } : {}),
-            ...(safeJsonParse(stageRun.summaryJson) ? { summary: safeJsonParse(stageRun.summaryJson) } : {}),
+            .map((run) => ({
+            run,
+            ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
+            ...(safeJsonParse(run.summaryJson) ? { summary: safeJsonParse(run.summaryJson) } : {}),
         }));
-        return { issue, stages };
+        return { issue, runs };
     }
     events(issueKey, options) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const stageRun = (options?.stageRunId !== undefined ? this.db.issueWorkflows.getStageRun(options.stageRunId) : undefined) ??
-            this.getActiveStageRunForIssue(issue) ??
-            this.db.issueWorkflows.getLatestStageRunForIssue(issue.projectId, issue.linearIssueId);
-        if (!stageRun || stageRun.projectId !== issue.projectId || stageRun.linearIssueId !== issue.linearIssueId) {
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const run = (options?.runId !== undefined ? this.db.getRun(options.runId) : undefined) ??
+            (dbIssue.activeRunId ? this.db.getRun(dbIssue.activeRunId) : undefined) ??
+            this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        if (!run || run.projectId !== issue.projectId || run.linearIssueId !== issue.linearIssueId)
             return undefined;
-        }
         const events = this.db
-            .stageEvents.listThreadEvents(stageRun.id)
+            .listThreadEvents(run.id)
             .filter((event) => (options?.method ? event.method === options.method : true))
             .filter((event) => (options?.afterId !== undefined ? event.id > options.afterId : true))
             .map((event) => ({
             ...event,
             ...(safeJsonParse(event.eventJson) ? { parsedEvent: safeJsonParse(event.eventJson) } : {}),
         }));
-        return { issue, stageRun, events };
+        return { issue, run, events };
     }
     worktree(issueKey) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const workspace = this.getWorkspaceForIssue(issue);
-        if (!workspace) {
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        if (!dbIssue.branchName || !dbIssue.worktreePath)
             return undefined;
-        }
-        return {
-            issue,
-            workspace,
-            repoId: issue.projectId,
-        };
+        return { issue, branchName: dbIssue.branchName, worktreePath: dbIssue.worktreePath, repoId: issue.projectId };
     }
     open(issueKey) {
         const worktree = this.worktree(issueKey);
-        if (!worktree) {
+        if (!worktree)
             return undefined;
-        }
-        const resumeThreadId = this.getStoredOpenThreadId(worktree);
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const resumeThreadId = dbIssue.threadId ?? undefined;
         return {
             ...worktree,
             ...(resumeThreadId ? { resumeThreadId } : {}),
@@ -179,256 +148,100 @@ export class CliDataAccess extends CliOperatorApiClient {
     }
     async resolveOpen(issueKey, options) {
         const worktree = this.worktree(issueKey);
-        if (!worktree) {
+        if (!worktree)
             return undefined;
-        }
         if (options?.ensureWorktree) {
             await this.ensureOpenWorktree(worktree);
         }
-        const existingThreadId = await this.resolveStoredOpenThreadId(worktree);
-        if (existingThreadId) {
-            return {
-                ...worktree,
-                resumeThreadId: existingThreadId,
-            };
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const existingThreadId = dbIssue.threadId;
+        if (existingThreadId && (await this.canReadThread(existingThreadId))) {
+            return { ...worktree, resumeThreadId: existingThreadId };
         }
         if (!options?.createThreadIfMissing) {
-            return {
-                ...worktree,
-                needsNewSession: true,
-            };
+            return { ...worktree, needsNewSession: true };
         }
         const codex = await this.getCodex();
-        const thread = await codex.startThread({
-            cwd: worktree.workspace.worktreePath,
-        });
-        this.db.issueSessions.upsertIssueSession({
+        const thread = await codex.startThread({ cwd: worktree.worktreePath });
+        this.db.upsertIssue({
             projectId: worktree.issue.projectId,
             linearIssueId: worktree.issue.linearIssueId,
-            workspaceOwnershipId: worktree.workspace.id,
             threadId: thread.id,
-            source: "operator_open",
-            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
         });
-        this.db.issueSessions.touchIssueSession(thread.id);
-        return {
-            ...worktree,
-            resumeThreadId: thread.id,
-        };
+        return { ...worktree, resumeThreadId: thread.id };
     }
     async prepareOpen(issueKey) {
-        return await this.resolveOpen(issueKey, {
-            ensureWorktree: true,
-            createThreadIfMissing: true,
-        });
+        return await this.resolveOpen(issueKey, { ensureWorktree: true, createThreadIfMissing: true });
     }
     retry(issueKey, options) {
-        const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        if (dbIssue.activeRunId !== undefined) {
+            throw new Error(`Issue ${issueKey} already has an active run.`);
         }
-        const ledger = this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        if (ledger.issueControl?.activeRunLeaseId !== undefined) {
-            throw new Error(`Issue ${issueKey} already has an active stage run.`);
-        }
-        const stage = options?.stage ?? resolveStageFromState(this.config, issue.projectId, issue.currentLinearState);
-        if (!stage) {
-            throw new Error(`Unable to infer a stage for ${issueKey}; pass --stage.`);
-        }
-        const webhookId = `cli-retry-${Date.now()}`;
-        const receipt = this.db.eventReceipts.insertEventReceipt({
-            source: "linear-webhook",
-            externalId: webhookId,
-            eventType: "cli-retry",
-            receivedAt: new Date().toISOString(),
-            acceptanceStatus: "accepted",
+        const runType = (options?.runType ?? "implementation");
+        this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
+            pendingRunType: runType,
+            factoryState: "delegated",
         });
-        this.db.workflowCoordinator.setIssueDesiredStage(issue.projectId, issue.linearIssueId, stage, {
-            desiredReceiptId: receipt.id,
-            lifecycleStatus: "queued",
-        });
-        const updated = this.db.issueWorkflows.getTrackedIssue(issue.projectId, issue.linearIssueId);
-        return {
-            issue: updated,
-            stage,
-            ...(options?.reason ? { reason: options.reason } : {}),
-        };
+        const updated = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
+        return { issue: updated, runType, ...(options?.reason ? { reason: options.reason } : {}) };
     }
     list(options) {
         const conditions = [];
         const values = [];
         if (options?.project) {
-            conditions.push("ai.project_id = ?");
+            conditions.push("i.project_id = ?");
             values.push(options.project);
         }
         const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
         const rows = this.db.connection
             .prepare(`
-        WITH all_issues AS (
-          SELECT project_id, linear_issue_id FROM issue_projection
-          UNION
-          SELECT project_id, linear_issue_id FROM issue_control
-        )
         SELECT
-          ai.project_id,
-          ai.linear_issue_id,
-          ip.issue_key,
-          ip.title,
-          ip.current_linear_state,
-          COALESCE(ic.lifecycle_status, 'idle') AS lifecycle_status,
-          COALESCE(ic.updated_at, ip.updated_at) AS updated_at,
-          active_run.stage AS active_stage,
-          latest_run.stage AS latest_stage,
-          latest_run.status AS latest_stage_status
-        FROM all_issues ai
-        LEFT JOIN issue_projection ip
-          ON ip.project_id = ai.project_id AND ip.linear_issue_id = ai.linear_issue_id
-        LEFT JOIN issue_control ic
-          ON ic.project_id = ai.project_id AND ic.linear_issue_id = ai.linear_issue_id
-        LEFT JOIN run_leases active_run
-          ON active_run.id = ic.active_run_lease_id
-        LEFT JOIN run_leases latest_run ON latest_run.id = (
-          SELECT rl.id
-          FROM run_leases rl
-          WHERE rl.project_id = ai.project_id AND rl.linear_issue_id = ai.linear_issue_id
-          ORDER BY rl.id DESC
-          LIMIT 1
+          i.project_id,
+          i.linear_issue_id,
+          i.issue_key,
+          i.title,
+          i.current_linear_state,
+          i.factory_state,
+          i.updated_at,
+          active_run.run_type AS active_run_type,
+          latest_run.run_type AS latest_run_type,
+          latest_run.status AS latest_run_status
+        FROM issues i
+        LEFT JOIN runs active_run ON active_run.id = i.active_run_id
+        LEFT JOIN runs latest_run ON latest_run.id = (
+          SELECT r.id FROM runs r
+          WHERE r.project_id = i.project_id AND r.linear_issue_id = i.linear_issue_id
+          ORDER BY r.id DESC LIMIT 1
         )
         ${whereClause}
-        ORDER BY COALESCE(ic.updated_at, ip.updated_at) DESC, ip.issue_key ASC, ai.linear_issue_id ASC
+        ORDER BY i.updated_at DESC, i.issue_key ASC
         `)
             .all(...values);
-        const items = rows.map((row) => {
-            const projectId = String(row.project_id);
-            const linearIssueId = String(row.linear_issue_id);
-            const issueKey = row.issue_key === null ? undefined : String(row.issue_key);
-            const issue = this.db.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
-            const ledger = issue ? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId) : undefined;
-            return {
-                ...(issueKey ? { issueKey } : {}),
-                ...(row.title === null ? {} : { title: String(row.title) }),
-                projectId,
-                ...(row.current_linear_state === null ? {} : { currentLinearState: String(row.current_linear_state) }),
-                lifecycleStatus: String(row.lifecycle_status),
-                ...(ledger?.runLease
-                    ? { activeStage: ledger.runLease.stage }
-                    : row.active_stage !== null
-                        ? { activeStage: row.active_stage }
-                        : {}),
-                ...(row.latest_stage !== null
-                    ? { latestStage: row.latest_stage }
-                    : ledger?.runLease
-                        ? { latestStage: ledger.runLease.stage }
-                        : {}),
-                ...(row.latest_stage_status !== null
-                    ? { latestStageStatus: String(row.latest_stage_status) }
-                    : ledger?.runLease
-                        ? {
-                            latestStageStatus: ledger.runLease.status === "failed"
-                                ? "failed"
-                                : ledger.runLease.status === "completed" || ledger.runLease.status === "released" || ledger.runLease.status === "paused"
-                                    ? "completed"
-                                    : "running",
-                        }
-                        : {}),
-                updatedAt: String(row.updated_at),
-            };
-        });
+        const items = rows.map((row) => ({
+            ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
+            ...(row.title !== null ? { title: String(row.title) } : {}),
+            projectId: String(row.project_id),
+            ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
+            factoryState: String(row.factory_state ?? "delegated"),
+            ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+            ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
+            ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
+            updatedAt: String(row.updated_at),
+        }));
         return items.filter((item) => {
-            if (options?.active && !item.activeStage) {
+            if (options?.active && !item.activeRunType)
                 return false;
-            }
-            if (options?.failed && item.latestStageStatus !== "failed") {
+            if (options?.failed && item.latestRunStatus !== "failed")
                 return false;
-            }
             return true;
         });
     }
-    getLedgerIssueContext(projectId, linearIssueId) {
-        const issueControl = this.db.issueControl.getIssueControl(projectId, linearIssueId);
-        const runLease = issueControl?.activeRunLeaseId ? this.db.runLeases.getRunLease(issueControl.activeRunLeaseId) : undefined;
-        return {
-            ...(issueControl ? { issueControl } : {}),
-            ...(runLease ? { runLease } : {}),
-        };
-    }
-    getActiveStageRunForIssue(issue, ledger) {
-        const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        const activeStageRun = context.issueControl?.activeRunLeaseId
-            ? this.db.issueWorkflows.getStageRun(context.issueControl.activeRunLeaseId)
-            : undefined;
-        if (!activeStageRun) {
-            return undefined;
-        }
-        return activeStageRun.projectId === issue.projectId && activeStageRun.linearIssueId === issue.linearIssueId
-            ? activeStageRun
-            : undefined;
-    }
-    getWorkspaceForIssue(issue, ledger) {
-        const context = ledger ?? this.getLedgerIssueContext(issue.projectId, issue.linearIssueId);
-        if (context.issueControl?.activeWorkspaceOwnershipId !== undefined) {
-            const activeWorkspace = this.db.issueWorkflows.getWorkspace(context.issueControl.activeWorkspaceOwnershipId);
-            if (activeWorkspace) {
-                return activeWorkspace;
-            }
-        }
-        return this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
-    }
-    getStoredOpenThreadId(worktree) {
-        return this.listOpenCandidateThreadIds(worktree).at(0);
-    }
-    async resolveStoredOpenThreadId(worktree) {
-        for (const threadId of this.listOpenCandidateThreadIds(worktree)) {
-            if (!(await this.canReadThread(threadId))) {
-                continue;
-            }
-            this.recordOpenThreadForIssue(worktree, threadId);
-            return threadId;
-        }
-        return undefined;
-    }
-    listOpenCandidateThreadIds(worktree) {
-        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
-        const sessions = this.db.issueSessions.listIssueSessionsForIssue(worktree.issue.projectId, worktree.issue.linearIssueId);
-        const candidates = [
-            ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined,
-            ...sessions.map((session) => session.threadId),
-            worktree.workspace.lastThreadId,
-            worktree.issue.latestThreadId,
-            ledger.runLease?.threadId,
-        ];
-        const seen = new Set();
-        const ordered = [];
-        for (const candidate of candidates) {
-            if (!candidate || seen.has(candidate)) {
-                continue;
-            }
-            seen.add(candidate);
-            ordered.push(candidate);
-        }
-        return ordered;
-    }
-    recordOpenThreadForIssue(worktree, threadId) {
-        const existing = this.db.issueSessions.getIssueSessionByThreadId(threadId);
-        if (existing) {
-            this.db.issueSessions.touchIssueSession(threadId);
-            return;
-        }
-        const runLease = this.db.runLeases.getRunLeaseByThreadId(threadId);
-        this.db.issueSessions.upsertIssueSession({
-            projectId: worktree.issue.projectId,
-            linearIssueId: worktree.issue.linearIssueId,
-            workspaceOwnershipId: runLease?.workspaceOwnershipId ?? worktree.workspace.id,
-            threadId,
-            source: runLease ? "stage_run" : "operator_open",
-            ...(runLease?.id !== undefined ? { runLeaseId: runLease.id } : {}),
-            ...(runLease?.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
-            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
-        });
-        this.db.issueSessions.touchIssueSession(threadId);
-    }
     async canReadThread(threadId) {
         try {
             const codex = await this.getCodex();
@@ -440,15 +253,13 @@ export class CliDataAccess extends CliOperatorApiClient {
         }
     }
     async ensureOpenWorktree(worktree) {
-        if (existsSync(worktree.workspace.worktreePath)) {
+        if (existsSync(worktree.worktreePath))
             return;
-        }
         const project = this.config.projects.find((entry) => entry.id === worktree.repoId);
-        if (!project) {
+        if (!project)
             throw new Error(`Project not found for ${worktree.repoId}`);
-        }
         const worktreeManager = new WorktreeManager(this.config);
-        await worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktree.workspace.worktreePath, worktree.workspace.branchName);
+        await worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktree.worktreePath, worktree.branchName);
     }
     async readLiveSummary(threadId, latestTimestampSeen) {
         const codex = await this.getCodex();

package/dist/cli/formatters/text.js

@@ -15,34 +15,28 @@ export function formatInspect(result) {
     const lines = [
         header,
         value("Title", result.issue?.title),
-        value("Lifecycle", result.issue?.lifecycleStatus),
-        value("Active stage", result.activeStageRun?.stage),
-        value("Latest stage", result.latestStageRun?.stage),
-        value("Latest result", result.latestStageRun?.status),
-        value("Workspace", result.workspace?.worktreePath),
-        value("Branch", result.workspace?.branchName),
-        value("Latest thread", result.activeStageRun?.threadId ?? result.issue?.latestThreadId ?? result.workspace?.lastThreadId),
-        value("Latest turn", result.live?.latestTurnId ?? result.activeStageRun?.turnId ?? result.latestStageRun?.turnId),
+        value("State", result.issue?.factoryState),
+        result.activeRun ? value("Active run", `${result.activeRun.runType} (${result.activeRun.status})`) : undefined,
+        result.latestRun && !result.activeRun ? value("Latest run", `${result.latestRun.runType} (${result.latestRun.status})`) : undefined,
+        result.prNumber ? value("PR", `#${result.prNumber}${result.prReviewState ? ` [${result.prReviewState}]` : ""}`) : undefined,
         result.statusNote ? value("Status", truncateLine(result.statusNote)) : undefined,
-        result.live?.latestTurnStatus ? value("Live turn", result.live.latestTurnStatus) : undefined,
-        result.live?.latestAssistantMessage ? `Latest assistant message:\n${truncateLine(result.live.latestAssistantMessage)}` : undefined,
     ].filter(Boolean);
     return `${lines.join("\n")}\n`;
 }
 export function formatLive(result) {
     const lines = [
         value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
-        value("Stage", result.stageRun.stage),
-        value("Thread", result.stageRun.threadId),
-        value("Turn", result.live?.latestTurnId ?? result.stageRun.turnId),
-        value("Turn status", result.live?.latestTurnStatus ?? result.live?.threadStatus ?? result.stageRun.status),
+        value("Run type", result.run.runType),
+        value("Thread", result.run.threadId),
+        value("Turn", result.live?.latestTurnId ?? result.run.turnId),
+        value("Turn status", result.live?.latestTurnStatus ?? result.live?.threadStatus ?? result.run.status),
         value("Latest timestamp", result.live?.latestTimestampSeen),
         result.live?.latestAssistantMessage ? `Latest assistant message:\n${truncateLine(result.live.latestAssistantMessage)}` : undefined,
     ].filter(Boolean);
     return `${lines.join("\n")}\n`;
 }
 export function formatReport(result) {
-    const sections = result.stages.map(({ stageRun, report, summary }) => {
+    const sections = result.runs.map(({ run, report, summary }) => {
         const changedFiles = report?.fileChanges
             .map((entry) => (typeof entry.path === "string" ? entry.path : undefined))
             .filter(Boolean)
@@ -50,10 +44,10 @@ export function formatReport(result) {
         const commands = report?.commands.map((command) => command.command).join(" | ");
         const tools = report?.toolCalls.map((tool) => `${tool.type}:${tool.name}`).join(", ");
         return [
-            `${stageRun.stage} #${stageRun.id} ${stageRun.status}`,
-            value("Started", stageRun.startedAt),
-            value("Ended", stageRun.endedAt),
-            value("Thread", stageRun.threadId),
+            `${run.runType} #${run.id} ${run.status}`,
+            value("Started", run.startedAt),
+            value("Ended", run.endedAt),
+            value("Thread", run.threadId),
             summary?.latestAssistantMessage ? value("Summary", truncateLine(String(summary.latestAssistantMessage))) : undefined,
             report?.assistantMessages.at(-1) ? value("Assistant conclusion", truncateLine(report.assistantMessages.at(-1))) : undefined,
             commands ? value("Commands", commands) : undefined,
@@ -72,16 +66,16 @@ export function formatEvents(result) {
         value("Turn", event.turnId),
         event.parsedEvent ? JSON.stringify(event.parsedEvent, null, 2) : event.eventJson,
     ].join("\n"));
-    return `${value("Stage run", result.stageRun.id)}\n${value("Stage", result.stageRun.stage)}\n\n${sections.join("\n\n")}\n`;
+    return `${value("Run", result.run.id)}\n${value("Run type", result.run.runType)}\n\n${sections.join("\n\n")}\n`;
 }
 export function formatWorktree(result, cdOnly) {
     if (cdOnly) {
-        return `${result.workspace.worktreePath}\n`;
+        return `${result.worktreePath}\n`;
     }
     return `${[
         value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
-        value("Worktree", result.workspace.worktreePath),
-        value("Branch", result.workspace.branchName),
+        value("Worktree", result.worktreePath),
+        value("Branch", result.branchName),
         value("Repo", result.repoId),
     ].join("\n")}\n`;
 }
@@ -90,7 +84,7 @@ function formatCommand(command, args) {
 }
 export function formatOpen(result, command) {
     const commands = [
-        `cd ${result.workspace.worktreePath}`,
+        `cd ${result.worktreePath}`,
         "git branch --show-current",
     ];
     if (result.needsNewSession) {
@@ -106,7 +100,7 @@ export function formatOpen(result, command) {
 export function formatRetry(result) {
     return `${[
         value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
-        value("Queued stage", result.stage),
+        value("Queued stage", result.runType),
         result.reason ? value("Reason", result.reason) : undefined,
     ]
         .filter(Boolean)
@@ -117,9 +111,9 @@ export function formatList(items) {
         .map((item) => [
         item.issueKey ?? "-",
         item.currentLinearState ?? "-",
-        item.lifecycleStatus,
-        item.activeStage ?? "-",
-        item.latestStage ? `${item.latestStage}:${item.latestStageStatus ?? "-"}` : "-",
+        item.factoryState,
+        item.activeRunType ?? "-",
+        item.latestRunType ? `${item.latestRunType}:${item.latestRunStatus ?? "-"}` : "-",
         item.updatedAt,
     ].join("\t"))
         .join("\n")}\n`;