patchrelay 0.12.8 → 0.13.0

package/dist/agent-session-plan.js

@@ -8,27 +8,171 @@ function titleCase(value) {
         .map((word) => word[0].toUpperCase() + word.slice(1))
         .join(" ");
 }
-function buildPlan(runType, statuses) {
-    const label = titleCase(formatRunLabel(runType));
+export function formatRunTypeLabel(runType) {
+    return titleCase(formatRunLabel(runType));
+}
+function implementationPlan() {
+    return [
+        { content: "Prepare workspace", status: "pending" },
+        { content: "Implement or update branch", status: "pending" },
+        { content: "Await review", status: "pending" },
+        { content: "Land change", status: "pending" },
+    ];
+}
+function reviewFixPlan() {
+    return [
+        { content: "Prepare workspace", status: "completed" },
+        { content: "Address review feedback", status: "pending" },
+        { content: "Await re-review", status: "pending" },
+        { content: "Land change", status: "pending" },
+    ];
+}
+function ciRepairPlan(attempt) {
+    return [
+        { content: "Prepare workspace", status: "completed" },
+        { content: "Implement or update branch", status: "completed" },
+        { content: `Repair failing checks (${attemptLabel(attempt)})`, status: "pending" },
+        { content: "Return to merge flow", status: "pending" },
+    ];
+}
+function queueRepairPlan(attempt) {
+    return [
+        { content: "Prepare workspace", status: "completed" },
+        { content: "Implement or update branch", status: "completed" },
+        { content: "Review approved", status: "completed" },
+        { content: `Repair merge queue (${attemptLabel(attempt)})`, status: "pending" },
+    ];
+}
+function awaitingInputPlan() {
+    return [
+        { content: "Prepare workspace", status: "completed" },
+        { content: "Implement or update branch", status: "completed" },
+        { content: "Review approved", status: "completed" },
+        { content: "Waiting for guidance", status: "inProgress" },
+    ];
+}
+function failedPlan(label) {
     return [
-        { content: "Prepare workspace", status: statuses[0] },
-        { content: `Run ${label}`, status: statuses[1] },
-        { content: "Review outcome", status: statuses[2] },
+        { content: "Prepare workspace", status: "completed" },
+        { content: "Implement or update branch", status: "completed" },
+        { content: "Review approved", status: "completed" },
+        { content: label, status: "inProgress" },
     ];
 }
+function attemptLabel(attempt) {
+    const safeAttempt = Math.max(1, attempt);
+    return `attempt ${safeAttempt}`;
+}
+function setStatuses(plan, statuses) {
+    return plan.map((step, index) => ({ ...step, status: statuses[index] ?? step.status }));
+}
+function resolvePlanRunType(params) {
+    if (params.activeRunType) {
+        return params.activeRunType;
+    }
+    if (params.pendingRunType) {
+        return params.pendingRunType;
+    }
+    switch (params.factoryState) {
+        case "changes_requested":
+            return "review_fix";
+        case "repairing_ci":
+            return "ci_repair";
+        case "repairing_queue":
+            return "queue_repair";
+        default:
+            return "implementation";
+    }
+}
+export function buildAgentSessionPlan(params) {
+    const runType = resolvePlanRunType(params);
+    switch (params.factoryState) {
+        case "delegated":
+        case "preparing":
+            return setStatuses(planForRunType(runType, params), ["inProgress", "pending", "pending", "pending"]);
+        case "implementing":
+            return setStatuses(planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
+        case "pr_open":
+        case "awaiting_review":
+            return setStatuses(implementationPlan(), ["completed", "completed", "inProgress", "pending"]);
+        case "changes_requested":
+            return setStatuses(reviewFixPlan(), ["completed", "inProgress", "pending", "pending"]);
+        case "repairing_ci":
+            return setStatuses(ciRepairPlan(params.ciRepairAttempts ?? 1), ["completed", "completed", "inProgress", "pending"]);
+        case "awaiting_queue":
+            return setStatuses([
+                { content: "Prepare workspace", status: "completed" },
+                { content: "Implement or update branch", status: "completed" },
+                { content: "Review approved", status: "completed" },
+                { content: "Queued for merge", status: "inProgress" },
+            ], ["completed", "completed", "completed", "inProgress"]);
+        case "repairing_queue":
+            return setStatuses(queueRepairPlan(params.queueRepairAttempts ?? 1), ["completed", "completed", "completed", "inProgress"]);
+        case "awaiting_input":
+            return awaitingInputPlan();
+        case "escalated":
+            return failedPlan("Needs human help");
+        case "failed":
+            return failedPlan("Recovery needed");
+        case "done":
+            return setStatuses([
+                { content: "Prepare workspace", status: "completed" },
+                { content: "Implement or update branch", status: "completed" },
+                { content: "Review approved", status: "completed" },
+                { content: "Merged", status: "completed" },
+            ], ["completed", "completed", "completed", "completed"]);
+    }
+}
+function planForRunType(runType, params) {
+    switch (runType) {
+        case "review_fix":
+            return reviewFixPlan();
+        case "ci_repair":
+            return ciRepairPlan(params.ciRepairAttempts ?? 1);
+        case "queue_repair":
+            return queueRepairPlan(params.queueRepairAttempts ?? 1);
+        case "implementation":
+        default:
+            return implementationPlan();
+    }
+}
+export function buildAgentSessionPlanForIssue(issue, options) {
+    return buildAgentSessionPlan({
+        factoryState: issue.factoryState,
+        ciRepairAttempts: issue.ciRepairAttempts,
+        queueRepairAttempts: issue.queueRepairAttempts,
+        ...(issue.pendingRunType ? { pendingRunType: issue.pendingRunType } : {}),
+        ...(options?.activeRunType ? { activeRunType: options.activeRunType } : {}),
+    });
+}
 export function buildPreparingSessionPlan(runType) {
-    return buildPlan(runType, ["inProgress", "pending", "pending"]);
+    return buildAgentSessionPlan({
+        factoryState: "preparing",
+        pendingRunType: runType,
+    });
 }
 export function buildRunningSessionPlan(runType) {
-    return buildPlan(runType, ["completed", "inProgress", "pending"]);
+    return buildAgentSessionPlan({
+        factoryState: runType === "ci_repair" ? "repairing_ci"
+            : runType === "review_fix" ? "changes_requested"
+                : runType === "queue_repair" ? "repairing_queue"
+                    : "implementing",
+        activeRunType: runType,
+    });
 }
 export function buildCompletedSessionPlan(runType) {
-    return buildPlan(runType, ["completed", "completed", "completed"]);
+    if (runType === "ci_repair" || runType === "queue_repair") {
+        return buildAgentSessionPlan({ factoryState: "awaiting_queue" });
+    }
+    return buildAgentSessionPlan({ factoryState: "awaiting_review" });
 }
 export function buildAwaitingHandoffSessionPlan(runType) {
-    return buildPlan(runType, ["completed", "completed", "inProgress"]);
+    return buildCompletedSessionPlan(runType);
 }
 export function buildFailedSessionPlan(runType, run) {
-    const workflowStepStatus = run?.threadId || run?.turnId ? "completed" : "inProgress";
-    return buildPlan(runType, ["completed", workflowStepStatus, "pending"]);
+    void run;
+    return buildAgentSessionPlan({
+        factoryState: "failed",
+        activeRunType: runType,
+    });
 }

package/dist/agent-session-presentation.js

@@ -1,22 +1,27 @@
 import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSigningSecret, } from "./public-agent-session-status.js";
 const SESSION_STATUS_TTL_SECONDS = 60 * 60 * 24 * 7;
-export function buildAgentSessionExternalUrls(config, issueKey) {
-    if (!issueKey || !config.server.publicBaseUrl) {
-        return undefined;
-    }
-    const token = createSessionStatusToken({
-        issueKey,
-        secret: deriveSessionStatusSigningSecret(config.linear.tokenEncryptionKey),
-        ttlSeconds: SESSION_STATUS_TTL_SECONDS,
-    });
-    return [
-        {
+export function buildAgentSessionExternalUrls(config, params) {
+    const urls = [];
+    if (params.issueKey && config.server.publicBaseUrl) {
+        const token = createSessionStatusToken({
+            issueKey: params.issueKey,
+            secret: deriveSessionStatusSigningSecret(config.linear.tokenEncryptionKey),
+            ttlSeconds: SESSION_STATUS_TTL_SECONDS,
+        });
+        urls.push({
             label: "PatchRelay status",
             url: buildSessionStatusUrl({
                 publicBaseUrl: config.server.publicBaseUrl,
-                issueKey,
+                issueKey: params.issueKey,
                 token: token.token,
             }),
-        },
-    ];
+        });
+    }
+    if (params.prUrl) {
+        urls.push({
+            label: "Pull request",
+            url: params.prUrl,
+        });
+    }
+    return urls.length > 0 ? urls : undefined;
 }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.12.8",
-  "commit": "711863ef2d94",
-  "builtAt": "2026-03-24T22:49:07.152Z"
+  "version": "0.13.0",
+  "commit": "e106318f8abc",
+  "builtAt": "2026-03-25T08:10:05.542Z"
 }

package/dist/cli/args.js

@@ -16,6 +16,7 @@ export const KNOWN_COMMANDS = new Set([
     "connect",
     "installations",
     "feed",
+    "watch",
     "install-service",
     "restart-service",
     "help",

package/dist/cli/commands/watch.js

@@ -0,0 +1,30 @@
+function resolveBaseUrl(config) {
+    const bind = config.server.bind;
+    let host;
+    if (bind === "0.0.0.0") {
+        host = "127.0.0.1";
+    }
+    else if (bind === "::") {
+        host = "[::1]";
+    }
+    else if (bind.includes(":") && !bind.startsWith("[")) {
+        host = `[${bind}]`;
+    }
+    else {
+        host = bind;
+    }
+    return `http://${host}:${config.server.port}`;
+}
+export async function handleWatchCommand(params) {
+    const { render } = await import("ink");
+    const { createElement } = await import("react");
+    const { App } = await import("../watch/App.js");
+    const baseUrl = resolveBaseUrl(params.config);
+    const bearerToken = params.config.operatorApi.bearerToken ?? undefined;
+    const issueKey = typeof params.parsed.flags.get("issue") === "string"
+        ? String(params.parsed.flags.get("issue"))
+        : undefined;
+    const instance = render(createElement(App, { baseUrl, bearerToken, initialIssueKey: issueKey }));
+    await instance.waitUntilExit();
+    return 0;
+}

package/dist/cli/help.js

@@ -39,6 +39,7 @@ export function rootHelpText() {
         "  installations [--json]                                 Show connected Linear installations",
         "  feed [--follow] [--limit <count>] [--issue <issueKey>] [--project <projectId>] [--kind <kind>] [--stage <stage>] [--status <status>] [--workflow <id>] [--json]",
         "                                                          Show a live operator feed from the daemon",
+        "  watch [--issue <issueKey>]                              Live TUI dashboard of issues and runs",
         "  serve                                                  Run the local PatchRelay service",
         "  inspect <issueKey>                                     Show the latest known issue state",
         "  live <issueKey> [--watch] [--json]                     Show the active run status",

package/dist/cli/index.js

@@ -21,6 +21,7 @@ function getCommandConfigProfile(command) {
         case "connect":
         case "installations":
         case "feed":
+        case "watch":
             return "operator_cli";
         case "inspect":
         case "live":
@@ -90,6 +91,9 @@ function validateFlags(command, commandArgs, parsed) {
         case "feed":
             assertKnownFlags(parsed, command, ["follow", "limit", "issue", "project", "kind", "stage", "status", "workflow", "json"]);
             return;
+        case "watch":
+            assertKnownFlags(parsed, command, ["issue"]);
+            return;
         case "install-service":
             assertKnownFlags(parsed, command, ["force", "write-only", "json"]);
             return;
@@ -316,6 +320,10 @@ export async function runCli(argv, options) {
                 data: operatorData,
             });
         }
+        if (command === "watch") {
+            const { handleWatchCommand } = await import("./commands/watch.js");
+            return await handleWatchCommand({ config, parsed });
+        }
         if (command === "retry") {
             const issueData = await ensureIssueDataAccess(data, config);
             if (!data) {

package/dist/cli/watch/App.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useReducer } from "react";
+import { Box, useApp, useInput } from "ink";
+import { watchReducer, initialWatchState } from "./watch-state.js";
+import { useWatchStream } from "./use-watch-stream.js";
+import { useDetailStream } from "./use-detail-stream.js";
+import { IssueListView } from "./IssueListView.js";
+import { IssueDetailView } from "./IssueDetailView.js";
+export function App({ baseUrl, bearerToken, initialIssueKey }) {
+    const { exit } = useApp();
+    const [state, dispatch] = useReducer(watchReducer, {
+        ...initialWatchState,
+        ...(initialIssueKey ? { view: "detail", activeDetailKey: initialIssueKey } : {}),
+    });
+    useWatchStream({ baseUrl, bearerToken, dispatch });
+    useDetailStream({ baseUrl, bearerToken, issueKey: state.activeDetailKey, dispatch });
+    useInput((input, key) => {
+        if (input === "q") {
+            exit();
+            return;
+        }
+        if (state.view === "list") {
+            if (input === "j" || key.downArrow) {
+                dispatch({ type: "select", index: state.selectedIndex + 1 });
+            }
+            else if (input === "k" || key.upArrow) {
+                dispatch({ type: "select", index: state.selectedIndex - 1 });
+            }
+            else if (key.return) {
+                const issue = state.issues[state.selectedIndex];
+                if (issue?.issueKey) {
+                    dispatch({ type: "enter-detail", issueKey: issue.issueKey });
+                }
+            }
+        }
+        else if (state.view === "detail") {
+            if (key.escape || key.backspace || key.delete) {
+                dispatch({ type: "exit-detail" });
+            }
+        }
+    });
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { state: state })) : (_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), thread: state.thread })) }));
+}

package/dist/cli/watch/HelpBar.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function HelpBar({ view }) {
+    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: view === "list"
+                ? "j/k: navigate  Enter: detail  q: quit"
+                : "Esc: back  q: quit" }) }));
+}

package/dist/cli/watch/IssueDetailView.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { ThreadView } from "./ThreadView.js";
+import { HelpBar } from "./HelpBar.js";
+export function IssueDetailView({ issue, thread }) {
+    if (!issue) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail" })] }));
+    }
+    const key = issue.issueKey ?? issue.projectId;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["PR #", issue.prNumber] })] }), issue.title && _jsx(Text, { dimColor: true, children: issue.title }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), thread ? (_jsx(ThreadView, { thread: thread })) : (_jsx(Text, { dimColor: true, children: "Waiting for thread data..." })), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "detail" })] }));
+}

package/dist/cli/watch/IssueListView.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { IssueRow } from "./IssueRow.js";
+import { StatusBar } from "./StatusBar.js";
+import { HelpBar } from "./HelpBar.js";
+export function IssueListView({ state }) {
+    const { issues, selectedIndex, connected } = state;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, connected: connected }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No tracked issues." })) : (_jsx(Box, { flexDirection: "column", children: issues.map((issue, index) => (_jsx(IssueRow, { issue: issue, selected: index === selectedIndex }, issue.issueKey ?? `${issue.projectId}-${index}`))) })), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "list" })] }));
+}

package/dist/cli/watch/IssueRow.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const STATE_COLORS = {
+    delegated: "blue",
+    preparing: "blue",
+    implementing: "yellow",
+    pr_open: "cyan",
+    awaiting_review: "cyan",
+    changes_requested: "magenta",
+    repairing_ci: "magenta",
+    awaiting_queue: "green",
+    repairing_queue: "magenta",
+    done: "green",
+    failed: "red",
+    escalated: "red",
+    awaiting_input: "yellow",
+};
+function stateColor(state) {
+    return STATE_COLORS[state] ?? "white";
+}
+function formatPr(issue) {
+    if (!issue.prNumber)
+        return "";
+    const parts = [`PR #${issue.prNumber}`];
+    if (issue.prReviewState === "approved")
+        parts.push("approved");
+    else if (issue.prReviewState === "changes_requested")
+        parts.push("changes");
+    if (issue.prCheckStatus === "passed")
+        parts.push("checks ok");
+    else if (issue.prCheckStatus === "failed")
+        parts.push("checks fail");
+    return parts.join(" ");
+}
+export function IssueRow({ issue, selected }) {
+    const key = issue.issueKey ?? issue.projectId;
+    const state = issue.factoryState;
+    const run = issue.activeRunType ?? issue.latestRunType;
+    const runStatus = issue.activeRunType ? "running" : issue.latestRunStatus;
+    const pr = formatPr(issue);
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: selected ? "blueBright" : "white", bold: selected, children: selected ? "▸" : " " }), _jsx(Text, { bold: true, children: key.padEnd(10) }), _jsx(Text, { color: stateColor(state), children: state.padEnd(20) }), _jsx(Text, { dimColor: true, children: run ? `${run}${runStatus ? `:${runStatus}` : ""}`.padEnd(25) : "".padEnd(25) }), pr ? _jsx(Text, { dimColor: true, children: pr }) : null] }));
+}

package/dist/cli/watch/ItemLine.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const STATUS_SYMBOL = {
+    completed: "\u2713",
+    failed: "\u2717",
+    declined: "\u2717",
+    inProgress: "\u25cf",
+};
+function statusChar(status) {
+    return STATUS_SYMBOL[status] ?? " ";
+}
+function statusColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "failed" || status === "declined")
+        return "red";
+    if (status === "inProgress")
+        return "yellow";
+    return "white";
+}
+function truncate(text, max) {
+    const line = text.replace(/\n/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 3)}...` : line;
+}
+function renderAgentMessage(item) {
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "message: " }), _jsx(Text, { children: truncate(item.text ?? "", 120) })] }));
+}
+function renderCommand(item) {
+    const cmd = item.command ?? "?";
+    const exit = item.exitCode !== undefined ? ` exit:${item.exitCode}` : "";
+    const duration = item.durationMs !== undefined ? ` ${(item.durationMs / 1000).toFixed(1)}s` : "";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "$ " }), _jsx(Text, { children: truncate(cmd, 60) }), exit && _jsx(Text, { dimColor: true, children: exit }), duration && _jsx(Text, { dimColor: true, children: duration })] }), item.output && item.status === "inProgress" && (_jsxs(Text, { dimColor: true, children: ["  ", truncate(item.output.split("\n").filter(Boolean).at(-1) ?? "", 100)] }))] }));
+}
+function renderFileChange(item) {
+    const count = item.changes?.length ?? 0;
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "files: " }), _jsxs(Text, { children: [count, " change", count !== 1 ? "s" : ""] })] }));
+}
+function renderToolCall(item) {
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "tool: " }), _jsx(Text, { children: item.toolName ?? item.type })] }));
+}
+function renderPlan(item) {
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "plan: " }), _jsx(Text, { children: truncate(item.text ?? "", 120) })] }));
+}
+function renderDefault(item) {
+    return (_jsxs(Text, { dimColor: true, children: [item.type, item.text ? `: ${truncate(item.text, 80)}` : ""] }));
+}
+export function ItemLine({ item, isLast }) {
+    const prefix = isLast ? "\u2514" : "\u251c";
+    let content;
+    switch (item.type) {
+        case "agentMessage":
+            content = renderAgentMessage(item);
+            break;
+        case "commandExecution":
+            content = renderCommand(item);
+            break;
+        case "fileChange":
+            content = renderFileChange(item);
+            break;
+        case "mcpToolCall":
+        case "dynamicToolCall":
+            content = renderToolCall(item);
+            break;
+        case "plan":
+            content = renderPlan(item);
+            break;
+        default:
+            content = renderDefault(item);
+            break;
+    }
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: prefix }), _jsx(Text, { color: statusColor(item.status), children: statusChar(item.status) }), content] }));
+}

package/dist/cli/watch/StatusBar.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function StatusBar({ issues, connected }) {
+    const active = issues.filter((i) => i.activeRunType).length;
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: issues.length }), _jsx(Text, { children: " issues tracked" }), active > 0 && (_jsxs(Text, { children: [", ", _jsx(Text, { bold: true, color: "green", children: active }), " active"] }))] }), _jsx(Text, { color: connected ? "green" : "red", children: connected ? "● connected" : "○ disconnected" })] }));
+}

package/dist/cli/watch/ThreadView.js

@@ -0,0 +1,20 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { TurnSection } from "./TurnSection.js";
+function planStepSymbol(status) {
+    if (status === "completed")
+        return "\u2713";
+    if (status === "inProgress")
+        return "\u25b8";
+    return " ";
+}
+function planStepColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "inProgress")
+        return "yellow";
+    return "white";
+}
+export function ThreadView({ thread }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Thread: ", thread.threadId.slice(0, 16)] }), _jsxs(Text, { dimColor: true, children: ["Status: ", thread.status] }), _jsxs(Text, { dimColor: true, children: ["Turns: ", thread.turns.length] })] }), thread.plan && thread.plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Plan:" }), thread.plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`)))] })), _jsx(Box, { flexDirection: "column", marginTop: 1, children: thread.turns.map((turn, i) => (_jsx(TurnSection, { turn: turn, index: i }, turn.id))) })] }));
+}

package/dist/cli/watch/TurnSection.js

@@ -0,0 +1,15 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { ItemLine } from "./ItemLine.js";
+function turnStatusColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "failed" || status === "interrupted")
+        return "red";
+    if (status === "inProgress")
+        return "yellow";
+    return "white";
+}
+export function TurnSection({ turn, index }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { bold: true, children: ["Turn #", index + 1] }), _jsx(Text, { color: turnStatusColor(turn.status), children: turn.status }), _jsxs(Text, { dimColor: true, children: ["(", turn.items.length, " items)"] })] }), turn.items.map((item, i) => (_jsx(ItemLine, { item: item, isLast: i === turn.items.length - 1 }, item.id)))] }));
+}