@visual-z/xeno 0.7.2 → 0.8.1

package/src/store/sessions.ts

@@ -22,7 +22,7 @@
  * and silently truncate a log.
  */
 
-import { cp, lstat, mkdir, mkdtemp, open, readdir, rename, rm, stat } from "node:fs/promises";
+import { cp, lstat, mkdir, mkdtemp, open, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import type { Dirent } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
@@ -112,10 +112,6 @@ export function sessionsDir(workspace: string, override?: string): string {
   return join(workspace, ".xeno", "sessions");
 }
 
-export function legacyLogDir(workspace: string): string {
-  return join(workspace, ".xeno", "log");
-}
-
 /**
  * `<base36 ms>-<4 digit base36 random>`.
  *
@@ -141,6 +137,8 @@ export async function createSession(
 ): Promise<{ id: string; path: string }> {
   const dir = sessionsDir(workspace, sessionDir);
   await mkdir(dir, { recursive: true });
+  // The first session makes the state directory exist; keep it out of git from that moment.
+  await ignoreStateDir(dirname(dir));
   for (let attempt = 0; attempt < MAX_ID_ATTEMPTS; attempt++) {
     const id = formatSessionId(clock.nowMs(), clock.random());
     const path = join(dir, id);
@@ -193,21 +191,6 @@ export async function listSessions(workspace: string, sessionDir?: string, limit
   return { sessions, truncated };
 }
 
-/**
- * A leftover `.xeno/log` is not migrated. Moving someone else's data cannot
- * be a startup side effect; the person keeps using it by pointing `--log`
- * at it. Once `.xeno/sessions/` exists they are already in the new layout
- * and the leftover is just leftover, so the notice stays quiet.
- */
-export async function legacyLogNotice(workspace: string): Promise<string | null> {
-  if (!(await isDirectory(legacyLogDir(workspace)))) return null;
-  if (await isDirectory(sessionsDir(workspace))) return null;
-  return (
-    "This workspace still has a log at .xeno/log from before named sessions existed. " +
-    "It has not been moved. Continue it with --log .xeno/log"
-  );
-}
-
 export type SessionPrefixMatch =
   | { ok: true; session: Extract<ListedSession, { ok: true }> }
   | { ok: false; reason: string; candidates: string[] };
@@ -352,46 +335,44 @@ export interface ResolveLogOpts extends SessionEntryFlags {
 export async function resolveLogDir(
   workspace: string,
   opts: ResolveLogOpts = {},
-): Promise<{ logDir: string; created: boolean; legacyNotice: string | null }> {
+): Promise<{ logDir: string; created: boolean }> {
   const entry = planSessionEntry(opts);
-  // Computed first: createSession will mkdir `.xeno/sessions/`, after which
-  // the leftover-log condition is no longer true.
-  const legacyNotice = await legacyLogNotice(workspace);
   switch (entry.kind) {
     case "named": {
       const root = sessionsDir(workspace, opts.sessionDir), logDir = join(root, entry.id);
       await mkdir(root, { recursive: true });
-      try { await mkdir(logDir); return { logDir, created: true, legacyNotice }; }
+      await ignoreStateDir(dirname(root));
+      try { await mkdir(logDir); return { logDir, created: true }; }
       catch (error) {
         if ((error as { code?: string }).code !== "EEXIST" || !(await lstat(logDir)).isDirectory()) throw error;
-        return { logDir, created: false, legacyNotice };
+        return { logDir, created: false };
       }
     }
     case "ephemeral": {
       const logDir = await mkdtemp(join(tmpdir(), "xeno-nosession-"));
-      return { logDir, created: true, legacyNotice };
+      return { logDir, created: true };
     }
     case "open": {
-      if (entry.explicit) return { logDir: entry.target, created: false, legacyNotice };
+      if (entry.explicit) return { logDir: entry.target, created: false };
       const archive = resolve(workspace, entry.target);
       if (await stat(archive).then(info => info.isFile(), () => false)) {
-        return { logDir: await importSessionArchive(archive, sessionsDir(workspace, opts.sessionDir), workspace), created: true, legacyNotice };
+        return { logDir: await importSessionArchive(archive, sessionsDir(workspace, opts.sessionDir), workspace), created: true };
       }
       const found = await findSessionByPrefix(workspace, entry.target, opts.sessionDir);
       if (!found.ok) throw new Error(found.reason);
-      return { logDir: found.session.path, created: false, legacyNotice };
+      return { logDir: found.session.path, created: false };
     }
     case "fork": {
       const found = await findSessionByPrefix(workspace, entry.target, opts.sessionDir);
       if (!found.ok) throw new Error(found.reason);
       const created = await createSession(workspace, systemIdClock, opts.sessionDir);
       await copyAncestryTo(found.session.path, created.path, new Date().toISOString());
-      return { logDir: created.path, created: true, legacyNotice };
+      return { logDir: created.path, created: true };
     }
     case "continue": {
       const { sessions } = await listSessions(workspace, opts.sessionDir, Infinity);
       const newest = sessions.find((s) => s.ok);
-      if (newest !== undefined) return { logDir: newest.path, created: false, legacyNotice };
+      if (newest !== undefined) return { logDir: newest.path, created: false };
       break;
     }
     case "select":
@@ -400,7 +381,7 @@ export async function resolveLogDir(
     default: return assertNever(entry, "resolveLogDir");
   }
   const created = await createSession(workspace, systemIdClock, opts.sessionDir);
-  return { logDir: created.path, created: true, legacyNotice };
+  return { logDir: created.path, created: true };
 }
 
 async function existingDir(workspace: string, prefix: string): Promise<string | null> {
@@ -482,3 +463,20 @@ async function isDirectory(path: string): Promise<boolean> {
     throw err;
   }
 }
+
+/**
+ * Keeps a state directory out of `git status` the way pytest, ruff and mypy
+ * keep their caches out: a `.gitignore` holding `*` inside the directory
+ * itself. Checks people and models write ("only plan.md changed") read git,
+ * and a visible session directory made such a check fail forever
+ * (fix-state-dir-self-ignore). The user's own ignore files are never edited,
+ * and .git/info/exclude is avoided: worktrees do not read it, and a sandboxed
+ * agent could use it to hide files. An existing file is left alone; failure
+ * to write one never blocks a session.
+ */
+export async function ignoreStateDir(stateRoot: string): Promise<void> {
+  try {
+    await mkdir(stateRoot, { recursive: true });
+    await writeFile(join(stateRoot, ".gitignore"), "# Created by xeno: session state is not project source.\n*\n", { flag: "wx" });
+  } catch { /* present already, or not writable: either way nothing to do */ }
+}

package/src/store/workspace-clone.ts

@@ -0,0 +1,42 @@
+/**
+ * A disposable copy of a workspace, for running a check somewhere it cannot
+ * touch the real files (feat-counter-check).
+ *
+ * Copy-on-write where the filesystem offers it -- APFS clonefile through
+ * `cp -c`, reflinks through `cp --reflink=auto` -- so a workspace with large
+ * dependency trees costs metadata, not bytes. Where it does not, cp falls back
+ * to a real copy, bounded by the deadline below.
+ */
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Assumed, not measured: a clone is metadata-only on APFS and reflink
+ * filesystems; a full copy that takes longer than this is better reported as
+ * unavailable than waited on.
+ */
+export const CLONE_TIMEOUT_MS = 60_000;
+
+export type WorkspaceClone = { ok: true; path: string; dispose: () => Promise<void> } | { ok: false; reason: string };
+
+export async function cloneWorkspace(root: string, signal?: AbortSignal): Promise<WorkspaceClone> {
+  const parent = await mkdtemp(join(tmpdir(), "xeno-counter-check-")), path = join(parent, "workspace");
+  const dispose = () => rm(parent, { recursive: true, force: true });
+  const attempts = process.platform === "darwin" ? [["cp", "-cR", root, path], ["cp", "-R", root, path]] : [["cp", "-a", "--reflink=auto", root, path]];
+  let reason = "the workspace could not be copied";
+  for (const argv of attempts) {
+    if (signal?.aborted) { await dispose(); return { ok: false, reason: "cancelled" }; }
+    await rm(path, { recursive: true, force: true });
+    const child = Bun.spawn(argv, { stdout: "ignore", stderr: "pipe" });
+    const timer = setTimeout(() => child.kill(), CLONE_TIMEOUT_MS);
+    const abort = () => child.kill();
+    signal?.addEventListener("abort", abort, { once: true });
+    const [exit, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    clearTimeout(timer); signal?.removeEventListener("abort", abort);
+    if (exit === 0) return { ok: true, path, dispose };
+    reason = child.signalCode ? `copying the workspace exceeded ${CLONE_TIMEOUT_MS / 1000}s` : `the workspace could not be copied: ${stderr.trim().split("\n").at(-1) ?? `exit ${exit}`}`;
+  }
+  await dispose();
+  return { ok: false, reason };
+}

package/src/store/workspace.ts

@@ -1,32 +1,18 @@
 /**
- * Workspace scanning, reconciliation and restore.
+ * A bounded content scan of a workspace: relative path -> digest, and one
+ * version digest over the whole set.
  *
- * The tree can move a cursor between nodes; this is what lets the files move
- * with it. Two properties shape everything here:
- *
- *   TURN GRANULARITY. The workspace is scanned once per turn, not per tool
- *   call. Per-call is too fine to be meaningful -- the documented criticism
- *   of character-level versioning is that a single keystroke is not a change
- *   -- and a turn is the same unit as "a message and the edit it produced".
- *
- *   TWO INDEPENDENT SOURCES. A tool's effect says what the tool CLAIMED to
- *   do; a scan says what ACTUALLY changed. bash can write anywhere and its
- *   effect records only an exit code, so without the scan an edit outside
- *   every declared path would be invisible -- and a restore would silently
- *   fail to undo it. Comparing the two makes that detectable, which is the
- *   same rule the handoff applies to the model: claims are checked, not
- *   believed.
- *
- * A restore moves the workspace and nothing else. Migrations, sent requests
- * and started processes do not come back, and applyRestore says so rather
- * than implying it undid the world.
+ * Session file history no longer comes from per-turn scans. P.3 replaced them
+ * with journaled checkpoints and source fingerprints (workspace-observation.ts,
+ * WorkspaceLifecycle), and S.3 removed the compatibility mode that still
+ * scanned. What remains is the scanner itself and the default ignore list the
+ * search and file index share.
  */
 
-import { readdir, rm, stat, lstat } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import type { Dirent } from "node:fs";
-import { join, dirname, relative, sep, isAbsolute } from "node:path";
-import type { Effect } from "../core/events.ts";
-import { blobAddress, digestFile, verifyBlob, restoreBlob } from "./blobs.ts";
+import { join, relative, sep } from "node:path";
+import { blobAddress, digestFile } from "./blobs.ts";
 
 export interface ScanLimits {
   maxFiles: number;
@@ -68,28 +54,6 @@ export type ScanResult =
   | { ok: true; files: FileSet }
   | { ok: false; error: string };
 
-export interface ScanDelta {
-  added: FileSet;
-  changed: FileSet;
-  removed: string[];
-}
-
-export interface Reconciliation {
-  /** Changed on disk with no tool claiming it -- usually a shell command. */
-  undeclared: string[];
-  /** A tool claimed an edit the disk does not show. */
-  declaredButUnchanged: string[];
-}
-
-export interface RestoreResult {
-  restored: string[];
-  removed: string[];
-  /** Target files whose content is no longer in the blob store. */
-  unrecoverable: string[];
-  /** What this restore did not and could not touch. */
-  note: string;
-}
-
 function isIgnored(rel: string, ignore: readonly string[]): boolean {
   const parts = rel.split(sep);
   return ignore.some((i) => parts.includes(i));
@@ -149,114 +113,3 @@ export async function scanWorkspace(
     return error ? { ok: false, error } : { ok: true, files };
   } catch (error) { return { ok: false, error: `incomplete workspace scan: ${String(error)}` }; }
 }
-
-export function diffScans(before: FileSet, after: FileSet): ScanDelta {
-  const added: FileSet = {};
-  const changed: FileSet = {};
-  const removed: string[] = [];
-
-  for (const [path, sha] of Object.entries(after)) {
-    const was = before[path];
-    if (was === undefined) added[path] = sha;
-    else if (was !== sha) changed[path] = sha;
-  }
-  for (const path of Object.keys(before)) {
-    if (!(path in after)) removed.push(path);
-  }
-  return { added, changed, removed: removed.sort() };
-}
-
-export function reconcile(effects: readonly Effect[], observed: ScanDelta): Reconciliation {
-  // Only edits claim to change the workspace. A read claims nothing, and a
-  // command claims only its exit code -- which is exactly why the scan is
-  // needed to see what a command did.
-  const declared = new Set(
-    effects.filter((e) => e.kind === "edit").map((e) => e.path),
-  );
-  const touched = [
-    ...Object.keys(observed.added),
-    ...Object.keys(observed.changed),
-    ...observed.removed,
-  ];
-
-  return {
-    undeclared: touched.filter((p) => !declared.has(p)).sort(),
-    declaredButUnchanged: [...declared].filter((p) => !touched.includes(p)).sort(),
-  };
-}
-
-/**
- * Replays deltas up to and including `toNode` to get the file set at that
- * point. Pure, so a restore can be planned and inspected before anything is
- * written.
- */
-export function planRestore(
-  deltas: readonly (ScanDelta & { node: number })[],
-  toNode: number,
-): FileSet {
-  const files: FileSet = {};
-  for (const d of deltas) {
-    if (d.node > toNode) break;
-    for (const [path, sha] of Object.entries(d.added)) files[path] = sha;
-    for (const [path, sha] of Object.entries(d.changed)) files[path] = sha;
-    for (const path of d.removed) delete files[path];
-  }
-  return files;
-}
-
-export async function applyRestore(
-  root: string,
-  store: string,
-  target: FileSet,
-  ignore: readonly string[],
-): Promise<RestoreResult> {
-  const restored: string[] = [];
-  const unrecoverable: string[] = [];
-
-  // Validate the complete plan before its first write or deletion. Missing
-  // objects and a failed scan cannot be interpreted as an empty target (H).
-  const current = await scanWorkspace(root, ignore);
-  if (!current.ok) throw new Error(current.error);
-  for (const [path, sha] of Object.entries(target)) {
-    if (isAbsolute(path) || path.split(/[\\/]/).some((p) => p === "..") || isIgnored(path, ignore)) {
-      throw new Error(`unsafe restore path: ${path}`);
-    }
-    let parent = dirname(join(root, path));
-    while (parent !== root && parent.startsWith(root + sep)) {
-      try { if ((await lstat(parent)).isSymbolicLink()) throw new Error(`restore path crosses symlink: ${path}`); }
-      catch (error) { if ((error as { code?: string }).code !== "ENOENT") throw error; }
-      parent = dirname(parent);
-    }
-    if (!await verifyBlob(store, sha)) unrecoverable.push(path);
-  }
-  if (unrecoverable.length > 0) return {
-    restored: [], removed: [], unrecoverable: unrecoverable.sort(),
-    note: "Restore not applied: missing snapshot objects. Workspace and cursor remain unchanged.",
-  };
-
-  for (const [path, sha] of Object.entries(target)) {
-    const abs = join(root, path);
-    await restoreBlob(store, sha, abs);
-    restored.push(path);
-  }
-
-  // Anything present but not in the target was created after this point.
-  const removed: string[] = [];
-  if (current.ok) {
-    for (const path of Object.keys(current.files)) {
-      if (path in target) continue;
-      await rm(join(root, path), { force: true });
-      removed.push(path);
-    }
-  }
-
-  return {
-    restored: restored.sort(),
-    removed: removed.sort(),
-    unrecoverable: unrecoverable.sort(),
-    note:
-      "Restored the workspace only. Anything outside it is not undone: " +
-      "database migrations, requests already sent, processes already " +
-      "started, and files outside the workspace root all remain as they are.",
-  };
-}

package/src/tui/ui/duration.ts

@@ -0,0 +1,16 @@
+/**
+ * Elapsed time as people read it (feat-sidebar-goal-and-speed): `59s`, then
+ * `1m 00s`, then `1h 01m 01s`. The steps are Codex's fmt_elapsed_compact; a
+ * running turn used to read `3725s`.
+ *
+ * Every field after the first is two digits, so a running clock keeps its
+ * width within a unit instead of jittering the labels beside it. Parts of a
+ * second never round up: the clock shows seconds that have fully passed.
+ */
+export function formatElapsed(ms: number): string {
+  const total = Number.isFinite(ms) && ms > 0 ? Math.floor(ms / 1000) : 0;
+  if (total < 60) return `${total}s`;
+  const seconds = String(total % 60).padStart(2, "0");
+  if (total < 3600) return `${Math.floor(total / 60)}m ${seconds}s`;
+  return `${Math.floor(total / 3600)}h ${String(Math.floor(total % 3600 / 60)).padStart(2, "0")}m ${seconds}s`;
+}

package/src/tui/ui/layout.ts

@@ -48,7 +48,7 @@ export function screenLayout(cols: number, rows: number, sidebarWanted = true):
   return { tier: "bare", sidebarWidth: 0, mainWidth: c, topbar: false };
 }
 
-export const STATUS_FIELDS = ["mode", "provider", "activity", "git", "model", "thinking", "context", "title", "workspace", "branch", "usage", "cost", "handoff", "tasks", "files", "background", "resources", "extension"] as const;
+export const STATUS_FIELDS = ["mode", "provider", "activity", "git", "model", "thinking", "context", "goal", "title", "workspace", "branch", "usage", "cost", "handoff", "tasks", "files", "background", "resources", "extension"] as const;
 export type StatusField = (typeof STATUS_FIELDS)[number];
 /** Screen surfaces only; the terminal title is outside the frame and listed separately. */
 export type Place = "sidebar" | "topbar" | "topEdge" | "bottomEdge" | "hidden";
@@ -61,13 +61,13 @@ export type Place = "sidebar" | "topbar" | "topEdge" | "bottomEdge" | "hidden";
 export function placement(tier: Tier): Readonly<Record<StatusField, Place>> {
   switch (tier) {
     case "sidebar":
-      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "sidebar", model: "bottomEdge", thinking: "bottomEdge", context: "sidebar", title: "sidebar", workspace: "sidebar", branch: "sidebar",
+      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "sidebar", model: "bottomEdge", thinking: "bottomEdge", context: "sidebar", goal: "sidebar", title: "sidebar", workspace: "sidebar", branch: "sidebar",
         usage: "sidebar", cost: "sidebar", handoff: "sidebar", tasks: "sidebar", files: "sidebar", background: "sidebar", resources: "sidebar", extension: "sidebar" };
     case "topbar":
-      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", title: "topbar", workspace: "topbar", branch: "topbar",
+      return { mode: "bottomEdge", provider: "topbar", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", goal: "bottomEdge", title: "topbar", workspace: "topbar", branch: "topbar",
         usage: "hidden", cost: "topbar", handoff: "topbar", tasks: "hidden", files: "hidden", background: "topbar", resources: "hidden", extension: "topbar" };
     case "bare":
-      return { mode: "bottomEdge", provider: "hidden", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", title: "hidden", workspace: "hidden", branch: "hidden",
+      return { mode: "bottomEdge", provider: "hidden", activity: "topEdge", git: "hidden", model: "bottomEdge", thinking: "bottomEdge", context: "bottomEdge", goal: "bottomEdge", title: "hidden", workspace: "hidden", branch: "hidden",
         usage: "hidden", cost: "hidden", handoff: "hidden", tasks: "hidden", files: "hidden", background: "hidden", resources: "hidden", extension: "hidden" };
     default: return assertNever(tier, "placement");
   }

package/src/tui/ui/screen.ts

@@ -31,8 +31,9 @@ import { screenLayout, sidebarContentWidth, type ScreenLayout } from "./layout.t
 import { greetingLines, mascotFrame, MASCOT_FRAME_MS, MASCOT_FRAMES, type Greeting } from "./mascot.ts";
 import { MessageList, type MessageFeatures } from "./messages.ts";
 import { Motion } from "./motion.ts";
-import { contextLabel, modeLabels, sidebarLines, topbarRow, type Line, type StatusModel } from "./status.ts";
+import { contextLabel, goalLabel, modeLabels, sidebarLines, speedText, topbarRow, type Line, type StatusModel } from "./status.ts";
 import { DEFAULT_CELL, stripImageRows } from "./image-size.ts";
+import { formatElapsed } from "./duration.ts";
 import { Pictures, type PictureSource } from "./pictures.ts";
 import type { ImageView, ViewItem } from "./items.ts";
 
@@ -376,11 +377,14 @@ export class Screen {
       // to recover on the existing edge, without putting control content in it.
       left = [{ segs: [{ text: "Resize for control", role: "accent" }], priority: 0, min: 1 }];
     } else if (d.busy) {
-      const seconds = Math.max(0, Math.floor((Date.now() - this.busySince) / 1000));
+      const elapsed = formatElapsed(Date.now() - this.busySince);
       const activity = this.status?.activity;
       const label = activity ? `${activity.label}${activity.label === "Running tool" || activity.label === "Retrying" ? ` · ${activity.detail}` : ""}${activity.queued ? ` · ${activity.queued} queued` : ""}` : d.activity;
       const transient = this.transientActivity ? ` · ${this.transientActivityText()}` : "";
-      left = [{ segs: [{ text: "●", role: "accent", spin: activity?.state !== "blocked" }, { text: ` ${label}${transient}`, role: activity?.state === "blocked" ? "warning" : "muted" }, { text: ` ${seconds}s`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
+      left = [{ segs: [{ text: "●", role: "accent", spin: activity?.state !== "blocked" }, { text: ` ${label}${transient}`, role: activity?.state === "blocked" ? "warning" : "muted" }, { text: ` ${elapsed}`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
+      // The turn's speed so far, refreshed after each model request (runtime/usage.ts generationSpeed).
+      const speed = this.status?.usage?.speed;
+      if (speed !== undefined) right.push({ segs: [{ text: speedText(speed), role: "muted" }], priority: 3 });
       right.push({ segs: [{ text: "esc interrupt", role: "muted" }], priority: 4 });
     } else if (this.transientActivity) {
       left = [{ segs: [{ text: "●", role: "accent", spin: true }, { text: ` ${this.transientActivityText()}`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
@@ -396,8 +400,10 @@ export class Screen {
       { segs: [{ text: d.model, role: "text" as const, bold: true }], priority: 1, min: 8 },
       ...(d.thinking ? [{ segs: [{ text: d.thinking, role: "muted" as const }], priority: 2 }] : []),
     ] : [])];
+    // Without a sidebar the goal and the context share ride on this edge (layout.ts placement).
     const context = this.shape.tier !== "sidebar" && this.status ? contextLabel(this.status) : undefined;
-    this.bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"], role, left: bottomLeft, right: context ? [context] : [] })]);
+    const goal = this.shape.tier !== "sidebar" && this.status ? goalLabel(this.status) : undefined;
+    this.bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"], role, left: bottomLeft, right: [...(goal ? [goal] : []), ...(context ? [context] : [])] })]);
   }
 
   /** A stream event arrived (delta, tool progress, shell output): the spinner returns to full speed. */
@@ -426,9 +432,9 @@ export class Screen {
 
   private transientActivityText(): string {
     const activity = this.transientActivity!;
-    const elapsed = Math.max(0, Math.floor((Date.now() - activity.startedAt) / 1000));
-    const deadline = Math.max(1, Math.ceil(activity.timeoutMs / 1000));
-    return `${activity.label} · ${elapsed}s / ${deadline}s max${activity.detail ? ` · ${activity.detail}` : ""}`;
+    // The limit is a whole number of seconds, rounded up so it is never shown shorter than it is.
+    const deadline = Math.max(1, Math.ceil(activity.timeoutMs / 1000)) * 1000;
+    return `${activity.label} · ${formatElapsed(Date.now() - activity.startedAt)} / ${formatElapsed(deadline)} max${activity.detail ? ` · ${activity.detail}` : ""}`;
   }
 
   /** The spinner's current interval (tests). */