@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/acceptance.ts

@@ -1,139 +0,0 @@
-/** O.11: declared criteria, command evidence and human acceptance are separate. */
-import type { LogEvent } from "./events.ts";
-import type { Evidence } from "./handoff.ts";
-import { evidenceStale } from "./evidence.ts";
-import { workspaceChanged } from "./checkpoints.ts";
-import { parseRuntimeTarget, type RuntimeTarget, type TargetAcceptance } from "./runtime-target.ts";
-
-/**
- * A command criterion either tests the change -- it fails before the work and
- * passes after it (SWE-bench's FAIL_TO_PASS) -- or, with `guard`, protects
- * what the work must not break: it passes before and after (PASS_TO_PASS),
- * such as "the test file is unchanged" (S.7).
- */
-export type AcceptanceCriterion = { id: string; description: string } &
-  ({ kind: "command"; command: string; guard?: true } | { kind: "human"; target?: string });
-export type AcceptanceContract = { version: 1; id: string; scope?: "request" | "changes"; criteria: AcceptanceCriterion[];
-  source?: { path: string; sha256: string }; targets?: RuntimeTarget[] };
-export type AcceptanceState = {
-  contract_id: string; contract_event: string; request: string; scope: "request" | "changes"; changed: boolean;
-  criteria: (AcceptanceCriterion & { status: "not_run" | "pass" | "fail" | "stale" | "awaiting_human" | "accepted"; evidence?: Evidence; accepted_event?: string; accepted_binding?: string })[];
-  targets?: TargetAcceptance[];
-  status: "needs_work" | "awaiting_human" | "verified" | "not_applicable";
-};
-/**
- * The longest check command a contract accepts. Drafted checks are often one
- * inline script (`python3 -c '...'`); a real 599-character structure check
- * was refused at the earlier 500 (fix-goal-read-only-draft). Bounded so a
- * frozen contract stays small.
- */
-export const ACCEPTANCE_COMMAND_LIMIT = 2000;
-const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const label = (value: unknown, max: number) => typeof value === "string" && value.trim().length > 0 && value.length <= max;
-
-export function parseAcceptanceContract(value: unknown): AcceptanceContract {
-  if (!record(value) || value["version"] !== 1 || !label(value["id"], 80) ||
-      (value["scope"] !== undefined && value["scope"] !== "request" && value["scope"] !== "changes") ||
-      !Array.isArray(value["criteria"]) || value["criteria"].length < 1 || value["criteria"].length > 20) throw new Error("invalid acceptance contract v1");
-  if (Object.keys(value).some(key => !["version", "id", "scope", "criteria", "source", "targets"].includes(key))) throw new Error("unsupported acceptance contract field");
-  const source = value["source"];
-  if (source !== undefined && (!record(source) || !label(source["path"], 4096) || typeof source["sha256"] !== "string" || !/^[a-f0-9]{64}$/.test(source["sha256"]))) throw new Error("invalid acceptance source");
-  const criteria: AcceptanceCriterion[] = value["criteria"].map((item: unknown) => {
-    if (!record(item) || !label(item["id"], 80) || !label(item["description"], 300)) throw new Error("invalid acceptance criterion");
-    if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/.test(String(item["id"])) || Object.keys(item).some(key => !["id", "description", "kind", "command", "target", "guard"].includes(key))) throw new Error("unsupported acceptance criterion field or ID");
-    const fields = { id: String(item["id"]), description: String(item["description"]) };
-    if (item["kind"] === "human" && item["command"] === undefined && item["guard"] === undefined && (item["target"] === undefined || label(item["target"], 80))) return { ...fields, kind: "human", ...(item["target"] ? { target: String(item["target"]) } : {}) };
-    if (item["kind"] === "command" && item["target"] === undefined && label(item["command"], ACCEPTANCE_COMMAND_LIMIT) && (item["guard"] === undefined || item["guard"] === true)) {
-      return { ...fields, kind: "command", command: String(item["command"]), ...(item["guard"] === true ? { guard: true as const } : {}) };
-    }
-    throw new Error("acceptance criterion must declare a command or human decision");
-  });
-  if (new Set(criteria.map(item => item.id)).size !== criteria.length) throw new Error("duplicate acceptance criterion IDs");
-  const declarations = value["targets"];
-  if (declarations !== undefined && (!Array.isArray(declarations) || declarations.length < 1 || declarations.length > 8)) throw Error("targets requires 1..8 declared runtimes");
-  const targets = Array.isArray(declarations) ? declarations.map(parseRuntimeTarget) : undefined;
-  if (targets && (new Set(targets.map(target => target.id)).size !== targets.length || targets.some(target =>
-    !criteria.some(item => item.id === target.build && item.kind === "command") || !criteria.some(item => item.kind === "human" && item.target === target.id)))) throw Error("targets require a build condition and a bound human condition");
-  if (criteria.some(item => item.kind === "human" && item.target && !targets?.some(target => target.id === item.target))) throw Error("unknown human acceptance target");
-  return { version: 1, id: String(value["id"]), criteria,
-    ...(targets ? { targets } : {}),
-    ...(record(source) ? { source: { path: String(source["path"]), sha256: String(source["sha256"]) } } : {}),
-    ...(value["scope"] ? { scope: value["scope"] as "request" | "changes" } : {}) };
-}
-
-/**
- * What one counter-check observation means (S.1, S.7): the check run once more
- * in a clone with the request's changes undone. A check that tests the change
- * must fail there; a guard must still pass there. The log records only the
- * exit code and the role it ran under, so every view derives the verdict here
- * and none can disagree with another.
- *
- *   tests the change   fails there: discriminating   passes there: vacuous
- *   guard              passes there: held            fails there: not_held
- *
- * A guard that did not hold is not a defect in the evidence: the check does
- * test the change, only its declaration was wrong.
- */
-export type CounterVerdict = "discriminating" | "vacuous" | "held" | "not_held" | "unavailable";
-export function counterVerdict(observation: { guard?: true } & ({ exit: number } | { reason: string })): CounterVerdict {
-  if (!("exit" in observation)) return "unavailable";
-  if (observation.guard) return observation.exit === 0 ? "held" : "not_held";
-  return observation.exit === 0 ? "vacuous" : "discriminating";
-}
-
-export function deriveAcceptance(previous: AcceptanceState | undefined, events: readonly LogEvent[]): AcceptanceState | undefined {
-  let state = previous ? { ...previous, criteria: previous.criteria.map(item => ({ ...item })), ...(previous.targets ? { targets: previous.targets.map(target => ({ ...target })) } : {}) } : undefined;
-  for (const event of events) {
-    if (event.t === "acceptance_contract") {
-      state = { contract_id: event.contract.id, contract_event: event.id, request: event.request, scope: event.contract.scope ?? "request", changed: false,
-        criteria: event.contract.criteria.map(item => ({ ...item, status: item.kind === "human" ? "awaiting_human" : "not_run" })), status: "needs_work" };
-      if (event.contract.targets) state.targets = event.contract.targets.map(target => ({ id: target.id, build: target.build, status: "not_run" }));
-      continue;
-    }
-    if (!state) continue;
-    const mutation = workspaceChanged(event);
-    if (mutation) { state.changed = true; for (const target of state.targets ?? []) target.status = "stale"; }
-    if (event.t === "target_observation" && event.observation.request === state.request && event.observation.contract_event === state.contract_event) {
-      const target = state.targets?.find(item => item.id === event.observation.target), receipt = event.observation;
-      if (target) {
-        const build = state.criteria.find(item => item.id === target.build);
-        target.status = receipt.state === "ready" && (build?.status !== "pass" || build.evidence?.event_id !== receipt.build?.event) ? "stale" : receipt.state;
-        target.observation = event.id; target.reason = receipt.reason;
-        if (receipt.build) target.build_event = receipt.build.event;
-        if (receipt.instance) { target.binding = receipt.instance.id; target.session = receipt.instance.session; target.pid = receipt.instance.pid; target.entry = receipt.instance.entry.path; }
-        else { delete target.binding; delete target.session; delete target.pid; delete target.entry; }
-        if (receipt.port !== undefined) target.port = receipt.port;
-      }
-    }
-    for (const target of state.targets ?? []) if (event.t === "process_exit" && event.session === target.session ||
-      event.t === "tool_result" && record(event.data) && event.data["session_id"] === target.session && event.data["running"] === false) target.status = "stale";
-    for (const item of state.criteria) {
-      if (item.evidence && evidenceStale([event], item.evidence, item.status === "stale")) item.status = "stale";
-      if (mutation && item.kind === "human" && item.status === "accepted") { item.status = "awaiting_human"; delete item.accepted_event; delete item.accepted_binding; }
-      if (item.kind === "command" && event.t === "tool_result" && event.effect?.kind === "command" && event.effect.cmd === item.command) {
-        item.status = event.effect.exit === 0 && event.ok ? event.effect.workspace_observed === false ? "stale" : "pass" : "fail";
-        item.evidence = { command: event.effect.cmd, exit: event.effect.exit, event_id: event.id, at: event.at,
-          ...(event.effect.workspace_scope ? { workspace_scope: event.effect.workspace_scope } : {}),
-          ...(event.effect.workspace_sha256 ? { workspace_sha256: event.effect.workspace_sha256 } : {}) };
-        for (const target of state.targets ?? []) if (target.build === item.id && target.build_event !== event.id) target.status = "stale";
-      }
-      if (item.kind === "human" && event.t === "acceptance_decision" && event.request === state.request &&
-          event.contract_id === state.contract_id && event.criterion === item.id && event.actor === "user") {
-        const target = item.target ? state.targets?.find(target => target.id === item.target) : undefined;
-        if (!item.target || target?.status === "ready" && target.binding === event.target_binding && target.observation === event.target_observation) {
-          item.status = "accepted"; item.accepted_event = event.id;
-          if (event.target_binding) item.accepted_binding = event.target_binding;
-        }
-      }
-    }
-    for (const target of state.targets ?? []) if (target.status === "ready" && !state.criteria.some(item => item.id === target.build && item.status === "pass" && item.evidence?.event_id === target.build_event)) target.status = "stale";
-    for (const item of state.criteria) if (item.kind === "human" && item.target && item.status === "accepted") {
-      const target = state.targets?.find(target => target.id === item.target);
-      if (target?.status !== "ready" || target.binding !== item.accepted_binding) { item.status = "awaiting_human"; delete item.accepted_event; delete item.accepted_binding; }
-    }
-  }
-  if (state) state.status = state.scope === "changes" && !state.changed ? "not_applicable" :
-    state.criteria.some(item => item.kind === "command" && item.status !== "pass") || state.targets?.some(target => target.status !== "ready") ? "needs_work" :
-    state.criteria.some(item => item.kind === "human" && item.status !== "accepted") ? "awaiting_human" : "verified";
-  return state;
-}

package/src/core/action-defaults.ts

@@ -1,58 +0,0 @@
-/**
- * xeno's key bindings (D20). One flat namespace:
- *   app.*     global, handled before the focused component
- *   editor.*  the composer (submit / newline / history / completion)
- *   list.*    every list dialog (palette, model, login, resume, tree, …)
- * Shortcuts that only exist inside one dialog are shown in that dialog's
- * hint row instead of being configurable globals; the palette (Ctrl+P)
- * reaches every command, so rarely used actions need no chord at all.
- */
-export const ACTION_DEFAULTS = {
-  "app.palette": ["ctrl+p"],
-  "app.model": ["ctrl+l"],
-  "app.cycleModel": ["alt+m"],
-  "app.cycleModelReverse": ["alt+shift+m"],
-  "app.cycleThinking": ["shift+tab"],
-  "app.toggleTools": ["ctrl+o"],
-  "app.toggleThinking": ["ctrl+t"],
-  "app.toggleSidebar": ["ctrl+b"],
-  "app.interrupt": ["escape"],
-  "app.clear": ["ctrl+c"],
-  "app.exit": ["ctrl+d"],
-  "app.suspend": ["ctrl+z"],
-  "app.externalEditor": ["ctrl+g"],
-  "app.message.copy": ["ctrl+x"],
-  "app.message.followUp": ["alt+enter"],
-  "app.message.dequeue": ["alt+up"],
-  "app.clipboard.pasteImage": ["ctrl+v"],
-  "app.scroll.pageUp": ["pageup"],
-  "app.scroll.pageDown": ["pagedown"],
-  "app.scroll.top": ["ctrl+home"],
-  "app.scroll.bottom": ["ctrl+end"],
-  "app.session.new": [],
-  "app.session.tree": [],
-  "app.session.fork": [],
-  "app.session.resume": [],
-  "app.saveDefault": ["ctrl+s"],
-  "editor.submit": ["enter"],
-  "editor.newLine": ["shift+enter", "ctrl+j"],
-  "editor.complete": ["tab"],
-  "editor.historyPrevious": ["up"],
-  "editor.historyNext": ["down"],
-  "list.up": ["up", "ctrl+k"],
-  "list.down": ["down", "ctrl+j"],
-  "list.pageUp": ["pageup"],
-  "list.pageDown": ["pagedown"],
-  "list.confirm": ["enter"],
-  "list.cancel": ["escape"],
-  "list.toggle": ["space"],
-} as const satisfies Record<string, readonly string[]>;
-
-/** Renamed ids still read from a user's keybindings file. */
-export const ACTION_ALIASES: Readonly<Record<string, string>> = {
-  "app.model.select": "app.model",
-  "app.thinking.cycle": "app.cycleThinking",
-  "app.thinking.toggle": "app.toggleThinking",
-  "app.tools.expand": "app.toggleTools",
-  "app.editor.external": "app.externalEditor",
-};

package/src/core/activity-status.ts

@@ -1,52 +0,0 @@
-/** A finer view of OSC status, derived from the same runtime facts (D11). */
-import { programStatus, type ProgramStatus } from "./program-status.ts";
-import type { ExecutionOutcome } from "./outcome.ts";
-
-export interface ActivityFacts {
-  readonly running: boolean;
-  readonly waiting?: "permission" | "question" | "auth" | null;
-  readonly outcome?: ExecutionOutcome;
-  readonly goal?: string;
-  readonly phase?: "connecting" | "thinking" | "streaming" | "tool";
-  readonly tool?: string;
-  readonly retry?: RetryFacts;
-  readonly queued: number;
-}
-/** One pending retry: which attempt, out of how many, how long until it, and why. */
-export interface RetryFacts { readonly attempt: number; readonly max?: number; readonly seconds: number; readonly reason?: string }
-
-const attemptText = (retry: RetryFacts): string => retry.max === undefined ? `${retry.attempt}` : `${retry.attempt}/${retry.max}`;
-
-/**
- * The stream-area retry line. The cause appears from the third attempt (or
- * the last, for a smaller budget), as in Claude Code: one or two retries are
- * noise, and naming them would send the user to check a network that is fine.
- */
-export function retryLine(retry: RetryFacts): string {
-  const named = retry.reason !== undefined && retry.attempt >= Math.min(3, retry.max ?? 3);
-  return `retry ${attemptText(retry)} in ${Math.max(0, retry.seconds).toFixed(1)}s · ${named ? `${retry.reason} · ` : ""}esc to cancel`;
-}
-
-export interface ActivityStatus { readonly state: ProgramStatus["state"]; readonly label: string; readonly detail: string; readonly queued: number }
-
-const STOP_CAUSE: Partial<Record<ExecutionOutcome["reason"], string>> = {
-  stalled: "no progress", no_progress: "no progress", max_turns: "request limit", context_budget: "context budget",
-  output_limit: "output limit", timeout: "time limit",
-};
-
-export function activityStatus(facts: ActivityFacts): ActivityStatus {
-  const status = programStatus(facts), queued = Math.max(0, Math.floor(facts.queued));
-  const view = (label: string, detail = status.msg ?? ""): ActivityStatus => ({ state: status.state, label, detail, queued });
-  // A harness stop is not a question: saying "Awaiting input" left the user
-  // guessing what to answer (fix-finished-turn-status). The OSC state stays blocked.
-  if (!facts.running && !facts.waiting && facts.outcome?.status === "stopped") return view("Stopped", STOP_CAUSE[facts.outcome.reason] ?? facts.outcome.reason.replaceAll("_", " "));
-  if (status.state === "blocked") return view(status.kind === "auth" ? "Sign in required" : status.kind === "permission" ? "Awaiting approval"
-    : !facts.waiting && facts.goal === "awaiting_human" ? "Awaiting review" : "Awaiting input");
-  if (status.state === "error") return view("Failed");
-  if (!facts.running) return view(status.state === "done" ? "Turn finished" : facts.outcome?.status === "cancelled" ? "Cancelled" : "Ready");
-  if (facts.retry) return view("Retrying", `attempt ${attemptText(facts.retry)} · ${Math.max(0, Math.ceil(facts.retry.seconds))}s`);
-  if (facts.phase === "tool") return view("Running tool", facts.tool ?? "Tool execution");
-  if (facts.phase === "thinking") return view("Thinking");
-  if (facts.phase === "streaming") return view("Responding");
-  return view("Connecting", "Waiting for the first response");
-}

package/src/core/agent-profile.ts

@@ -1,130 +0,0 @@
-/** R13 / D13: explicit role layers share tool, model, workflow and budget ownership. */
-import { isWorkflowMode, type WorkflowMode } from "./workflow-mode.ts";
-import { isToolProfile, parsePermissionRule, type PermissionRule, type ToolSelection } from "./permissions.ts";
-import { asThinkingLevel, type ThinkingLevel } from "./thinking.ts";
-
-export interface AgentProfile {
-  readonly name: string;
-  readonly description?: string;
-  readonly mode?: WorkflowMode;
-  readonly instructions?: string;
-  readonly model?: { readonly provider: string; readonly id: string; readonly thinking?: ThinkingLevel };
-  readonly tools?: ToolSelection;
-  readonly permissions?: readonly PermissionRule[];
-  /** maxTurns is a hard cap; timeBudgetMs retains the existing advisory semantics. */
-  readonly budget?: { readonly maxTurns?: number; readonly timeBudgetMs?: number };
-}
-export type AgentProfileField = Exclude<keyof AgentProfile, "name">;
-export interface AgentProfileSource { readonly kind: "builtin" | "user" | "project" | "cli"; readonly path?: string }
-export interface AgentProfileLayer { readonly source: AgentProfileSource; readonly profiles: readonly AgentProfile[] }
-export interface ResolvedAgentProfile {
-  readonly profile: AgentProfile;
-  readonly sources: readonly AgentProfileSource[];
-  readonly provenance: Readonly<Partial<Record<AgentProfileField, AgentProfileSource>>>;
-}
-export interface AgentProfileParse { readonly profiles: readonly AgentProfile[]; readonly diagnostics: readonly string[] }
-
-/** Named builtins are explicit selectable presets; they never fill missing fields in another role. */
-export function builtinAgentProfileLayer(): AgentProfileLayer {
-  return { source: { kind: "builtin" }, profiles: [{ name: "build", mode: "build", tools: { profile: "foundation" } }, { name: "plan", mode: "plan", tools: { profile: "foundation" } },
-    { name: "reviewer", mode: "plan", tools: { profile: "readonly" },
-      instructions: "Review current code for actionable defects. Cite concrete evidence and paths; do not edit the workspace." }] };
-}
-
-const FIELDS: readonly AgentProfileField[] = ["description", "mode", "instructions", "model", "tools", "permissions", "budget"];
-export function isAgentProfileName(value: string): boolean { return /^[a-z][a-z0-9_-]{0,63}$/.test(value); }
-function record(value: unknown, label: string, allowed: readonly string[]): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw Error(`${label} must be an object`);
-  const obj = value as Record<string, unknown>;
-  const unknown = Object.keys(obj).find(key => !allowed.includes(key));
-  if (unknown) throw Error(`${label} has unknown field ${unknown}`);
-  return obj;
-}
-function text(value: unknown, label: string): string {
-  if (typeof value !== "string" || !value.trim() || value.includes("\0")) throw Error(`${label} must be a nonempty string`);
-  return value;
-}
-function strings(value: unknown, label: string): string[] {
-  if (!Array.isArray(value) || value.some(item => typeof item !== "string" || !item.trim()) || new Set(value).size !== value.length) throw Error(`${label} must contain unique nonempty names`);
-  return [...value] as string[];
-}
-
-export function parseAgentProfile(value: unknown): AgentProfile {
-  const obj = record(value, "agent profile", ["name", ...FIELDS]);
-  const name = text(obj["name"], "agent name");
-  if (!isAgentProfileName(name)) throw Error("agent name must begin with a lowercase letter and contain only letters, digits, _ or - (max 64)");
-  const profile: { name: string; description?: string; mode?: WorkflowMode; instructions?: string;
-    model?: NonNullable<AgentProfile["model"]>; tools?: ToolSelection; permissions?: PermissionRule[]; budget?: NonNullable<AgentProfile["budget"]> } = { name };
-  if (obj["description"] !== undefined) profile.description = text(obj["description"], "agent description");
-  if (obj["instructions"] !== undefined) profile.instructions = text(obj["instructions"], "agent instructions");
-  if (obj["mode"] !== undefined) {
-    if (typeof obj["mode"] !== "string" || !isWorkflowMode(obj["mode"])) throw Error("agent mode must be build or plan");
-    profile.mode = obj["mode"];
-  }
-  if (obj["model"] !== undefined) {
-    const model = record(obj["model"], "agent model", ["provider", "id", "thinking"]);
-    const provider = text(model["provider"], "agent model provider"), id = text(model["id"], "agent model id");
-    const thinking = asThinkingLevel(model["thinking"]);
-    if (model["thinking"] !== undefined && thinking === undefined) throw Error("agent model thinking is invalid");
-    profile.model = { provider, id, ...(thinking !== undefined ? { thinking } : {}) };
-  }
-  if (obj["tools"] !== undefined) {
-    const tools = record(obj["tools"], "agent tools", ["profile", "only", "exclude", "none", "noBuiltin"]);
-    const selected: { profile?: NonNullable<ToolSelection["profile"]>; only?: string[]; exclude?: string[]; none?: boolean; noBuiltin?: boolean } = {};
-    if (tools["profile"] !== undefined) {
-      if (typeof tools["profile"] !== "string" || !isToolProfile(tools["profile"])) throw Error("agent tool profile is invalid");
-      selected.profile = tools["profile"];
-    }
-    if (tools["only"] !== undefined) selected.only = strings(tools["only"], "agent tools.only");
-    if (tools["exclude"] !== undefined) selected.exclude = strings(tools["exclude"], "agent tools.exclude");
-    for (const key of ["none", "noBuiltin"] as const) {
-      if (tools[key] !== undefined) { if (typeof tools[key] !== "boolean") throw Error(`agent tools.${key} must be boolean`); selected[key] = tools[key]; }
-    }
-    profile.tools = selected;
-  }
-  if (obj["permissions"] !== undefined) {
-    if (!Array.isArray(obj["permissions"])) throw Error("agent permissions must be an array");
-    profile.permissions = obj["permissions"].map(parsePermissionRule);
-  }
-  if (obj["budget"] !== undefined) {
-    const budget = record(obj["budget"], "agent budget", ["maxTurns", "timeBudgetMs"]);
-    const selected: { maxTurns?: number; timeBudgetMs?: number } = {};
-    for (const key of ["maxTurns", "timeBudgetMs"] as const) {
-      if (budget[key] !== undefined) {
-        if (!Number.isSafeInteger(budget[key]) || Number(budget[key]) < 1) throw Error(`agent budget.${key} must be a positive safe integer`);
-        selected[key] = Number(budget[key]);
-      }
-    }
-    profile.budget = selected;
-  }
-  return profile;
-}
-
-/** A malformed document contributes no partial authority. */
-export function parseAgentProfiles(value: unknown): AgentProfileParse {
-  try {
-    const obj = record(value, "agents document", ["profiles"]);
-    if (!Array.isArray(obj["profiles"])) throw Error("agents document profiles must be an array");
-    const profiles = obj["profiles"].map(parseAgentProfile);
-    if (new Set(profiles.map(profile => profile.name)).size !== profiles.length) throw Error("agents document contains duplicate profile names");
-    return { profiles, diagnostics: [] };
-  } catch (error) { return { profiles: [], diagnostics: [error instanceof Error ? error.message : "Invalid agents document"] }; }
-}
-
-/** Caller supplies low-to-high layers; whole-field replacement stays explainable. */
-export function resolveAgentProfile(name: string, layers: readonly AgentProfileLayer[]): ResolvedAgentProfile | null {
-  let profile: AgentProfile | undefined;
-  const sources: AgentProfileSource[] = [], provenance: Partial<Record<AgentProfileField, AgentProfileSource>> = {};
-  for (const layer of layers) {
-    const matching = layer.profiles.find(item => item.name === name);
-    if (!matching) continue;
-    const source = structuredClone(layer.source);
-    sources.push(source); profile = { ...profile, ...structuredClone(matching) };
-    for (const field of FIELDS) if (matching[field] !== undefined) provenance[field] = structuredClone(source);
-  }
-  return profile ? { profile, sources, provenance } : null;
-}
-
-export function agentProfileNames(layers: readonly AgentProfileLayer[]): string[] {
-  return [...new Set(layers.flatMap(layer => layer.profiles.map(profile => profile.name)))].sort();
-}

package/src/core/attachment-input.ts

@@ -1,17 +0,0 @@
-/** Only an entire list of image paths is a drop; ordinary prose and shell syntax remain literal. */
-export function droppedImagePaths(text: string): string[] | null {
-  const paths: string[] = [];
-  let token = "", quote = "", escaped = false;
-  for (const char of text.trim()) {
-    if (escaped) { token += char; escaped = false; }
-    else if (char === "\\" && quote !== "'") escaped = true;
-    else if (quote) { if (char === quote) quote = ""; else token += char; }
-    else if (char === "'" || char === '"') quote = char;
-    else if (/\s/.test(char)) { if (token) { paths.push(token); token = ""; } }
-    else token += char;
-  }
-  if (escaped || quote) return null;
-  if (token) paths.push(token);
-  return paths.length > 0 && paths.every(path => !/[\x00-\x1f]/.test(path) && !path.startsWith("@") &&
-    /\.(png|jpe?g|gif|webp|bmp)$/i.test(path) && !/[;$|<>`]/.test(path)) ? paths : null;
-}

package/src/core/blind-checks.ts

@@ -1,72 +0,0 @@
-/**
- * Blind checks: the independent rung of the evidence ladder (S.1).
- *
- * A check the model can see is a check the model can work toward. Blind
- * checks live outside the workspace, never enter a projection, and run only
- * after the goal ends, against a clone of the final result. Because the log
- * is complete, whether the model ever touched them is a mechanical question
- * over its own tool inputs and read receipts -- not a promise.
- */
-import type { LogEvent } from "./events.ts";
-
-/**
- * Assumed, not measured: a hidden test suite of a handful of cases plus their
- * fixtures. Bounded so freezing a blind directory into the session context
- * cannot grow without limit.
- */
-export const BLIND_CHECK_LIMIT = 8;
-export const BLIND_FILE_LIMIT = 64;
-export const BLIND_BYTES_LIMIT = 8 * 1024 * 1024;
-
-export type BlindCheck = { id: string; description: string; command: string };
-export type BlindManifest = { version: 1; checks: BlindCheck[] };
-/**
- * What a session freezes: where the checks live (the real path, plus every
- * spelling of it the user gave, since a symlinked temp directory is a
- * different string), the manifest, and every file's digest.
- */
-export type BlindChecks = { dir: string; aliases: readonly string[]; manifest: BlindManifest; files: Record<string, string> };
-
-const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const label = (value: unknown, max: number): value is string => typeof value === "string" && value.trim().length > 0 && value.length <= max;
-
-export function parseBlindManifest(value: unknown): BlindManifest {
-  if (!record(value) || value["version"] !== 1 || Object.keys(value).some(key => key !== "version" && key !== "checks")) throw Error("blind.json must be {version: 1, checks: [...]}");
-  const checks = value["checks"];
-  if (!Array.isArray(checks) || checks.length < 1 || checks.length > BLIND_CHECK_LIMIT) throw Error(`blind.json needs 1..${BLIND_CHECK_LIMIT} checks`);
-  const parsed = checks.map((check: unknown, index): BlindCheck => {
-    if (!record(check) || Object.keys(check).some(key => !["id", "description", "command"].includes(key))) throw Error(`blind check ${index + 1}: only id, description and command are allowed`);
-    const { id, description, command } = check;
-    if (!label(id, 80) || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/.test(id)) throw Error(`blind check ${index + 1}: invalid id`);
-    if (!label(description, 300) || !label(command, 500)) throw Error(`blind check ${index + 1}: description and command are required`);
-    return { id, description, command };
-  });
-  if (new Set(parsed.map(check => check.id)).size !== parsed.length) throw Error("blind.json has duplicate check ids");
-  return { version: 1, checks: parsed };
-}
-
-export function isBlindChecks(value: unknown): value is BlindChecks {
-  if (!record(value) || typeof value["dir"] !== "string" || !record(value["files"]) ||
-      !Array.isArray(value["aliases"]) || !value["aliases"].every(alias => typeof alias === "string" && alias.length > 0)) return false;
-  try { parseBlindManifest(value["manifest"]); } catch { return false; }
-  return Object.values(value["files"]).every(sha => typeof sha === "string" && /^[a-f0-9]{64}$/.test(sha));
-}
-
-/**
- * Whether the model could have seen the blind checks: a tool input naming the
- * blind directory, or a read whose content digest matches a blind file. This
- * covers what the harness records for every tool; output a command produced
- * without naming the path (a recursive search, say) is not matched, and the
- * report says only what was found.
- */
-export function blindExposure(events: readonly LogEvent[], blind: BlindChecks): string | null {
-  const digests = new Set(Object.values(blind.files)), paths = [blind.dir, ...blind.aliases];
-  for (const event of events) {
-    if (event.t === "assistant") for (const block of event.blocks) {
-      const input = block.type === "tool_use" ? JSON.stringify(block.input) : "";
-      if (block.type === "tool_use" && paths.some(path => input.includes(path))) return `tool call ${block.call_id} names the blind check directory`;
-    }
-    if (event.t === "tool_result" && event.effect?.kind === "read" && digests.has(event.effect.sha256)) return `tool result ${event.id} read a blind check file`;
-  }
-  return null;
-}

package/src/core/boundary.ts

@@ -1,174 +0,0 @@
-/**
- * Explicit fixed-segment policy (decisions D1, D4, D5; new default in N.8).
- *
- * Pure. Given a token count and where the loop currently stands, decide whether
- * to close the segment.
- *
- * Three rules, each with a reason:
- *
- *   ONLY AT A TURN BOUNDARY (D5). A cut between a tool_use and its tool_result
- *   would produce an unpairable request. The gap between trigger and hard limit is
- *   the headroom that makes waiting for the boundary safe.
- *
- *   THE MODEL MAY ADVANCE A CUT BUT NEVER DEFER ONE (D4). A checkpoint request at
- *   a clean semantic boundary is usually better than an arbitrary threshold, so it
- *   is honoured -- but the hard limit is checked first and cannot be overridden.
- *
- *   ABSOLUTE TOKENS, NOT A PERCENTAGE OF THE WINDOW. Cost and quality both argue
- *   for tens of thousands of tokens, and neither argument scales with whatever
- *   window the model happens to advertise.
- *
- * On the defaults below: the optimum from the cost model is L - H = 5*sqrt(H*d),
- * where H is handoff size and d is per-turn growth. H was originally *assumed* to
- * be ~10k, which put the optimum near 37k and the thresholds at 60k/80k.
- * The original single-segment measurement (prev=null) yielded 366 to 3201
- * tokens, 1.6-7.6% of L. It did not measure accumulation across boundaries.
- * D20 adds bounded carried state and continuous-history measurements; full
- * derivation state still grows with distinct facts. The old local cost optimum
- * is a workload diagnostic, not proof of a globally optimal threshold.
- *
- * The defaults are 30k/40k rather than 15k/25k because the cost model prices only
- * bytes. Two things it does not price argue for longer segments: the re-read a new
- * segment usually needs before it can act (the digest check on file_anchors), and
- * the fact that too-short segments break stateful work -- the documented failure
- * mode of fresh-context loops is that extended debugging loses context that was
- * load-bearing. 30k/40k is within 15% of the cost optimum for every re-read cost
- * from 0 to 24k tokens per boundary, which 60k/80k is not.
- */
-
-import type { CutReason } from "./events.ts";
-
-export interface BoundaryConfig {
-  /** Start looking for a turn boundary at or above this count. */
-  triggerTokens: number;
-  /** Cut at the next turn boundary regardless. Must exceed triggerTokens. */
-  hardTokens: number;
-  /**
-   * How much of the context a node must have produced itself before cutting is
-   * worth it.
-   *
-   * Every node starts with tokens it did not create: the frozen prefix plus,
-   * after the first cut, the handoff. Without this floor, a trigger set below
-   * that inherited weight makes the first turn of every node cut -- a real run
-   * produced 36 nodes for a five-file task, spending its budget on handoffs.
-   *
-   * The value follows the crossover: a handoff only pays for itself once the
-   * node's own history exceeds it. Measured handoffs ran 366-3201 tokens, so
-   * the default sits above the top of that range.
-   *
-   * This is also the floor for a model-requested checkpoint. A separate knob
-   * for that case would be the same idea written twice: a checkpoint on a node
-   * that has produced nothing costs a handoff write and discards the node's
-   * cache for no gain, which is exactly what this floor exists to prevent.
-   */
-  minNodeWorkTokens: number;
-}
-
-export const DEFAULT_BOUNDARY: BoundaryConfig = {
-  triggerTokens: 30_000,
-  hardTokens: 40_000,
-  minNodeWorkTokens: 5_000,
-};
-
-export interface BoundaryInput {
-  tokens: number;
-  /**
-   * Tokens the node did not produce: the frozen prefix, plus the rendered
-   * handoff for any node after the first. Cutting cannot reduce these, so they
-   * do not count toward the node having earned a boundary.
-   */
-  inheritedTokens?: number;
-  /** True only between a completed assistant/tool exchange and the next request. */
-  atTurnBoundary: boolean;
-  /** Set when the model called the checkpoint tool during this turn. */
-  checkpointRequested?: boolean;
-  config?: Partial<BoundaryConfig>;
-}
-
-export type BoundaryDecision =
-  | { cut: true; reason: CutReason }
-  | {
-      cut: false;
-      reason:
-        | "below_trigger"
-        | "awaiting_turn_boundary"
-        | "below_min_node_work"
-        /**
-         * The inherited floor alone is at or past the hard limit, so a cut
-         * would hand the next node a context it cannot work in either. The
-         * thresholds need widening or the frozen prefix shrinking; cutting
-         * would only thrash.
-         */
-        | "inherited_floor_exceeds_limit";
-      /**
-       * True when the count is already past the hard limit and a cut is not yet
-       * possible -- i.e. a single turn consumed more than the headroom. The caller
-       * should surface this: the thresholds need retuning, or one tool returned an
-       * output large enough to need its own handling.
-       */
-      overrun: boolean;
-    };
-
-export function shouldCut(input: BoundaryInput): BoundaryDecision {
-  const cfg = { ...DEFAULT_BOUNDARY, ...input.config };
-  if (cfg.hardTokens <= cfg.triggerTokens) {
-    throw new RangeError(
-      `boundary: hardTokens (${cfg.hardTokens}) must exceed triggerTokens (${cfg.triggerTokens}); ` +
-        "the difference is the headroom needed to reach a turn boundary",
-    );
-  }
-  // The mirror of thrashing, and just as silent: a work floor at or above the
-  // trigger means the trigger can never be acted on, so the session grows
-  // without bound and nothing says why.
-  if (cfg.minNodeWorkTokens >= cfg.triggerTokens) {
-    throw new RangeError(
-      `boundary: minNodeWorkTokens (${cfg.minNodeWorkTokens}) must be below triggerTokens ` +
-        `(${cfg.triggerTokens}); otherwise no node can ever reach a boundary`,
-    );
-  }
-
-  const { tokens, atTurnBoundary, checkpointRequested = false, inheritedTokens = 0 } = input;
-  const ownWork = Math.max(0, tokens - inheritedTokens);
-
-  if (!atTurnBoundary) {
-    return {
-      cut: false,
-      reason: "awaiting_turn_boundary",
-      overrun: tokens >= cfg.hardTokens,
-    };
-  }
-
-  // Is there any reason to consider a boundary at all?
-  const wouldCut =
-    tokens >= cfg.hardTokens || checkpointRequested || tokens >= cfg.triggerTokens;
-  if (!wouldCut) return { cut: false, reason: "below_trigger", overrun: false };
-
-  // There is -- but a node that has produced almost nothing cannot be helped
-  // by one: the next node inherits the same floor and lands in the same place.
-  if (ownWork < cfg.minNodeWorkTokens) {
-    if (inheritedTokens >= cfg.hardTokens) {
-      return { cut: false, reason: "inherited_floor_exceeds_limit", overrun: true };
-    }
-    return { cut: false, reason: "below_min_node_work", overrun: tokens >= cfg.hardTokens };
-  }
-
-  // Worth cutting. The hard limit is checked first so the model cannot defer
-  // it by asking for a checkpoint.
-  if (tokens >= cfg.hardTokens) return { cut: true, reason: "hard_limit" };
-  if (checkpointRequested) return { cut: true, reason: "model_checkpoint" };
-  return { cut: true, reason: "trigger" };
-}
-
-/**
- * Stop-and-ask rule (D9 / M.4). New read observations or fresh successful checks
- * reset the counter. Exact repetitions, annotations alone and gate regressions
- * do not. This detects inactivity; it cannot judge relevance to the user's goal.
- */
-export const DEFAULT_MAX_SEGMENTS_WITHOUT_PROGRESS = 3;
-
-export function shouldStopAndAsk(
-  segmentsWithoutProgress: number,
-  max = DEFAULT_MAX_SEGMENTS_WITHOUT_PROGRESS,
-): boolean {
-  return segmentsWithoutProgress >= max;
-}