patchrelay 0.26.0 → 0.29.1

package/dist/cli/index.js

@@ -1,36 +1,29 @@
 import { loadConfig } from "../config.js";
 import { getBuildInfo } from "../build-info.js";
 import { assertKnownFlags, hasHelpFlag, 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";
+import { handleIssueCommand, } from "./commands/issues.js";
+import { handleLinearCommand } from "./commands/linear.js";
+import { handleRepoCommand } from "./commands/repo.js";
+import { handleInitCommand, handleServiceCommand } from "./commands/setup.js";
 import { CliUsageError } from "./errors.js";
 import { formatJson } from "./formatters/json.js";
 import { helpTextFor, rootHelpText } from "./help.js";
-import { runInteractiveCommand } from "./interactive.js";
+import { runBufferedCommand, runInteractiveCommand } from "./interactive.js";
 import { formatDoctor, writeOutput, writeUsageError } from "./output.js";
 function getCommandConfigProfile(command) {
     switch (command) {
         case "version":
             return "service";
         case "doctor":
-        case "install-service":
+        case "service":
             return "doctor";
-        case "connect":
-        case "installations":
+        case "linear":
         case "feed":
-        case "watch":
+        case "dashboard":
             return "operator_cli";
-        case "inspect":
-        case "live":
-        case "report":
-        case "events":
-        case "worktree":
-        case "open":
-        case "retry":
-        case "list":
+        case "repo":
+        case "issue":
             return "cli";
         default:
             return "service";
@@ -45,61 +38,107 @@ function validateFlags(command, commandArgs, parsed) {
         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, ["run-type", "run", "json"]);
-            return;
-        case "events":
-            assertKnownFlags(parsed, command, ["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, ["run-type", "reason", "json"]);
-            return;
-        case "list":
-            assertKnownFlags(parsed, command, ["active", "failed", "project", "json"]);
-            return;
+        case "issue": {
+            switch (commandArgs[0]) {
+                case "show":
+                    assertKnownFlags(parsed, "issue", ["json"]);
+                    return;
+                case "list":
+                    assertKnownFlags(parsed, "issue", ["active", "failed", "repo", "json"]);
+                    return;
+                case "watch":
+                    assertKnownFlags(parsed, "issue", ["json"]);
+                    return;
+                case "report":
+                    assertKnownFlags(parsed, "issue", ["run-type", "run", "json"]);
+                    return;
+                case "events":
+                    assertKnownFlags(parsed, "issue", ["run", "method", "follow", "json"]);
+                    return;
+                case "path":
+                    assertKnownFlags(parsed, "issue", ["cd", "json"]);
+                    return;
+                case "open":
+                    assertKnownFlags(parsed, "issue", ["print", "json"]);
+                    return;
+                case "retry":
+                    assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
+                    return;
+                default:
+                    assertKnownFlags(parsed, "issue", []);
+                    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;
+        case "linear":
+            switch (commandArgs[0]) {
+                case undefined:
+                case "list":
+                    assertKnownFlags(parsed, "linear", ["json"]);
+                    return;
+                case "connect":
+                    assertKnownFlags(parsed, "linear", ["no-open", "timeout", "json"]);
+                    return;
+                case "sync":
+                case "disconnect":
+                    assertKnownFlags(parsed, "linear", ["json"]);
+                    return;
+                default:
+                    assertKnownFlags(parsed, "linear", []);
+                    return;
             }
-            assertKnownFlags(parsed, command, []);
-            return;
+        case "repo":
+            switch (commandArgs[0]) {
+                case undefined:
+                case "list":
+                case "show":
+                case "unlink":
+                case "sync":
+                    assertKnownFlags(parsed, "repo", ["json"]);
+                    return;
+                case "link":
+                    assertKnownFlags(parsed, "repo", ["workspace", "team", "project", "prefix", "path", "json"]);
+                    return;
+                default:
+                    assertKnownFlags(parsed, "repo", []);
+                    return;
+            }
+        case "attach":
+        case "repos":
         case "connect":
-            assertKnownFlags(parsed, command, ["project", "no-open", "timeout", "json"]);
-            return;
         case "installations":
-            assertKnownFlags(parsed, command, ["json"]);
+            throw new CliUsageError(`${command} has been removed. Use \`patchrelay linear ...\` and \`patchrelay repo ...\` instead.`);
+            return;
+        case "service":
+            if (commandArgs[0] === "install") {
+                assertKnownFlags(parsed, "service", ["force", "write-only", "json"]);
+                return;
+            }
+            if (commandArgs[0] === "restart") {
+                assertKnownFlags(parsed, "service", ["json"]);
+                return;
+            }
+            if (commandArgs[0] === "status") {
+                assertKnownFlags(parsed, "service", ["json"]);
+                return;
+            }
+            if (commandArgs[0] === "logs") {
+                assertKnownFlags(parsed, "service", ["lines", "json"]);
+                return;
+            }
+            assertKnownFlags(parsed, "service", []);
             return;
         case "feed":
-            assertKnownFlags(parsed, command, ["follow", "limit", "issue", "project", "kind", "stage", "status", "workflow", "json"]);
+            assertKnownFlags(parsed, command, ["follow", "limit", "issue", "repo", "kind", "stage", "status", "workflow", "json"]);
             return;
-        case "watch":
+        case "dashboard":
             assertKnownFlags(parsed, command, ["issue"]);
             return;
-        case "install-service":
-            assertKnownFlags(parsed, command, ["force", "write-only", "json"]);
-            return;
-        case "restart-service":
-            assertKnownFlags(parsed, command, ["json"]);
-            return;
         default:
             return;
     }
@@ -131,8 +170,8 @@ export async function runCli(argv, options) {
     const json = parsed.flags.get("json") === true;
     if (command === "help") {
         const topic = commandArgs[0];
-        if (topic === "project") {
-            writeOutput(stdout, `${helpTextFor("project")}\n`);
+        if (topic === "linear" || topic === "repo" || topic === "issue" || topic === "service") {
+            writeOutput(stdout, `${helpTextFor(topic)}\n`);
             return 0;
         }
         if (topic) {
@@ -148,13 +187,28 @@ export async function runCli(argv, options) {
         return 0;
     }
     if (hasHelpFlag(parsed)) {
-        writeOutput(stdout, `${helpTextFor(command === "project" ? "project" : "root")}\n`);
+        const helpTopic = command === "linear"
+            ? "linear"
+            : command === "repo"
+                ? "repo"
+                : command === "issue" || command === "service"
+                    ? command
+                    : "root";
+        writeOutput(stdout, `${helpTextFor(helpTopic)}\n`);
         return 0;
     }
     if (command === "serve") {
         return -1;
     }
     const runInteractive = options?.runInteractive ?? runInteractiveCommand;
+    const runCommand = options?.runCommand
+        ?? (options?.runInteractive
+            ? async (command, args) => ({
+                exitCode: await options.runInteractive(command, args),
+                stdout: "",
+                stderr: "",
+            })
+            : runBufferedCommand);
     if (command === "init") {
         return await handleInitCommand({
             commandArgs,
@@ -163,37 +217,57 @@ export async function runCli(argv, options) {
             stdout,
             stderr,
             runInteractive,
+            runCommand,
         });
     }
-    if (command === "install-service") {
-        return await handleInstallServiceCommand({
-            commandArgs,
-            parsed,
-            json,
-            stdout,
-            stderr,
-            runInteractive,
-        });
-    }
-    if (command === "restart-service") {
-        return await handleRestartServiceCommand({
-            commandArgs,
-            parsed,
-            json,
-            stdout,
-            stderr,
-            runInteractive,
-        });
-    }
-    if (command === "project") {
+    if (command === "service") {
         try {
-            return await handleProjectCommand({
+            return await handleServiceCommand({
                 commandArgs,
                 parsed,
                 json,
                 stdout,
                 stderr,
                 runInteractive,
+                runCommand,
+            });
+        }
+        catch (error) {
+            if (error instanceof CliUsageError) {
+                writeUsageError(stderr, error);
+                return 1;
+            }
+            writeOutput(stderr, `${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "linear") {
+        try {
+            return await handleLinearCommand({
+                commandArgs,
+                parsed,
+                json,
+                stdout,
+                ...(options ? { options } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof CliUsageError) {
+                writeUsageError(stderr, error);
+                return 1;
+            }
+            writeOutput(stderr, `${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+    }
+    if (command === "repo") {
+        try {
+            return await handleRepoCommand({
+                commandArgs,
+                parsed,
+                json,
+                stdout,
+                runCommand,
                 ...(options ? { options } : {}),
             });
         }
@@ -229,81 +303,25 @@ export async function runCli(argv, options) {
             writeOutput(stdout, json ? formatJson(doctorReport) : formatDoctor(doctorReport, cliVersion, serviceVersion));
             return report.ok ? 0 : 1;
         }
-        if (command === "inspect") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleInspectCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "live") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleLiveCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "report") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleReportCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "events") {
+        if (command === "issue") {
             const issueData = await ensureIssueDataAccess(data, config);
             if (!data) {
                 data = issueData;
                 ownsData = true;
             }
-            return await handleEventsCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "worktree") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleWorktreeCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "open") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleOpenCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "connect") {
-            const operatorData = await ensureConnectDataAccess(data, config);
-            if (!data) {
-                data = operatorData;
-                ownsData = true;
-            }
-            return await handleConnectCommand({
+            return await handleIssueCommand({
+                commandArgs,
                 parsed,
                 json,
                 stdout,
+                data: issueData,
                 config,
-                data: operatorData,
-                ...(options ? { options } : {}),
+                runInteractive,
             });
         }
-        if (command === "installations") {
-            const operatorData = await ensureInstallationsDataAccess(data, config);
-            if (!data) {
-                data = operatorData;
-                ownsData = true;
-            }
-            return await handleInstallationsCommand({
-                json,
-                stdout,
-                data: operatorData,
-                config,
-            });
+        if (command === "attach" || command === "repos" || command === "connect" || command === "installations") {
+            writeOutput(stderr, `${command} has been removed. Use \`patchrelay linear ...\` and \`patchrelay repo ...\` instead.\n`);
+            return 1;
         }
         if (command === "feed") {
             const operatorData = parsed.flags.get("follow") === true
@@ -320,26 +338,10 @@ export async function runCli(argv, options) {
                 data: operatorData,
             });
         }
-        if (command === "watch") {
+        if (command === "dashboard") {
             const { handleWatchCommand } = await import("./commands/watch.js");
             return await handleWatchCommand({ config, parsed });
         }
-        if (command === "retry") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleRetryCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
-        if (command === "list") {
-            const issueData = await ensureIssueDataAccess(data, config);
-            if (!data) {
-                data = issueData;
-                ownsData = true;
-            }
-            return await handleListCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
-        }
         throw new Error(`Unknown command: ${command}`);
     }
     catch (error) {
@@ -373,27 +375,9 @@ async function ensureIssueDataAccess(data, config) {
     }
     return await createCliDataAccess(config);
 }
-async function ensureConnectDataAccess(data, config) {
-    if (data) {
-        if (hasConnectDataAccess(data)) {
-            return data;
-        }
-        throw new Error("The connect command requires HTTP-backed OAuth CLI data access.");
-    }
-    return await createCliOperatorDataAccess(config);
-}
 function isIssueDataAccess(data) {
     return !!data && typeof data === "object" && "inspect" in data && typeof data.inspect === "function";
 }
-async function ensureInstallationsDataAccess(data, config) {
-    if (data) {
-        if (hasInstallationsDataAccess(data)) {
-            return data;
-        }
-        throw new Error("The installations command requires HTTP-backed installation data access.");
-    }
-    return await createCliOperatorDataAccess(config);
-}
 async function ensureFeedListDataAccess(data, config) {
     if (data) {
         if (hasFeedListDataAccess(data)) {
@@ -403,12 +387,6 @@ async function ensureFeedListDataAccess(data, config) {
     }
     return await createCliOperatorDataAccess(config);
 }
-function hasConnectDataAccess(data) {
-    return !!data && typeof data === "object" && "connect" in data && typeof data.connect === "function";
-}
-function hasInstallationsDataAccess(data) {
-    return !!data && typeof data === "object" && "listInstallations" in data && typeof data.listInstallations === "function";
-}
 async function ensureFeedFollowDataAccess(data, config) {
     if (data) {
         if (hasFeedFollowDataAccess(data)) {

package/dist/cli/interactive.js

@@ -27,6 +27,31 @@ export async function runInteractiveCommand(command, args) {
         });
     });
 }
+export async function runBufferedCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            resolve({
+                exitCode: signal ? 1 : (code ?? 0),
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
 export async function openExternalUrl(url) {
     const candidates = process.platform === "darwin"
         ? [{ command: "open", args: [url] }]

package/dist/cli/operator-client.js

@@ -18,6 +18,17 @@ export class CliOperatorApiClient {
     async listInstallations() {
         return await this.requestJson("/api/installations");
     }
+    async listLinearWorkspaces() {
+        return await this.requestJson("/api/linear/workspaces");
+    }
+    async syncLinearWorkspace(workspace) {
+        return await this.requestJson("/api/linear/workspaces/sync", {
+            ...(workspace ? { workspace } : {}),
+        }, { method: "POST" });
+    }
+    async disconnectLinearWorkspace(workspace) {
+        return await this.requestJson(`/api/linear/workspaces/${encodeURIComponent(workspace)}`, undefined, { method: "DELETE" });
+    }
     async listOperatorFeed(options) {
         return await this.requestJson("/api/feed", {
             ...(options?.limit && options.limit > 0 ? { limit: String(options.limit) } : {}),

package/dist/cli/service-commands.js

@@ -1,10 +1,18 @@
+function summarizeCommandOutput(result) {
+    const parts = [result.stderr.trim(), result.stdout.trim()].filter(Boolean);
+    return parts.length > 0 ? `\n${parts.join("\n")}` : "";
+}
 export async function runServiceCommands(runner, commands) {
+    const results = [];
     for (const entry of commands) {
-        const exitCode = await runner(entry.command, entry.args);
-        if (exitCode !== 0) {
-            throw new Error(`Command failed with exit code ${exitCode}: ${entry.command} ${entry.args.join(" ")}`);
+        const result = await runner(entry.command, entry.args);
+        const commandResult = { ...entry, ...result };
+        results.push(commandResult);
+        if (result.exitCode !== 0) {
+            throw new Error(`Command failed with exit code ${result.exitCode}: ${entry.command} ${entry.args.join(" ")}${summarizeCommandOutput(result)}`);
         }
     }
+    return results;
 }
 export async function tryManageService(runner, commands) {
     try {
@@ -18,7 +26,6 @@ export async function tryManageService(runner, commands) {
 export function installServiceCommands() {
     return [
         { command: "sudo", args: ["systemctl", "daemon-reload"] },
-        { command: "sudo", args: ["systemctl", "enable", "--now", "patchrelay.path"] },
         { command: "sudo", args: ["systemctl", "enable", "patchrelay.service"] },
         { command: "sudo", args: ["systemctl", "reload-or-restart", "patchrelay.service"] },
     ];

package/dist/cli/watch/App.js

@@ -193,5 +193,5 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, timelineMode: state.timelineMode, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [state.activeDetailKey && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Issues" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { bold: true, children: state.activeDetailKey }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { dimColor: true, children: state.detailTab === "timeline" ? "Timeline" : "History" })] })), _jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, timelineMode: state.timelineMode, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Issues" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { bold: true, children: "Operator Feed" })] }), _jsx(FeedView, { events: state.feedEvents, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt })] })) }));
 }

package/dist/cli/watch/FactoryStateGraph.js

@@ -0,0 +1,31 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function statusColor(status) {
+    switch (status) {
+        case "current":
+            return "cyan";
+        case "visited":
+            return "green";
+        case "upcoming":
+            return "gray";
+    }
+}
+function statusPrefix(status) {
+    switch (status) {
+        case "current":
+            return "*";
+        case "visited":
+            return "+";
+        case "upcoming":
+            return " ";
+    }
+}
+function NodePill({ node }) {
+    return (_jsxs(Text, { color: statusColor(node.status), bold: node.status === "current", children: ["[", statusPrefix(node.status), " ", node.label, "]"] }));
+}
+function NodeRow({ label, nodes, connector = " -> ", }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(11, " ") }), nodes.map((node, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { dimColor: true, children: connector }), _jsx(NodePill, { node: node })] }, node.state)))] }));
+}
+export function FactoryStateGraph({ main, prLoops, queueLoop, exits, }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "State Graph" }), _jsx(NodeRow, { label: "main", nodes: main }), _jsx(NodeRow, { label: "pr loops", nodes: prLoops, connector: "   " }), _jsx(NodeRow, { label: "queue loop", nodes: queueLoop, connector: "   " }), _jsx(NodeRow, { label: "exits", nodes: exits, connector: "   " })] }));
+}

package/dist/cli/watch/FeedView.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { HelpBar } from "./HelpBar.js";
+import { FreshnessBadge } from "./FreshnessBadge.js";
 const TAIL_SIZE = 30;
 const KIND_COLORS = {
     stage: "cyan",
@@ -20,8 +21,8 @@ function FeedEventRow({ event }) {
     const kindColor = KIND_COLORS[event.kind] ?? "white";
     return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(event.at), " "] }), _jsx(Text, { color: kindColor, children: (event.status ?? event.kind).padEnd(14) }), event.issueKey && _jsx(Text, { bold: true, children: ` ${event.issueKey.padEnd(9)}` }), _jsxs(Text, { children: [" ", event.summary] })] }));
 }
-export function FeedView({ events, connected }) {
+export function FeedView({ events, connected, lastServerMessageAt }) {
     const visible = events.length > TAIL_SIZE ? events.slice(-TAIL_SIZE) : events;
     const skipped = events.length - visible.length;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "Operator Feed" }), _jsx(Text, { color: connected ? "green" : "red", children: connected ? "\u25cf connected" : "\u25cb disconnected" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: events.length === 0 ? (_jsx(Text, { dimColor: true, children: "No feed events yet." })) : (_jsxs(_Fragment, { children: [skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier"] }), visible.map((event) => (_jsx(FeedEventRow, { event: event }, event.id)))] })) }), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "feed" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "Operator Feed" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: events.length === 0 ? (_jsx(Text, { dimColor: true, children: "No feed events yet." })) : (_jsxs(_Fragment, { children: [skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier"] }), visible.map((event) => (_jsx(FeedEventRow, { event: event }, event.id)))] })) }), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "feed" }) })] }));
 }

package/dist/cli/watch/FreshnessBadge.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useReducer } from "react";
+import { Text } from "ink";
+import { describePatchRelayFreshness } from "./freshness.js";
+export function FreshnessBadge({ connected, lastServerMessageAt }) {
+    const [, tick] = useReducer((value) => value + 1, 0);
+    useEffect(() => {
+        const id = setInterval(tick, 5_000);
+        return () => clearInterval(id);
+    }, []);
+    const freshness = describePatchRelayFreshness(connected, lastServerMessageAt);
+    return _jsx(Text, { color: freshness.color, children: freshness.label });
+}