patchrelay 0.12.8 → 0.13.0

package/dist/http.js

@@ -330,6 +330,49 @@ export async function buildHttpServer(config, service, logger) {
             reply.raw.on("error", cleanup);
             request.raw.on("close", cleanup);
         });
+        app.get("/api/watch", async (request, reply) => {
+            reply.hijack();
+            reply.raw.writeHead(200, {
+                "content-type": "text/event-stream; charset=utf-8",
+                "cache-control": "no-cache, no-transform",
+                connection: "keep-alive",
+                "x-accel-buffering": "no",
+            });
+            const writeSse = (eventType, data) => {
+                reply.raw.write(`event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`);
+            };
+            // Send initial issue snapshot
+            writeSse("issues", service.listTrackedIssues());
+            // Stream operator feed events
+            const issueFilter = getQueryParam(request, "issue");
+            const unsubscribeFeed = service.subscribeOperatorFeed((event) => {
+                if (issueFilter && event.issueKey !== issueFilter) {
+                    return;
+                }
+                writeSse("feed", event);
+            });
+            // When filtered to a specific issue, also stream codex notifications
+            const unsubscribeCodex = issueFilter
+                ? service.subscribeCodexNotifications((event) => {
+                    if (event.issueKey !== issueFilter) {
+                        return;
+                    }
+                    writeSse("codex", { method: event.method, params: event.params });
+                })
+                : undefined;
+            const cleanup = () => {
+                clearInterval(keepAlive);
+                unsubscribeFeed();
+                unsubscribeCodex?.();
+                if (!reply.raw.destroyed)
+                    reply.raw.end();
+            };
+            const keepAlive = setInterval(() => {
+                reply.raw.write(": keepalive\n\n");
+            }, 15000);
+            reply.raw.on("error", cleanup);
+            request.raw.on("close", cleanup);
+        });
         app.get("/api/installations", async (_request, reply) => {
             return reply.send({ ok: true, installations: service.listLinearInstallations() });
         });
@@ -477,10 +520,25 @@ function renderAgentSessionStatusErrorPage(message) {
 function renderAgentSessionStatusPage(params) {
     const issueTitle = params.sessionStatus.issue.title ?? params.sessionStatus.issue.issueKey ?? params.issueKey;
     const issueUrl = params.sessionStatus.issue.issueUrl;
+    const prUrl = params.sessionStatus.issue.prUrl;
+    const prLabel = params.sessionStatus.issue.prNumber ? `#${params.sessionStatus.issue.prNumber}` : undefined;
     const activeStage = formatStageChip(params.sessionStatus.activeRun);
     const latestStage = formatStageChip(params.sessionStatus.latestRun);
     const threadInfo = formatThread(params.sessionStatus.liveThread);
     const stagesRows = params.sessionStatus.runs.slice(-8).map((entry) => formatStageRow(entry.run)).join("");
+    const latestAgentMessage = params.sessionStatus.liveThread?.latestAgentMessage ?? params.sessionStatus.latestReportSummary?.latestAssistantMessage ?? "No agent summary yet.";
+    const latestPlan = params.sessionStatus.liveThread?.latestPlan ?? "No live plan available.";
+    const activeCommand = params.sessionStatus.liveThread?.activeCommand ?? "idle";
+    const commandCount = params.sessionStatus.liveThread?.commandCount ?? params.sessionStatus.latestReportSummary?.commandCount ?? 0;
+    const fileChangeCount = params.sessionStatus.liveThread?.fileChangeCount ?? params.sessionStatus.latestReportSummary?.fileChangeCount ?? 0;
+    const toolCallCount = params.sessionStatus.liveThread?.toolCallCount ?? params.sessionStatus.latestReportSummary?.toolCallCount ?? 0;
+    const factoryState = params.sessionStatus.issue.factoryState ?? "unknown";
+    const linearState = params.sessionStatus.issue.currentLinearState ?? "unknown";
+    const prState = params.sessionStatus.issue.prState ?? "unknown";
+    const reviewState = params.sessionStatus.issue.prReviewState ?? "unknown";
+    const checkState = params.sessionStatus.issue.prCheckStatus ?? "unknown";
+    const ciAttempts = params.sessionStatus.issue.ciRepairAttempts ?? 0;
+    const queueAttempts = params.sessionStatus.issue.queueRepairAttempts ?? 0;
     return `<!doctype html>
 <html lang="en">
   <head>
@@ -538,11 +596,34 @@ function renderAgentSessionStatusPage(params) {
       <h1>${escapeHtml(issueTitle)}</h1>
       <p>PatchRelay read-only agent session status for <code>${escapeHtml(params.issueKey)}</code>.</p>
       ${issueUrl ? `<p><a href="${escapeHtml(issueUrl)}" target="_blank" rel="noopener noreferrer">Open issue in Linear</a></p>` : ""}
+      ${prUrl ? `<p><a href="${escapeHtml(prUrl)}" target="_blank" rel="noopener noreferrer">Open pull request ${escapeHtml(prLabel ?? "")}</a></p>` : ""}
       <div class="chips">
+        <span class="chip"><strong>Factory:</strong> <code>${escapeHtml(factoryState)}</code></span>
+        <span class="chip"><strong>Linear:</strong> <code>${escapeHtml(linearState)}</code></span>
         <span class="chip"><strong>Active:</strong> ${activeStage}</span>
         <span class="chip"><strong>Latest:</strong> ${latestStage}</span>
         <span class="chip"><strong>Thread:</strong> ${threadInfo}</span>
       </div>
+      <div class="section">
+        <h2>Current View</h2>
+        <table>
+          <tbody>
+            <tr><th>Pull request</th><td>${escapeHtml(prLabel ?? "none")} (${escapeHtml(prState)})</td></tr>
+            <tr><th>Review</th><td>${escapeHtml(reviewState)}</td></tr>
+            <tr><th>Checks</th><td>${escapeHtml(checkState)}</td></tr>
+            <tr><th>Latest plan</th><td>${escapeHtml(latestPlan)}</td></tr>
+            <tr><th>Active command</th><td><code>${escapeHtml(activeCommand)}</code></td></tr>
+            <tr><th>Latest summary</th><td>${escapeHtml(latestAgentMessage)}</td></tr>
+          </tbody>
+        </table>
+      </div>
+      <div class="chips">
+        <span class="chip"><strong>Commands:</strong> ${escapeHtml(String(commandCount))}</span>
+        <span class="chip"><strong>File changes:</strong> ${escapeHtml(String(fileChangeCount))}</span>
+        <span class="chip"><strong>Tool calls:</strong> ${escapeHtml(String(toolCallCount))}</span>
+        <span class="chip"><strong>CI repairs:</strong> ${escapeHtml(String(ciAttempts))}</span>
+        <span class="chip"><strong>Queue repairs:</strong> ${escapeHtml(String(queueAttempts))}</span>
+      </div>
       <div class="section">
         <h2>Recent Stages</h2>
         <table>

package/dist/issue-query-service.js

@@ -1,4 +1,4 @@
-import { summarizeCurrentThread } from "./run-reporting.js";
+import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
 import { safeJsonParse } from "./utils.js";
 export class IssueQueryService {
     db;
@@ -65,12 +65,27 @@ export class IssueQueryService {
         const overview = await this.getIssueOverview(issueKey);
         if (!overview)
             return undefined;
+        const issueRecord = this.db.getIssueByKey(issueKey);
         const report = await this.getIssueReport(issueKey);
+        const latestRunReport = report?.runs.at(-1)?.report;
         return {
-            issue: overview.issue,
+            issue: {
+                issueKey: overview.issue.issueKey,
+                title: overview.issue.title,
+                issueUrl: overview.issue.issueUrl,
+                currentLinearState: overview.issue.currentLinearState,
+                factoryState: overview.issue.factoryState,
+                ...(issueRecord?.prNumber !== undefined ? { prNumber: issueRecord.prNumber } : {}),
+                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
+                ...(issueRecord ? { ciRepairAttempts: issueRecord.ciRepairAttempts, queueRepairAttempts: issueRecord.queueRepairAttempts } : {}),
+            },
             ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
             ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
             ...(overview.liveThread ? { liveThread: overview.liveThread } : {}),
+            ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
             runs: report?.runs ?? [],
             generatedAt: new Date().toISOString(),
         };

package/dist/linear-session-reporting.js

@@ -0,0 +1,134 @@
+import { formatRunTypeLabel } from "./agent-session-plan.js";
+function lowerRunTypeLabel(runType) {
+    return formatRunTypeLabel(runType).toLowerCase();
+}
+function trimSummary(summary, maxLength = 300) {
+    const value = summary?.trim();
+    if (!value) {
+        return undefined;
+    }
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength).trimEnd()}...`;
+}
+function describeNextState(state, prNumber) {
+    const prLabel = prNumber ? `PR #${prNumber}` : "the pull request";
+    switch (state) {
+        case "pr_open":
+        case "awaiting_review":
+            return `${prLabel} is ready for review.`;
+        case "awaiting_queue":
+            return `${prLabel} is approved and back in the merge flow.`;
+        case "done":
+            return `${prLabel} has merged.`;
+        case "awaiting_input":
+            return "PatchRelay is waiting for guidance before continuing.";
+        case "failed":
+            return "PatchRelay needs help to recover this workflow.";
+        default:
+            return undefined;
+    }
+}
+export function buildDelegationThought(runType, source = "delegation") {
+    const sourceText = source === "prompt" ? "latest instructions" : "delegation";
+    return {
+        type: "thought",
+        body: `PatchRelay received the ${sourceText} and is preparing the ${lowerRunTypeLabel(runType)} workflow.`,
+    };
+}
+export function buildAlreadyRunningThought(runType) {
+    return {
+        type: "thought",
+        body: `PatchRelay is already working on the ${lowerRunTypeLabel(runType)} workflow.`,
+    };
+}
+export function buildPromptDeliveredThought(runType) {
+    return {
+        type: "thought",
+        body: `PatchRelay routed your latest instructions into the active ${lowerRunTypeLabel(runType)} workflow.`,
+    };
+}
+export function buildRunStartedActivity(runType) {
+    switch (runType) {
+        case "review_fix":
+            return { type: "action", action: "Addressing", parameter: "review feedback" };
+        case "ci_repair":
+            return { type: "action", action: "Repairing", parameter: "failing CI checks" };
+        case "queue_repair":
+            return { type: "action", action: "Repairing", parameter: "merge queue failure" };
+        case "implementation":
+        default:
+            return { type: "action", action: "Implementing", parameter: "requested change" };
+    }
+}
+export function buildRunCompletedActivity(params) {
+    const label = formatRunTypeLabel(params.runType);
+    const nextState = describeNextState(params.postRunState, params.prNumber);
+    const summary = trimSummary(params.completionSummary);
+    const lines = [`${label} completed.`];
+    if (nextState) {
+        lines.push("", nextState);
+    }
+    if (summary) {
+        lines.push("", summary);
+    }
+    return {
+        type: "response",
+        body: lines.join("\n"),
+    };
+}
+export function buildRunFailureActivity(runType, reason) {
+    const label = formatRunTypeLabel(runType);
+    return {
+        type: "error",
+        body: reason ? `${label} failed.\n\n${reason}` : `${label} failed.`,
+    };
+}
+export function buildGitHubStateActivity(newState, event) {
+    switch (newState) {
+        case "pr_open": {
+            const parts = [`PR #${event.prNumber ?? "?"} is open and ready for review.`];
+            if (event.prUrl) {
+                parts.push("", event.prUrl);
+            }
+            return { type: "response", body: parts.join("\n") };
+        }
+        case "awaiting_queue":
+            return { type: "response", body: "Review approved. PatchRelay is moving the PR toward merge." };
+        case "changes_requested":
+            return {
+                type: "action",
+                action: "Addressing",
+                parameter: event.reviewerName ? `review feedback from ${event.reviewerName}` : "review feedback",
+            };
+        case "repairing_ci":
+            return {
+                type: "action",
+                action: "Repairing",
+                parameter: event.checkName ? `CI failure: ${event.checkName}` : "failing CI checks",
+            };
+        case "repairing_queue":
+            return {
+                type: "action",
+                action: "Repairing",
+                parameter: "merge queue validation",
+            };
+        case "done":
+            return { type: "response", body: `PR merged.${event.prNumber ? ` PR #${event.prNumber}` : ""}` };
+        case "failed":
+            return { type: "error", body: "The pull request was closed without merging." };
+        default:
+            return undefined;
+    }
+}
+export function summarizeIssueStateForLinear(issue) {
+    switch (issue.factoryState) {
+        case "awaiting_review":
+        case "pr_open":
+            return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";
+        case "awaiting_queue":
+            return issue.prNumber ? `PR #${issue.prNumber} is approved and awaiting merge.` : "Approved and awaiting merge.";
+        case "done":
+            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+        default:
+            return undefined;
+    }
+}

package/dist/run-orchestrator.js

@@ -2,8 +2,10 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
-import { buildRunningSessionPlan, buildCompletedSessionPlan, buildFailedSessionPlan, } from "./agent-session-plan.js";
+import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
+import { buildRunCompletedActivity, buildRunFailureActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { execCommand } from "./utils.js";
@@ -15,6 +17,9 @@ function slugify(value) {
 function sanitizePathSegment(value) {
     return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
 }
+function lowerCaseFirst(value) {
+    return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
+}
 const WORKFLOW_FILES = {
     implementation: "IMPLEMENTATION_WORKFLOW.md",
     review_fix: "REVIEW_WORKFLOW.md",
@@ -36,6 +41,14 @@ function buildRunPrompt(issue, runType, repoPath, context) {
         issue.prNumber ? `PR: #${issue.prNumber}` : undefined,
         "",
     ].filter(Boolean);
+    const promptContext = typeof context?.promptContext === "string" ? context.promptContext.trim() : "";
+    const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
+    if (promptContext) {
+        lines.push("## Linear Session Context", "", promptContext, "");
+    }
+    if (latestPrompt) {
+        lines.push("## Latest Human Instruction", "", latestPrompt, "");
+    }
     // Add run-type-specific context for reactive runs
     switch (runType) {
         case "ci_repair":
@@ -210,16 +223,17 @@ export class RunOrchestrator {
                 factoryState: "failed",
             });
             this.logger.error({ issueKey: issue.issueKey, runType, error: message }, `Failed to launch ${runType} run`);
-            void this.emitLinearActivity(issue, "error", `Failed to start ${runType}: ${message}`);
-            void this.updateLinearPlan(issue, buildFailedSessionPlan(runType));
+            const failedIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
+            void this.emitLinearActivity(failedIssue, buildRunFailureActivity(runType, `Failed to start ${lowerCaseFirst(message)}`));
+            void this.syncLinearSession(failedIssue, { activeRunType: runType });
             throw error;
         }
         this.db.updateRunThread(run.id, { threadId, turnId });
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
-        void this.emitLinearActivity(freshIssue, "thought", `Started ${runType} run.`, { ephemeral: true });
-        void this.updateLinearPlan(freshIssue, buildRunningSessionPlan(runType));
+        void this.emitLinearActivity(freshIssue, buildRunStartedActivity(runType));
+        void this.syncLinearSession(freshIssue, { activeRunType: runType });
     }
     // ─── Notification handler ─────────────────────────────────────────
     async handleCodexNotification(notification) {
@@ -269,8 +283,9 @@ export class RunOrchestrator {
                 status: "failed",
                 summary: `Turn failed for ${run.runType}`,
             });
-            void this.emitLinearActivity(issue, "error", `${run.runType} run failed.`);
-            void this.updateLinearPlan(issue, buildFailedSessionPlan(run.runType, run));
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType));
+            void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
             return;
         }
         // Complete the run
@@ -323,10 +338,15 @@ export class RunOrchestrator {
             detail: summarizeCurrentThread(thread).latestAgentMessage,
         });
         // Emit Linear completion activity + plan
+        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
-        const prInfo = issue.prNumber ? ` PR #${issue.prNumber}` : "";
-        void this.emitLinearActivity(issue, "response", `${run.runType} completed.${prInfo}\n\n${completionSummary}`);
-        void this.updateLinearPlan(issue, buildCompletedSessionPlan(run.runType));
+        void this.emitLinearActivity(updatedIssue, buildRunCompletedActivity({
+            runType: run.runType,
+            completionSummary,
+            postRunState: updatedIssue.factoryState,
+            ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+        }));
+        void this.syncLinearSession(updatedIssue);
     }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {
@@ -471,7 +491,9 @@ export class RunOrchestrator {
         if (latestTurn?.status === "interrupted") {
             this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, threadId: run.threadId }, "Run has interrupted turn — marking as failed");
             this.failRunAndClear(run, "Codex turn was interrupted");
-            void this.emitLinearActivity(issue, "error", `${run.runType} run was interrupted.`);
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
+            void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
             return;
         }
         // Handle completed turn discovered during reconciliation
@@ -513,6 +535,12 @@ export class RunOrchestrator {
             status: "escalated",
             summary: `Escalated: ${reason}`,
         });
+        const escalatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        void this.emitLinearActivity(escalatedIssue, {
+            type: "error",
+            body: `PatchRelay needs human help to continue.\n\n${reason}`,
+        });
+        void this.syncLinearSession(escalatedIssue);
     }
     failRunAndClear(run, message) {
         this.db.transaction(() => {
@@ -525,34 +553,53 @@ export class RunOrchestrator {
             });
         });
     }
-    async emitLinearActivity(issue, type, body, options) {
+    async emitLinearActivity(issue, content, options) {
         if (!issue.agentSessionId)
             return;
         try {
             const linear = await this.linearProvider.forProject(issue.projectId);
             if (!linear)
                 return;
+            const allowEphemeral = content.type === "thought" || content.type === "action";
             await linear.createAgentActivity({
                 agentSessionId: issue.agentSessionId,
-                content: { type, body },
-                ...(options?.ephemeral ? { ephemeral: true } : {}),
+                content,
+                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
             });
         }
         catch (error) {
-            this.logger.debug({ issueKey: issue.issueKey, type, error: error instanceof Error ? error.message : String(error) }, "Failed to emit Linear activity (non-blocking)");
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.feed?.publish({
+                level: "warn",
+                kind: "linear",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                status: "linear_error",
+                summary: `Linear activity failed: ${msg}`,
+            });
         }
     }
-    async updateLinearPlan(issue, plan) {
+    async syncLinearSession(issue, options) {
         if (!issue.agentSessionId)
             return;
         try {
             const linear = await this.linearProvider.forProject(issue.projectId);
             if (!linear?.updateAgentSession)
                 return;
-            await linear.updateAgentSession({ agentSessionId: issue.agentSessionId, plan });
+            const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            });
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: buildAgentSessionPlanForIssue(issue, options),
+                ...(externalUrls ? { externalUrls } : {}),
+            });
         }
         catch (error) {
-            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to update Linear plan (non-blocking)");
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to update Linear plan");
         }
     }
     async readThreadWithRetry(threadId, maxRetries = 3) {

package/dist/run-reporting.js

@@ -12,11 +12,42 @@ export function summarizeCurrentThread(thread) {
     const latestAgentMessage = latestTurn?.items
         .filter((item) => item.type === "agentMessage")
         .at(-1)?.text;
+    const latestPlan = latestTurn?.items
+        .filter((item) => item.type === "plan")
+        .at(-1)?.text;
+    const activeCommand = latestTurn?.items
+        .filter((item) => item.type === "commandExecution")
+        .filter((item) => item.status === "inProgress" || item.status === "running")
+        .at(-1)?.command
+        ?? latestTurn?.items
+            .filter((item) => item.type === "commandExecution")
+            .at(-1)?.command;
+    let commandCount = 0;
+    let fileChangeCount = 0;
+    let toolCallCount = 0;
+    for (const turn of thread.turns) {
+        for (const item of turn.items) {
+            if (item.type === "commandExecution") {
+                commandCount += 1;
+            }
+            else if (item.type === "fileChange" && Array.isArray(item.changes)) {
+                fileChangeCount += item.changes.length;
+            }
+            else if (item.type === "mcpToolCall" || item.type === "dynamicToolCall") {
+                toolCallCount += 1;
+            }
+        }
+    }
     return {
         threadId: thread.id,
         threadStatus: thread.status,
+        commandCount,
+        fileChangeCount,
+        toolCallCount,
         ...(latestTurn ? { latestTurnId: latestTurn.id, latestTurnStatus: latestTurn.status } : {}),
         ...(latestAgentMessage ? { latestAgentMessage } : {}),
+        ...(latestPlan ? { latestPlan } : {}),
+        ...(activeCommand ? { activeCommand } : {}),
     };
 }
 export function buildStageReport(run, issue, thread, eventCounts) {

package/dist/service.js

@@ -138,6 +138,66 @@ export class PatchRelayService {
     getReadiness() {
         return this.runtime.getReadiness();
     }
+    listTrackedIssues() {
+        const rows = this.db.connection
+            .prepare(`SELECT
+          i.project_id, i.linear_issue_id, i.issue_key, i.title,
+          i.current_linear_state, i.factory_state, i.updated_at,
+          i.pr_number, i.pr_review_state, i.pr_check_status,
+          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
+        )
+        ORDER BY i.updated_at DESC, i.issue_key ASC`)
+            .all();
+        return rows.map((row) => ({
+            ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
+            ...(row.title !== null ? { title: String(row.title) } : {}),
+            projectId: String(row.project_id),
+            factoryState: String(row.factory_state ?? "delegated"),
+            ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
+            ...(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) } : {}),
+            ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+            ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
+            ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
+            updatedAt: String(row.updated_at),
+        }));
+    }
+    subscribeCodexNotifications(listener) {
+        const handler = (notification) => {
+            const threadId = typeof notification.params.threadId === "string"
+                ? notification.params.threadId
+                : typeof notification.params.thread === "object" && notification.params.thread !== null && "id" in notification.params.thread
+                    ? String(notification.params.thread.id)
+                    : undefined;
+            let issueKey;
+            let runId;
+            if (threadId) {
+                const run = this.db.getRunByThreadId(threadId);
+                if (run) {
+                    runId = run.id;
+                    const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+                    issueKey = issue?.issueKey ?? undefined;
+                }
+            }
+            listener({
+                method: notification.method,
+                params: notification.params,
+                ...(issueKey ? { issueKey } : {}),
+                ...(runId !== undefined ? { runId } : {}),
+            });
+        };
+        this.codex.on("notification", handler);
+        return () => { this.codex.off("notification", handler); };
+    }
     listOperatorFeed(options) {
         return this.feed.list(options);
     }