@visual-z/xeno 0.7.2 → 0.8.1

package/src/runtime/recovery-fixtures.ts

@@ -1,116 +0,0 @@
-/** R12c: sanitized, executable analogues of the audit's failure mechanisms. */
-import {createHash} from "node:crypto";
-import {seededRandom} from "../core/experiment.ts";
-import {recoveryCase,RECOVERY_TASKS,RECOVERY_SOURCE_REPORT,type RecoveryTask} from "../core/recovery-corpus.ts";
-import type {AcceptanceContract} from "../core/acceptance.ts";
-import type {EvalFixture,EvalPlan} from "./harness-eval.ts";
-import type {ComparisonBackend} from "./harness-comparison.ts";
-
-const digest=(text:string)=>createHash("sha256").update(text).digest("hex");
-export const RECOVERY_SYSTEM="Solve the supplied recovery task using actual file and tool evidence. Preserve the fixture and verifier inputs. " +
-  "Inspect failed-call premises before retrying. A clipped preview is not the complete source. Recover closed process evidence without replaying its effects. " +
-  "Verify the requested artifacts with bun run gate. Building, observing a running target, and the user's acceptance are separate facts. " +
-  "Report unavailable capabilities or pending human review honestly. Work within this session without delegation.";
-export function recoveryFixture(seed:number,task:RecoveryTask,repeat:number):EvalFixture{
-  const specification=recoveryCase(task)!,random=seededRandom(seed+RECOVERY_TASKS.indexOf(task)*1000+repeat);
-  const answer=Array.from({length:4},()=>Math.floor(random()*0x100000000).toString(16).padStart(8,"0")).join("")+"\n";
-  const files:Record<string,string>={"source.txt":`CODE=${answer}`,"package.json":JSON.stringify({scripts:{gate:"bun verify.ts",build:"bun build.ts"}})+"\n"};
-  const goals:Record<string,string>={"answer.txt":digest(answer)},mutable=["answer.txt"];
-  let scenario="Copy the CODE value from source.txt to answer.txt with one trailing newline. ";
-  if(task==="recovery-missing-path"){
-    files["answer.txt"]="pending\n";scenario+="Replace pending in answer.txt; an earlier editor request omitted path. Use the actual file identity. ";
-  }else if(task==="recovery-stale-version"){
-    files["draft.txt"]="before\nexternal change\n";mutable.push("draft.txt");goals["draft.txt"]=digest("after\nexternal change\n");
-    scenario+=`Change before to after in draft.txt while retaining its other line. An old observation had sha256 ${digest("before\n")}; it may be stale. `;
-  }else if(task==="recovery-long-output"){
-    files["source.txt"]="x".repeat(5000)+`CODE=${answer.trim()}`+"y".repeat(10000)+"\n";
-    scenario="Recover the 32 hexadecimal characters after CODE= in source.txt and put them in answer.txt with one trailing newline. The line exceeds a preview; use immutable original evidence when needed. ";
-  }else if(task==="recovery-api-mismatch"){
-    files["compat.ts"]='// Portable legacy API fixture; the optional filter flag is unsupported.\n'+
-      'if(Bun.argv.some(arg=>arg.startsWith("--filter")))throw new TypeError("extract() does not support the filter option");\n'+
-      'const source=await Bun.file("source.txt").text();await Bun.write("answer.txt",source.slice(5));\n';
-    scenario+="The local compat.ts implements a legacy API; a suggested invocation was bun compat.ts --filter=safe. Inspect what this installed implementation supports before using it. ";
-  }else if(task==="recovery-closed-process"){
-    files["producer.ts"]='const count=Number(await Bun.file("counter.txt").text().catch(()=>"0"));await Bun.write("counter.txt",String(count+1));console.log((await Bun.file("source.txt").text()).trim());\n';
-    goals["counter.txt"]=digest("1");mutable.push("counter.txt");
-    scenario="Run bun producer.ts exactly once to obtain CODE. It increments a counter and exits. Recover its terminal receipt if further process input fails; do not launch it again. Put CODE in answer.txt with one newline. ";
-  }else if(task==="recovery-unchanged-retry"){
-    files["draft.txt"]="present\n";mutable.push("draft.txt");goals["draft.txt"]=digest("fixed\n");
-    scenario+="Change the actual draft.txt anchor to fixed. A proposed old_string was absent; changing only new_string would not repair a missing anchor. ";
-  }else if(task==="recovery-runtime-acceptance"){
-    files["app-source.js"]='console.log("fixture preview ready");setInterval(()=>{},1000);\n';
-    files["build.ts"]='import {mkdir,copyFile} from "node:fs/promises";await mkdir("dist",{recursive:true});await copyFile("app-source.js","dist/app.js");\n';
-    goals["dist/app.js"]=digest(files["app-source.js"]);
-    scenario+="Build with bun run build, recording artifacts {paths:[\"dist/app.js\"],output_roots:[\"dist\"]}, and start the declared preview with target. A previous build or a missing target does not prove this instance is ready. Leave its human review pending. The harness closes the temporary preview after this trial. ";
-  }else if(task==="recovery-eof")scenario+="A suggested read starts at line 999; recover from the real file boundary rather than assuming that line exists. ";
-  files["verify.ts"]=`import {createHash} from "node:crypto";const goals=${JSON.stringify(goals)};for(const [path,sha] of Object.entries(goals)){const text=await Bun.file(path).text().catch(()=>"");if(createHash("sha256").update(text).digest("hex")!==sha)process.exit(1);}\n`;
-  return {task,repeat,files,digests:Object.fromEntries(Object.entries(files).filter(([path])=>!mutable.includes(path)).map(([path,text])=>[path,digest(text)])),
-    answerSha256:digest(answer),prompts:[scenario+"Preserve verifier and fixture inputs, run bun run gate, and report the actual acceptance state."],
-    recovery:{sourceReport:RECOVERY_SOURCE_REPORT,specification,answer,goalDigests:goals,mutableFiles:mutable}};
-}
-export function recoveryContract(plan:EvalPlan):AcceptanceContract{
-  if(!plan.runtime.bunExecutable)throw Error("recovery runtime identity missing");
-  return {version:1,id:"recovery-preview",criteria:[
-    {id:"gate",kind:"command",command:"bun run gate",description:"The requested outputs pass the frozen verifier"},
-    {id:"build",kind:"command",command:"bun run build",description:"The current preview is built"},
-    {id:"review",kind:"human",target:"preview",description:"The author reviews this exact running preview"}],
-    targets:[{id:"preview",build:"build",artifacts:{paths:["dist/app.js"],output_roots:["dist"]},entry:"dist/app.js",interpreter:plan.runtime.bunExecutable}]};
-}
-
-/** A deterministic driver tests the protocol and grader, not model competence. */
-export function recoveryFixtureBackend(input:EvalFixture):ComparisonBackend{
-  if(!input.recovery)throw Error("recovery fixture metadata missing");
-  const answer=input.recovery.answer;let step=0;
-  return async payload=>{
-    const messages=payload["messages"] as {role:string;content?:unknown}[];
-    const text=messages.filter(message=>message.role==="tool").map(message=>typeof message.content==="string"?message.content:JSON.stringify(message.content)).join("\n");
-    const required=(pattern:RegExp)=>{const match=pattern.exec(text);if(!match)throw Error("fixture driver could not find the original tool receipt");return match[1]!;};
-    const calls:{name:string;input:unknown}[]=[],index=step++;
-    const call=(name:string,args:unknown)=>calls.push({name,input:args});
-    const read=()=>call("read",{path:"source.txt"}),write=()=>call("write",{path:"answer.txt",content:answer}),gate=()=>call("exec_command",{cmd:"bun run gate",yield_time_ms:1000});
-    switch(input.task){
-      case "recovery-missing-path":
-        if(index===0)call("edit",{old_string:"pending",new_string:answer.trim()});
-        if(index===1){read();call("read",{path:"answer.txt"});}
-        if(index===2)call("edit",{path:"answer.txt",old_string:"pending",new_string:answer.trim()});
-        if(index===3)gate();break;
-      case "recovery-stale-version":
-        if(index===0)call("edit",{path:"draft.txt",expected_sha256:digest("before\n"),old_string:"before",new_string:"after"});
-        if(index===1)call("read",{path:"draft.txt"});
-        if(index===2)call("edit",{path:"draft.txt",old_string:"before",new_string:"after"});
-        if(index===3)read();if(index===4)write();if(index===5)gate();break;
-      case "recovery-long-output":
-        if(index===0)read();
-        if(index===1)call("history",{artifact:required(/sha256: ([a-f0-9]{64})/),offset:4500});
-        if(index===2)write();if(index===3)gate();break;
-      case "recovery-api-mismatch":
-        if(index===0)call("exec_command",{cmd:"bun compat.ts --filter=safe",yield_time_ms:1000});
-        if(index===1)call("read",{path:"compat.ts"});
-        if(index===2)call("exec_command",{cmd:"bun compat.ts",yield_time_ms:1000});
-        if(index===3)gate();break;
-      case "recovery-closed-process":
-        if(index===0)call("exec_command",{cmd:"bun producer.ts",yield_time_ms:5000});
-        if(index===1)call("history",{recent:true,tool:"exec_command"});
-        if(index===2||index===3)call("write_stdin",{session_id:Number(required(/"session_id"\s*:\s*(\d+)/)),chars:index===2?"repeat\n":"",yield_time_ms:100});
-        if(index===4)write();if(index===5)gate();break;
-      case "recovery-unchanged-retry":
-        if(index===0||index===3)call("read",{path:"draft.txt"});
-        if(index===1||index===2)call("edit",{path:"draft.txt",old_string:"absent",new_string:index===1?"first":"second"});
-        if(index===4)call("edit",{path:"draft.txt",old_string:"present",new_string:"fixed"});
-        if(index===5)read();if(index===6)write();if(index===7)gate();break;
-      case "recovery-runtime-acceptance":
-        if(index===0||index===4)call("target",{action:"start",target:"preview",yield_time_ms:100});
-        if(index===1)read();if(index===2)write();
-        if(index===3)call("exec_command",{cmd:"bun run build",artifacts:{paths:["dist/app.js"],output_roots:["dist"]},yield_time_ms:1000});
-        if(index===5)gate();break;
-      case "recovery-eof":
-        if(index===0)call("read",{path:"source.txt",start:999});
-        if(index===1)read();if(index===2)write();if(index===3)gate();break;
-      default:throw Error("not a recovery fixture");
-    }
-    return {id:`recovery-${index}`,model:"eval-mechanical",choices:[{index:0,message:{role:"assistant",
-      content:calls.length?null:input.task==="recovery-runtime-acceptance"?"Preview preparation ended; the author's acceptance is pending.":"Recovery fixture finished.",
-      ...(calls.length?{tool_calls:calls.map((item,i)=>({id:`recovery-${index}-${i}`,type:"function",function:{name:item.name,arguments:JSON.stringify(item.input)}}))}:{})},
-      finish_reason:calls.length?"tool_calls":"stop"}],usage:{prompt_tokens:200,completion_tokens:32,prompt_cache_hit_tokens:0}};
-  };
-}

package/src/runtime/tool-mode-eval.ts

@@ -1,146 +0,0 @@
-/** Q.19: fixed workloads and admission overlays share production tools and the v2 auditor. */
-import { queryEvalVerifier } from "./query-eval-verifier.ts";
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import { seededRandom, type EvalJob } from "../core/experiment.ts";
-import { TOOL_MODE_TASKS, type ToolModeTask, type ToolModeMetrics } from "../core/tool-mode-protocol.ts";
-import { queryEvalContract } from "../core/query-eval-contract.ts";
-import { inputError } from "../core/tool-contract.ts";
-import type { LogEvent, ArtifactRef } from "../core/events.ts";
-import { readObservation } from "../store/observations.ts";
-import { TOOL_DEFINITIONS, modelToolSchema, type ToolContext } from "./tools.ts";
-import type { ToolSchema } from "./provider.ts";
-import type { ComparisonBackend } from "./harness-comparison.ts";
-import type { EvalFixture } from "./harness-eval.ts";
-
-const digest = (text: string) => createHash("sha256").update(text).digest("hex");
-export const TOOL_MODE_SYSTEM = "Solve the supplied data task using query over the complete source files. Preserve inputs and verifier. " +
-  "Use the declared query syntax. Inspect all failures and original evidence. " +
-  "Write only answer.txt, run bun run gate, and report the observed outcome. Do not delegate.";
-export interface ToolModeFixture {
-  answer: string;
-  queries: { path: string; json: Record<string, unknown>; sql: Record<string, unknown> }[];
-}
-export function toolModeFixture(seed: number, task: ToolModeTask, repeat: number): EvalFixture {
-  const random = seededRandom(seed + TOOL_MODE_TASKS.indexOf(task) * 1000 + repeat);
-  const count = task === "tool-batch" ? 8 : 1, rows = task === "tool-small" ? 1 : task === "tool-batch" ? 25 : 9000;
-  const files: Record<string, string> = {}, queries: ToolModeFixture["queries"] = [], expected: { path: string; rows: unknown[] }[] = [];
-  for (let i = 0; i < count; i++) {
-    const path = "data-" + i + ".jsonl", data = Array.from({ length: rows }, (_, row) => ({
-      team: "team" + row % 4, enabled: row % 3 !== 0, amount: 1 + Math.floor(random() * 97),
-    }));
-    files[path] = data.map(row => JSON.stringify(row)).join("\n") + "\n";
-    const base = { paths: [path], format: "jsonl" };
-    if (task === "tool-small") {
-      queries.push({ path, json: { ...base, select: ["amount"] }, sql: { ...base, sql: "SELECT amount FROM source" } });
-      expected.push({ path, rows: [{ amount: data[0]!.amount }] });
-    } else if (task === "tool-batch") {
-      queries.push({ path, json: { ...base, aggregate: [{ op: "sum", field: "amount", as: "total" }] }, sql: { ...base, sql: "SELECT SUM(amount) AS total FROM source" } });
-      expected.push({ path, rows: [{ total: data.reduce((n, row) => n + row.amount, 0) }] });
-    } else {
-      queries.push({ path, json: { ...base, where: [{ field: "enabled", op: "eq", value: true }], group_by: ["team"],
-        aggregate: [{ op: "sum", field: "amount", as: "total" }], order_by: [{ field: "team" }] },
-        sql: { ...base, sql: "SELECT team, SUM(amount) AS total FROM source WHERE enabled = TRUE GROUP BY team ORDER BY team" } });
-      // Independent fixture arithmetic; do not ask the query kernel to grade itself.
-      expected.push({ path, rows: Array.from({ length: 4 }, (_, n) => {
-        const team = "team" + n;
-        return { team, total: data.filter(row => row.enabled && row.team === team).reduce((sum, row) => sum + row.amount, 0) };
-      }) });
-    }
-  }
-  const answer = JSON.stringify(expected) + "\n", answerSha256 = digest(answer);
-  files["package.json"] = JSON.stringify({ scripts: { gate: "bun verify.ts" } }) + "\n";
-  const contract = queryEvalContract(task, queries.map(query => query.path), answerSha256);
-  files["verify.ts"] = queryEvalVerifier(contract);
-  return { task, repeat, files, digests: Object.fromEntries(Object.entries(files).map(([path, body]) => [path, digest(body)])),
-    answerSha256, prompts: [contract.instruction], toolMode: { answer, queries } };
-}
-export type ToolModeSchemas = Record<"json" | "sql", ToolSchema[]>;
-export function toolModeSchemas(): ToolModeSchemas {
-  const build = (syntax: "json" | "sql"): ToolSchema[] => {
-    const names = ["read", "query", "history", "write", "exec_command", "write_stdin", "note"];
-    return names.map(name => {
-      const definition = TOOL_DEFINITIONS.find(tool => tool.name === name)!;
-      if (name !== "query") return modelToolSchema(definition, names);
-      const schema = structuredClone(definition.input_schema) as ToolSchema["input_schema"] & { additionalProperties?: boolean };
-      const jsonKeys = ["where", "select", "group_by", "aggregate", "order_by"];
-      for (const key of syntax === "json" ? ["sql"] : jsonKeys) delete schema.properties[key];
-      if (syntax === "sql") schema.required.push("sql");
-      schema.additionalProperties = false;
-      return { name, description: definition.description + " This trial admits only " + syntax.toUpperCase() + " query syntax.", input_schema: schema };
-    });
-  };
-  return { json: build("json"), sql: build("sql") };
-}
-export const toolModeSchemaKey = (job: EvalJob): keyof ToolModeSchemas => job.policy.querySyntax === "sql" ? "sql" : "json";
-/** Schema visibility is not authority: the same frozen restriction runs before every admitted query. */
-export function toolModeHooks(schemas: readonly ToolSchema[]): NonNullable<ToolContext["extensionHooks"]> {
-  const query = schemas.find(schema => schema.name === "query")!;
-  return { async before(name, input) {
-    if (name !== "query") return undefined;
-    const error = inputError(query.input_schema, input);
-    const properties = (query.input_schema as { properties: Record<string, unknown> }).properties;
-    const extra = input && typeof input === "object" ? Object.keys(input).find(key => !Object.hasOwn(properties, key)) : undefined;
-    return error || extra ? "Frozen query syntax restriction: " + (error ?? "unsupported field " + extra) : undefined;
-  }, async event() {} };
-}
-/** Oracle driver tests the machinery; neither its answers nor call choices are model evidence. */
-export function toolModeBackend(input: EvalFixture): ComparisonBackend {
-  const fixture = input.toolMode!;
-  let step = 0;
-  return async payload => {
-    const declarations = payload["tools"] as { function: { name: string; parameters: { properties: Record<string, unknown> } } }[];
-    const syntax = declarations.find(tool => tool.function.name === "query")!.function.parameters.properties["sql"] ? "sql" : "json";
-    const calls: { name: string; input: unknown }[] = [], index = step++;
-    if (index === 0) {
-      for (const query of fixture.queries) calls.push({ name: "query", input: query[syntax] });
-    }
-    if (index === 1) {
-      const messages = payload["messages"] as { role: string; content?: unknown }[];
-      const observed = messages.filter(message => message.role === "tool").flatMap(message => {
-        const value = JSON.parse(String(message.content));
-        return [value];
-      }) as { sources: { path: string }[]; rows: unknown[] }[];
-      const answer = fixture.queries.map(query => {
-        const value = observed.find(value => value.sources?.length === 1 && value.sources[0]!.path === query.path);
-        if (!value) throw Error("mechanical driver lacks a successful source query receipt");
-        return { path: query.path, rows: value.rows };
-      });
-      calls.push({ name: "write", input: { path: "answer.txt", content: JSON.stringify(answer) + "\n" } });
-    }
-    if (index === 2) calls.push({ name: "exec_command", input: { cmd: "bun run gate", yield_time_ms: 1000 } });
-    return { id: "tool-mode-" + index, model: "eval-mechanical", choices: [{ index: 0, message: {
-      role: "assistant", content: calls.length ? null : "Mechanical protocol fixture finished.",
-      ...(calls.length ? { tool_calls: calls.map((call, i) => ({ id: "mode-" + index + "-" + i, type: "function",
-        function: { name: call.name, arguments: JSON.stringify(call.input) } })) } : {}),
-    }, finish_reason: calls.length ? "tool_calls" : "stop" }], usage: { prompt_tokens: 200, completion_tokens: 32, prompt_cache_hit_tokens: 0 } };
-  };
-}
-export async function toolModeMetrics(directory: string, input: EvalFixture, events: readonly LogEvent[], elapsedMs: number): Promise<ToolModeMetrics> {
-  if (!Number.isFinite(elapsedMs) || elapsedMs < 0) throw Error("missing tool mode elapsed observation");
-  const fixture = input.toolMode!, invocations = new Map(events.filter(event => event.t === "tool_invocation").map(event => [event.id, event]));
-  const sources = new Set<string>();
-  const original = async (ref: ArtifactRef): Promise<unknown> => {
-    const parts: Uint8Array[] = [];
-    for (let offset = 0;;) {
-      const page = await readObservation(join(directory, "observations"), ref.sha256, offset, 1024 * 1024);
-      parts.push(Buffer.from(page.base64, "base64"));
-      if (page.next === null) break;
-      offset = page.next;
-    }
-    return JSON.parse(Buffer.concat(parts).toString("utf8"));
-  };
-  for (const event of events) if (event.t === "tool_result" && event.ok && event.invocation_ref) {
-    const invocation = invocations.get(event.invocation_ref.event);
-    if (!invocation || invocation.call_id !== event.call_id || invocation.name !== "query") continue;
-    const value = event.data_ref ? await original(event.data_ref) : event.content_ref ? await original(event.content_ref) : event.data;
-    if (!value || typeof value !== "object" || !("sources" in value) || !Array.isArray(value.sources)) continue;
-    for (const source of value.sources as { path?: string; sha256?: string }[]) {
-      if (typeof source.path === "string" && fixture.queries.some(query => query.path === source.path) && input.digests[source.path] === source.sha256) sources.add(source.path);
-    }
-  }
-  const calls = [...invocations.values()], sourcePaths = [...sources].sort(), requiredSourcePaths = fixture.queries.map(query => query.path).sort();
-  return { elapsedMs, queryCalls: calls.filter(call => call.name === "query").length,
-    primitiveCalls: calls.length, sourcePaths, requiredSourcePaths,
-    sourceComplete: requiredSourcePaths.every(path => sources.has(path)) };
-}

package/src/runtime/trial-control.ts

@@ -1,45 +0,0 @@
-/** Q.14: an explicit signal owner records the first interruption independent of exception paths. */
-import type { TrialInterruption, TrialLifecycle } from "../core/trial-lifecycle.ts";
-
-/** A bad deadline must not strand the gateway acquired immediately before its clock starts. */
-export async function openTrialControl(timeoutMs:number,caller:AbortSignal|undefined,disposeOnFailure:()=>Promise<void>):Promise<TrialControl> {
-  try {return new TrialControl(timeoutMs,caller);}
-  catch(error){await disposeOnFailure();throw error;}
-}
-
-export class TrialControl {
-  private readonly controller=new AbortController();
-  readonly signal=this.controller.signal;
-  private readonly deadline:AbortSignal;
-  private readonly caller:AbortSignal|undefined;
-  private phase:TrialInterruption["phase"]="initialization";
-  private requests=0;
-  private interrupted:TrialInterruption|null=null;
-  private active=true;
-  private readonly onDeadline=()=>this.stop("deadline");
-  private readonly onCaller=()=>this.stop("caller");
-  constructor(timeoutMs:number,caller?:AbortSignal) {
-    this.deadline=AbortSignal.timeout(timeoutMs);this.caller=caller;
-    this.deadline.addEventListener("abort",this.onDeadline,{once:true});
-    caller?.addEventListener("abort",this.onCaller,{once:true});
-    // An already-cancelled caller precedes the newly-created local deadline.
-    if(caller?.aborted)this.onCaller();else if(this.deadline.aborted)this.onDeadline();
-  }
-  private stop(source:TrialInterruption["source"]):void {
-    if(!this.active||this.interrupted)return;
-    this.interrupted={source,phase:this.phase,backendRequests:this.requests};
-    this.controller.abort();
-  }
-  enterExecution():void {this.phase="execution";}
-  beginBackend():void {
-    if(!this.active||this.signal.aborted)throw Error("trial no longer accepts backend requests");
-    this.requests++;
-  }
-  finishWork():void {
-    this.active=false;
-    this.deadline.removeEventListener("abort",this.onDeadline);this.caller?.removeEventListener("abort",this.onCaller);
-  }
-  observe(cleanup:TrialLifecycle["cleanup"]):TrialLifecycle {
-    return {version:1,backendRequests:this.requests,interruption:this.interrupted?{...this.interrupted}:null,cleanup};
-  }
-}

package/src/runtime/window-trial.ts

@@ -1,141 +0,0 @@
-/** N.13: real sessions with independent file verdicts at every stage. */
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, dirname } from "node:path";
-import { createHash } from "node:crypto";
-import { verifyWindowArtifact, windowPrompt, type WindowFixture } from "../core/window-trial.ts";
-import type { BenchmarkPrice } from "../core/benchmark.ts";
-import { projectContext } from "../core/project.ts";
-import { readNodeHistory } from "../store/restore.ts";
-import { manifestPath, nodePath } from "../store/log.ts";
-import { Session, type SessionConfig } from "./loop.ts";
-import { buildRequest, OpenAICompletionsProvider } from "./openai.ts";
-import type { Provider, ProviderConfig } from "./provider.ts";
-import { COMPARISON_SYSTEM, COMPARISON_TOOLS, comparisonGateway, comparisonPayload, comparisonTools, type ComparisonBackend, type ComparisonLedger, type GatewayRecord } from "./harness-comparison.ts";
-import { DEFAULT_TOOL_CONTEXT } from "./tools.ts";
-
-const sha = (body: string) => createHash("sha256").update(body).digest("hex");
-export interface WindowStageResult {
-  stage: number; status: "answered" | "stopped" | "balance" | "error"; reason: string;
-  artifact: { ok: boolean; reason: string }; artifactSha256: string | null;
-  fullPageRead: boolean; inputsUnchanged: boolean; passed: boolean;
-  lastEvent: string | null; inputs: Record<string, string | null>;
-  requestBegin: number; requestEnd: number; nodeBefore: number; nodeAfter: number;
-  restart: { beforeSha256: string; afterSha256: string } | null;
-}
-export interface WindowTrialResult {
-  policy: "windowed" | "continuous"; planned: number; stages: WindowStageResult[]; unrun: number;
-  cuts: number; firstCutStage: number | null; restartedAt: number | null;
-  requests: number; knownCost: number; reservedUnknown: number; peakPrompt: number;
-  promptTokens: number; cacheTokens: number; outputTokens: number; prefixMutationsWithinNode: number;
-  toolExecutions: number; toolFailures: number; wallMs: number;
-  stopped: "budget" | "balance" | "error" | "limit" | null;
-}
-
-export async function runWindowTrial(options: {
-  directory: string; fixture: WindowFixture; policy: WindowTrialResult["policy"];
-  config: ProviderConfig; price: BenchmarkPrice; ledger: ComparisonLedger; backend: ComparisonBackend;
-  maxTurns: number; stageTimeoutMs: number; maxOutputBytes: number;
-  /** windowed restarts after its first cut; continuous uses that same stage. */
-  restartAfterStage?: number | null;
-  onProgress?: (event: Record<string, unknown>) => Promise<void>;
-}): Promise<WindowTrialResult> {
-  const started = performance.now(), workspace = join(options.directory, "workspace"), logDir = join(options.directory, "log");
-  await mkdir(workspace, { recursive: true }); await mkdir(logDir);
-  const result: WindowTrialResult = { policy: options.policy, planned: options.fixture.pages.length, stages: [], unrun: options.fixture.pages.length,
-    cuts: 0, firstCutStage: null, restartedAt: null, requests: 0, knownCost: 0, reservedUnknown: 0, peakPrompt: 0,
-    promptTokens: 0, cacheTokens: 0, outputTokens: 0, prefixMutationsWithinNode: 0, toolExecutions: 0, toolFailures: 0, wallMs: 0, stopped: null };
-  let stage = 0, lastNode: number | null = null, sentNode = 0;
-  const gateway = comparisonGateway({ config: options.config, price: options.price, ledger: options.ledger,
-    maxRequests: options.maxTurns * options.fixture.pages.length, backend: options.backend, record: async record => {
-      await appendFile(join(options.directory, "requests.jsonl"), JSON.stringify({ stage, node: sentNode, ...record }) + "\n");
-      if (record.kind === "settled") {
-        result.requests++;
-        if (record.measured === null) result.reservedUnknown += record.reservation; else result.knownCost += record.measured;
-        const usage = record.usage;
-        if (usage) {
-          const prompt = usage.input_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens;
-          result.peakPrompt = Math.max(result.peakPrompt, prompt); result.promptTokens += prompt;
-          result.cacheTokens += usage.cache_read_input_tokens; result.outputTokens += usage.output_tokens;
-        }
-        if (lastNode === sentNode && record.prefixUnchanged === false) result.prefixMutationsWithinNode++;
-        lastNode = sentNode;
-      }
-      await options.onProgress?.({ phase: record.kind, policy: options.policy, stage, request: record.request,
-        measured: record.measured, failure: record.failure, result });
-    } });
-  const config = { ...options.config, spec: { ...options.config.spec, baseUrl: gateway.url } };
-  const actual = new OpenAICompletionsProvider(config, gateway.token, { retry: { maxRetries: 0, maxRetryDelayMs: 0 } });
-  const sessionConfig: SessionConfig = { logDir, blobDir: join(options.directory, "blobs"),
-    frozen: { system: COMPARISON_SYSTEM, tools: comparisonTools() },
-    tools: { ...DEFAULT_TOOL_CONTEXT, root: workspace, allow: COMPARISON_TOOLS, maxOutputBytes: options.maxOutputBytes,
-      outputStore: join(options.directory, "observations") }, contextPolicy: options.policy, maxTurns: options.maxTurns, harnessReviews: false };
-  const provider: Provider = { config, async send(frozen, messages, node, signal, onDelta) {
-    sentNode = node;
-    await appendFile(join(options.directory, "dispatch.jsonl"), JSON.stringify({ stage, request: gateway.requests + 1, node,
-      lastEvent: session.state.events.at(-1)?.id,
-      inputSha256: sha(JSON.stringify(comparisonPayload(config, buildRequest(config, frozen, messages).messages, true))) }) + "\n");
-    return actual.send(frozen, messages, node, signal, onDelta);
-  } };
-  let session = new Session(sessionConfig, provider);
-  try {
-    await session.start();
-    for (const page of options.fixture.pages) {
-      if (options.ledger.halted) break;
-      stage = page.stage;
-      const file = join(workspace, page.path); await mkdir(dirname(file), { recursive: true });
-      await writeFile(file, page.body, { flag: "wx" });
-      const row: WindowStageResult = { stage, status: "stopped", reason: "no completion", artifact: { ok: false, reason: "not checked" },
-        artifactSha256: null, fullPageRead: false, inputsUnchanged: false, passed: false, lastEvent: null, inputs: {}, requestBegin: gateway.requests,
-        requestEnd: gateway.requests, nodeBefore: session.state.node, nodeAfter: session.state.node, restart: null };
-      const signal = AbortSignal.timeout(options.stageTimeoutMs);
-      try {
-        for await (const event of session.send(windowPrompt(options.fixture, stage), signal)) {
-          if (event.kind === "cut") { result.cuts++; result.firstCutStage ??= stage; }
-          if (event.kind === "tool_call") result.toolExecutions++;
-          if (event.kind === "tool_result" && event.ok === false) result.toolFailures++;
-          if (event.kind === "done") row.reason = event.reason ?? "unknown completion";
-        }
-        if (["stop", "end_turn"].includes(row.reason)) row.status = "answered";
-      } catch {
-        row.status = gateway.stopped === "balance" ? "balance" : "error";
-        row.reason = signal.aborted ? "stage deadline" : gateway.stopped === "balance" ? "upstream balance; awaiting topup" : "trial stopped on error";
-      }
-      row.nodeAfter = session.state.node; row.requestEnd = gateway.requests;
-      const body = await readFile(join(workspace, "ledger.json"), "utf8").catch(() => null);
-      row.artifact = verifyWindowArtifact(body, page.expected); row.artifactSha256 = body === null ? null : sha(body);
-      // Preserve failed outputs as well, before the next stage can repair them.
-      await writeFile(join(options.directory, `artifact-${stage}.json`), JSON.stringify({ body }), { flag: "wx" });
-      const history = await readNodeHistory(logDir, session.state.node, undefined, "context");
-      if (!history.ok) throw new Error(history.error);
-      const events = history.nodes.flatMap(node => node.events);
-      row.lastEvent = events.at(-1)?.id ?? null;
-      row.fullPageRead = events.some(event => event.t === "tool_result" && event.ok && event.effect?.kind === "read" &&
-        event.effect.path === page.path && event.effect.sha256 === sha(page.body) && event.effect.ranges?.some(range => range[0] === 1 && range[1] === page.body.split("\n").length) &&
-        // Archival is independent of truncation. Verify what the model actually received, including the middle.
-        event.content.includes(page.body.split("\n").map((line, index) => `${index + 1}\t${line}`).join("\n")));
-      for (const prior of options.fixture.pages.slice(0, stage + 1)) {
-        const content = await readFile(join(workspace, prior.path), "utf8").catch(() => null);
-        row.inputs[prior.path] = content === null ? null : sha(content);
-      }
-      row.inputsUnchanged = options.fixture.pages.slice(0, stage + 1).every(prior => row.inputs[prior.path] === sha(prior.body));
-      row.passed = row.status === "answered" && row.artifact.ok && row.fullPageRead && row.inputsUnchanged;
-      const restart = options.policy === "windowed" ? result.firstCutStage : options.restartAfterStage;
-      if (row.status === "answered" && result.restartedAt === null && restart === stage) {
-        const view = () => sha(JSON.stringify(projectContext({ frozen: session.config.frozen, handoff: session.state.handoff, events: session.state.events,
-          logHint: { manifestPath: manifestPath(logDir), segmentPath: nodePath(logDir, Math.max(0, session.state.node - 1)) } })));
-        const beforeSha256 = view(); session = new Session(sessionConfig, provider); await session.start();
-        row.restart = { beforeSha256, afterSha256: view() }; result.restartedAt = stage;
-        if (row.restart.beforeSha256 !== row.restart.afterSha256) throw new Error("restart changed the context projection");
-      }
-      result.stages.push(row); result.unrun = result.planned - result.stages.length;
-      await writeFile(join(options.directory, `stage-${stage}.json`), JSON.stringify(row, null, 2) + "\n", { flag: "wx" });
-      await options.onProgress?.({ phase: "stage", policy: options.policy, stage, result });
-      if (row.status !== "answered") break;
-    }
-  } finally { await gateway.close(); }
-  result.stopped = gateway.stopped; result.wallMs = performance.now() - started;
-  await writeFile(join(options.directory, "result.json"), JSON.stringify(result, null, 2) + "\n", { flag: "wx" });
-  return result;
-}
-
-export type WindowRequest = GatewayRecord & { stage: number; node: number };

package/src/store/git-branch.ts

@@ -1,35 +0,0 @@
-/**
- * Current git branch for the status line.
- *
- * I/O lives here because tui cannot do I/O. Failure is silent: a missing
- * binary, a directory that is not a repo, a detached HEAD, or a hang must
- * not throw and must not stall TUI attach -- the status line just omits
- * the branch.
- */
-
-/**
- * Assumed, not measured. `git symbolic-ref` is a local read; 200ms is long
- * enough for a cold disk and short enough that a hung credential helper
- * cannot freeze the first paint.
- */
-export const GIT_BRANCH_TIMEOUT_MS = 200;
-
-export function currentBranch(
-  cwd: string,
-  command = "git",
-  timeoutMs = GIT_BRANCH_TIMEOUT_MS,
-): string | null {
-  try {
-    const p = Bun.spawnSync([command, "symbolic-ref", "--short", "HEAD"], {
-      cwd,
-      timeout: timeoutMs,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (p.exitCode !== 0) return null;
-    const name = new TextDecoder().decode(p.stdout).trim();
-    return name.length > 0 ? name : null;
-  } catch {
-    return null;
-  }
-}

package/src/tui/ui/testing.ts

@@ -1,5 +0,0 @@
-/**
- * The headless renderer, re-exported so tests reach OpenTUI through the one
- * directory allowed to import it (scripts/check-boundaries.ts, D20).
- */
-export { createTestRenderer, type TestRendererSetup } from "@opentui/core/testing";