@visual-z/xeno 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # 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:
+- A run is treated as stuck only when it repeats the same tool call, or the same cycle of up to five calls, three times without learning anything new. Re-reading files, rerunning a test after an edit, a failing test whose output changes, and waiting on a running process never count.
+- The first time, the model is told to change its method. If the cycle comes back, an interactive session asks you: Continue, Stop, or type instructions for the agent. Without anyone to ask (headless), the request still ends as stalled.
+- The old request-wide allowance of twelve exchanges without new evidence is gone. It stopped a long, finished task right after its final answer.
+
+The input box after a turn:
+- A finished turn reads `✓ Turn finished · 32m 34s` in the success colour, with how long the turn ran. The time stays until the next turn starts.
+- A turn the harness stopped reads `■ Stopped · no progress` (or request limit, context budget, output limit, time limit) in the warning colour, instead of `Awaiting input`. `Awaiting input` now means a question is waiting for you. A failed turn reads `✗ Failed` in the error colour.
+- A stop report names the tools that failed (`Failed tools: exec_command ×2, edit ×1`) instead of listing receipt ids, and says when the model had already given a final reply before the stop.
+
+Tools:
+- Where `rg` is missing, interactive sessions install a pinned ripgrep (14.1.1, checked against its SHA-256) into `~/.xeno/bin` in the background and add it to the end of the command PATH. Nothing is downloaded with `--offline`, in CI or from a source checkout. The environment tells the model whether `rg` is available.
+- A new `worktree` tool lets the model create an isolated Git worktree under `~/.xeno/worktrees`, on a branch `xeno/<name>`, and move the session into it; leaving returns to the main checkout and keeps the worktree and branch. Resumed sessions add the tool after their existing tools.
+- `exec_command` and `write_stdin` accept Codex's `max_output_tokens`. It lowers the inline preview only, and near spellings such as `max_output_chars` are pointed at the right name.
+- `grep`, `rg`, `diff`, `cmp` and `test` exiting 1 as the last command is read as their answer (no match, files differ), not a failure. The receipt keeps the real exit code.
+- A leading `(?i)` in a grep pattern means the same with or without ripgrep.
+
+Fixes:
+- A new segment no longer sends the model to `history` first when every user message is already in its handoff. Before, the first tool call of almost every session was that read.
+- The completion check says that a verification command counts only when run on its own, without redirects, pipes, `$()`, `;` or `&&`. The read it asks for no longer counts toward the stall watchdog.
+- Refusing an edit under `.git` or `.xeno` now says it is a fixed rule, instead of asking for a policy change that no setting can make.
+
 ## 0.8.1 — 2026-10-11
 
 The sidebar now follows your goal:

package/docs/install.md

@@ -144,6 +144,31 @@ check described above is a separate action):
 - the run is not the interactive app: `-p`, `--mode json`, `--export`, `--list-models`, `models --refresh`, package and `config` commands, `--version`
 - xeno runs from a checkout: its package root is not under `node_modules`, or has a `.git` (`bun src/apps/cli.ts`, `bun run agent`, `bun link`)
 
+## ripgrep
+
+Agents reach for `rg` in shell commands, and xeno's grep tool is faster with
+it. When neither `PATH` nor `~/.xeno/bin` has one, the interactive app
+installs ripgrep 14.1.1 into `~/.xeno/bin/rg` in the background:
+
+- **Only that build.** The archive comes from the ripgrep GitHub release and
+  must match a sha256 pinned in xeno (`src/core/ripgrep-release.ts`).
+  Anything else is discarded before extraction; only the `rg` executable is
+  unpacked.
+- **Yours wins.** `~/.xeno/bin` is appended to the end of the PATH of tool
+  commands, so an `rg` you install yourself is used instead.
+- **What the model is told.** The session's environment section says whether
+  `rg` exists in the shell at session start. A copy that finishes
+  downloading during the first session appears in the next one's line, but
+  shell commands can use it immediately.
+- **When not.** The same conditions as background update checks, except the
+  update settings: `--offline` / `XENO_OFFLINE`, `CI` /
+  `CONTINUOUS_INTEGRATION`, a non-interactive run, or running from a
+  checkout. `XENO_NO_TOOL_INSTALL` turns off only this download. Quitting
+  cancels it.
+
+Platforms: macOS arm64 and x64, Linux x64 (static musl) and arm64 (glibc).
+Elsewhere grep uses its built-in TypeScript search.
+
 ## Credentials
 
 Resolution order, first match wins:

package/package.json

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

package/src/apps/cli.ts

@@ -13,7 +13,7 @@
  */
 
 import {
-  parseArgs, startup, readPipedStdin, mergePrintPrompt, isInteractiveSession, printCliHelp,
+  parseArgs, startup, readPipedStdin, mergePrintPrompt, isInteractiveSession, printCliHelp, provisionToolsInBackground,
 } from "./startup.ts";
 import { createStartupInput } from "./startup-input.ts";
 import { runPrompt, runRepl } from "./shell.ts";
@@ -37,6 +37,7 @@ const args = parseArgs(process.argv.slice(serverMode || acpMode || reviewMode ?
 if (serverMode || acpMode) { args.print = true; args.mode = "json"; if (args.prompt) throw Error("protocol servers receive prompts through their client"); }
 if (reviewMode) args.print = true;
 let closeControl: (() => Promise<void>) | undefined;
+let stopToolInstall = (): void => {};
 const input = createStartupInput({ interactive: isInteractiveSession(args) && !args.packageCommand && !args.version && !args.exportFile && !args.listModels && !args.modelsCommand });
 process.once("exit", input.restore);
 try {
@@ -60,6 +61,7 @@ try {
     catch (error) { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = controller.signal.aborted ? 130 : 1; }
     finally { process.off("SIGINT", cancel); process.off("SIGTERM", cancel); }
   } else {
+    stopToolInstall = provisionToolsInBackground(args);
     const app = await startup(args, input);
     if (args.controlSocket) closeControl = await listenControl(args.controlSocket, () => sessionControl(app.session));
     if (serverMode) {
@@ -90,6 +92,7 @@ try {
 } catch (error) {
   console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1;
 } finally {
+  stopToolInstall();
   await closeControl?.();
   process.off("exit", input.restore);
   input.restore();

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

@@ -29,6 +29,10 @@ import {
   resolveCredential, envLabel, storedIsOAuth,
   type AuthFile, type ResolveEffects, type Resolved, describeMissingCredential } from "../runtime/auth.ts";
 import { authPath, configDir, readJsonFile } from "../store/config.ts";
+import { findRipgrep, provisionRipgrep } from "../store/tool-binaries.ts";
+import { packageLocation } from "../store/update-cache.ts";
+import { installKind } from "../core/update-check.ts";
+import { toolInstallAllowed } from "../core/ripgrep-release.ts";
 import { loadUiResources, loadTextResources, type UiResources } from "../store/resources.ts";
 import { discoverResources, type ResourceIndex } from "../store/resource-index.ts";
 import { pickProjectTrust, pickStartupSession, runResourceConfig } from "./ui/standalone.ts";
@@ -44,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";
@@ -108,9 +112,29 @@ export function sessionEnvironment(workspace: string): SessionEnvironment {
     cwd: workspace,
     date: `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`,
     git,
+    ripgrep: findRipgrep(configDir()) !== null,
   };
 }
 
+/**
+ * Fills the rg gap in the background for interactive sessions only: scripts,
+ * protocol servers and test subprocesses must not reach the network on their
+ * own. Failure is silent because grep keeps its TypeScript engine; the next
+ * session's environment line reports what is actually there. The returned
+ * stop aborts the download, so quitting never waits for it.
+ */
+export function provisionToolsInBackground(args: Args): () => void {
+  const location = packageLocation();
+  if (!isInteractiveSession(args) || !toolInstallAllowed({ env: process.env, offline: args.offline === true, install: installKind(location.root, location.git) })) return () => {};
+  const controller = new AbortController();
+  void provisionRipgrep({ configDir: configDir(), signal: controller.signal, fetchBytes: async (url, signal) => {
+    const response = await fetch(url, { ...(signal ? { signal } : {}), redirect: "follow" });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+  } }).catch(() => { /* grep falls back to its own engine */ });
+  return () => controller.abort();
+}
+
 /**
  * Session policy a CLI coding session differs from a benchmark run in.
  * Benchmarks construct their own SessionConfig and keep the core defaults.
@@ -366,8 +390,9 @@ export function parseArgs(argv: string[], options: { deferExtensions?: boolean;
   let updateExtensions = false;
   const args: Args = {
     cliFlags: argv.filter(value => value.startsWith("-")),
-    // No default request cap (S.6 item 1): the stall watchdog ends a run that
-    // stops producing evidence; --max-turns or an agent budget sets a hard cap.
+    // No default request cap (S.6 item 1): the stall watchdog catches a run
+    // repeating a cycle without evidence, and asks the user when one can answer
+    // (S.8); --max-turns or an agent budget sets a hard cap.
     workspace: process.cwd(), logDir: "", maxTurns: Infinity, prompt: "",
     // Overridable so a node boundary can be forced in a short session --
     // otherwise cutting is only reachable after tens of thousands of tokens,
@@ -1245,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) } : {}) };
@@ -1390,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,18 +9,42 @@ 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>> = {
+  stalled: "no progress", no_progress: "no progress", max_turns: "request limit", context_budget: "context budget",
+  output_limit: "output limit", timeout: "time limit",
+};
+
 export function activityStatus(facts: ActivityFacts): ActivityStatus {
   const status = programStatus(facts), queued = Math.max(0, Math.floor(facts.queued));
   const view = (label: string, detail = status.msg ?? ""): ActivityStatus => ({ state: status.state, label, detail, queued });
-  if (status.state === "blocked") return view(status.kind === "auth" ? "Sign in required" : status.kind === "permission" ? "Awaiting approval" : "Awaiting input");
+  // A harness stop is not a question: saying "Awaiting input" left the user
+  // guessing what to answer (fix-finished-turn-status). The OSC state stays blocked.
+  if (!facts.running && !facts.waiting && facts.outcome?.status === "stopped") return view("Stopped", STOP_CAUSE[facts.outcome.reason] ?? facts.outcome.reason.replaceAll("_", " "));
+  if (status.state === "blocked") return view(status.kind === "auth" ? "Sign in required" : status.kind === "permission" ? "Awaiting approval"
+    : !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");