@visual-z/xeno 0.8.3 → 0.9.0

package/src/runtime/catalog.ts

@@ -1,285 +0,0 @@
-/**
- * Which model to run, and which adapter to run it through.
- *
- * Selection is a pure function of the catalog, the settings file, the flags
- * and one predicate saying whether a model has a credential. Keeping it pure
- * matters because the interesting case is the one nobody configures on
- * purpose: no flag, no settings, two providers installed, one of them
- * authenticated. What happens then is a decision, and a decision should be
- * testable without a filesystem.
- *
- * The built-in list is a typed constant. The live list is that constant
- * overlaid with `~/.xeno/models.json`. Overlay is also pure: the file is
- * read elsewhere, this module only parses and merges. Fetch is accepted on
- * `loadCatalog` so a test can prove startup never calls it (D16).
- */
-
-import { assertNever } from "../core/exhaustive.ts";
-import { createHash } from "node:crypto";
-import { resolve } from "node:path";
-import { modelKey } from "../core/session-position.ts";
-import { mergeCatalogs } from "../core/catalog-merge.ts";
-import { parseModelConfiguration } from "./model-config.ts";
-import type { Settings } from "../core/settings.ts";
-import { CATALOG, CURATED_CATALOG, type ModelSpec } from "./model.ts";
-import { AnthropicProvider, type Provider, type ProviderConfig } from "./provider.ts";
-import { OpenAICompletionsProvider } from "./openai.ts";
-import { OpenAIResponsesProvider } from "./openai-responses.ts";
-import { PiProvider } from "./pi-provider.ts";
-import { copyProviderAccess, hasProviderAccess } from "./provider-access.ts";
-import type { ResolveEffects } from "./auth.ts";
-
-export type { Settings };
-
-export interface LoadedCatalog {
-  models: ModelSpec[];
-  warnings: string[];
-}
-
-/** Call signature only — `typeof fetch` also has `preconnect`, which a test spy does not. */
-export type CatalogFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-
-/**
- * Built-in catalog plus a user file. `fetch` is part of the signature so the
- * startup-path test can inject one and assert it was never called — a default
- * `refresh: false` flag would not prove that.
- */
-export function loadCatalog(opts: { userText: string | null; cacheText?: string | null; readWarnings?: readonly string[]; fetch?: CatalogFetch }): LoadedCatalog {
-  void opts.fetch;
-  const warnings: string[] = [...(opts.readWarnings ?? [])];
-  let models = [...CATALOG];
-  if (opts.cacheText?.trim()) {
-    try {
-      const parsed = parseModelConfiguration(JSON.parse(opts.cacheText));
-      const curated = new Map(CURATED_CATALOG.map(spec => [modelKey(spec), spec]));
-      const cached = parsed.models.map(spec => {
-        const known = curated.get(modelKey(spec));
-        if (!known) return spec;
-        // Refresh metadata without replacing already verified wire dialects for existing sessions.
-        const next = { ...spec, api: known.api, reasoning: known.reasoning };
-        delete next.driver; delete next.compat; delete next.nativeCompat; delete next.thinkingLevelMap;
-        if (known.driver) next.driver = known.driver;
-        if (known.nativeCompat) next.nativeCompat = known.nativeCompat;
-        if (known.compat) next.compat = known.compat;
-        if (known.thinkingLevelMap) next.thinkingLevelMap = known.thinkingLevelMap;
-        if (known.baseUrl !== undefined) next.baseUrl = known.baseUrl;
-        copyProviderAccess(spec, next);
-        return next;
-      });
-      models = mergeCatalogs(models, cached);
-      warnings.push(...parsed.errors.map(message => "catalog cache: " + message));
-    } catch { warnings.push("catalog cache is not valid JSON; using bundled models"); }
-  }
-  if (opts.userText?.trim()) {
-    try { const parsed = parseModelConfiguration(JSON.parse(opts.userText), models); models = parsed.models; warnings.push(...parsed.errors); }
-    catch { warnings.push("user catalog is not valid JSON; using bundled/cache models"); }
-  }
-  return { models, warnings };
-}
-
-export function overlayCatalog(builtin: readonly ModelSpec[], user: readonly ModelSpec[]): ModelSpec[] { return mergeCatalogs(builtin, user); }
-export function parseUserCatalog(json: unknown): { models: ModelSpec[]; errors: string[] } { return parseModelConfiguration(json); }
-
-export function findModel(id: string, catalog: readonly ModelSpec[] = CATALOG): ModelSpec | undefined {
-  return catalog.find((m) => m.id === id);
-}
-
-/**
- * Resolve a typed pattern to one catalog entry.
- *
- * Order is `provider/id`, then exact id, then substring, then subsequence
- * ("fuzzy"). Each tier is tried only if the one above it matched nothing,
- * so a unique exact id cannot be displaced by a looser match. Several
- * hits at the winning tier is an error that lists the candidates --
- * picking the first would make `--model sonnet` silently follow catalog
- * order after a refresh, and bill, cost, and behaviour would all change
- * with nothing in the log saying why.
- */
-export type ModelPatternMatch =
-  | { ok: true; spec: ModelSpec }
-  | { ok: false; reason: string; candidates: readonly ModelSpec[] };
-
-export function findModelByPattern(
-  pattern: string,
-  catalog: readonly ModelSpec[] = CATALOG,
-): ModelPatternMatch {
-  const needle = pattern.trim().toLowerCase();
-  if (needle.length === 0) {
-    return { ok: false, reason: "empty model pattern", candidates: [] };
-  }
-
-  const byRef = catalog.filter((m) => `${m.provider}/${m.id}`.toLowerCase() === needle);
-  if (byRef.length > 0) return reportPattern(pattern, byRef);
-
-  const exactId = catalog.filter((m) => m.id.toLowerCase() === needle);
-  if (exactId.length > 0) return reportPattern(pattern, exactId);
-
-  const substring = catalog.filter((m) => haystacks(m).some((h) => h.includes(needle)));
-  if (substring.length > 0) return reportPattern(pattern, substring);
-
-  const fuzzy = catalog.filter((m) => haystacks(m).some((h) => isSubsequence(needle, h)));
-  return reportPattern(pattern, fuzzy);
-}
-
-function haystacks(m: ModelSpec): string[] {
-  return [m.id.toLowerCase(), m.name.toLowerCase(), `${m.provider}/${m.id}`.toLowerCase()];
-}
-
-/**
- * Characters of `needle` appear in order in `haystack`, not necessarily
- * adjacent. A typed abbreviation ("dflash") and a dropped letter both
- * match; an edit-distance threshold would be a guessed constant, and
- * this function is the same rule a picker uses without one.
- */
-function isSubsequence(needle: string, haystack: string): boolean {
-  let i = 0;
-  for (const ch of haystack) {
-    if (ch === needle[i]) i += 1;
-    if (i === needle.length) return true;
-  }
-  return false;
-}
-
-function reportPattern(pattern: string, matches: readonly ModelSpec[]): ModelPatternMatch {
-  if (matches.length === 1) return { ok: true, spec: matches[0]! };
-  if (matches.length === 0) {
-    return { ok: false, reason: `unknown model: ${pattern}. Try --list-models`, candidates: [] };
-  }
-  const ids = matches.map(modelKey);
-  return {
-    ok: false,
-    reason:
-      `ambiguous model pattern ${JSON.stringify(pattern)}: matches ${ids.join(", ")}. ` +
-      "Be more specific rather than guessing",
-    candidates: matches,
-  };
-}
-
-export function modelsOfProvider(
-  provider: string,
-  catalog: readonly ModelSpec[] = CATALOG,
-): readonly ModelSpec[] {
-  return catalog.filter((m) => m.provider === provider);
-}
-
-/** First-seen provider order, which is catalog order, not alphabetical. */
-export function groupedModels(
-  catalog: readonly ModelSpec[] = CATALOG,
-): { provider: string; models: readonly ModelSpec[] }[] {
-  const order: string[] = [];
-  const map = new Map<string, ModelSpec[]>();
-  for (const spec of catalog) {
-    let list = map.get(spec.provider);
-    if (list === undefined) {
-      list = [];
-      map.set(spec.provider, list);
-      order.push(spec.provider);
-    }
-    list.push(spec);
-  }
-  return order.map((provider) => ({ provider, models: map.get(provider)! }));
-}
-
-export type Selection =
-  | { ok: true; spec: ModelSpec }
-  | { ok: false; reason: string };
-
-/**
- * `--model` wins, then `--provider`'s first model, then the settings file,
- * then a usable recent selection from older settings, then the first model
- * in the catalog that has a credential.
- *
- * The last step is what makes a fresh install work: someone who exported one
- * API key should get a working session without also having to learn the name
- * of a model. It is deliberately last, so it can never override something the
- * person actually asked for -- an explicit `--model` that has no credential
- * must fail loudly rather than quietly running a different model, which would
- * bill the wrong account and invalidate any comparison between runs.
- */
-export function selectModel(
-  settings: Settings,
-  flags: { model?: string | undefined; provider?: string | undefined },
-  hasCredential: (spec: ModelSpec) => boolean,
-  catalog: readonly ModelSpec[] = CATALOG,
-): Selection {
-  if (flags.model !== undefined && flags.model.length > 0) {
-    const candidates = flags.provider ? modelsOfProvider(flags.provider, catalog) : catalog;
-    const match = findModelByPattern(flags.model, candidates);
-    return match.ok ? { ok: true, spec: match.spec } : { ok: false, reason: `${match.reason}. Try --list-models` };
-  }
-
-  if (flags.provider !== undefined && flags.provider.length > 0) {
-    const models = modelsOfProvider(flags.provider, catalog);
-    if (models.length === 0) {
-      return { ok: false, reason: `unknown provider: ${flags.provider}. Try --list-models` };
-    }
-    return { ok: true, spec: models.find(hasCredential) ?? models[0]! };
-  }
-
-  if (settings.defaultModel !== undefined) {
-    const candidates = settings.defaultProvider ? catalog.filter(model => model.provider === settings.defaultProvider) : catalog;
-    const found = findModelByPattern(settings.defaultModel, candidates);
-    const spec = found.ok ? found.spec : undefined;
-    if (spec !== undefined) return { ok: true, spec };
-    // Not fatal: a settings file naming a model this build dropped should
-    // degrade to the normal search, not refuse to start.
-  }
-
-  if (settings.defaultProvider !== undefined) {
-    const preferred = modelsOfProvider(settings.defaultProvider, catalog).find(hasCredential);
-    if (preferred !== undefined) return { ok: true, spec: preferred };
-  }
-
-  // Old pickers only persisted recent identities. Reuse one exactly, without fuzzy guesses (Q.25).
-  for (const key of settings.recentModels ?? []) {
-    const recent = catalog.find(model => modelKey(model) === key);
-    if (recent !== undefined && hasCredential(recent)) return { ok: true, spec: recent };
-  }
-
-  const authenticated = catalog.find(hasCredential);
-  if (authenticated !== undefined) return { ok: true, spec: authenticated };
-
-  return {
-    ok: false,
-    reason:
-      "no model has a credential. Set an API key for one of: " +
-      [...new Set(catalog.map((m) => m.provider))].join(", ") +
-      " -- export its environment variable, or run /provider",
-  };
-}
-
-/** One adapter per wire format. A new API means a new case here, never a flag. */
-export function createProvider(
-  config: ProviderConfig,
-  apiKey: string,
-  onRetry?: (attempt: number, delayMs: number, error: unknown) => void,
-  opts?: { oauth?: boolean; fetch?: typeof fetch; effects?: ResolveEffects; sessionId?: string },
-): Provider {
-  const oauth = opts?.oauth === true;
-  if (config.spec.driver === "pi" || hasProviderAccess(config.spec)) return new PiProvider(config, apiKey, {
-    oauth,
-    ...(opts?.sessionId ? { sessionId: opts.sessionId } : {}),
-    ...(onRetry ? { onRetry } : {}), ...(opts?.fetch ? { fetch: opts.fetch } : {}), ...(opts?.effects ? { effects: opts.effects } : {}),
-  });
-  switch (config.spec.api) {
-    case "anthropic-messages":
-      return new AnthropicProvider(config, apiKey.length > 0 ? apiKey : undefined, {
-        ...(onRetry ? { onRetry } : {}),
-        ...(oauth ? { oauth: true } : {}),
-      });
-    case "openai-completions":
-      return new OpenAICompletionsProvider(config, apiKey, { ...(onRetry ? { onRetry } : {}) });
-    case "openai-responses":
-      return new OpenAIResponsesProvider(config, apiKey, { ...(onRetry ? { onRetry } : {}) });
-    case "azure-openai-responses": case "openai-codex-responses": case "google-generative-ai": case "google-vertex":
-    case "bedrock-converse-stream": case "mistral-conversations": case "pi-messages":
-      return new PiProvider(config, apiKey, { ...(onRetry ? { onRetry } : {}), ...(opts?.fetch ? { fetch: opts.fetch } : {}), ...(opts?.effects ? { effects: opts.effects } : {}), ...(opts?.sessionId ? { sessionId: opts.sessionId } : {}) });
-    default:
-      return assertNever(config.spec.api, "createProvider");
-  }
-}
-
-/** D6/D8: routing affinity survives reload and cold resume without server-owned history or path disclosure. */
-export function providerSessionId(logDir: string): string {
-  return createHash("sha256").update(resolve(logDir)).digest("hex");
-}

package/src/runtime/clipboard.ts

@@ -1,125 +0,0 @@
-/**
- * Pi's files → image → text precedence (MIT, 02eed88) over the platform's own
- * clipboard commands. The optional native helper went with the vendored TUI
- * (D20); a caller may still inject one.
- */
-import { fileURLToPath } from "node:url";
-
-export interface NativeClipboard {
-  setText?(text: string): Promise<void>;
-  getText?(): Promise<string | null | undefined>;
-  getImage?(): Promise<Uint8Array | null | undefined>;
-  getFilePaths?(): Promise<string[] | null | undefined>;
-}
-function getNativeClipboard(): NativeClipboard | null { return null; }
-import { runClipboardCommand } from "../vendor/pi-rich/clipboard-command.ts";
-
-export type ClipboardContent = { files: string[] } | { image: Uint8Array } | { text: string } | null;
-type Run = (command: string, args: readonly string[], options?: { input?: string; timeoutMs?: number }) => Promise<Buffer | undefined>;
-export interface ClipboardOptions {
-  platform?: NodeJS.Platform;
-  env?: NodeJS.ProcessEnv;
-  native?: NativeClipboard | null;
-  run?: Run;
-}
-
-/** Text is transported as data. Clipboard contents must never become PowerShell or shell source. */
-export async function writeClipboard(text: string, options: ClipboardOptions = {}): Promise<boolean> {
-  const platform = options.platform ?? process.platform, env = options.env ?? process.env;
-  const native = options.native === undefined ? getNativeClipboard() : options.native, run = options.run ?? runClipboardCommand;
-  if (native?.setText) {
-    try { await native.setText(text); return true; } catch { /* Continue to the same platform's command transport. */ }
-  }
-  const windows = platform === "win32" || !!(env["WSL_DISTRO_NAME"] || env["WSL_INTEROP"]);
-  const commands: readonly (readonly [string, readonly string[]])[] = windows
-    ? [["powershell.exe", ["-NoProfile", "-STA", "-Command", "Add-Type -AssemblyName System.Windows.Forms; [Console]::InputEncoding = [System.Text.Encoding]::UTF8; $t = [Console]::In.ReadToEnd(); if ($t.Length) { [System.Windows.Forms.Clipboard]::SetText($t) } else { [System.Windows.Forms.Clipboard]::Clear() }"]]]
-    : platform === "darwin" ? [["pbcopy", []]]
-    : env["TERMUX_VERSION"] ? [["termux-clipboard-set", []]]
-    : platform === "linux" ? [
-        ...(env["WAYLAND_DISPLAY"] || env["XDG_SESSION_TYPE"] === "wayland" ? [["wl-copy", ["--type", "text/plain;charset=utf-8"]] as const] : []),
-        ...(env["DISPLAY"] ? [["xclip", ["-selection", "clipboard"]] as const, ["xsel", ["--clipboard", "--input"]] as const] : []),
-      ] : [];
-  for (const [command, args] of commands) {
-    try { if (await run(command, args, { input: text, timeoutMs: 5000 }) !== undefined) return true; } catch { /* Try a same-platform backend. */ }
-  }
-  return false;
-}
-
-// Fixed programs only. Clipboard content is data, never interpolated into a shell or script.
-const MAC_READ = `ObjC.import('AppKit');
-const p = $.NSPasteboard.generalPasteboard;
-const urls = p.readObjectsForClassesOptions([$.NSURL], $({NSPasteboardURLReadingFileURLsOnlyKey: true}));
-const files = [];
-if (urls) for (let i = 0; i < urls.count; i++) files.push(ObjC.unwrap(urls.objectAtIndex(i).path));
-if (files.length) JSON.stringify({files});
-else {
-  const png = p.dataForType('public.png');
-  const tiff = png ? null : p.dataForType('public.tiff');
-  const data = png || (tiff ? $.NSBitmapImageRep.imageRepWithData(tiff).representationUsingTypeProperties($.NSPNGFileType, $({})) : null);
-  if (data) JSON.stringify({image: ObjC.unwrap(data.base64EncodedStringWithOptions(0))});
-  else JSON.stringify({text: ObjC.unwrap(p.stringForType($.NSPasteboardTypeString)) || ''});
-}`;
-const WINDOWS_READ = `Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing;
-$c = [System.Windows.Forms.Clipboard];
-if ($c::ContainsFileDropList()) { @{files = @($c::GetFileDropList())} | ConvertTo-Json -Compress }
-elseif ($c::ContainsImage()) { $i = $c::GetImage(); $s = New-Object System.IO.MemoryStream; try { $i.Save($s, [System.Drawing.Imaging.ImageFormat]::Png); @{image = [Convert]::ToBase64String($s.ToArray())} | ConvertTo-Json -Compress } finally { $i.Dispose(); $s.Dispose() } }
-else { @{text = $c::GetText()} | ConvertTo-Json -Compress }`;
-
-function decode(bytes: Buffer | undefined): ClipboardContent | undefined {
-  if (bytes === undefined) return undefined;
-  const value = JSON.parse(bytes.toString("utf8")) as { files?: unknown; image?: unknown; text?: unknown };
-  if (Array.isArray(value.files) && value.files.every(p => typeof p === "string") && value.files.length) return { files: value.files };
-  if (typeof value.image === "string" && value.image) return { image: Buffer.from(value.image, "base64") };
-  return typeof value.text === "string" && value.text ? { text: value.text } : null;
-}
-
-export async function readClipboard(options: ClipboardOptions = {}): Promise<ClipboardContent> {
-  const platform = options.platform ?? process.platform, env = options.env ?? process.env;
-  const run = options.run ?? runClipboardCommand;
-  const native = options.native === undefined ? getNativeClipboard() : options.native;
-  const files = await native?.getFilePaths?.();
-  if (files?.length) return { files };
-  if (platform === "darwin" && !native) {
-    const result = decode(await run("osascript", ["-l", "JavaScript", "-e", MAC_READ]));
-    if (result !== undefined) return result;
-  }
-  const wsl = !!(env["WSL_DISTRO_NAME"] || env["WSL_INTEROP"]);
-  if (platform === "win32" || wsl) {
-    const result = decode(await run("powershell.exe", ["-NoProfile", "-STA", "-Command", WINDOWS_READ], { timeoutMs: 5000 }));
-    if (result !== undefined) return result;
-  }
-  if (platform === "linux" && !env["TERMUX_VERSION"]) {
-    const wayland = !!env["WAYLAND_DISPLAY"] || env["XDG_SESSION_TYPE"] === "wayland";
-    const backends = [...(wayland ? ["wayland"] : []), ...(env["DISPLAY"] ? ["x11"] : [])];
-    for (const backend of backends) {
-      const read = (type: string) => backend === "wayland" ? run("wl-paste", ["--type", type, "--no-newline"]) : run("xclip", ["-selection", "clipboard", "-t", type, "-o"]);
-      const available = backend === "wayland" ? await run("wl-paste", ["--list-types"], { timeoutMs: 1000 }) : await read("TARGETS");
-      if (available === undefined) continue;
-      const types = available.toString("utf8").trim().split(/\r?\n/);
-      if (types.includes("text/uri-list")) {
-        const bytes = await read("text/uri-list");
-        if (bytes === undefined) throw new Error("Clipboard file transfer failed");
-        const paths = bytes.toString("utf8").split(/\r?\n/).filter(p => p.startsWith("file://")).map(p => fileURLToPath(p));
-        if (paths.length) return { files: paths };
-      }
-      const type = ["image/png", "image/jpeg", "image/webp", "image/gif", "image/bmp"].find(t => types.includes(t));
-      if (type) {
-        const bytes = await read(type);
-        if (bytes === undefined) throw new Error("Clipboard image transfer failed");
-        return bytes.length ? { image: bytes } : null;
-      }
-      const textType = ["text/plain;charset=utf-8", "UTF8_STRING", "text/plain", "text"].find(t => types.includes(t));
-      if (!textType) return null; // An empty Wayland selection must not reveal stale X11 contents.
-      const bytes = await read(textType);
-      if (bytes === undefined) throw new Error("Clipboard text transfer failed");
-      return bytes.length ? { text: bytes.toString("utf8") } : null;
-    }
-  }
-  const image = await native?.getImage?.();
-  if (image?.length) return { image };
-  const text = await native?.getText?.();
-  if (text !== undefined) return text ? { text } : null;
-  const fallback = env["TERMUX_VERSION"] ? await run("termux-clipboard-get", []) : platform === "darwin" ? await run("pbpaste", []) : undefined;
-  if (fallback === undefined) throw new Error("Clipboard unavailable for this terminal session");
-  return fallback.length ? { text: fallback.toString("utf8") } : null;
-}

package/src/runtime/command-artifacts.ts

@@ -1,64 +0,0 @@
-/** R8: one owner observes an admitted command once, including after a managed call yields. */
-import { hostname } from "node:os";
-import { resolve, join } from "node:path";
-import { artifactChange, commandArtifactState, parseCommandArtifactPlan, COMMAND_ARTIFACT_SCOPE, type CommandArtifactReceipt } from "../core/command-artifacts.ts";
-import { observeArtifactInputs, observeArtifactFiles, artifactExclusions, archiveCommandArtifacts } from "../store/command-artifacts.ts";
-import type { ToolContext } from "./tools.ts";
-
-export type ArtifactCommandEnd = { exit: number; stopped?: "cancelled" | "timeout"; capture?: "complete" | "partial"; cleanup?: unknown };
-export type CommandArtifactObserver = {
-  pending: CommandArtifactReceipt;
-  finish(end: ArtifactCommandEnd): Promise<CommandArtifactReceipt>;
-};
-
-/** Syntactic validation precedes admission; no preflight disk probing is smuggled through a denied tool. */
-export function prepareArtifactArguments(input: unknown): unknown {
-  if (input === null || typeof input !== "object" || Array.isArray(input) || !("artifacts" in input)) return input;
-  return { ...input, artifacts: parseCommandArtifactPlan(input.artifacts) };
-}
-
-export async function beginCommandArtifacts(ctx: Pick<ToolContext, "root" | "hostId" | "ownedStatePaths" | "outputStore" | "signal">,
-  command: string, cwd: string, requested: unknown): Promise<CommandArtifactObserver | undefined> {
-  if (requested === undefined) return undefined;
-  const plan = parseCommandArtifactPlan(requested), exclusions = artifactExclusions(ctx.root, plan,
-    [...(ctx.ownedStatePaths ?? []), ctx.outputStore ?? join(ctx.root, ".xeno", "observations")]);
-  const beforeInputs = await observeArtifactInputs(ctx.root, exclusions, ctx.signal);
-  const before = await observeArtifactFiles(ctx.root, plan.paths, ctx.signal);
-  const pending: CommandArtifactReceipt = {
-    kind: "command_artifacts", version: 1, state: "pending", plan,
-    source: { host: ctx.hostId ?? hostname(), workspace: resolve(ctx.root), cwd: resolve(cwd), runtime: `bun/${Bun.version}` },
-    command, exit: null, started_at: new Date().toISOString(), observed_at: null,
-    inputs: { scope: COMMAND_ARTIFACT_SCOPE, exclusions, before: beforeInputs.sha256, after: null },
-    outputs: [], reasons: beforeInputs.reason ? [beforeInputs.reason] : [],
-  };
-  let completed: Promise<CommandArtifactReceipt> | undefined;
-  return { pending, finish(end) {
-    completed ??= (async () => {
-      // Observation failures retain the actual exit. Never retry a post-exit read against later files.
-      const reasons = [...pending.reasons];
-      if (end.exit !== 0) reasons.push("command exited unsuccessfully");
-      if (end.stopped) reasons.push(`command ${end.stopped}`);
-      if (end.capture === "partial") reasons.push("command output capture is partial");
-      if (end.cleanup) reasons.push("command cleanup is unconfirmed");
-      const after = await observeArtifactFiles(ctx.root, plan.paths, ctx.signal);
-      const afterInputs = await observeArtifactInputs(ctx.root, exclusions, ctx.signal);
-      if (afterInputs.reason) reasons.push(afterInputs.reason);
-      const receipt: CommandArtifactReceipt = { ...pending, exit: end.exit, observed_at: new Date().toISOString(),
-        inputs: { ...pending.inputs, after: afterInputs.sha256 },
-        outputs: plan.paths.map((path, i) => ({ path, before: before[i]!, after: after[i]!, change: artifactChange(before[i]!, after[i]!) })), reasons };
-      receipt.state = commandArtifactState(receipt);
-      try { receipt.manifest = await archiveCommandArtifacts(ctx.outputStore ?? join(ctx.root, ".xeno", "observations"), receipt); }
-      catch { receipt.reasons.push("artifact observation archive unavailable"); receipt.state = commandArtifactState(receipt); }
-      return receipt;
-    })();
-    return completed;
-  } };
-}
-
-export function commandArtifactSummary(receipt: CommandArtifactReceipt | undefined): string {
-  if (!receipt) return "";
-  const changes = ["created", "modified", "unchanged", "unknown"].map(change => `${change}=${receipt.outputs.filter(output => output.change === change).length}`).join(", ");
-  return `\n[artifacts ${receipt.state}; ${changes}; reasons=${receipt.reasons.length}; ` +
-    (receipt.manifest ? `history artifact=${receipt.manifest.sha256}; ` : "") +
-    "command association only, not build causality or runtime acceptance]";
-}

package/src/runtime/connection-reuse.ts

@@ -1,40 +0,0 @@
-/**
- * Whether a provider may keep reusing pooled connections.
- *
- * A socket that a proxy, NAT or server dropped while it sat in the pool fails
- * the next request the same way -- Horizyn 2026-10-12 lost the first request
- * after "continue" to it. Claude Code answers by turning keep-alive off for
- * the rest of the process once a connection dies; this does the same per
- * provider instance, so tests sharing a process cannot leak state into each
- * other and a fresh session starts from the cheap path again
- * (feat-fresh-connection-after-drop).
- *
- * Bun honours `keepalive: false` by opening a new socket per request
- * (measured on 1.3.10: three default fetches share one socket, three with
- * keepalive:false open three). The cost is a TLS handshake per request,
- * negligible next to a model call. Google, Vertex and Bedrock go through
- * pi-ai's native HTTP with no fetch hook, so this cannot reach them.
- */
-import { connectionFailure } from "./retry.ts";
-
-export class ConnectionReuse {
-  private fresh = false;
-
-  /**
-   * Called with every failed attempt, retried or final. Only a connection
-   * that existed and died counts: one that never opened left nothing stale
-   * in the pool.
-   */
-  note(error: unknown): void {
-    if (connectionFailure(error) === "stale") this.fresh = true;
-  }
-
-  init(init: RequestInit | undefined): RequestInit | undefined {
-    return this.fresh ? { ...init, keepalive: false } : init;
-  }
-
-  /** A fetch that opens fresh connections once one has died. */
-  wrap(fetchImpl: typeof fetch): typeof fetch {
-    return Object.assign((input: RequestInfo | URL, init?: RequestInit) => fetchImpl(input, this.init(init)), { preconnect: fetchImpl.preconnect });
-  }
-}