@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/edit-plan.ts

@@ -1,200 +0,0 @@
-/**
- * O.3: exact edits remain exact; a loose match is never silent.
- *
- * planEdit is the original single exact replacement and stays as it was.
- * planEdits is what the tool uses: several edits, matched on the view read
- * shows (see text-normalize.ts), with a loose fallback that is reported as
- * such in the result rather than applied quietly.
- */
-import { editDistance, fromView, normalizeLoose, similarity, toLF, toView } from "./text-normalize.ts";
-
-export function lineDiff(before: string, after: string): { diff: string; firstLine: number } {
-  const a = before.split("\n"), b = after.split("\n");
-  let prefix = 0, suffix = 0;
-  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix++;
-  while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - suffix - 1] === b[b.length - suffix - 1]) suffix++;
-  const removed = a.slice(prefix, a.length - suffix), added = b.slice(prefix, b.length - suffix);
-  return { firstLine: prefix + 1,
-    diff: before === after ? "(content unchanged)" : `@@ -${prefix + 1},${removed.length} +${prefix + 1},${added.length} @@\n` +
-      [...removed.map(line => `-${line}`), ...added.map(line => `+${line}`)].join("\n") };
-}
-
-export function planEdit(before: string, oldText: string, newText: string, all: boolean):
-  { ok: true; after: string; replacements: number; diff: string; firstLine: number } |
-  { ok: false; code: "invalid_input" | "not_found" | "ambiguous_edit"; occurrences: number } {
-  if (!oldText) return { ok: false, code: "invalid_input", occurrences: 0 };
-  const occurrences = before.split(oldText).length - 1;
-  if (occurrences === 0) return { ok: false, code: "not_found", occurrences };
-  if (occurrences > 1 && !all) return { ok: false, code: "ambiguous_edit", occurrences };
-  // split/join avoids replacement-string interpolation of literal $&, $` or $'.
-  const at = before.indexOf(oldText);
-  const after = all ? before.split(oldText).join(newText) : before.slice(0, at) + newText + before.slice(at + oldText.length);
-  const a = before.split("\n"), b = after.split("\n");
-  let prefix = 0, suffix = 0;
-  while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix++;
-  while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - suffix - 1] === b[b.length - suffix - 1]) suffix++;
-  const removed = a.slice(prefix, a.length - suffix), added = b.slice(prefix, b.length - suffix);
-  return { ok: true, after, replacements: all ? occurrences : 1, firstLine: prefix + 1,
-    diff: before === after ? "(content unchanged)" : `@@ -${prefix + 1},${removed.length} +${prefix + 1},${added.length} @@\n` +
-      [...removed.map(line => `-${line}`), ...added.map(line => `+${line}`)].join("\n") };
-}
-
-
-export interface EditSpec { old_string: string; new_string: string; replace_all?: boolean }
-
-export interface ClosestMatch {
-  /** 1-indexed, inclusive, in the view read shows. */
-  startLine: number;
-  endLine: number;
-  score: number;
-  /** First line of old_string that differs from the file, and the file's line there. */
-  expected: string;
-  actual: string;
-}
-
-export type EditsPlan =
-  | { ok: true; after: string; replacements: number; fuzzy: boolean; diff: string; firstLine: number }
-  | { ok: false; code: "invalid_input" | "not_found" | "ambiguous_edit"; edit: number; occurrences: number;
-      message: string; closest?: ClosestMatch };
-
-/** A replacement in view coordinates: [start, end) becomes text. */
-interface Span { start: number; end: number; text: string; edit: number }
-
-function occurrences(haystack: string, needle: string): number[] {
-  const found: number[] = [];
-  for (let at = haystack.indexOf(needle); at !== -1; at = haystack.indexOf(needle, at + needle.length)) found.push(at);
-  return found;
-}
-
-/** Offsets of each line start in `text`, plus a sentinel one past the end. */
-function lineStarts(text: string): number[] {
-  const starts = [0];
-  for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
-  starts.push(text.length + 1);
-  return starts;
-}
-
-const lineOf = (starts: readonly number[], offset: number) => {
-  let lo = 0, hi = starts.length - 2;
-  while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (starts[mid]! <= offset) lo = mid; else hi = mid - 1; }
-  return lo;
-};
-
-/**
- * Loose matches mapped back onto whole original lines.
- *
- * normalizeLoose keeps the line count, so a match starting on normalized line
- * i covers original lines i..j. Those lines -- and only those -- are replaced
- * by their normalized form with the substitution applied. Rewriting the whole
- * normalized file instead would quietly straighten every quote in it.
- */
-function looseSpans(text: string, spec: { old: string; next: string; all: boolean }, edit: number):
-  { spans: Span[] } | { count: number } {
-  const loose = normalizeLoose(text);
-  const needle = normalizeLoose(spec.old);
-  if (needle.trim().length === 0) return { count: 0 };
-  const found = occurrences(loose, needle);
-  if (found.length === 0 || (found.length > 1 && !spec.all)) return { count: found.length };
-  const looseStarts = lineStarts(loose), starts = lineStarts(text);
-  const spans: Span[] = [];
-  for (const at of found) {
-    const first = lineOf(looseStarts, at), last = lineOf(looseStarts, at + needle.length - 1);
-    const from = looseStarts[first]!, to = looseStarts[last + 1]! - 1;
-    const segment = loose.slice(from, to);
-    const local = at - from;
-    spans.push({ start: starts[first]!, end: starts[last + 1]! - 1, edit,
-      text: segment.slice(0, local) + spec.next + segment.slice(local + needle.length) });
-  }
-  return { spans };
-}
-
-/**
- * Where old_string most nearly occurs, for a failure message that lets the
- * model fix its copy instead of rereading the file (omp reports the same:
- * `crates/pi-edit/src/fuzzy.rs`). Candidates are anchored on lines of
- * old_string that occur verbatim (trimmed); failing that, on the most similar
- * single line, which is only computed for files small enough to afford it.
- */
-export function closestMatch(text: string, old: string): ClosestMatch | undefined {
-  const lines = text.split("\n");
-  const want = old.split("\n");
-  if (want.length > lines.length) return undefined;
-  const clip = (line: string) => line.trim().slice(0, 200);
-  const starts = new Set<number>();
-  const index = new Map<string, number[]>();
-  lines.forEach((line, i) => { const key = clip(line); if (key.length >= 4) index.set(key, [...(index.get(key) ?? []), i]); });
-  want.forEach((line, k) => {
-    for (const i of index.get(clip(line)) ?? []) if (i - k >= 0 && i - k + want.length <= lines.length) starts.add(i - k);
-  });
-  if (starts.size === 0 && lines.length <= 5_000) {
-    const anchor = want.findIndex((line) => clip(line).length > 0);
-    if (anchor === -1) return undefined;
-    const target = clip(want[anchor]!).slice(0, 80);
-    let best = -1, bestScore = 0;
-    lines.forEach((line, i) => {
-      const candidate = clip(line).slice(0, 80);
-      if (Math.abs(candidate.length - target.length) > target.length / 2) return;
-      const score = similarity(candidate, target);
-      if (score > bestScore && i - anchor >= 0 && i - anchor + want.length <= lines.length) { best = i - anchor; bestScore = score; }
-    });
-    if (best >= 0) starts.add(best);
-  }
-  let result: ClosestMatch | undefined;
-  const block = want.join("\n").slice(0, 2_000);
-  for (const start of [...starts].slice(0, 20)) {
-    const window = lines.slice(start, start + want.length);
-    const score = 1 - editDistance(window.join("\n").slice(0, 2_000), block) / Math.max(1, Math.max(block.length, window.join("\n").slice(0, 2_000).length));
-    if (result !== undefined && score <= result.score) continue;
-    const differs = want.findIndex((line, k) => line !== window[k]);
-    result = { startLine: start + 1, endLine: start + want.length, score,
-      expected: want[Math.max(0, differs)] ?? "", actual: window[Math.max(0, differs)] ?? "" };
-  }
-  return result !== undefined && result.score >= 0.5 ? result : undefined;
-}
-
-/**
- * Several edits, all located in the original before any is applied, so one
- * edit can never match text another just wrote. All succeed or none do.
- */
-export function planEdits(raw: string, edits: readonly EditSpec[]): EditsPlan {
-  const view = toView(raw);
-  const text = view.text;
-  if (edits.length === 0) return { ok: false, code: "invalid_input", edit: 0, occurrences: 0, message: "no edits given" };
-  const spans: Span[] = [];
-  let fuzzy = false;
-  for (let e = 0; e < edits.length; e++) {
-    const spec = { old: toLF(edits[e]!.old_string), next: toLF(edits[e]!.new_string), all: edits[e]!.replace_all === true };
-    const which = edits.length > 1 ? `edit ${e + 1}: ` : "";
-    if (spec.old.length === 0) return { ok: false, code: "invalid_input", edit: e, occurrences: 0, message: `${which}old_string must not be empty` };
-    const exact = occurrences(text, spec.old);
-    if (exact.length > 1 && !spec.all) {
-      return { ok: false, code: "ambiguous_edit", edit: e, occurrences: exact.length,
-        message: `${which}old_string appears ${exact.length} times; add surrounding lines to make it unique or pass replace_all` };
-    }
-    if (exact.length > 0) {
-      for (const at of exact) spans.push({ start: at, end: at + spec.old.length, text: spec.next, edit: e });
-      continue;
-    }
-    const loose = looseSpans(text, spec, e);
-    if ("spans" in loose) { spans.push(...loose.spans); fuzzy = true; continue; }
-    if (loose.count > 1) {
-      return { ok: false, code: "ambiguous_edit", edit: e, occurrences: loose.count,
-        message: `${which}old_string has no exact match and ${loose.count} matches ignoring whitespace and quote style; add surrounding lines to make it unique` };
-    }
-    const closest = closestMatch(text, spec.old);
-    return { ok: false, code: "not_found", edit: e, occurrences: 0,
-      message: `${which}old_string not found` + (closest === undefined ? "; read the current file before retrying" : ""),
-      ...(closest === undefined ? {} : { closest }) };
-  }
-  spans.sort((a, b) => a.start - b.start);
-  for (let i = 1; i < spans.length; i++) {
-    if (spans[i]!.start < spans[i - 1]!.end) {
-      return { ok: false, code: "invalid_input", edit: spans[i]!.edit, occurrences: 0,
-        message: `edits ${spans[i - 1]!.edit + 1} and ${spans[i]!.edit + 1} overlap; merge them into one edit` };
-    }
-  }
-  let after = text;
-  for (let i = spans.length - 1; i >= 0; i--) after = after.slice(0, spans[i]!.start) + spans[i]!.text + after.slice(spans[i]!.end);
-  if (after === text) return { ok: false, code: "invalid_input", edit: 0, occurrences: 0, message: "no change: new_string produces the current content" };
-  return { ok: true, after: fromView(view, after), replacements: spans.length, fuzzy, ...lineDiff(text, after) };
-}

package/src/core/environment.ts

@@ -1,181 +0,0 @@
-import type { ArtifactRef, LogEvent } from "./events.ts";
-import { isObservationArtifact } from "./observation-view.ts";
-import { workspaceChanged } from "./checkpoints.ts";
-
-/**
- * Facts about the machine, fixed at session start.
- *
- * Without them the model spends its first requests discovering what one
- * `uname` / `pwd` / `git status` would have told it (Meta-Harness and
- * LangChain's LocalContext middleware inject the same snapshot for that
- * reason). They go into the frozen prefix, which a resumed session reads
- * back from its saved context rather than rebuilding, so a date that has
- * moved on by the next day does not change the cached prefix.
- */
-export interface SessionEnvironment {
-  platform: string;
-  shell: string;
-  cwd: string;
-  /** Local calendar date, YYYY-MM-DD. */
-  date: string;
-  git: boolean;
-  /**
-   * Whether `rg` resolves in tool shells at session start. Models reach for
-   * it by habit; without this line a missing one costs an exit-127 request.
-   * Optional so environments recorded before it existed still render.
-   */
-  ripgrep?: boolean;
-}
-
-export function environmentSection(env: SessionEnvironment): string {
-  return [
-    "Environment (recorded at session start):",
-    `- Platform: ${env.platform}`,
-    `- Shell: ${env.shell}`,
-    `- Working directory: ${env.cwd}`,
-    `- Date: ${env.date}`,
-    `- Git repository: ${env.git ? "yes" : "no"}`,
-    ...(env.ripgrep === undefined ? [] : [`- ripgrep (rg) in the shell: ${env.ripgrep ? "yes" : "no — use the grep and find tools"}`]),
-  ].join("\n");
-}
-
-/** R6: these are operational assumptions, not measured freshness guarantees. */
-export const ENVIRONMENT_TTL_MS = 5 * 60_000;
-export const ENVIRONMENT_TIMEOUT_MS = 5_000;
-export const ENVIRONMENT_OUTPUT_BYTES = 256 * 1024;
-export const ENVIRONMENT_PARSE_BYTES = 64 * 1024;
-/** Version reports are metadata; verbose command output remains in the original artifact. */
-export const ENVIRONMENT_VERSION_BYTES = 4096;
-export type EnvironmentProbe = "version" | "python";
-export type EnvironmentSource = { host: string; workspace: string; cwd: string; runtime: string; inherited_sha256: string };
-export type PythonCapability = { executable: string; prefix: string; base_prefix: string; version: string;
-  implementation: string; isolated: true; features: { tarfile_extractall_filter: boolean } };
-export type EnvironmentReceipt = {
-  kind: "environment"; version: 1;
-  query: { program: string; probe: EnvironmentProbe };
-  source: EnvironmentSource;
-  observed_at: number; expires_at: number;
-  state: "observed" | "missing" | "opaque" | "failed" | "unknown";
-  shell: { executable: string; version: string; cwd: string; path_sha256: string } | null;
-  resolution: { kind: string; executable: string | null } | null;
-  reported_version: string | null;
-  python?: PythonCapability;
-  evidence: { output: ArtifactRef; exit: number; complete: boolean };
-  reason?: string;
-};
-
-const quote = (text: string) => "'" + text.replaceAll("'", "'\\''") + "'";
-const marker = "\0XENO_ENVIRONMENT_V1\0";
-const PYTHON_CAPABILITY_PROBE = [
-  "import inspect,json,platform,sys,tarfile",
-  "print(json.dumps({'executable':sys.executable,'prefix':sys.prefix,'base_prefix':sys.base_prefix,'version':platform.python_version(),'implementation':platform.python_implementation(),'isolated':bool(sys.flags.isolated),'features':{'tarfile_extractall_filter':'filter' in inspect.signature(tarfile.TarFile.extractall).parameters}},sort_keys=True))",
-].join(";");
-
-/** Program names are data, including paths with quotes/newlines; no caller code is evaluated. */
-export function environmentProbeCommand(program: unknown, probe: unknown = "version"): string {
-  if (typeof program !== "string" || !program || program.includes("\0") || new TextEncoder().encode(program).length > 4096) throw new Error("program must be a nonempty name or path up to 4096 bytes without NUL");
-  if (probe !== "version" && probe !== "python") throw new Error("probe must be version or python");
-  return [
-    "builtin set +e", `xeno_probe_program=${quote(program)}`,
-    'xeno_probe_kind=$(builtin type -t -- "$xeno_probe_program" 2>/dev/null)',
-    'xeno_probe_path=""',
-    'if [ "$xeno_probe_kind" = file ]; then xeno_probe_path=$(builtin type -P -- "$xeno_probe_program" 2>/dev/null); fi',
-    // A single frame precedes the program output, which remains untrusted data.
-    `builtin printf '\\0XENO_ENVIRONMENT_V1\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0' "$xeno_probe_program" ${quote(probe)} "$xeno_probe_kind" "$xeno_probe_path" "$BASH" "$BASH_VERSION" "$PWD" "$PATH"`,
-    'if [ -z "$xeno_probe_kind" ]; then builtin exit 127; fi',
-    'if [ "$xeno_probe_kind" != file ] || [ -z "$xeno_probe_path" ]; then builtin exit 125; fi',
-    // Replace the discovery shell: the managed group leader and exit belong
-    // to the probed program, not an extra shell waiting for its child (R1).
-    probe === "python" ? `builtin exec -- "$xeno_probe_path" -I -c ${quote(PYTHON_CAPABILITY_PROBE)}` : 'builtin exec -- "$xeno_probe_path" --version',
-  ].join("\n");
-}
-
-export interface EnvironmentFrame { program: string; probe: EnvironmentProbe; kind: string; executable: string | null;
-  shell: string; shell_version: string; cwd: string; path: string; output: string }
-export function parseEnvironmentFrame(text: string, program: string, probe: EnvironmentProbe): EnvironmentFrame | null {
-  const start = text.indexOf(marker);
-  if (start < 0) return null;
-  const fields: string[] = [];
-  let at = start + marker.length;
-  for (let i = 0; i < 8; i++) {
-    const end = text.indexOf("\0", at);
-    if (end < 0) return null;
-    fields.push(text.slice(at, end)); at = end + 1;
-  }
-  if (fields[0] !== program || fields[1] !== probe || !["", "file", "function", "alias", "builtin", "keyword"].includes(fields[2]!) ||
-    !fields[4] || !fields[5] || !fields[6] || (fields[2] === "file" && !fields[3])) return null;
-  return { program, probe, kind: fields[2]!, executable: fields[3] || null, shell: fields[4]!, shell_version: fields[5]!, cwd: fields[6]!, path: fields[7]!, output: text.slice(at) };
-}
-
-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 strings = (value: Record<string, unknown>, keys: readonly string[]) => keys.every(key => typeof value[key] === "string" && value[key] !== "");
-export function isPythonCapability(value: unknown): value is PythonCapability {
-  return object(value) && strings(value, ["executable", "prefix", "base_prefix", "version", "implementation"]) && value["isolated"] === true &&
-    object(value["features"]) && typeof value["features"]["tarfile_extractall_filter"] === "boolean";
-}
-
-/** D11: neither a version-looking line nor an interrupted exit zero proves a capability. */
-export function environmentCapability(frame: EnvironmentFrame | null, exit: number, capture: {
-  complete: boolean; stopped?: "cancelled" | "timeout"; limited?: "output" | "parse";
-}): Pick<EnvironmentReceipt, "state" | "reported_version" | "python" | "reason"> {
-  const unknown = (reason: string) => ({ state: "unknown" as const, reported_version: null, reason });
-  if (capture.limited) return unknown(`probe exceeded its ${capture.limited} budget; inspect the original output`);
-  if (capture.stopped) return unknown(`probe ${capture.stopped}; inspect partial effects before continuing`);
-  if (!capture.complete || !frame) return unknown("probe output is incomplete or its environment frame is invalid");
-  if (frame.kind === "" && exit === 127) return { state: "missing", reported_version: null, reason: "program was not found in the command environment" };
-  if (frame.kind !== "file") return { state: "opaque", reported_version: null, reason: "shell resolution is not an executable file; specify its exact path" };
-  if (exit !== 0) return { state: "failed", reported_version: null, reason: "program exited unsuccessfully; a version-like line is not capability evidence" };
-  const output = frame.output.trim();
-  if (!output || new TextEncoder().encode(output).length > ENVIRONMENT_VERSION_BYTES) return unknown("version report is empty or exceeds the metadata budget");
-  if (frame.probe === "version") return { state: "observed", reported_version: output };
-  try {
-    const value: unknown = JSON.parse(output);
-    if (isPythonCapability(value)) return { state: "observed", reported_version: value.version, python: value };
-  } catch { /* The complete untrusted report remains available in the artifact. */ }
-  return unknown("Python did not return a valid isolated capability report");
-}
-export function isEnvironmentReceipt(value: unknown): value is EnvironmentReceipt {
-  if (!object(value) || value["kind"] !== "environment" || value["version"] !== 1 || !object(value["query"]) ||
-    !strings(value["query"], ["program"]) || !["version", "python"].includes(String(value["query"]["probe"]))) return false;
-  const source = value["source"], evidence = value["evidence"], shell = value["shell"], resolution = value["resolution"];
-  if (!object(source) || !strings(source, ["host", "workspace", "cwd", "runtime"]) || !digest(source["inherited_sha256"]) ||
-    !object(evidence) || !isObservationArtifact(evidence["output"]) || !Number.isInteger(evidence["exit"]) || typeof evidence["complete"] !== "boolean") return false;
-  const observed = value["observed_at"], expires = value["expires_at"];
-  if (typeof observed !== "number" || !Number.isSafeInteger(observed) || observed < 0 || expires !== observed + ENVIRONMENT_TTL_MS ||
-    !["observed", "missing", "opaque", "failed", "unknown"].includes(String(value["state"])) ||
-    !(value["reported_version"] === null || typeof value["reported_version"] === "string") ||
-    !(value["reason"] === undefined || typeof value["reason"] === "string")) return false;
-  if (shell !== null && (!object(shell) || !strings(shell, ["executable", "version", "cwd"]) || !digest(shell["path_sha256"]))) return false;
-  if (resolution !== null && (!object(resolution) || typeof resolution["kind"] !== "string" ||
-    !(resolution["executable"] === null || typeof resolution["executable"] === "string"))) return false;
-  if (value["python"] !== undefined && !isPythonCapability(value["python"])) return false;
-  if (value["state"] === "observed" && (evidence["exit"] !== 0 || !evidence["complete"] || !object(shell) || !object(resolution) ||
-    resolution["kind"] !== "file" || !resolution["executable"] || !value["reported_version"] ||
-    value["query"]["probe"] === "python" && value["python"] === undefined)) return false;
-  return true;
-}
-
-export type EnvironmentValidity = { state: "recorded" | "expired" | "scope_changed" | "invalidated" | "unconfirmed";
-  reason: string; event?: string };
-/** Recomputed on consumption: recent observations are never guarantees about a future invocation. */
-export function environmentValidity(receipt: EnvironmentReceipt, source: EnvironmentSource, now: number, after: readonly LogEvent[]): EnvironmentValidity {
-  for (const event of after) {
-    if (event.t === "user_bash" || workspaceChanged(event)) {
-      return { state: "invalidated", reason: "later command or workspace change requires environment revalidation", event: event.id };
-    }
-    if (event.t !== "tool_result") continue;
-    if (isEnvironmentReceipt(event.data) && event.data.query.program === receipt.query.program && event.data.query.probe === receipt.query.probe) {
-      return { state: "invalidated", reason: "a later probe supersedes this observation, including a failed probe", event: event.id };
-    }
-    if (event.effect?.kind === "edit" || event.effect?.kind === "command" || event.diagnostic?.code === "environment_missing" ||
-      event.diagnostic?.effects === "possible" && event.diagnostic.execution !== "not_started") {
-      return { state: "invalidated", reason: "later execution or mutation requires environment revalidation", event: event.id };
-    }
-  }
-  const keys: readonly (keyof EnvironmentSource)[] = ["host", "workspace", "cwd", "runtime", "inherited_sha256"];
-  if (keys.some(key => source[key] !== receipt.source[key])) return { state: "scope_changed", reason: "host, workspace, directory, runtime, or inherited environment changed" };
-  if (!Number.isFinite(now) || now < receipt.observed_at || now >= receipt.expires_at) return { state: "expired", reason: "observation time is outside its validity interval" };
-  if (receipt.state !== "observed") return { state: "unconfirmed", reason: "the probe did not establish this capability" };
-  return { state: "recorded", reason: "recent observation only; login startup files or external changes may require another probe" };
-}

package/src/core/event-validation.ts

@@ -1,220 +0,0 @@
-/** D8/D11: malformed durable data is corruption, never a valid empty event. */
-import type { LogEvent, NodeRef } from "./events.ts";
-import { isExecutionOutcome } from "./outcome.ts";
-import { isJsonValue, isToolDiagnostic } from "./tool-contract.ts";
-import { validImageRef } from "./images.ts";
-import { parseAcceptanceContract } from "./acceptance.ts";
-import { validFileChanges } from "./checkpoints.ts";
-import { isObservationReceipt } from "./read-observation.ts";
-import { isSearchReceipt } from "./search-observation.ts";
-import { isProcessReceipt } from "./process-receipt.ts";
-import { isObservationArtifact } from "./observation-view.ts";
-import { isCommandArtifactReceipt } from "./command-artifacts.ts";
-import { isRuntimeTargetReceipt } from "./runtime-target.ts";
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-const strings = (value: unknown): boolean => Array.isArray(value) && value.every((v) => typeof v === "string");
-const optionalString = (value: unknown): boolean => value === undefined || typeof value === "string";
-const natural = (value: unknown): boolean => Number.isSafeInteger(value) && Number(value) >= 0;
-const eventRef = (value: unknown): boolean => isRecord(value) && natural(value["node"]) && typeof value["event"] === "string" && value["event"] !== "";
-export function validNodeRef(value: unknown): value is NodeRef {
-  return isRecord(value) && Number.isSafeInteger(value["node"]) && Number(value["node"]) >= 0 &&
-    typeof value["log_ref"] === "string" && typeof value["sha256"] === "string" &&
-    (value["at_event"] === undefined || typeof value["at_event"] === "string");
-}
-
-/** A label is a short phrase or class name; anything longer or with control characters is not one the harness wrote. */
-function validFailureCause(value: unknown): boolean {
-  return isRecord(value) && (value["source"] === "provider" || value["source"] === "harness") &&
-    typeof value["label"] === "string" && /^[^\u0000-\u001f\u007f]{1,64}$/.test(value["label"]) &&
-    (value["status"] === undefined || Number.isSafeInteger(value["status"])) &&
-    (value["retries"] === undefined || natural(value["retries"]));
-}
-
-export function isLogEvent(value: unknown): value is LogEvent {
-  if (!isRecord(value) || typeof value["id"] !== "string" || value["id"].length === 0 || typeof value["at"] !== "string") return false;
-  if (value["outcome"] !== undefined && !isExecutionOutcome(value["outcome"])) return false;
-  if (value["work_id"] !== undefined && !(typeof value["work_id"] === "string" && value["work_id"].trim().length > 0)) return false;
-  const carried = value["carried_from"];
-  if (carried !== undefined && !(isRecord(carried) && natural(carried["node"]) && typeof carried["event"] === "string")) return false;
-  const has = (...keys: string[]): boolean => keys.every((key) => typeof value[key] === "string");
-  const images = value["images"];
-  if (images !== undefined && (!Array.isArray(images) || !images.every(validImageRef))) return false;
-  switch (value["t"]) {
-    case "tool_invocation": return has("call_id", "name") && value["call_id"] !== "" && value["name"] !== "" &&
-      (value["origin"] === undefined || value["origin"] === "extension") &&
-      isObservationArtifact(value["input_ref"]) && (value["schema_ref"] === null || isObservationArtifact(value["schema_ref"])) &&
-      (value["input"] === undefined || isJsonValue(value["input"])) && optionalString(value["parent_call_id"]) &&
-      (value["parent_ref"] === undefined ? value["parent_call_id"] === undefined : eventRef(value["parent_ref"]) && value["parent_call_id"] !== undefined) &&
-      value["parent_call_id"] !== "" && value["parent_call_id"] !== value["call_id"];
-    case "checkpoint": return has("operation") && ["edit", "git", "restore"].includes(String(value["source"])) &&
-      ["prepared", "applied", "unavailable"].includes(String(value["phase"])) && validFileChanges(value["changes"]) &&
-      optionalString(value["tree"]) && optionalString(value["reason"]);
-    case "workspace_observation": return value["scope"] === "source-v1" && typeof value["changed"] === "boolean" && optionalString(value["reason"]) &&
-      (value["baseline"] === undefined || value["baseline"] === true) &&
-      (value["fingerprint"] === undefined || typeof value["fingerprint"] === "string" && /^[a-f0-9]{64}$/.test(value["fingerprint"]));
-    case "process_exit": {
-      const output = value["output"];
-      const receipt = value["receipt"];
-      if (receipt !== undefined && (!isProcessReceipt(receipt) || receipt.replayed || receipt.running !== false ||
-        receipt.session_id !== value["session"] || receipt.exit !== value["exit"] || !isRecord(output) ||
-        receipt.artifacts !== undefined && receipt.artifacts.command !== value["command"] ||
-        receipt.output === undefined || receipt.output.sha256 !== output["sha256"] || receipt.output.bytes !== output["bytes"])) return false;
-      return has("command") && natural(value["session"]) && Number(value["session"]) > 0 && Number.isInteger(value["exit"]) &&
-        value["reason"] === "disposed" && isRecord(output) && typeof output["path"] === "string" &&
-        typeof output["sha256"] === "string" && /^[a-f0-9]{64}$/.test(output["sha256"]) && natural(output["bytes"]);
-    }
-    case "approval": {
-      const user = ["once", "command", "tool", "deny"].includes(String(value["decision"]));
-      const rule = value["decision"] === "allow" || value["decision"] === "deny";
-      return has("call_id", "tool") && value["call_id"] !== "" && value["tool"] !== "" &&
-        optionalString(value["command"]) && optionalString(value["rule"]) &&
-        (value["source"] === "user" ? user : value["source"] === "no_prompt" ? value["decision"] === "deny" :
-          ["session_rule", "config", "auto"].includes(String(value["source"])) && rule);
-    }
-    case "skill_loaded": return has("name", "path", "sha256", "artifact") &&
-      ["sha256", "artifact"].every(key => /^[a-f0-9]{64}$/.test(String(value[key]))) &&
-      ["inline", "fork", "read"].includes(String(value["mode"])) && ["user", "model"].includes(String(value["origin"]));
-    case "acceptance_contract": {
-      try { parseAcceptanceContract(value["contract"]); return has("request"); } catch { return false; }
-    }
-    case "acceptance_decision": return has("request", "contract_id", "criterion") && value["actor"] === "user" &&
-      (value["target_binding"] === undefined ? value["target_observation"] === undefined : has("target_binding", "target_observation"));
-    case "target_observation": return isRuntimeTargetReceipt(value["observation"]);
-    case "counter_check": return has("request", "criterion", "command") && (value["guard"] === undefined || value["guard"] === true) &&
-      (Number.isSafeInteger(value["exit"]) ? value["reason"] === undefined : typeof value["reason"] === "string" && value["exit"] === undefined);
-    case "blind_check": return has("request", "check") && typeof value["exposed"] === "boolean" && optionalString(value["exposure"]) &&
-      (Number.isSafeInteger(value["exit"]) ? value["reason"] === undefined : typeof value["reason"] === "string" && value["exit"] === undefined);
-    case "goal": {
-      if (value["action"] === "clear") return value["reason"] === "met" || value["reason"] === "user";
-      if (value["action"] !== "set" || !has("objective", "draft") || !strings(value["accepted"]) || !strings(value["rejected"])) return false;
-      try {
-        const contract = parseAcceptanceContract(value["contract"]), accepted = value["accepted"] as string[];
-        return accepted.length > 0 && contract.criteria.map(item => item.id).join("\0") === accepted.join("\0");
-      } catch { return false; }
-    }
-    case "extension": return has("customType", "content") && typeof value["display"] === "boolean" && typeof value["inContext"] === "boolean" && (value["data"] === undefined || isJsonValue(value["data"]));
-    case "user": return has("text") && (value["request"] === undefined || typeof value["request"] === "string" && value["request"] !== "");
-    case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]) && (value["failure"] === undefined || validFailureCause(value["failure"]));
-    case "user_bash": {
-      const ref = value["content_ref"];
-      const outcome = value["outcome"];
-      if (!isExecutionOutcome(outcome) || !["tool_completed", "tool_failed", "cancelled", "timeout"].includes(outcome.reason)) return false;
-      if (outcome.reason === "tool_completed" && value["exit"] !== 0) return false;
-      if (outcome.reason === "tool_failed" && value["exit"] === 0) return false;
-      return has("command", "content") && Number.isInteger(value["exit"]) && typeof value["excludeFromContext"] === "boolean" &&
-        isRecord(ref) && typeof ref["sha256"] === "string" &&
-        typeof ref["path"] === "string" && natural(ref["bytes"]);
-    }
-    case "guidance": return has("text") && ["continuation", "repetition", "budget", "boundary", "stall", "output_recovery", "completion_review", "churn", "deadline", "runtime_acceptance", "goal", "secret", "branch"].includes(String(value["reason"])) && strings(value["sources"]);
-    case "interrupt": return has("user_id");
-    case "assistant": return (value["stop_reason"] === null || optionalString(value["stop_reason"])) &&
-      (value["replay_key"] === undefined || typeof value["replay_key"] === "string" && /^[a-f0-9]{64}$/.test(value["replay_key"])) &&
-      Array.isArray(value["blocks"]) && value["blocks"].every((b: unknown) => {
-      if (!isRecord(b)) return false;
-      if (b["type"] === "text") return typeof b["text"] === "string";
-      if (b["type"] === "thinking") return typeof b["text"] === "string" && "raw" in b;
-      return b["type"] === "tool_use" && typeof b["call_id"] === "string" && typeof b["name"] === "string" && "input" in b;
-    });
-    case "tool_result": {
-      if (!optionalString(value["parent_call_id"]) || value["parent_call_id"] === "" || value["parent_call_id"] === value["call_id"]) return false;
-      if (value["origin"] !== undefined && value["origin"] !== "extension") return false;
-      if (value["invocation_ref"] !== undefined && !eventRef(value["invocation_ref"])) return false;
-      const observation = value["observation"];
-      if (observation !== undefined && (!isObservationReceipt(observation) ||
-        !isRecord(value["content_ref"]) || value["content_ref"]["sha256"] !== observation.artifact.sha256 ||
-        value["content_ref"]["bytes"] !== observation.artifact.bytes || value["content_sha256"] !== observation.artifact.sha256)) return false;
-      if (value["data"] !== undefined && !isJsonValue(value["data"])) return false;
-      if (value["data_ref"] !== undefined && (!isObservationArtifact(value["data_ref"]) || value["data"] !== undefined)) return false;
-      if (isRecord(value["data"]) && value["data"]["kind"] === "process") {
-        const process = value["data"];
-        if (!isProcessReceipt(process)) return false;
-        if (process.output && (!isRecord(value["content_ref"]) || value["content_ref"]["sha256"] !== process.output.sha256 ||
-          value["content_ref"]["bytes"] !== process.output.bytes || value["content_sha256"] !== process.output.sha256)) return false;
-        if (process.replayed && value["effect"] !== undefined) return false;
-        if (value["effect"] !== undefined && (!isRecord(value["effect"]) || value["effect"]["kind"] !== "command" ||
-          process.running !== false || value["effect"]["exit"] !== process.exit ||
-          JSON.stringify(value["effect"]["artifacts"]) !== JSON.stringify(process.artifacts))) return false;
-      }
-      if (isObservationReceipt(observation) && observation.descriptor !== undefined &&
-        (!isRecord(value["data"]) || value["data"]["read_handle"] !== observation.descriptor.sha256)) return false;
-      if (isRecord(value["data"]) && value["data"]["kind"] === "search") {
-        const search = value["data"];
-        if (!isSearchReceipt(search) || !isRecord(value["content_ref"]) || value["content_ref"]["sha256"] !== search.artifact.sha256 ||
-          value["content_ref"]["bytes"] !== search.artifact.bytes || value["content_sha256"] !== search.artifact.sha256) return false;
-      }
-      if (value["diagnostic"] !== undefined && !isToolDiagnostic(value["diagnostic"])) return false;
-      if (value["warnings"] !== undefined && (!Array.isArray(value["warnings"]) || !value["warnings"].every(isToolDiagnostic))) return false;
-      const instructions = value["instructions"];
-      if (instructions !== undefined && (!isRecord(instructions) || !Array.isArray(instructions["keys"]) || instructions["keys"].length === 0 ||
-        !instructions["keys"].every(key => typeof key === "string" && key.length > 0) ||
-        typeof instructions["text"] !== "string" || instructions["text"].length === 0)) return false;
-      if (!has("call_id", "content") || typeof value["ok"] !== "boolean") return false;
-      if (!optionalString(value["content_sha256"])) return false;
-      if (!optionalString(value["observation_sha256"])) return false;
-      const artifact = value["content_ref"];
-      if (artifact !== undefined && !(isRecord(artifact) && typeof artifact["sha256"] === "string" &&
-          typeof artifact["path"] === "string" && natural(artifact["bytes"]))) return false;
-      const effect = value["effect"];
-      if (effect === undefined) return true;
-      if (!isRecord(effect)) return false;
-      if (effect["kind"] === "command") return typeof effect["cmd"] === "string" && Number.isInteger(effect["exit"]) &&
-        optionalString(effect["gate"]) && optionalString(effect["workspace_sha256"]) &&
-        (effect["artifacts"] === undefined || isCommandArtifactReceipt(effect["artifacts"]) &&
-          effect["artifacts"].exit === effect["exit"] && effect["artifacts"].command === effect["cmd"]) &&
-        (effect["workspace_scope"] === undefined || effect["workspace_scope"] === "source-v1") &&
-        (effect["workspace_observed"] === undefined || typeof effect["workspace_observed"] === "boolean");
-      if (effect["kind"] === "read") return typeof effect["path"] === "string" && typeof effect["sha256"] === "string" &&
-        (effect["ranges"] === undefined || (Array.isArray(effect["ranges"]) && effect["ranges"].every((r: unknown) =>
-          Array.isArray(r) && r.length === 2 && r.every((n) => Number.isSafeInteger(n)) && r[0] >= 1 && r[1] >= r[0])));
-      return effect["kind"] === "edit" && typeof effect["path"] === "string" && typeof effect["sha256_after"] === "string" &&
-        (effect["sha256_before"] === null || typeof effect["sha256_before"] === "string");
-    }
-    case "cut": return has("handoff_ref") && (value["working_set_version"] === undefined || value["working_set_version"] === 2 || value["working_set_version"] === 3) && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
-      (value["guidance_tools"] === undefined || Array.isArray(value["guidance_tools"]) && value["guidance_tools"].every(item => typeof item === "string")) &&
-      optionalString(value["retained_from"]) && optionalString(value["next_context_ref"]) &&
-      (value["next_node"] === undefined || natural(value["next_node"])) && optionalString(value["next_model"]) &&
-      (value["handoff_tokens"] === undefined || (typeof value["handoff_tokens"] === "number" && Number.isFinite(value["handoff_tokens"]) && value["handoff_tokens"] > 0)) &&
-      (value["predecessor"] === null || validNodeRef(value["predecessor"]));
-    case "claim": {
-      const q = value["evidence"];
-      return has("what") && isRecord(q) && (typeof q["gate"] === "string" || typeof q["command"] === "string");
-    }
-    case "decision": return has("chose", "because") && (value["rejected"] === undefined || strings(value["rejected"]));
-    case "pitfall": return has("tried", "failed_because");
-    case "blocked": return has("what", "reason");
-    case "question": return has("text");
-    case "next_action": return has("what", "next_action") && (value["depends_on"] === undefined || strings(value["depends_on"]));
-    case "work_dependencies": return has("work_id", "what") && strings(value["depends_on"]);
-    case "work_owner": return has("work_id", "what", "owner") && ["claim", "release"].includes(String(value["operation"]));
-    case "evidence_link": return has("work", "what", "source") && optionalString(value["resource"]) && optionalString(value["version"]) &&
-      optionalString(value["supersedes"]) && (value["observed_version"] === null || optionalString(value["observed_version"]));
-    case "work_status": return has("work_id", "what") && ["unblock", "reopen", "cancel"].includes(String(value["operation"])) &&
-      optionalString(value["reason"]) && (value["operation"] === "cancel" ||
-        (typeof value["next_action"] === "string" && value["next_action"].trim().length > 0));
-    case "rewind": return ["both", "files", "context"].includes(String(value["mode"])) && validNodeRef(value["from"]) &&
-      (value["files_from"] === undefined || validNodeRef(value["files_from"])) &&
-      has("prompt") && strings(value["restored"]) && strings(value["removed"]) && strings(value["unrecoverable"]) && strings(value["divergence"]);
-    case "spawn": {
-      const input = value["input"];
-      if (input !== undefined) {
-        if (!isRecord(input) || typeof input["source_event"] !== "string" || !strings(input["tools"]) ||
-            !Number.isSafeInteger(input["max_turns"]) || Number(input["max_turns"]) < 1 || !isRecord(input["workspace"])) return false;
-        const workspace = input["workspace"];
-        if (!(workspace["kind"] === "shared_readonly" || (workspace["kind"] === "git_tree" &&
-            typeof workspace["head"] === "string" && typeof workspace["tree"] === "string"))) return false;
-      }
-      return (value["background"] === undefined || value["background"] === true) && validNodeRef(value["branch"]) && has("purpose") && (value["workspace"] === undefined ||
-      (isRecord(value["workspace"]) && typeof value["workspace"]["path"] === "string" && typeof value["workspace"]["branch"] === "string"));
-    }
-    case "joined": return validNodeRef(value["branch"]) && has("handoff_ref", "summary") && optionalString(value["model"]) &&
-      (value["receipt_ref"] === undefined || typeof value["receipt_ref"] === "string" && /^[a-f0-9]{64}$/.test(value["receipt_ref"])) &&
-      (value["tip"] === undefined || validNodeRef(value["tip"]));
-    case "adopt": return validNodeRef(value["branch"]) && (value["next_node"] === undefined || natural(value["next_node"])) &&
-      (value["applied"] === undefined || value["applied"] === true);
-    case "discard": return validNodeRef(value["branch"]) && has("reason");
-    default: return false;
-  }
-}