@visual-z/xeno 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # xeno changelog
 
+## 0.8.3 — 2026-10-12
+
+Credentials stay out of the log and out of the model's context:
+- A key, token or password in your message or in a tool's output is replaced by a placeholder such as `[[xeno-secret-1]]` before anything is written. Only high-confidence shapes are recognised (provider key prefixes such as `sk-`, `ghp_`, `tskey-`, `AKIA`; JWTs; private keys; `password=` / `token:` / `密码是` followed by a value); there is no entropy guessing.
+- A short reply sent right after the assistant asked for a password or token is treated as that credential.
+- The model can still use it: a placeholder in a command or file is turned back into the real value when the tool runs, and hidden again if the output repeats it. Values live in the session's `secrets.jsonl` (owner-only), never in an event, a handoff or an export.
+- Credentials already in older logs are not rewritten; rotate any you pasted before this release.
+
+Knowing what happened:
+- A failed request records why: `HTTP 503 after 3 retries`, `connection lost`, `stream stalled`. Reopening the session still shows it. The provider's error text is still never written. An error inside xeno itself is recorded as an execution error, not a provider error.
+- Each approval is logged: who allowed the call (you, an earlier choice, a configured rule, `--yolo`) and which rule matched.
+- When a request ends, xeno lists what it did outside the workspace: writes, `kill`, system settings, `brew`/`npm -g`, non-GET `curl`, `git push`. Nothing is blocked; the list is there so a blanket approval is not silent.
+- Session logs record the xeno version that wrote them.
+
+Network:
+- Dropped connections are retried up to ten times, backing off to 32s, and the retry line says `retry 3/10 · connection lost`. A socket Bun closed or a host it could not reach is now retried; certificate failures are not.
+- After a connection dies, later requests open fresh connections instead of reusing a pooled dead socket.
+- A stream that sends nothing for 300s is abandoned and sent again, at most twice, instead of waiting for Escape.
+
+Verification and continuation:
+- A check run as `build && test`, with its output redirected to a file, or as `make build test lint` (also `just` and `task`) counts as verification. The model is no longer asked to run it again on its own.
+- A stop report lists a claim that was recorded but not verified as unverified, not as a failed tool, and no longer reads an uncapped request count as a limit that was hit.
+- Switching models before anything has happened no longer starts a new segment, so the model does not open from an empty handoff and go looking for work.
+- A next step written in an earlier segment no longer counts as a current plan; the boundary reminder asks the model to confirm or update it.
+- New segments carry every one of your messages before other history, name the screenshots attached to them (`history(event=…)` brings an image back), and keep one copy of each next step.
+
+Tools:
+- `write_stdin` with Ctrl-C or Ctrl-D to a process that already exited returns its exit and unread output instead of an error.
+- An empty `write_stdin` wait collects output until its window ends instead of waking for every line, so a chatty process no longer costs one request per line.
+- When `read` or `edit` cannot find a path, the error names up to three closest existing paths.
+- Paths outside the workspace skip instruction discovery, so the answer is the path rule's, not "instruction target escapes workspace".
+- Refusing to write under `.git` or `.xeno` says it is not a permission problem and no approval can allow it.
+- Exit 141 from `… | head` is read as the reader closing early, not a failure. Progress bars drawn with carriage returns reach the model as the line a terminal shows.
+
+Interface:
+- Pictures in the transcript may take half the screen (up to twenty rows); clicking one opens the original image.
+- `-c`, the resume pickers and `/sessions` skip sessions where you never sent a message.
+- A forked session shows `forked · HH:MM` and is timed from the fork, not from its parent's first message.
+
+Fixes:
+- Reasoning a gateway sent without a signature is replayed as reasoning, so Gemini through such a gateway stops copying its thinking into replies.
+
 ## 0.8.2 — 2026-10-11
 
 The stall watchdog no longer stops work that is merely long:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visual-z/xeno",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "license": "UNLICENSED",
   "type": "module",
   "description": "Segmented append-only agent log with pure context and handoff projections",

package/src/apps/shell.ts

@@ -7,6 +7,7 @@
  */
 
 import { criterionSummary, draftGoal, pickCriteria, type PendingGoal } from "./goal-flow.ts";
+import { openImageFile } from "../runtime/open-image.ts";
 import { closeAppSession, switchAppSession } from "./session-lifecycle.ts";
 import { basename, dirname, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
@@ -58,7 +59,7 @@ import { reloadAppResources } from "./resources.ts";
 import { publishModelCatalog } from "./model-catalog.ts";
 import { readCursor, writeCursor, listNodes, readNode, readManifest, setSessionLabel } from "../store/log.ts";
 import { registerSessionRoot } from "../store/session-browser.ts";
-import { createSession, findSessionByPrefix, listSessions, truncationNote, sessionsDir } from "../store/sessions.ts";
+import { createSession, findSessionByPrefix, hasConversation, listSessions, truncationNote, sessionsDir } from "../store/sessions.ts";
 import { exportSessionArchive, importSessionArchive } from "../store/session-archive.ts";
 import { resolveTuiMode } from "../core/tui-mode.ts";
 import { modelPreferencePatch, thinkingPreferencePatch } from "../core/model-preferences.ts";
@@ -75,6 +76,8 @@ import { createStyle, IDENTITY } from "../tui/style.ts";
 import { lastAssistantText, toHtml } from "../core/export.ts";
 import { toJsonEvent } from "../core/json-event.ts";
 import { sessionControl } from "../runtime/session-control.ts";
+import { hostExternalOptions, requestExternalEffects } from "../runtime/turn-effects.ts";
+import { formatExternalEffects } from "../core/external-effects.ts";
 import { COMMANDS, parseCommand, type Command } from "./commands.ts";
 import { expandInput } from "./input.ts";
 import {
@@ -433,6 +436,8 @@ export const interactiveHooks = {
   effortSupported: (spec: ModelSpec, level: Effort) => effortSupported(spec, level),
   fileIndexFor: (app: App, refresh?: boolean) => fileIndexFor(app, refresh),
   dropFileIndex: (workspace: string) => { fileIndexes.delete(workspace); },
+  /** Show a stored image in the system viewer; resolves to why it could not, or null. */
+  openImage: (app: App, sha256: string) => openImageFile(app.blobDir, sha256),
 };
 
 type Outcome = "continue" | "quit" | { login: string };
@@ -1089,6 +1094,8 @@ async function printSessionList(app: App): Promise<void> {
       app.io.say(C.red(`  ${s.id}  unreadable  ${s.error}`));
       continue;
     }
+    // A session left without a word is noise here; the current one stays (fix-skip-empty-sessions).
+    if (s.path !== app.logDir && !await hasConversation(s.path)) continue;
     const here = s.path === app.logDir ? C.cyan(" now ") : "     ";
     const label = (s.name ?? s.id).padEnd(24);
     app.io.say(`  ${here} ${label}${C.dim(`${s.events} events  ${s.model ?? ""}`)}`);
@@ -1652,9 +1659,8 @@ export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort
     thinkingDisplay: app.providerConfig.thinkingDisplay,
   };
   const next = makeProvider(app, nextConfig, got.key);
-  app.io.say(C.dim("  new segment: the next model starts from a handoff, not this model's thinking"));
   try {
-    await app.session.switchModel(next);
+    if (await app.session.switchModel(next)) app.io.say(C.dim("  new segment: the next model starts from a handoff, not this model's thinking"));
   } catch (err) {
     app.io.say(C.red(`  cannot switch: ${describeError(err)}`));
     return;
@@ -2041,6 +2047,10 @@ export async function runTurn(
       app.io.say(line);
     }
   } } finally { await registry?.emit("agent_end", { messages: structuredClone(app.session.state.events) }); }
+  // feat-external-effects-summary: one line, in every mode (print and json send it to stderr).
+  const host = hostExternalOptions();
+  const outside = formatExternalEffects(skill ? requestExternalEffects(app.session, host) : sessionControl(app.session).lastExternalEffects, host);
+  if (outside) { if (tui?.notice) tui.notice(outside, "warning"); else app.io.say(app.io.palette.yellow(`  ${outside}`)); }
   if (failure) throw Error(failure);
   if (completed) {
     const text = finalText.join("\n");

package/src/apps/startup.ts

@@ -48,7 +48,7 @@ import { refreshRemoteCatalog } from "../runtime/models-fetch.ts";
 import { readCursor, writeCursor, type Cursor } from "../store/log.ts";
 import { getBlob } from "../store/blobs.ts";
 import { parseSessionContext } from "../core/session-format.ts";
-import { resolveLogDir, findSessionByPrefix, listSessions, sessionsDir, type ResolveLogOpts } from "../store/sessions.ts";
+import { resolveLogDir, findSessionByPrefix, newestConversation, sessionsDir, type ResolveLogOpts } from "../store/sessions.ts";
 import { recoverCut } from "../store/recovery.ts";
 import { planSessionEntry, restoreSessionModel } from "../core/session-entry.ts";
 import { loadContext, assembleSystemPrompt, formatNotice, type LoadedContext } from "../store/context-files.ts";
@@ -1270,9 +1270,9 @@ export async function openSessionFor(opts: OpenSessionOptions): Promise<{
   session.config.tools.workflowMode = opts.args.workflow ?? "build";
   session.config.tools.deferredTools = restoredTools.deferred;
   if (restoring.id !== spec.id || restoring.provider !== spec.provider) {
-    await session.switchModel(createProvider(providerConfig, credential.ok ? credential.key : "", retryHandler(opts.io),
+    const cut = await session.switchModel(createProvider(providerConfig, credential.ok ? credential.key : "", retryHandler(opts.io),
       { sessionId: providerSessionId(session.config.logDir), ...(oauth(spec, credential) ? { oauth: true } : {}), ...(opts.effects ? { effects: opts.effects } : {}) }));
-    opts.io.say(opts.io.palette.yellow(`  switched ${restoring.id} → ${spec.id} at a model checkpoint`));
+    opts.io.say(opts.io.palette.yellow(`  switched ${restoring.id} → ${spec.id}${cut ? " at a model checkpoint" : ""}`));
   }
   resources.ui.settings = { ...resources.ui.settings, thinking: providerConfig.effort,
     ...(opts.args.modelsExplicit || opts.args.models ? { scopedModels: splitModelPatterns(opts.args.models) } : {}) };
@@ -1415,7 +1415,7 @@ export async function startup(args: Args, input?: StartupInput): Promise<App> {
     let resourceLog: string | undefined;
     if (target) { const found = await findSessionByPrefix(workspace, target, sessionDirFor(args, workspace)); if (found.ok) resourceLog = found.session.path; }
     else if (args.sessionId) resourceLog = join(sessionsDir(workspace, sessionDirFor(args, workspace)), args.sessionId);
-    else if (args.continueLatest) resourceLog = (await listSessions(workspace, sessionDirFor(args, workspace), Infinity)).sessions.find(session => session.ok)?.path;
+    else if (args.continueLatest) resourceLog = (await newestConversation(workspace, sessionDirFor(args, workspace)))?.path;
     if (resourceLog) resourceWorkspace = (await readCursor(resourceLog))?.workspace ?? workspace;
   }
   input?.phase("Loading session resources");

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,12 @@ 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 { 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";
@@ -155,7 +157,7 @@ export class InteractiveApp implements Ui {
   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 +196,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. */
@@ -464,6 +468,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 +486,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 +503,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();
@@ -563,7 +568,7 @@ export class InteractiveApp implements Ui {
     });
     const home = !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 +599,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 +686,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. */
@@ -1139,7 +1144,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 +1222,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"));
         }
@@ -1482,14 +1496,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 +1616,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 +1688,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"].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"]) &&