@visual-z/xeno 0.6.0 → 0.7.0

package/src/runtime/provider.ts

@@ -39,6 +39,7 @@ import type { UsageSample } from "./usage.ts";
 import { type Effort, type ModelSpec, CLAUDE_OPUS_5 } from "./model.ts";
 import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
 import { anthropicOAuthHeaders } from "./oauth.ts";
+import type { ProviderSendOptions } from "./provider-tool-policy.ts";
 
 export interface ToolSchema {
   name: string;
@@ -106,6 +107,7 @@ export interface Provider {
     node: number,
     signal?: AbortSignal,
     onDelta?: OnDelta,
+    options?: ProviderSendOptions,
   ): Promise<Turn>;
 }
 
@@ -235,9 +237,10 @@ export class AnthropicProvider implements Provider {
     node: number,
     signal?: AbortSignal,
     onDelta?: OnDelta,
+    options?: ProviderSendOptions,
   ): Promise<Turn> {
     return withRetry(
-      () => this.attempt(frozen, messages, node, signal, onDelta),
+      () => this.attempt(frozen, messages, node, signal, onDelta, options),
       this.retry,
       undefined,
       (attempt, delayMs, error) => {
@@ -257,6 +260,7 @@ export class AnthropicProvider implements Provider {
     node: number,
     signal?: AbortSignal,
     onDelta?: OnDelta,
+    options?: ProviderSendOptions,
   ): Promise<Turn> {
     const started = Date.now();
 
@@ -277,6 +281,7 @@ export class AnthropicProvider implements Provider {
         // Auto-caching walks the breakpoint forward over the growing tail.
         cache_control: { type: "ephemeral" },
         tools: frozen.tools as Anthropic.Tool[],
+        ...(options?.toolUse === "disabled" ? { tool_choice: { type: "none" as const } } : {}),
         // Only a reasoning model understands these. An older Claude, or an
         // Anthropic-compatible endpoint serving some other model, answers
         // them with a 400 or silently ignores them.

package/src/runtime/session-control.ts

@@ -164,6 +164,7 @@ export class SessionControl {
     // Assumed ingress bound, not an execution policy. Keep a client from queuing unbounded work.
     if (turn.queue.length >= 32) throw Error("steering queue is full");
     turn.queue.push(structuredClone(input));
+    this.session.wakeProcessWaits();
     this.emit("turn/steeringQueued", { count: turn.queue.length });
   }
   interrupt(turnId: string): void {

package/src/runtime/tools.ts

@@ -127,6 +127,9 @@ export interface ToolContext {
   historyCache?: HistoryCache;
   /** O.14: opaque process ownership is supplied by Session, never by model input. */
   execOwner?: string;
+  /** Session-owned empty stdin waits; low-level/native callers retain bounded polling. */
+  processWait?: { wake(): AbortSignal };
+  onProcessWait?: (session: number, active: boolean) => void;
   /** Session-owned registrations never mutate the built-in table (D13). */
   extensions?: ReadonlyMap<string, ToolDefinition>;
   /** R11: current locally selected optional schemas, never restored as authority from historical text. */
@@ -629,7 +632,7 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
     access: "shell", execution: "exclusive", branch: "write", run: toolWriteStdin,
     description:
       "Send characters to an owned running process handle and return the output since the last call. " +
-      "Empty chars polls. Include \\n to submit a line; \\u0003 is Ctrl-C, \\u0004 is Ctrl-D (end of input). " +
+      "In an agent session, empty chars waits for new output, exit, hard timeout, cancellation or user steering without periodic model polling. Include \\n to submit a line; \\u0003 is Ctrl-C, \\u0004 is Ctrl-D (end of input). " +
       "After exit, empty chars retrieves the last receipt without rerunning or producing fresh verification. Source and byte cursor are in data; full_output recovers all captured output. " +
       "Lost handles cannot accept input; a last running observation is not an exit. Ctrl-C may interrupt a PTY foreground job while its REPL stays alive.",
     input_schema: {
@@ -637,7 +640,7 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
       properties: {
         session_id: { type: "integer", minimum: 1 },
         chars: { type: "string", description: "Characters to write; empty to poll" },
-        yield_time_ms: { type: "integer", minimum: 100, maximum: 30000, description: "Milliseconds to wait for output; default 10000" },
+        yield_time_ms: { type: "integer", minimum: 100, maximum: 30000, description: "Bounded wait when sending input or using low-level polling; agent empty waits are owned until an observation changes" },
       },
       required: ["session_id"],
     },
@@ -1108,7 +1111,8 @@ async function toolWriteStdin(ctx: ToolContext, input: Record<string, unknown>):
       data: { kind: "process", version: 1, session_id: id, state: "unknown", capability: "unknown", source: null, running: null, exit: null, replayed: true } };
   }
   const outputStore = ctx.outputStore ?? join(ctx.root, ".xeno", "observations");
-  return sessionResult(ctx, session.command, session.timeoutMs, await pollSession(session, outputStore, ctx.maxOutputBytes, clampYield(input["yield_time_ms"]), chars, ctx.signal));
+  return sessionResult(ctx, session.command, session.timeoutMs, await pollSession(session, outputStore, ctx.maxOutputBytes, clampYield(input["yield_time_ms"]), chars, ctx.signal,
+    ctx.processWait && chars.length === 0 ? { wake: ctx.processWait.wake(), onWaiting: active => ctx.onProcessWait?.(id, active) } : undefined));
 }
 
 /** A successful historical query proves only that the receipt was found, never a new command exit. */

package/src/store/blobs.ts

@@ -121,8 +121,9 @@ export async function getBlob(dir: string, sha: string): Promise<string | null>
 }
 
 /** Restore uses bytes; decoding binary data is an irreversible transformation. */
-export async function getBlobBytes(dir: string, sha: string): Promise<Uint8Array | null> {
+export async function getBlobBytes(dir: string, sha: string, maxBytes?: number): Promise<Uint8Array | null> {
   try {
+    if (maxBytes !== undefined && (await stat(blobFilePath(dir, sha))).size > maxBytes) throw new RangeError("Blob exceeds byte limit");
     const bytes = await readFile(blobFilePath(dir, sha));
     if (blobAddress(bytes) !== sha) throw new Error(`blob integrity failure: ${sha}`);
     return bytes;

package/src/store/git-status.ts

@@ -0,0 +1,15 @@
+/** Local Git reads are asynchronous and bounded; a paint never launches a process. */
+import { execFile } from "node:child_process";
+import { parseGitStatus, type GitStatus } from "../core/git-status.ts";
+/** Assumed cold-disk allowance; Git failure remains unavailable rather than "clean". */
+const GIT_STATUS_TIMEOUT_MS = 1000;
+/** A busy repository cannot flood memory or the status view with paths. */
+const GIT_STATUS_MAX_BYTES = 1024 * 1024;
+
+export function readGitStatus(cwd: string): Promise<GitStatus | null> {
+  return new Promise(resolve => {
+    execFile("git", ["--no-optional-locks", "status", "--porcelain=v2", "--branch", "-z", "--untracked-files=normal"],
+      { cwd, timeout: GIT_STATUS_TIMEOUT_MS, maxBuffer: GIT_STATUS_MAX_BYTES, encoding: "utf8" },
+      (error, output) => resolve(error ? null : parseGitStatus(output)));
+  });
+}

package/src/tui/ui/layout.ts

@@ -1,7 +1,7 @@
 /**
  * Where status lives at a given terminal size (docs/tasks/refactor-tui-dock-layout.md). Pure.
  *
- *   sidebar  ≥ 110 cols and ≥ 20 rows   right column; the top bar is not shown
+ *   sidebar  ≥ 110 cols and ≥ 20 rows   right column plus compact provider header
  *   topbar   80–109 cols, or a wide but short terminal (≥ 18 rows)   one row on top
  *   bare     everything else            the input box's bottom edge only;
  *                                       session and branch go to the terminal title
@@ -42,16 +42,16 @@ export function screenLayout(cols: number, rows: number, sidebarWanted = true):
   const c = Math.max(0, Math.floor(cols)), r = Math.max(0, Math.floor(rows));
   if (sidebarWanted && c >= SIDEBAR_MIN_COLUMNS && r >= SIDEBAR_MIN_ROWS) {
     const sidebarWidth = sidebarContentWidth(c) + 1;
-    return { tier: "sidebar", sidebarWidth, mainWidth: c - sidebarWidth, topbar: false };
+    return { tier: "sidebar", sidebarWidth, mainWidth: c - sidebarWidth, topbar: true };
   }
   if (c >= TOPBAR_MIN_COLUMNS && r >= TOPBAR_MIN_ROWS) return { tier: "topbar", sidebarWidth: 0, mainWidth: c, topbar: true };
   return { tier: "bare", sidebarWidth: 0, mainWidth: c, topbar: false };
 }
 
-export const STATUS_FIELDS = ["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", "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" | "bottomEdge" | "hidden";
+export type Place = "sidebar" | "topbar" | "topEdge" | "bottomEdge" | "hidden";
 
 /**
  * The one place each field takes in a tier. Hidden fields stay one command
@@ -61,13 +61,13 @@ export type Place = "sidebar" | "topbar" | "bottomEdge" | "hidden";
 export function placement(tier: Tier): Readonly<Record<StatusField, Place>> {
   switch (tier) {
     case "sidebar":
-      return { 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", 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 { 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", 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 { 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", 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/messages.ts

@@ -34,7 +34,7 @@ export interface MessageFeatures {
 }
 
 /** Without a source (tests, print mode) pictures are named, not drawn. */
-const NO_PICTURES: PictureSource = { mode: "chip", protocol: "blocks", cell: DEFAULT_CELL, widthCells: 60, load: async () => null };
+const NO_PICTURES: PictureSource = { mode: "chip", protocol: "blocks", cell: DEFAULT_CELL, widthCells: 60, load: async () => ({ kind: "error", reason: "closed" }) };
 
 interface Entry { rev: string; node: Renderable; item: ViewItem }
 

package/src/tui/ui/pictures.ts

@@ -13,7 +13,7 @@
 import { BoxRenderable, ImageRenderable, type CliRenderer, type ImageRenderProtocol, type NativeImage } from "@opentui/core";
 import { Canvas } from "./canvas.ts";
 import type { UiColors } from "./colors.ts";
-import type { Seg } from "./edge.ts";
+import { splitLine, type Seg } from "./edge.ts";
 import { imageCells, IMAGES_PER_ITEM } from "./image-size.ts";
 import type { ImageView } from "./items.ts";
 
@@ -25,10 +25,14 @@ export interface PictureSource {
   readonly cell: { readonly width: number; readonly height: number };
   /** The widest a picture may be, in cells (`terminal.imageWidthCells`). */
   readonly widthCells: number;
-  /** The decoded picture for a blob, shared by every node that shows it; null when it cannot be shown. */
-  load(sha256: string): Promise<NativeImage | null>;
+  readonly reason?: string;
+  /** The decoded picture for a blob, shared by every node that shows it, or its preparation failure. */
+  load(sha256: string): Promise<PictureLoad>;
 }
 
+export type PictureLoad = { readonly kind: "ready"; readonly image: NativeImage } |
+  { readonly kind: "error"; readonly reason: "missing" | "corrupt" | "decode" | "limit" | "busy" | "closed" };
+
 let serial = 0;
 
 export function chipLine(images: readonly ImageView[], limit: number): Seg[] {
@@ -52,17 +56,31 @@ export class Pictures extends BoxRenderable {
     const limit = options.limit ?? IMAGES_PER_ITEM;
     const shown = images.slice(0, limit);
     const pictures: ImageRenderable[] = [];
+    const states = shown.map(() => source.mode === "picture" ? "preparing" : source.reason ?? "preview unavailable");
+    const caption = new Canvas(ctx, { id: `${id}-caption`, height: Math.max(1, shown.length), flexShrink: 0, colors });
+    // A long filename must not hide the preparation state or the reason a preview failed.
+    const paintCaption = () => caption.setRows(shown.length ? shown.map((image, i) => splitLine(options.maxCols, [
+      { segs: [{ text: "▣ ", role: "muted" }, { text: image.name, role: "text" }], priority: 0, min: 4, shrinkPriority: 5 },
+      { segs: [{ text: `${image.width}×${image.height}`, role: "muted" }], priority: 3 },
+      ...(i === shown.length - 1 && images.length > shown.length ? [{ segs: [{ text: `+${images.length - shown.length} more`, role: "muted" as const }], priority: 4 }] : []),
+    ], [{ segs: [{ text: states[i]!, role: states[i]?.startsWith("preview failed") ? "warning" : "muted" }], priority: 0 }], 1, [{ text: " · ", role: "muted" }])) : [chipLine(images, limit)]);
     if (source.mode === "picture" && shown.length) {
       const row = new BoxRenderable(ctx, { id: `${id}-row`, flexDirection: "row", flexShrink: 0, columnGap: 1 });
       // Pictures share the width; each keeps its own proportions.
       const each = Math.max(1, Math.floor((Math.min(options.maxCols, source.widthCells * shown.length) - (shown.length - 1)) / shown.length));
-      for (const image of shown) {
+      for (const [index, image] of shown.entries()) {
         const size = imageCells(image, Math.min(each, source.widthCells), options.maxRows, source.cell);
         const picture = new ImageRenderable(ctx, { id: `${id}-${image.sha256.slice(0, 8)}-${serial++}`, width: size.cols, height: size.rows,
-          fit: "fit", protocol: source.protocol, flexShrink: 0 });
-        void source.load(image.sha256).then(native => {
+          fit: "fit", protocol: source.protocol, flexShrink: 0,
+          onLoad: () => { states[index] = "decoded"; if (!caption.isDestroyed) paintCaption(); },
+          onError: () => { states[index] = "preview failed: decode"; picture.visible = false; if (!caption.isDestroyed) paintCaption(); } });
+        void source.load(image.sha256).then(result => {
+          if (picture.isDestroyed) return;
+          if (result.kind === "ready") picture.source = result.image;
+          else { picture.visible = false; states[index] = `preview failed: ${result.reason}`; paintCaption(); }
+        }).catch(() => {
           if (picture.isDestroyed) return;
-          if (native) picture.source = native; else picture.visible = false;
+          picture.visible = false; states[index] = "preview failed: decode"; paintCaption();
         });
         pictures.push(picture);
         row.add(picture);
@@ -71,8 +89,7 @@ export class Pictures extends BoxRenderable {
     }
     this.pictures = pictures;
     // The names stay visible beside the pictures (and stand in for them in chip mode).
-    const caption = new Canvas(ctx, { id: `${id}-caption`, height: 1, flexShrink: 0, colors });
-    caption.setRows([chipLine(images, source.mode === "picture" ? shown.length : limit)]);
+    paintCaption();
     this.add(caption);
   }
 }

package/src/tui/ui/screen.ts

@@ -31,7 +31,7 @@ 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, sidebarLines, topbarRow, type Line, type StatusModel } from "./status.ts";
+import { contextLabel, modeLabels, sidebarLines, topbarRow, type Line, type StatusModel } from "./status.ts";
 import { DEFAULT_CELL, stripImageRows } from "./image-size.ts";
 import { Pictures, type PictureSource } from "./pictures.ts";
 import type { ImageView, ViewItem } from "./items.ts";
@@ -112,7 +112,7 @@ export class Screen {
   private queue: readonly string[] = [];
   private attachmentImages: readonly ImageView[] = [];
   private attachmentsKey = "";
-  private picturesSource: PictureSource = { mode: "chip", protocol: "blocks", cell: DEFAULT_CELL, widthCells: 60, load: async () => null };
+  private picturesSource: PictureSource = { mode: "chip", protocol: "blocks", cell: DEFAULT_CELL, widthCells: 60, load: async () => ({ kind: "error", reason: "closed" }) };
   private readonly attachments: BoxRenderable;
   private widgets: readonly string[] = [];
   private unread = 0;
@@ -317,7 +317,7 @@ export class Screen {
 
   private paintStatus(): void {
     const model = this.status;
-    if (model && this.topbar.visible) this.topbar.setRows([topbarRow(model, Math.max(1, this.renderer.width - 2))]);
+    if (model && this.topbar.visible) this.topbar.setRows([topbarRow(this.shape.tier === "sidebar" ? { ...model, title: null } : model, Math.max(1, this.renderer.width - 2))]);
     if (this.controlShown) {
       this.sidebar.borderColor = this.controlFocused ? this.colors.accent : this.colors.line;
       this.sidebarRows.setRows(this.controlView.rows(this.sidebarRows.width, this.sidebarRows.height, this.controlFocused));
@@ -327,7 +327,7 @@ export class Screen {
     if (!model) { this.sidebarRows.setRows([]); return; }
     if (this.sidebar.visible) {
       const width = Math.max(1, this.shape.sidebarWidth - 3);
-      this.sidebarRows.setRows(sidebarLines(model, width, Math.max(0, this.renderer.height - 1)));
+      this.sidebarRows.setRows(sidebarLines(model, width, Math.max(0, this.renderer.height - (this.shape.topbar ? 1 : 0) - 1)));
     }
   }
 
@@ -361,6 +361,7 @@ export class Screen {
     let left: Label[] = [];
     if (dialog) {
       left = [{ segs: [{ text: this.dialogs.title, role: "text", bold: true }], priority: 0, min: 8 }];
+      if (this.status?.activity?.state === "blocked") right.push({ segs: [{ text: this.status.activity.label, role: "warning" }], priority: 1, min: 8 });
       if (this.dialogs.edgeHint) right.push({ segs: [{ text: this.dialogs.edgeHint, role: "muted" }], priority: 3, min: 10 });
     } else if (this.controlShown && this.renderer.height <= 3) {
       // No transcript rows remain for a drawer. Keep its state and explain how
@@ -368,19 +369,22 @@ export class Screen {
       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));
-      left = [{ segs: [{ text: "●", role: "accent", spin: true }, { text: ` ${d.activity}`, role: "muted" }, { text: ` ${seconds}s`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
+      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;
+      left = [{ segs: [{ text: "●", role: "accent", spin: activity?.state !== "blocked" }, { text: ` ${label}`, role: activity?.state === "blocked" ? "warning" : "muted" }, { text: ` ${seconds}s`, role: "muted" }], priority: 0, min: 1, shrink: 1 }];
       right.push({ segs: [{ text: "esc interrupt", role: "muted" }], priority: 4 });
     } else {
       // A draft taller than the box says what scrolled out of view (fix-tui-composer-growth DoD 4).
       const { above, below } = this.composer.overflow;
       if (above) left = [{ segs: [{ text: `↑ ${above} more`, role: "muted" }], priority: 1 }];
       if (below && !this.toastText) right.push({ segs: [{ text: `↓ ${below} more`, role: "muted" }], priority: 2 });
+      if (!above && this.status?.activity) left = [{ segs: [{ text: this.status.activity.label, role: this.status.activity.state === "error" ? "error" : this.status.activity.state === "blocked" ? "warning" : "muted" }], priority: 1, min: 4 }];
     }
     this.topEdge.setRows([edgeLine({ width, corners: ["╭", "╮"], role, left, right })]);
-    const bottomLeft: Label[] = d.model ? [
-      { segs: [{ text: d.model, role: "text", bold: true }], priority: 0, min: 8 },
+    const bottomLeft: Label[] = [...(this.status ? modeLabels(this.status) : []), ...(d.model ? [
+      { 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 }] : []),
-    ] : [];
+    ] : [])];
     const context = this.shape.tier !== "sidebar" && this.status ? contextLabel(this.status) : undefined;
     this.bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"], role, left: bottomLeft, right: context ? [context] : [] })]);
   }

package/src/tui/ui/status.ts

@@ -34,6 +34,10 @@ export interface StatusModel {
   readonly workspace: string;
   readonly workspaceShort: string;
   readonly branch: string | null;
+  readonly mode?: { readonly yolo: boolean; readonly workflow: "build" | "plan" };
+  readonly provider?: { readonly name: string; readonly api: string; readonly host: string | null; readonly role: string | null; readonly ready: boolean };
+  readonly activity?: { readonly state: string; readonly label: string; readonly detail: string; readonly queued: number };
+  readonly git?: { readonly staged: number; readonly changed: number; readonly untracked: number; readonly conflicted: number; readonly ahead: number; readonly behind: number } | null;
   readonly context?: ContextStatus;
   readonly usage?: { readonly input: number; readonly output: number; readonly cacheRate: number; readonly cost: string | null };
   readonly tools: { readonly running: number; readonly done: number; readonly failed: number };
@@ -71,10 +75,18 @@ function shareSeg(context: ContextStatus): Seg | undefined {
   return { text: `${context.estimated ? "~" : ""}${Math.round(share * 100)}%`, role: share >= CONTEXT_WARNING ? "warning" : "text" };
 }
 
-/** The input box's bottom-right label where there is no sidebar: `ctx ~12%`. */
+/** The input box's bottom-right label names the measured budget: `seg ~12%` or `model ~12%`. */
 export function contextLabel(model: StatusModel): Label | undefined {
   const share = model.context && shareSeg(model.context);
-  return share ? { segs: [{ text: "ctx ", role: "muted" }, share], priority: 1 } : undefined;
+  return share ? { segs: [{ text: model.context?.trigger === null ? "model " : "seg ", role: "muted" }, share], priority: 3 } : undefined;
+}
+
+export function modeLabels(model: StatusModel): Label[] {
+  if (!model.mode) return [];
+  return [
+    { segs: [{ text: model.mode.yolo ? "YOLO" : "Approval", role: model.mode.yolo ? "warning" : "muted", bold: model.mode.yolo }], priority: 0 },
+    { segs: [{ text: model.mode.workflow === "plan" ? "Plan" : "Build", role: "accent" }], priority: 0 },
+  ];
 }
 
 export function terminalTitle(model: StatusModel): string {
@@ -91,6 +103,16 @@ function firstLine(text: string): string { return text.split("\n").find(line =>
  * row is narrow: location goes before counts, as OpenCode #570 asked.
  */
 export function topbarRow(model: StatusModel, width: number): Seg[] {
+  if (model.provider) {
+    const provider = model.provider;
+    return splitLine(width, [
+      { segs: [{ text: "xeno", role: "text", bold: true }], priority: 0 },
+      { segs: [{ text: `${provider.ready ? "" : "! "}${provider.name}`, role: provider.ready ? "text" : "warning" }], priority: 0, min: 6 },
+      { segs: [{ text: provider.api, role: "muted" }], priority: 2, min: 8 },
+      ...(provider.host ? [{ segs: [{ text: provider.host, role: "muted" as const }], priority: 3, min: 8 }] : []),
+      ...(provider.role ? [{ segs: [{ text: `agent ${provider.role}`, role: "accent" as const }], priority: 1, min: 8 }] : []),
+    ], model.title ? [{ segs: [{ text: firstLine(model.title), role: "muted" }], priority: 4, min: 12 }] : []);
+  }
   const left: Label[] = [
     { segs: [{ text: "xeno", role: "text", bold: true }], priority: 0 },
     // Never dropped, but gives up width after cost and background counts, before the handoff counts go.
@@ -175,6 +197,9 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
     ...title.map(text => [{ text, role: model.title ? "text" : "muted", bold: Boolean(model.title) }] as Line),
     [{ text: clipText(model.workspace, w), role: "muted" }],
     ...(model.branch ? [[{ text: "⎇ ", role: "muted" }, { text: model.branch, role: "muted" }] as Line] : []),
+    ...(model.git ? [[{ text: `${model.git.staged} staged · ${model.git.changed} changed · ${model.git.untracked} new`, role: "muted" }] as Line,
+      ...(model.git.conflicted ? [[{ text: `${model.git.conflicted} conflicts`, role: "warning" }] as Line] : []),
+      ...(model.git.ahead || model.git.behind ? [[{ text: `↑${model.git.ahead} ↓${model.git.behind}`, role: "muted" }] as Line] : [])] : model.git === null ? [[{ text: "Git unavailable", role: "muted" }] as Line] : []),
   ] });
   const context = model.context;
   if (model.goal) blocks.push({ list: false, items: [], head: [
@@ -190,10 +215,11 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
     const tone = share !== undefined && share >= CONTEXT_WARNING ? "warning" : "accent";
     const shareText = shareSeg(context);
     blocks.push({ list: false, items: [], head: [
-      row([{ text: "Context", role: "text", bold: true }], shareText ? [shareText] : []),
+      row([{ text: "Context", role: "text", bold: true }], shareText ? [{ text: context.trigger === null ? "model " : "seg ", role: "muted" }, shareText] : []),
       ...(share === undefined ? [] : [[{ text: "━".repeat(filled), role: tone }, { text: "─".repeat(Math.max(0, w - filled)), role: "line" }] as Line]),
-      [{ text: `${est}${compact(context.used)}${context.window ? ` / ${compact(context.window)}` : ""}`, role: "text" }, { text: ` · node ${context.segment}`, role: "muted" }],
-      ...(context.trigger !== null ? [[{ text: `cut at ${est}${compact(context.trigger)}`, role: "muted" }] as Line] : []),
+      [{ text: `Segment ${est}${compact(context.used)}${context.trigger !== null ? ` / ${est}${compact(context.trigger)}` : " · cut disabled"}`, role: "text" }],
+      [{ text: context.window ? `Model ${est}${compact(context.used)} / ${compact(context.window)} · ${est}${Math.round(context.used / context.window * 100)}%` : "Model window unknown", role: "muted" }],
+      [{ text: `node ${context.segment}`, role: "muted" }],
     ] });
   }
   const usage = model.usage, tools = model.tools;
@@ -222,7 +248,7 @@ function sidebarBlocks(model: StatusModel, w: number): Block[] {
   blocks.push({ list: true, head: [row([{ text: "Tasks", role: "text", bold: true }], [{ text: `${tasks.length} open`, role: "muted" }])],
     items: tasks.map(task => [{ text: task.status === "blocked" ? "! " : "◐ ", role: task.status === "blocked" ? "warning" : "accent" }, { text: task.what, role: "text" }] as Line) });
   const files = model.files ?? [];
-  blocks.push({ list: true, head: [row([{ text: "Files", role: "text", bold: true }], [{ text: String(files.length), role: "muted" }])],
+  blocks.push({ list: true, head: [row([{ text: "Agent files", role: "text", bold: true }], [{ text: String(files.length), role: "muted" }])],
     items: files.map(file => fileLine(file, w)) });
   const background = model.background ?? [];
   blocks.push({ list: true, head: [row([{ text: "Background", role: "text", bold: true }], [{ text: String(background.length), role: "muted" }])],