@visual-z/xeno 0.8.2 → 0.8.4

package/src/apps/ui/app.ts

@@ -37,6 +37,8 @@ import { DEFAULT_FULLSCREEN_EXIT_OUTPUT, resumeCommand, sessionExitStatus } from
 import { lastAssistantText } from "../../core/export.ts";
 import type { PermissionRequest } from "../../core/permissions.ts";
 import type { ApprovalChoice } from "../../runtime/tools.ts";
+import { formatExternalEffects, type ExternalEffect } from "../../core/external-effects.ts";
+import { hostExternalOptions } from "../../runtime/turn-effects.ts";
 import { attachImageBytes, attachImageFile } from "../../runtime/images.ts";
 import { readClipboard, writeClipboard, type ClipboardContent } from "../../runtime/clipboard.ts";
 import { highlightCode, transformMermaid, warmSyntaxLanguages } from "../../runtime/rich-text.ts";
@@ -49,12 +51,14 @@ import { updateNotice } from "../../core/update-check.ts";
 import { assertNever } from "../../core/exhaustive.ts";
 import { isUpgrade } from "../../core/version.ts";
 import type { Effort } from "../../runtime/model.ts";
-import { readNode, readCursor, setSessionLabel } from "../../store/log.ts";
+import { readNode, readCursor, setSessionLabel, forkedAt } from "../../store/log.ts";
 import { readNodeHistory } from "../../store/restore.ts";
+import { branchPanelLines, type BranchRow, type BranchRowState } from "../../tui/ui/branch-panel.ts";
+import type { ExecutionOutcome as BranchOutcome } from "../../core/outcome.ts";
 import { sessionsDir } from "../../store/sessions.ts";
 import { readGitStatus } from "../../store/git-status.ts";
 import type { GitStatus } from "../../core/git-status.ts";
-import { activityStatus } from "../../core/activity-status.ts";
+import { activityStatus, retryLine, type RetryFacts } from "../../core/activity-status.ts";
 import { goalStatus } from "../../core/goal-view.ts";
 import { generationSpeed } from "../../runtime/usage.ts";
 import { executionOutcome, type ExecutionOutcome } from "../../core/outcome.ts";
@@ -125,6 +129,21 @@ function endpointHost(baseUrl: string | undefined): string | null {
   try { return baseUrl ? new URL(baseUrl).host : null; } catch { return null; }
 }
 
+/** Parent commits that change which branches exist or how they ended. */
+const BRANCH_LIFECYCLE = new Set(["spawn", "joined", "adopt", "discard"]);
+/** A joined branch's row: the outcome it joined with; absence stays unknown, never success. */
+function rowState(outcome: BranchOutcome | undefined): BranchRowState {
+  if (!outcome) return "unknown";
+  switch (outcome.status) {
+    case "completed": return "done";
+    case "cancelled": return "cancelled";
+    case "stopped": return "stopped";
+    case "failed": return "failed";
+    case "unknown": return "unknown";
+    default: return assertNever(outcome.status, "branch row outcome");
+  }
+}
+
 export class InteractiveApp implements Ui {
   readonly app: App;
   readonly screen: Screen;
@@ -149,13 +168,22 @@ export class InteractiveApp implements Ui {
   private readonly work = new Set<Promise<void>>();
   private sessionTransition = false;
   private transcriptItems: TranscriptItem[] = [];
+  /** Unresolved branches as rows under the box (feat-branch-panel); resolving one (D16) removes its row. */
+  private branchRows: BranchRow[] = [];
+  /** The focused branch row, or undefined while the prompt has focus. */
+  private branchFocus: number | undefined;
+  /** Rows cleared with x: this view only, the log keeps the branch. */
+  private readonly clearedBranches = new Set<number>();
+  /** The branch the transcript shows instead of the main session, and its own items. */
+  private viewing: { node: number; purpose: string } | undefined;
+  private branchItems: TranscriptItem[] = [];
   private ancestors: LogEvent[] = [];
   private historyDir = "";
   private historyNode = -1;
   private historyLength = -1;
   private notices: Notice[] = [];
   private noticeSerial = 0;
-  private live: { thinking: string; text: string; tools: Map<string, { name: string; arguments: string }>; output: string; bash: string | null; retryUntil: number; retryAttempt: number } = emptyLive();
+  private live: { thinking: string; text: string; tools: Map<string, { name: string; arguments: string }>; output: string; bash: string | null; retryUntil: number; retry: RetryFacts | null } = emptyLive();
   private retryTimer: ReturnType<typeof setInterval> | undefined;
   private bashDecoder = new TextDecoder();
   private branch: string | null;
@@ -194,6 +222,8 @@ export class InteractiveApp implements Ui {
   private files: ReturnType<typeof fileChanges> = [];
   private prompt: string | null = null;
   private startedAt: string | undefined;
+  /** Set for a forked session: its clock starts at the fork, not at the copied parent history (fix-fork-start-time). */
+  private forkedAt: string | null = null;
   private budgetKey = "";
   private budgetCache: ContextBudget | undefined;
   /** An extension's own terminal title wins over ours; ours is written only when it changes. */
@@ -450,6 +480,64 @@ export class InteractiveApp implements Ui {
     return { width: this.renderer.width, height: this.renderer.height, lines: text.split("\n") };
   }
 
+  // ---------------------------------------------------------------- branches
+  /** Rows from the handoff's branch records (D16); running state comes from the owned handles. */
+  private async refreshBranches(): Promise<void> {
+    const session = this.app.session;
+    let statuses: Awaited<ReturnType<typeof session.branchStatuses>>;
+    try { statuses = await session.branchStatuses(); } catch { return; }
+    if (this.app.session !== session) return;
+    const running = new Set(session.runningBranches);
+    this.branchRows = statuses.filter(item => item.resolution === null && !this.clearedBranches.has(item.node))
+      // The log's join wins over a handle: a user branch's job is still settling when it records its own join.
+      .map(item => ({ node: item.node, purpose: item.purpose,
+        state: item.handoff_ref ? rowState(item.outcome) : running.has(item.node) || item.status === "running" || item.status === "ready" ? "running" : "unknown" }));
+    if (this.branchFocus !== undefined) this.branchFocus = this.branchRows.length ? Math.min(this.branchFocus, this.branchRows.length - 1) : undefined;
+    this.paintBranches();
+  }
+  private paintBranches(): void { this.screen.setBranches(branchPanelLines(this.branchRows, this.branchFocus)); }
+  /** Keys while a row is focused. Undefined hands the key on: typing never gets swallowed by the panel. */
+  private branchKey(key: KeyPress): boolean | undefined {
+    const b = this.keymap().byAction, at = this.branchFocus!, row = this.branchRows[at];
+    if (!row) { this.branchFocus = undefined; this.paintBranches(); return undefined; }
+    if (bound(b, "list.up", key)) { this.branchFocus = at > 0 ? at - 1 : undefined; this.paintBranches(); return true; }
+    if (bound(b, "list.down", key)) { this.branchFocus = Math.min(this.branchRows.length - 1, at + 1); this.paintBranches(); return true; }
+    if (bound(b, "list.confirm", key)) { this.branchFocus = undefined; this.paintBranches(); this.openBranchView(row); return true; }
+    if (bound(b, "list.cancel", key)) { this.branchFocus = undefined; this.paintBranches(); return true; }
+    if (key.chord === "x") { this.stopOrClearBranch(row); return true; }
+    this.branchFocus = undefined; this.paintBranches(); return undefined;
+  }
+  private stopOrClearBranch(row: BranchRow): void {
+    const session = this.app.session;
+    if (row.state !== "running") { this.clearedBranches.add(row.node); this.track(() => this.refreshBranches()); return; }
+    if (session.userBranches.includes(row.node)) { session.cancelUserBranch(row.node); return; }
+    // A model's background branch: the same coordinator the /branches command uses, which needs an idle parent.
+    if (this.inflight) { this.toast("the turn owns this branch; esc interrupts it", "warning"); return; }
+    this.track(async () => { await session.resolveBranch(row.node, "cancel"); await this.refreshBranches(); });
+  }
+  private openBranchView(row: BranchRow): void {
+    this.viewing = { node: row.node, purpose: row.purpose }; this.branchItems = [];
+    this.screen.setViewing(`branch ${row.node} · ${row.purpose}`);
+    this.screen.messages.scrollToBottom();
+    this.track(() => this.syncBranchView());
+  }
+  private closeBranchView(): void {
+    this.viewing = undefined; this.branchItems = [];
+    this.screen.setViewing(undefined);
+    this.screen.messages.scrollToBottom();
+    this.paint();
+  }
+  /** The branch node's own events (basis none: no parent replay), projected like the main transcript. */
+  private async syncBranchView(): Promise<void> {
+    const viewing = this.viewing;
+    if (!viewing) return;
+    const history = await readNodeHistory(this.app.logDir, viewing.node, undefined, "context");
+    if (this.viewing !== viewing) return;
+    if (!history.ok) { this.notice(`Cannot load branch ${viewing.node}: ${history.error}`, "error"); return; }
+    this.branchItems = projectTranscript(history.nodes.flatMap(part => part.events), new Set(this.app.extensions?.entryRenderers.keys()));
+    this.paint();
+  }
+
   // --------------------------------------------------------------- transcript
   async syncTranscript(): Promise<void> {
     this.bindControl();
@@ -464,6 +552,7 @@ export class InteractiveApp implements Ui {
         this.clearStream();
         void this.refreshGit();
         this.sessionName = (await readCursor(dir))?.name ?? this.sessionName;
+        this.forkedAt = await forkedAt(dir).catch(() => null);
         this.thinkingExpanded = this.app.ui?.settings.hideThinkingBlock === false;
         void this.refreshFileIndex();
       }
@@ -481,7 +570,7 @@ export class InteractiveApp implements Ui {
       this.historyLength = physical.events.length;
       this.files = fileChanges(this.transcriptItems);
       this.prompt = firstPrompt(this.transcriptItems);
-      this.startedAt = events.find(event => typeof event.at === "string")?.at ?? physical.header?.created_at;
+      this.startedAt = this.forkedAt ?? events.find(event => typeof event.at === "string")?.at ?? physical.header?.created_at;
       this.requestDerived();
     }
     this.paint();
@@ -498,7 +587,7 @@ export class InteractiveApp implements Ui {
     if (progress.kind === "retry") {
       this.stopRetry();
       this.live.retryUntil = Date.now() + progress.delayMs;
-      this.live.retryAttempt = progress.attempt;
+      this.live.retry = { attempt: progress.attempt, seconds: 0, ...(progress.max === undefined ? {} : { max: progress.max }), ...(progress.reason === undefined ? {} : { reason: progress.reason }) };
       this.retryTimer = setInterval(() => this.paint(), 200);
     } else {
       this.stopRetry();
@@ -538,10 +627,12 @@ export class InteractiveApp implements Ui {
     // A changed thinking label changes every thinking view; start the caches over.
     if (this.extensions.hiddenThinkingLabel !== this.cacheLabel) { this.cacheLabel = this.extensions.hiddenThinkingLabel; this.clearViewCache(); }
     const width = Math.max(20, this.screen.width - 8);
-    const items = projectItems(this.transcriptItems, {
-      notices: this.notices,
+    // A shown branch is its own log: the main session's notices and live stream do not belong in it.
+    const viewing = this.viewing !== undefined;
+    const items = projectItems(viewing ? this.branchItems : this.transcriptItems, {
+      notices: viewing ? [] : this.notices,
       style: () => app.ui?.style,
-      ...(live ? { live } : {}),
+      ...(live && !viewing ? { live } : {}),
       cache: this.viewCache,
       customTool: item => this.extensions.toolRenderer(item.name, item.input, item.result, item.callId),
       customMessage: item => this.extensions.messageRenderer(item.customType, item.text, item.data, item.entry),
@@ -561,9 +652,9 @@ export class InteractiveApp implements Ui {
       }
       return text === item.text ? item : { ...item, text };
     });
-    const home = !this.transcriptItems.some(item => item.kind === "user" || item.kind === "assistant" || item.kind === "tool" || item.kind === "shell" || item.kind === "custom") && !this.inflight;
+    const home = !viewing && !this.transcriptItems.some(item => item.kind === "user" || item.kind === "assistant" || item.kind === "tool" || item.kind === "shell" || item.kind === "custom") && !this.inflight;
     const clock = this.startedAt ? sessionClock(this.startedAt, new Date()) : undefined;
-    const view = projectWithStart(items, clock);
+    const view = projectWithStart(items, clock, this.forkedAt !== null);
     this.screen.setGreeting(home ? {
       version: XENO_VERSION, model: app.credential.ok ? spec.name : null, thinking: app.providerConfig.effort,
       workspace: displayPath(app.workspace, homedir()), branch: this.branch,
@@ -594,7 +685,7 @@ export class InteractiveApp implements Ui {
       ...(pending ? { tool: pending.name } : this.executionKind === "bash" ? { tool: "bash" } : {}),
       ...(this.lastOutcome ? { outcome: this.lastOutcome } : this.controlSnapshot?.goal?.state.execution ? { outcome: this.controlSnapshot.goal.state.execution } : {}),
       ...(this.controlSnapshot?.goal ? { goal: this.controlSnapshot.goal.state.status } : {}),
-      ...(this.live.retryUntil ? { retry: { attempt: this.live.retryAttempt, seconds: (this.live.retryUntil - Date.now()) / 1000 } } : {}) });
+      ...(this.live.retryUntil && this.live.retry ? { retry: { ...this.live.retry, seconds: (this.live.retryUntil - Date.now()) / 1000 } } : {}) });
     return {
       version: XENO_VERSION, title: this.sessionName ?? this.prompt, workspace: displayPath(app.workspace, homedir()),
       workspaceShort: shortPath(displayPath(app.workspace, homedir())), branch: this.branch,
@@ -681,7 +772,7 @@ export class InteractiveApp implements Ui {
     const l = this.live;
     if (!l.thinking && !l.text && !l.tools.size && !l.output && l.bash === null && !l.retryUntil) return undefined;
     return { thinking: l.thinking, text: l.text, tools: [...l.tools].map(([id, tool]) => ({ id, ...tool })), output: l.output, bash: l.bash,
-      ...(l.retryUntil ? { retry: `retry ${l.retryAttempt} in ${Math.max(0, (l.retryUntil - Date.now()) / 1000).toFixed(1)}s · esc to cancel` } : {}) };
+      ...(l.retryUntil && l.retry ? { retry: retryLine({ ...l.retry, seconds: (l.retryUntil - Date.now()) / 1000 }) } : {}) };
   }
 
   /** The context budget changes only with the log or the model; it is not recounted on every paint. */
@@ -767,6 +858,7 @@ export class InteractiveApp implements Ui {
     if (bound(b, "app.suspend", key)) { this.suspend(); return true; }
     if (this.screen.dialogs.open) return this.screen.dialogs.key(key);
     if (this.screen.handleControlKey(key)) return true;
+    if (this.branchFocus !== undefined) { const handled = this.branchKey(key); if (handled !== undefined) return handled; }
     const composer = this.screen.composer;
     if (composer.completing) {
       if (key.chord === "up") { composer.moveCompletion(-1); return true; }
@@ -794,6 +886,7 @@ export class InteractiveApp implements Ui {
       else this.toast("press ctrl+c again to quit");
       this.lastInterrupt = Date.now(); this.paint(); return true;
     }
+    if (bound(b, "app.interrupt", key) && this.viewing) { this.closeBranchView(); return true; }
     if (bound(b, "app.interrupt", key)) {
       if (this.inflight) this.interrupt();
       else if (!this.screen.messages.atBottom) this.screen.messages.scrollToBottom();
@@ -826,7 +919,12 @@ export class InteractiveApp implements Ui {
     if (bound(b, "editor.newLine", key)) { composer.insert("\n"); return true; }
     if (bound(b, "editor.submit", key)) { const text = composer.text; this.track(() => this.submit(text, "steering")); return true; }
     if (bound(b, "editor.historyPrevious", key)) return composer.historyStep(-1);
-    if (bound(b, "editor.historyNext", key)) return composer.historyStep(1);
+    if (bound(b, "editor.historyNext", key)) {
+      if (composer.historyStep(1)) return true;
+      // Nothing newer to recall: Down continues into the branch rows under the box (Claude Code's footer).
+      if (composer.onLastRow && composer.historyPosition === undefined && this.branchRows.length) { this.branchFocus = 0; this.paintBranches(); return true; }
+      return false;
+    }
     for (const [chord, shortcut] of this.app.extensions?.shortcuts ?? []) if (chord === key.chord) {
       this.runExtensionAction(() => shortcut.handler(this.hooks.extensionContext(this.app, this))); return true;
     }
@@ -1139,7 +1237,13 @@ export class InteractiveApp implements Ui {
     const cell = resolution && this.renderer.terminalWidth > 0 && this.renderer.terminalHeight > 0
       ? { width: resolution.width / this.renderer.terminalWidth, height: resolution.height / this.renderer.terminalHeight } : DEFAULT_CELL;
     return { mode: show ? "picture" : "chip", protocol: effective, cell, widthCells: terminal?.imageWidthCells ?? 60,
-      ...(!show ? { reason } : {}), load: sha => this.images.loadResult(sha) };
+      ...(!show ? { reason } : {}), load: sha => this.images.loadResult(sha), open: sha => this.openImage(sha) };
+  }
+  /** A click on a picture (feat-tui-image-full-size): the system viewer shows what the thumbnail cannot. */
+  private openImage(sha256: string): void {
+    void this.hooks.openImage(this.app, sha256)
+      .then(reason => { if (reason) this.notice(reason, "warning"); })
+      .catch(error => this.notice(describeError(error), "warning"));
   }
   private applyPictures(): void {
     if (this.disposed) return;
@@ -1211,6 +1315,9 @@ export class InteractiveApp implements Ui {
         if (notice.method === "turn/started") { this.inflight = true; this.executionKind = "model"; }
         if (notice.method === "turn/completed") {
           this.inflight = false; this.executionKind = "idle"; this.clearStream();
+          // feat-external-effects-summary: a remote-driven turn shows the same line a local one does.
+          const outside = formatExternalEffects((notice.params["externalEffects"] ?? []) as ExternalEffect[], hostExternalOptions());
+          if (outside) this.notice(outside, "warning");
           const outcome = notice.params["outcome"] as import("../../core/outcome.ts").ExecutionOutcome | undefined;
           this.turn = this.continueRemoteTurn(control, outcome).catch(error => this.notice(describeError(error), "error"));
         }
@@ -1223,9 +1330,21 @@ export class InteractiveApp implements Ui {
           else this.track(() => this.syncTranscript());
         }
       }
+      // A background branch (/review-code) joins while no turn runs; nothing else would redraw the transcript.
+      if (notice.method === "item/completed" && !this.inflight && !this.abort) this.track(() => this.syncTranscript());
+      if (notice.method === "item/completed" && BRANCH_LIFECYCLE.has((notice.params["item"] as { type?: string } | undefined)?.type ?? "")) this.track(() => this.refreshBranches());
       if (notice.method !== "turn/event") { this.derivedKey = ""; this.requestDerived(); this.paint(); }
     });
-    this.stopControl = () => { detachInput(); unsubscribe(); };
+    // A shown branch follows its own commits; an ended one changes its row.
+    const unsubscribeBranches = this.app.session.subscribeBranchRecords(item => {
+      if (this.disposed) return;
+      if (this.viewing?.node === item.node) this.track(() => this.syncBranchView());
+      // Its first prompt means the child is live (the spawn notice can arrive before its handle exists).
+      if (item.type === "outcome" || item.type === "user") this.track(() => this.refreshBranches());
+    });
+    this.viewing = undefined; this.branchItems = []; this.branchFocus = undefined; this.clearedBranches.clear(); this.screen.setViewing(undefined);
+    this.track(() => this.refreshBranches());
+    this.stopControl = () => { detachInput(); unsubscribe(); unsubscribeBranches(); };
   }
 
   private async continueRemoteTurn(control: SessionControl, outcome?: import("../../core/outcome.ts").ExecutionOutcome): Promise<void> {
@@ -1482,14 +1601,16 @@ export class InteractiveApp implements Ui {
     const scan = new AbortController();
     const items = (query = ""): ListItem[] => selectSessions(rows, query, sort, false, sessionFuzzy).map(row => ({
       value: row.path, label: "  ".repeat(Math.min(8, row.depth)) + (row.depth ? "↳ " : "") + (row.name?.trim() || row.text?.split("\n").find(Boolean)?.slice(0, 90) || row.id),
-      description: [row.updated_at?.slice(0, 16).replace("T", " ") ?? "", row.model ?? "", scope === "all" ? row.workspace ?? "" : ""].filter(Boolean).join(" · "),
+      description: [row.updated_at?.slice(0, 16).replace("T", " ") ?? "", row.forked_at ? `forked ${row.forked_at.slice(0, 16).replace("T", " ")}` : "",
+        row.model ?? "", scope === "all" ? row.workspace ?? "" : ""].filter(Boolean).join(" · "),
       ...(row.path === this.app.logDir ? { hint: "● current" } : {}),
     }));
     const load = async () => {
       rows = [];
       const roots = scope === "current" ? [root] : await sessionRoots(root);
       for await (const batch of scanSessionRoots(roots, scan.signal)) {
-        rows.push(...batch.sessions.filter((row): row is Row => row.ok));
+        // Empty sessions are hidden, except the one in use (fix-skip-empty-sessions).
+        rows.push(...batch.sessions.filter((row): row is Row => row.ok && (row.conversation !== false || row.path === this.app.logDir)));
         if (this.screen.dialogs.top === spec) this.screen.dialogs.list?.setItems(items(this.screen.dialogs.list.query));
       }
     };
@@ -1600,7 +1721,7 @@ export function trustItems(workspace: string): ListItem[] {
   ];
 }
 
-function emptyLive() { return { thinking: "", text: "", tools: new Map<string, { name: string; arguments: string }>(), output: "", bash: null as string | null, retryUntil: 0, retryAttempt: 0 }; }
+function emptyLive() { return { thinking: "", text: "", tools: new Map<string, { name: string; arguments: string }>(), output: "", bash: null as string | null, retryUntil: 0, retry: null as RetryFacts | null }; }
 
 function noticeOf(id: string, after: number, lines: string[], tone: Tone): Notice & { lines: string[]; tone: Tone } {
   const prefix = tone === "error" ? "\x1b[31m" : tone === "warning" ? "\x1b[33m" : tone === "success" ? "\x1b[32m" : "";
@@ -1672,8 +1793,10 @@ async function printExit(app: App): Promise<void> {
 }
 
 /** The session-start rule first, then the projection (refactor-tui-dock-layout DoD 7). */
-function projectWithStart(items: ReturnType<typeof projectItems>, clock: string | undefined): ReturnType<typeof projectItems> {
-  return clock ? [{ kind: "segment", id: "session-start", rev: clock, label: `session · ${clock}` }, ...items] : items;
+function projectWithStart(items: ReturnType<typeof projectItems>, clock: string | undefined, forked = false): ReturnType<typeof projectItems> {
+  // The label is part of rev: a view keyed on rev alone would keep "session" after switching into a fork.
+  const label = `${forked ? "forked" : "session"} · ${clock}`;
+  return clock ? [{ kind: "segment", id: "session-start", rev: label, label }, ...items] : items;
 }
 
 /** "~/Projects/workspace/xeno-tui" → "~/P/w/xeno-tui": every directory but the last cut to its first letter. */

package/src/apps/ui/project.ts

@@ -123,5 +123,5 @@ function shortRef(ref: string): string { return ref.split("/").pop() ?? ref; }
 
 /** What the view needs of a logged image: its address, name and pixel size. Never the bytes (D8). */
 export function imageView(image: ImageRef): ImageView {
-  return { sha256: image.sha256, name: image.name, width: image.width, height: image.height };
+  return { sha256: image.sha256, name: image.name, width: image.width, height: image.height, ...(image.original ? { full: image.original.sha256 } : {}) };
 }

package/src/apps/ui/standalone.ts

@@ -102,13 +102,15 @@ export async function pickStartupSession(opts: { workspace: string; sessionDir?:
   let scope: "current" | "all" = "current";
   const items = (query = ""): ListItem[] => selectSessions(rows, query, "threaded", false, (q, text) => { const score = fuzzyMatch(text, q); return { matches: score !== null, score: score ?? Infinity }; })
     .map(row => ({ value: row.path, label: "  ".repeat(Math.min(8, row.depth)) + (row.depth ? "↳ " : "") + (row.name?.trim() || row.text?.split("\n").find(Boolean)?.slice(0, 90) || row.id),
-      description: [row.updated_at?.slice(0, 16).replace("T", " ") ?? "", row.model ?? "", scope === "all" ? row.workspace ?? "" : ""].filter(Boolean).join(" · ") }));
+      description: [row.updated_at?.slice(0, 16).replace("T", " ") ?? "", row.forked_at ? `forked ${row.forked_at.slice(0, 16).replace("T", " ")}` : "",
+        row.model ?? "", scope === "all" ? row.workspace ?? "" : ""].filter(Boolean).join(" · ") }));
   try {
     let spec: DialogSpec & { kind: "list" } | undefined;
     const load = async () => {
       rows = [];
       for await (const batch of scanSessionRoots(scope === "current" ? [root] : await sessionRoots(root), scan.signal)) {
-        rows.push(...batch.sessions.filter((row): row is Session => row.ok));
+        // A session left without a word is not something to resume (fix-skip-empty-sessions).
+        rows.push(...batch.sessions.filter((row): row is Session => row.ok && row.conversation !== false));
         if (spec && host.dialogs.top === spec) host.dialogs.list?.setItems(items(host.dialogs.list.query));
       }
     };

package/src/apps/ui/surface.ts

@@ -20,6 +20,8 @@ export interface TurnSurface {
   pushProgress?(progress: NonNullable<LoopEvent["progress"]>): void;
   pullQueued?(phase: Phase): Promise<UserInput | null>;
   observeEvent?(event: LoopEvent): void;
+  /** A plain-text notice in the message stream (the interactive app); line mode prints instead. */
+  notice?(text: string, tone?: "info" | "success" | "warning" | "error"): void;
 }
 
 export interface Ui extends TurnSurface {

package/src/core/activity-status.ts

@@ -9,9 +9,24 @@ export interface ActivityFacts {
   readonly goal?: string;
   readonly phase?: "connecting" | "thinking" | "streaming" | "tool";
   readonly tool?: string;
-  readonly retry?: { readonly attempt: number; readonly seconds: number };
+  readonly retry?: RetryFacts;
   readonly queued: number;
 }
+/** One pending retry: which attempt, out of how many, how long until it, and why. */
+export interface RetryFacts { readonly attempt: number; readonly max?: number; readonly seconds: number; readonly reason?: string }
+
+const attemptText = (retry: RetryFacts): string => retry.max === undefined ? `${retry.attempt}` : `${retry.attempt}/${retry.max}`;
+
+/**
+ * The stream-area retry line. The cause appears from the third attempt (or
+ * the last, for a smaller budget), as in Claude Code: one or two retries are
+ * noise, and naming them would send the user to check a network that is fine.
+ */
+export function retryLine(retry: RetryFacts): string {
+  const named = retry.reason !== undefined && retry.attempt >= Math.min(3, retry.max ?? 3);
+  return `retry ${attemptText(retry)} in ${Math.max(0, retry.seconds).toFixed(1)}s · ${named ? `${retry.reason} · ` : ""}esc to cancel`;
+}
+
 export interface ActivityStatus { readonly state: ProgramStatus["state"]; readonly label: string; readonly detail: string; readonly queued: number }
 
 const STOP_CAUSE: Partial<Record<ExecutionOutcome["reason"], string>> = {
@@ -29,7 +44,7 @@ export function activityStatus(facts: ActivityFacts): ActivityStatus {
     : !facts.waiting && facts.goal === "awaiting_human" ? "Awaiting review" : "Awaiting input");
   if (status.state === "error") return view("Failed");
   if (!facts.running) return view(status.state === "done" ? "Turn finished" : facts.outcome?.status === "cancelled" ? "Cancelled" : "Ready");
-  if (facts.retry) return view("Retrying", `attempt ${facts.retry.attempt} · ${Math.max(0, Math.ceil(facts.retry.seconds))}s`);
+  if (facts.retry) return view("Retrying", `attempt ${attemptText(facts.retry)} · ${Math.max(0, Math.ceil(facts.retry.seconds))}s`);
   if (facts.phase === "tool") return view("Running tool", facts.tool ?? "Tool execution");
   if (facts.phase === "thinking") return view("Thinking");
   if (facts.phase === "streaming") return view("Responding");

package/src/core/command-contract.ts

@@ -65,18 +65,12 @@ const NEGATIVE_ANSWERS: Readonly<Record<string, string>> = {
 };
 
 /**
- * What exit 1 of the command's final simple command means, or null.
- *
- * Only the last segment after a top-level `;`, newline, `||` or `|` is read.
- * After `&&` the 1 may come from the command that short-circuited, so it is
- * not classified. Under pipefail an earlier pipeline stage can also set the
- * status; the exit is kept in the receipt either way, and the label states
- * the program's meaning rather than claiming success. Anything this scanner
- * cannot read with certainty -- unbalanced quotes, subshells, compound
- * statements, substitutions -- yields null.
+ * The final simple command of `command` and the separator before it, or
+ * null when this scanner cannot read the command with certainty --
+ * unbalanced quotes, subshells, compound statements, substitutions or a
+ * background `&`. Only top-level `;`, newline, `&&`, `||` and `|` split.
  */
-export function negativeAnswer(command: string, exit: number): string | null {
-  if (exit !== 1) return null;
+function finalStage(command: string): { separator: string; words: string[] } | null {
   let quote: "'" | "\"" | null = null, start = 0, separator = "";
   for (let i = 0; i < command.length; i++) {
     const c = command[i]!;
@@ -93,16 +87,64 @@ export function negativeAnswer(command: string, exit: number): string | null {
     if (c === ";" || c === "\n" || c === "|") { separator = c; start = i + 1; continue; }
     if (c === "&" && command[i + 1] !== ">" && command[i - 1] !== ">") return null;
   }
-  if (quote !== null || separator === "&&") return null;
-  const words = command.slice(start).trim().split(/\s+/).filter(word => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word));
-  const program = (words[0] ?? "").replace(/^.*\//, "");
-  if (program === "git") return words[1] === "grep" ? "no match" : null;
+  if (quote !== null) return null;
+  return { separator, words: command.slice(start).trim().split(/\s+/).filter(word => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) };
+}
+
+const programName = (words: readonly string[]) => (words[0] ?? "").replace(/^.*\//, "");
+
+/**
+ * What exit 1 of the command's final simple command means, or null.
+ *
+ * Only the last segment after a top-level `;`, newline, `||` or `|` is read.
+ * After `&&` the 1 may come from the command that short-circuited, so it is
+ * not classified. Under pipefail an earlier pipeline stage can also set the
+ * status; the exit is kept in the receipt either way, and the label states
+ * the program's meaning rather than claiming success. Anything this scanner
+ * cannot read with certainty -- unbalanced quotes, subshells, compound
+ * statements, substitutions -- yields null.
+ */
+export function negativeAnswer(command: string, exit: number): string | null {
+  if (exit !== 1) return null;
+  const stage = finalStage(command);
+  if (stage === null || stage.separator === "&&") return null;
+  const program = programName(stage.words);
+  if (program === "git") return stage.words[1] === "grep" ? "no match" : null;
   return Object.hasOwn(NEGATIVE_ANSWERS, program) ? NEGATIVE_ANSWERS[program]! : null;
 }
 
+/**
+ * Readers that may stop reading before their input ends (`head -n`, `sed Nq`,
+ * `awk '{exit}'`, `grep -m` / `-q`), closing the pipe on the writer before it.
+ */
+const EARLY_READERS: ReadonlySet<string> = new Set(["head", "sed", "awk", "gawk", "mawk", "grep", "egrep", "fgrep", "rg"]);
+
+/**
+ * What exit 141 means when an early reader ends the pipeline, or null.
+ *
+ * Measured (pipe-early-close card): under `bash -o pipefail`, `seq 1 1000000
+ * | head -1` exits 141 -- pipefail reports the rightmost nonzero stage, here
+ * the writer that SIGPIPE killed after head closed its input, while every
+ * stage to its right, the final reader included, exited 0. The output the
+ * command asked for is complete. Only a final stage joined by a top-level
+ * `|` is read: after `;`, `&&` or `||` the 141 is the last command's own.
+ */
+export function earlyCloseAnswer(command: string, exit: number): string | null {
+  if (exit !== 141) return null;
+  const stage = finalStage(command);
+  if (stage === null || stage.separator !== "|") return null;
+  const program = programName(stage.words);
+  return EARLY_READERS.has(program) ? `${program} closed the pipe early; the earlier stage's SIGPIPE is not a failure` : null;
+}
+
+/** The program's own meaning of a nonzero exit that is an answer, not a fault. */
+export function commandAnswer(command: string, exit: number): string | null {
+  return negativeAnswer(command, exit) ?? earlyCloseAnswer(command, exit);
+}
+
 /** A trap can exit zero after cancellation: successful exit alone does not erase the stop. */
 export function commandCompletion(exit: number, stopped?: "cancelled" | "timeout", cleanup?: ToolDiagnostic, command?: string) {
-  const answered = exit === 0 || command !== undefined && negativeAnswer(command, exit) !== null;
+  const answered = exit === 0 || command !== undefined && commandAnswer(command, exit) !== null;
   return { ok: stopped === undefined && answered && cleanup === undefined,
     outcome: executionOutcome(stopped ?? (answered && cleanup === undefined ? "tool_completed" : "tool_failed")),
     ...(cleanup ? { warnings: [cleanup] } : {}) };

package/src/core/completion-review.ts

@@ -69,7 +69,7 @@ export function requestCompletion(state: RequestState, remainingRequests: number
   if (state.used_tools && text.length === 0) gaps.push("the final reply is empty");
   // Strict verification counts only configured gates (O.11); say so, since a successful `cat` would otherwise look like a check.
   if (freshCheck && freshCheck.status !== "pass") gaps.push(freshCheck.gate_only
-    ? "files were changed but no configured verification gate (a test, typecheck, lint, build or check command) has passed since the last edit; reading or printing files does not count, and a gate counts only when run as its own plain command, without redirects, pipes, $(), ; or &&"
+    ? "files were changed but no configured verification gate (a test, typecheck, lint, build or check command) has passed since the last edit; reading or printing files does not count, and a gate counts only when run as plain commands joined by && (trailing output redirects to fixed files are fine); ;, ||, pipes, $() and variables hide it"
     : "files were changed but no command has succeeded since the last edit");
   if (acceptance?.status === "needs_work") gaps.push(`declared acceptance criteria need evidence: ${[
     ...missingCommands.map(item => `${item.id}=${item.status}`),

package/src/core/derive.ts

@@ -425,7 +425,15 @@ export function deriveHandoff(input: DeriveInput): Handoff {
   const processes = deriveProcesses(prev?.processes ?? [], events, input.self.node);
 
   const hasRemaining = inFlight.length > 0 || blocked.length > 0 || openQuestions.length > 0;
-  const hasNextAction = inFlight.some((i) => i.next_action.trim().length > 0);
+  // A next action is a statement about the current state of the work, so it
+  // follows the evidence rule above: only one this segment recorded or
+  // refreshed counts. A carried one stays listed but no longer suppresses the
+  // boundary and continuation reminders that ask the model to confirm it.
+  const thisSegment = new Set(events.map((e) => e.id));
+  const freshUnscoped = new Set(events.flatMap((e) => e.t === "next_action" && e.work_id === undefined ? [e.what] : []));
+  const freshWork = new Set(workItems.filter((item) => thisSegment.has(item.updated_at)).map((item) => item.id));
+  const hasNextAction = inFlight.some((i) => i.next_action.trim().length > 0 &&
+    (i.work_id === undefined ? freshUnscoped.has(i.what) : freshWork.has(i.work_id)));
 
   return {
     handoff_version: HANDOFF_VERSION,

package/src/core/event-validation.ts

@@ -25,6 +25,14 @@ export function validNodeRef(value: unknown): value is NodeRef {
     (value["at_event"] === undefined || typeof value["at_event"] === "string");
 }
 
+/** A label is a short phrase or class name; anything longer or with control characters is not one the harness wrote. */
+function validFailureCause(value: unknown): boolean {
+  return isRecord(value) && (value["source"] === "provider" || value["source"] === "harness") &&
+    typeof value["label"] === "string" && /^[^\u0000-\u001f\u007f]{1,64}$/.test(value["label"]) &&
+    (value["status"] === undefined || Number.isSafeInteger(value["status"])) &&
+    (value["retries"] === undefined || natural(value["retries"]));
+}
+
 export function isLogEvent(value: unknown): value is LogEvent {
   if (!isRecord(value) || typeof value["id"] !== "string" || value["id"].length === 0 || typeof value["at"] !== "string") return false;
   if (value["outcome"] !== undefined && !isExecutionOutcome(value["outcome"])) return false;
@@ -58,6 +66,14 @@ export function isLogEvent(value: unknown): value is LogEvent {
         value["reason"] === "disposed" && isRecord(output) && typeof output["path"] === "string" &&
         typeof output["sha256"] === "string" && /^[a-f0-9]{64}$/.test(output["sha256"]) && natural(output["bytes"]);
     }
+    case "approval": {
+      const user = ["once", "command", "tool", "deny"].includes(String(value["decision"]));
+      const rule = value["decision"] === "allow" || value["decision"] === "deny";
+      return has("call_id", "tool") && value["call_id"] !== "" && value["tool"] !== "" &&
+        optionalString(value["command"]) && optionalString(value["rule"]) &&
+        (value["source"] === "user" ? user : value["source"] === "no_prompt" ? value["decision"] === "deny" :
+          ["session_rule", "config", "auto"].includes(String(value["source"])) && rule);
+    }
     case "skill_loaded": return has("name", "path", "sha256", "artifact") &&
       ["sha256", "artifact"].every(key => /^[a-f0-9]{64}$/.test(String(value[key]))) &&
       ["inline", "fork", "read"].includes(String(value["mode"])) && ["user", "model"].includes(String(value["origin"]));
@@ -81,7 +97,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
     }
     case "extension": return has("customType", "content") && typeof value["display"] === "boolean" && typeof value["inContext"] === "boolean" && (value["data"] === undefined || isJsonValue(value["data"]));
     case "user": return has("text") && (value["request"] === undefined || typeof value["request"] === "string" && value["request"] !== "");
-    case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]);
+    case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]) && (value["failure"] === undefined || validFailureCause(value["failure"]));
     case "user_bash": {
       const ref = value["content_ref"];
       const outcome = value["outcome"];
@@ -92,7 +108,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
         isRecord(ref) && typeof ref["sha256"] === "string" &&
         typeof ref["path"] === "string" && natural(ref["bytes"]);
     }
-    case "guidance": return has("text") && ["continuation", "repetition", "budget", "boundary", "stall", "output_recovery", "completion_review", "churn", "deadline", "runtime_acceptance", "goal"].includes(String(value["reason"])) && strings(value["sources"]);
+    case "guidance": return has("text") && ["continuation", "repetition", "budget", "boundary", "stall", "output_recovery", "completion_review", "churn", "deadline", "runtime_acceptance", "goal", "secret", "branch"].includes(String(value["reason"])) && strings(value["sources"]);
     case "interrupt": return has("user_id");
     case "assistant": return (value["stop_reason"] === null || optionalString(value["stop_reason"])) &&
       (value["replay_key"] === undefined || typeof value["replay_key"] === "string" && /^[a-f0-9]{64}$/.test(value["replay_key"])) &&
@@ -156,7 +172,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
       return effect["kind"] === "edit" && typeof effect["path"] === "string" && typeof effect["sha256_after"] === "string" &&
         (effect["sha256_before"] === null || typeof effect["sha256_before"] === "string");
     }
-    case "cut": return has("handoff_ref") && (value["working_set_version"] === undefined || value["working_set_version"] === 2) && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
+    case "cut": return has("handoff_ref") && (value["working_set_version"] === undefined || value["working_set_version"] === 2 || value["working_set_version"] === 3) && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
       (value["guidance_tools"] === undefined || Array.isArray(value["guidance_tools"]) && value["guidance_tools"].every(item => typeof item === "string")) &&
       optionalString(value["retained_from"]) && optionalString(value["next_context_ref"]) &&
       (value["next_node"] === undefined || natural(value["next_node"])) && optionalString(value["next_model"]) &&