patchrelay 0.36.19 → 0.37.1

package/dist/github-webhook-handler.js

@@ -1,4 +1,4 @@
-import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
 import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, summarizeGitHubFailureContext, } from "./github-failure-context.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
@@ -7,6 +7,7 @@ import { buildGitHubStateActivity } from "./linear-session-reporting.js";
 import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
 import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { buildClosedPrCleanupFields, isIssueTerminal, resolveClosedPrFactoryState, resolveClosedPrDisposition, } from "./pr-state.js";
 import { resolveSecret } from "./resolve-secret.js";
 import { safeJsonParse } from "./utils.js";
 /**
@@ -153,6 +154,9 @@ export class GitHubWebhookHandler {
                 : event.reviewState === "approved"
                     ? { lastBlockingReviewHeadSha: null }
                     : {}),
+            ...(event.triggerEvent === "pr_closed"
+                ? buildClosedPrCleanupFields()
+                : {}),
         });
         await this.updateCiSnapshot(issue, event, project);
         await this.updateFailureProvenance(issue, event, project);
@@ -227,11 +231,14 @@ export class GitHubWebhookHandler {
         }
     }
     resolveFactoryStateForEvent(issue, event, project) {
+        if (event.triggerEvent === "pr_closed") {
+            return undefined;
+        }
         if (event.triggerEvent === "check_failed"
             && this.isQueueEvictionFailure(issue, event, project)
             && issue.prState === "open"
             && issue.activeRunId === undefined
-            && !TERMINAL_STATES.has(issue.factoryState)) {
+            && !isIssueTerminal(issue)) {
             return "repairing_queue";
         }
         return resolveFactoryStateFromGitHub(event.triggerEvent, issue.factoryState, {
@@ -318,7 +325,7 @@ export class GitHubWebhookHandler {
             return;
         // Don't trigger on terminal issues — late-arriving webhooks (e.g.
         // merge_group_failed after pr_merged) must not resurrect done issues.
-        if (TERMINAL_STATES.has(issue.factoryState))
+        if (isIssueTerminal(issue))
             return;
         if (!this.isPatchRelayOwnedPr(issue)) {
             this.feed?.publish({
@@ -521,11 +528,14 @@ export class GitHubWebhookHandler {
                         : "Pull request closed during active run",
                 });
             }
+            const terminalFactoryState = event.triggerEvent === "pr_merged"
+                ? "done"
+                : resolveClosedPrFactoryState(issue);
             this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 activeRunId: null,
-                factoryState: event.triggerEvent === "pr_merged" ? "done" : "failed",
+                factoryState: terminalFactoryState,
             });
         };
         const activeLease = this.db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
@@ -537,6 +547,18 @@ export class GitHubWebhookHandler {
         }
         this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
         const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "delegated",
+                dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
+            });
+            this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
+            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
         }

package/dist/idle-reconciliation.js

@@ -1,8 +1,10 @@
+import {} from "./factory-state.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { execCommand } from "./utils.js";
 const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
@@ -439,8 +441,23 @@ export class IdleIssueReconciler {
                 return;
             }
             if (pr.state === "CLOSED") {
-                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed, re-delegating for implementation");
-                this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "closed" });
+                const closedPrDisposition = resolveClosedPrDisposition(issue);
+                this.db.issues.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    prState: "closed",
+                    ...buildClosedPrCleanupFields(),
+                });
+                if (closedPrDisposition === "done") {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed for an already completed issue; preserving done state");
+                    this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                    return;
+                }
+                if (closedPrDisposition === "terminal") {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, factoryState: issue.factoryState }, "Reconciliation: PR was closed on a terminal issue; preserving terminal state");
+                    return;
+                }
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed on unfinished work, re-delegating for implementation");
                 this.advanceIdleIssue(issue, "delegated", {
                     pendingRunType: "implementation",
                     clearFailureProvenance: true,

package/dist/implementation-outcome-policy.js

@@ -46,7 +46,9 @@ export class ImplementationOutcomePolicy {
                             ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
                             ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
                         }, "published PR verification refresh");
-                        return undefined;
+                        if (pr.state?.toLowerCase() !== "closed") {
+                            return undefined;
+                        }
                     }
                 }
             }

package/dist/issue-overview-query.js

@@ -143,6 +143,7 @@ export class IssueOverviewQuery {
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
             prNumber: session.prNumber,
+            prState: issueRecord?.prState,
             prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
             prReviewState: issueRecord?.prReviewState,
             prCheckStatus: issueRecord?.prCheckStatus,
@@ -159,6 +160,10 @@ export class IssueOverviewQuery {
             ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
             sessionState: session.sessionState,
             factoryState: issueRecord?.factoryState ?? "delegated",
+            ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
+            ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+            ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+            ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
             blockedByCount: unresolvedBlockedBy.length,
             blockedByKeys,
             readyForExecution: isIssueSessionReadyForExecution({

package/dist/linear-session-reporting.js

@@ -1,5 +1,6 @@
 import { formatRunTypeLabel } from "./agent-session-plan.js";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
+import { isClosedPrState } from "./pr-state.js";
 function lowerRunTypeLabel(runType) {
     return formatRunTypeLabel(runType).toLowerCase();
 }
@@ -188,15 +189,19 @@ export function buildMergePrepEscalationActivity(attempts) {
 export function summarizeIssueStateForLinear(issue) {
     switch (issue.sessionState) {
         case "waiting_input":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
         case "running":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is actively running.` : "Actively running.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is actively running.` : "Actively running.");
         case "idle":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is idle.` : "Idle.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is idle.` : "Idle.");
         case "done":
-            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+            if (issue.prNumber && issue.prState === "merged")
+                return `PR #${issue.prNumber} has merged.`;
+            if (issue.prNumber && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}.`;
+            return issue.prNumber ? `Completed with PR #${issue.prNumber}.` : "Completed.";
         case "failed":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
     }
     switch (issue.factoryState) {
         case "pr_open":
@@ -204,7 +209,11 @@ export function summarizeIssueStateForLinear(issue) {
         case "awaiting_queue":
             return issue.prNumber ? `PR #${issue.prNumber} is approved and awaiting merge.` : "Approved and awaiting merge.";
         case "done":
-            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+            if (issue.prNumber && issue.prState === "merged")
+                return `PR #${issue.prNumber} has merged.`;
+            if (issue.prNumber && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}.`;
+            return issue.prNumber ? `Completed with PR #${issue.prNumber}.` : "Completed.";
         default:
             return undefined;
     }

package/dist/linear-status-comment-sync.js

@@ -1,6 +1,7 @@
 import { extractCompletionCheck } from "./completion-check.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { isClosedPrState } from "./pr-state.js";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -31,7 +32,9 @@ export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
         || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return true;
     }
-    if ((issue.sessionState === "done" || issue.factoryState === "done") && issue.prNumber === undefined && !issue.prUrl) {
+    if ((issue.sessionState === "done" || issue.factoryState === "done")
+        && ((issue.prNumber === undefined && !issue.prUrl)
+            || isClosedPrState(issue.prState))) {
         return true;
     }
     return false;
@@ -49,6 +52,7 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         factoryState: issue.factoryState,
         pendingRunType: issue.pendingRunType,
         ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+        ...(issue.prState ? { prState: issue.prState } : {}),
         prHeadSha: issue.prHeadSha,
         prReviewState: issue.prReviewState,
         prCheckStatus: issue.prCheckStatus,
@@ -110,6 +114,10 @@ function statusHeadline(issue, activeRunType) {
         case "running":
             return issue.prNumber !== undefined ? `PR #${issue.prNumber} is actively running` : "Actively running";
         case "done":
+            if (issue.prNumber !== undefined && issue.prState === "merged")
+                return `Completed with merged PR #${issue.prNumber}`;
+            if (issue.prNumber !== undefined && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}`;
             return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
         case "failed":
             return "Needs operator intervention";
@@ -138,6 +146,10 @@ function statusHeadline(issue, activeRunType) {
         case "escalated":
             return "Needs operator intervention";
         case "done":
+            if (issue.prNumber !== undefined && issue.prState === "merged")
+                return `Completed with merged PR #${issue.prNumber}`;
+            if (issue.prNumber !== undefined && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}`;
             return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
         default:
             return humanize(issue.factoryState);

package/dist/pr-state.js

@@ -0,0 +1,49 @@
+import { TERMINAL_STATES } from "./factory-state.js";
+export function isOpenPrState(prState) {
+    return prState === undefined || prState === "open";
+}
+export function hasOpenPr(prNumber, prState) {
+    // Transitional compatibility: older rows may still have a tracked PR number
+    // before webhook/reconciliation has populated pr_state.
+    return prNumber !== undefined && isOpenPrState(prState);
+}
+export function isClosedPrState(prState) {
+    return prState === "closed";
+}
+export function isCompletedLinearState(currentLinearStateType, currentLinearState) {
+    return currentLinearStateType === "completed"
+        || currentLinearState?.trim().toLowerCase() === "done";
+}
+export function isIssueCompleted(issue) {
+    return issue.factoryState === "done" || isCompletedLinearState(issue.currentLinearStateType, issue.currentLinearState);
+}
+export function isIssueTerminal(issue) {
+    return issue.factoryState !== undefined && TERMINAL_STATES.has(issue.factoryState);
+}
+export function resolveClosedPrDisposition(issue) {
+    if (isIssueCompleted(issue))
+        return "done";
+    if (isIssueTerminal(issue))
+        return "terminal";
+    return "redelegate";
+}
+export function resolveClosedPrFactoryState(issue) {
+    const disposition = resolveClosedPrDisposition(issue);
+    if (disposition === "done")
+        return "done";
+    if (disposition === "terminal")
+        return issue.factoryState;
+    return "delegated";
+}
+export function buildClosedPrCleanupFields() {
+    return {
+        prReviewState: null,
+        prCheckStatus: null,
+        lastBlockingReviewHeadSha: null,
+        lastGitHubCiSnapshotHeadSha: null,
+        lastGitHubCiSnapshotGateCheckName: null,
+        lastGitHubCiSnapshotGateCheckStatus: null,
+        lastGitHubCiSnapshotJson: null,
+        lastGitHubCiSnapshotSettledAt: null,
+    };
+}

package/dist/service-issue-actions.js

@@ -1,4 +1,5 @@
 import { buildOperatorRetryEvent } from "./operator-retry-event.js";
+import { hasOpenPr } from "./pr-state.js";
 export class ServiceIssueActions {
     db;
     codex;
@@ -107,21 +108,21 @@ export class ServiceIssueActions {
         }
         let runType = "implementation";
         let factoryState = "delegated";
-        if (issue.prNumber && issue.lastGitHubFailureSource === "queue_eviction") {
+        if (hasOpenPr(issue.prNumber, issue.prState) && issue.lastGitHubFailureSource === "queue_eviction") {
             runType = "queue_repair";
             factoryState = "repairing_queue";
         }
-        else if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
+        else if (hasOpenPr(issue.prNumber, issue.prState) && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
             runType = "ci_repair";
             factoryState = "repairing_ci";
         }
-        else if (issue.prNumber && issue.prReviewState === "changes_requested") {
+        else if (hasOpenPr(issue.prNumber, issue.prState) && issue.prReviewState === "changes_requested") {
             runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
                 ? "branch_upkeep"
                 : "review_fix";
             factoryState = "changes_requested";
         }
-        else if (issue.prNumber) {
+        else if (hasOpenPr(issue.prNumber, issue.prState)) {
             runType = "implementation";
             factoryState = "implementing";
         }

package/dist/tracked-issue-list-query.js

@@ -82,7 +82,7 @@ export class TrackedIssueListQuery {
           s.project_id, s.linear_issue_id, s.issue_key, i.title,
           i.current_linear_state, i.factory_state, s.session_state, s.waiting_reason, s.summary_text, s.updated_at,
           i.pending_run_type,
-          i.pr_number, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
+          i.pr_number, i.pr_state, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
           i.last_github_ci_snapshot_json,
           i.last_github_failure_source,
           i.last_github_failure_head_sha,
@@ -180,6 +180,7 @@ export class TrackedIssueListQuery {
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_head_sha !== null ? { prHeadSha: String(row.pr_head_sha) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
@@ -242,6 +243,7 @@ export class TrackedIssueListQuery {
                 ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
                 ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
                 ...(prChecksSummary ? { prChecksSummary } : {}),

package/dist/tracked-issue-projector.js

@@ -15,6 +15,7 @@ export function buildTrackedIssueRecord(params) {
         factoryState: params.issue.factoryState,
         pendingRunType: params.issue.pendingRunType,
         prNumber: params.issue.prNumber,
+        prState: params.issue.prState,
         prHeadSha: params.issue.prHeadSha,
         prReviewState: params.issue.prReviewState,
         prCheckStatus: params.issue.prCheckStatus,
@@ -46,6 +47,10 @@ export function buildTrackedIssueRecord(params) {
         ...(params.issue.currentLinearState ? { currentLinearState: params.issue.currentLinearState } : {}),
         ...(params.session?.sessionState ? { sessionState: params.session.sessionState } : {}),
         factoryState: params.issue.factoryState,
+        ...(params.issue.prNumber !== undefined ? { prNumber: params.issue.prNumber } : {}),
+        ...(params.issue.prState ? { prState: params.issue.prState } : {}),
+        ...(params.issue.prReviewState ? { prReviewState: params.issue.prReviewState } : {}),
+        ...(params.issue.prCheckStatus ? { prCheckStatus: params.issue.prCheckStatus } : {}),
         blockedByCount: unresolvedBlockedBy.length,
         blockedByKeys,
         readyForExecution: isIssueSessionReadyForExecution({

package/dist/waiting-reason.js

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "./pr-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
     finalizingPublishedPr: "PatchRelay is finalizing a published PR",
@@ -14,7 +15,7 @@ export const PATCHRELAY_WAITING_REASONS = {
 };
 export function derivePatchRelayWaitingReason(params) {
     if (params.activeRunType) {
-        if (params.prNumber !== undefined && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
+        if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
             return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
         }
         if (params.factoryState === "done") {
@@ -66,7 +67,7 @@ export function derivePatchRelayWaitingReason(params) {
     if (params.prReviewState === "approved") {
         return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
     }
-    if (params.prNumber !== undefined) {
+    if (hasOpenPr(params.prNumber, params.prState)) {
         return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
     }
     if (params.pendingRunType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.36.19",
+  "version": "0.37.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/dist/cli/watch/ItemLine.js

@@ -1,80 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-function cleanCommand(raw) {
-    const bashMatch = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+['"](.+?)['"]$/s);
-    if (bashMatch?.[1])
-        return bashMatch[1];
-    const bashMatch2 = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+"(.+?)"$/s);
-    if (bashMatch2?.[1])
-        return bashMatch2[1];
-    return raw;
-}
-function summarizeFileChange(item) {
-    const count = item.changes?.length ?? 0;
-    return `updated ${count} file${count === 1 ? "" : "s"}`;
-}
-function summarizeToolCall(item) {
-    return `used ${item.toolName ?? item.type}`;
-}
-function summarizeText(item) {
-    return (item.text ?? "").replace(/\s+/g, " ").trim();
-}
-function itemPrefix(item) {
-    if (item.type === "commandExecution")
-        return "$ ";
-    return "";
-}
-function formatItemDuration(ms) {
-    if (ms === undefined || ms === null)
-        return "";
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 1)
-        return "";
-    if (seconds < 60)
-        return `  ${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    return `  ${minutes}m`;
-}
-function itemText(item) {
-    switch (item.type) {
-        case "agentMessage":
-        case "plan":
-        case "reasoning":
-            return summarizeText(item);
-        case "commandExecution": {
-            const cmd = cleanCommand(item.command ?? "?");
-            const exit = item.exitCode !== undefined && item.exitCode !== null && item.exitCode !== 0
-                ? `  exit ${item.exitCode}` : "";
-            const dur = formatItemDuration(item.durationMs);
-            return `${cmd}${exit}${dur}`;
-        }
-        case "fileChange":
-            return summarizeFileChange(item);
-        case "mcpToolCall":
-        case "dynamicToolCall": {
-            const dur = formatItemDuration(item.durationMs);
-            return `${summarizeToolCall(item)}${dur}`;
-        }
-        case "userMessage":
-            return `you: ${summarizeText(item)}`;
-        default:
-            return item.text ? summarizeText(item) : item.type;
-    }
-}
-function itemColor(item) {
-    if (item.status === "failed" || item.status === "declined")
-        return "red";
-    if (item.status === "inProgress")
-        return "yellow";
-    if (item.type === "userMessage")
-        return "yellow";
-    return undefined;
-}
-export function ItemLine({ item }) {
-    const text = itemText(item);
-    if (!text) {
-        return _jsx(_Fragment, {});
-    }
-    const color = itemColor(item);
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { wrap: "wrap", bold: item.type === "agentMessage", ...(color ? { color } : {}), children: [itemPrefix(item), text] }), item.output && item.status === "inProgress" && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: item.output.split("\n").filter(Boolean).at(-1) ?? "" }) }))] }));
-}

package/dist/cli/watch/Timeline.js

@@ -1,22 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { Box, Static, Text, useStdout } from "ink";
-import { buildTimelineRows } from "./timeline-presentation.js";
-import { TimelineRow } from "./TimelineRow.js";
-const ACTIVE_TAIL = 8;
-export function Timeline({ entries, follow }) {
-    const { stdout } = useStdout();
-    const rows = stdout?.rows ?? 24;
-    const maxActive = Math.max(ACTIVE_TAIL, rows - 12);
-    const displayRows = useMemo(() => buildTimelineRows(entries), [entries]);
-    // Always cap the rendered entries to prevent OOM/WASM crashes.
-    // In follow mode: older entries go to Static (terminal scrollback).
-    // Without follow: show last maxActive entries only.
-    const splitIndex = Math.max(0, displayRows.length - maxActive);
-    const finalized = follow ? displayRows.slice(0, splitIndex) : [];
-    const active = displayRows.slice(splitIndex);
-    if (displayRows.length === 0) {
-        return _jsx(Text, { dimColor: true, children: "No timeline events yet." });
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [finalized.length > 0 && (_jsx(Static, { items: finalized, children: (entry) => _jsx(TimelineRow, { entry: entry }, entry.id) })), active.map((entry) => (_jsx(TimelineRow, { entry: entry }, entry.id)))] }));
-}

package/dist/cli/watch/TimelineRow.js

@@ -1,77 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { ItemLine } from "./ItemLine.js";
-function formatDuration(startedAt, endedAt) {
-    const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    const s = seconds % 60;
-    return `${minutes}m ${String(s).padStart(2, "0")}s`;
-}
-const CHECK_SYMBOLS = { passed: "\u2713", failed: "\u2717", pending: "\u25cf" };
-const CHECK_COLORS = { passed: "green", failed: "red", pending: "yellow" };
-const RUN_LABELS = {
-    implementation: "implement",
-    ci_repair: "ci fix",
-    review_fix: "review fix",
-    branch_upkeep: "branch upkeep",
-    queue_repair: "merge fix",
-};
-function runDotColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "failed")
-        return "red";
-    if (status === "released")
-        return "magenta";
-    if (status === "running")
-        return "yellow";
-    return "white";
-}
-function detailColor(detail) {
-    if (detail.tone === "command")
-        return "white";
-    if (detail.tone === "user")
-        return "yellow";
-    return undefined;
-}
-function detailPrefix(detail) {
-    if (detail.tone === "command")
-        return "$ ";
-    return "";
-}
-function FeedRow({ entry }) {
-    const label = entry.feed.status ?? entry.feed.feedKind;
-    const repeatSuffix = entry.repeatCount && entry.repeatCount > 1 ? ` \u00d7${entry.repeatCount}` : "";
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u25cf" }), _jsx(Text, { color: "cyan", children: ` ${label}` }), _jsx(Text, { dimColor: true, children: `  ${entry.feed.summary}${repeatSuffix}` })] }));
-}
-function RunRow({ entry, }) {
-    const run = entry.run;
-    const dotColor = runDotColor(run.status);
-    const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : undefined;
-    const showItems = entry.items.length > 0;
-    const showDetails = !showItems && entry.details.length > 0;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: dotColor, children: "\u25cf" }), _jsx(Text, { bold: true, color: "yellow", children: ` ${RUN_LABELS[run.runType] ?? run.runType}` }), _jsx(Text, { bold: true, color: dotColor, children: `  ${run.status}` }), duration ? _jsx(Text, { dimColor: true, children: `  ${duration}` }) : null] }), showItems && entry.items.map((itemEntry, index) => (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: itemEntry.item }) }, `${entry.id}-item-${index}`))), showDetails && entry.details.map((detail, index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { wrap: "wrap", ...(detailColor(detail) ? { color: detailColor(detail) } : { dimColor: true }), bold: detail.tone === "message", children: [detailPrefix(detail), detail.text] }) }, `${entry.id}-detail-${index}`)))] }));
-}
-function ItemRow({ entry, }) {
-    return (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: entry.item }) }));
-}
-function CIChecksRow({ entry }) {
-    const ci = entry.ciChecks;
-    const dotColor = CHECK_COLORS[ci.overall] ?? "white";
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: dotColor, children: "\u25cf" }), _jsx(Text, { color: dotColor, bold: true, children: ` checks` }), _jsx(Text, { children: `  ` }), ci.checks.map((check, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { children: `  ` }) : null, _jsx(Text, { color: CHECK_COLORS[check.status] ?? "white", children: CHECK_SYMBOLS[check.status] ?? " " }), _jsx(Text, { dimColor: true, children: ` ${check.name}` })] }, `c-${i}`)))] }));
-}
-export function TimelineRow({ entry }) {
-    switch (entry.kind) {
-        case "feed":
-            return _jsx(FeedRow, { entry: entry });
-        case "run":
-            return _jsx(RunRow, { entry: entry });
-        case "item":
-            return _jsx(ItemRow, { entry: entry });
-        case "ci-checks":
-            return _jsx(CIChecksRow, { entry: entry });
-    }
-}