@visual-z/xeno 0.8.4 → 0.9.1

package/src/apps/ui/standalone.ts

@@ -1,148 +0,0 @@
-/**
- * Pickers that run before a session exists (startup session choice, project
- * trust, `xeno config`). Each borrows the terminal for one dialog on its own
- * renderer and gives it back; none of them creates a durable session.
- * Same dialog component as the session UI, so keys and look match.
- */
-import { BoxRenderable, createCliRenderer, type CliRenderer } from "@opentui/core";
-import { defaultKeymap, type Keymap } from "../../core/keymap.ts";
-import { nextResourceOverride } from "../../core/resource-selection.ts";
-import { selectSessions } from "../../core/session-browser.ts";
-import { builtinTheme, type Theme } from "../../core/theme.ts";
-import { projectTrust } from "../../store/trust.ts";
-import { discoverResources, setResourceOverride, type ResourceOptions } from "../../store/resource-index.ts";
-import { loadUiResources } from "../../store/resources.ts";
-import { registerSessionRoot, scanSessionRoots, sessionRoots } from "../../store/session-browser.ts";
-import { sessionsDir, type ListedSession } from "../../store/sessions.ts";
-import { fuzzyMatch } from "../../tui/fuzzy.ts";
-import { DialogHost, type DialogSpec } from "../../tui/ui/dialog.ts";
-import { keyPress } from "../../tui/ui/keys.ts";
-import type { ListItem } from "../../tui/ui/list-model.ts";
-import { Canvas } from "../../tui/ui/canvas.ts";
-import { edgeLine } from "../../tui/ui/edge.ts";
-import { applyTrustChoice, type TrustChoice } from "../project-trust.ts";
-import { uiColors } from "./theme.ts";
-import { trustItems } from "./app.ts";
-
-interface Standalone { renderer: CliRenderer; dialogs: DialogHost; close(): void }
-
-/**
- * A one-dialog screen: a heading row on top and the same input box the
- * session uses, pinned to the bottom, with the dialog's title and keys on its
- * top edge (refactor-tui-dock-layout). Nothing is painted behind it.
- */
-async function open(theme: Theme, keymap: Keymap, heading: string, handoff?: () => void, renderer?: CliRenderer): Promise<Standalone> {
-  handoff?.();
-  const r = renderer ?? await createCliRenderer({ screenMode: "alternate-screen", exitOnCtrlC: false, exitSignals: [], consoleMode: "disabled", openConsoleOnError: false,
-    enableMouseMovement: false, gatherStats: false, memorySnapshotInterval: 0, maxFps: 60 });
-  // The terminal's palette is not known yet on this short-lived renderer; the
-  // theme's hint picks safe slots. The background is still never painted.
-  const colors = uiColors(theme);
-  r.setBackgroundColor(colors.background);
-  const root = new BoxRenderable(r, { id: "standalone", flexDirection: "column", width: "100%", height: "100%" });
-  const top = new Canvas(r, { id: "standalone-heading", height: 1, flexShrink: 0, marginLeft: 1, marginRight: 1, colors });
-  top.setRows([[{ text: "xeno", role: "text", bold: true }, { text: `  ${heading}`, role: "muted" }]]);
-  const spacer = new BoxRenderable(r, { id: "standalone-space", flexGrow: 1 });
-  const box = new BoxRenderable(r, { id: "standalone-box", flexDirection: "column", flexShrink: 0, marginLeft: 1, marginRight: 1 });
-  const topEdge = new Canvas(r, { id: "standalone-top", height: 1, flexShrink: 0, colors });
-  const body = new BoxRenderable(r, { id: "standalone-body", flexDirection: "column", flexShrink: 0, border: ["left", "right"], borderStyle: "rounded", borderColor: colors.edge, paddingLeft: 1, paddingRight: 1 });
-  const slot = new BoxRenderable(r, { id: "dialog", flexDirection: "column", flexShrink: 0, visible: false });
-  const bottomEdge = new Canvas(r, { id: "standalone-bottom", height: 1, flexShrink: 0, colors });
-  body.add(slot); box.add(topEdge); box.add(body); box.add(bottomEdge);
-  root.add(top); root.add(spacer); root.add(box);
-  r.root.add(root);
-  const dialogs = new DialogHost(r, colors, () => keymap.byAction, slot, () => Math.max(1, r.height - 4));
-  const paint = () => {
-    const width = Math.max(2, r.width - 2);
-    topEdge.setRows([edgeLine({ width, corners: ["╭", "╮"], left: dialogs.title ? [{ segs: [{ text: dialogs.title, role: "text", bold: true }], priority: 0, min: 8 }] : [],
-      right: dialogs.edgeHint ? [{ segs: [{ text: dialogs.edgeHint, role: "muted" }], priority: 3, min: 10 }] : [] })]);
-    bottomEdge.setRows([edgeLine({ width, corners: ["╰", "╯"] })]);
-  };
-  dialogs.onChrome = paint;
-  r.on("resize", () => { dialogs.layout(); paint(); });
-  paint();
-  r.keyInput.on("keypress", event => { if (dialogs.key(keyPress(event))) event.preventDefault(); });
-  r.keyInput.on("paste", event => { if (dialogs.paste(new TextDecoder().decode(event.bytes)) === false) event.preventDefault(); });
-  return { renderer: r, dialogs, close: () => { dialogs.dispose(); if (!renderer) r.destroy(); } };
-}
-
-/** Show one dialog; resolves with the picked value, or null when it is closed without a choice. */
-function ask(host: Standalone, spec: (resolve: (value: string | null) => void) => DialogSpec): Promise<string | null> {
-  return new Promise(resolve => {
-    let settled = false;
-    const done = (value: string | null) => { if (!settled) { settled = true; resolve(value); } };
-    // A pick empties the stack before its callback runs; let the callback answer first.
-    host.dialogs.onClosed = () => queueMicrotask(() => done(null));
-    host.dialogs.push(spec(done));
-  });
-}
-
-export async function pickProjectTrust(workspace: string, handoff?: () => void, renderer?: CliRenderer): Promise<boolean> {
-  const decision = await projectTrust(workspace);
-  const ui = await loadUiResources({ workspace, trusted: false });
-  const host = await open(ui.theme, ui.keymap, "project trust", handoff, renderer);
-  try {
-    const choice = await ask(host, resolve => ({ kind: "list", title: "Trust this project?", search: false, items: trustItems(workspace),
-      intro: [workspace, "This project has its own .xeno configuration (settings, skills, extensions). Tool permissions are separate."],
-      ...(decision.saved ? { selected: decision.saved.trusted ? decision.saved.path === workspace ? "here" : "parent" : "never" } : {}),
-      onPick: item => resolve(item.value) }));
-    return choice === null ? false : applyTrustChoice(workspace, choice as TrustChoice);
-  } finally { host.close(); }
-}
-
-type Session = Extract<ListedSession, { ok: true }>;
-
-export async function pickStartupSession(opts: { workspace: string; sessionDir?: string; say: (line: string) => void; keymap?: Keymap; theme?: Theme },
-  handoff?: () => void, renderer?: CliRenderer): Promise<string | null> {
-  const root = { path: sessionsDir(opts.workspace, opts.sessionDir), workspace: opts.workspace };
-  await registerSessionRoot(root).catch(error => opts.say(String(error)));
-  const host = await open(opts.theme ?? builtinTheme("dark"), opts.keymap ?? defaultKeymap(), "resume a session", handoff, renderer);
-  const scan = new AbortController();
-  let rows: Session[] = [];
-  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.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)) {
-        // 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));
-      }
-    };
-    const picked = ask(host, resolve => (spec = { kind: "list", title: "Resume · this folder", items: [], rows: 16, empty: "Loading sessions…", placeholder: "search sessions",
-      actions: [{ key: "tab", label: "all workspaces", run: async () => { scope = scope === "current" ? "all" : "current"; spec!.title = `Resume · ${scope === "current" ? "this folder" : "all workspaces"}`; await load(); } }],
-      onPick: item => resolve(item.value) }));
-    await load();
-    if (!rows.length && scope === "current" && (await sessionRoots(root)).length === 1) { opts.say("No sessions to resume"); host.dialogs.clear(); return null; }
-    return await picked;
-  } finally { scan.abort(); host.close(); }
-}
-
-export async function runResourceConfig(options: ResourceOptions, handoff?: () => void, renderer?: CliRenderer): Promise<void> {
-  let index = await discoverResources(options);
-  const ui = await loadUiResources(options, index);
-  const host = await open(ui.theme, ui.keymap, "resources", handoff, renderer);
-  let scope: "user" | "project" = options.local ? "project" : "user";
-  const items = (): ListItem[] => index.entries.map(entry => ({ value: `${entry.kind}:${entry.path}`, label: `${entry.enabled ? "◉" : "○"} ${entry.name}`, section: entry.kind,
-    description: `${entry.scope}${entry.trusted ? "" : " · untrusted"}${scope === "project" ? ` · ${entry.override}` : ""}`, keywords: entry.path }));
-  try {
-    let spec: DialogSpec & { kind: "list" } | undefined;
-    await ask(host, () => (spec = { kind: "list", title: `Resources · ${scope === "user" ? "global" : "project"}`, items: items(), rows: 16, empty: "No resources found",
-      hint: "space toggle · tab scope · esc close",
-      actions: [
-        { key: "tab", label: "scope", run: () => { scope = scope === "user" ? "project" : "user"; spec!.title = `Resources · ${scope === "user" ? "global" : "project"}`; host.dialogs.list?.setItems(items()); } },
-        { key: "space", label: "toggle", run: async item => {
-          const entry = index.entries.find(row => `${row.kind}:${row.path}` === item?.value);
-          if (!entry) return;
-          await setResourceOverride(index, entry, scope, scope === "project" ? nextResourceOverride(entry.override) : entry.inherited ? "skip" : "load");
-          index = await discoverResources(options);
-          host.dialogs.list?.setItems(items(), item?.value);
-        } },
-      ] }));
-  } finally { host.close(); }
-}

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

@@ -1,68 +0,0 @@
-/**
- * Log → status facts for the sidebar and top bar (docs/tasks/refactor-tui-dock-layout.md). Pure.
- *
- * Everything here is a projection of what the log already records: file
- * counts come from the logged input of edit calls that succeeded, handoff
- * entries from the derived preview (D8), background work from the processes
- * and branches the log observed. Nothing reads model narration (D11).
- */
-import type { Handoff } from "../../core/handoff.ts";
-import type { TranscriptItem } from "../../core/transcript.ts";
-import { diffCounts } from "../../tui/ui/tool-card.ts";
-import type { FileStatus, StatusModel } from "../../tui/ui/status.ts";
-
-/** Files the session touched, most recent first. Counts only for files changed solely by edits (a write's prior content is unknown). */
-export function fileChanges(items: readonly TranscriptItem[]): FileStatus[] {
-  const files = new Map<string, { edited: boolean; added: number; removed: number; rewritten: boolean; at: number }>();
-  items.forEach((item, at) => {
-    if (item.kind !== "tool" || !item.result?.ok) return;
-    const input = item.input !== null && typeof item.input === "object" ? item.input as Record<string, unknown> : {};
-    const path = typeof input["path"] === "string" ? input["path"] : undefined;
-    if (!path || !["read", "edit", "write"].includes(item.name)) return;
-    const entry = files.get(path) ?? { edited: false, added: 0, removed: 0, rewritten: false, at };
-    entry.at = at;
-    if (item.name === "edit") { const counts = diffCounts(item.input); entry.edited = true; entry.added += counts.added; entry.removed += counts.removed; }
-    if (item.name === "write") { entry.edited = true; entry.rewritten = true; }
-    files.set(path, entry);
-  });
-  return [...files.entries()].sort((a, b) => b[1].at - a[1].at)
-    .map(([path, entry]) => ({ path, edited: entry.edited, added: entry.rewritten ? 0 : entry.added, removed: entry.rewritten ? 0 : entry.removed }));
-}
-
-export function firstPrompt(items: readonly TranscriptItem[]): string | null {
-  const user = items.find(item => item.kind === "user" && item.text.trim());
-  return user?.kind === "user" ? user.text.trim() : null;
-}
-
-type Derived = Pick<StatusModel, "handoff" | "tasks" | "background">;
-
-/** The parts of a handoff preview the status surfaces show. Each list keeps its most recent entries last. */
-export function handoffStatus(handoff: Handoff): Derived {
-  const background = [
-    ...handoff.branches.filter(branch => branch.background && branch.resolution === null && !branch.handoff_ref).map(branch => `branch ${branch.node} · ${branch.purpose}`),
-    ...(handoff.processes ?? []).filter(process => process.observed === "running").map(process => process.command ?? `process ${process.session}`),
-  ];
-  const tasks = (handoff.state.work_items ?? []).filter(item => item.status === "active" || item.status === "blocked")
-    .map(item => ({ what: item.what, status: item.status === "blocked" ? "blocked" as const : "active" as const }));
-  return {
-    handoff: {
-      verified: handoff.state.completed.map(item => item.what),
-      inFlight: handoff.state.in_flight.map(item => item.what),
-      unverified: handoff.state.unverified_claims.map(item => item.what),
-    },
-    tasks, background,
-  };
-}
-
-const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-
-/** "20:13" today, "Oct 5 20:13" on another day, in the given local offset. */
-export function sessionClock(iso: string, now: Date, offsetMinutes = -now.getTimezoneOffset()): string | undefined {
-  const at = Date.parse(iso);
-  if (!Number.isFinite(at)) return undefined;
-  const local = (ms: number) => new Date(ms + offsetMinutes * 60_000);
-  const t = local(at), n = local(now.getTime());
-  const hhmm = `${String(t.getUTCHours()).padStart(2, "0")}:${String(t.getUTCMinutes()).padStart(2, "0")}`;
-  const sameDay = t.getUTCFullYear() === n.getUTCFullYear() && t.getUTCMonth() === n.getUTCMonth() && t.getUTCDate() === n.getUTCDate();
-  return sameDay ? hhmm : `${MONTHS[t.getUTCMonth()]} ${t.getUTCDate()} ${hhmm}`;
-}

package/src/apps/ui/surface.ts

@@ -1,91 +0,0 @@
-/**
- * What command and turn code may ask of the interactive UI. shell.ts
- * depends on this interface only; apps/ui/app.ts implements it. A null Ui
- * means print/json/line mode, where every branch has a text fallback.
- */
-import type { ImageRef, UserInput } from "../../core/images.ts";
-import type { Phase, QueueKind } from "../../core/queue.ts";
-import type { PermissionRequest } from "../../core/permissions.ts";
-import type { ApprovalChoice } from "../../runtime/tools.ts";
-import type { LoopEvent } from "../../runtime/loop.ts";
-import type { ExtensionUI } from "../../runtime/extension-ui.ts";
-import type { ClipboardContent } from "../../runtime/clipboard.ts";
-import type { CallbackServer, OAuthCredential, OAuthInteraction } from "../../runtime/oauth.ts";
-
-export interface TurnSurface {
-  pushDelta(kind: "text" | "thinking", text: string): void;
-  discardStream(): void;
-  commitStream(): void;
-  syncTranscript(): Promise<void>;
-  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 {
-  readonly extensionUi: ExtensionUI;
-  readonly signal: AbortSignal | undefined;
-  readonly queueLength: number;
-  sessionName: string | null;
-  oauthEffects: OAuthEffects;
-  clipboardWriter: (text: string) => boolean | Promise<boolean>;
-  clipboardReader: () => Promise<ClipboardContent>;
-
-  /** Notices and documents in the message stream. */
-  notice(text: string, tone?: "info" | "success" | "warning" | "error"): void;
-  showDocument(title: string, text: string): void;
-  checkForUpdate(): void;
-  toast(text: string, tone?: "info" | "success" | "warning" | "error"): void;
-  redraw(): void;
-
-  /** A masked single-line form; resolves undefined when cancelled. The value never reaches a renderable. */
-  askSecret(title: string, label: string, hint: string): Promise<string | undefined>;
-  confirm(title: string, message: string): Promise<boolean>;
-  /** A cancellable "waiting" dialog (OAuth browser / device code). Returns a closer. */
-  waiting(title: string, lines: readonly string[], onCancel: () => void, pasteLabel?: string, onPaste?: (value: string) => void): () => void;
-
-  openLogin(method?: "oauth" | "api_key"): void;
-  openLogout(): void;
-  openModel(): void;
-  openScopedModels(): void;
-  openThinking(): void;
-  openSettings(field?: string): void;
-  openResume(): Promise<void>;
-  openFork(): Promise<void>;
-  openTree(): Promise<void>;
-  openResources(): Promise<void>;
-  openControl(tab?: "goal" | "progress" | "context"): Promise<void>;
-  /** S.5: draft criteria for an objective, ask the user which to accept, then work toward them. */
-  startGoal(objective: string): void;
-  openTrust(): Promise<void>;
-  openAttachments(): void;
-
-  restoreDraft(text: string, images?: readonly ImageRef[]): void;
-  refreshResources(): Promise<void>;
-  applyConfiguration(): void;
-  followTheme(): void;
-  beginBash(command: string): void;
-  pushBash(chunk: Uint8Array): void;
-  ask(request: PermissionRequest): Promise<ApprovalChoice>;
-
-  runExtensionAction(action: () => void | Promise<void>): void;
-  runExtensionCommand(name: string, args: string): void;
-  runSessionTransition(action: () => Promise<void>): void;
-  deliverExtension(text: string, kind: QueueKind): void;
-  bindExtensionRegistry(): void;
-  requestShutdown(): void;
-  /** Abort the running turn (Esc semantics) without quitting. */
-  interrupt(): void;
-  /** Plain-text snapshot of the current frame (/debug). */
-  snapshot(): { width: number; height: number; lines: string[] };
-}
-
-/** Injectable OAuth side effects (browser, callback server, device flow, fetch). */
-export interface OAuthEffects {
-  fetch: typeof globalThis.fetch;
-  openBrowser(url: string): void;
-  callback(options: { expectedState: string; host: string; port: number; path: string }): Promise<CallbackServer>;
-  device(interaction: OAuthInteraction): Promise<OAuthCredential>;
-}

package/src/apps/ui/theme.ts

@@ -1,86 +0,0 @@
-/**
- * core Theme + the terminal's reported palette → the view's colours.
- *
- * Built-in appearances (dark, light, system/auto) take every colour from the
- * terminal (tui/ui/ink.ts); their name only says which way to guess when the
- * terminal does not answer the palette query. A custom theme file is an
- * explicit choice and is drawn with its own colours; it paints a background
- * only when it sets one (refactor-tui-terminal-colors).
- */
-import type { TerminalColors } from "@opentui/core";
-import { isBuiltinTheme, type Theme } from "../../core/theme.ts";
-import { colorsFromInks, rgba, type UiColors } from "../../tui/ui/colors.ts";
-import { isHex, terminalInks, type InkSet, type InkSpec, type TerminalPalette } from "../../tui/ui/ink.ts";
-
-/** OpenTUI's detection result → the 16-slot palette ink.ts expects, or null when incomplete. */
-export function terminalPalette(colors: TerminalColors | null | undefined): TerminalPalette | null {
-  if (!colors) return null;
-  const slots = colors.palette.slice(0, 16).map(hex => normalizeHex(hex));
-  const foreground = normalizeHex(colors.defaultForeground), background = normalizeHex(colors.defaultBackground);
-  if (!foreground || !background || slots.length < 16 || slots.some(slot => !slot)) return null;
-  const hb = normalizeHex(colors.highlightBackground), hf = normalizeHex(colors.highlightForeground);
-  return { foreground, background, slots: slots as string[], ...(hb && hf ? { highlight: { background: hb, foreground: hf } } : {}) };
-}
-
-function normalizeHex(value: string | null | undefined): string | undefined {
-  if (!value) return undefined;
-  const hex = value.startsWith("#") ? value : `#${value}`;
-  return isHex(hex) ? hex.toLowerCase() : undefined;
-}
-
-function hint(theme: Theme): "dark" | "light" { return theme.name === "light" ? "light" : "dark"; }
-
-/** "38;2;r;g;b" / "48;2;r;g;b" → "#rrggbb"; anything else is undefined. */
-export function sgrHex(value: string | undefined): string | undefined {
-  const match = value ? /(?:^|;)[34]8;2;(\d+);(\d+);(\d+)/.exec(value) : null;
-  if (!match) return undefined;
-  return "#" + [match[1], match[2], match[3]].map(n => Math.max(0, Math.min(255, Number(n))).toString(16).padStart(2, "0")).join("");
-}
-
-export function uiColors(theme: Theme, palette: TerminalPalette | null = null): UiColors {
-  const terminal = colorsFromInks(terminalInks(palette, hint(theme)));
-  if (isBuiltinTheme(theme)) return terminal;
-  // A theme file's colours are the user's explicit choice; tokens it leaves
-  // out (or sets to the terminal default) still come from the terminal.
-  const pick = (...tokens: string[]) => { const hex = tokens.map(token => sgrHex(theme.colors[token])).find(Boolean); return hex ? rgba(hex) : undefined; };
-  return {
-    background: pick("background") ?? terminal.background,
-    text: pick("text") ?? terminal.text,
-    muted: pick("muted", "toolOutput") ?? terminal.muted,
-    edge: pick("border", "borderMuted") ?? terminal.edge,
-    line: pick("borderMuted", "border") ?? terminal.line,
-    accent: pick("accent", "mdLink") ?? terminal.accent,
-    success: pick("success", "toolDiffAdded") ?? terminal.success,
-    error: pick("error", "toolDiffRemoved") ?? terminal.error,
-    warning: pick("warning") ?? terminal.warning,
-    reasoning: pick("thinkingText") ?? terminal.reasoning,
-    code: pick("mdCode") ?? terminal.code,
-    selectionBg: pick("selectedBg") ?? terminal.selectionBg,
-    selectionFg: terminal.selectionFg,
-  };
-}
-
-/**
- * SGR tokens for the ANSI renderers (tool details, diffs, code highlighting)
- * from the same terminal-derived inks, so text drawn through ANSI strings
- * matches the view. Custom themes keep their own tokens.
- */
-export function styleTokens(theme: Theme, palette: TerminalPalette | null): Readonly<Record<string, string>> {
-  if (!isBuiltinTheme(theme)) return theme.colors;
-  const inks: InkSet = terminalInks(palette, hint(theme));
-  const sgr = (spec: InkSpec): string => spec.kind === "default" ? "" : spec.kind === "index"
-    ? String(spec.index < 8 ? 30 + spec.index : 90 + spec.index - 8)
-    : `38;2;${[1, 3, 5].map(i => Number.parseInt(spec.hex.slice(i, i + 2), 16)).join(";")}`;
-  const muted = sgr(inks.muted);
-  return {
-    ...theme.colors,
-    text: "", prompt: "", toolTitle: "",
-    muted, dim: muted, status: muted, toolOutput: muted, thinkingOff: muted, syntaxComment: muted,
-    error: sgr(inks.error), toolDiffRemoved: sgr(inks.error), toolDiffAdded: sgr(inks.success), success: sgr(inks.success),
-    warning: sgr(inks.warning), syntaxNumber: sgr(inks.warning),
-    accent: sgr(inks.accent), mdHeading: sgr(inks.accent), mdLink: sgr(inks.accent), syntaxFunction: sgr(inks.accent),
-    mdCode: sgr(inks.code), syntaxString: sgr(inks.success),
-    thinkingText: sgr(inks.reasoning), syntaxKeyword: sgr(inks.reasoning),
-    border: sgr(inks.line), borderMuted: sgr(inks.line),
-  };
-}

package/src/apps/update-check.ts

@@ -1,112 +0,0 @@
-/** Shared lifecycle for automatic hints and explicit checks; policy remains in core (D16). */
-import { dirname } from "node:path";
-import { installArgv, installKind, installResult, manualUpdateResult, updateDisabled, updatePlan, type UpdateInput } from "../core/update-check.ts";
-import { packageLocation, readUpdateCache, writeUpdateCache } from "../store/update-cache.ts";
-import { fetchLatestVersion, UPDATE_TIMEOUT_MS } from "../runtime/update-check.ts";
-import { INSTALL_TIMEOUT_MS, runInstall } from "../runtime/self-update.ts";
-import { XENO_VERSION } from "../runtime/version.ts";
-
-export interface UpdateOptions {
-  readonly offline?: boolean;
-  readonly enabled?: boolean | undefined;
-  /** Install a newer release after the check: `/update` does, `xeno update --check` never does. */
-  readonly install?: boolean;
-}
-
-export type ManualUpdateActivity =
-  | { readonly state: "checking"; readonly current: string; readonly timeoutMs: number }
-  | { readonly state: "installing"; readonly version: string; readonly timeoutMs: number; readonly startedAt: number; readonly detail?: string }
-  | { readonly state: "idle" };
-
-type ManualUpdateReporter = (text: string, tone?: "info" | "error") => void;
-
-export class UpdateChecks {
-  private readonly controller = new AbortController();
-  private pending: Promise<string | null> | undefined;
-  private manualTask: Promise<number> | undefined;
-  /** The release this process already installed; the running code stays old until a restart. */
-  private installed: string | undefined;
-
-  async prepare(options: UpdateOptions, manual = false) {
-    const location = packageLocation();
-    const input: UpdateInput = { current: XENO_VERSION, now: Date.now(), cache: await readUpdateCache(), env: process.env,
-      offline: options.offline === true, enabled: options.enabled, install: installKind(location.root, location.git), manual };
-    return { input, plan: updatePlan(input), disabled: updateDisabled(input) };
-  }
-
-  /** One request and one cache write even when a manual check joins startup's request. */
-  refresh(input: UpdateInput): Promise<string | null> {
-    if (this.pending) return this.pending;
-    const pending = (async () => {
-      const latest = await fetchLatestVersion(input.env["npm_config_registry"], { signal: this.controller.signal });
-      if (!this.controller.signal.aborted) {
-        const known = latest ?? input.cache?.latest;
-        await writeUpdateCache({ checkedAt: Date.now(), ...(known ? { latest: known } : {}) });
-      }
-      return latest;
-    })().finally(() => { if (this.pending === pending) this.pending = undefined; });
-    this.pending = pending;
-    return pending;
-  }
-
-  manual(options: UpdateOptions, say: ManualUpdateReporter, onActivity?: (activity: ManualUpdateActivity) => void): Promise<number> {
-    if (this.manualTask) return this.manualTask;
-    const task = this.runManual(options, say, onActivity).finally(() => { if (this.manualTask === task) this.manualTask = undefined; });
-    this.manualTask = task;
-    return task;
-  }
-
-  private async runManual(options: UpdateOptions, say: ManualUpdateReporter, onActivity?: (activity: ManualUpdateActivity) => void): Promise<number> {
-    if (options.install && this.installed) {
-      say(`xeno ${this.installed} is already installed. Restart xeno to use it.`);
-      return 0;
-    }
-    const { input, plan, disabled } = await this.prepare(options, true);
-    if (this.controller.signal.aborted) return 130;
-    if (!plan.check) {
-      say(input.install === "checkout" ? `Source checkout: xeno ${input.current}. Use git pull to update this checkout.`
-        : `Update check skipped: ${disabled ?? "check unavailable"} (xeno ${input.current}).`);
-      return input.install === "checkout" ? 0 : 1;
-    }
-    if (onActivity) onActivity({ state: "checking", current: input.current, timeoutMs: UPDATE_TIMEOUT_MS });
-    else say(`Checking for xeno updates (current ${input.current})...`);
-    try {
-      const latest = await this.refresh(input);
-      if (this.controller.signal.aborted) return 130;
-      const result = manualUpdateResult(latest, input.current, input.install);
-      const argv = options.install && result.status === "available" && latest ? installArgv(input.install, latest) : undefined;
-      if (!argv || !latest) {
-        say(result.text, result.status === "failed" ? "error" : "info");
-        return result.status === "failed" ? 1 : 0;
-      }
-      return await this.install(argv, latest, input.current, say, onActivity);
-    } finally {
-      if (onActivity) onActivity({ state: "idle" });
-    }
-  }
-
-  private async install(argv: readonly string[], latest: string, current: string, say: ManualUpdateReporter, onActivity?: (activity: ManualUpdateActivity) => void): Promise<number> {
-    const startedAt = Date.now();
-    if (onActivity) onActivity({ state: "installing", version: latest, timeoutMs: INSTALL_TIMEOUT_MS, startedAt });
-    else say(`Installing xeno ${latest} with ${argv.join(" ")}...`);
-    const outcome = await runInstall(argv, {
-      signal: this.controller.signal, timeoutMs: INSTALL_TIMEOUT_MS, writableDir: dirname(packageLocation().root),
-      ...(onActivity ? { onLine: (detail: string) => onActivity({ state: "installing", version: latest, timeoutMs: INSTALL_TIMEOUT_MS, startedAt, detail }) } : {}),
-    });
-    if (outcome.kind === "cancelled") return 130;
-    const result = installResult(outcome, argv, current, latest);
-    if (result.ok) this.installed = latest;
-    say(result.text, result.ok ? "info" : "error");
-    return result.ok ? 0 : 1;
-  }
-
-  cancel(): void { this.controller.abort(); }
-}
-
-/** A standalone command has no UI lifecycle to own cancellation. */
-export async function runManualUpdate(options: UpdateOptions, say: (text: string) => void): Promise<number> {
-  const checks = new UpdateChecks(), cancel = () => checks.cancel();
-  process.once("SIGINT", cancel); process.once("SIGTERM", cancel);
-  try { return await checks.manual(options, say); }
-  finally { checks.cancel(); process.off("SIGINT", cancel); process.off("SIGTERM", cancel); }
-}

package/src/apps/workflow.ts

@@ -1,58 +0,0 @@
-/** D5/D6: the app changes capabilities only through the live session's checkpoint owner. */
-import { isWorkflowMode, workflowInstructions, type WorkflowMode } from "../core/workflow-mode.ts";
-import { sessionControl } from "../runtime/session-control.ts";
-import { sessionToolCatalog, type App } from "./startup.ts";
-
-export type WorkflowApp = Pick<App, "args" | "session" | "extensions" | "system">;
-
-export async function setAppWorkflow(app: WorkflowApp, mode: WorkflowMode): Promise<boolean> {
-  if (!isWorkflowMode(mode)) throw Error("workflow mode must be build or plan");
-  const session = app.session, previousMode = session.config.tools.workflowMode;
-  const current = previousMode ?? app.args.workflow ?? "build";
-  return sessionControl(session).withIdleChange(async () => {
-    const previousProfile = session.config.agentProfile, name = previousProfile?.name ?? app.args.agent;
-    const nextProfile = name ? { name, workflowExplicit: true } : undefined;
-    const args = structuredClone(app.args), previousScope = session.config.workflowToolProfile;
-    const promote = mode === "plan" && args.tools === undefined && !args.noTools && args.toolProfile === undefined;
-    if (promote) args.toolProfile = "foundation";
-    const nextScope = args.toolProfile === "foundation" ? "foundation" as const : undefined;
-    const metadataChanged = JSON.stringify(previousProfile) !== JSON.stringify(nextProfile) || previousScope !== nextScope;
-    if (mode === current && !metadataChanged && !promote) {
-      app.args.workflow = mode; app.args.cliFlags = [...new Set([...app.args.cliFlags ?? [], "--workflow"])];
-      return false;
-    }
-    const oldInstruction = workflowInstructions(current), nextInstruction = workflowInstructions(mode);
-    // Replace only a complete harness paragraph: user context and all other frozen bytes survive.
-    const paragraphs = session.config.frozen.system.split("\n\n");
-    const index = paragraphs.indexOf(oldInstruction);
-    if (index >= 0) paragraphs[index] = nextInstruction; else paragraphs.push(nextInstruction);
-    const system = mode === current ? session.config.frozen.system : paragraphs.join("\n\n");
-    const catalog = sessionToolCatalog({ ...args, workflow: mode }, app.extensions, session.config.frozen.tools);
-    // The persisted checkpoint owns the admission mode as well as declarations, including cold restore.
-    session.config.tools.workflowMode = mode;
-    if (nextProfile) session.config.agentProfile = nextProfile;
-    if (nextScope) session.config.workflowToolProfile = nextScope; else delete session.config.workflowToolProfile;
-    try {
-      const changed = await session.reloadResources(mode === current && !promote ? session.config.frozen : { ...session.config.frozen, system, tools: catalog.schemas }, undefined, undefined, metadataChanged);
-      if (mode !== current || promote) session.config.tools.deferredTools = catalog.deferred;
-      args.workflow = mode; args.cliFlags = [...new Set([...args.cliFlags ?? [], "--workflow"])]; app.args = args; app.system = system;
-      return changed;
-    } catch (error) {
-      if (previousMode === undefined) delete session.config.tools.workflowMode;
-      else session.config.tools.workflowMode = previousMode;
-      if (previousProfile === undefined) delete session.config.agentProfile;
-      else session.config.agentProfile = previousProfile;
-      if (previousScope === undefined) delete session.config.workflowToolProfile;
-      else session.config.workflowToolProfile = previousScope;
-      throw error;
-    }
-  });
-}
-
-export function bindAppWorkflow(app: WorkflowApp): void {
-  const session = app.session;
-  sessionControl(session).configureWorkflow = async mode => {
-    if (app.session !== session) throw Error("this session is no longer attached to the app");
-    await setAppWorkflow(app, mode);
-  };
-}