@visual-z/xeno 0.8.4 → 0.9.1

package/src/apps/commands.ts

@@ -1,319 +0,0 @@
-/**
- * Slash-command dispatch as a pure function.
- *
- * Matching the first token, not a string prefix, is the whole point: a
- * prompt that starts with `/backdrop` used to be swallowed as `/back`.
- * Unknown lone `/word`s are `unknown`; a slash-like word followed by
- * more text is a prompt, so ordinary sentences stay ordinary.
- *
- * Prompt templates and skills register names into the same space. Built-in
- * commands win, then templates, then skills; a loser is named, never silent.
- */
-
-import type { RewindMode } from "../runtime/loop.ts";
-import { expandTemplate, type PromptTemplate } from "../core/prompts.ts";
-import { skillInvocationMessage, type Skill } from "../core/skills.ts";
-
-export type Command =
-  | { kind: "workflow"; mode: "build" | "plan" }
-  | { kind: "agent"; name?: string }
-  | { kind: "mcp"; action: "status" | "login" | "logout"; name?: string }
-  | { kind: "review" | "diff"; args: string }
-  | { kind: "extension"; name: string; args: string }
-  | { kind: "prompt"; text: string; skill?: Skill }
-  | { kind: "quit" }
-  | { kind: "usage" }
-  | { kind: "state" }
-  | { kind: "context" }
-  | { kind: "control" }
-  | { kind: "acceptance" }
-  | { kind: "tasks" }
-  | { kind: "branches"; action?: "wait" | "cancel" | "status"; node?: number }
-  | { kind: "processes" }
-  | { kind: "accept"; criterion: string }
-  | { kind: "goal"; action: "status" } | { kind: "goal"; action: "clear" } | { kind: "goal"; action: "accept"; pick: string }
-  | { kind: "goal"; action: "set"; objective: string }
-  | { kind: "model"; pattern?: string }
-  | { kind: "scoped-models" }
-  | { kind: "login"; provider?: string }
-  | { kind: "logout"; provider?: string }
-  | { kind: "back"; arg?: string; mode: RewindMode; confirm: boolean }
-  | { kind: "tree" }
-  | { kind: "new" }
-  | { kind: "resume"; id?: string }
-  | { kind: "name"; name: string }
-  | { kind: "session" }
-  | { kind: "help" }
-  | { kind: "trust"; target?: "here" | "parent" | "never" | "once" }
-  | { kind: "reload" }
-  | { kind: "config" }
-  | { kind: "models-refresh" }
-  | { kind: "settings"; field?: string; value?: string }
-  | { kind: "hotkeys" }
-  | { kind: "thinking"; level?: string }
-  | { kind: "export"; file?: string }
-  | { kind: "import"; file?: string }
-  | { kind: "debug"; file?: string }
-  | { kind: "changelog" }
-  | { kind: "update" }
-  | { kind: "copy" }
-  | { kind: "attachments" }
-  | { kind: "fork"; arg?: string }
-  | { kind: "clone" }
-  | { kind: "unknown"; input: string };
-
-/** One catalog owns discoverability, parsing and busy-turn policy. */
-export const COMMANDS = [
-  { name: "model", description: "Choose a model", argumentHint: "[id]", busy: "idle" },
-  { name: "scoped-models", description: "Enable and order models for cycling", busy: "idle" },
-  { name: "thinking", description: "Set reasoning effort", argumentHint: "[level]", busy: "idle" },
-  { name: "settings", description: "Configure appearance, input and model behavior", argumentHint: "[key value]", busy: "idle" },
-  { name: "provider", description: "Connect and manage providers: account, API key, gateway or local server", argumentHint: "[provider]", busy: "idle" },
-  { name: "logout", description: "Remove a stored credential", argumentHint: "[provider]", busy: "idle" },
-  { name: "new", description: "Start a new session", busy: "idle" },
-  { name: "resume", description: "Search saved sessions", argumentHint: "[id]", busy: "idle" },
-  { name: "tree", description: "Navigate session context", busy: "run" },
-  { name: "fork", description: "Fork at a user message", argumentHint: "[n]", busy: "idle" },
-  { name: "clone", description: "Copy this branch into a new session", busy: "idle" },
-  { name: "back", description: "Restore context or files explicitly", argumentHint: "[n [files|context|both] [confirm]]", busy: "idle" },
-  { name: "name", description: "Name this session", argumentHint: "<name>", busy: "idle" },
-  { name: "session", description: "Show session details", busy: "run" },
-  { name: "usage", description: "Show token usage and costs", busy: "run" },
-  { name: "state", description: "Show log and handoff state", busy: "run" },
-  { name: "context", description: "Explain context sources, omissions and token estimates", busy: "run" },
-  { name: "control", description: "Inspect the goal, evidence and context; control the active turn", busy: "run" },
-  { name: "acceptance", description: "Show declared criteria and current evidence", busy: "idle" },
-  { name: "tasks", description: "Show work dependencies, readiness and ownership", busy: "run" },
-  { name: "branches", description: "Inspect or join owned background work", argumentHint: "[wait|cancel|status node]", busy: "idle" },
-  { name: "processes", description: "Show process observations and available handles", busy: "run" },
-  { name: "accept", description: "Record your acceptance of a human criterion", argumentHint: "<criterion ID>", busy: "idle" },
-  { name: "goal", description: "Set a goal: the model drafts checks, you accept them, work continues until they pass", argumentHint: "<objective> | clear | accept all|1,3", busy: "idle" },
-  { name: "export", description: "Export HTML or JSONL", argumentHint: "[file]", busy: "idle" },
-  { name: "import", description: "Import a portable JSONL session", argumentHint: "<file>", busy: "idle" },
-  { name: "debug", description: "Write local terminal diagnostics", argumentHint: "[file]", busy: "run" },
-  { name: "changelog", description: "Show local release notes", busy: "run" },
-  { name: "update", description: "Check for a newer xeno and install it; restart to use it", busy: "run" },
-  { name: "copy", description: "Copy the last assistant reply", busy: "run" },
-  { name: "attachments", description: "Remove images from the current draft", busy: "run" },
-  { name: "models", description: "Refresh the model catalog", argumentHint: "<refresh>", busy: "idle" },
-  { name: "trust", description: "Set workspace configuration trust", argumentHint: "[here|parent|never]", busy: "idle" },
-  { name: "reload", description: "Reload settings, skills, prompts, themes and models", busy: "idle" },
-  { name: "config", description: "Configure resource sources and enablement", busy: "idle" },
-  { name: "hotkeys", description: "Show active keybindings", busy: "run" },
-  { name: "help", description: "Show commands and input help", busy: "run" },
-  { name: "quit", description: "Exit xeno", busy: "run" },
-  { name: "exit", description: "Exit xeno", busy: "run" },
-  { name: "plan", description: "Explore and plan with read-only capabilities", busy: "idle" },
-  { name: "build", description: "Enable implementation at a resource checkpoint", busy: "idle" },
-  { name: "agent", description: "List or select a reusable agent profile", argumentHint: "[name]", busy: "idle" },
-  { name: "mcp", description: "Inspect MCP servers or log in/out", argumentHint: "[status|login|logout [name]]", busy: "idle" },
-  { name: "diff", description: "Inspect current, branch, commit or last-turn changes", argumentHint: "[working|branch base|commit sha|last-turn]", busy: "idle" },
-  // /review already belongs to existing user prompt/skill resources. Keep it usable.
-  { name: "review-code", description: "Run an independent read-only code review", argumentHint: "[working|branch base|commit sha|last-turn]", busy: "idle" },
-] as const;
-
-/**
- * Hidden spellings of a listed command. Not in COMMANDS, so the `/` menu,
- * the startup hint and completion show one entry per job.
- */
-const ALIASES: Readonly<Record<string, string>> = { login: "provider", connect: "provider" };
-
-// Hidden spellings still own their names, so resources cannot promise an unreachable route.
-export const BUILTIN_COMMAND_NAMES: readonly string[] = [...COMMANDS.map(command => command.name), ...Object.keys(ALIASES)];
-
-export function commandDefinition(input: string): (typeof COMMANDS)[number] | undefined {
-  const typed = input.trim().split(/\s/, 1)[0]?.slice(1).toLowerCase() ?? "";
-  const name = ALIASES[typed] ?? typed;
-  return COMMANDS.find((command) => command.name === name);
-}
-
-const BUILTIN_SET = new Set<string>(BUILTIN_COMMAND_NAMES);
-
-export interface SlashCatalog {
-  readonly prompts: ReadonlyMap<string, PromptTemplate>;
-  readonly skills: ReadonlyMap<string, Skill>;
-  readonly skillCommands?: boolean;
-  readonly skillExecution?: boolean;
-}
-
-export function resolveSlashCatalog(
-  prompts: readonly PromptTemplate[],
-  skills: readonly Skill[],
-): { catalog: SlashCatalog; diagnostics: readonly string[] } {
-  const diagnostics: string[] = [];
-  const promptMap = new Map<string, PromptTemplate>();
-  const skillMap = new Map<string, Skill>();
-
-  for (const prompt of prompts) {
-    if (BUILTIN_SET.has(prompt.name)) {
-      diagnostics.push(
-        `prompt template "${prompt.name}" from ${prompt.filePath} is shadowed by a built-in command`,
-      );
-      continue;
-    }
-    promptMap.set(prompt.name, prompt);
-  }
-
-  for (const skill of skills) {
-    if (BUILTIN_SET.has(skill.name)) {
-      diagnostics.push(
-        `skill "${skill.name}" from ${skill.filePath} is shadowed by a built-in command`,
-      );
-      continue;
-    }
-    const prompt = promptMap.get(skill.name);
-    if (prompt !== undefined) {
-      diagnostics.push(
-        `skill "${skill.name}" from ${skill.filePath} is shadowed by prompt template ${prompt.filePath}`,
-      );
-      continue;
-    }
-    skillMap.set(skill.name, skill);
-  }
-
-  return { catalog: { prompts: promptMap, skills: skillMap }, diagnostics };
-}
-
-export function parseCommand(input: string, catalog?: SlashCatalog): Command {
-  const text = input.trim();
-  if (!text.startsWith("/")) return { kind: "prompt", text };
-
-  const [head, ...rest] = text.split(/\s+/);
-  const typed = (head ?? "").toLowerCase();
-  const token = `/${ALIASES[typed.slice(1)] ?? typed.slice(1)}`;
-  if (token === "/control") return { kind: "control" };
-  const arg = rest.join(" ");
-
-  if (!commandDefinition(text)) return resolveRegistered(token, arg, text, rest.length, catalog);
-
-  switch (token) {
-    case "/plan": return arg ? { kind: "unknown", input: text } : { kind: "workflow", mode: "plan" };
-    case "/build": return arg ? { kind: "unknown", input: text } : { kind: "workflow", mode: "build" };
-    case "/agent": return arg ? { kind: "agent", name: arg } : { kind: "agent" };
-    case "/mcp": { const [action = "status", name] = rest; return ["status", "login", "logout"].includes(action) && rest.length <= 2 ? { kind: "mcp", action: action as "status" | "login" | "logout", ...(name ? { name } : {}) } : { kind: "unknown", input: text }; }
-    case "/diff": return { kind: "diff", args: arg };
-    case "/review-code": return { kind: "review", args: arg };
-    case "/reload": return { kind: "reload" };
-    case "/config": return { kind: "config" };
-    case "/update": return arg === "" ? { kind: "update" } : { kind: "unknown", input: text };
-    case "/attachments": return { kind: "attachments" };
-    case "/scoped-models": return { kind: "scoped-models" };
-    case "/quit":
-    case "/exit":
-      return { kind: "quit" };
-    case "/usage":
-      return { kind: "usage" };
-    case "/state":
-      return { kind: "state" };
-    case "/context": return { kind: "context" };
-    case "/acceptance": return { kind: "acceptance" };
-    case "/tasks": return { kind: "tasks" };
-    case "/processes": return { kind: "processes" };
-    case "/branches": {
-      if (!arg) return { kind: "branches" };
-      const action = rest[0], node = Number(rest[1]);
-      return (action === "wait" || action === "cancel" || action === "status") && Number.isSafeInteger(node) && node >= 0 && rest.length === 2
-        ? { kind: "branches", action, node } : { kind: "unknown", input: text };
-    }
-    case "/accept": return { kind: "accept", criterion: arg };
-    case "/goal":
-      if (!arg) return { kind: "goal", action: "status" };
-      if (arg === "clear") return { kind: "goal", action: "clear" };
-      if (rest[0] === "accept") return { kind: "goal", action: "accept", pick: rest.slice(1).join(" ") };
-      return { kind: "goal", action: "set", objective: arg };
-    case "/model":
-      return arg.length > 0 ? { kind: "model", pattern: arg } : { kind: "model" };
-    case "/provider":
-      return rest[0] === undefined ? { kind: "login" } : { kind: "login", provider: rest[0] };
-    case "/logout":
-      return rest[0] === undefined ? { kind: "logout" } : { kind: "logout", provider: rest[0] };
-    case "/back": {
-      const [n, ...flags] = rest;
-      const words = new Set(flags);
-      const mode: RewindMode =
-        words.has("files") ? "files" : words.has("context") ? "context" : "both";
-      const confirm = words.has("confirm");
-      return n === undefined
-        ? { kind: "back", mode, confirm }
-        : { kind: "back", arg: n, mode, confirm };
-    }
-    case "/tree":
-      return { kind: "tree" };
-    case "/new":
-      return { kind: "new" };
-    case "/resume":
-      return arg.length > 0 ? { kind: "resume", id: arg } : { kind: "resume" };
-    case "/name":
-      return { kind: "name", name: arg };
-    case "/session":
-      return { kind: "session" };
-    case "/help":
-      return { kind: "help" };
-    case "/models":
-      return arg === "refresh" ? { kind: "models-refresh" } : { kind: "unknown", input: text };
-    case "/settings": {
-      if (rest.length === 0) return { kind: "settings" };
-      const field = rest[0];
-      if (field === undefined) return { kind: "settings" };
-      if (rest.length === 1) return { kind: "settings", field };
-      return { kind: "settings", field, value: rest.slice(1).join(" ") };
-    }
-    case "/hotkeys":
-      return { kind: "hotkeys" };
-    case "/thinking":
-      return arg.length > 0 ? { kind: "thinking", level: arg } : { kind: "thinking" };
-    case "/changelog": return { kind: "changelog" };
-    case "/export":
-    case "/import":
-    case "/debug": {
-      const kind = token.slice(1) as "export" | "import" | "debug";
-      const path = text.slice(head!.length).trim().replace(/^(?:"(.*)"|'(.*)')$/, (_m, double: string | undefined, single: string | undefined) => double ?? single ?? "");
-      return path ? { kind, file: path } : { kind };
-    }
-    case "/copy":
-      return { kind: "copy" };
-    case "/fork":
-      return arg.length > 0 ? { kind: "fork", arg } : { kind: "fork" };
-    case "/clone":
-      return { kind: "clone" };
-    case "/trust": {
-      if (!rest.length) return { kind: "trust" };
-      const word = (rest[0] ?? "here").toLowerCase();
-      if (word === "once") return { kind: "trust", target: "once" };
-      if (rest.length === 0 || word === "here" || word === "yes") {
-        return { kind: "trust", target: "here" };
-      }
-      if (word === "parent") return { kind: "trust", target: "parent" };
-      if (word === "never" || word === "no") return { kind: "trust", target: "never" };
-      return { kind: "unknown", input: text };
-    }
-    default:
-      return resolveRegistered(token, arg, text, rest.length, catalog);
-  }
-}
-
-function resolveRegistered(
-  token: string,
-  arg: string,
-  text: string,
-  restCount: number,
-  catalog: SlashCatalog | undefined,
-): Command {
-  if (catalog !== undefined) {
-    if (token.startsWith("/skill:") && catalog.skillCommands !== false) {
-      const name = token.slice("/skill:".length);
-      const skill = catalog.skills.get(name);
-      if (skill !== undefined) {
-        if (skill.userInvocable === false) return { kind: "unknown", input: text };
-        return { kind: "prompt", text: skillInvocationMessage(skill, arg), ...(catalog.skillExecution ? { skill } : {}) };
-      }
-    }
-    const prompt = catalog.prompts.get(token.slice(1));
-    if (prompt !== undefined) {
-      return { kind: "prompt", text: expandTemplate(prompt.content, arg).text };
-    }
-  }
-  // A lone unknown /word is a failed command. More text means the user
-  // typed a sentence that happens to start with a slash-like token.
-  return restCount === 0 ? { kind: "unknown", input: text } : { kind: "prompt", text };
-}

package/src/apps/completions.ts

@@ -1,87 +0,0 @@
-/**
- * What the composer offers for the text at the cursor. Pure given its
- * sources, so the three cases are tested without a terminal:
- *   "/mo|"          command names (the palette's own entries)
- *   "/thinking h|" the command's argument values
- *   "see @src/ap|"  workspace paths (ranked fuzzy, quoted when they contain spaces)
- * `@` inside a word (an e-mail) or after a backslash is not a reference.
- */
-import type { App } from "./startup.ts";
-import { SUBSCRIPTION_OPTIONS, subscriptionById } from "../runtime/oauth.ts";
-import { supportedThinkingLevels } from "../core/thinking.ts";
-import { interactiveSettingKeys } from "../core/settings.ts";
-import { fuzzyFilter } from "../tui/fuzzy.ts";
-import { COMMANDS, commandDefinition } from "./commands.ts";
-import { commandCompletionRank } from "../core/completion-action.ts";
-import type { Completion } from "../tui/ui/composer.ts";
-import type { ListItem } from "../tui/ui/list-model.ts";
-
-export interface CompletionSources {
-  readonly commands: readonly { name: string; description: string }[];
-  readonly argumentValues: (command: string) => readonly string[];
-  readonly paths: readonly string[];
-}
-
-/** Twelve rows: enough to see siblings of a path without hiding the composer. Assumed. */
-const MAX_ITEMS = 12;
-
-export function completionAt(text: string, cursor: number, sources: CompletionSources): Completion | undefined {
-  const before = text.slice(0, cursor);
-  const line = before.slice(before.lastIndexOf("\n") + 1);
-  const lineStart = cursor - line.length;
-  if (line.startsWith("/") && lineStart === 0) {
-    const space = line.indexOf(" ");
-    if (space < 0) {
-      const query = line.slice(1).toLowerCase();
-      const items = sources.commands
-        .map(command => ({ command, rank: commandCompletionRank(command.name, query) }))
-        .filter(item => Number.isFinite(item.rank)).sort((a, b) => a.rank - b.rank)
-        .map(({ command }) => ({ value: `/${command.name} `, label: `/${command.name}`, description: command.description }));
-      return items.length ? { kind: "command", start: 0, end: cursor, items: items.slice(0, MAX_ITEMS) } : undefined;
-    }
-    const command = line.slice(1, space).toLowerCase();
-    const arg = line.slice(space + 1);
-    if (arg.includes(" ")) return undefined;
-    const values = sources.argumentValues(command);
-    if (!values.length) return undefined;
-    const items = fuzzyFilter(values, arg).slice(0, MAX_ITEMS).map(value => ({ value, label: value }));
-    return items.length ? { kind: "argument", start: space + 1, end: cursor, items } : undefined;
-  }
-  const at = line.lastIndexOf("@");
-  if (at < 0) return undefined;
-  const prev = line[at - 1];
-  if (prev !== undefined && !/\s/.test(prev)) return undefined;
-  const query = line.slice(at + 1);
-  if (/\s/.test(query) && !query.startsWith("\"")) return undefined;
-  const bare = query.replace(/^"/, "");
-  const items: ListItem[] = fuzzyFilter(sources.paths, bare).slice(0, MAX_ITEMS)
-    .map(path => ({ value: `@${/\s/.test(path) ? JSON.stringify(path) : path} `, label: path }));
-  return items.length ? { kind: "path", start: lineStart + at, end: cursor, items } : undefined;
-}
-
-export function completionSources(app: App, paths: readonly string[]): CompletionSources {
-  const providers = [...new Set([...app.catalog.map(m => m.provider).filter(provider => !subscriptionById(provider)), ...SUBSCRIPTION_OPTIONS.map(p => p.id)])];
-  const values: Record<string, () => string[]> = {
-    // Model identities belong to the searchable picker. The generic completer
-    // still handles arbitrary argument sources; this app supplies only one
-    // model selection surface, rather than a second list with different keys.
-    thinking: () => [...supportedThinkingLevels(app.providerConfig.spec)],
-    provider: () => providers, logout: () => Object.keys(app.auth).filter(provider => app.auth[provider] !== undefined),
-    settings: interactiveSettingKeys,
-    models: () => ["refresh"], trust: () => ["once", "here", "parent", "never"],
-  };
-  return {
-    commands: [...COMMANDS.filter(command => command.name !== "exit"), ...commandEntries(app)],
-    argumentValues: command => values[commandDefinition(`/${command}`)?.name ?? command.toLowerCase()]?.() ?? [],
-    paths,
-  };
-}
-
-/** Built-ins, then extension commands, prompt templates and skills: the same names the palette lists. */
-export function commandEntries(app: App): { name: string; description: string; section: string }[] {
-  return [
-    ...[...app.extensions?.commands ?? []].map(([name, command]) => ({ name, description: command.description ?? "extension command", section: "Extensions" })),
-    ...[...(app.slash?.prompts.values() ?? [])].map(p => ({ name: p.name, description: p.description ?? "prompt template", section: "Prompts" })),
-    ...(app.slash?.skillCommands === false ? [] : [...(app.slash?.skills.values() ?? [])].map(s => ({ name: `skill:${s.name}`, description: s.description ?? "skill", section: "Skills" }))),
-  ];
-}

package/src/apps/control-transport.ts

@@ -1,90 +0,0 @@
-/** Q24: bounded local JSONL transport. No TCP listener or additional runtime dependency. */
-import { createServer, type Socket } from "node:net";
-import { chmodSync } from "node:fs";
-import { lstat, mkdir, rm } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { CONTROL_SCHEMA } from "../core/control-protocol.ts";
-import { ControlConnection, type RpcOutput } from "../runtime/control-connection.ts";
-import type { SessionControl } from "../runtime/session-control.ts";
-import type { SessionHub } from "../runtime/session-hub.ts";
-
-export class ControlJsonl {
-  private buffer = Buffer.alloc(0);
-  private pending = 0;
-  private tail = Promise.resolve();
-  private closed = false;
-  readonly connection: ControlConnection;
-  private readonly stop: () => void;
-  private readonly output: (text: string) => void;
-  constructor(control: () => SessionControl, output: (text: string) => void, stop: () => void, denyOnClose = false, hub?: SessionHub) {
-    this.stop = stop;
-    this.output = text => { try { output(text); } catch { this.close(); this.stop(); } };
-    this.connection = new ControlConnection(control, message => this.write(message), { denyOnClose, ...(hub ? { hub } : {}) });
-  }
-  private write(message: RpcOutput): void {
-    if (this.closed) return;
-    const text = JSON.stringify(message) + "\n";
-    if (Buffer.byteLength(text) > CONTROL_SCHEMA.limits.frameBytes) {
-      if ("id" in message) this.output(JSON.stringify({ id: message.id, error: { code: -32002, message: "response exceeds frame limit; use paginated inspectors" } }) + "\n");
-      else this.fail("event exceeds frame limit; reconnect and resynchronize");
-    } else this.output(text);
-  }
-  private fail(message: string): void {
-    if (this.closed) return;
-    this.output(JSON.stringify({ id: null, error: { code: -32001, message } }) + "\n");
-    this.close(); this.stop();
-  }
-  feed(chunk: Uint8Array): void {
-    if (this.closed) return;
-    this.buffer = Buffer.concat([this.buffer, chunk]);
-    for (;;) {
-      const newline = this.buffer.indexOf(10);
-      if (newline < 0) { if (this.buffer.length > CONTROL_SCHEMA.limits.frameBytes) this.fail("input frame exceeds limit"); return; }
-      if (newline > CONTROL_SCHEMA.limits.frameBytes) { this.fail("input frame exceeds limit"); return; }
-      const line = this.buffer.subarray(0, newline).toString("utf8"); this.buffer = this.buffer.subarray(newline + 1);
-      if (!line.trim()) continue;
-      if (++this.pending > CONTROL_SCHEMA.limits.queuedRequests) { this.fail("request queue is full"); return; }
-      this.tail = this.tail.then(async () => {
-        if (this.closed) return;
-        let value: unknown;
-        try { value = JSON.parse(line); }
-        catch { this.write({ id: null, error: { code: -32700, message: "invalid JSON" } }); return; }
-        await this.connection.receive(value);
-      }).finally(() => { this.pending--; });
-    }
-  }
-  async drained(): Promise<void> { await this.tail; }
-  close(): void { this.closed = true; this.buffer = Buffer.alloc(0); this.connection.close(); }
-}
-
-export async function listenControl(path: string, control: () => SessionControl): Promise<() => Promise<void>> {
-  const absolute = resolve(path), parent = dirname(absolute);
-  await mkdir(parent, { recursive: true, mode: 0o700 });
-  const directory = await lstat(parent);
-  if (!directory.isDirectory() || directory.mode & 0o077 || process.getuid && directory.uid !== process.getuid()) throw Error("control socket requires an owned private directory (mode 0700)");
-  try { await lstat(absolute); throw Error("control socket path already exists; refusing to replace it"); }
-  catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
-  const clients = new Map<Socket, ControlJsonl>();
-  const server = createServer(socket => {
-    // Assumed local adapter capacity; together with per-peer bounds this caps retained transport memory.
-    if (clients.size >= 32) { socket.destroy(); return; }
-    const peer = new ControlJsonl(control, text => {
-      if (socket.writableLength + Buffer.byteLength(text) > CONTROL_SCHEMA.limits.outputBytes) socket.destroy(); else socket.write(text);
-    }, () => socket.destroy());
-    clients.set(socket, peer);
-    socket.on("data", chunk => peer.feed(typeof chunk === "string" ? Buffer.from(chunk) : chunk));
-    socket.on("error", () => socket.destroy());
-    socket.on("close", () => { peer.close(); clients.delete(socket); });
-  });
-  await new Promise<void>((resolveReady, reject) => {
-    server.once("error", reject);
-    server.listen(absolute, () => { chmodSync(absolute, 0o600); resolveReady(); });
-  });
-  const owned = await lstat(absolute);
-  return async () => {
-    for (const [socket, peer] of clients) { peer.close(); socket.destroy(); }
-    await new Promise<void>((resolveClosed, reject) => server.close(error => error ? reject(error) : resolveClosed()));
-    try { const current = await lstat(absolute); if (current.ino === owned.ino && current.dev === owned.dev) await rm(absolute); }
-    catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
-  };
-}

package/src/apps/export-cli.ts

@@ -1,24 +0,0 @@
-/** Offline export is a local storage operation and never constructs an agent or loads extensions. */
-import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { toHtml } from "../core/export.ts";
-import { readCursor } from "../store/log.ts";
-import { readNodeHistory } from "../store/restore.ts";
-import { importSessionArchive } from "../store/session-archive.ts";
-import { findSessionByPrefix } from "../store/sessions.ts";
-
-export async function exportHtmlFile(input: string, output: string | undefined, workspace: string): Promise<string> {
-  const source = resolve(workspace, input), temporary = await mkdtemp(join(tmpdir(), "xeno-export-"));
-  try {
-    let dir: string;
-    if (await stat(source).then(info => info.isFile(), () => false)) dir = await importSessionArchive(source, temporary, workspace);
-    else { const found = await findSessionByPrefix(workspace, input); if (!found.ok) throw new Error(found.reason); dir = found.session.path; }
-    const cursor = await readCursor(dir); if (!cursor) throw new Error("Session has no cursor");
-    const history = await readNodeHistory(dir, cursor.node); if (!history.ok) throw new Error(history.error);
-    const destination = resolve(workspace, output || basename(input).replace(/\.jsonl$/i, "") + ".html");
-    if (source === destination) throw new Error("Export destination must differ from its source");
-    await writeFile(destination, toHtml(history.nodes.flatMap(node => node.events), { title: cursor.name ?? basename(input), exportedAt: new Date().toISOString() }), { mode: 0o600 });
-    return destination;
-  } finally { await rm(temporary, { recursive: true, force: true }); }
-}

package/src/apps/goal-flow.ts

@@ -1,70 +0,0 @@
-/**
- * The drafting half of /goal shared by the line shell and the TUI (S.2 / S.5):
- * one read-only request, then the reply parsed into candidate criteria.
- * Nothing here decides what is accepted; that is the user's pick.
- */
-import { draftReply, GOAL_DRAFT_RETRIES, goalDraftRequest, goalDraftRetry, parseGoalDraft } from "../core/goal.ts";
-import type { AcceptanceCriterion } from "../core/acceptance.ts";
-import type { RequestOptions } from "../runtime/loop.ts";
-import type { App } from "./startup.ts";
-
-export type PendingGoal = { objective: string; draft: string; criteria: AcceptanceCriterion[] };
-
-/**
- * Runs the draft request and reads the candidates from its reply; null when
- * there is nothing to accept. `runDraft` answers false for a draft that was
- * not sent or was cancelled. A draft that does not validate goes back to the
- * model once with the parser's reasons (GOAL_DRAFT_RETRIES); a reported
- * blocker is an answer and does not.
- */
-export async function draftGoal(app: App, objective: string,
-  runDraft: (prompt: string, options: RequestOptions) => Promise<boolean>): Promise<PendingGoal | null> {
-  const C = app.io.palette;
-  let prompt = goalDraftRequest(objective);
-  for (let attempt = 0; ; attempt++) {
-    const mark = app.session.state.events.at(-1)?.id;
-    if (!await runDraft(prompt, { readOnly: true })) return null;
-    const events = app.session.state.events;
-    // Only what this run recorded. A segment cut meanwhile removes the mark, and then the whole segment is new.
-    const reply = draftReply(events.slice(events.findIndex(event => event.id === mark) + 1));
-    if (!reply) { app.io.say(C.yellow("  the goal draft produced no reply; the goal was not set")); return null; }
-    const parsed = parseGoalDraft(reply.text);
-    for (const error of parsed.errors) app.io.say(C.yellow(`  draft ${error}`));
-    if (parsed.errors.length > 0 && !parsed.blocked && attempt < GOAL_DRAFT_RETRIES) {
-      app.io.say(C.dim("  the draft goes back to the model once to be corrected"));
-      prompt = goalDraftRetry(parsed.errors);
-      continue;
-    }
-    if (parsed.criteria.length === 0) {
-      app.io.say(C.yellow(parsed.blocked ? `  the model says this goal cannot be checked here: ${parsed.blocked}. The goal was not set`
-        : "  the draft has no usable criteria; the goal was not set. Run /goal again or rephrase the objective"));
-      return null;
-    }
-    return { objective, draft: reply.id, criteria: parsed.criteria };
-  }
-}
-
-/**
- * One drafted criterion as the user decides on it, the same in the line shell
- * and the TUI checklist: what runs, and whether it is a guard -- a check that
- * must keep passing rather than one that shows the work was done (S.7).
- */
-export function criterionSummary(item: AcceptanceCriterion): string {
-  return item.kind === "human" ? `human · ${item.description}` : `${item.guard ? "guard · " : ""}${item.command} · ${item.description}`;
-}
-
-/** `all`, or 1-based positions such as `1,3`. Unknown positions are refused, never skipped. */
-export function pickCriteria(criteria: readonly AcceptanceCriterion[], pick: string): { ok: true; ids: string[] } | { ok: false; error: string } {
-  const text = pick.trim();
-  if (text === "all") return { ok: true, ids: criteria.map(item => item.id) };
-  const positions = text.split(/[\s,]+/).filter(Boolean);
-  if (positions.length === 0) return { ok: false, error: "name the criteria to accept: /goal accept all, or /goal accept 1,3" };
-  const ids: string[] = [];
-  for (const position of positions) {
-    const index = Number(position);
-    if (!Number.isSafeInteger(index) || index < 1 || index > criteria.length) return { ok: false, error: `no drafted criterion ${position}` };
-    const id = criteria[index - 1]!.id;
-    if (!ids.includes(id)) ids.push(id);
-  }
-  return { ok: true, ids };
-}

package/src/apps/image-draft.ts

@@ -1,46 +0,0 @@
-import { draftImageInput, draftImageSpans, focusedDraftImage, imageMarker } from "../core/draft-images.ts";
-import type { ImageRef } from "../core/images.ts";
-
-/** D19: the renderer owns text and undo; the app only binds tokens to D8 blob identities. */
-export interface ImageDraftEditor {
-  readonly text: string;
-  readonly cursor: number;
-  setAtoms(spans: (text: string) => readonly { start: number; end: number }[]): void;
-  insert(text: string): void;
-  removeAtom(label: string): void;
-  resetDraft(project: (text: string) => string): void;
-}
-
-export class ImageDraft {
-  private readonly editor: ImageDraftEditor;
-  private readonly registry = new Map<number, ImageRef>();
-  // Never reuse an ID: undo, kill/yank and local history can restore an earlier tag.
-  private nextId = 1;
-
-  constructor(editor: ImageDraftEditor) {
-    this.editor = editor;
-    editor.setAtoms(text => draftImageSpans(text, this.registry));
-  }
-  get images(): ImageRef[] { return this.input(this.editor.text).images; }
-  get focusedImage() { return focusedDraftImage(this.editor.text, this.editor.cursor, this.registry); }
-  input(text: string) { return draftImageInput(text, this.registry); }
-
-  insertImages(images: readonly ImageRef[]): void {
-    let labels = "";
-    for (const image of images) {
-      while (this.editor.text.includes(imageMarker(this.nextId))) this.nextId++;
-      const id = this.nextId++;
-      this.registry.set(id, image); labels += imageMarker(id);
-    }
-    if (labels) this.editor.insert(labels);
-  }
-  removeImage(index: number): void {
-    const ids = [...new Set(draftImageSpans(this.editor.text, this.registry).map(span => span.id))];
-    const id = ids[index];
-    if (id !== undefined) this.editor.removeAtom(imageMarker(id));
-  }
-  reset(): void {
-    this.editor.resetDraft(text => this.input(text).text);
-    this.registry.clear();
-  }
-}