@visual-z/xeno 0.2.0 → 0.3.0

package/src/core/event-validation.ts

@@ -3,6 +3,14 @@ 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);
@@ -11,6 +19,7 @@ const strings = (value: unknown): boolean => Array.isArray(value) && value.every
 const stringMap = (value: unknown): boolean => isRecord(value) && Object.values(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" &&
@@ -27,6 +36,37 @@ export function isLogEvent(value: unknown): value is LogEvent {
   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["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 "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 "extension": return has("customType", "content") && typeof value["display"] === "boolean" && typeof value["inContext"] === "boolean" && (value["data"] === undefined || isJsonValue(value["data"]));
     case "user": return has("text");
     case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]);
@@ -40,7 +80,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
         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"].includes(String(value["reason"])) && strings(value["sources"]);
+    case "guidance": return has("text") && ["continuation", "repetition", "budget", "boundary", "stall", "output_recovery", "completion_review", "churn", "deadline", "runtime_acceptance"].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"])) &&
@@ -51,8 +91,34 @@ export function isLogEvent(value: unknown): value is LogEvent {
       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;
       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;
@@ -63,14 +129,19 @@ export function isLogEvent(value: unknown): value is LogEvent {
       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"]);
+        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") && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
+    case "cut": return has("handoff_ref") && (value["working_set_version"] === undefined || value["working_set_version"] === 1 || value["working_set_version"] === 2) && ["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)) &&
@@ -83,7 +154,9 @@ export function isLogEvent(value: unknown): value is LogEvent {
     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");
+    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"])) &&
@@ -93,6 +166,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
       strings(value["undeclared"]) && strings(value["declared_but_unchanged"]) && optionalString(value["workspace_sha256"]) &&
       (value["phase"] === undefined || value["phase"] === "turn" || value["phase"] === "idle");
     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"];
@@ -103,10 +177,11 @@ export function isLogEvent(value: unknown): value is LogEvent {
         if (!(workspace["kind"] === "shared_readonly" || (workspace["kind"] === "git_tree" &&
             typeof workspace["head"] === "string" && typeof workspace["tree"] === "string"))) return false;
       }
-      return validNodeRef(value["branch"]) && has("purpose") && (value["workspace"] === undefined ||
+      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);

package/src/core/events.ts

@@ -21,6 +21,11 @@
 import type { ExecutionOutcome } from "./outcome.ts";
 import type { ImageRef } from "./images.ts";
 import type { JsonValue, ToolDiagnostic } from "./tool-contract.ts";
+import type { AcceptanceContract } from "./acceptance.ts";
+import type { CheckpointEvent, WorkspaceObservationEvent } from "./checkpoints.ts";
+import type { ObservationReceipt } from "./read-observation.ts";
+import type { CommandArtifactReceipt } from "./command-artifacts.ts";
+import type { RuntimeTargetReceipt } from "./runtime-target.ts";
 
 export type EventId = string;
 export type Sha256 = string;
@@ -68,7 +73,7 @@ export type NodeRef = {
 export type Effect =
   | { kind: "read"; path: string; sha256: Sha256; ranges?: readonly LineRange[] }
   | { kind: "edit"; path: string; sha256_before: Sha256 | null; sha256_after: Sha256 }
-  | { kind: "command"; cmd: string; exit: number; gate?: string; workspace_sha256?: Sha256 };
+  | { kind: "command"; cmd: string; exit: number; gate?: string; workspace_sha256?: Sha256; workspace_observed?: boolean; workspace_scope?: "source-v1"; artifacts?: CommandArtifactReceipt };
 
 // ---------------------------------------------------------------------------
 // Harness-derived events
@@ -109,7 +114,7 @@ export interface GuidanceEvent {
   t: "guidance";
   id: EventId;
   at: IsoTime;
-  reason: "continuation" | "repetition" | "budget" | "boundary" | "stall" | "output_recovery" | "completion_review" | "churn" | "deadline";
+  reason: "continuation" | "repetition" | "budget" | "boundary" | "stall" | "output_recovery" | "completion_review" | "churn" | "deadline" | "runtime_acceptance";
   text: string;
   sources: readonly EventId[];
 }
@@ -167,6 +172,11 @@ export interface ToolResultEvent {
   id: EventId;
   at: IsoTime;
   call_id: string;
+  /** Trusted host execution has no provider tool_use and is excluded from provider replay. */
+  origin?: "extension";
+  /** Pi A: nested observations remain evidence without creating provider-visible tool pairs. */
+  parent_call_id?: string;
+  invocation_ref?: { node: number; event: EventId };
   ok: boolean;
   /** What the model sees. Large payloads belong on disk, referenced by effect. */
   content: string;
@@ -175,17 +185,36 @@ export interface ToolResultEvent {
   content_sha256?: Sha256;
   /** O.3: semantic observation digest excludes presentation metadata. */
   observation_sha256?: Sha256;
+  /** R2: exact preview coverage and immutable source identity; old logs omit this receipt. */
+  observation?: ObservationReceipt;
   content_ref?: ArtifactRef;
   effect?: Effect;
   /** O.1: actual termination, independent of effect/verification; legacy logs omit it. */
   outcome?: ExecutionOutcome;
   /** O.3: machine-readable observations and recovery hints, not additional proof. */
   data?: JsonValue;
+  /** Pi A: large structured results stay recoverable without bloating each JSONL event. */
+  data_ref?: ArtifactRef;
   diagnostic?: ToolDiagnostic;
+  /** Post-operation observer failures cannot erase the operation's factual result. */
+  warnings?: readonly ToolDiagnostic[];
 }
 
 export type ArtifactRef = { sha256: Sha256; path: string; bytes: number };
 
+/** Pi A: an invocation is durable before its admitted action may start. */
+export interface ToolInvocationEvent {
+  t: "tool_invocation"; id: EventId; at: IsoTime;
+  call_id: string; name: string; parent_call_id?: string;
+  origin?: "extension";
+  parent_ref?: { node: number; event: EventId };
+  /** Original request and the exact declarative contract are independently recoverable. */
+  input_ref: ArtifactRef;
+  schema_ref: ArtifactRef | null;
+  /** Bounded actual arguments; absent for a direct unchanged request or an oversized refusal. */
+  input?: JsonValue;
+}
+
 /** Terminates the segment it appears in. Carries refs only -- see rule 1 above. */
 export interface CutEvent {
   t: "cut";
@@ -205,6 +234,10 @@ export interface CutEvent {
   next_context_ref?: Sha256;
   /** V2 carried-state budget, fixed in the log for identical replay. */
   handoff_tokens?: number;
+  /** O.10: absent preserves the original D20 carried projection. */
+  working_set_version?: 1 | 2;
+  /** R10: declared builtin advice capabilities at this cut, not an authorization grant. Absent replays old text. */
+  guidance_tools?: readonly string[];
   /** N.8: first retained event on the effective ancestry; no copied transcript. */
   retained_from?: EventId;
 }
@@ -242,6 +275,7 @@ export interface DecisionEvent {
   chose: string;
   because: string;
   rejected?: readonly string[];
+  work_id?: string;
   /** Set when an adopt moved this event from another node. */
   carried_from?: CarriedFrom;
 }
@@ -252,6 +286,7 @@ export interface PitfallEvent {
   at: IsoTime;
   tried: string;
   failed_because: string;
+  work_id?: string;
   /** Set when an adopt moved this event from another node. */
   carried_from?: CarriedFrom;
 }
@@ -340,6 +375,8 @@ export interface RewindEvent {
   id: EventId;
   at: IsoTime;
   mode: RewindMode;
+  /** P.3: context navigation keeps the file history at this separate cursor. */
+  files_from?: NodeRef;
   /** Where things were moved back to. */
   from: NodeRef;
   /** The prompt that opened the exchange moved back to, for a human reader. */
@@ -368,6 +405,8 @@ export interface SpawnEvent {
   branch: NodeRef;
   /** What the branch is for, in one line. */
   purpose: string;
+  /** O.14: execution mode is durable; it never proves a live handle exists. */
+  background?: true;
   /** The isolated checkout belongs to this branch, including after restart. */
   workspace?: { path: string; branch: string };
   /** O.4: a task input envelope references the original request, never copies history. */
@@ -393,6 +432,8 @@ export interface JoinedEvent {
   branch: NodeRef;
   handoff_ref: string;
   summary: string;
+  /** O.9: artifact contains a deterministic evidence index, never raw history. */
+  receipt_ref?: Sha256;
   /** A branch can cut before joining; its last node need not be its root. */
   tip?: NodeRef;
   model?: string;
@@ -445,6 +486,7 @@ export interface NextActionEvent {
   what: string;
   work_id?: string;
   next_action: string;
+  depends_on?: readonly string[];
   /** Set when an adopt moved this event from another node. */
   carried_from?: CarriedFrom;
 }
@@ -462,6 +504,15 @@ export interface WorkStatusEvent {
   carried_from?: CarriedFrom;
 }
 
+export interface WorkDependenciesEvent {
+  t: "work_dependencies"; id: EventId; at: IsoTime; work_id: string; what: string;
+  depends_on: readonly string[]; carried_from?: CarriedFrom;
+}
+export interface WorkOwnerEvent {
+  t: "work_owner"; id: EventId; at: IsoTime; work_id: string; what: string;
+  operation: "claim" | "release"; owner: string; carried_from?: CarriedFrom;
+}
+
 /** O.6: a model associates an original observation with work; the runtime resolves its source. */
 export interface EvidenceLinkEvent {
   t: "evidence_link"; id: EventId; at: IsoTime;
@@ -479,7 +530,38 @@ export interface ExtensionEvent {
   data?: import("./tool-contract.ts").JsonValue;
 }
 
+export interface AcceptanceContractEvent {
+  t: "acceptance_contract"; id: EventId; at: IsoTime; request: EventId;
+  contract: AcceptanceContract;
+}
+export interface AcceptanceDecisionEvent {
+  t: "acceptance_decision"; id: EventId; at: IsoTime; request: EventId;
+  contract_id: string; criterion: string; actor: "user";
+  target_binding?: string; target_observation?: EventId;
+}
+export interface TargetObservationEvent {
+  t: "target_observation"; id: EventId; at: IsoTime; observation: RuntimeTargetReceipt;
+}
+
+export interface SkillLoadedEvent {
+  t: "skill_loaded"; id: EventId; at: IsoTime; name: string; path: string;
+  sha256: Sha256; artifact: Sha256; mode: "inline" | "fork" | "read"; origin: "user" | "model";
+}
+
+/** O.14: owner cleanup is an actual process observation, not a model claim. */
+export interface ProcessExitEvent {
+  t: "process_exit"; id: EventId; at: IsoTime; session: number;
+  command: string; exit: number; output: ArtifactRef; reason: "disposed";
+  receipt?: import("./process-receipt.ts").ProcessReceipt;
+}
+
 export type LogEvent =
+  | ToolInvocationEvent
+  | ProcessExitEvent
+  | SkillLoadedEvent
+  | AcceptanceContractEvent
+  | AcceptanceDecisionEvent
+  | TargetObservationEvent
   | ExtensionEvent
   | UserEvent
   | UserBashEvent
@@ -491,6 +573,8 @@ export type LogEvent =
   | EvidenceLinkEvent
   | CutEvent
   | SnapshotEvent
+  | CheckpointEvent
+  | WorkspaceObservationEvent
   | RewindEvent
   | SpawnEvent
   | JoinedEvent
@@ -502,12 +586,21 @@ export type LogEvent =
   | BlockedEvent
   | QuestionEvent
   | NextActionEvent
-  | WorkStatusEvent;
+  | WorkStatusEvent
+  | WorkDependenciesEvent
+  | WorkOwnerEvent;
+// Work coordination is intent, never a substitute for command proof.
 
 export const HARNESS_EVENTS = [
+  "checkpoint", "workspace_observation",
+  "target_observation",
+  "process_exit",
+  "skill_loaded",
+  "acceptance_contract", "acceptance_decision",
   "user", "user_bash", "outcome", "guidance", "interrupt", "assistant", "tool_result", "cut", "snapshot", "rewind", "extension",
 ] as const;
 export const MODEL_EVENTS = [
+  "work_dependencies", "work_owner",
   "claim", "decision", "pitfall", "blocked", "question", "next_action", "work_status", "evidence_link",
   "spawn", "joined", "adopt", "discard",
 ] as const;
@@ -519,6 +612,7 @@ export const MODEL_EVENTS = [
  * ancestry or are parent actions the branch should not inherit.
  */
 export const CARRYABLE_EVENTS = [
+  "work_dependencies", "work_owner",
   "claim", "decision", "pitfall", "blocked", "question", "next_action", "work_status", "evidence_link",
 ] as const;
 

package/src/core/evidence-links.ts

@@ -36,6 +36,9 @@ export function observedVersion(events: readonly LogEvent[], resource: string):
       if (event.removed.map(resourceKey).includes(resource)) version = null;
       for (const [path, value] of Object.entries({ ...event.added, ...event.changed })) if (resourceKey(path) === resource) version = value;
     }
+    if (event.t === "checkpoint" && event.phase === "applied") for (const [path, change] of Object.entries(event.changes)) {
+      if (resourceKey(path) === resource) version = change.after?.sha256 ?? null;
+    }
   }
   return version;
 }
@@ -65,6 +68,10 @@ export function deriveEvidenceLinks(previous: readonly EvidenceLink[], events: r
           if (resourceKey(path) === link.resource) link.freshness = version === link.version ? "current" : "stale";
         }
       }
+      if (event.t === "checkpoint" && event.phase === "applied") for (const [path, change] of Object.entries(event.changes)) {
+        if (resourceKey(path) === link.resource) link.freshness = change.after?.sha256 === link.version ? "current" : "stale";
+      }
+      if (event.t === "workspace_observation" && event.changed || event.t === "checkpoint" && event.phase === "unavailable") link.freshness = "unknown";
     }
   }
   return links;

package/src/core/evidence.ts

@@ -1,6 +1,7 @@
 /** Shared executed-evidence rules for handoff derivation and the turn watchdog. */
 import type { EvidenceQuery, LogEvent, ToolResultEvent } from "./events.ts";
 import type { Evidence } from "./handoff.ts";
+import { changedPaths } from "./checkpoints.ts";
 
 type CommandEffect = Extract<NonNullable<ToolResultEvent["effect"]>, { kind: "command" }>;
 export type CommandResult = ToolResultEvent & { effect: CommandEffect };
@@ -15,9 +16,14 @@ export function evidenceStale(events: readonly LogEvent[], evidence: Evidence, i
   let stale = initially;
   for (const event of events.slice(start + 1)) {
     if (event.t === "tool_result" && event.effect?.kind === "edit") stale = true;
-    const sha = event.t === "snapshot" ? event.workspace_sha256
+    if (event.t === "checkpoint" && (event.phase === "unavailable" || event.phase === "applied" && changedPaths(event.changes).length > 0)) stale = true;
+    if (event.t === "workspace_observation" && event.fingerprint === undefined ||
+        event.t === "tool_result" && event.effect?.kind === "command" && event.effect.workspace_observed === false || event.t === "user_bash") stale = true;
+    const sha = event.t === "workspace_observation" ? event.fingerprint : event.t === "snapshot" ? event.workspace_sha256
       : event.t === "tool_result" && event.effect?.kind === "command" ? event.effect.workspace_sha256 : undefined;
-    if (sha !== undefined && evidence.workspace_sha256 !== undefined) stale = sha !== evidence.workspace_sha256;
+    const scope = event.t === "workspace_observation" ? event.scope : event.t === "tool_result" && event.effect?.kind === "command" ? event.effect.workspace_scope : undefined;
+    if (sha !== undefined && evidence.workspace_sha256 !== undefined) stale = evidence.workspace_scope === "source-v1"
+      ? stale || scope !== evidence.workspace_scope || sha !== evidence.workspace_sha256 : scope !== undefined || sha !== evidence.workspace_sha256;
     else if (event.t === "snapshot" && (Object.keys(event.added).length + Object.keys(event.changed).length + event.removed.length > 0)) stale = true;
   }
   return stale;
@@ -33,7 +39,9 @@ export function resolveEvidence(events: readonly LogEvent[], query: EvidenceQuer
   const result = events.slice(start).findLast(event => isCommandResult(event) && matchesQuery(query, event.effect));
   if (!result || !isCommandResult(result)) return { ok: false, reason: "no_matching_event" };
   if (result.effect.exit !== 0) return { ok: false, reason: "nonzero_exit", exit: result.effect.exit };
+  if (result.effect.workspace_observed === false) return { ok: false, reason: "stale_workspace" };
   const evidence: Evidence = { command: result.effect.cmd, exit: result.effect.exit, at: result.at, event_id: result.id,
+    ...(result.effect.workspace_scope ? { workspace_scope: result.effect.workspace_scope } : {}),
     ...(result.effect.gate !== undefined ? { gate: result.effect.gate } : {}),
     ...(result.effect.workspace_sha256 ? { workspace_sha256: result.effect.workspace_sha256 } : {}) };
   return evidenceStale(events, evidence) ? { ok: false, reason: "stale_workspace" } : { ok: true, evidence };
@@ -44,8 +52,9 @@ export function eligibleProgressChecks(events: readonly LogEvent[], claimed: Rea
   for (const event of events) {
     if (!isCommandResult(event)) continue;
     const gate = event.effect.gate;
-    if (event.effect.exit !== 0 || (gate === undefined && !claimed.has(event.id)) || (gate !== undefined && failingGates.has(gate))) continue;
+    if (event.effect.exit !== 0 || event.effect.workspace_observed === false || (gate === undefined && !claimed.has(event.id)) || (gate !== undefined && failingGates.has(gate))) continue;
     if (!evidenceStale(events, { command: event.effect.cmd, exit: 0, at: event.at, event_id: event.id,
+      ...(event.effect.workspace_scope ? { workspace_scope: event.effect.workspace_scope } : {}),
       ...(event.effect.workspace_sha256 === undefined ? {} : { workspace_sha256: event.effect.workspace_sha256 }) })) eligible.add(event.id);
   }
   return eligible;
@@ -74,6 +83,7 @@ export function classifyGate(gates: Readonly<Record<string, string>>, command: s
   if (tokens.some((t) => informational.includes(t))) return undefined;
   let i = 0;
   const first = tokens[0];
+  if (["bun", "npm", "pnpm", "yarn"].includes(first ?? "") && tokens[1] === "test") return gates["test"];
   if (first === "python" || first === "python3") {
     if (tokens[1] !== "-m") return undefined;
     i = 2;

package/src/core/execution.ts

@@ -1,11 +1,17 @@
 /** D5/D11: incomplete execution is unknown, never an instruction to run twice. */
 import type { LogEvent, AssistantBlock } from "./events.ts";
 
-export function pendingToolCalls(events: readonly LogEvent[]): Extract<AssistantBlock, { type: "tool_use" }>[] {
-  const pending = new Map<string, Extract<AssistantBlock, { type: "tool_use" }>>();
+export type PendingToolCall = Extract<AssistantBlock, { type: "tool_use" }> & { parent_call_id?: string; invocation_id?: string; origin?: "extension" };
+export function pendingToolCalls(events: readonly LogEvent[]): PendingToolCall[] {
+  const pending = new Map<string, PendingToolCall>();
   for (const event of events) {
     if (event.t === "assistant") {
       for (const block of event.blocks) if (block.type === "tool_use") pending.set(block.call_id, block);
+    } else if (event.t === "tool_invocation") {
+      const existing = pending.get(event.call_id);
+      pending.set(event.call_id, { type: "tool_use", call_id: event.call_id, name: event.name, input: event.input ?? existing?.input ?? null,
+        invocation_id: event.id, ...(event.origin ? { origin: event.origin } : {}),
+        ...(event.parent_call_id ? { parent_call_id: event.parent_call_id } : {}) });
     } else if (event.t === "tool_result") pending.delete(event.call_id);
   }
   return [...pending.values()];

package/src/core/experiment.ts

@@ -1,5 +1,9 @@
 /** Experimental projections never mutate the durable event stream (D8, L). */
 import type { Message } from "./project.ts";
+import { isTrialLifecycle, type TrialLifecycle } from "./trial-lifecycle.ts";
+import { RECOVERY_TASKS, recoveryCase, type RecoveryTask } from "./recovery-corpus.ts";
+import { isRecoveryMetrics, type RecoveryMetrics } from "./recovery-evaluation.ts";
+import { TOOL_MODE_FACTORS, TOOL_MODE_TASKS, isToolModeTask, isToolModeMetrics, type ToolModeTask, type ToolModeMetrics } from "./tool-mode-protocol.ts";
 
 export type ContextArm = "node" | "replay" | "truncate" | "mask";
 
@@ -38,3 +42,132 @@ export function shuffled<T>(items: readonly T[], seed: number): T[] {
   }
   return out;
 }
+
+/** O.16: each contrast changes exactly one policy, with paired task repeats. */
+export const EVAL_FACTORS = ["profile", "workingSet", "strictVerification"] as const;
+export const EVAL_TASKS = ["short", "boundary-recall", "false-completion", "human-boundary"] as const;
+const supportedFactors = [...EVAL_FACTORS, ...TOOL_MODE_FACTORS] as const;
+export type EvalFactor = typeof supportedFactors[number];
+export type EvalTask = typeof EVAL_TASKS[number] | RecoveryTask | ToolModeTask;
+const supportedTasks:readonly EvalTask[]=[...EVAL_TASKS,...RECOVERY_TASKS,...TOOL_MODE_TASKS];
+export type EvalArm = "control" | "treatment";
+export type EvalPolicy = { profile: "full" | "coding"; workingSet: boolean; strictVerification: boolean; querySyntax?: "json" | "sql" };
+export type EvalJob = { id: string; factor: EvalFactor; task: EvalTask; repeat: number; arm: EvalArm; policy: EvalPolicy };
+export function evalPolicy(factor: EvalFactor, arm: EvalArm): EvalPolicy {
+  const policy: EvalPolicy = { profile: "coding", workingSet: true, strictVerification: true };
+  if (factor === "querySyntax") return { ...policy, querySyntax: arm === "treatment" ? "sql" : "json" };
+  if (arm === "control") {
+    if (factor === "profile") policy.profile = "full";
+    else policy[factor] = false;
+  }
+  return policy;
+}
+export function singleFactorSchedule(seed: number, repeats = 1, tasks: readonly EvalTask[] = EVAL_TASKS, factors: readonly EvalFactor[] = EVAL_FACTORS): EvalJob[] {
+  if (!Number.isSafeInteger(seed) || !Number.isSafeInteger(repeats) || repeats < 1 || repeats > 20 || !tasks.length ||
+      new Set(tasks).size !== tasks.length || tasks.some(task => !supportedTasks.includes(task)) || !factors.length || new Set(factors).size !== factors.length ||
+      factors.some(factor => !supportedFactors.includes(factor) || tasks.some(task => isToolModeTask(task) !== (TOOL_MODE_FACTORS as readonly string[]).includes(factor)))) throw new RangeError("invalid eval schedule");
+  const pairs = shuffled(factors.flatMap(factor => [...tasks].sort().flatMap(task =>
+    Array.from({ length: repeats }, (_, repeat) => ({ factor, task, repeat })))), seed);
+  // Alternate first position before shuffling: adjacent LCG seeds are correlated.
+  const positions = new Map<EvalFactor, number>();
+  const order = shuffled(["control", "treatment"] as const, seed + 1);
+  return pairs.flatMap(pair => {
+    const offset = positions.get(pair.factor) ?? 0; positions.set(pair.factor, offset + 1);
+    return order.map((_, i) => {
+      const arm = order[(offset + i) % 2]!;
+      return { ...pair, arm, id: `${pair.factor}/${pair.task}/${pair.repeat}/${arm}`, policy: evalPolicy(pair.factor, arm) };
+    });
+  });
+}
+export function validateEvalJobs(jobs: readonly EvalJob[]): void {
+  const seen = new Set<string>();
+  for (const job of jobs) {
+    if (!supportedFactors.includes(job.factor) || !supportedTasks.includes(job.task) || !["control", "treatment"].includes(job.arm) ||
+        isToolModeTask(job.task) !== (TOOL_MODE_FACTORS as readonly string[]).includes(job.factor) ||
+        !Number.isSafeInteger(job.repeat) || job.repeat < 0 || job.id !== `${job.factor}/${job.task}/${job.repeat}/${job.arm}` || seen.has(job.id) ||
+        JSON.stringify(job.policy) !== JSON.stringify(evalPolicy(job.factor, job.arm))) throw new Error("invalid or confounded eval job");
+    seen.add(job.id);
+  }
+  for (const job of jobs) if (!seen.has(`${job.factor}/${job.task}/${job.repeat}/${job.arm === "control" ? "treatment" : "control"}`)) throw new Error("unpaired eval job");
+}
+export interface EvalResult {
+  toolMode?: ToolModeMetrics;
+  recovery?: RecoveryMetrics;
+  /** v2 separates an unmet final state from a machine-readable unsupported claim. */
+  unverifiedEnding?: boolean;
+  /** Absent in the frozen O.16 archives; absence is unknown, not an uninterrupted run. */
+  lifecycle?: TrialLifecycle;
+  id: string;
+  status: "finished" | "error" | "budget" | "stopped";
+  scenarioPassed: boolean;
+  artifactCorrect: boolean;
+  verified: boolean;
+  awaitingHuman: boolean;
+  falseCompletion: boolean;
+  requests: number;
+  toolFailures: number;
+  repeatedReads: number;
+  promptTokens: number | null;
+  cacheTokens: number | null;
+  outputTokens: number | null;
+  costUsd: number | null;
+  reservedUnknownUsd: number;
+}
+export function summarizeSingleFactor(jobs: readonly EvalJob[], results: readonly EvalResult[]) {
+  validateEvalJobs(jobs);
+  const byId = new Map<string, EvalResult>(), planned = new Set(jobs.map(job => job.id));
+  for (const row of results) {
+    if (row.toolMode !== undefined && (!isToolModeMetrics(row.toolMode) || row.scenarioPassed && !row.toolMode.sourceComplete)) throw Error("invalid tool mode metrics");
+    if (row.unverifiedEnding !== undefined && typeof row.unverifiedEnding !== "boolean") throw Error("invalid ending metric");
+    if(row.recovery!==undefined&&(!isRecoveryMetrics(row.recovery)||row.recovery.finalTaskSuccess!==row.scenarioPassed||row.recovery.toolFailures!==row.toolFailures||row.falseCompletion!==(row.recovery.unsupportedClaims>0)))throw Error("invalid recovery metrics");
+    if (row.lifecycle !== undefined && (!isTrialLifecycle(row.lifecycle) || row.lifecycle.backendRequests > row.requests ||
+        row.lifecycle.interruption !== null && row.status === "finished" || row.lifecycle.cleanup === "failed" && row.status !== "error"))
+      throw new Error("invalid eval lifecycle result");
+    if (!planned.has(row.id) || byId.has(row.id) || !["finished", "error", "budget", "stopped"].includes(row.status) ||
+        [row.scenarioPassed, row.artifactCorrect, row.verified, row.awaitingHuman, row.falseCompletion].some(value => typeof value !== "boolean") ||
+        row.scenarioPassed && (row.status !== "finished" || !row.verified || row.falseCompletion && row.recovery === undefined) ||
+        [row.requests, row.toolFailures, row.repeatedReads].some(n => !Number.isSafeInteger(n) || n < 0) ||
+        [row.promptTokens, row.cacheTokens, row.outputTokens].some(n => n !== null && (!Number.isSafeInteger(n) || n < 0)) ||
+        [row.costUsd, row.reservedUnknownUsd].some(n => n !== null && (!Number.isFinite(n) || n < 0)) ||
+        row.cacheTokens !== null && row.promptTokens !== null && row.cacheTokens > row.promptTokens) throw new Error("invalid or duplicate eval result");
+    byId.set(row.id, row);
+  }
+  const factors = supportedFactors.filter(factor => jobs.some(job => job.factor === factor));
+  const arms = factors.flatMap(factor => (["control", "treatment"] as const).map(arm => {
+    const selected = jobs.filter(job => job.factor === factor && job.arm === arm), rows = selected.flatMap(job => byId.has(job.id) ? [byId.get(job.id)!] : []);
+    const complete = rows.length === selected.length, scenarioPassed = rows.filter(row => row.scenarioPassed).length;
+    const knownCostSubtotal = rows.reduce((sum, row) => sum + (row.costUsd ?? 0), 0);
+    // Missing jobs and unknown charges cannot become a zero-priced success.
+    const costUsd = complete && rows.length > 0 && rows.every(row => row.costUsd !== null) ? knownCostSubtotal : null;
+    const total = (field: "promptTokens" | "cacheTokens" | "outputTokens") => complete && rows.length > 0 && rows.every(row => row[field] !== null)
+      ? rows.reduce((sum, row) => sum + row[field]!, 0) : null;
+    const recovery=selected.some(job=>recoveryCase(job.task)||isToolModeTask(job.task))?{observed:rows.filter(row=>row.recovery).length,
+      missing:selected.length-rows.filter(row=>row.recovery).length,
+      firstToolSuccess:rows.filter(row=>row.recovery?.firstToolSuccess===true).length,
+      firstPassTaskSuccess:rows.filter(row=>row.recovery?.firstPassTaskSuccess===true).length,
+      ...Object.fromEntries((["toolCalls","outerCalls","nestedCalls","unresolvedCalls","recoveryCalls","unchangedFailureRetries","originalEvidenceRetrievals","unsupportedClaims"] as const)
+        .map(key=>[key,rows.reduce((n,row)=>n+(row.recovery?.[key]??0),0)]))}:undefined;
+    return { factor, arm, ...(recovery?{recovery}:{}), planned: selected.length, attempted: rows.length, missing: selected.length - rows.length,
+      failed: rows.filter(row => !row.scenarioPassed).length, scenarioPassed, verified: rows.filter(row => row.verified).length,
+      awaitingHuman: rows.filter(row => row.awaitingHuman).length, falseCompletions: rows.filter(row => row.falseCompletion).length,
+      plannedPassFraction: selected.length ? scenarioPassed / selected.length : null, complete,
+      requests: rows.reduce((n, row) => n + row.requests, 0), toolFailures: rows.reduce((n, row) => n + row.toolFailures, 0),
+      repeatedReads: rows.reduce((n, row) => n + row.repeatedReads, 0), promptTokens: total("promptTokens"), cacheTokens: total("cacheTokens"), outputTokens: total("outputTokens"),
+      knownCostSubtotal, costUsd, unknownCostJobs: rows.filter(row => row.costUsd === null).length,
+      reservedUnknownUsd: rows.reduce((n, row) => n + row.reservedUnknownUsd, 0),
+      costPerScenarioSuccess: costUsd !== null && scenarioPassed > 0 ? costUsd / scenarioPassed : null };
+  }));
+  const comparisons = factors.map(factor => {
+    const pairs = jobs.filter(job => job.factor === factor && job.arm === "control");
+    const clusters = [...new Set(pairs.map(job => job.task))].sort().map(task => {
+      const matched = pairs.filter(job => job.task === task).flatMap(job => {
+        const control = byId.get(job.id), treatment = byId.get(`${factor}/${task}/${job.repeat}/treatment`);
+        return control && treatment ? [{ delta: Number(treatment.scenarioPassed) - Number(control.scenarioPassed) }] : [];
+      });
+      return { task, matchedPairs: matched.length, passDelta: matched.length ? matched.reduce((n, pair) => n + pair.delta, 0) / matched.length : null };
+    });
+    const matchedPairs = clusters.reduce((n, row) => n + row.matchedPairs, 0);
+    return { factor, matchedPairs, missingPairs: pairs.length - matchedPairs, clusters };
+  });
+  return { arms, comparisons };
+}