@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/branch-receipt.ts

@@ -1,26 +0,0 @@
-/** O.9: references to facts, never a child's self-assessed completion. */
-import type { LogEvent, NodeRef } from "./events.ts";
-import type { Handoff } from "./handoff.ts";
-import type { ExecutionOutcome } from "./outcome.ts";
-import { deriveRequestState } from "./request-state.ts";
-
-export function deriveBranchReceipt(input: {
-  source: NodeRef; outcome: ExecutionOutcome; handoff: Handoff;
-  nodes: readonly { node: number; events: readonly LogEvent[] }[];
-}) {
-  const entries = input.nodes.flatMap(part => part.events.map(event => ({ node: part.node, event })));
-  const commands = entries.flatMap(({ node, event }) => event.t === "tool_result" && event.effect?.kind === "command"
-    ? [{ node, event: event.id, exit: event.effect.exit }] : []);
-  const changes = entries.flatMap(({ node, event }) => event.t === "tool_result" && event.effect?.kind === "edit"
-    ? [{ node, event: event.id, path: event.effect.path }] : []);
-  const observations = entries.flatMap(({ node, event }) => event.t === "tool_result" ? [{ node, event: event.id }] : []);
-  const unfinished = (input.handoff.state.work_items ?? []).filter(item => item.status === "active" || item.status === "blocked")
-    .map(item => ({ work_id: item.id, status: item.status, next_action: item.next_action ?? null }));
-  return { version: 1, source: input.source, execution: input.outcome,
-    // S.1: the child's request ledger, the same verdict any request view shows.
-    verification: deriveRequestState(input.nodes)?.status ?? "not_applicable",
-    task_acceptance: "not_assessed", commands, changes, observations, unfinished,
-    ...(input.handoff.processes?.length ? { processes: input.handoff.processes } : {}),
-    unresolved_branches: input.handoff.branches.filter(b => b.resolution === null).map(b => b.node),
-  };
-}

package/src/core/catalog-merge.ts

@@ -1,19 +0,0 @@
-import { modelKey } from "./session-position.ts";
-
-/** D13: identity and selection are independent of provider SDKs and source order. */
-export function mergeCatalogs<T extends { provider: string; id: string }>(...layers: readonly (readonly T[])[]): T[] {
-  const models = new Map<string, T>();
-  for (const layer of layers) for (const model of layer) models.set(modelKey(model), model);
-  return [...models.values()];
-}
-
-/** Provider-local allow/deny patterns use literal characters plus '*' and '?'. */
-export function matchesModelPattern(id: string, pattern: string): boolean {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "u").test(id);
-}
-
-export function modelEnabled(id: string, allow?: readonly string[], deny?: readonly string[]): boolean {
-  return (allow === undefined || allow.some(pattern => matchesModelPattern(id, pattern)))
-    && !(deny?.some(pattern => matchesModelPattern(id, pattern)) ?? false);
-}

package/src/core/checkpoints.ts

@@ -1,85 +0,0 @@
-/** P.3: recovery describes observed file transitions, never a complete disk image. */
-export type FileVersion = { sha256: string; mode: number } | null;
-export type FileChange = { before: FileVersion; after: FileVersion };
-export type FileChanges = Record<string, FileChange>;
-export interface CheckpointEvent {
-  t: "checkpoint";
-  id: string;
-  at: string;
-  operation: string;
-  source: "edit" | "git" | "restore";
-  phase: "prepared" | "applied" | "unavailable";
-  changes: FileChanges;
-  tree?: string;
-  reason?: string;
-}
-export interface WorkspaceObservationEvent {
-  t: "workspace_observation";
-  id: string;
-  at: string;
-  /** P.3: this scope excludes ignored/build output and is not a backup. */
-  fingerprint?: string;
-  scope: "source-v1";
-  changed: boolean;
-  reason?: string;
-  /** The workspace as a goal request began: the state a counter-check must revert to exactly. */
-  baseline?: true;
-}
-
-export function sameVersion(a: FileVersion, b: FileVersion): boolean {
-  return a === null || b === null ? a === b : a.sha256 === b.sha256 && a.mode === b.mode;
-}
-export function changedPaths(changes: FileChanges): string[] {
-  return Object.keys(changes).filter(path => !sameVersion(changes[path]!.before, changes[path]!.after)).sort();
-}
-
-/** Undo the abandoned suffix then replay the selected suffix, touching only their paths. */
-export function planFileTransition(from: readonly CheckpointEvent[], to: readonly CheckpointEvent[]): FileChanges {
-  const left = from.filter(event => event.phase === "applied");
-  const right = to.filter(event => event.phase === "applied");
-  let common = 0;
-  while (common < left.length && common < right.length && left[common]!.id === right[common]!.id) common++;
-  const changes: FileChanges = Object.create(null) as FileChanges;
-  const apply = (path: string, before: FileVersion, after: FileVersion) => {
-    const existing = changes[path];
-    if (existing && !sameVersion(existing.after, before)) throw new Error(`discontinuous file history: ${path}; inspect intervening external edits`);
-    changes[path] = { before: existing ? existing.before : before, after };
-  };
-  for (const event of left.slice(common).reverse()) for (const path of changedPaths(event.changes)) {
-    const change = event.changes[path]!;
-    apply(path, change.after, change.before);
-  }
-  for (const event of right.slice(common)) for (const path of changedPaths(event.changes)) {
-    const change = event.changes[path]!;
-    apply(path, change.before, change.after);
-  }
-  return Object.fromEntries(changedPaths(changes).map(path => [path, changes[path]!])) as FileChanges;
-}
-
-export function validFileChanges(value: unknown): value is FileChanges {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-  const version = (v: unknown): boolean => v === null || typeof v === "object" && !Array.isArray(v) &&
-    typeof (v as Record<string, unknown>)["sha256"] === "string" && /^[a-f0-9]{64}$/.test(String((v as Record<string, unknown>)["sha256"])) &&
-    Number.isInteger((v as Record<string, unknown>)["mode"]) && Number((v as Record<string, unknown>)["mode"]) >= 0 && Number((v as Record<string, unknown>)["mode"]) <= 0o777;
-  return Object.entries(value).every(([path, change]: [string, unknown]) => path.length > 0 && typeof change === "object" && change !== null &&
-    version((change as Record<string, unknown>)["before"]) && version((change as Record<string, unknown>)["after"]));
-}
-
-/**
- * The one test for "this event changed the workspace": a real edit, an
- * applied checkpoint that moved a file, or an observation that saw a change.
- * Acceptance, request evidence and environment validity all ask exactly this
- * question and must not answer it three different ways (S.1).
- */
-export function workspaceChanged(event: import("./events.ts").LogEvent): boolean {
-  return event.t === "tool_result" && event.effect?.kind === "edit" && event.effect.sha256_before !== event.effect.sha256_after ||
-    event.t === "checkpoint" && event.phase === "applied" && changedPaths(event.changes).length > 0 ||
-    event.t === "workspace_observation" && event.changed;
-}
-
-/** The transition back: every path's before and after swapped. Applying it undoes `changes`. */
-export function invertFileChanges(changes: FileChanges): FileChanges {
-  const inverted: FileChanges = Object.create(null) as FileChanges;
-  for (const [path, change] of Object.entries(changes)) inverted[path] = { before: change.after, after: change.before };
-  return inverted;
-}

package/src/core/churn.ts

@@ -1,61 +0,0 @@
-/**
- * Two loops the repetition check cannot see.
- *
- * `continuationGuidance` flags an action/observation cycle that repeats
- * exactly. A real rut rarely does: a rerun test prints a new timestamp, a
- * build a new temp path, and every observation digest differs -- so neither
- * that check nor D9 stall counting fires while the model retries one idea.
- * These two keys come from facts the harness recorded itself, not from
- * comparing output: the exact command with its exit code, and the path of
- * each successful edit (LangChain's harness write-up uses the same edit
- * count; opencode's doom_loop misses exactly these near-repeats).
- *
- * Advice only, once per request: nothing is blocked and the stop rules are
- * unchanged.
- */
-import type { GuidanceEvent, LogEvent } from "./events.ts";
-import { currentRequestEvents } from "./request-state.ts";
-
-/**
- * Assumed, not measured. Three failures leaves room for "change, retry,
- * still failing" -- normal debugging -- before calling it a loop; eight edits
- * of one file sits above a typical refactor. Too low costs one extra notice;
- * too high falls back to today's behaviour.
- */
-export const CHURN_FAILURES = 3;
-export const CHURN_EDITS = 8;
-
-export function churnReview(events: readonly LogEvent[]): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
-  const current = currentRequestEvents(events);
-  if (current.some((event) => event.t === "guidance" && event.reason === "churn")) return null;
-  const failures = new Map<string, { count: number; last: string }>();
-  const edits = new Map<string, { count: number; last: string }>();
-  for (const event of current) {
-    if (event.t !== "tool_result" || event.effect === undefined) continue;
-    const effect = event.effect;
-    if (effect.kind === "command") {
-      // R5 handles structured failures with version/change premises; keep this path for legacy logs.
-      if (event.diagnostic?.execution !== undefined) continue;
-      const key = effect.cmd.trim();
-      if (effect.exit === 0) { failures.delete(key); continue; }
-      const seen = { count: (failures.get(key)?.count ?? 0) + 1, last: event.id };
-      failures.set(key, seen);
-      if (seen.count >= CHURN_FAILURES) return {
-        reason: "churn", sources: [event.id],
-        text: `Harness: \`${key}\` failed ${seen.count} times in this request without succeeding. ` +
-          "Retrying the same approach is unlikely to change the result. Read the end of the last failure, " +
-          "state the cause you believe it has, and test that belief with a different step before running it again.",
-      };
-    } else if (effect.kind === "edit") {
-      const seen = { count: (edits.get(effect.path)?.count ?? 0) + 1, last: event.id };
-      edits.set(effect.path, seen);
-      if (seen.count >= CHURN_EDITS) return {
-        reason: "churn", sources: [event.id],
-        text: `Harness: ${effect.path} was edited ${seen.count} times in this request. ` +
-          "Repeated small edits usually mean the underlying cause is not yet understood. Re-read the file and the " +
-          "failing evidence, then make one change that addresses the cause.",
-      };
-    }
-  }
-  return null;
-}

package/src/core/command-artifacts.ts

@@ -1,94 +0,0 @@
-/** R8 / D8 / D11: an explicit observation scope is not a claim of build causality. */
-import type { ArtifactRef } from "./events.ts";
-import { isObservationArtifact } from "./observation-view.ts";
-
-// Assumed observation budgets keep a model-supplied plan bounded before execution.
-export const MAX_COMMAND_ARTIFACTS = 16;
-export const MAX_ARTIFACT_PLAN_BYTES = 16 * 1024;
-export const MAX_COMMAND_ARTIFACT_BYTES = 512 * 1024 * 1024;
-export const COMMAND_ARTIFACT_SCOPE = "source-v1-minus-artifacts";
-export type CommandArtifactPlan = { paths: string[]; output_roots: string[] };
-export type ArtifactFileIdentity = { device: string; inode: string; mtime_ns: string; ctime_ns: string; mode: number };
-export type ArtifactFile = { state: "observed"; sha256: string; bytes: number; identity: ArtifactFileIdentity } |
-  { state: "missing" | "unsafe" | "changed" | "unknown"; reason: string };
-export type ArtifactChange = "created" | "modified" | "unchanged" | "unknown";
-export type CommandArtifactOutput = { path: string; before: ArtifactFile; after: ArtifactFile; change: ArtifactChange };
-export type CommandArtifactReceipt = {
-  kind: "command_artifacts"; version: 1;
-  state: "pending" | "observed" | "changed" | "unknown";
-  plan: CommandArtifactPlan;
-  source: { host: string; workspace: string; cwd: string; runtime: string };
-  command: string; exit: number | null;
-  started_at: string; observed_at: string | null;
-  inputs: { scope: typeof COMMAND_ARTIFACT_SCOPE; exclusions: string[]; before: string | null; after: string | null };
-  outputs: CommandArtifactOutput[];
-  reasons: string[];
-  manifest?: ArtifactRef;
-};
-
-const object = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const digest = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-const covers = (root: string, path: string) => root === path || path.startsWith(root + "/");
-export function validArtifactPath(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).length <= 4096 &&
-    !/[\x00-\x1f\x7f\\:]/.test(value) && value.split("/").every(part => part !== "" && part !== "." && part !== ".." && part !== ".git" && part !== ".xeno");
-}
-export function parseCommandArtifactPlan(value: unknown): CommandArtifactPlan {
-  if (!object(value) || Object.keys(value).some(key => !["paths", "output_roots"].includes(key))) throw new Error("artifacts needs paths and optional output_roots only");
-  const paths = value["paths"], roots = value["output_roots"] ?? paths;
-  for (const list of [paths, roots]) {
-    if (!Array.isArray(list) || list.length < 1 || list.length > MAX_COMMAND_ARTIFACTS || !list.every(validArtifactPath) || new Set(list).size !== list.length)
-      throw new Error("artifacts needs 1..16 unique workspace-relative file paths; no traversal or protected paths");
-  }
-  const plan = { paths: [...paths as string[]].sort(), output_roots: [...roots as string[]].sort() };
-  if (new TextEncoder().encode(JSON.stringify(plan)).length > MAX_ARTIFACT_PLAN_BYTES) throw new Error("artifact plan exceeds 16 KiB");
-  if (plan.paths.some((path, i) => plan.paths.some((other, j) => i !== j && covers(path, other)))) throw new Error("artifact file paths cannot contain one another");
-  if (plan.output_roots.some((root, i) => !plan.paths.some(path => covers(root, path)) || plan.output_roots.some((other, j) => i !== j && covers(root, other))) ||
-    plan.paths.some(path => !plan.output_roots.some(root => covers(root, path)))) throw new Error("output_roots must be nonoverlapping and cover exactly the requested artifact paths");
-  return plan;
-}
-export function artifactChange(before: ArtifactFile, after: ArtifactFile): ArtifactChange {
-  if (after.state !== "observed") return "unknown";
-  if (before.state === "missing") return "created";
-  if (before.state !== "observed") return "unknown";
-  return before.sha256 === after.sha256 && before.bytes === after.bytes && sameArtifactIdentity(before.identity, after.identity) ? "unchanged" : "modified";
-}
-export function sameArtifactIdentity(a: ArtifactFileIdentity, b: ArtifactFileIdentity): boolean {
-  return a.device === b.device && a.inode === b.inode && a.mtime_ns === b.mtime_ns && a.ctime_ns === b.ctime_ns && a.mode === b.mode;
-}
-export function commandArtifactState(receipt: Pick<CommandArtifactReceipt, "exit" | "inputs" | "outputs" | "reasons">): CommandArtifactReceipt["state"] {
-  if (receipt.exit === null) return "pending";
-  if (receipt.inputs.before !== null && receipt.inputs.after !== null && receipt.inputs.before !== receipt.inputs.after ||
-    receipt.outputs.some(output => output.after.state === "changed")) return "changed";
-  if (receipt.exit !== 0 || receipt.reasons.length > 0 || receipt.inputs.before === null || receipt.inputs.after === null ||
-    receipt.outputs.length === 0 || receipt.outputs.some(output => output.after.state !== "observed")) return "unknown";
-  return "observed";
-}
-export function isArtifactFile(value: unknown): value is ArtifactFile {
-  if (!object(value)) return false;
-  if (value["state"] !== "observed") return ["missing", "unsafe", "changed", "unknown"].includes(String(value["state"])) && typeof value["reason"] === "string" && value["reason"].length > 0;
-  const id = value["identity"];
-  return digest(value["sha256"]) && Number.isSafeInteger(value["bytes"]) && Number(value["bytes"]) >= 0 && Number(value["bytes"]) <= MAX_COMMAND_ARTIFACT_BYTES &&
-    object(id) && ["device", "inode", "mtime_ns", "ctime_ns"].every(key => typeof id[key] === "string" && /^-?\d+$/.test(id[key])) &&
-    Number.isInteger(id["mode"]) && Number(id["mode"]) >= 0 && Number(id["mode"]) <= 0o777;
-}
-export function isCommandArtifactReceipt(value: unknown): value is CommandArtifactReceipt {
-  if (!object(value) || value["kind"] !== "command_artifacts" || value["version"] !== 1 || typeof value["command"] !== "string" || !value["command"].trim() ||
-    typeof value["started_at"] !== "string" || (value["exit"] !== null && !Number.isInteger(value["exit"]))) return false;
-  let plan: CommandArtifactPlan;
-  try { plan = parseCommandArtifactPlan(value["plan"]); } catch { return false; }
-  if (!object(value["plan"]) || JSON.stringify(value["plan"]["paths"]) !== JSON.stringify(plan.paths) ||
-    JSON.stringify(value["plan"]["output_roots"]) !== JSON.stringify(plan.output_roots)) return false;
-  const source = value["source"], inputs = value["inputs"], outputs = value["outputs"], reasons = value["reasons"];
-  if (!object(source) || !["host", "workspace", "cwd", "runtime"].every(key => typeof source[key] === "string" && source[key] !== "") ||
-    !object(inputs) || inputs["scope"] !== COMMAND_ARTIFACT_SCOPE || !Array.isArray(inputs["exclusions"]) ||
-    !inputs["exclusions"].every(path => typeof path === "string" && path.length > 0) || new Set(inputs["exclusions"]).size !== inputs["exclusions"].length ||
-    !plan.output_roots.every(root => (inputs["exclusions"] as unknown[]).includes(root)) ||
-    !["before", "after"].every(key => inputs[key] === null || digest(inputs[key])) || !Array.isArray(outputs) ||
-    !Array.isArray(reasons) || !reasons.every(reason => typeof reason === "string" && reason.length > 0)) return false;
-  if (value["exit"] === null) return value["state"] === "pending" && value["observed_at"] === null && inputs["after"] === null && outputs.length === 0 && value["manifest"] === undefined;
-  if (typeof value["observed_at"] !== "string" || !value["observed_at"] || outputs.length !== plan.paths.length || !outputs.every((item, index) =>
-    object(item) && item["path"] === plan.paths[index] && isArtifactFile(item["before"]) && isArtifactFile(item["after"]) && item["change"] === artifactChange(item["before"], item["after"]))) return false;
-  if (value["manifest"] !== undefined && !isObservationArtifact(value["manifest"])) return false;
-  return value["state"] === commandArtifactState(value as CommandArtifactReceipt) && (value["state"] !== "observed" || isObservationArtifact(value["manifest"]));
-}

package/src/core/command-contract.ts

@@ -1,151 +0,0 @@
-/** R1 / D11: all command entrances agree on invocation and observed termination. */
-import { executionOutcome } from "./outcome.ts";
-import type { ToolDiagnostic } from "./tool-contract.ts";
-
-/** Operational grace, not a measured optimum: ignored SIGTERM cannot defeat cancellation. */
-export const COMMAND_TERMINATION_GRACE_MS = 200;
-
-/** A fresh login Bash per command; interactive stdin does not change shell success semantics. */
-export function commandArgv(command: string): string[] {
-  return ["bash", "-o", "pipefail", "-lc", command];
-}
-
-/**
- * Preserve inherited values except documented noninteractive defaults; never mutate the host.
- *
- * `appendPath` is xeno's own tool directory (store/tool-binaries.ts). It goes
- * last, so anything the user installed wins and xeno only fills a gap.
- */
-export function commandEnvironment(base: Readonly<Record<string, string | undefined>>, appendPath?: string): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const [key, value] of Object.entries(base)) if (value !== undefined) env[key] = value;
-  if (appendPath !== undefined && appendPath.length > 0 && !(env["PATH"] ?? "").split(":").includes(appendPath)) {
-    env["PATH"] = env["PATH"] ? `${env["PATH"]}:${appendPath}` : appendPath;
-  }
-  Object.assign(env, {
-    TERM: "dumb", PAGER: "cat", GIT_PAGER: "cat", NO_COLOR: "1",
-    GIT_TERMINAL_PROMPT: "0", DEBIAN_FRONTEND: "noninteractive",
-  });
-  if (env["LANG"] === undefined || env["LANG"] === "") env["LANG"] = "C.UTF-8";
-  return env;
-}
-
-/**
- * Codex's `max_output_tokens` as an inline byte budget for one call. It can
- * only lower the session ceiling: full output is still captured and
- * recoverable, so this shapes the preview, never the receipt.
- *
- * Assumed, not measured: 4 bytes per token rounds the ASCII estimate in
- * tokens.ts (about 3.6) up, so the model never gets less than it asked for.
- * The 1 KiB floor keeps room for the header and recovery hint (about 300
- * bytes); below it a preview shows almost no output and forces a re-read.
- */
-export const OUTPUT_BYTES_PER_TOKEN = 4;
-export const MIN_OUTPUT_BYTES = 1_024;
-export function outputBytesForTokens(tokens: unknown, ceiling: number): number {
-  if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens <= 0) return ceiling;
-  return Math.min(ceiling, Math.max(MIN_OUTPUT_BYTES, Math.floor(tokens) * OUTPUT_BYTES_PER_TOKEN));
-}
-
-/** Model seconds and host milliseconds meet once; a yield is never a command deadline. */
-export function commandTimeout(requestedSeconds: number | undefined, defaultMs: number, maximumMs = defaultMs): number {
-  return Math.min(requestedSeconds === undefined ? defaultMs : requestedSeconds * 1000, maximumMs);
-}
-
-/**
- * Programs whose exit 1 is an answer rather than a fault (POSIX: grep's 1 is
- * "no match" and >1 an error; diff and cmp use 1 for "differ"; test for
- * false). Reporting them as failures tells the model to inspect and retry an
- * answer it already holds -- the same reading Claude Code's command semantics
- * give these programs.
- */
-const NEGATIVE_ANSWERS: Readonly<Record<string, string>> = {
-  grep: "no match", egrep: "no match", fgrep: "no match", rg: "no match",
-  diff: "files differ", cmp: "files differ", test: "condition false", "[": "condition false",
-};
-
-/**
- * The final simple command of `command` and the separator before it, or
- * null when this scanner cannot read the command with certainty --
- * unbalanced quotes, subshells, compound statements, substitutions or a
- * background `&`. Only top-level `;`, newline, `&&`, `||` and `|` split.
- */
-function finalStage(command: string): { separator: string; words: string[] } | null {
-  let quote: "'" | "\"" | null = null, start = 0, separator = "";
-  for (let i = 0; i < command.length; i++) {
-    const c = command[i]!;
-    if (quote !== null) {
-      if (c === "\\" && quote === "\"") i++;
-      else if (c === quote) quote = null;
-      continue;
-    }
-    if (c === "\\") { i++; continue; }
-    if (c === "'" || c === "\"") { quote = c; continue; }
-    if (c === "`" || c === "(" || c === ")" || c === "{" || c === "}" || (c === "$" && command[i + 1] === "(")) return null;
-    const two = command.slice(i, i + 2);
-    if (two === "&&" || two === "||") { separator = two; start = i + 2; i++; continue; }
-    if (c === ";" || c === "\n" || c === "|") { separator = c; start = i + 1; continue; }
-    if (c === "&" && command[i + 1] !== ">" && command[i - 1] !== ">") return null;
-  }
-  if (quote !== null) return null;
-  return { separator, words: command.slice(start).trim().split(/\s+/).filter(word => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) };
-}
-
-const programName = (words: readonly string[]) => (words[0] ?? "").replace(/^.*\//, "");
-
-/**
- * What exit 1 of the command's final simple command means, or null.
- *
- * Only the last segment after a top-level `;`, newline, `||` or `|` is read.
- * After `&&` the 1 may come from the command that short-circuited, so it is
- * not classified. Under pipefail an earlier pipeline stage can also set the
- * status; the exit is kept in the receipt either way, and the label states
- * the program's meaning rather than claiming success. Anything this scanner
- * cannot read with certainty -- unbalanced quotes, subshells, compound
- * statements, substitutions -- yields null.
- */
-export function negativeAnswer(command: string, exit: number): string | null {
-  if (exit !== 1) return null;
-  const stage = finalStage(command);
-  if (stage === null || stage.separator === "&&") return null;
-  const program = programName(stage.words);
-  if (program === "git") return stage.words[1] === "grep" ? "no match" : null;
-  return Object.hasOwn(NEGATIVE_ANSWERS, program) ? NEGATIVE_ANSWERS[program]! : null;
-}
-
-/**
- * Readers that may stop reading before their input ends (`head -n`, `sed Nq`,
- * `awk '{exit}'`, `grep -m` / `-q`), closing the pipe on the writer before it.
- */
-const EARLY_READERS: ReadonlySet<string> = new Set(["head", "sed", "awk", "gawk", "mawk", "grep", "egrep", "fgrep", "rg"]);
-
-/**
- * What exit 141 means when an early reader ends the pipeline, or null.
- *
- * Measured (pipe-early-close card): under `bash -o pipefail`, `seq 1 1000000
- * | head -1` exits 141 -- pipefail reports the rightmost nonzero stage, here
- * the writer that SIGPIPE killed after head closed its input, while every
- * stage to its right, the final reader included, exited 0. The output the
- * command asked for is complete. Only a final stage joined by a top-level
- * `|` is read: after `;`, `&&` or `||` the 141 is the last command's own.
- */
-export function earlyCloseAnswer(command: string, exit: number): string | null {
-  if (exit !== 141) return null;
-  const stage = finalStage(command);
-  if (stage === null || stage.separator !== "|") return null;
-  const program = programName(stage.words);
-  return EARLY_READERS.has(program) ? `${program} closed the pipe early; the earlier stage's SIGPIPE is not a failure` : null;
-}
-
-/** The program's own meaning of a nonzero exit that is an answer, not a fault. */
-export function commandAnswer(command: string, exit: number): string | null {
-  return negativeAnswer(command, exit) ?? earlyCloseAnswer(command, exit);
-}
-
-/** A trap can exit zero after cancellation: successful exit alone does not erase the stop. */
-export function commandCompletion(exit: number, stopped?: "cancelled" | "timeout", cleanup?: ToolDiagnostic, command?: string) {
-  const answered = exit === 0 || command !== undefined && commandAnswer(command, exit) !== null;
-  return { ok: stopped === undefined && answered && cleanup === undefined,
-    outcome: executionOutcome(stopped ?? (answered && cleanup === undefined ? "tool_completed" : "tool_failed")),
-    ...(cleanup ? { warnings: [cleanup] } : {}) };
-}

package/src/core/completion-action.ts

@@ -1,20 +0,0 @@
-import { assertNever } from "./exhaustive.ts";
-
-/** D19: confirmation follows the selected completion, never the unfinished draft. */
-export function completionAction(kind: "command" | "argument" | "path", key: "enter" | "tab", requiresArgument: boolean): "insert" | "submit" {
-  if (key === "tab") return "insert";
-  switch (kind) {
-    case "command": return requiresArgument ? "insert" : "submit";
-    case "argument": return "submit";
-    case "path": return "insert";
-    default: return assertNever(kind, "completion kind");
-  }
-}
-
-/** Match the parser's exact identity before discoverable prefixes and substrings. */
-export function commandCompletionRank(name: string, query: string): number {
-  const canonical = name.toLowerCase(), typed = query.toLowerCase();
-  if (canonical === typed) return 0;
-  if (canonical.startsWith(typed)) return 1;
-  return typed.length > 1 && canonical.includes(typed) ? 2 : Number.POSITIVE_INFINITY;
-}

package/src/core/completion-review.ts

@@ -1,98 +0,0 @@
-/**
- * A one-time reconciliation when the model ends a request.
- *
- * The model deciding it is done is a claim like any other (D11), and the
- * failure modes that end a Terminal-Bench run early all look like a normal
- * final reply: an edit nobody ran, a question handed back to a user who is
- * not there, or nothing at all. ForgeCode found a programmatic check at this
- * point was its largest single gain and that a prompt instruction alone did
- * not reproduce it. The check here only appends a notice; the model still
- * decides, and a second finish is respected -- an honest blocker must not
- * turn into a loop.
- */
-import type { GuidanceEvent, LogEvent } from "./events.ts";
-import type { AcceptanceState } from "./acceptance.ts";
-import { deriveRequestState, type RequestState } from "./request-state.ts";
-
-/**
- * Wording that hands the task back instead of finishing it. Ported from
- * waner `crates/waner_core/src/turn/premature_stop.rs`, including its window:
- * the first 400 and last 300 characters, where an opening refusal or a
- * closing offer sits. The same words in the middle of a long report are
- * usually a quotation or a description, not a stop.
- */
-const HAND_BACK = [
-  "i can't proceed", "i cannot proceed", "i can't continue", "i cannot continue",
-  "giving up", "stopping here", "unable to complete", "i'm unable to", "i am unable to",
-  "let me know if you", "would you like me to", "do you want me to", "shall i ",
-  "我无法继续", "无法完成", "需要你确认", "请确认是否", "是否需要我", "要不要我",
-];
-
-export function looksLikeHandBack(text: string): boolean {
-  const chars = [...text.trim()];
-  const window = `${chars.slice(0, 400).join("")}\n${chars.slice(Math.max(0, chars.length - 300)).join("")}`.toLowerCase();
-  return HAND_BACK.some((pattern) => window.includes(pattern));
-}
-
-export function completionReview(
-  events: readonly LogEvent[],
-  remainingRequests: number,
-  options?: { strictVerification?: boolean; acceptance?: AcceptanceState },
-): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
-  const state = deriveRequestState([{ node: 0, events }], { strict: options?.strictVerification === true });
-  const decision = state ? requestCompletion(state, remainingRequests, options) : { action: "finish" as const };
-  return decision.action === "continue" ? decision.guidance : null;
-}
-
-export type RequestCompletion = { action: "finish" } |
-  { action: "continue"; guidance: Pick<GuidanceEvent, "reason" | "text" | "sources"> };
-
-/**
- * Q23 / S.1: loop termination reads the same ledger as every request view.
- * A reported blocker does not end the check early: the model's statement is
- * not evidence (D11), and the check still runs only once, so an honest
- * blocker restated at the second finish is respected.
- */
-export function requestCompletion(state: RequestState, remainingRequests: number,
-  options?: { acceptance?: AcceptanceState }): RequestCompletion {
-  const finish = { action: "finish" as const };
-  if (remainingRequests < 1 || state.reviewed) return finish;
-  const final = state.final;
-  if (!final || final.has_tools || state.execution?.reason !== "model_end" && state.execution?.reason !== "unknown") return finish;
-  const text = final.text;
-
-  const gaps: string[] = [];
-  const acceptance = options?.acceptance ?? state.acceptance;
-  const missingCommands = acceptance?.status === "needs_work" ? acceptance.criteria.flatMap(item =>
-    item.kind === "command" && item.status !== "pass" ? [{ id: item.id, command: item.command, status: item.status }] : []) : [];
-  const freshCheck = acceptance ? undefined : state.criteria.find(item => item.kind === "fresh_check");
-  if (state.used_tools && text.length === 0) gaps.push("the final reply is empty");
-  // Strict verification counts only configured gates (O.11); say so, since a successful `cat` would otherwise look like a check.
-  if (freshCheck && freshCheck.status !== "pass") gaps.push(freshCheck.gate_only
-    ? "files were changed but no configured verification gate (a test, typecheck, lint, build or check command) has passed since the last edit; reading or printing files does not count, and a gate counts only when run as plain commands joined by && (trailing output redirects to fixed files are fine); ;, ||, pipes, $() and variables hide it"
-    : "files were changed but no command has succeeded since the last edit");
-  if (acceptance?.status === "needs_work") gaps.push(`declared acceptance criteria need evidence: ${[
-    ...missingCommands.map(item => `${item.id}=${item.status}`),
-    ...(acceptance.targets ?? []).filter(target => target.status !== "ready").map(target => `target ${target.id}=${target.status}`),
-  ].join(", ")}`);
-  if (text.length > 0 && looksLikeHandBack(text) && acceptance?.status !== "awaiting_human")
-    gaps.push("the reply deferred the request; check whether authorized work remains or a specific blocker requires the user");
-  if (gaps.length === 0) return finish;
-  // D11 / O.11: a declared command needs its exact receipt even when the
-  // request has no recorded edit. Compound shell success is not that receipt.
-  const next = missingCommands.length > 0
-    ? "Obtain a fresh successful receipt for each missing command. Run each command exactly as a separate invocation without adding other commands:\n" +
-      missingCommands.map(item => `- ${item.id}: ${JSON.stringify(item.command)}`).join("\n") +
-      "\nIf verification cannot run, report the specific blocker. "
-    : !state.changed
-      ? "Use original sources for research and full inputs for calculations; do not invent command evidence. Finish with the result or the specific blocker. "
-      : "Run the command that verifies the result, or finish with the specific blocker that prevents verification. ";
-  return { action: "continue", guidance: {
-    reason: "completion_review",
-    sources: [state.request.event, final.source.event],
-    text: `Harness completion check: ${gaps.join("; ")}. ` +
-      `Re-read the original request (event ${state.request.event}) and check each requirement against evidence in this session. ` +
-      next + (acceptance?.criteria.some(item => item.kind === "human" && item.status !== "accepted") ? "Required human acceptance remains pending. " : "") +
-      "This check runs once per request.",
-  } };
-}

package/src/core/context-detail.ts

@@ -1,37 +0,0 @@
-/** O.8: a read-only explanation of the same projection that is dispatched. */
-import { projectContext, type ProjectInput } from "./project.ts";
-import { anchoredCount, estimateTokens, type Anchor, type TokenCounter } from "./tokens.ts";
-import { historyItems, HISTORY_SECTIONS } from "./history.ts";
-import { contextLimits, type ContextPolicy } from "./context-policy.ts";
-import type { BoundaryConfig } from "./boundary.ts";
-
-export function contextDetail(input: ProjectInput & {
-  anchor: Anchor | null; counter?: TokenCounter; policy: ContextPolicy;
-  contextWindow: number | undefined; outputReserve: number; boundary?: Partial<BoundaryConfig>;
-}) {
-  const counter = input.counter ?? estimateTokens;
-  const projection = projectContext({ ...input, trace: true });
-  const base = counter.count([], "", []);
-  const system = counter.count([], projection.system, []);
-  const tools = counter.count([], projection.system, projection.tools);
-  const floor = counter.count(projection.messages.slice(0, input.handoff ? 1 : 0), projection.system, projection.tools);
-  const estimated = counter.count(projection.messages, projection.system, projection.tools);
-  const anchored = anchoredCount(projection.messages, projection.system, input.anchor, counter, projection.tools);
-  const sections = input.handoff ? HISTORY_SECTIONS.map(section => {
-    const retained = historyItems(input.handoff!, section).length;
-    const index = input.handoff!.history?.sections[section];
-    return { section, retained, omitted: index?.offset ?? 0, total: index?.total ?? retained,
-      recovery: index && index.offset > 0 ? { node: input.handoff!.history!.source.node, section, offset: 0 } : null };
-  }) : [];
-  return {
-    version: projection.provenance!.version,
-    countKind: counter.kind,
-    components: { framing: base, system: system - base, tools: tools - system, handoff: floor - tools, messages: estimated - floor },
-    estimatedTotal: estimated, used: anchored.tokens,
-    anchorCorrection: anchored.tokens - estimated,
-    measuredThrough: anchored.exactUpTo,
-    limits: contextLimits(input), policy: input.policy,
-    sources: projection.provenance!.messages, omittedEvents: projection.provenance!.omitted,
-    sections, violations: projection.violations,
-  };
-}