patchrelay 0.35.11 → 0.35.13

package/README.md

@@ -1,8 +1,8 @@
 # PatchRelay
 
-PatchRelay is a self-hosted harness for running a controlled coding loop per Linear issue on your own machine.
+PatchRelay is a self-hosted harness for delegated Linear work and upkeep of PatchRelay-owned pull requests on your own machine.
 
-It receives Linear webhooks, routes issues to the right local repository, prepares durable issue worktrees, runs Codex sessions through `codex app-server`, and keeps the whole issue loop observable and resumable from the CLI. GitHub webhooks drive reactive loops for CI repair and review fixes. A separate [Merge Steward](./packages/merge-steward) service handles serial queue integration and landing.
+It receives Linear webhooks, routes issues to the right local repository, prepares durable issue worktrees, runs Codex sessions through `codex app-server`, and keeps the issue loop observable and resumable from the CLI. GitHub webhooks drive reactive loops for CI repair, review fixes, and merge-steward incidents on PatchRelay-owned PRs. Separate downstream services own review automation and merge execution.
 
 PatchRelay is the system around the model:
 
@@ -38,10 +38,14 @@ PatchRelay does the deterministic harness work that you do not want to re-implem
 - creates and reuses one durable worktree and branch per issue lifecycle
 - starts Codex threads for implementation runs
 - triggers reactive runs for CI failures, review feedback, and Merge Steward evictions
+- opens and updates PatchRelay-owned PRs
+- marks its own PRs ready when implementation is complete
 - persists enough state to correlate the Linear issue, local workspace, run, and Codex thread
 - reports progress back to Linear and forwards follow-up agent input into active runs
 - exposes CLI and optional read-only inspection surfaces so operators can understand what happened
 
+PatchRelay does not own review decisions or queue admission. GitHub is the source of truth for PR readiness, `reviewbot` owns review automation, and [Merge Steward](./packages/merge-steward) owns queueing and merge execution.
+
 ## System Layers
 
 PatchRelay works best when read as five layers with clear ownership:
@@ -50,7 +54,7 @@ PatchRelay works best when read as five layers with clear ownership:
 - coordination layer: issue claiming, run scheduling, retry budgets, and reconciliation
 - execution layer: durable worktrees, Codex threads, and queued turn input delivery
 - integration layer: Linear webhooks, GitHub webhooks, OAuth, project routing, and state sync
-- observability layer: CLI inspection, reports, event trails, and operator endpoints
+- observability layer: CLI inspection, session status, and operator endpoints
 
 That separation is intentional. PatchRelay is not the policy itself and it is not the coding agent. It is the harness that keeps context, action, verification, and repair coordinated in a real repository with real operational state.
 
@@ -81,8 +85,26 @@ You will also need:
 3. Delegated issues create or reuse the issue worktree and launch an implementation run through `codex app-server`.
 4. PatchRelay persists thread ids, run state, and observations so the work stays inspectable and resumable.
 5. GitHub webhooks drive reactive verification and repair loops: CI repair on check failures and review fix on changes requested.
-6. When the PR is approved and CI is green, PatchRelay adds the `queue` label. Merge Steward takes over — rebasing, validating, and merging the PR. If the steward evicts the PR, PatchRelay triggers a queue repair run.
-7. Native agent prompts and Linear comments can steer the active run. An operator can take over from the exact same worktree when needed.
+6. PatchRelay opens draft PRs while implementation is in progress and marks its own PR ready when implementation is complete.
+7. Downstream automation reacts to GitHub truth: `reviewbot` reviews ready PRs with green CI, and Merge Steward admits ready PRs with green CI and approval into the merge queue.
+8. If requested changes, red CI, or a merge-steward incident lands on a PatchRelay-owned PR, PatchRelay resumes work on that same PR branch.
+9. Native agent prompts and Linear comments can steer the active run. An operator can take over from the exact same worktree when needed.
+
+## Ownership Model
+
+PatchRelay tracks two different kinds of ownership:
+
+- issue ownership: who may start new delegated implementation work from Linear
+- PR ownership: who is responsible for keeping an existing PR healthy until it merges or closes
+
+For PatchRelay, PR ownership is determined by one concrete GitHub fact: a PR is PatchRelay-owned when its author is the PatchRelay GitHub app or service account.
+
+That ownership does not change just because:
+
+- the issue is undelegated
+- the PR becomes ready for review
+- the PR is approved
+- the PR enters or leaves the merge queue
 
 ## Factory State Machine
 
@@ -106,6 +128,16 @@ Run types:
 
 PatchRelay treats these as distinct loop types with different context, entry conditions, and success criteria rather than as one generic "ask the agent again" workflow.
 
+The long-term runtime model is a small durable `IssueSession`:
+
+- `idle`
+- `running`
+- `waiting_input`
+- `done`
+- `failed`
+
+Waiting on review or queue should be represented as a waiting reason, not as a large internal control-plane state machine.
+
 ## Restart And Reconciliation
 
 PatchRelay treats restart safety as part of the harness contract, not as a best-effort extra.
@@ -269,14 +301,14 @@ Useful commands:
 - `patchrelay issue list --active`
 - `patchrelay issue show APP-123`
 - `patchrelay issue watch APP-123`
-- `patchrelay dashboard`
-- `patchrelay issue report APP-123`
-- `patchrelay issue events APP-123 --follow`
 - `patchrelay issue path APP-123 --cd`
 - `patchrelay issue open APP-123`
 - `patchrelay issue retry APP-123`
 - `patchrelay service logs --lines 100`
 
+PatchRelay's operator surface is being reduced to its own runtime responsibilities: issue status,
+active work, waiting reason, worktree handoff, and retry controls.
+
 `patchrelay issue open` is the handoff bridge: it opens Codex in the issue worktree and resumes the existing thread when PatchRelay has one.
 
 Today that takeover path is intentionally YOLO mode: it launches Codex with `--dangerously-bypass-approvals-and-sandbox`.
@@ -297,7 +329,7 @@ PatchRelay keeps enough durable state to answer the questions that matter during
 
 [Merge Steward](./packages/merge-steward) is a separate service that owns serial merge queue integration. PatchRelay develops code and produces pull requests. Merge Steward delivers those PRs into production — rebasing onto main, waiting for CI, and merging when green.
 
-The two services communicate through GitHub. PatchRelay adds a `queue` label when a PR is ready. The steward processes the queue. On failure, the steward evicts the PR with a check run report, and PatchRelay can trigger a queue repair run in response.
+The two services communicate through GitHub. PatchRelay makes its own PR ready, and Merge Steward decides queue admission and merge execution from GitHub truth. On failure, the steward reports the incident through GitHub signals, and PatchRelay can trigger a queue repair run in response.
 
 The steward now has its own bootstrap flow:
 

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.11",
-  "commit": "77fedbcefb07",
-  "builtAt": "2026-04-04T04:28:17.653Z"
+  "version": "0.35.13",
+  "commit": "f82366476725",
+  "builtAt": "2026-04-07T23:06:53.397Z"
 }

package/dist/cli/args.js

@@ -15,7 +15,6 @@ export const KNOWN_COMMANDS = new Set([
     "service",
     "connect",
     "installations",
-    "feed",
     "help",
 ]);
 export function parseArgs(argv) {
@@ -56,6 +55,25 @@ export function resolveCommand(parsed) {
         return { command: "help", commandArgs: [] };
     }
     if (KNOWN_COMMANDS.has(requestedCommand)) {
+        if (requestedCommand === "attach") {
+            return { command: "repo", commandArgs: ["link", ...parsed.positionals.slice(1)] };
+        }
+        if (requestedCommand === "repos") {
+            const rest = parsed.positionals.slice(1);
+            if (rest.length === 0) {
+                return { command: "repo", commandArgs: ["list"] };
+            }
+            if (["list", "show", "link", "unlink", "sync"].includes(rest[0])) {
+                return { command: "repo", commandArgs: rest };
+            }
+            return { command: "repo", commandArgs: ["show", ...rest] };
+        }
+        if (requestedCommand === "connect") {
+            return { command: "linear", commandArgs: ["connect", ...parsed.positionals.slice(1)] };
+        }
+        if (requestedCommand === "installations") {
+            return { command: "linear", commandArgs: ["list", ...parsed.positionals.slice(1)] };
+        }
         const command = requestedCommand === "dash" || requestedCommand === "d"
             ? "dashboard"
             : requestedCommand;

package/dist/cli/commands/issues.js

@@ -1,8 +1,8 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { getRunTypeFlag, parsePositiveIntegerFlag } from "../args.js";
+import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatEvents, formatInspect, formatList, formatLive, formatOpen, formatReport, formatRetry, formatWorktree } from "../formatters/text.js";
+import { formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -30,14 +30,12 @@ export async function handleIssueCommand(params) {
                 },
             });
         }
-        case "report":
-            return await handleReportCommand(nested);
-        case "events":
-            return await handleEventsCommand(nested);
         case "path":
             return await handleWorktreeCommand(nested);
         case "open":
             return await handleOpenCommand(nested);
+        case "sessions":
+            return await handleSessionsCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
         default:
@@ -75,56 +73,6 @@ export async function handleLiveCommand(params) {
     } while (true);
     return 0;
 }
-export async function handleReportCommand(params) {
-    const issueKey = params.commandArgs[0];
-    if (!issueKey) {
-        throw new Error("report requires <issueKey>.");
-    }
-    const reportOptions = {};
-    const runType = getRunTypeFlag(params.parsed.flags.get("run-type"));
-    if (runType) {
-        reportOptions.runType = runType;
-    }
-    const runId = parsePositiveIntegerFlag(params.parsed.flags.get("run"), "--run");
-    if (runId !== undefined) {
-        reportOptions.runId = runId;
-    }
-    const result = params.data.report(issueKey, reportOptions);
-    if (!result) {
-        throw new Error(`Issue not found: ${issueKey}`);
-    }
-    writeOutput(params.stdout, params.json ? formatJson(result) : formatReport(result));
-    return 0;
-}
-export async function handleEventsCommand(params) {
-    const issueKey = params.commandArgs[0];
-    if (!issueKey) {
-        throw new Error("events requires <issueKey>.");
-    }
-    const follow = params.parsed.flags.get("follow") === true;
-    let afterId;
-    let runId = parsePositiveIntegerFlag(params.parsed.flags.get("run"), "--run");
-    do {
-        const result = params.data.events(issueKey, {
-            ...(runId !== undefined ? { runId } : {}),
-            ...(typeof params.parsed.flags.get("method") === "string" ? { method: String(params.parsed.flags.get("method")) } : {}),
-            ...(afterId !== undefined ? { afterId } : {}),
-        });
-        if (!result) {
-            throw new Error(`Run not found for ${issueKey}`);
-        }
-        runId = result.run.id;
-        if (result.events.length > 0) {
-            writeOutput(params.stdout, params.json ? formatJson(result) : formatEvents(result));
-            afterId = result.events.at(-1)?.id;
-        }
-        if (!follow || result.run.status !== "running") {
-            break;
-        }
-        await delay(2000);
-    } while (true);
-    return 0;
-}
 export async function handleWorktreeCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {
@@ -166,6 +114,20 @@ export async function handleOpenCommand(params) {
     const openCommand = buildOpenCommand(params.config, result.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }
+export async function handleSessionsCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("sessions requires <issueKey>.");
+    }
+    const result = params.data.sessions(issueKey);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    writeOutput(params.stdout, params.json
+        ? formatJson(result)
+        : formatSessionHistory(result, (threadId) => buildOpenCommand(params.config, result.worktreePath ?? "", threadId)));
+    return 0;
+}
 export async function handleRetryCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/commands/watch.js

@@ -16,6 +16,11 @@ function resolveBaseUrl(config) {
     return `http://${host}:${config.server.port}`;
 }
 export async function handleWatchCommand(params) {
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
+        process.stderr.write("patchrelay dashboard requires an interactive TTY.\n");
+        process.stderr.write("Use `patchrelay issue list`, `patchrelay issue show <issueKey>`, or run the dashboard from a terminal.\n");
+        return 1;
+    }
     const { render } = await import("ink");
     const { createElement } = await import("react");
     const { App } = await import("../watch/App.js");

package/dist/cli/data.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
+import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
 import { WorktreeManager } from "../worktree-manager.js";
 import { CliOperatorApiClient } from "./operator-client.js";
@@ -15,8 +16,20 @@ function safeJsonParse(value) {
         return undefined;
     }
 }
+function normalizeStageReport(reportJson, runStatus) {
+    if (!reportJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(reportJson);
+        return { ...parsed, status: runStatus ?? parsed.status };
+    }
+    catch {
+        return undefined;
+    }
+}
 function summarizeThread(thread, latestTimestampSeen) {
-    const latestTurn = thread.turns.at(-1);
+    const turns = getThreadTurns(thread);
+    const latestTurn = turns.at(-1);
     const latestAssistantMessage = latestTurn?.items
         .filter((item) => item.type === "agentMessage")
         .at(-1)?.text;
@@ -32,6 +45,34 @@ function latestEventTimestamp(db, runId) {
     const events = db.listThreadEvents(runId);
     return events.at(-1)?.createdAt;
 }
+function parseObjectJson(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function summarizeRun(run) {
+    const summary = parseObjectJson(run.summaryJson);
+    if (typeof summary?.latestAssistantMessage === "string" && summary.latestAssistantMessage.trim()) {
+        return summary.latestAssistantMessage.trim();
+    }
+    const report = parseObjectJson(run.reportJson);
+    const assistantMessages = report?.assistantMessages;
+    if (Array.isArray(assistantMessages)) {
+        for (let index = assistantMessages.length - 1; index >= 0; index -= 1) {
+            const value = assistantMessages[index];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return run.failureReason?.trim() || undefined;
+}
 export class CliDataAccess extends CliOperatorApiClient {
     config;
     db;
@@ -56,7 +97,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         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 latestReport = normalizeStageReport(latestRun?.reportJson, latestRun?.status);
         const latestSummary = safeJsonParse(latestRun?.summaryJson);
         const statusNote = latestReport?.assistantMessages.at(-1) ??
             (typeof latestSummary?.latestAssistantMessage === "string" ? latestSummary.latestAssistantMessage : undefined) ??
@@ -70,6 +111,8 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(latestSummary ? { latestSummary } : {}),
             ...(dbIssue.prNumber ? { prNumber: dbIssue.prNumber } : {}),
             ...(dbIssue.prReviewState ? { prReviewState: dbIssue.prReviewState } : {}),
+            ...((dbIssue.sessionState) ? { sessionState: dbIssue.sessionState } : {}),
+            ...((dbIssue.waitingReason) ? { waitingReason: dbIssue.waitingReason } : {}),
             ...(statusNote ? { statusNote } : {}),
         };
     }
@@ -85,47 +128,6 @@ export class CliDataAccess extends CliOperatorApiClient {
             (await this.readLiveSummary(run.threadId, latestEventTimestamp(this.db, run.id)).catch(() => undefined));
         return { issue, run, ...(live ? { live } : {}) };
     }
-    report(issueKey, options) {
-        const issue = this.db.getTrackedIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        const runs = this.db
-            .listRunsForIssue(issue.projectId, issue.linearIssueId)
-            .filter((run) => {
-            if (options?.runId !== undefined && run.id !== options.runId)
-                return false;
-            if (options?.runType !== undefined && run.runType !== options.runType)
-                return false;
-            return true;
-        })
-            .reverse()
-            .map((run) => ({
-            run,
-            ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
-            ...(safeJsonParse(run.summaryJson) ? { summary: safeJsonParse(run.summaryJson) } : {}),
-        }));
-        return { issue, runs };
-    }
-    events(issueKey, options) {
-        const issue = this.db.getTrackedIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        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
-            .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, run, events };
-    }
     worktree(issueKey) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)
@@ -181,16 +183,120 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (dbIssue.activeRunId !== undefined) {
             throw new Error(`Issue ${issueKey} already has an active run.`);
         }
-        const runType = (options?.runType ?? "implementation");
+        const runType = (options?.runType
+            ?? (issue.latestFailureSource === "queue_eviction" || issue.factoryState === "repairing_queue"
+                ? "queue_repair"
+                : dbIssue.prCheckStatus === "failed" || dbIssue.prCheckStatus === "failure" || issue.latestFailureSource === "branch_ci" || issue.factoryState === "repairing_ci"
+                    ? "ci_repair"
+                    : dbIssue.prReviewState === "changes_requested" || issue.factoryState === "changes_requested"
+                        ? "review_fix"
+                        : "implementation"));
+        const factoryState = runType === "queue_repair"
+            ? "repairing_queue"
+            : runType === "ci_repair"
+                ? "repairing_ci"
+                : runType === "review_fix"
+                    ? "changes_requested"
+                    : "delegated";
+        this.appendRetryWake(dbIssue, runType);
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            pendingRunType: runType,
-            factoryState: "delegated",
+            pendingRunType: null,
+            pendingRunContextJson: null,
+            factoryState,
         });
         const updated = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
         return { issue: updated, runType, ...(options?.reason ? { reason: options.reason } : {}) };
     }
+    sessions(issueKey) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const runs = this.db.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const sessions = runs
+            .slice()
+            .reverse()
+            .map((run) => {
+            const summary = summarizeRun(run);
+            return {
+                runId: run.id,
+                runType: run.runType,
+                status: run.status,
+                ...(run.threadId ? { threadId: run.threadId } : {}),
+                ...(run.turnId ? { turnId: run.turnId } : {}),
+                ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
+                ...(summary ? { summary } : {}),
+                ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                eventCount: this.db.listThreadEvents(run.id).length,
+                startedAt: run.startedAt,
+                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+                isCurrentThread: run.threadId !== undefined && run.threadId === dbIssue.threadId,
+            };
+        });
+        return {
+            issue,
+            ...(dbIssue.worktreePath ? { worktreePath: dbIssue.worktreePath } : {}),
+            ...(dbIssue.threadId ? { currentThreadId: dbIssue.threadId } : {}),
+            sessions,
+        };
+    }
+    appendRetryWake(issue, runType) {
+        if (runType === "queue_repair") {
+            const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
+            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "merge_steward_incident",
+                eventJson: JSON.stringify({
+                    ...(queueIncident ?? {}),
+                    ...(failureContext ?? {}),
+                    source: "operator_retry",
+                }),
+                dedupeKey: `operator_retry:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
+            });
+            return;
+        }
+        if (runType === "ci_repair") {
+            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "settled_red_ci",
+                eventJson: JSON.stringify({
+                    ...(failureContext ?? {}),
+                    source: "operator_retry",
+                }),
+                dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
+            });
+            return;
+        }
+        if (runType === "review_fix") {
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "review_changes_requested",
+                eventJson: JSON.stringify({
+                    reviewBody: "Operator requested retry of review-fix work.",
+                    source: "operator_retry",
+                }),
+                dedupeKey: `operator_retry:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+            });
+            return;
+        }
+        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            eventJson: JSON.stringify({
+                promptContext: "Operator requested retry of PatchRelay work.",
+                source: "operator_retry",
+            }),
+            dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+        });
+    }
     list(options) {
         const conditions = [];
         const values = [];
@@ -209,10 +315,15 @@ export class CliDataAccess extends CliOperatorApiClient {
           i.current_linear_state,
           i.factory_state,
           i.updated_at,
+          s.session_state,
+          s.waiting_reason,
           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 issue_sessions s
+          ON s.project_id = i.project_id
+         AND s.linear_issue_id = i.linear_issue_id
         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
@@ -228,7 +339,9 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(row.title !== null ? { title: String(row.title) } : {}),
             projectId: String(row.project_id),
             ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
+            ...(row.session_state !== null ? { sessionState: String(row.session_state) } : {}),
             factoryState: String(row.factory_state ?? "delegated"),
+            ...(row.waiting_reason !== null ? { waitingReason: String(row.waiting_reason) } : {}),
             ...(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) } : {}),
@@ -237,7 +350,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         return items.filter((item) => {
             if (options?.active && !item.activeRunType)
                 return false;
-            if (options?.failed && item.latestRunStatus !== "failed")
+            if (options?.failed && item.factoryState !== "failed" && item.factoryState !== "escalated")
                 return false;
             return true;
         });