@visual-z/xeno 0.8.4 → 0.9.1

package/src/apps/provider-connect.ts

@@ -1,346 +0,0 @@
-/**
- * Custom endpoints and connected-provider management, reached from `/provider`.
- *
- * Flow (magpie's add form + OpenCode's /connect, see
- * docs/tasks/feat-provider-connect.md): choose a preset or a custom endpoint
- * → base URL and id (custom only) → API key (masked; `$VAR` keeps it in the
- * environment) → list the provider's own models with that key → check the
- * ones to enable → save → offer to switch.
- *
- * Every write goes through the files the rest of xeno already reads:
- * `auth.json` for keys and `models.json` `providers.<id>` for endpoints and
- * enabled models. After saving, the catalog is reloaded through the same
- * entry `/reload` uses, so a connected provider behaves exactly like a
- * hand-configured one.
- */
-import { modelKey } from "../core/session-position.ts";
-import { loadCatalog } from "../runtime/catalog.ts";
-import type { ModelSpec } from "../runtime/model.ts";
-import { discoverModels, discoveryFamily, likelyChatModel, normalizeBaseUrl, type DiscoveredModel } from "../runtime/model-discovery.ts";
-import { SOURCE_PROVIDERS } from "../runtime/model-data.ts";
-import { applyConnect, applyDisconnect, catalogTwin } from "../runtime/provider-connect.ts";
-import { CUSTOM_PRESETS, presetById, slugProviderId, suggestProviderId, validProviderId, type ProviderPreset } from "../runtime/provider-presets.ts";
-import { providerAccess } from "../runtime/provider-access.ts";
-import { writeAuthFile } from "../store/auth-store.ts";
-import { authPath } from "../store/config.ts";
-import { modelsPath, readModelSources, readModelsText, writeModelsFile } from "../store/models.ts";
-import { publishModelCatalog } from "./model-catalog.ts";
-import type { App } from "./startup.ts";
-import type { DialogHost } from "../tui/ui/dialog.ts";
-import type { ListItem } from "../tui/ui/list-model.ts";
-type SelectItem = ListItem;
-
-/** Lists at or below this size are preselected whole; larger ones keep only known models. magpie uses 24. */
-const PRESELECT_ALL = 24;
-
-export interface ConnectHost {
-  app: App;
-  wizard: Pick<DialogHost, "push" | "reset" | "pop" | "top" | "depth">;
-  /** Unmount the wizard. */
-  close(): void;
-  switchTo(spec: ModelSpec): Promise<void>;
-  fetch?: (input: string, init?: RequestInit) => Promise<Response>;
-}
-
-interface Draft {
-  preset: ProviderPreset;
-  id: string;
-  name: string;
-  baseUrl: string;
-  key: string;
-  /** `$VAR` / `{env:VAR}` / `!cmd`: stays in config, never stored. */
-  reference?: string;
-  previous?: readonly string[];
-}
-
-export function providerReady(app: App, provider: string): { ready: number; source?: string } {
-  const models = app.catalog.filter(model => model.provider === provider);
-  const resolved = models.map(model => app.credentialOf(model)).find(got => got.ok);
-  return { ready: resolved ? models.filter(model => app.credentialOf(model).ok).length : 0, ...(resolved?.ok ? { source: resolved.source } : {}) };
-}
-
-function providerName(app: App, id: string): string {
-  return SOURCE_PROVIDERS[id]?.name ?? (app.catalog.find(model => model.provider === id) ? connectedName(id) : id);
-}
-
-function connectedName(id: string): string {
-  return CUSTOM_PRESETS.find(preset => preset.id === id)?.label ?? id;
-}
-
-/**
- * Entry points from `/provider`. API-key and subscription sign-in stay on the
- * login picker itself (their masked editor and OAuth flows are fixed by
- * tests); the wizard owns what login never did: custom endpoints and
- * per-provider model choice.
- */
-export function startConnect(host: ConnectHost, entry: "custom" | "manage"): void {
-  const { app, wizard } = host;
-  if (entry === "custom") {
-    wizard.push({
-      kind: "list", keep: true,
-      title: "Which protocol does the endpoint speak?",
-      items: CUSTOM_PRESETS.map(preset => ({ value: preset.id, label: preset.label, description: preset.hint ?? "" })),
-      onPick: item => { const preset = presetById(item.value); if (preset) beginPreset(host, preset); },
-    });
-    return;
-  }
-  const connected = [...new Set(app.catalog.map(model => model.provider))].filter(id => providerReady(app, id).ready > 0).sort();
-  if (connected.length === 0) {
-    wizard.push({ kind: "message", title: "No provider is connected yet", lines: ["Choose a subscription, an API-key provider or a custom endpoint from /provider first."], onDone: () => host.close() });
-    return;
-  }
-  wizard.push({
-    kind: "list", keep: true,
-    title: `${connected.length} connected · choose one to manage`,
-    items: connected.map(id => {
-      const state = providerReady(app, id);
-      return { value: id, label: providerName(app, id), description: `${state.ready} model${state.ready === 1 ? "" : "s"} · ${state.source ?? "configured"}` };
-    }),
-    onPick: item => manage(host, item.value),
-  });
-}
-
-/** A provider configured by hand (or by an earlier /provider) that is not a preset. */
-function customFromCatalog(app: App, id: string): ProviderPreset | undefined {
-  const model = app.catalog.find(candidate => candidate.provider === id);
-  if (!model) return undefined;
-  return { id, label: id, api: model.api, baseUrl: model.baseUrl ?? "", catalog: false, custom: true };
-}
-
-function manage(host: ConnectHost, id: string): void {
-  const { app, wizard } = host;
-  const preset = presetById(id) ?? customFromCatalog(app, id);
-  if (!preset) return;
-  const enabled = app.catalog.filter(model => model.provider === id).map(model => model.id);
-  wizard.push({
-    kind: "list", keep: true,
-    title: providerName(app, id),
-    items: [
-      { value: "models", label: "Choose models", description: "list the provider's models again and pick which appear in /model" },
-      { value: "key", label: "Replace API key", description: app.auth[id] ? `stored in ${authPath()}` : "currently from the environment or config" },
-      { value: "remove", label: "Disconnect", description: "remove the stored key and this provider's endpoint config" },
-    ],
-    onPick: async item => {
-      const sample = app.catalog.find(model => model.provider === id);
-      const baseUrl = sample?.baseUrl ?? preset.baseUrl;
-      const got = sample ? app.credentialOf(sample) : undefined;
-      const draft: Draft = { preset, id, name: preset.custom ? id : preset.label, baseUrl, key: got?.ok ? got.key : "", previous: enabled };
-      if (item.value === "models") { await fetchModels(host, draft); return; }
-      if (item.value === "key") { askKey(host, draft); return; }
-      await disconnect(host, id);
-    },
-  });
-}
-
-function beginPreset(host: ConnectHost, preset: ProviderPreset): void {
-  const { app, wizard } = host;
-  const draft: Draft = { preset, id: preset.id, name: preset.label, baseUrl: preset.baseUrl, key: "" };
-  if (!preset.custom) { askKey(host, draft); return; }
-  wizard.push({
-    kind: "form", keep: true,
-    title: `${preset.label} · base URL`,
-    label: "URL",
-    value: preset.baseUrl,
-    hint: preset.api === "anthropic-messages" ? "the root, e.g. https://gateway.example.com/anthropic · Enter continue · Esc back"
-      : preset.api === "google-generative-ai" ? "e.g. https://generativelanguage.googleapis.com/v1beta · Enter continue · Esc back"
-      : "usually ends in /v1 · a pasted …/chat/completions is trimmed · Enter continue · Esc back",
-    validate: value => /^https?:\/\/[^\s/]+/.test(value) ? undefined : "Enter an http(s) URL",
-    onSubmit: value => {
-      draft.baseUrl = normalizeBaseUrl(value);
-      const taken = new Set(app.catalog.map(model => model.provider).filter(id => !(id in app.auth) && SOURCE_PROVIDERS[id] !== undefined));
-      const suggested = preset.keyless ? preset.id : suggestProviderId(draft.baseUrl, taken);
-      wizard.push({
-        kind: "form", keep: true,
-        title: `${preset.label} · name`,
-        label: "Provider ID",
-        value: suggested,
-        hint: "shown in /model as <id>/<model>; lowercase a-z, digits, - and _",
-        validate: id => !validProviderId(id) ? `Use lowercase a-z, digits, - and _ (no spaces, capitals or non-Latin letters); try "${slugProviderId(id) || suggested}"`
-          : SOURCE_PROVIDERS[id] !== undefined ? `"${id}" is a built-in provider; pick another id or choose it from the list` : undefined,
-        onSubmit: id => {
-          draft.id = id;
-          draft.name = id;
-          if (preset.keyless) { void fetchModels(host, draft); return; }
-          askKey(host, draft);
-        },
-      });
-    },
-  });
-}
-
-function askKey(host: ConnectHost, draft: Draft): void {
-  const { app, wizard } = host;
-  const sample = app.catalog.find(model => model.provider === draft.id);
-  const existing = sample ? app.credentialOf(sample) : undefined;
-  const reuse = existing?.ok ? existing.source : undefined;
-  wizard.push({
-    kind: "form", keep: true,
-    title: `${draft.name} · API key`,
-    label: "Key",
-    secret: true,
-    hint: [reuse ? `empty keeps the current key (${reuse})` : draft.preset.keyUrl ? `get one at ${draft.preset.keyUrl}` : "paste the key",
-      "$VAR reads the environment", "Enter continue · Esc back"].join(" · "),
-    validate: value => value.length === 0 && !reuse ? "Paste a key, or $VAR to read one from the environment" : undefined,
-    onSubmit: async value => {
-      if (value.length === 0 && existing?.ok) draft.key = existing.key;
-      else if (/^(\$|\{env:|!)/.test(value)) {
-        draft.reference = value;
-        const name = /^\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?$/.exec(value)?.[1] ?? /^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(value)?.[1];
-        draft.key = name ? process.env[name] ?? "" : "";
-      } else draft.key = value;
-      await fetchModels(host, draft);
-    },
-  });
-}
-
-async function fetchModels(host: ConnectHost, draft: Draft): Promise<void> {
-  const { app, wizard } = host;
-  const family = discoveryFamily(draft.preset.api);
-  const known = app.catalog.filter(model => model.provider === draft.id);
-  const builtin = loadCatalog({ userText: null }).models.filter(model => model.provider === draft.id);
-  const catalogModels = [...new Map([...builtin, ...known].map(model => [model.id, model])).values()];
-  if (!family) { chooseModels(host, draft, catalogModels.map(toDiscovered), undefined); return; }
-  const abort = new AbortController();
-  wizard.push({ kind: "busy", title: "models", message: `Listing models from ${draft.baseUrl} …`, onCancel: () => abort.abort() });
-  const headers = Object.fromEntries(Object.entries(providerAccess(known[0] ?? ({} as ModelSpec)).headers ?? {}).filter((entry): entry is [string, string] => typeof entry[1] === "string" && !entry[1].includes("$")));
-  const result = await discoverModels({ family, baseUrl: draft.baseUrl, key: draft.key, headers, fetch: host.fetch ?? ((input, init) => globalThis.fetch(input, init)), signal: abort.signal });
-  if (abort.signal.aborted || wizard.top?.kind !== "busy") return;
-  if (result.ok) {
-    const live = result.models;
-    // Catalog metadata wins for display; the live list decides availability.
-    const merged = live.map(model => {
-      const twin = catalogModels.find(candidate => candidate.id === model.id);
-      return twin ? { ...toDiscovered(twin), ...model, name: model.name ?? twin.name } : model;
-    });
-    chooseModels(host, draft, merged, `${live.length} models from ${result.url}`, true);
-    return;
-  }
-  const options: SelectItem[] = [
-    { value: "retry", label: "Retry", description: result.reason },
-    { value: "key", label: "Change the API key" },
-    ...(draft.preset.custom ? [{ value: "url", label: "Change the base URL", description: draft.baseUrl }] : []),
-    ...(catalogModels.length ? [{ value: "catalog", label: `Use the ${catalogModels.length} built-in models`, description: "skip the live list" }] : []),
-    { value: "manual", label: "Type model IDs", description: "for endpoints without a /models listing" },
-  ];
-  wizard.push({
-    kind: "list", keep: true,
-    title: `Could not list models: ${result.reason}`,
-    items: options,
-    onPick: async item => {
-      if (item.value === "retry") { wizard.pop(); await fetchModels(host, draft); }
-      else if (item.value === "key") { wizard.pop(); wizard.pop(); askKey(host, draft); }
-      else if (item.value === "url") { while (wizard.depth > 1 && wizard.top?.title !== `${draft.preset.label} · base URL`) wizard.pop(); }
-      else if (item.value === "catalog") chooseModels(host, draft, catalogModels.map(toDiscovered), "built-in catalog");
-      else wizard.push({
-        kind: "form", keep: true, title: "Model IDs", label: "IDs", hint: "comma or space separated, exactly as the provider names them · Enter save",
-        validate: value => value.split(/[\s,]+/).filter(Boolean).length ? undefined : "Enter at least one model id",
-        onSubmit: async value => { await save(host, draft, value.split(/[\s,]+/).filter(Boolean).map(id => ({ id }))); },
-      });
-    },
-  }, true);
-}
-
-function toDiscovered(model: ModelSpec): DiscoveredModel {
-  return { id: model.id, ...(model.name !== model.id ? { name: model.name } : {}),
-    ...(model.contextWindow ? { contextWindow: model.contextWindow } : {}), ...(model.maxTokens ? { maxTokens: model.maxTokens } : {}) };
-}
-
-function chooseModels(host: ConnectHost, draft: Draft, models: readonly DiscoveredModel[], source: string | undefined, replace = false): void {
-  const { app, wizard } = host;
-  const chat = models.filter(model => likelyChatModel(model.id));
-  const known = new Set(app.catalog.filter(model => model.provider === draft.id).map(model => model.id));
-  const preselect = (model: DiscoveredModel): boolean => {
-    if (draft.previous) return draft.previous.includes(model.id);
-    if (!likelyChatModel(model.id)) return false;
-    if (chat.length <= PRESELECT_ALL) return true;
-    return known.has(model.id) || catalogTwin(model.id, app.catalog) !== undefined && draft.preset.custom === false;
-  };
-  const ordered = [...chat, ...models.filter(model => !likelyChatModel(model.id))];
-  const items: ListItem[] = ordered.map(model => ({
-    value: model.id,
-    label: model.id,
-    description: [model.name && model.name !== model.id ? model.name : "", model.contextWindow ? `${Math.round(model.contextWindow / 1000)}k ctx` : "", likelyChatModel(model.id) ? "" : "not a chat model?"].filter(Boolean).join(" · "),
-  }));
-  wizard.push({
-    kind: "list", multi: true, keep: true,
-    title: `${draft.name} · models to enable${source ? `  (${source})` : ""}`,
-    items, checked: ordered.filter(preselect).map(model => model.id),
-    hint: "space toggle · ctrl+a all · enter save · esc back",
-    onSubmitChecked: async values => {
-      if (!values.length) { fail(host, "Select at least one model (space toggles, ctrl+a selects all)"); return; }
-      await save(host, draft, ordered.filter(model => values.includes(model.id)));
-    },
-  }, replace);
-}
-
-async function save(host: ConnectHost, draft: Draft, chosen: readonly DiscoveredModel[]): Promise<void> {
-  const { app, wizard } = host;
-  const read = await readModelsText();
-  let json: unknown = {};
-  if (read.error) { fail(host, `${read.error}; nothing was changed`); return; }
-  if (read.text !== null && read.text.trim().length) {
-    try { json = JSON.parse(read.text); }
-    catch { fail(host, `${modelsPath()} is not valid JSON; fix it first — nothing was changed`); return; }
-  }
-  const catalogDefault = SOURCE_PROVIDERS[draft.id]?.baseUrl;
-  const keyless = draft.preset.keyless === true;
-  const next = applyConnect(json, {
-    id: draft.id, name: draft.name, api: draft.preset.api, baseUrl: draft.baseUrl, catalog: !draft.preset.custom,
-    ...(catalogDefault ? { catalogBaseUrl: catalogDefault } : {}), keyless,
-    ...(draft.reference ? { keyReference: draft.reference } : {}), chosen,
-  }, loadCatalog({ userText: null }).models);
-  if (!keyless && !draft.reference && draft.key && (app.auth[draft.id]?.type !== "api_key" || app.auth[draft.id]?.type === "api_key" && (app.auth[draft.id] as { key: string }).key !== draft.key)) {
-    const auth = { ...app.auth, [draft.id]: { type: "api_key" as const, key: draft.key } };
-    await writeAuthFile(auth);
-    app.auth[draft.id] = auth[draft.id];
-  }
-  await writeModelsFile(next);
-  const loaded = loadCatalog(await readModelSources());
-  await publishModelCatalog(app, loaded.models);
-  const ready = app.catalog.filter(model => model.provider === draft.id && app.credentialOf(model).ok);
-  const warnings = loaded.warnings.filter(warning => warning.includes(draft.id));
-  if (ready.length === 0) {
-    fail(host, warnings[0] ?? "saved, but no model of this provider resolves a credential yet — check the key");
-    return;
-  }
-  app.io.say(app.io.palette.green(`  connected ${draft.name}`) + app.io.palette.dim(`  ${ready.length} model${ready.length === 1 ? "" : "s"} · ${modelsPath()}`));
-  wizard.reset({
-    kind: "list",
-    title: `Connected ${draft.name} · ${ready.length} model${ready.length === 1 ? "" : "s"} ready. Switch now?`,
-    items: [
-      ...ready.map(model => ({ value: modelKey(model), label: model.id, description: model.name !== model.id ? model.name : "" })),
-      { value: "stay", label: "Keep the current model", description: modelKey(app.providerConfig.spec) },
-    ],
-    onPick: async item => {
-      host.close();
-      const spec = app.catalog.find(model => modelKey(model) === item.value);
-      if (spec) await host.switchTo(spec);
-    },
-  });
-}
-
-async function disconnect(host: ConnectHost, id: string): Promise<void> {
-  const { app } = host;
-  const read = await readModelsText();
-  if (read.text !== null && read.text.trim().length) {
-    let json: unknown;
-    try { json = JSON.parse(read.text); } catch { fail(host, `${modelsPath()} is not valid JSON; nothing was changed`); return; }
-    await writeModelsFile(applyDisconnect(json, id));
-  }
-  if (app.auth[id] !== undefined) {
-    const auth = { ...app.auth };
-    delete auth[id];
-    await writeAuthFile(auth);
-    delete app.auth[id];
-  }
-  const loaded = loadCatalog(await readModelSources());
-  if (app.providerConfig.spec.provider === id) app.io.say(app.io.palette.yellow("  the current model belonged to this provider; choose another with /model"));
-  await publishModelCatalog(app, loaded.models);
-  const left = providerReady(app, id).ready;
-  app.io.say(app.io.palette.green(`  disconnected ${id}`) + (left ? app.io.palette.dim(`  (${left} models still resolve a key from the environment)`) : ""));
-  host.close();
-}
-
-function fail(host: ConnectHost, reason: string): void {
-  host.wizard.push({ kind: "message", title: "Not saved", lines: [reason] });
-}

package/src/apps/question-ui.ts

@@ -1,27 +0,0 @@
-/** Existing app dialogs own focus and cancellation; question tools receive only validated values. */
-import type { QuestionRequest, QuestionReply, QuestionAnswer } from "../core/question.ts";
-import type { ExtensionUI } from "../runtime/extension-ui.ts";
-
-export async function presentQuestions(ui: ExtensionUI, request: QuestionRequest, signal: AbortSignal): Promise<QuestionReply | undefined> {
-  const answers: QuestionAnswer[] = [];
-  for (const question of request.questions) {
-    const selected = new Set<string>(); let text: string | undefined;
-    if (!question.options.length) {
-      text = await ui.input(`${question.header}: ${question.question}`, "Your answer", { signal });
-      if (!text?.trim() || signal.aborted) return undefined;
-    } else for (;;) {
-      const labels = question.options.map(option => `${selected.has(option.id) ? "✓ " : ""}[${option.id}] ${option.label}${option.description ? " — " + option.description : ""}`);
-      const custom = "Enter a custom answer", submit = "Submit selected answers";
-      const choice = await ui.select(`${question.header}: ${question.question}`, [...labels, ...(question.custom ? [custom] : []), ...(question.multiple ? [submit] : [])], { signal });
-      if (choice === undefined || signal.aborted) return undefined;
-      if (choice === custom && question.custom) { text = await ui.input(question.question, "Your answer", { signal }); if (!text?.trim() || signal.aborted) return undefined; break; }
-      if (choice === submit && question.multiple) { if (selected.size) break; ui.notify("Select at least one answer.", "warning"); continue; }
-      const index = labels.indexOf(choice); if (index < 0) return undefined;
-      const id = question.options[index]!.id;
-      if (!question.multiple) { selected.add(id); break; }
-      if (selected.has(id)) selected.delete(id); else selected.add(id);
-    }
-    answers.push({ id: question.id, choices: [...selected], ...(text === undefined ? {} : { text }) });
-  }
-  return { request_id: request.request_id, turn_id: request.turn_id, answers };
-}

package/src/apps/render.ts

@@ -1,181 +0,0 @@
-/**
- * Loop events become lines. The shell prints them; this file does not
- * touch a terminal, so "what a tool call looks like" can be asserted
- * without starting one.
- *
- * Colour is a parameter, not a global. Piped and CI runs have no tty,
- * and a CSI 2026 (or even a dim code) in `-p` output is a parse error
- * waiting for a script.
- */
-
-import { assertNever } from "../core/exhaustive.ts";
-import type { LoopEvent } from "../runtime/loop.ts";
-import { ANSI as ANSI_STYLE, IDENTITY, type Style } from "../tui/style.ts";
-import { toolCard, toolDetail } from "../tui/ui/tool-card.ts";
-
-export interface Palette {
-  dim: (s: string) => string;
-  bold: (s: string) => string;
-  red: (s: string) => string;
-  green: (s: string) => string;
-  yellow: (s: string) => string;
-  cyan: (s: string) => string;
-}
-
-const identity = (s: string): string => s;
-
-const ANSI: Palette = {
-  dim: (s) => `\x1b[2m${s}\x1b[0m`,
-  bold: (s) => `\x1b[1m${s}\x1b[0m`,
-  red: (s) => `\x1b[31m${s}\x1b[0m`,
-  green: (s) => `\x1b[32m${s}\x1b[0m`,
-  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-};
-
-const PLAIN: Palette = {
-  dim: identity,
-  bold: identity,
-  red: identity,
-  green: identity,
-  yellow: identity,
-  cyan: identity,
-};
-
-export function createPalette(color: boolean): Palette {
-  return color ? ANSI : PLAIN;
-}
-
-/**
- * Colour is a tty AND not NO_COLOR. A theme that still emits ESC in a pipe
- * or under NO_COLOR is the same class of bug as createPalette(true) on a
- * redirected stdout.
- */
-export function colorEnabled(): boolean {
-  const noColor = process.env["NO_COLOR"];
-  if (noColor !== undefined && noColor !== "") return false;
-  return stdoutIsTty();
-}
-
-/** True only for a real tty. `undefined` (piped, CI) must not count. */
-export function stdoutIsTty(): boolean {
-  return process.stdout.isTTY === true;
-}
-
-export function stdinIsTty(): boolean {
-  return process.stdin.isTTY === true;
-}
-
-/**
- * One readable line from whatever was thrown.
- *
- * Never a stack. A stack is for whoever wrote the harness; the person running
- * it needs the status and the provider's own sentence, which is the part that
- * says whether this is their key, their quota, or the provider being down.
- */
-export function describeError(error: unknown): string {
-  if (error instanceof Error) {
-    const status = (error as { status?: unknown }).status;
-    const prefix = typeof status === "number" ? `HTTP ${status}: ` : "";
-    return error.message.startsWith("HTTP ") ? error.message : prefix + error.message;
-  }
-  return String(error);
-}
-
-export function indent(text: string, pad: string): string {
-  return text.split("\n").map((l) => pad + l).join("\n");
-}
-
-export function wrap(text: string, width: number): string {
-  const out: string[] = [];
-  let line = "";
-  for (const word of text.split(/\s+/)) {
-    if (line && line.length + word.length + 1 > width) { out.push(line); line = word; }
-    else line = line ? `${line} ${word}` : word;
-  }
-  if (line) out.push(line);
-  return out.join("\n");
-}
-
-export function firstLine(text: string, width: number): string {
-  const line = text.split("\n")[0] ?? "";
-  return line.length > width ? line.slice(0, width - 1) + "…" : line;
-}
-
-/**
- * Zero or more lines that the shell will print, matching the previous
- * inline switch one-for-one -- including the leading newline on
- * stop_and_ask, which is a blank line in the transcript.
- *
- * Kinds the old CLI ignored stay silent so this extraction cannot change
- * what a piped run prints.
- */
-function markdownStyle(C: Palette, style?: Style): Style {
-  if (style !== undefined) return style;
-  // Palette has no colour flag; identity wrappers are how -p and pipes
-  // already opt out of CSI. A sentinel that round-trips is that same gate.
-  return C.bold("\0") === "\0" ? IDENTITY : ANSI_STYLE;
-}
-
-export interface FormatFlags {
-  readonly toolsExpanded?: boolean;
-  readonly thinkingExpanded?: boolean;
-}
-
-export function formatEvent(
-  e: LoopEvent,
-  C: Palette,
-  width = 80,
-  flags: FormatFlags = {},
-  style?: Style,
-): string[] {
-  const md = markdownStyle(C, style);
-  switch (e.kind) {
-    case "thinking": {
-      // Print mode sends this to stderr, so 2>&1 can still read the reasoning in full.
-      const text = (e.text ?? "").trim();
-      void flags;
-      return text ? text.split("\n").map(line => C.dim(`  ${line}`)) : [];
-    }
-    case "assistant_text":
-      // Markdown stays source text in a pipe: scripts read it, and terminals render the TUI.
-      return (e.text ?? "").split("\n");
-    case "tool_call": {
-      const tool = e.tool ?? { name: "", input: {} };
-      const card = toolCard({ name: tool.name, input: tool.input, result: null });
-      return [C.cyan(`  → ${tool.name}${card.summary ? ` ${card.summary}` : ""}`)];
-    }
-    case "tool_result": {
-      const tool = e.tool ?? { name: "", input: {} };
-      const call = { name: tool.name, input: tool.input, result: { text: e.text ?? "", ok: e.ok !== false } };
-      const card = toolCard(call);
-      const head = `    ${e.ok === false ? "err" : "ok "}${card.evidence ? `  ${card.evidence}` : ""}`;
-      const body = flags.toolsExpanded === true ? toolDetail({ ...call, input: tool.name === "bash" ? {} : tool.input }, width - 6, md).map(line => `      ${line}`) : [];
-      return [e.ok === false ? C.red(head) : C.dim(head), ...body];
-    }
-    case "usage": {
-      const u = e.usage!;
-      const line =
-        `    ${u.input_tokens} new  ${u.cache_read_input_tokens} cached  ` +
-        `${u.cache_creation_input_tokens} written  ${u.output_tokens} out  ${u.ms}ms`;
-      return [e.ok ? C.dim(line) : C.yellow(line + `  ⚠ ${e.prefix}`)];
-    }
-    case "cut":
-      return [C.yellow(`  ── node ${e.node} closed (${e.reason}); handoff written`)];
-    case "stop_and_ask":
-      return [C.red(`\n  stopping: ${e.reason}`)];
-    case "done":
-      if (e.reason && e.reason !== "end_turn") return [C.dim(`  [${e.reason}]`)];
-      return [];
-    case "turn_start":
-    case "branch_start":
-    case "branch_done":
-    case "text_delta":
-    case "thinking_delta":
-    case "discard":
-    case "progress":
-      return [];
-    default:
-      return assertNever(e.kind, "formatEvent");
-  }
-}

package/src/apps/resources.ts

@@ -1,66 +0,0 @@
-import { loadSessionResources, sessionToolCatalog, processPermissionRules, type App, type Args } from "./startup.ts";
-import { loadCatalog, type createProvider } from "../runtime/catalog.ts";
-import { readModelSources } from "../store/models.ts";
-import { stageModelCatalog, applyModelCatalog } from "./model-catalog.ts";
-import { sessionControl } from "../runtime/session-control.ts";
-
-export interface ResourceReloadOptions {
-  readonly ownerLocked?: boolean;
-  readonly args?: Args;
-  readonly providerFactory?: typeof createProvider;
-}
-
-/** Parsing and discovery never retire the currently published runtime. */
-export async function reloadAppResources(app: App, options: ResourceReloadOptions = {}): Promise<boolean> {
-  if (!options.ownerLocked) return sessionControl(app.session).withIdleChange(() => reloadAppResources(app, { ...options, ownerLocked: true }));
-  const args = structuredClone(options.args ?? app.args);
-  const resources = await loadSessionResources(args, app.workspace, app.io, app.projectTrusted, app.foundation?.questionSlot);
-  let published = false;
-  try {
-    const catalog = loadCatalog(await readModelSources());
-    for (const warning of catalog.warnings) app.io.say(app.io.palette.yellow(warning));
-    const profileModel = args.role?.profile.model;
-    const stage = stageModelCatalog(app, catalog.models, {
-      ...(profileModel ? { model: args.model, provider: args.provider, ...(args.thinking ? { thinking: args.thinking } : {}), requireCredential: true } : {}),
-      ...(options.providerFactory ? { providerFactory: options.providerFactory } : {}),
-    });
-    const tools = sessionToolCatalog(args, resources.extensions, app.session.config.frozen.tools);
-    const hostRules = app.session.config.tools.appOwnsPermissions === true ? undefined : app.session.config.tools.hostPermissionRules ?? app.session.config.tools.rules ?? [];
-    const rules = processPermissionRules(args, resources.foundation, hostRules);
-    const previousMode = app.session.config.tools.workflowMode, previousProfile = app.session.config.agentProfile, previousScope = app.session.config.workflowToolProfile;
-    const nextProfile = args.agent ? { name: args.agent, workflowExplicit: args.cliFlags?.includes("--workflow") === true } : undefined;
-    const nextScope = args.toolProfile === "foundation" ? "foundation" as const : undefined;
-    const metadataChanged = previousMode !== (args.workflow ?? "build") || JSON.stringify(previousProfile) !== JSON.stringify(nextProfile) || previousScope !== nextScope;
-    // Pairing is checked before retiring any existing integration generation.
-    app.session.assertResourceIdle();
-    if (app.extensions && !await app.extensions.releaseIntegrations()) { app.extensions.restoreIntegrations(); throw Error("An integration still owns unfinished work or unconfirmed cleanup. Wait for it to settle before reloading; no replacement was activated."); }
-    app.session.config.tools.workflowMode = args.workflow ?? "build";
-    if (nextProfile) app.session.config.agentProfile = nextProfile; else delete app.session.config.agentProfile;
-    if (nextScope) app.session.config.workflowToolProfile = nextScope; else delete app.session.config.workflowToolProfile;
-    let cut: boolean;
-    try { cut = await app.session.reloadResources({ system: resources.system, tools: tools.schemas }, [...resources.slash.skills.values()], stage.next, metadataChanged); }
-    catch (error) {
-      if (previousMode === undefined) delete app.session.config.tools.workflowMode; else app.session.config.tools.workflowMode = previousMode;
-      if (previousProfile === undefined) delete app.session.config.agentProfile; else app.session.config.agentProfile = previousProfile;
-      if (previousScope === undefined) delete app.session.config.workflowToolProfile; else app.session.config.workflowToolProfile = previousScope;
-      app.extensions?.restoreIntegrations();
-      throw error;
-    }
-    const oldExtensions = app.extensions, oldFoundation = app.foundation;
-    app.args = args; app.extensions = resources.extensions; app.foundation = resources.foundation;
-    app.session.config.tools.questionSlot = resources.foundation.questionSlot;
-    app.session.config.tools.instructionCheck = (ctx, name, input) => resources.foundation.instructions(ctx, name, input, app.args.noContextFiles);
-    app.session.config.tools.extensions = resources.extensions.definitions(); app.session.config.tools.deferredTools = tools.deferred;
-    app.session.config.tools.extensionHooks = resources.extensions.toolHooks(); app.session.config.tools.rules = rules;
-    if (hostRules) app.session.config.tools.hostPermissionRules = structuredClone([...hostRules]);
-    app.session.config.maxTurns = args.maxTurns;
-    if (args.timeBudgetMs === undefined) delete app.session.config.timeBudgetMs; else app.session.config.timeBudgetMs = args.timeBudgetMs;
-    app.loadedContext = resources.loadedContext; app.slash = resources.slash; app.ui = resources.ui;
-    app.resources = resources.index; app.projectTrusted = resources.trusted; app.system = app.session.config.frozen.system;
-    published = true; applyModelCatalog(app, stage);
-    // The new owner is live. Cleanup errors cannot roll it back to an already retired generation.
-    try { if (oldExtensions) await oldExtensions.dispose(); else await oldFoundation?.dispose(); }
-    catch { app.io.err("Previous resources could not finish cleanup; the new checkpoint remains active."); }
-    return cut;
-  } finally { if (!published) await resources.extensions.dispose().catch(() => {}); }
-}