patchrelay 0.4.1 → 0.6.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.4.1",
-  "commit": "13439842db03",
-  "builtAt": "2026-03-13T09:25:15.012Z"
+  "version": "0.6.0",
+  "commit": "3dd80e1684b4",
+  "builtAt": "2026-03-13T13:20:38.482Z"
 }

package/dist/cli/args.js

@@ -1,4 +1,5 @@
 export const KNOWN_COMMANDS = new Set([
+    "version",
     "serve",
     "inspect",
     "live",
@@ -13,10 +14,12 @@ export const KNOWN_COMMANDS = new Set([
     "project",
     "connect",
     "installations",
+    "feed",
     "install-service",
     "restart-service",
     "help",
 ]);
+const ISSUE_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
 export function parseArgs(argv) {
     const positionals = [];
     const flags = new Map();
@@ -47,13 +50,16 @@ export function parseArgs(argv) {
 }
 export function resolveCommand(parsed) {
     const requestedCommand = parsed.positionals[0];
-    const command = !requestedCommand
-        ? "help"
-        : KNOWN_COMMANDS.has(requestedCommand)
-            ? requestedCommand
-            : "inspect";
-    const commandArgs = command === requestedCommand ? parsed.positionals.slice(1) : parsed.positionals;
-    return { command, commandArgs };
+    if (!requestedCommand) {
+        return { command: "help", commandArgs: [] };
+    }
+    if (KNOWN_COMMANDS.has(requestedCommand)) {
+        return { command: requestedCommand, commandArgs: parsed.positionals.slice(1) };
+    }
+    if (ISSUE_KEY_PATTERN.test(requestedCommand)) {
+        return { command: "inspect", commandArgs: parsed.positionals };
+    }
+    throw new Error(`Unknown command: ${requestedCommand}. Run \`patchrelay help\`.`);
 }
 export function getStageFlag(value) {
     if (typeof value !== "string") {
@@ -71,3 +77,25 @@ export function parseCsvFlag(value) {
         .map((entry) => entry.trim())
         .filter(Boolean);
 }
+export function assertKnownFlags(parsed, command, allowedFlags) {
+    const allowed = new Set(allowedFlags);
+    const unknownFlags = [...parsed.flags.keys()].filter((flag) => !allowed.has(flag)).sort();
+    if (unknownFlags.length === 0) {
+        return;
+    }
+    throw new Error(`Unknown flag${unknownFlags.length === 1 ? "" : "s"} for ${command}: ${unknownFlags.map((flag) => `--${flag}`).join(", ")}`);
+}
+export function parsePositiveIntegerFlag(value, flagName) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new Error(`${flagName} must be a positive integer.`);
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error(`${flagName} must be a positive integer.`);
+    }
+    return parsed;
+}

package/dist/cli/commands/feed.js

@@ -0,0 +1,53 @@
+import { formatJson } from "../formatters/json.js";
+import { formatOperatorFeed, formatOperatorFeedEvent } from "../formatters/text.js";
+import { writeOutput } from "../output.js";
+function parseLimit(value) {
+    if (typeof value !== "string") {
+        return 50;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new Error("--limit must be a positive integer.");
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer.");
+    }
+    return parsed;
+}
+export async function handleFeedCommand(params) {
+    const limit = parseLimit(params.parsed.flags.get("limit"));
+    const follow = params.parsed.flags.get("follow") === true;
+    const issueFlag = params.parsed.flags.get("issue");
+    const projectFlag = params.parsed.flags.get("project");
+    if (issueFlag === true) {
+        throw new Error("--issue requires a value.");
+    }
+    if (projectFlag === true) {
+        throw new Error("--project requires a value.");
+    }
+    const issueKey = typeof issueFlag === "string" ? issueFlag.trim() || undefined : undefined;
+    const projectId = typeof projectFlag === "string" ? projectFlag.trim() || undefined : undefined;
+    const query = {
+        limit,
+        ...(issueKey ? { issueKey } : {}),
+        ...(projectId ? { projectId } : {}),
+    };
+    if (!follow) {
+        const result = await params.data.listOperatorFeed(query);
+        writeOutput(params.stdout, params.json
+            ? formatJson(result)
+            : formatOperatorFeed(result, { color: "isTTY" in params.stdout && params.stdout.isTTY === true }));
+        return 0;
+    }
+    if (params.json) {
+        await params.data.followOperatorFeed((event) => {
+            writeOutput(params.stdout, formatJson(event));
+        }, query);
+        return 0;
+    }
+    await params.data.followOperatorFeed((event) => {
+        writeOutput(params.stdout, formatOperatorFeedEvent(event, { color: "isTTY" in params.stdout && params.stdout.isTTY === true }));
+    }, query);
+    return 0;
+}

package/dist/cli/commands/issues.js

@@ -1,5 +1,5 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { getStageFlag } from "../args.js";
+import { getStageFlag, parsePositiveIntegerFlag } from "../args.js";
 import { formatJson } from "../formatters/json.js";
 import { formatEvents, formatInspect, formatList, formatLive, formatOpen, formatReport, formatRetry, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
@@ -45,8 +45,9 @@ export async function handleReportCommand(params) {
     if (stage) {
         reportOptions.stage = stage;
     }
-    if (typeof params.parsed.flags.get("stage-run") === "string") {
-        reportOptions.stageRunId = Number(params.parsed.flags.get("stage-run"));
+    const stageRunId = parsePositiveIntegerFlag(params.parsed.flags.get("stage-run"), "--stage-run");
+    if (stageRunId !== undefined) {
+        reportOptions.stageRunId = stageRunId;
     }
     const result = params.data.report(issueKey, reportOptions);
     if (!result) {
@@ -62,7 +63,7 @@ export async function handleEventsCommand(params) {
     }
     const follow = params.parsed.flags.get("follow") === true;
     let afterId;
-    let stageRunId = typeof params.parsed.flags.get("stage-run") === "string" ? Number(params.parsed.flags.get("stage-run")) : undefined;
+    let stageRunId = parsePositiveIntegerFlag(params.parsed.flags.get("stage-run"), "--stage-run");
     do {
         const result = params.data.events(issueKey, {
             ...(stageRunId !== undefined ? { stageRunId } : {}),
@@ -102,7 +103,7 @@ export async function handleOpenCommand(params) {
         throw new Error("open requires <issueKey>.");
     }
     if (params.json) {
-        const result = params.data.open(issueKey);
+        const result = await params.data.resolveOpen(issueKey);
         if (!result) {
             throw new Error(`Workspace not found for ${issueKey}`);
         }
@@ -110,11 +111,12 @@ export async function handleOpenCommand(params) {
         return 0;
     }
     if (params.parsed.flags.get("print") === true) {
-        const result = params.data.open(issueKey);
+        const result = await params.data.resolveOpen(issueKey);
         if (!result) {
             throw new Error(`Workspace not found for ${issueKey}`);
         }
-        writeOutput(params.stdout, formatOpen(result));
+        const openCommand = buildOpenCommand(params.config, result.workspace.worktreePath, result.resumeThreadId);
+        writeOutput(params.stdout, formatOpen(result, openCommand));
         return 0;
     }
     const result = await params.data.prepareOpen(issueKey);

package/dist/cli/data.js

@@ -175,12 +175,14 @@ export class CliDataAccess {
             ...(resumeThreadId ? { resumeThreadId } : {}),
         };
     }
-    async prepareOpen(issueKey) {
+    async resolveOpen(issueKey, options) {
         const worktree = this.worktree(issueKey);
         if (!worktree) {
             return undefined;
         }
-        await this.ensureOpenWorktree(worktree);
+        if (options?.ensureWorktree) {
+            await this.ensureOpenWorktree(worktree);
+        }
         const existingThreadId = await this.resolveStoredOpenThreadId(worktree);
         if (existingThreadId) {
             return {
@@ -188,6 +190,12 @@ export class CliDataAccess {
                 resumeThreadId: existingThreadId,
             };
         }
+        if (!options?.createThreadIfMissing) {
+            return {
+                ...worktree,
+                needsNewSession: true,
+            };
+        }
         const codex = await this.getCodex();
         const thread = await codex.startThread({
             cwd: worktree.workspace.worktreePath,
@@ -206,6 +214,12 @@ export class CliDataAccess {
             resumeThreadId: thread.id,
         };
     }
+    async prepareOpen(issueKey) {
+        return await this.resolveOpen(issueKey, {
+            ensureWorktree: true,
+            createThreadIfMissing: true,
+        });
+    }
     retry(issueKey, options) {
         const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
         if (!issue) {
@@ -448,6 +462,72 @@ export class CliDataAccess {
     async listInstallations() {
         return await this.requestJson("/api/installations");
     }
+    async listOperatorFeed(options) {
+        return await this.requestJson("/api/feed", {
+            ...(options?.limit && options.limit > 0 ? { limit: String(options.limit) } : {}),
+            ...(options?.issueKey ? { issue: options.issueKey } : {}),
+            ...(options?.projectId ? { project: options.projectId } : {}),
+        });
+    }
+    async followOperatorFeed(onEvent, options) {
+        const url = new URL("/api/feed", this.getOperatorBaseUrl());
+        url.searchParams.set("follow", "1");
+        if (options?.limit && options.limit > 0) {
+            url.searchParams.set("limit", String(options.limit));
+        }
+        if (options?.issueKey) {
+            url.searchParams.set("issue", options.issueKey);
+        }
+        if (options?.projectId) {
+            url.searchParams.set("project", options.projectId);
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
+            },
+        });
+        if (!response.ok || !response.body) {
+            const body = await response.text().catch(() => "");
+            const message = this.readErrorMessage(body);
+            throw new Error(message ?? `Request failed: ${response.status}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let dataLines = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                if (!line) {
+                    if (dataLines.length > 0) {
+                        const parsed = JSON.parse(dataLines.join("\n"));
+                        onEvent(parsed);
+                        dataLines = [];
+                    }
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith(":")) {
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        }
+    }
     getOperatorBaseUrl() {
         const host = this.normalizeLocalHost(this.config.server.bind);
         return `http://${host}:${this.config.server.port}/`;

package/dist/cli/formatters/text.js

@@ -85,15 +85,22 @@ export function formatWorktree(result, cdOnly) {
         value("Repo", result.repoId),
     ].join("\n")}\n`;
 }
-export function formatOpen(result) {
+function formatCommand(command, args) {
+    return [command, ...args].join(" ");
+}
+export function formatOpen(result, command) {
     const commands = [
         `cd ${result.workspace.worktreePath}`,
         "git branch --show-current",
-        "codex --dangerously-bypass-approvals-and-sandbox",
     ];
-    if (result.resumeThreadId) {
-        commands.push(`codex --dangerously-bypass-approvals-and-sandbox resume ${result.resumeThreadId}`);
+    if (result.needsNewSession) {
+        commands.push(`# No resumable thread found; \`patchrelay open ${result.issue.issueKey ?? result.issue.linearIssueId}\` will create a fresh session.`);
     }
+    commands.push(command
+        ? formatCommand(command.command, command.args)
+        : result.resumeThreadId
+            ? `codex --dangerously-bypass-approvals-and-sandbox resume ${result.resumeThreadId}`
+            : "codex --dangerously-bypass-approvals-and-sandbox");
     return `${commands.join("\n")}\n`;
 }
 export function formatRetry(result) {
@@ -117,3 +124,45 @@ export function formatList(items) {
     ].join("\t"))
         .join("\n")}\n`;
 }
+function colorize(enabled, code, value) {
+    return enabled ? `\u001B[${code}m${value}\u001B[0m` : value;
+}
+function formatFeedStatus(event, color) {
+    const raw = event.status ?? event.kind;
+    const label = raw.replaceAll("_", " ");
+    const padded = label.padEnd(15);
+    if (event.level === "error" || raw === "failed" || raw === "delivery_failed") {
+        return colorize(color, "31", padded);
+    }
+    if (event.level === "warn" || raw === "ignored" || raw === "fallback" || raw === "handoff") {
+        return colorize(color, "33", padded);
+    }
+    if (raw === "running" || raw === "started" || raw === "delegated") {
+        return colorize(color, "32", padded);
+    }
+    if (raw === "queued") {
+        return colorize(color, "36", padded);
+    }
+    return colorize(color, "2", padded);
+}
+export function formatOperatorFeedEvent(event, options) {
+    const color = options?.color === true;
+    const timestamp = new Date(event.at).toLocaleTimeString("en-GB", { hour12: false });
+    const issue = event.issueKey ?? event.projectId ?? "-";
+    const line = [
+        colorize(color, "2", timestamp),
+        colorize(color, "1", issue.padEnd(10)),
+        formatFeedStatus(event, color),
+        event.summary,
+    ].join("  ");
+    if (!event.detail) {
+        return `${line}\n`;
+    }
+    return `${line}\n${colorize(color, "2", `  ${truncateLine(event.detail)}`)}\n`;
+}
+export function formatOperatorFeed(result, options) {
+    if (result.events.length === 0) {
+        return "No feed events yet.\n";
+    }
+    return result.events.map((event) => formatOperatorFeedEvent(event, options)).join("");
+}

package/dist/cli/index.js

@@ -1,7 +1,9 @@
 import { loadConfig } from "../config.js";
+import { getBuildInfo } from "../build-info.js";
 import { runPreflight } from "../preflight.js";
-import { parseArgs, resolveCommand } from "./args.js";
+import { assertKnownFlags, parseArgs, resolveCommand } from "./args.js";
 import { handleConnectCommand, handleInstallationsCommand } from "./commands/connect.js";
+import { handleFeedCommand } from "./commands/feed.js";
 import { handleEventsCommand, handleInspectCommand, handleListCommand, handleLiveCommand, handleOpenCommand, handleReportCommand, handleRetryCommand, handleWorktreeCommand, } from "./commands/issues.js";
 import { handleProjectCommand } from "./commands/project.js";
 import { handleInitCommand, handleInstallServiceCommand, handleRestartServiceCommand } from "./commands/setup.js";
@@ -38,8 +40,9 @@ function helpText() {
         "  upserts the repo config and reuses or starts the Linear connection flow.",
         "",
         "Commands:",
+        "  version [--json]                                        Show the installed PatchRelay build version",
         "  init <public-base-url> [--force] [--json]                Bootstrap the machine-level PatchRelay home",
-        "  project apply <id> <repo-path> [--issue-prefix <prefixes>] [--team-id <ids>] [--no-connect] [--timeout <seconds>] [--json]",
+        "  project apply <id> <repo-path> [--issue-prefix <prefixes>] [--team-id <ids>] [--no-connect] [--no-open] [--timeout <seconds>] [--json]",
         "                                                           Upsert one local repository and connect it to Linear when ready",
         "  doctor [--json]                                          Check secrets, paths, configured workflow files, git, and codex",
         "  install-service [--force] [--write-only] [--json]       Reinstall the systemd user service and watcher",
@@ -47,6 +50,8 @@ function helpText() {
         "  connect [--project <projectId>] [--no-open] [--timeout <seconds>] [--json]",
         "                                                           Advanced: start or reuse a Linear installation directly",
         "  installations [--json]                                  Show connected Linear installations",
+        "  feed [--follow] [--limit <count>] [--issue <issueKey>] [--project <projectId>] [--json]",
+        "                                                           Show a live operator feed from the daemon",
         "  serve                                                   Run the local PatchRelay service",
         "  inspect <issueKey>                                      Show the latest known issue state",
         "  live <issueKey> [--watch] [--json]                      Show the active run status",
@@ -64,11 +69,14 @@ function helpText() {
 }
 function getCommandConfigProfile(command) {
     switch (command) {
+        case "version":
+            return "service";
         case "doctor":
         case "install-service":
             return "doctor";
         case "connect":
         case "installations":
+        case "feed":
             return "operator_cli";
         case "inspect":
         case "live":
@@ -83,20 +91,100 @@ function getCommandConfigProfile(command) {
             return "service";
     }
 }
+function validateFlags(command, commandArgs, parsed) {
+    switch (command) {
+        case "version":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
+        case "help":
+        case "serve":
+            assertKnownFlags(parsed, command, []);
+            return;
+        case "inspect":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
+        case "live":
+            assertKnownFlags(parsed, command, ["watch", "json"]);
+            return;
+        case "report":
+            assertKnownFlags(parsed, command, ["stage", "stage-run", "json"]);
+            return;
+        case "events":
+            assertKnownFlags(parsed, command, ["stage-run", "method", "follow", "json"]);
+            return;
+        case "worktree":
+            assertKnownFlags(parsed, command, ["cd", "json"]);
+            return;
+        case "open":
+            assertKnownFlags(parsed, command, ["print", "json"]);
+            return;
+        case "retry":
+            assertKnownFlags(parsed, command, ["stage", "reason", "json"]);
+            return;
+        case "list":
+            assertKnownFlags(parsed, command, ["active", "failed", "project", "json"]);
+            return;
+        case "doctor":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
+        case "init":
+            assertKnownFlags(parsed, command, ["force", "json", "public-base-url"]);
+            return;
+        case "project":
+            if (commandArgs[0] === "apply") {
+                assertKnownFlags(parsed, "project apply", ["issue-prefix", "team-id", "no-connect", "no-open", "timeout", "json"]);
+                return;
+            }
+            assertKnownFlags(parsed, command, []);
+            return;
+        case "connect":
+            assertKnownFlags(parsed, command, ["project", "no-open", "timeout", "json"]);
+            return;
+        case "installations":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
+        case "feed":
+            assertKnownFlags(parsed, command, ["follow", "limit", "issue", "project", "json"]);
+            return;
+        case "install-service":
+            assertKnownFlags(parsed, command, ["force", "write-only", "json"]);
+            return;
+        case "restart-service":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
+        default:
+            return;
+    }
+}
 export async function runCli(argv, options) {
     const stdout = options?.stdout ?? process.stdout;
     const stderr = options?.stderr ?? process.stderr;
-    const parsed = parseArgs(argv);
-    const { command, commandArgs } = resolveCommand(parsed);
+    let parsed;
+    let command;
+    let commandArgs;
+    try {
+        parsed = parseArgs(argv);
+        ({ command, commandArgs } = resolveCommand(parsed));
+        validateFlags(command, commandArgs, parsed);
+    }
+    catch (error) {
+        writeOutput(stderr, `${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    const json = parsed.flags.get("json") === true;
     if (command === "help") {
         writeOutput(stdout, `${helpText()}\n`);
         return 0;
     }
+    if (command === "version") {
+        const buildInfo = getBuildInfo();
+        writeOutput(stdout, json ? formatJson(buildInfo) : `${buildInfo.version}\n`);
+        return 0;
+    }
     if (command === "serve") {
         return -1;
     }
     const runInteractive = options?.runInteractive ?? runInteractiveCommand;
-    const json = parsed.flags.get("json") === true;
     if (command === "init") {
         return await handleInitCommand({
             commandArgs,
@@ -185,6 +273,14 @@ export async function runCli(argv, options) {
                 data,
             });
         }
+        if (command === "feed") {
+            return await handleFeedCommand({
+                parsed,
+                json,
+                stdout,
+                data,
+            });
+        }
         if (command === "retry") {
             return await handleRetryCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
         }

package/dist/db/migrations.js

@@ -184,6 +184,19 @@ CREATE TABLE IF NOT EXISTS oauth_states (
   error_message TEXT
 );
 
+CREATE TABLE IF NOT EXISTS operator_feed_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  at TEXT NOT NULL,
+  level TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  detail TEXT,
+  issue_key TEXT,
+  project_id TEXT,
+  stage TEXT,
+  status TEXT
+);
+
 CREATE INDEX IF NOT EXISTS idx_event_receipts_project_issue ON event_receipts(project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issue_control_ready ON issue_control(desired_stage, active_run_lease_id);
 CREATE INDEX IF NOT EXISTS idx_issue_projection_issue_key ON issue_projection(issue_key);
@@ -192,6 +205,8 @@ CREATE INDEX IF NOT EXISTS idx_issue_sessions_last_opened ON issue_sessions(proj
 CREATE INDEX IF NOT EXISTS idx_run_leases_active ON run_leases(status, project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_run_leases_thread ON run_leases(thread_id);
 CREATE INDEX IF NOT EXISTS idx_run_thread_events_run ON run_thread_events(run_lease_id, id);
+CREATE INDEX IF NOT EXISTS idx_operator_feed_events_issue ON operator_feed_events(issue_key, id);
+CREATE INDEX IF NOT EXISTS idx_operator_feed_events_project ON operator_feed_events(project_id, id);
 CREATE INDEX IF NOT EXISTS idx_obligations_pending ON obligations(status, run_lease_id, kind);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_obligations_dedupe
 ON obligations(run_lease_id, kind, dedupe_key)

package/dist/db/operator-feed-store.js

@@ -0,0 +1,72 @@
+import { isoNow } from "./shared.js";
+export class OperatorFeedStore {
+    connection;
+    maxRows;
+    constructor(connection, maxRows = 5000) {
+        this.connection = connection;
+        this.maxRows = maxRows;
+    }
+    save(event) {
+        const at = event.at ?? isoNow();
+        const result = this.connection.prepare(`
+      INSERT INTO operator_feed_events (at, level, kind, summary, detail, issue_key, project_id, stage, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(at, event.level, event.kind, event.summary, event.detail ?? null, event.issueKey ?? null, event.projectId ?? null, event.stage ?? null, event.status ?? null);
+        this.prune();
+        const stored = this.connection.prepare("SELECT * FROM operator_feed_events WHERE id = ?").get(Number(result.lastInsertRowid));
+        return mapOperatorFeedEvent(stored);
+    }
+    list(options) {
+        const clauses = [];
+        const params = [];
+        if (options?.afterId !== undefined) {
+            clauses.push("id > ?");
+            params.push(options.afterId);
+        }
+        if (options?.issueKey) {
+            clauses.push("issue_key = ?");
+            params.push(options.issueKey);
+        }
+        if (options?.projectId) {
+            clauses.push("project_id = ?");
+            params.push(options.projectId);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = options?.limit ?? 50;
+        const rows = this.connection.prepare(`
+      SELECT *
+      FROM operator_feed_events
+      ${where}
+      ORDER BY id DESC
+      LIMIT ?
+      `).all(...params, limit);
+        return rows
+            .map((row) => mapOperatorFeedEvent(row))
+            .reverse();
+    }
+    prune() {
+        this.connection.prepare(`
+      DELETE FROM operator_feed_events
+      WHERE id NOT IN (
+        SELECT id
+        FROM operator_feed_events
+        ORDER BY id DESC
+        LIMIT ?
+      )
+      `).run(this.maxRows);
+    }
+}
+function mapOperatorFeedEvent(row) {
+    return {
+        id: Number(row.id),
+        at: String(row.at),
+        level: row.level,
+        kind: row.kind,
+        summary: String(row.summary),
+        ...(row.detail === null ? {} : { detail: String(row.detail) }),
+        ...(row.issue_key === null ? {} : { issueKey: String(row.issue_key) }),
+        ...(row.project_id === null ? {} : { projectId: String(row.project_id) }),
+        ...(row.stage === null ? {} : { stage: row.stage }),
+        ...(row.status === null ? {} : { status: String(row.status) }),
+    };
+}

package/dist/db.js

@@ -4,6 +4,7 @@ import { IssueWorkflowCoordinator } from "./db/issue-workflow-coordinator.js";
 import { IssueWorkflowStore } from "./db/issue-workflow-store.js";
 import { LinearInstallationStore } from "./db/linear-installation-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { OperatorFeedStore } from "./db/operator-feed-store.js";
 import { RunReportStore } from "./db/run-report-store.js";
 import { StageEventStore } from "./db/stage-event-store.js";
 import { SqliteConnection } from "./db/shared.js";
@@ -24,6 +25,7 @@ export class PatchRelayDatabase {
     runReports;
     stageEvents;
     linearInstallations;
+    operatorFeed;
     constructor(databasePath, wal) {
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
@@ -54,6 +56,7 @@ export class PatchRelayDatabase {
         });
         this.stageEvents = new StageEventStore(this.connection);
         this.linearInstallations = new LinearInstallationStore(this.connection);
+        this.operatorFeed = new OperatorFeedStore(this.connection);
     }
     runMigrations() {
         runPatchRelayMigrations(this.connection);