@visual-z/xeno 0.8.4 → 0.9.1

package/src/apps/ui/control-model.ts

@@ -1,43 +0,0 @@
-import type { ControlSnapshot } from "../../runtime/session-control.ts";
-import type { ControlPanelModel } from "../../tui/ui/control-panel.ts";
-import type { RequestState } from "../../core/request-state.ts";
-import { evidenceLadder, ladderGlyph, RUNGS } from "../../core/evidence-ladder.ts";
-
-/** The sidebar's compact ladder: rung names with their glyphs, then the reading. */
-export function ladderView(state: RequestState): { ladder?: { glyphs: string; summary: string } } {
-  const ladder = evidenceLadder(state);
-  if (!ladder) return {};
-  const names = { ran: "ran", discriminating: "tests", independent: "blind", human: "human" } as const;
-  return { ladder: { glyphs: RUNGS.map(rung => `${names[rung]} ${ladderGlyph(ladder[rung])}`).join("  "), summary: ladder.summary } };
-}
-
-export function controlModel(snapshot: ControlSnapshot): ControlPanelModel {
-  const goal = snapshot.goal, state = goal?.state, context = snapshot.context;
-  const progress = (label: string, sources: readonly { node: number; event: string }[]) => ({ label, count: sources.length, sources: sources.map(source => `${source.node}/${source.event}`) });
-  return { thread: snapshot.threadId, turn: snapshot.activeTurnId ?? state?.request.event ?? null,
-    goal: goal?.text ?? "Send a request to establish a goal.", status: state?.status ?? "idle",
-    execution: snapshot.waiting ? `waiting for ${snapshot.waiting}` : snapshot.activeTurnId ? "running" : state?.execution?.reason ?? "idle",
-    gaps: [...ladderLines(state), ...goal?.gaps ?? []], checks: state?.commands.map(command => `${command.status} · exit ${command.exit} · ${command.command} · ${command.source.node}/${command.source.event}`) ?? [],
-    progress: state ? [
-      progress("New observations", state.progress.observations),
-      progress("Artifact changes", state.progress.artifact_changes),
-      progress("Acceptance advances", state.progress.acceptance_advances),
-      progress("New diagnostics", state.progress.new_diagnostics),
-      progress("Unchanged retries", state.progress.unchanged_retries),
-      progress("Unknown diagnostics", state.progress.unknown_diagnostics),
-    ] : [],
-    context: [`${context.used} tokens (${context.countKind}); ${context.messages.length} messages; ${context.policy}`,
-      ...Object.entries(context.components).map(([name, count]) => `${name}: ~${count}`),
-      ...context.messages.map(message => `#${message.index} ${message.role}: ${message.sources.join(", ")}`)],
-    omitted: context.omitted.map(event => `${event.id}: ${event.type} (original stays in log)`),
-    history: context.sections.filter(section => section.total > 0).map(section => `${section.section}: ${section.retained}/${section.total}` +
-      (section.recovery ? ` · history(${JSON.stringify(section.recovery)})` : "")),
-  };
-}
-
-/** The control panel's goal page spells each rung out on its own line. */
-function ladderLines(state: RequestState | undefined): string[] {
-  const ladder = state ? evidenceLadder(state) : null;
-  if (!ladder) return [];
-  return [`Evidence: ${ladder.summary}`, ...RUNGS.map(rung => `  ${ladderGlyph(ladder[rung])} ${rung}: ${ladder[rung]}`), ""];
-}

package/src/apps/ui/extension-host.ts

@@ -1,194 +0,0 @@
-/**
- * ExtensionUI for the interactive view. Dialog requests are serialized (one
- * extension question at a time, in arrival order) and all cancel on
- * shutdown or session switch, resolving as "dismissed". A call arriving from
- * a disposed generation (an extension of the previous session finishing
- * late) is ignored rather than mutating the new session's UI.
- */
-import type { Theme } from "../../core/theme.ts";
-import type { DialogOptions, ExtensionComponent, ExtensionTheme, ExtensionUI } from "../../runtime/extension-ui.ts";
-import type { ExtensionRegistry, ExtensionToolResult } from "../../runtime/extensions.ts";
-import type { DialogSpec } from "../../tui/ui/dialog.ts";
-
-export interface ExtensionHostDeps {
-  dialog(spec: DialogSpec): void;
-  closeDialog(spec: DialogSpec): void;
-  notify(message: string, tone: "info" | "warning" | "error"): void;
-  redraw(): void;
-  theme(): Theme;
-  colored(): boolean;
-  editorText(): string;
-  setEditorText(text: string): void;
-  insertEditorText(text: string): void;
-  toolsExpanded(): boolean;
-  setToolsExpanded(value: boolean): void;
-  setTitle(title: string): void;
-  cwd(): string;
-}
-
-export class ExtensionHost {
-  private readonly deps: ExtensionHostDeps;
-  private generation = 0;
-  private queue: Promise<unknown> = Promise.resolve();
-  private readonly pending = new Set<() => void>();
-  private readonly statuses = new Map<string, string>();
-  private readonly widgets = new Map<string, string[]>();
-  private readonly toolState = new Map<string, Record<string, unknown>>();
-  private readonly partials = new Map<string, ExtensionToolResult>();
-  private registry: ExtensionRegistry | undefined;
-  private unwatch: (() => void) | undefined;
-  workingMessage: string | undefined;
-  hiddenThinkingLabel: string | undefined;
-  private api: ExtensionUI;
-
-  constructor(deps: ExtensionHostDeps) {
-    this.deps = deps;
-    this.api = this.createApi();
-  }
-
-  get context(): ExtensionUI { return this.api; }
-  get status(): string { return [...this.statuses.values()].join(" · "); }
-  get widgetLines(): string[] { return [...this.widgets.values()].flat(); }
-
-  bind(registry: ExtensionRegistry | undefined): void {
-    if (registry === this.registry && this.unwatch) return;
-    if (registry !== this.registry) this.reset();
-    this.registry = registry;
-    this.unwatch = registry?.onToolUpdate((_name, id, _input, result) => { this.partials.set(id, result); this.deps.redraw(); });
-  }
-
-  /** New generation: cancel dialogs, drop widgets and statuses. Late calls from the old one become no-ops. */
-  reset(): void {
-    this.generation++;
-    this.cancelDialogs();
-    this.unwatch?.(); this.unwatch = undefined; this.registry = undefined;
-    this.statuses.clear(); this.widgets.clear(); this.toolState.clear(); this.partials.clear();
-    this.workingMessage = undefined; this.hiddenThinkingLabel = undefined;
-    this.api = this.createApi();
-  }
-
-  cancelDialogs(): void { for (const cancel of [...this.pending]) cancel(); }
-
-  partial(id: string): ExtensionToolResult | undefined { return this.partials.get(id); }
-  clearPartials(): void { this.partials.clear(); }
-
-  theme(): ExtensionTheme {
-    const theme = this.deps.theme();
-    const colored = this.deps.colored();
-    const sgr = (color: string) => colored && theme.colors[color] ? `\x1b[${theme.colors[color]}m` : "";
-    const wrap = (open: string, text: string, close: string) => open ? open + text + close : text;
-    const attr = (on: number, off: number) => (text: string) => wrap(colored ? `\x1b[${on}m` : "", text, `\x1b[${off}m`);
-    return { ...theme, fg: (color, text) => wrap(sgr(color), text, "\x1b[39m"), bg: (color, text) => wrap(sgr(color), text, "\x1b[49m"),
-      bold: attr(1, 22), dim: attr(2, 22), italic: attr(3, 23), underline: attr(4, 24), inverse: attr(7, 27), strikethrough: attr(9, 29) };
-  }
-
-  /** Render an extension component safely: a throwing renderer shows its error, not a crash. */
-  lines(component: ExtensionComponent | undefined, width: number): string[] {
-    if (!component) return [];
-    try { return component.render(width); } catch (error) { this.deps.notify(`Extension renderer: ${String(error)}`, "error"); return [`(extension renderer failed: ${String(error)})`]; }
-  }
-
-  toolRenderer(name: string, input: unknown, result: { text: string; ok: boolean; data?: unknown } | null, id: string): ((width: number) => string[]) | undefined {
-    const tool = this.registry?.tools.get(name);
-    if (!tool?.renderCall && !tool?.renderResult) return undefined;
-    const state = this.toolState.get(id) ?? {};
-    this.toolState.set(id, state);
-    const partial = this.partials.get(id);
-    const expanded = this.deps.toolsExpanded();
-    return width => {
-      const context = { args: input, toolCallId: id, invalidate: () => this.deps.redraw(), lastComponent: undefined, state, cwd: this.deps.cwd(),
-        executionStarted: result !== null || partial !== undefined, argsComplete: true, isPartial: result === null, expanded, showImages: false, isError: result?.ok === false };
-      const call = tool.renderCall ? this.lines(tool.renderCall(input, this.theme(), context), width) : [];
-      const payload: ExtensionToolResult | undefined = result
-        ? resultPayload(result)
-        : partial;
-      const body = payload && tool.renderResult ? this.lines(tool.renderResult(payload, { expanded, isPartial: result === null }, this.theme(), context), width) : [];
-      return [...call, ...body];
-    };
-  }
-
-  /** Extension Markdown transformers, in registration order; a throwing one is skipped. Display only. */
-  transformMarkdown(text: string, context: { streaming: boolean; messageType: "assistant" | "assistant-thinking"; width: number }): string {
-    for (const transform of this.registry?.markdown ?? []) {
-      // Context keys are the ones extensions already read (availableWidth / isStreaming / messageType).
-      try { text = transform(text, { availableWidth: context.width, isStreaming: context.streaming, messageType: context.messageType }) ?? text; } catch (error) { this.deps.notify(`Markdown transformer: ${String(error)}`, "error"); }
-    }
-    return text;
-  }
-
-  messageRenderer(type: string, text: string, data: unknown, entry: boolean): ((width: number) => string[]) | undefined {
-    const renderer = (entry ? this.registry?.entryRenderers.get(type) : undefined) ?? this.registry?.renderers.get(type);
-    if (!renderer) return undefined;
-    return width => {
-      try {
-        const component = renderer({ customType: type, content: text, ...(data === undefined ? {} : { details: data }) }, { expanded: this.deps.toolsExpanded(), outputPad: 1 }, this.theme());
-        return component ? this.lines(component, width) : [text];
-      } catch (error) { return [`(extension renderer failed: ${String(error)})`, text]; }
-    };
-  }
-
-  private createApi(): ExtensionUI {
-    const generation = this.generation;
-    const live = () => generation === this.generation;
-    const api: ExtensionUI = {
-      select: (title, options, opts) => this.ask<string | undefined>(undefined, opts, resolve => ({
-        kind: "list", title, items: options.map(option => ({ value: option, label: option })), onPick: item => resolve(item.value), onCancel: () => resolve(undefined),
-      })),
-      confirm: (title, message, opts) => this.ask<boolean>(false, opts, resolve => ({ kind: "confirm", title, message, onAnswer: yes => resolve(yes) })),
-      input: (title, placeholder, opts) => this.ask<string | undefined>(undefined, opts, resolve => ({
-        kind: "form", title, label: placeholder || "value", onSubmit: value => resolve(value), onCancel: () => resolve(undefined),
-      })),
-      show: (title, component) => this.ask<void>(undefined, undefined, resolve => ({
-        kind: "lines", title, render: width => this.lines(component, width), onCancel: () => { component.dispose?.(); resolve(undefined); },
-      })),
-      notify: (message, type) => { if (live()) this.deps.notify(message, type ?? "info"); },
-      setStatus: (key, text) => { if (!live()) return; if (text === undefined) this.statuses.delete(key); else this.statuses.set(key, text); this.deps.redraw(); },
-      setWidget: (key, lines) => { if (!live()) return; if (lines === undefined) this.widgets.delete(key); else this.widgets.set(key, lines); this.deps.redraw(); },
-      setWorkingMessage: message => { if (!live()) return; this.workingMessage = message; this.deps.redraw(); },
-      setHiddenThinkingLabel: label => { if (!live()) return; this.hiddenThinkingLabel = label; this.deps.redraw(); },
-      setTitle: title => { if (live()) this.deps.setTitle(title); },
-      getEditorText: () => this.deps.editorText(),
-      setEditorText: text => { if (live()) this.deps.setEditorText(text); },
-      pasteToEditor: text => { if (live()) this.deps.insertEditorText(text); },
-      get theme() { return hostTheme(); },
-      getToolsExpanded: () => this.deps.toolsExpanded(),
-      setToolsExpanded: value => { if (live()) this.deps.setToolsExpanded(value); },
-    };
-    const hostTheme = () => this.theme();
-    return api;
-  }
-
-  /** One extension dialog at a time; signal/timeout/shutdown resolve with `dismissed`. */
-  private ask<T>(dismissed: T, opts: DialogOptions | undefined, spec: (resolve: (value: T) => void) => DialogSpec): Promise<T> {
-    const generation = this.generation;
-    const run = () => new Promise<T>(resolve => {
-      if (generation !== this.generation || opts?.signal?.aborted) { resolve(dismissed); return; }
-      let done = false, timer: ReturnType<typeof setTimeout> | undefined, shown: DialogSpec | undefined;
-      const finish = (value: T, close: boolean) => {
-        if (done) return;
-        done = true;
-        clearTimeout(timer);
-        opts?.signal?.removeEventListener("abort", abort);
-        this.pending.delete(cancel);
-        if (close && shown) this.deps.closeDialog(shown);
-        resolve(value);
-      };
-      const cancel = () => finish(dismissed, true);
-      const abort = () => finish(dismissed, true);
-      this.pending.add(cancel);
-      opts?.signal?.addEventListener("abort", abort, { once: true });
-      if (opts?.timeout) timer = setTimeout(abort, opts.timeout);
-      shown = spec(value => finish(value, false));
-      this.deps.dialog(shown);
-    });
-    const next = this.queue.then(run, run);
-    this.queue = next.catch(() => undefined);
-    return next;
-  }
-}
-
-function resultPayload(result: { text: string; ok: boolean; data?: unknown }): ExtensionToolResult {
-  const payload: ExtensionToolResult = { content: [{ type: "text", text: result.text }], isError: !result.ok };
-  if (result.data !== undefined) payload.details = result.data as NonNullable<ExtensionToolResult["details"]>;
-  return payload;
-}

package/src/apps/ui/image-cache.ts

@@ -1,121 +0,0 @@
-/**
- * Decoded pictures, shared and bounded (docs/tasks/feat-tui-inline-images.md DoD 4).
- *
- * The log stores each image once as a content-addressed blob; this keeps one
- * decoded NativeImage per blob for every node that shows it. Each picture
- * node retains its own reference (OpenTUI counts them), so evicting an entry
- * here only drops the cache's reference: a picture still on screen keeps
- * its pixels, and memory is returned once the last node goes.
- *
- * Bytes come from the blob store, which checks the hash; a missing or
- * corrupt blob, or one that will not decode, has a typed failure so the view
- * retains the caption and shows the actual preparation error.
- */
-import { NativeImage, imageInfo } from "@opentui/core";
-import { getBlobBytes } from "../../store/blobs.ts";
-import { modelImageDimensions, MAX_IMAGE_SOURCE_BYTES, MAX_IMAGE_SOURCE_PIXELS } from "../../core/image-limits.ts";
-import type { PictureLoad } from "../../tui/ui/pictures.ts";
-
-/** Two full previews fit; mounted ImageRenderables retain their own references. */
-export const IMAGE_CACHE_BYTES = 64 * 1024 * 1024;
-/** Bounds failed entries and queued requests as well as successful pixels. */
-export const IMAGE_CACHE_ENTRIES = 128;
-/** Limit simultaneous native allocations; remaining admitted loads wait in the bounded cache. */
-const IMAGE_DECODE_CONCURRENCY = 2;
-interface Entry { readonly result: Promise<PictureLoad>; bytes: number; settled: boolean }
-
-export class ImageCache {
-  private readonly entries = new Map<string, Entry>();
-  private used = 0;
-  private active = 0;
-  private closed = false;
-  private readonly waiting: (() => void)[] = [];
-  private readonly blobDir: () => string;
-  private readonly budget: number;
-
-  constructor(blobDir: () => string, budget = IMAGE_CACHE_BYTES) {
-    this.blobDir = blobDir;
-    this.budget = budget;
-  }
-
-  /** Bytes of decoded pixels held now (tests). */
-  get size(): number { return this.used; }
-  get count(): number { return this.entries.size; }
-
-  async load(sha256: string): Promise<NativeImage | null> {
-    const result = await this.loadResult(sha256);
-    return result.kind === "ready" ? result.image : null;
-  }
-
-  loadResult(sha256: string): Promise<PictureLoad> {
-    if (this.closed) return Promise.resolve({ kind: "error", reason: "closed" });
-    const hit = this.entries.get(sha256);
-    if (hit) {
-      // Most recently used goes last; eviction starts from the front.
-      this.entries.delete(sha256); this.entries.set(sha256, hit);
-      return hit.result;
-    }
-    if (this.entries.size >= IMAGE_CACHE_ENTRIES) {
-      const oldest = [...this.entries].find(([, entry]) => entry.settled);
-      if (oldest) this.drop(oldest[0], oldest[1]);
-      else return Promise.resolve({ kind: "error", reason: "busy" });
-    }
-    // Capture the blob owner before awaiting: session switches cannot redirect an in-flight read.
-    const entry: Entry = { result: this.decode(this.blobDir(), sha256), bytes: 0, settled: false };
-    this.entries.set(sha256, entry);
-    void entry.result.then(result => {
-      entry.settled = true;
-      if (this.entries.get(sha256) !== entry) { if (result.kind === "ready") result.image.dispose(); return; }
-      entry.bytes = result.kind === "ready" ? result.image.width * result.image.height * 4 : 0;
-      this.used += entry.bytes;
-      for (const [sha, old] of this.entries) {
-        if (this.used <= this.budget) break;
-        if (sha !== sha256 && old.settled) this.drop(sha, old);
-      }
-    });
-    return entry.result;
-  }
-
-  private async decode(dir: string, sha: string): Promise<PictureLoad> {
-    if (this.active >= IMAGE_DECODE_CONCURRENCY) await new Promise<void>(resolve => this.waiting.push(resolve));
-    else this.active++;
-    if (this.closed) return { kind: "error", reason: "closed" };
-    let native: NativeImage | undefined;
-    try {
-      let bytes: Uint8Array | null;
-      try { bytes = await getBlobBytes(dir, sha, MAX_IMAGE_SOURCE_BYTES); }
-      catch (error) { return { kind: "error", reason: error instanceof RangeError ? "limit" : "corrupt" }; }
-      if (!bytes) return { kind: "error", reason: "missing" };
-      if (bytes.length > MAX_IMAGE_SOURCE_BYTES) return { kind: "error", reason: "limit" };
-      const info = imageInfo(bytes);
-      if (info.width * info.height > MAX_IMAGE_SOURCE_PIXELS) return { kind: "error", reason: "limit" };
-      native = await NativeImage.load(bytes);
-      const target = modelImageDimensions(native);
-      if (target.width !== native.width || target.height !== native.height) {
-        const resized = native.resize(target); native.dispose(); native = resized;
-      }
-      if (this.closed) return { kind: "error", reason: "closed" };
-      if (native.width * native.height * 4 > this.budget) return { kind: "error", reason: "limit" };
-      const image = native; native = undefined;
-      return { kind: "ready", image };
-    } catch { return { kind: "error", reason: "decode" }; }
-    finally {
-      native?.dispose();
-      const next = this.waiting.shift();
-      if (next) next(); else this.active--;
-    }
-  }
-
-  private drop(sha: string, entry: Entry): void {
-    this.entries.delete(sha); this.used -= entry.bytes;
-    void entry.result.then(result => { if (result.kind === "ready") result.image.dispose(); });
-  }
-
-  dispose(): void {
-    this.closed = true;
-    for (const entry of this.entries.values()) if (entry.settled) void entry.result.then(result => { if (result.kind === "ready") result.image.dispose(); });
-    this.entries.clear();
-    this.used = 0;
-    this.waiting.splice(0).forEach(resolve => resolve());
-  }
-}

package/src/apps/ui/palette.ts

@@ -1,88 +0,0 @@
-/**
- * Ctrl+P: every command and action in one searchable list.
- *
- * Sources: the slash-command catalog (COMMANDS, prompt templates, skills,
- * extension commands) plus actions that have no slash spelling (toggle tools,
- * scroll, sidebar) and the ready models. The `/` completion menu reads the
- * same command entries, so a command is discoverable exactly one way
- * (OpenCode's command registry). Pure: the controller supplies state.
- */
-import type { ListItem } from "../../tui/ui/list-model.ts";
-import { COMMANDS } from "../commands.ts";
-
-export interface PaletteAction { readonly id: string; readonly label: string; readonly description: string; readonly section: string; readonly chord?: string; readonly when?: boolean }
-
-export interface PaletteInput {
-  readonly bindings: Readonly<Record<string, readonly string[]>>;
-  readonly busy: boolean;
-  readonly extraCommands: readonly { name: string; description: string; section: string }[];
-  readonly models: readonly { key: string; label: string; description: string; current: boolean }[];
-  readonly toolsExpanded: boolean;
-  readonly thinkingExpanded: boolean;
-  readonly sidebar: boolean;
-}
-
-/** Which section a built-in command belongs to; unlisted ones go under "Commands". */
-const SECTION: Readonly<Record<string, string>> = {
-  model: "Model", "scoped-models": "Model", thinking: "Model", login: "Model", logout: "Model",
-  new: "Session", resume: "Session", tree: "Session", fork: "Session", clone: "Session", back: "Session", name: "Session", session: "Session",
-  export: "Session", import: "Session", copy: "Session",
-  usage: "Inspect", state: "Inspect", context: "Inspect", acceptance: "Inspect", tasks: "Inspect", branches: "Inspect", processes: "Inspect", debug: "Inspect",
-  settings: "Configure", reload: "Configure", config: "Configure", trust: "Configure", hotkeys: "Configure", models: "Configure",
-};
-
-function chord(bindings: PaletteInput["bindings"], action: string): string | undefined {
-  return bindings[action]?.[0];
-}
-
-export function paletteActions(input: PaletteInput): PaletteAction[] {
-  const b = input.bindings;
-  const actions: PaletteAction[] = [
-    { id: "action:toggleTools", label: input.toolsExpanded ? "Collapse tool output" : "Expand tool output", description: "all tool cards", section: "View", ...opt(chord(b, "app.toggleTools")) },
-    { id: "action:toggleThinking", label: input.thinkingExpanded ? "Hide thinking" : "Show thinking", description: "reasoning blocks", section: "View", ...opt(chord(b, "app.toggleThinking")) },
-    { id: "action:toggleSidebar", label: input.sidebar ? "Hide sidebar" : "Show sidebar", description: "segment state (≥120 columns)", section: "View", ...opt(chord(b, "app.toggleSidebar")) },
-    { id: "action:appearance", label: "Appearance", description: "dark, light or follow terminal", section: "View" },
-    { id: "action:animations", label: "Animations", description: "enable or reduce motion", section: "View" },
-    { id: "action:bottom", label: "Jump to latest", description: "resume following new output", section: "View", ...opt(chord(b, "app.scroll.bottom")) },
-    { id: "action:top", label: "Jump to start", description: "first message of this session", section: "View", ...opt(chord(b, "app.scroll.top")) },
-    { id: "action:editor", label: "Open draft in $EDITOR", description: "edit the prompt externally", section: "Compose", ...opt(chord(b, "app.externalEditor")) },
-    { id: "action:pasteImage", label: "Paste image from clipboard", description: "attach to the draft", section: "Compose", ...opt(chord(b, "app.clipboard.pasteImage")) },
-    { id: "action:cycleThinking", label: "Cycle thinking level", description: "next supported level", section: "Model", ...opt(chord(b, "app.cycleThinking")) },
-    { id: "action:interrupt", label: "Interrupt", description: "stop the running turn", section: "Run", when: input.busy, ...opt(chord(b, "app.interrupt")) },
-    { id: "action:quit", label: "Quit", description: "exit xeno", section: "Run", ...opt(chord(b, "app.exit")) },
-  ];
-  return actions.filter(action => action.when !== false);
-}
-
-function opt(value: string | undefined): { chord?: string } { return value ? { chord: value } : {}; }
-
-export function paletteItems(input: PaletteInput): ListItem[] {
-  const items: ListItem[] = [];
-  const model = input.models.find(entry => entry.current);
-  for (const action of paletteActions(input)) items.push({ value: action.id, label: action.label, description: action.description, section: action.section, ...(action.chord ? { hint: action.chord } : {}) });
-  for (const command of COMMANDS) {
-    if (command.name === "exit" || command.name === "quit") continue;
-    const blocked = input.busy && command.busy === "idle";
-    items.push({ value: `command:${command.name}`, label: `/${command.name}`, description: blocked ? `${command.description} · needs an idle session` : command.description,
-      section: SECTION[command.name] ?? "Commands", disabled: blocked,
-      ...(command.name === "model" && model ? { hint: model.label } : command.name === "model" && input.bindings["app.model"]?.[0] ? { hint: input.bindings["app.model"][0] } : {}) });
-  }
-  for (const command of input.extraCommands) items.push({ value: `command:${command.name}`, label: `/${command.name}`, description: command.description, section: command.section });
-  for (const entry of input.models) items.push({ value: `model:${entry.key}`, label: entry.label, description: entry.description, section: "Switch model", keywords: entry.key, disabled: input.busy,
-    ...(input.busy ? { hint: "after this turn" } : entry.current ? { hint: "current" } : {}) });
-  return sortSections(items);
-}
-
-const ORDER = ["View", "Model", "Session", "Compose", "Inspect", "Configure", "Commands", "Prompts", "Skills", "Extensions", "Run", "Switch model"];
-function sortSections(items: ListItem[]): ListItem[] {
-  const rank = (section: string | undefined) => { const at = ORDER.indexOf(section ?? ""); return at < 0 ? ORDER.length : at; };
-  return items.map((item, index) => ({ item, index })).sort((a, b) => rank(a.item.section) - rank(b.item.section) || a.index - b.index).map(entry => entry.item);
-}
-
-/** `/` completion: the same command entries, filtered by prefix, ranked by the list model's fuzzy order. */
-export function slashItems(input: PaletteInput, prefix: string): ListItem[] {
-  const all = paletteItems(input).filter(item => item.value.startsWith("command:"));
-  const q = prefix.toLowerCase();
-  return all.filter(item => item.label.slice(1).toLowerCase().startsWith(q)).concat(all.filter(item => !item.label.slice(1).toLowerCase().startsWith(q) && item.label.toLowerCase().includes(q)))
-    .map(item => ({ ...item, value: `${item.label} ` }));
-}

package/src/apps/ui/project.ts

@@ -1,127 +0,0 @@
-/**
- * Log projection → view items. Pure apart from the renderer callbacks it
- * hands to tool cards, which are themselves pure functions of the log.
- *
- * Inputs are the durable transcript (core/transcript.ts), the UI-only
- * notices anchored to it, and the live (uncommitted) stream. The stream is
- * never history: once the log has the assistant event, the stream is gone
- * and the projected item takes its place (same id scheme, no flash).
- */
-import type { TranscriptItem } from "../../core/transcript.ts";
-import type { ImageView, ViewItem } from "../../tui/ui/items.ts";
-import type { ImageRef } from "../../core/images.ts";
-import { toolCard, toolDetail, toolPreview, toolSummary } from "../../tui/ui/tool-card.ts";
-import type { Style } from "../../tui/style.ts";
-
-export interface Notice { readonly id: string; readonly after: number; readonly item: ViewItem }
-
-export interface LiveStream {
-  readonly thinking: string;
-  readonly text: string;
-  readonly tools: readonly { id: string; name: string; arguments: string }[];
-  readonly output: string;
-  readonly bash: string | null;
-  readonly retry?: string;
-}
-
-export interface ProjectOptions {
-  readonly notices: readonly Notice[];
-  readonly live?: LiveStream;
-  /** Extension renderers; return lines to replace the default card, undefined to keep it. */
-  readonly customTool?: (item: Extract<TranscriptItem, { kind: "tool" }>) => ((width: number) => string[]) | undefined;
-  readonly customMessage?: (item: Extract<TranscriptItem, { kind: "custom" }>) => ((width: number) => string[]) | undefined;
-  readonly hiddenThinkingLabel?: string;
-  readonly style?: () => Style | undefined;
-  /**
-   * Views of durable items from earlier paints, by item id. A log item never
-   * changes without a new revision, so an equal key means an equal view, and
-   * a long session re-projects only what changed (refactor-tui-chrome-cleanup
-   * DoD 5). The caller clears it when renderers or labels change.
-   */
-  readonly cache?: Map<string, { readonly key: string; readonly view: ViewItem | undefined }>;
-}
-
-/** CutReason → words. Unknown reasons (future log versions) print verbatim. */
-const SEGMENT_REASONS: Readonly<Record<string, string>> = {
-  trigger: "context boundary", hard_limit: "context limit", model_checkpoint: "model switch",
-};
-
-export function projectItems(items: readonly TranscriptItem[], options: ProjectOptions): ViewItem[] {
-  const out: ViewItem[] = [];
-  let notice = 0;
-  const flush = (upTo: number) => { while (notice < options.notices.length && options.notices[notice]!.after <= upTo) out.push(options.notices[notice++]!.item); };
-  flush(0);
-  let segment = 1;
-  items.forEach((item, index) => {
-    // A segment's label depends on how many came before it, so that count is part of its key.
-    const key = item.kind === "segment" ? `${item.revision}|${segment}` : item.revision;
-    const hit = options.cache?.get(item.id);
-    let view: ViewItem | undefined;
-    if (hit && hit.key === key) { view = hit.view; if (item.kind === "segment" && item.nextNode === undefined) segment++; }
-    else { view = projectOne(item, options, () => ++segment); options.cache?.set(item.id, { key, view }); }
-    if (view) out.push(view);
-    flush(index + 1);
-  });
-  while (notice < options.notices.length) out.push(options.notices[notice++]!.item);
-  const live = options.live;
-  if (live) {
-    if (live.bash !== null) out.push({ kind: "tool", id: "live:bash", rev: `${live.bash.length}`, name: "shell", summary: "running", status: "pending", detail: () => live.bash!.split("\n").slice(-40) });
-    const logged = new Set(items.flatMap(item => item.kind === "tool" ? [item.callId] : []));
-    for (const tool of live.tools) {
-      if (logged.has(tool.id)) continue;
-      let input: unknown;
-      try { input = JSON.parse(tool.arguments) as unknown; } catch { input = {}; }
-      out.push({ kind: "tool", id: `live:tool:${tool.id}`, rev: `${tool.arguments.length}`, name: tool.name, summary: toolSummary(tool.name, input) || "preparing…", status: "pending",
-        detail: width => toolDetail({ name: tool.name, input, result: null }, width, options.style?.()) });
-    }
-    if (live.output) out.push({ kind: "lines", id: "live:output", rev: `${live.output.length}`, render: () => live.output.split("\n").slice(-12) });
-    if (live.retry) out.push({ kind: "notice", id: "live:retry", rev: live.retry, text: live.retry, tone: "warning" });
-    if (live.thinking) out.push({ kind: "thinking", id: "live:thinking", rev: `${live.thinking.length}`, text: live.thinking, streaming: true, ...(options.hiddenThinkingLabel !== undefined ? { label: options.hiddenThinkingLabel } : {}) });
-    if (live.text) out.push({ kind: "assistant", id: "live:text", rev: `${live.text.length}`, text: live.text, streaming: true });
-  }
-  return out;
-}
-
-function projectOne(item: TranscriptItem, options: ProjectOptions, nextSegment: () => number): ViewItem | undefined {
-  const base = { id: item.id, rev: item.revision };
-  switch (item.kind) {
-    case "user":
-      return { ...base, kind: "user", text: item.text, ...(item.images?.length ? { images: item.images.map(imageView) } : {}), ...(item.interrupted ? { interrupted: true } : {}) };
-    case "assistant": return item.text.trim() ? { ...base, kind: "assistant", text: item.text } : undefined;
-    case "thinking": return item.text.trim() ? { ...base, kind: "thinking", text: item.text, ...(options.hiddenThinkingLabel !== undefined ? { label: options.hiddenThinkingLabel } : {}) } : undefined;
-    case "notice": return { ...base, kind: "notice", text: item.text };
-    case "custom": {
-      const render = options.customMessage?.(item);
-      return render ? { ...base, kind: "lines", render } : { ...base, kind: "notice", text: `[${item.customType}] ${item.text}` };
-    }
-    case "tool": {
-      const custom = options.customTool?.(item);
-      const card = toolCard(item);
-      return { ...base, kind: "tool", name: item.name, summary: card.summary, status: card.status, ...(card.evidence ? { evidence: card.evidence } : {}),
-        ...(custom ? {} : { preview: toolPreview(item) }), ...(item.result?.images?.length ? { images: item.result.images.map(imageView) } : {}),
-        detail: custom ?? (width => toolDetail(item, width, options.style?.())) };
-    }
-    case "shell": {
-      const code = item.exit; // the logged exit code is the evidence (D11)
-      // The log appends `exit N · status · reason` as the content's last line; the card's evidence already says it.
-      const output = item.output.replace(/^exit -?\d+[^\n]*\n?/, "").replace(/\n?exit -?\d+ · [^\n]*$/, "").replace(/\s+$/, "");
-      return { ...base, kind: "tool", name: item.excluded ? "!!" : "!", summary: item.command, status: code === 0 ? "ok" : "error", evidence: `exit ${code}`,
-        // Shell output keeps its last two lines in view while folded (refactor-tui-chrome-cleanup DoD 2).
-        preview: output.split("\n").filter(line => line.trim()).slice(-2),
-        // The exit code is already the card's evidence; the body is the output itself.
-        detail: () => (output || "(no output)").split("\n").slice(0, 200) };
-    }
-    case "segment": {
-      const node = item.nextNode ?? nextSegment();
-      return { ...base, kind: "segment", label: `node ${node} · ${SEGMENT_REASONS[item.reason] ?? item.reason}`,
-        detail: `handoff ${shortRef(item.handoff)}${item.nextModel ? ` → ${item.nextModel}` : ""} · history before this line is carried as structured state, not replayed` };
-    }
-  }
-}
-
-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, ...(image.original ? { full: image.original.sha256 } : {}) };
-}