@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/keymap.ts

@@ -1,153 +0,0 @@
-/**
- * Action id ↔ key chord. Pure: the file is read in store; this module
- * parses, reports conflicts by name, and lets the last definition win.
- *
- * Silent drop of one side of a conflict is how a shortcut "just stops
- * working" with no trail (feat-theming design). The action list is
- * xeno's (core/action-defaults.ts, D20).
- */
-
-import { ACTION_DEFAULTS, ACTION_ALIASES } from "./action-defaults.ts";
-export const ACTION_IDS = Object.keys(ACTION_DEFAULTS) as (keyof typeof ACTION_DEFAULTS)[];
-
-export type ActionId = (typeof ACTION_IDS)[number];
-
-export interface Chord {
-  readonly ctrl: boolean;
-  readonly alt: boolean;
-  readonly shift: boolean;
-  readonly super: boolean;
-  readonly key: string;
-}
-
-export interface Keymap {
-  readonly byKey: Readonly<Record<string, ActionId>>;
-  readonly byAction: Readonly<Record<string, readonly string[]>>;
-  readonly diagnostics: readonly string[];
-}
-
-const ACTION_SET = new Set<string>(ACTION_IDS);
-
-const NAMED_KEYS = new Set([
-  "escape",
-  "esc",
-  "enter",
-  "return",
-  "tab",
-  "space",
-  "backspace",
-  "delete",
-  "insert",
-  "home",
-  "end",
-  "pageup",
-  "pagedown",
-  "up",
-  "down",
-  "left",
-  "right",
-]);
-
-export function parseKey(spec: string): Chord | { error: string } {
-  const raw = spec.trim();
-  if (raw.length === 0) return { error: `unparseable key: ${JSON.stringify(spec)}` };
-  const parts = raw.split("+").map((p) => p.trim()).filter((p) => p.length > 0);
-  if (parts.length === 0) return { error: `unparseable key: ${JSON.stringify(spec)}` };
-  let ctrl = false;
-  let alt = false;
-  let shift = false;
-  let superKey = false;
-  const last = parts[parts.length - 1]!;
-  for (const part of parts.slice(0, -1)) {
-    const m = part.toLowerCase();
-    if (m === "ctrl" || m === "control") ctrl = true;
-    else if (m === "alt" || m === "option") alt = true;
-    else if (m === "shift") shift = true;
-    else if (m === "super" || m === "cmd" || m === "meta") superKey = true;
-    else return { error: `unparseable key: ${JSON.stringify(spec)}` };
-  }
-  const key = normalizeKeyName(last);
-  if (key === null) return { error: `unparseable key: ${JSON.stringify(spec)}` };
-  return { ctrl, alt, shift, super: superKey, key };
-}
-
-export function formatKey(chord: Chord): string {
-  const parts: string[] = [];
-  if (chord.ctrl) parts.push("ctrl");
-  if (chord.alt) parts.push("alt");
-  if (chord.shift) parts.push("shift");
-  if (chord.super) parts.push("super");
-  parts.push(chord.key);
-  return parts.join("+");
-}
-
-export function resolveAction(map: Keymap, spec: string): ActionId | undefined {
-  const parsed = parseKey(spec);
-  if ("error" in parsed) return undefined;
-  return map.byKey[formatKey(parsed)];
-}
-
-export function defaultKeymap(platform: "posix" | "win32" | "wsl" = "posix"): Keymap {
-  // Windows has no job control; Ctrl+Z stays a plain key there.
-  return parseKeymap({ ...ACTION_DEFAULTS, ...(platform === "win32" ? { "app.suspend": [] } : {}) });
-}
-
-/** Scopes share chords on purpose: arrows mean history in the composer and movement in a list. */
-export function actionScope(action: string): string {
-  if (action.startsWith("editor.")) return "editor";
-  if (action.startsWith("list.")) return "list";
-  return "global";
-}
-export function parseKeymap(json: unknown, base?: Keymap): Keymap {
-  const diagnostics = [...(base?.diagnostics ?? [])];
-  const byAction: Record<string,string[]> = Object.fromEntries(Object.entries(base?.byAction ?? {}).map(([k,v]) => [k,[...v]]));
-  if (json !== undefined && json !== null && (typeof json !== "object" || Array.isArray(json))) diagnostics.push("keybindings is not an object");
-  else for (const [rawAction,raw] of Object.entries(json ?? {})) {
-    const action = ACTION_ALIASES[rawAction] ?? rawAction;
-    if (!ACTION_SET.has(action)) { diagnostics.push("unknown action: " + rawAction); continue; }
-    const specs = keySpecs(raw);
-    if (!specs) { diagnostics.push(action + ": bindings must be a string or array of strings"); continue; }
-    const keys: string[] = [];
-    byAction[action] = keys;
-    for (const spec of specs) {
-      const parsed = parseKey(spec);
-      if ("error" in parsed) { diagnostics.push(parsed.error + " (action " + action + ")"); continue; }
-      const key = formatKey(parsed);
-      for (const [other, bindings] of Object.entries(byAction)) {
-        if (other !== action && actionScope(other) === actionScope(action) && bindings.includes(key)) {
-          diagnostics.push("key " + key + " is bound to both " + other + " and " + action + "; " + action + " wins");
-          byAction[other] = bindings.filter(k => k !== key);
-        }
-      }
-      if (!keys.includes(key)) keys.push(key);
-    }
-  }
-  const byKey: Record<string,ActionId> = {};
-  for (const [action,keys] of Object.entries(byAction)) if (actionScope(action) === "global") for (const key of keys) byKey[key] = action as ActionId;
-  return { byKey, byAction, diagnostics };
-}
-
-export function listBindings(map: Keymap): { action: string; keys: readonly string[] }[] {
-  return ACTION_IDS.filter((a) => (map.byAction[a] ?? []).length > 0).map((action) => ({
-    action,
-    keys: map.byAction[action] ?? [],
-  }));
-}
-
-function keySpecs(raw: unknown): string[] | null {
-  if (typeof raw === "string") return [raw];
-  if (Array.isArray(raw) && raw.every((x) => typeof x === "string")) return raw as string[];
-  return null;
-}
-
-function normalizeKeyName(raw: string): string | null {
-  const lower = raw.toLowerCase();
-  if (lower === "esc") return "escape";
-  if (lower === "return") return "enter";
-  if (lower === "pageup") return "pageup";
-  if (lower === "pagedown") return "pagedown";
-  if (NAMED_KEYS.has(lower)) return lower === "esc" ? "escape" : lower === "return" ? "enter" : lower;
-  if (/^f([1-9]|1[0-2])$/.test(lower)) return lower;
-  if (raw.length === 1) return lower;
-  return null;
-}

package/src/core/lsp-framing.ts

@@ -1,34 +0,0 @@
-/** LSP 3.17 uses byte-counted Content-Length, not line-delimited JSON. */
-export type LspFrame = { body: Uint8Array; consumed: number };
-// Operational ceiling for optional server output; this is not a context segment threshold.
-export const MAX_LSP_FRAME = 8 * 1024 * 1024;
-// An operational bound, independent of context-segment thresholds: reject unbounded headers.
-export const MAX_LSP_HEADER = 8192;
-export function nextLspFrame(bytes: Uint8Array): LspFrame | null {
-  let end = -1;
-  for (let i = 0; i + 3 < bytes.length; i++) if (bytes[i] === 13 && bytes[i + 1] === 10 && bytes[i + 2] === 13 && bytes[i + 3] === 10) { end = i; break; }
-  if (end < 0) { if (bytes.length > MAX_LSP_HEADER) throw Error("LSP header exceeds 8 KiB"); return null; }
-  if (end > MAX_LSP_HEADER || bytes.subarray(0, end).some(byte => byte > 127)) throw Error("invalid LSP ASCII header");
-  const headers = new TextDecoder("ascii").decode(bytes.subarray(0, end)).split("\r\n");
-  if (headers.some(header => !/^[a-zA-Z0-9-]+:[\t\x20-\x7e]*$/.test(header))) throw Error("invalid LSP header field");
-  const lengths = headers.filter(header => /^content-length:/i.test(header));
-  if (lengths.length !== 1 || !/^content-length:\s*[0-9]+\s*$/i.test(lengths[0]!)) throw Error("invalid LSP Content-Length");
-  const types = headers.filter(header => /^content-type:/i.test(header));
-  if (types.length > 1) throw Error("ambiguous LSP Content-Type");
-  const charsets = types.flatMap(header => header.split(";").slice(1).filter(parameter => /^\s*charset\s*=/i.test(parameter)));
-  if (charsets.length > 1 || charsets.some(parameter => !/^\s*charset\s*=\s*(utf-?8|"utf-?8")\s*$/i.test(parameter))) throw Error("unsupported LSP charset");
-  const length = Number(lengths[0]!.split(":")[1]!.trim());
-  if (!Number.isSafeInteger(length) || length > MAX_LSP_FRAME) throw Error("LSP frame exceeds 8 MiB");
-  const consumed = end + 4 + length;
-  return bytes.length < consumed ? null : { body: bytes.slice(end + 4, consumed), consumed };
-}
-/** Unversioned server diagnostics cannot prove that they describe the current owned file. */
-export function diagnosticFreshness(observedVersion: number | undefined, currentVersion: number): "current" | "stale" | "unversioned" {
-  return observedVersion === undefined ? "unversioned" : observedVersion === currentVersion ? "current" : "stale";
-}
-export function encodeLspFrame(value: unknown): Uint8Array {
-  const body = new TextEncoder().encode(JSON.stringify(value));
-  if (body.length > MAX_LSP_FRAME) throw Error("LSP frame exceeds 8 MiB");
-  const header = new TextEncoder().encode(`Content-Length: ${body.length}\r\n\r\n`);
-  const frame = new Uint8Array(header.length + body.length); frame.set(header); frame.set(body, header.length); return frame;
-}

package/src/core/mcp-config.ts

@@ -1,68 +0,0 @@
-/** Explicit MCP configuration is authority; remote tool annotations never grant permissions (D11/D13). */
-import { webUrl } from "./web-content.ts";
-
-export interface McpOAuthConfig { clientId?: string; clientSecretEnv?: string; scope?: string; redirectUrl?: string }
-interface McpCommonConfig { enabled?: boolean; timeoutMs?: number }
-export type McpServerConfig = McpCommonConfig & ({ transport: "stdio"; command: string; args?: string[]; env?: Record<string, string> }
-  | { transport: "http"; url: string; bearerTokenEnv?: string; headers?: Record<string, string>; headersEnv?: Record<string, string>; oauth?: boolean | McpOAuthConfig });
-export type McpServers = Readonly<Record<string, McpServerConfig>>;
-function object(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw Error(`${label} must be an object`);
-  return value as Record<string, unknown>;
-}
-function strings(value: unknown, label: string, envNames = false): Record<string, string> {
-  const source = object(value, label), result: Record<string, string> = Object.create(null);
-  for (const [key, entry] of Object.entries(source)) {
-    if (typeof entry !== "string" || /[\r\n\u0000]/.test(entry) || /[\r\n\u0000]/.test(key)) throw Error(`${label} must contain single-line string values`);
-    if (envNames && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(entry)) throw Error(`${label} values must name environment variables`);
-    result[key] = entry;
-  }
-  return result;
-}
-function optionalString(source: Record<string, unknown>, key: string, envName = false): string | undefined {
-  const value = source[key];
-  if (value === undefined) return undefined;
-  if (typeof value !== "string" || !value || /[\r\n\u0000]/.test(value) || envName && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw Error(`${key} must be a valid ${envName ? "environment variable name" : "single-line string"}`);
-  return value;
-}
-export function mcpCallbackUrl(value: string): string {
-  const parsed = new URL(webUrl(value));
-  if (parsed.protocol !== "http:" || parsed.hostname !== "127.0.0.1" || parsed.search || !parsed.port || !parsed.pathname.startsWith("/"))
-    throw Error("OAuth redirectUrl must be an HTTP 127.0.0.1 URL with an explicit port and no query");
-  return parsed.href;
-}
-function oauth(value: unknown): boolean | McpOAuthConfig {
-  if (typeof value === "boolean") return value;
-  const source = object(value, "oauth");
-  if (Object.keys(source).some(key => !["clientId", "clientSecretEnv", "scope", "redirectUrl"].includes(key))) throw Error("oauth has an unsupported field");
-  const clientId = optionalString(source, "clientId"), clientSecretEnv = optionalString(source, "clientSecretEnv", true), scope = optionalString(source, "scope"), redirectUrl = optionalString(source, "redirectUrl");
-  if (clientSecretEnv && !clientId) throw Error("oauth.clientSecretEnv requires oauth.clientId");
-  return { ...(clientId ? { clientId } : {}), ...(clientSecretEnv ? { clientSecretEnv } : {}), ...(scope ? { scope } : {}), ...(redirectUrl ? { redirectUrl: mcpCallbackUrl(redirectUrl) } : {}) };
-}
-export function parseMcpServers(value: unknown): McpServers {
-  if (value === undefined || value === null) return {};
-  const source = object(value, "mcpServers"), result: Record<string, McpServerConfig> = Object.create(null);
-  for (const [name, raw] of Object.entries(source)) {
-    if (!/^[A-Za-z0-9_-]{1,64}$/.test(name)) throw Error("MCP server names must contain 1 to 64 letters, digits, underscores or hyphens");
-    const config = object(raw, `MCP server ${name}`), enabled = config["enabled"], timeout = config["timeoutMs"];
-    if (enabled !== undefined && typeof enabled !== "boolean") throw Error(`MCP server ${name}.enabled must be boolean`);
-    // Assumed cap protects startup and tool execution from a misconfigured peer, not an OS sandbox.
-    if (timeout !== undefined && (!Number.isSafeInteger(timeout) || Number(timeout) < 1 || Number(timeout) > 300_000)) throw Error("MCP timeoutMs must be an integer from 1 to 300000");
-    const common = { ...(typeof enabled === "boolean" ? { enabled } : {}), ...(typeof timeout === "number" ? { timeoutMs: timeout } : {}) };
-    if (config["transport"] === "stdio") {
-      if (Object.keys(config).some(key => !["transport", "command", "args", "env", "enabled", "timeoutMs"].includes(key))) throw Error(`MCP server ${name} has an unsupported stdio field`);
-      const command = optionalString(config, "command"), args = config["args"], env = config["env"];
-      if (!command) throw Error(`MCP server ${name}.command is required`);
-      if (args !== undefined && (!Array.isArray(args) || !args.every(arg => typeof arg === "string" && !arg.includes("\u0000")))) throw Error("MCP args must be strings without NUL");
-      result[name] = { transport: "stdio", command, ...common, ...(Array.isArray(args) ? { args: args.slice() as string[] } : {}), ...(env === undefined ? {} : { env: strings(env, "env") }) };
-    } else if (config["transport"] === "http") {
-      if (Object.keys(config).some(key => !["transport", "url", "bearerTokenEnv", "headers", "headersEnv", "oauth", "enabled", "timeoutMs"].includes(key))) throw Error(`MCP server ${name} has an unsupported HTTP field`);
-      const token = optionalString(config, "bearerTokenEnv", true), headers = config["headers"], headersEnv = config["headersEnv"];
-      if (config["oauth"] && token) throw Error("Use bearerTokenEnv or oauth for one MCP server, not both");
-      result[name] = { transport: "http", url: webUrl(config["url"]), ...common, ...(token ? { bearerTokenEnv: token } : {}),
-        ...(headers === undefined ? {} : { headers: strings(headers, "headers") }), ...(headersEnv === undefined ? {} : { headersEnv: strings(headersEnv, "headersEnv", true) }),
-        ...(config["oauth"] === undefined ? {} : { oauth: oauth(config["oauth"]) }) };
-    } else throw Error(`MCP server ${name}.transport must be stdio or http`);
-  }
-  return result;
-}

package/src/core/model-picker.ts

@@ -1,64 +0,0 @@
-/**
- * `/model` list order. Pure: the catalog, readiness and recency go in,
- * rows come out.
- *
- * The catalog holds thousands of entries across hundreds of providers; a
- * picker that lists them all is the "every time I pick a model it's hard"
- * report. The rule is OpenCode's (dialog-model.tsx): only models whose
- * provider can actually authenticate, Recent first (bounded), then one
- * group per provider, in catalog order. The current model is always shown, even when its
- * credential stopped resolving, so the user can see why they are stuck.
- */
-export interface PickerModel {
-  readonly key: string;
-  readonly provider: string;
-  readonly providerName: string;
-  readonly id: string;
-  readonly name: string;
-  readonly ready: boolean;
-}
-
-export interface PickerRow {
-  readonly key: string;
-  readonly section: "recent" | "provider";
-  /** Group heading: "Recent" or the provider's display name. */
-  readonly group: string;
-  readonly model: PickerModel;
-  readonly current: boolean;
-}
-
-/** Five recent models: one screen of a 10-row list stays for the provider groups. Assumed. */
-export const RECENT_LIMIT = 5;
-
-export function pickerRows(models: readonly PickerModel[], opts: { readonly current: string; readonly recent: readonly string[]; readonly limit?: number }): PickerRow[] {
-  const visible = models.filter(model => model.ready || model.key === opts.current);
-  const byKey = new Map(visible.map(model => [model.key, model]));
-  const rows: PickerRow[] = [];
-  const used = new Set<string>();
-  for (const key of opts.recent) {
-    if (rows.length >= (opts.limit ?? RECENT_LIMIT)) break;
-    const model = byKey.get(key);
-    if (!model || used.has(key)) continue;
-    used.add(key);
-    rows.push({ key, section: "recent", group: "Recent", model, current: key === opts.current });
-  }
-  const groups = new Map<string, PickerModel[]>();
-  for (const model of visible) {
-    if (used.has(model.key)) continue;
-    used.add(model.key);
-    const list = groups.get(model.provider) ?? [];
-    list.push(model);
-    groups.set(model.provider, list);
-  }
-  // Catalog order is curated (flagship models first), so it is kept for
-  // both the groups and the models inside them instead of re-sorting.
-  for (const [, list] of groups) {
-    for (const model of list) rows.push({ key: model.key, section: "provider", group: model.providerName, model, current: model.key === opts.current });
-  }
-  return rows;
-}
-
-/** Most recent first, deduplicated, bounded. Recording is a pure update of the stored list. */
-export function recordRecent(recent: readonly string[], key: string, limit = 10): string[] {
-  return [key, ...recent.filter(entry => entry !== key)].slice(0, limit);
-}

package/src/core/model-preferences.ts

@@ -1,28 +0,0 @@
-/** User selections become startup preferences; restored session state stays in the log (D8/Q.25). */
-import { recordRecent } from "./model-picker.ts";
-import { modelKey } from "./session-position.ts";
-import { settingsToWrite, type Settings } from "./settings.ts";
-import type { ThinkingLevel } from "./thinking.ts";
-
-interface ModelIdentity { readonly provider: string; readonly id: string }
-
-/** Keep the effective effort with its model, without changing another model's saved effort. */
-export function modelPreferencePatch(model: ModelIdentity, recent: readonly string[], effort: ThinkingLevel): Settings {
-  return { defaultProvider: model.provider, defaultModel: model.id, recentModels: recordRecent(recent, modelKey(model)),
-    modelThinkingLevels: { [modelKey(model)]: effort } };
-}
-
-export function thinkingPreferencePatch(model: ModelIdentity, effort: ThinkingLevel): Settings {
-  return { defaultThinking: effort, modelThinkingLevels: { [modelKey(model)]: effort } };
-}
-
-/** Patch only known preferences; retain future keys and nested fields not owned by this selection. */
-export function mergePreferenceJson(previous: Readonly<Record<string, unknown>>, patch: Settings): Record<string, unknown> {
-  const next = { ...previous, ...settingsToWrite(patch) };
-  for (const key of ["terminal", "images", "markdown", "modelThinkingLevels"] as const) {
-    if (patch[key] === undefined) continue;
-    const old = previous[key];
-    next[key] = { ...(old !== null && typeof old === "object" && !Array.isArray(old) ? old : {}), ...patch[key] };
-  }
-  return next;
-}

package/src/core/model-replay.ts

@@ -1,22 +0,0 @@
-import type { LogEvent } from "./events.ts";
-
-export interface ReplayModel {
-  provider: string; id: string; api: string; driver?: string; wireId?: string; baseUrl?: string;
-  compat?: unknown; nativeCompat?: unknown; thinkingLevelMap?: unknown;
-}
-function canonical(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)]));
-  return value;
-}
-
-/** D8: replay identity excludes prices, UI labels, credentials and sampling choices. */
-export function replayDescriptor(model: ReplayModel): string {
-  return JSON.stringify(canonical([model.provider, model.id, model.api, model.driver ?? "legacy", model.wireId ?? model.id,
-    model.baseUrl ?? "", model.compat ?? null, model.nativeCompat ?? null, model.thinkingLevelMap ?? null]));
-}
-
-/** Old native profiles have no provable wire identity. One checkpoint makes subsequent replay explicit. */
-export function needsReplayCheckpoint(events: readonly LogEvent[], key: string, requireKnown: boolean): boolean {
-  return events.some(event => event.t === "assistant" && (event.replay_key === undefined ? requireKnown : event.replay_key !== key));
-}

package/src/core/model-scope.ts

@@ -1,53 +0,0 @@
-/** Ordered model identities are session state until explicitly saved. D13: never resolve bare IDs here. */
-import { asThinkingLevel, type ThinkingLevel } from "./thinking.ts";
-import { modelKey } from "./session-position.ts";
-
-export interface ScopedModel<T> { model: T; thinking?: ThinkingLevel }
-
-/** Exact full references win before suffix parsing, including IDs whose colon is literal (Pi 02eed88). */
-export function resolveScope<T extends { id: string; provider: string }>(
-  patterns: readonly string[], match: (pattern: string) => readonly T[], strict = false,
-): { entries: ScopedModel<T>[]; diagnostics: string[] } {
-  const entries: ScopedModel<T>[] = [], diagnostics: string[] = [], seen = new Set<string>();
-  for (const pattern of patterns) {
-    let matches = match(pattern), thinking: ThinkingLevel | undefined;
-    if (!matches.length) {
-      const colon = pattern.lastIndexOf(":");
-      if (colon > 0) {
-        const suffix = pattern.slice(colon + 1), level = asThinkingLevel(suffix);
-        if (level || !strict) {
-          matches = match(pattern.slice(0, colon));
-          if (matches.length) {
-            thinking = level;
-            if (!level) diagnostics.push(`Invalid thinking level ${JSON.stringify(suffix)} in ${JSON.stringify(pattern)}; using the default`);
-          }
-        }
-      }
-    }
-    if (!matches.length) diagnostics.push(`No models match ${JSON.stringify(pattern)}`);
-    for (const model of matches) {
-      const key = modelKey(model); if (seen.has(key)) continue; seen.add(key);
-      entries.push({ model, ...(thinking === undefined ? {} : { thinking }) });
-    }
-  }
-  return { entries, diagnostics };
-}
-
-export function scopeReference<T extends { id: string; provider: string }>(entry: ScopedModel<T>): string {
-  return modelKey(entry.model) + (entry.thinking ? `:${entry.thinking}` : "");
-}
-
-export type ScopeChange = { readonly kind: "toggle"; readonly ids: readonly string[] } |
-  { readonly kind: "enable" | "disable"; readonly ids: readonly string[] } |
-  { readonly kind: "move"; readonly id: string; readonly delta: -1 | 1 };
-export function changeModelScope(current: readonly string[], change: ScopeChange): string[] {
-  const next = [...new Set(current)];
-  if (change.kind === "move") {
-    const index = next.indexOf(change.id), target = index + change.delta;
-    if (index >= 0 && target >= 0 && target < next.length) [next[index], next[target]] = [next[target]!, next[index]!];
-    return next;
-  }
-  const ids = new Set(change.ids);
-  const disable = change.kind === "disable" || change.kind === "toggle" && change.ids.every(id => next.includes(id));
-  return disable ? next.filter(id => !ids.has(id)) : [...next, ...[...ids].filter(id => !next.includes(id))];
-}

package/src/core/note-guidance.ts

@@ -1,34 +0,0 @@
-/** Q.22: recovery advice must use the same evidence rules as the handoff. */
-import type { LogEvent } from "./events.ts";
-import { resolveEvidence, type EvidenceResolution } from "./evidence.ts";
-import type { ToolDiagnostic } from "./tool-contract.ts";
-import { failureDiagnostic, NOT_STARTED } from "./tool-failure.ts";
-
-type Claim = Extract<LogEvent, { t: "claim" }>;
-
-/** Only unknown work may suggest the existing unscoped completion path. */
-export function unknownWorkClaimDiagnostic(events: readonly LogEvent[], claim: Claim): ToolDiagnostic {
-  const proof = resolveEvidence(events, claim.evidence);
-  const message = `unknown work_id ${claim.work_id}; no work item was created or completed`;
-  const diagnostic = failureDiagnostic("invalid_input", message, NOT_STARTED);
-  if (!proof.ok) return { ...diagnostic,
-    next: "For tracked work, record next before doing and verifying it. For a one-off task, omit work_id from done after an actual successful verification. A done note is optional." };
-  return { ...diagnostic,
-    next: "A current successful verification already exists. For this one-off completion, omit work_id; do not create next after verification or rerun the command just to record a note.",
-    recover: { tool: "note", input: { kind: "done", what: claim.what, proof: proof.evidence.command } } };
-}
-
-/** A persisted claim is a known state change, even when its proof is insufficient. */
-export function unverifiedNoteDiagnostic(reason: Extract<EvidenceResolution, { ok: false }>, event: string, openedAt?: string): ToolDiagnostic {
-  const cause = reason.reason === "nonzero_exit" ? `the matching command exited ${reason.exit}`
-    : reason.reason === "stale_workspace" ? "the verification no longer matches the observed workspace"
-    : openedAt ? `no matching verification was observed after work activation ${openedAt} in this segment`
-    : "no matching verification was observed in this segment";
-  const message = `Claim ${event} was recorded but remains unverified: ${cause}.`;
-  return { ...failureDiagnostic("execution_failed", message, { execution: "started", effects: "possible" }),
-    next: "The claim is already recorded; do not replay it unchanged. " + (reason.reason === "nonzero_exit"
-      ? "Inspect the command's original output, fix the cause and verify again before claiming completion."
-      : reason.reason === "stale_workspace" ? "Verify the current workspace before claiming completion."
-      : openedAt ? "Run the verifier for this work activation before claiming completion; reopening never reuses an older verification."
-      : "Cite an actual successful command from this segment, or run the required verification first.") };
-}

package/src/core/oauth-fields.ts

@@ -1,44 +0,0 @@
-/** Validated wire data only; the runtime owns HTTP, time, polling and persistence. */
-export interface OAuthTokens { access: string; refresh: string; expiresIn: number }
-export interface DeviceAuthorization {
-  deviceCode: string;
-  userCode: string;
-  verificationUri: string;
-  verificationUriComplete?: string;
-  expiresIn: number;
-  interval?: number;
-}
-
-function record(value: unknown): Record<string, unknown> | undefined {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-function positive(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value > 0; }
-function token(value: unknown): value is string { return typeof value === "string" && value.length > 0 && !/[\s\x00-\x1f\x7f]/.test(value); }
-
-/** Refresh rotation is optional; omission preserves the existing refresh capability. */
-export function parseOAuthTokens(value: unknown, previousRefresh?: string): OAuthTokens | undefined {
-  const data = record(value);
-  const access = data?.["access_token"], refresh = data?.["refresh_token"] ?? previousRefresh, expiresIn = data?.["expires_in"];
-  if (!token(access) || !token(refresh) || !positive(expiresIn)) return undefined;
-  return { access, refresh, expiresIn };
-}
-
-export function trustedOAuthUrl(value: unknown, origins: readonly string[]): value is string {
-  if (typeof value !== "string" || /[\x00-\x20\x7f]/.test(value)) return false;
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" && !url.username && !url.password && origins.includes(url.origin);
-  } catch { return false; }
-}
-
-/** Never open an issuer-supplied arbitrary origin or print its control characters. */
-export function parseDeviceAuthorization(value: unknown, origins: readonly string[]): DeviceAuthorization | undefined {
-  const data = record(value);
-  const deviceCode = data?.["device_code"], userCode = data?.["user_code"], verificationUri = data?.["verification_uri"];
-  const complete = data?.["verification_uri_complete"], expiresIn = data?.["expires_in"], interval = data?.["interval"];
-  if (!token(deviceCode) || typeof userCode !== "string" || !/^[A-Za-z0-9-]+$/.test(userCode)
-    || !trustedOAuthUrl(verificationUri, origins) || !positive(expiresIn)
-    || (complete !== undefined && !trustedOAuthUrl(complete, origins)) || (interval !== undefined && !positive(interval))) return undefined;
-  return { deviceCode, userCode, verificationUri, expiresIn,
-    ...(typeof complete === "string" ? { verificationUriComplete: complete } : {}), ...(typeof interval === "number" ? { interval } : {}) };
-}