patchrelay 0.35.12 → 0.35.13

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.12",
-  "commit": "d9cef8cb23dd",
-  "builtAt": "2026-04-07T10:41:56.287Z"
+  "version": "0.35.13",
+  "commit": "f82366476725",
+  "builtAt": "2026-04-07T23:06:53.397Z"
 }

package/dist/cli/args.js

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

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatInspect, formatList, formatLive, formatOpen, formatRetry, formatWorktree } from "../formatters/text.js";
+import { formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -34,6 +34,8 @@ export async function handleIssueCommand(params) {
             return await handleWorktreeCommand(nested);
         case "open":
             return await handleOpenCommand(nested);
+        case "sessions":
+            return await handleSessionsCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
         default:
@@ -112,6 +114,20 @@ export async function handleOpenCommand(params) {
     const openCommand = buildOpenCommand(params.config, result.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }
+export async function handleSessionsCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("sessions requires <issueKey>.");
+    }
+    const result = params.data.sessions(issueKey);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    writeOutput(params.stdout, params.json
+        ? formatJson(result)
+        : formatSessionHistory(result, (threadId) => buildOpenCommand(params.config, result.worktreePath ?? "", threadId)));
+    return 0;
+}
 export async function handleRetryCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/data.js

@@ -56,6 +56,23 @@ function parseObjectJson(value) {
         return undefined;
     }
 }
+function summarizeRun(run) {
+    const summary = parseObjectJson(run.summaryJson);
+    if (typeof summary?.latestAssistantMessage === "string" && summary.latestAssistantMessage.trim()) {
+        return summary.latestAssistantMessage.trim();
+    }
+    const report = parseObjectJson(run.reportJson);
+    const assistantMessages = report?.assistantMessages;
+    if (Array.isArray(assistantMessages)) {
+        for (let index = assistantMessages.length - 1; index >= 0; index -= 1) {
+            const value = assistantMessages[index];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return run.failureReason?.trim() || undefined;
+}
 export class CliDataAccess extends CliOperatorApiClient {
     config;
     db;
@@ -192,6 +209,39 @@ export class CliDataAccess extends CliOperatorApiClient {
         const updated = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
         return { issue: updated, runType, ...(options?.reason ? { reason: options.reason } : {}) };
     }
+    sessions(issueKey) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const dbIssue = this.db.getIssueByKey(issueKey);
+        const runs = this.db.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const sessions = runs
+            .slice()
+            .reverse()
+            .map((run) => {
+            const summary = summarizeRun(run);
+            return {
+                runId: run.id,
+                runType: run.runType,
+                status: run.status,
+                ...(run.threadId ? { threadId: run.threadId } : {}),
+                ...(run.turnId ? { turnId: run.turnId } : {}),
+                ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
+                ...(summary ? { summary } : {}),
+                ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                eventCount: this.db.listThreadEvents(run.id).length,
+                startedAt: run.startedAt,
+                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+                isCurrentThread: run.threadId !== undefined && run.threadId === dbIssue.threadId,
+            };
+        });
+        return {
+            issue,
+            ...(dbIssue.worktreePath ? { worktreePath: dbIssue.worktreePath } : {}),
+            ...(dbIssue.threadId ? { currentThreadId: dbIssue.threadId } : {}),
+            sessions,
+        };
+    }
     appendRetryWake(issue, runType) {
         if (runType === "queue_repair") {
             const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);

package/dist/cli/formatters/text.js

@@ -75,6 +75,51 @@ export function formatRetry(result) {
         .filter(Boolean)
         .join("\n")}\n`;
 }
+function formatTimestampRange(startedAt, endedAt) {
+    return endedAt ? `${startedAt} -> ${endedAt}` : `${startedAt} -> running`;
+}
+export function formatSessionHistory(result, buildOpenForThread) {
+    const lines = [
+        `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
+        value("Worktree", result.worktreePath),
+        value("Current thread", result.currentThreadId),
+    ];
+    if (result.sessions.length === 0) {
+        lines.push("No recorded app-server sessions.");
+        return `${lines.join("\n")}\n`;
+    }
+    for (const session of result.sessions) {
+        lines.push("");
+        lines.push([
+            `run #${session.runId}`,
+            session.runType,
+            session.status,
+            formatTimestampRange(session.startedAt, session.endedAt),
+            session.isCurrentThread ? "current" : undefined,
+        ]
+            .filter(Boolean)
+            .join("  "));
+        lines.push(value("Thread", session.threadId));
+        if (session.parentThreadId) {
+            lines.push(value("Parent thread", session.parentThreadId));
+        }
+        if (session.turnId) {
+            lines.push(value("Turn", session.turnId));
+        }
+        lines.push(value("Events", session.eventCount));
+        if (session.summary) {
+            lines.push(value("Summary", truncateLine(session.summary)));
+        }
+        else if (session.failureReason) {
+            lines.push(value("Failure", truncateLine(session.failureReason)));
+        }
+        if (session.threadId && result.worktreePath && buildOpenForThread) {
+            const command = buildOpenForThread(session.threadId);
+            lines.push(value("Open", formatCommand(command.command, command.args)));
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
 export function formatList(items) {
     return `${items
         .map((item) => [

package/dist/cli/help.js

@@ -36,6 +36,7 @@ export function rootHelpText() {
         "  issue show <issueKey> [--json]                          Show the latest known issue state",
         "  issue watch <issueKey> [--json]                         Follow the active run until it settles",
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
+        "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
         "  service status [--json]                                 Show systemd state and local health",
         "  service logs [--lines <count>] [--json]                 Show recent service logs",
         "  serve                                                   Run the local PatchRelay service",
@@ -93,6 +94,10 @@ export function linearHelpText() {
         "  patchrelay linear connect",
         "  patchrelay linear list",
         "  patchrelay linear sync usertold",
+        "",
+        "Compatibility aliases:",
+        "  patchrelay connect            Alias for `patchrelay linear connect`",
+        "  patchrelay installations      Alias for `patchrelay linear list`",
     ].join("\n");
 }
 export function repoHelpText() {
@@ -121,6 +126,11 @@ export function repoHelpText() {
         "  patchrelay repo link krasnoperov/usertold --workspace usertold --team USE",
         "  patchrelay repo show krasnoperov/usertold",
         "  patchrelay repo sync",
+        "",
+        "Compatibility aliases:",
+        "  patchrelay attach ...         Alias for `patchrelay repo link ...`",
+        "  patchrelay repos              Alias for `patchrelay repo list`",
+        "  patchrelay repos <repo>       Alias for `patchrelay repo show <repo>`",
     ].join("\n");
 }
 export function issueHelpText() {
@@ -134,12 +144,14 @@ export function issueHelpText() {
         "  watch <issueKey>                Follow PatchRelay-owned activity until it settles",
         "  path <issueKey>                 Print the issue worktree path",
         "  open <issueKey>                 Open Codex in the issue worktree",
+        "  sessions <issueKey>             Show recorded Codex app-server sessions",
         "  retry <issueKey>                Requeue a run",
         "",
         "Examples:",
         "  patchrelay issue list --active",
         "  patchrelay issue show USE-54",
         "  patchrelay issue watch USE-54",
+        "  patchrelay issue sessions USE-54",
     ].join("\n");
 }
 export function serviceHelpText() {

package/dist/cli/index.js

@@ -59,6 +59,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "open":
                     assertKnownFlags(parsed, "issue", ["print", "json"]);
                     return;
+                case "sessions":
+                    assertKnownFlags(parsed, "issue", ["json"]);
+                    return;
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;
@@ -106,12 +109,6 @@ function validateFlags(command, commandArgs, parsed) {
                     assertKnownFlags(parsed, "repo", []);
                     return;
             }
-        case "attach":
-        case "repos":
-        case "connect":
-        case "installations":
-            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"]);
@@ -314,10 +311,6 @@ export async function runCli(argv, options) {
                 runInteractive,
             });
         }
-        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 === "dashboard") {
             const { handleWatchCommand } = await import("./commands/watch.js");
             return await handleWatchCommand({ config, parsed });

package/dist/cli/watch/App.js

@@ -181,12 +181,32 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
                 dispatch({ type: "switch-detail-tab", tab: "timeline" });
             }
             else if (input === "j" || key.downArrow) {
-                dispatch({ type: "detail-navigate", direction: "next", filtered });
+                dispatch({ type: "detail-scroll", delta: 1 });
             }
             else if (input === "k" || key.upArrow) {
+                dispatch({ type: "detail-scroll", delta: -1 });
+            }
+            else if (key.pageDown || (key.ctrl && input === "d")) {
+                dispatch({ type: "detail-page", direction: "down" });
+            }
+            else if (key.pageUp || (key.ctrl && input === "u")) {
+                dispatch({ type: "detail-page", direction: "up" });
+            }
+            else if (key.home) {
+                dispatch({ type: "detail-jump", target: "start" });
+            }
+            else if (key.end) {
+                dispatch({ type: "detail-jump", target: "end" });
+            }
+            else if (input === "[" || key.leftArrow) {
                 dispatch({ type: "detail-navigate", direction: "prev", filtered });
             }
+            else if (input === "]" || key.rightArrow) {
+                dispatch({ type: "detail-navigate", direction: "next", filtered });
+            }
         }
     });
-    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, frozen: frozen })) : 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, 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 }))] })) : null }));
+    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, frozen: frozen })) : 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, scrollOffset: state.detailScrollOffset, unreadBelow: state.detailUnreadBelow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, reservedRows: 1 + ((promptMode || promptStatus) ? 1 : 0), onLayoutChange: (viewportRows, contentRows) => {
+                        dispatch({ type: "detail-layout-updated", viewportRows, contentRows });
+                    } }), 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 }))] })) : null }));
 }

package/dist/cli/watch/HelpBar.js

@@ -4,7 +4,7 @@ export function HelpBar({ view, follow, detailTab }) {
     let text;
     if (view === "detail") {
         const tabHint = detailTab === "history" ? "t: timeline" : "h: history";
-        text = [tabHint, `f: follow ${follow ? "on" : "off"}`, "p: prompt", "s: stop", "r: retry"]
+        text = [tabHint, "j/k: scroll", "PgUp/PgDn: page", "[ ]: issue", "Home/End: jump", `f: live ${follow ? "on" : "off"}`, "p: prompt", "s: stop", "r: retry"]
             .filter(Boolean)
             .join("  ");
     }

package/dist/cli/watch/IssueDetailView.js

@@ -1,169 +1,71 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useReducer } from "react";
-import { Box, Text } from "ink";
-import { Timeline } from "./Timeline.js";
-import { StateHistoryView } from "./StateHistoryView.js";
-import { buildStateHistory } from "./history-builder.js";
+import { Box, Text, useStdout } from "ink";
 import { HelpBar } from "./HelpBar.js";
-import { planStepSymbol, planStepColor } from "./plan-helpers.js";
-import { progressBar } from "./format-utils.js";
-import { FreshnessBadge } from "./FreshnessBadge.js";
-function formatTokens(n) {
-    if (n >= 1_000_000)
-        return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000)
-        return `${(n / 1_000).toFixed(1)}k`;
-    return String(n);
-}
-function formatReviewState(reviewState) {
-    switch (reviewState) {
-        case "approved":
-            return "approved";
-        case "changes_requested":
-            return "changes requested";
-        case "commented":
-            return "commented";
-        default:
-            return reviewState ? reviewState.replaceAll("_", " ") : null;
-    }
-}
-function formatCheckState(checkState) {
-    switch (checkState) {
-        case "passed":
-        case "success":
-            return "checks passed";
-        case "failed":
-        case "failure":
-            return "checks failed";
-        case "pending":
-        case "in_progress":
-        case "queued":
-            return "checks pending";
-        default:
-            return null;
-    }
-}
-const SESSION_DISPLAY = {
-    idle: { label: "idle", color: "blueBright" },
-    running: { label: "running", color: "cyan" },
-    waiting_input: { label: "needs input", color: "yellow" },
-    done: { label: "done", color: "green" },
-    failed: { label: "failed", color: "red" },
-};
-const STAGE_DISPLAY = {
-    blocked: "blocked",
-    ready: "ready",
-    delegated: "delegated",
-    implementing: "implementing",
-    pr_open: "PR open",
-    changes_requested: "review changes",
-    repairing_ci: "repairing CI",
-    awaiting_queue: "waiting downstream",
-    repairing_queue: "repairing queue",
-    done: "merged",
-    failed: "failed",
-    escalated: "escalated",
-    awaiting_input: "needs input",
-};
-function effectiveState(issue) {
-    if (issue.sessionState === "done")
-        return "done";
-    if (issue.sessionState === "failed")
-        return "failed";
-    if (issue.blockedByCount > 0 && !issue.activeRunType)
-        return "blocked";
-    if (issue.readyForExecution && !issue.activeRunType)
-        return "ready";
-    if (issue.sessionState === "waiting_input")
-        return "awaiting_input";
-    return issue.factoryState;
-}
-function sessionDisplay(issue) {
-    const state = issue.sessionState ?? "unknown";
-    return SESSION_DISPLAY[state] ?? { label: state, color: "white" };
-}
-function stageDisplay(issue) {
-    const state = effectiveState(issue);
-    return STAGE_DISPLAY[state] ?? issue.factoryState;
-}
-function blockerText(issue, issueContext) {
-    const rereviewNeeded = issue.prReviewState === "changes_requested"
-        && (issue.prCheckStatus === "passed" || issue.prCheckStatus === "success")
-        && !issue.activeRunType;
-    if (issue.sessionState === "waiting_input")
-        return issue.waitingReason ?? "Waiting for input";
-    if (issue.waitingReason && !issue.activeRunType)
-        return issue.waitingReason;
-    if (issue.blockedByCount > 0)
-        return `Waiting on ${issue.blockedByKeys.join(", ")}`;
-    if (effectiveState(issue) === "repairing_queue")
-        return "Merge queue conflict, repairing branch";
-    if (effectiveState(issue) === "repairing_ci") {
-        const check = issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName ?? "CI";
-        return `Repairing ${check}`;
-    }
-    if (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure") {
-        const check = issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName ?? "checks";
-        return `${check} failed`;
-    }
-    if (rereviewNeeded)
-        return "Awaiting re-review after requested changes";
-    if (issue.prReviewState === "changes_requested")
-        return "Review changes requested";
-    if (issue.prNumber !== undefined && !issue.prReviewState && effectiveState(issue) !== "done")
-        return "Awaiting review";
-    return null;
-}
-function ElapsedTime({ startedAt }) {
-    const [, tick] = useReducer((c) => c + 1, 0);
+import { buildDetailLines } from "./detail-rows.js";
+export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadBelow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, connected, lastServerMessageAt, reservedRows = 0, onLayoutChange, }) {
+    const [, tick] = useReducer((value) => value + 1, 0);
+    const { stdout } = useStdout();
+    const width = Math.max(20, stdout?.columns ?? 80);
+    const totalRows = stdout?.rows ?? 24;
+    const footerRows = 1 + (unreadBelow > 0 ? 1 : 0);
+    const viewportRows = Math.max(4, totalRows - reservedRows - footerRows);
     useEffect(() => {
-        const id = setInterval(tick, 1000);
+        const id = setInterval(tick, 1_000);
         return () => clearInterval(id);
     }, []);
-    const elapsed = Math.max(0, Math.floor((Date.now() - new Date(startedAt).getTime()) / 1000));
-    const minutes = Math.floor(elapsed / 60);
-    const seconds = elapsed % 60;
-    return _jsxs(Text, { dimColor: true, children: [minutes, "m ", String(seconds).padStart(2, "0"), "s"] });
+    const lines = useMemo(() => {
+        if (!issue) {
+            return [{ key: "loading", segments: [{ text: "Loading issue…", dimColor: true }] }];
+        }
+        return buildDetailLines({
+            issue,
+            timeline,
+            activeRunStartedAt,
+            activeRunId,
+            tokenUsage,
+            diffSummary,
+            plan,
+            issueContext,
+            detailTab,
+            rawRuns,
+            rawFeedEvents,
+            follow,
+            connected,
+            lastServerMessageAt,
+            width,
+        });
+    }, [
+        issue,
+        timeline,
+        activeRunStartedAt,
+        activeRunId,
+        tokenUsage,
+        diffSummary,
+        plan,
+        issueContext,
+        detailTab,
+        rawRuns,
+        rawFeedEvents,
+        follow,
+        connected,
+        lastServerMessageAt,
+        width,
+    ]);
+    useEffect(() => {
+        onLayoutChange(viewportRows, lines.length);
+    }, [lines.length, onLayoutChange, viewportRows]);
+    const maxOffset = Math.max(0, lines.length - viewportRows);
+    const start = Math.min(scrollOffset, maxOffset);
+    const visibleLines = lines.slice(start, start + viewportRows);
+    const fillerCount = Math.max(0, viewportRows - visibleLines.length);
+    return (_jsxs(Box, { flexDirection: "column", children: [visibleLines.map((line) => (_jsx(RenderedLine, { line: line }, line.key))), Array.from({ length: fillerCount }, (_, index) => (_jsx(Text, { children: " " }, `detail-fill-${index}`))), unreadBelow > 0 && (_jsx(Text, { color: "yellow", children: `${unreadBelow} below · End jumps back to live` })), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab })] }));
 }
-export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, connected, lastServerMessageAt, }) {
-    if (!issue) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Loading issue\u2026" }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab })] }));
-    }
-    const key = issue.issueKey ?? issue.projectId;
-    const meta = [];
-    if (tokenUsage)
-        meta.push(`${formatTokens(tokenUsage.inputTokens)} in / ${formatTokens(tokenUsage.outputTokens)} out`);
-    if (diffSummary && diffSummary.filesChanged > 0)
-        meta.push(`${diffSummary.filesChanged}f +${diffSummary.linesAdded} -${diffSummary.linesRemoved}`);
-    if (issueContext?.runCount)
-        meta.push(`${issueContext.runCount} runs`);
-    const session = sessionDisplay(issue);
-    const stage = stageDisplay(issue);
-    const blocker = blockerText(issue, issueContext);
-    const history = useMemo(() => buildStateHistory(rawRuns, rawFeedEvents, issue.factoryState, activeRunId), [rawRuns, rawFeedEvents, issue.factoryState, activeRunId]);
-    // Build compact facts for the header
-    const facts = [];
-    const rereviewNeeded = issue.prReviewState === "changes_requested"
-        && (issue.prCheckStatus === "passed" || issue.prCheckStatus === "success")
-        && !issue.activeRunType;
-    if (issue.prNumber !== undefined)
-        facts.push(`PR #${issue.prNumber}`);
-    if (issue.prReviewState === "approved")
-        facts.push("approved");
-    else if (rereviewNeeded)
-        facts.push("re-review needed");
-    else if (issue.prReviewState === "changes_requested")
-        facts.push("changes requested");
-    if (issue.waitingReason && issue.sessionState === "waiting_input")
-        facts.push(issue.waitingReason);
-    if (issue.prCheckStatus === "passed" || issue.prCheckStatus === "success")
-        facts.push("checks passed");
-    else if (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure") {
-        const check = issueContext?.latestFailureCheckName ?? issue.latestFailureCheckName ?? "checks";
-        facts.push(`${check} failed`);
-    }
-    else if (issue.prChecksSummary?.total) {
-        facts.push(`checks ${issue.prChecksSummary.completed}/${issue.prChecksSummary.total}`);
+function RenderedLine({ line }) {
+    if (line.segments.length === 0) {
+        return _jsx(Text, { children: " " });
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: session.color, children: session.label }), _jsx(Text, { dimColor: true, children: `  debug stage ${stage}` }), facts.length > 0 && _jsx(Text, { dimColor: true, children: facts.join(" \u00b7 ") }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), blocker && _jsx(Text, { color: "yellow", children: blocker }), issue.statusNote && issue.statusNote !== blocker && (_jsx(Text, { dimColor: true, wrap: "wrap", children: issue.statusNote })), issueContext?.latestFailureSummary && (_jsxs(Text, { color: issueContext.latestFailureSource === "queue_eviction" ? "yellow" : "red", children: ["Latest failure: ", issueContext.latestFailureSummary, issueContext.latestFailureHeadSha ? ` @ ${issueContext.latestFailureHeadSha.slice(0, 8)}` : ""] })), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), 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, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow }) })] })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "PatchRelay activity history." }), _jsx(Text, { dimColor: true, children: "Runs, waits, and wake-ups are shown here in PatchRelay order." })] }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab }) })] }));
+    return (_jsx(Text, { children: line.segments.map((segment, index) => (_jsx(Text
+        // eslint-disable-next-line react/no-array-index-key
+        , { ...(segment.color ? { color: segment.color } : {}), ...(segment.dimColor ? { dimColor: true } : {}), ...(segment.bold ? { bold: true } : {}), children: segment.text }, `${line.key}-${index}`))) }));
 }

package/dist/cli/watch/IssueRow.js

@@ -4,6 +4,9 @@ import { summarizeIssueStatusNote } from "./issue-status-note.js";
 import { relativeTime, truncate } from "./format-utils.js";
 // ─── State display ──────────────────────────────────────────────
 const TERMINAL_STATES = new Set(["done", "failed", "escalated"]);
+function needsOperatorIntervention(issue) {
+    return issue.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated";
+}
 function effectiveState(issue) {
     if (issue.sessionState === "done")
         return "done";
@@ -18,6 +21,9 @@ function effectiveState(issue) {
     return issue.factoryState;
 }
 function sessionDisplay(issue) {
+    if (needsOperatorIntervention(issue)) {
+        return { label: "needs help", color: "red" };
+    }
     switch (issue.sessionState) {
         case "running":
             return { label: "running", color: "cyan" };
@@ -71,6 +77,9 @@ function buildFacts(issue, selected) {
     if (issue.waitingReason && issue.sessionState === "waiting_input") {
         facts.push({ text: issue.waitingReason, color: "yellow" });
     }
+    if (needsOperatorIntervention(issue)) {
+        facts.push({ text: "operator action needed", color: "red" });
+    }
     // Review state — only show when it matters (not yet approved, or changes requested)
     if (issue.prReviewState === "approved") {
         facts.push({ text: "approved", color: "green" });
@@ -116,6 +125,8 @@ function blockerText(issue) {
         && !issue.activeRunType;
     if (issue.sessionState === "waiting_input")
         return issue.waitingReason ?? "Waiting for input";
+    if (needsOperatorIntervention(issue))
+        return issue.statusNote ?? issue.waitingReason ?? "Needs operator intervention";
     if (issue.waitingReason && !issue.activeRunType)
         return issue.waitingReason;
     if (issue.blockedByCount > 0)

package/dist/cli/watch/StatusBar.js

@@ -13,7 +13,8 @@ export function StatusBar({ issues, totalCount, filter, connected, lastServerMes
     const agg = computeAggregates(aggregateSource);
     const withPr = aggregateSource.filter((i) => i.prNumber !== undefined).length;
     const waitingInput = aggregateSource.filter((i) => i.sessionState === "waiting_input" || i.factoryState === "awaiting_input").length;
+    const intervention = aggregateSource.filter((i) => i.sessionState === "failed" || i.factoryState === "failed" || i.factoryState === "escalated").length;
     const running = aggregateSource.filter((i) => i.sessionState === "running").length;
     const idle = aggregateSource.filter((i) => i.sessionState === "idle").length;
-    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter], "]"] }), _jsx(Text, { dimColor: true, children: "|" }), running > 0 && _jsxs(Text, { color: "cyan", children: [running, " running"] }), idle > 0 && _jsxs(Text, { color: "blueBright", children: [idle, " idle"] }), agg.ready > 0 && _jsxs(Text, { color: "blueBright", children: [agg.ready, " ready"] }), agg.blocked > 0 && _jsxs(Text, { color: "yellow", children: [agg.blocked, " blocked"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), waitingInput > 0 && _jsxs(Text, { color: "yellow", children: [waitingInput, " needs input"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] }), frozen && _jsx(Text, { color: "magenta", children: "frozen" })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter], "]"] }), _jsx(Text, { dimColor: true, children: "|" }), running > 0 && _jsxs(Text, { color: "cyan", children: [running, " running"] }), idle > 0 && _jsxs(Text, { color: "blueBright", children: [idle, " idle"] }), agg.ready > 0 && _jsxs(Text, { color: "blueBright", children: [agg.ready, " ready"] }), agg.blocked > 0 && _jsxs(Text, { color: "yellow", children: [agg.blocked, " blocked"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), waitingInput > 0 && _jsxs(Text, { color: "yellow", children: [waitingInput, " needs input"] }), intervention > 0 && _jsxs(Text, { color: "red", children: [intervention, " needs help"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] }), frozen && _jsx(Text, { color: "magenta", children: "frozen" })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
 }