@visual-z/xeno 0.7.2 → 0.8.0

package/src/core/acceptance.ts

@@ -2,11 +2,17 @@
 import type { LogEvent } from "./events.ts";
 import type { Evidence } from "./handoff.ts";
 import { evidenceStale } from "./evidence.ts";
-import { changedPaths } from "./checkpoints.ts";
+import { workspaceChanged } from "./checkpoints.ts";
 import { parseRuntimeTarget, type RuntimeTarget, type TargetAcceptance } from "./runtime-target.ts";
 
+/**
+ * A command criterion either tests the change -- it fails before the work and
+ * passes after it (SWE-bench's FAIL_TO_PASS) -- or, with `guard`, protects
+ * what the work must not break: it passes before and after (PASS_TO_PASS),
+ * such as "the test file is unchanged" (S.7).
+ */
 export type AcceptanceCriterion = { id: string; description: string } &
-  ({ kind: "command"; command: string } | { kind: "human"; target?: string });
+  ({ kind: "command"; command: string; guard?: true } | { kind: "human"; target?: string });
 export type AcceptanceContract = { version: 1; id: string; scope?: "request" | "changes"; criteria: AcceptanceCriterion[];
   source?: { path: string; sha256: string }; targets?: RuntimeTarget[] };
 export type AcceptanceState = {
@@ -15,6 +21,13 @@ export type AcceptanceState = {
   targets?: TargetAcceptance[];
   status: "needs_work" | "awaiting_human" | "verified" | "not_applicable";
 };
+/**
+ * The longest check command a contract accepts. Drafted checks are often one
+ * inline script (`python3 -c '...'`); a real 599-character structure check
+ * was refused at the earlier 500 (fix-goal-read-only-draft). Bounded so a
+ * frozen contract stays small.
+ */
+export const ACCEPTANCE_COMMAND_LIMIT = 2000;
 const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
 const label = (value: unknown, max: number) => typeof value === "string" && value.trim().length > 0 && value.length <= max;
 
@@ -27,10 +40,12 @@ export function parseAcceptanceContract(value: unknown): AcceptanceContract {
   if (source !== undefined && (!record(source) || !label(source["path"], 4096) || typeof source["sha256"] !== "string" || !/^[a-f0-9]{64}$/.test(source["sha256"]))) throw new Error("invalid acceptance source");
   const criteria: AcceptanceCriterion[] = value["criteria"].map((item: unknown) => {
     if (!record(item) || !label(item["id"], 80) || !label(item["description"], 300)) throw new Error("invalid acceptance criterion");
-    if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/.test(String(item["id"])) || Object.keys(item).some(key => !["id", "description", "kind", "command", "target"].includes(key))) throw new Error("unsupported acceptance criterion field or ID");
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/.test(String(item["id"])) || Object.keys(item).some(key => !["id", "description", "kind", "command", "target", "guard"].includes(key))) throw new Error("unsupported acceptance criterion field or ID");
     const fields = { id: String(item["id"]), description: String(item["description"]) };
-    if (item["kind"] === "human" && item["command"] === undefined && (item["target"] === undefined || label(item["target"], 80))) return { ...fields, kind: "human", ...(item["target"] ? { target: String(item["target"]) } : {}) };
-    if (item["kind"] === "command" && item["target"] === undefined && label(item["command"], 500)) return { ...fields, kind: "command", command: String(item["command"]) };
+    if (item["kind"] === "human" && item["command"] === undefined && item["guard"] === undefined && (item["target"] === undefined || label(item["target"], 80))) return { ...fields, kind: "human", ...(item["target"] ? { target: String(item["target"]) } : {}) };
+    if (item["kind"] === "command" && item["target"] === undefined && label(item["command"], ACCEPTANCE_COMMAND_LIMIT) && (item["guard"] === undefined || item["guard"] === true)) {
+      return { ...fields, kind: "command", command: String(item["command"]), ...(item["guard"] === true ? { guard: true as const } : {}) };
+    }
     throw new Error("acceptance criterion must declare a command or human decision");
   });
   if (new Set(criteria.map(item => item.id)).size !== criteria.length) throw new Error("duplicate acceptance criterion IDs");
@@ -46,6 +61,26 @@ export function parseAcceptanceContract(value: unknown): AcceptanceContract {
     ...(value["scope"] ? { scope: value["scope"] as "request" | "changes" } : {}) };
 }
 
+/**
+ * What one counter-check observation means (S.1, S.7): the check run once more
+ * in a clone with the request's changes undone. A check that tests the change
+ * must fail there; a guard must still pass there. The log records only the
+ * exit code and the role it ran under, so every view derives the verdict here
+ * and none can disagree with another.
+ *
+ *   tests the change   fails there: discriminating   passes there: vacuous
+ *   guard              passes there: held            fails there: not_held
+ *
+ * A guard that did not hold is not a defect in the evidence: the check does
+ * test the change, only its declaration was wrong.
+ */
+export type CounterVerdict = "discriminating" | "vacuous" | "held" | "not_held" | "unavailable";
+export function counterVerdict(observation: { guard?: true } & ({ exit: number } | { reason: string })): CounterVerdict {
+  if (!("exit" in observation)) return "unavailable";
+  if (observation.guard) return observation.exit === 0 ? "held" : "not_held";
+  return observation.exit === 0 ? "vacuous" : "discriminating";
+}
+
 export function deriveAcceptance(previous: AcceptanceState | undefined, events: readonly LogEvent[]): AcceptanceState | undefined {
   let state = previous ? { ...previous, criteria: previous.criteria.map(item => ({ ...item })), ...(previous.targets ? { targets: previous.targets.map(target => ({ ...target })) } : {}) } : undefined;
   for (const event of events) {
@@ -56,10 +91,7 @@ export function deriveAcceptance(previous: AcceptanceState | undefined, events:
       continue;
     }
     if (!state) continue;
-    const mutation = event.t === "tool_result" && event.effect?.kind === "edit" && event.effect.sha256_before !== event.effect.sha256_after ||
-      event.t === "snapshot" && Object.keys(event.added).length + Object.keys(event.changed).length + event.removed.length > 0 ||
-      event.t === "checkpoint" && event.phase === "applied" && changedPaths(event.changes).length > 0 ||
-      event.t === "workspace_observation" && event.changed;
+    const mutation = workspaceChanged(event);
     if (mutation) { state.changed = true; for (const target of state.targets ?? []) target.status = "stale"; }
     if (event.t === "target_observation" && event.observation.request === state.request && event.observation.contract_event === state.contract_event) {
       const target = state.targets?.find(item => item.id === event.observation.target), receipt = event.observation;

package/src/core/blind-checks.ts

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

package/src/core/branch-receipt.ts

@@ -2,6 +2,7 @@
 import type { LogEvent, NodeRef } from "./events.ts";
 import type { Handoff } from "./handoff.ts";
 import type { ExecutionOutcome } from "./outcome.ts";
+import { deriveRequestState } from "./request-state.ts";
 
 export function deriveBranchReceipt(input: {
   source: NodeRef; outcome: ExecutionOutcome; handoff: Handoff;
@@ -16,7 +17,8 @@ export function deriveBranchReceipt(input: {
   const unfinished = (input.handoff.state.work_items ?? []).filter(item => item.status === "active" || item.status === "blocked")
     .map(item => ({ work_id: item.id, status: item.status, next_action: item.next_action ?? null }));
   return { version: 1, source: input.source, execution: input.outcome,
-    verification: commands.length === 0 ? "not_recorded" : commands.some(command => command.exit === 0) ? "command_succeeded" : "commands_failed",
+    // S.1: the child's request ledger, the same verdict any request view shows.
+    verification: deriveRequestState(input.nodes)?.status ?? "not_applicable",
     task_acceptance: "not_assessed", commands, changes, observations, unfinished,
     ...(input.handoff.processes?.length ? { processes: input.handoff.processes } : {}),
     unresolved_branches: input.handoff.branches.filter(b => b.resolution === null).map(b => b.node),

package/src/core/checkpoints.ts

@@ -22,6 +22,8 @@ export interface WorkspaceObservationEvent {
   scope: "source-v1";
   changed: boolean;
   reason?: string;
+  /** The workspace as a goal request began: the state a counter-check must revert to exactly. */
+  baseline?: true;
 }
 
 export function sameVersion(a: FileVersion, b: FileVersion): boolean {
@@ -62,3 +64,22 @@ export function validFileChanges(value: unknown): value is FileChanges {
   return Object.entries(value).every(([path, change]: [string, unknown]) => path.length > 0 && typeof change === "object" && change !== null &&
     version((change as Record<string, unknown>)["before"]) && version((change as Record<string, unknown>)["after"]));
 }
+
+/**
+ * The one test for "this event changed the workspace": a real edit, an
+ * applied checkpoint that moved a file, or an observation that saw a change.
+ * Acceptance, request evidence and environment validity all ask exactly this
+ * question and must not answer it three different ways (S.1).
+ */
+export function workspaceChanged(event: import("./events.ts").LogEvent): boolean {
+  return event.t === "tool_result" && event.effect?.kind === "edit" && event.effect.sha256_before !== event.effect.sha256_after ||
+    event.t === "checkpoint" && event.phase === "applied" && changedPaths(event.changes).length > 0 ||
+    event.t === "workspace_observation" && event.changed;
+}
+
+/** The transition back: every path's before and after swapped. Applying it undoes `changes`. */
+export function invertFileChanges(changes: FileChanges): FileChanges {
+  const inverted: FileChanges = Object.create(null) as FileChanges;
+  for (const [path, change] of Object.entries(changes)) inverted[path] = { before: change.after, after: change.before };
+  return inverted;
+}

package/src/core/churn.ts

@@ -14,6 +14,7 @@
  * unchanged.
  */
 import type { GuidanceEvent, LogEvent } from "./events.ts";
+import { currentRequestEvents } from "./request-state.ts";
 
 /**
  * Assumed, not measured. Three failures leaves room for "change, retry,
@@ -25,8 +26,7 @@ export const CHURN_FAILURES = 3;
 export const CHURN_EDITS = 8;
 
 export function churnReview(events: readonly LogEvent[]): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
-  const start = events.findLastIndex((event) => event.t === "user");
-  const current = events.slice(Math.max(0, start));
+  const current = currentRequestEvents(events);
   if (current.some((event) => event.t === "guidance" && event.reason === "churn")) return null;
   const failures = new Map<string, { count: number; last: string }>();
   const edits = new Map<string, { count: number; last: string }>();

package/src/core/completion-review.ts

@@ -37,9 +37,9 @@ export function looksLikeHandBack(text: string): boolean {
 export function completionReview(
   events: readonly LogEvent[],
   remainingRequests: number,
-  options?: { strictVerification?: boolean; acceptance?: AcceptanceState; taskAware?: boolean },
+  options?: { strictVerification?: boolean; acceptance?: AcceptanceState },
 ): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
-  const state = deriveRequestState([{ node: 0, events }]);
+  const state = deriveRequestState([{ node: 0, events }], { strict: options?.strictVerification === true });
   const decision = state ? requestCompletion(state, remainingRequests, options) : { action: "finish" as const };
   return decision.action === "continue" ? decision.guidance : null;
 }
@@ -47,29 +47,36 @@ export function completionReview(
 export type RequestCompletion = { action: "finish" } |
   { action: "continue"; guidance: Pick<GuidanceEvent, "reason" | "text" | "sources"> };
 
-/** Q23: loop termination and the public request view consume the same evidence. */
+/**
+ * Q23 / S.1: loop termination reads the same ledger as every request view.
+ * A reported blocker does not end the check early: the model's statement is
+ * not evidence (D11), and the check still runs only once, so an honest
+ * blocker restated at the second finish is respected.
+ */
 export function requestCompletion(state: RequestState, remainingRequests: number,
-  options?: { strictVerification?: boolean; acceptance?: AcceptanceState; taskAware?: boolean }): RequestCompletion {
+  options?: { acceptance?: AcceptanceState }): RequestCompletion {
   const finish = { action: "finish" as const };
-  if (remainingRequests < 1 || state.reviewed || state.status === "blocked") return finish;
+  if (remainingRequests < 1 || state.reviewed) return finish;
   const final = state.final;
   if (!final || final.has_tools || state.execution?.reason !== "model_end" && state.execution?.reason !== "unknown") return finish;
   const text = final.text;
-  const verifiedAfter = state.commands.some(command => command.status === "pass" && (!options?.strictVerification || command.gate !== undefined));
 
   const gaps: string[] = [];
   const acceptance = options?.acceptance ?? state.acceptance;
   const missingCommands = acceptance?.status === "needs_work" ? acceptance.criteria.flatMap(item =>
     item.kind === "command" && item.status !== "pass" ? [{ id: item.id, command: item.command, status: item.status }] : []) : [];
+  const freshCheck = acceptance ? undefined : state.criteria.find(item => item.kind === "fresh_check");
   if (state.used_tools && text.length === 0) gaps.push("the final reply is empty");
-  if (state.changed && !verifiedAfter && !acceptance) gaps.push("files were changed but no command has succeeded since the last edit");
+  // Strict verification counts only configured gates (O.11); say so, since a successful `cat` would otherwise look like a check.
+  if (freshCheck && freshCheck.status !== "pass") gaps.push(freshCheck.gate_only
+    ? "files were changed but no configured verification gate (a test, typecheck, lint, build or check command) has passed since the last edit; reading or printing files does not count"
+    : "files were changed but no command has succeeded since the last edit");
   if (acceptance?.status === "needs_work") gaps.push(`declared acceptance criteria need evidence: ${[
     ...missingCommands.map(item => `${item.id}=${item.status}`),
     ...(acceptance.targets ?? []).filter(target => target.status !== "ready").map(target => `target ${target.id}=${target.status}`),
   ].join(", ")}`);
-  if (text.length > 0 && looksLikeHandBack(text) && acceptance?.status !== "awaiting_human") gaps.push(options?.taskAware
-    ? "the reply deferred the request; check whether authorized work remains or a specific blocker requires the user"
-    : "the reply handed the task back instead of finishing it; no one will answer");
+  if (text.length > 0 && looksLikeHandBack(text) && acceptance?.status !== "awaiting_human")
+    gaps.push("the reply deferred the request; check whether authorized work remains or a specific blocker requires the user");
   if (gaps.length === 0) return finish;
   // D11 / O.11: a declared command needs its exact receipt even when the
   // request has no recorded edit. Compound shell success is not that receipt.
@@ -77,7 +84,7 @@ export function requestCompletion(state: RequestState, remainingRequests: number
     ? "Obtain a fresh successful receipt for each missing command. Run each command exactly as a separate invocation without adding other commands:\n" +
       missingCommands.map(item => `- ${item.id}: ${JSON.stringify(item.command)}`).join("\n") +
       "\nIf verification cannot run, report the specific blocker. "
-    : options?.taskAware && !state.changed
+    : !state.changed
       ? "Use original sources for research and full inputs for calculations; do not invent command evidence. Finish with the result or the specific blocker. "
       : "Run the command that verifies the result, or finish with the specific blocker that prevents verification. ";
   return { action: "continue", guidance: {

package/src/core/continuation.ts

@@ -1,4 +1,5 @@
 /** N.1: working-state guidance is an append-only observation, never a summary. */
+import { currentRequestEvents } from "./request-state.ts";
 import type { GuidanceEvent, LogEvent } from "./events.ts";
 import type { Handoff } from "./handoff.ts";
 import { DEFAULT_BOUNDARY, type BoundaryConfig } from "./boundary.ts";
@@ -79,27 +80,27 @@ export function continuationGuidance(input: {
    * short task a turn and can make some models stop mid-task.
    */
   minAssistantTurns?: number;
-  taskAware?: boolean;
 }): Notice | null {
   const { events, handoff, tools, remainingRequests } = input;
-  // A new user request owns its own budget and plan; old notices remain immutable.
-  const user = events.findLastIndex((e) => e.t === "user");
-  const current = events.slice(Math.max(0, user));
+  // A new user request owns its own budget and plan; steering continues it (S.1).
+  // Without a user event this segment resumes a request from its handoff.
+  const scoped = currentRequestEvents(events);
+  const resumed = scoped.length === 0;
+  const current = resumed ? events : scoped;
   const notices = new Set(current.filter((e) => e.t === "guidance").map((e) => e.reason));
   const assistants = current.filter((e) => e.t === "assistant");
   if (remainingRequests <= 3 && assistants.length > 0 && !notices.has("budget")) return {
     reason: "budget", sources: [],
-    text: `Harness: this request batch has ${remainingRequests} model requests remaining. ` + (input.taskAware
-      ? "Prioritize remaining requirements and verification. A smaller budget does not establish completion; report unfinished work or missing evidence explicitly."
-      : "Prioritize decisive evidence and the final response. If evidence is insufficient, state what remains unresolved."),
+    text: `Harness: this request batch has ${remainingRequests} model requests remaining. ` +
+      "Prioritize remaining requirements and verification. A smaller budget does not establish completion; report unfinished work or missing evidence explicitly.",
   };
   const work = deriveWorkItems(handoff?.state.work_items ?? [], events);
   const next = current.some(e => e.t === "next_action" && e.work_id === undefined && e.next_action.trim().length > 0) ||
-    (user < 0 && handoff?.state.in_flight.some(item => item.work_id === undefined && item.next_action.trim().length > 0)) ||
+    (resumed && handoff?.state.in_flight.some(item => item.work_id === undefined && item.next_action.trim().length > 0)) ||
     work.some(item => item.status === "active" && item.next_action?.trim() &&
-      (user < 0 || current.some(event => "work_id" in event && event.work_id === item.id)));
+      (resumed || current.some(event => "work_id" in event && event.work_id === item.id)));
   if (tools.includes("note") && !next && !notices.has("continuation") &&
-      (assistants.length >= (input.minAssistantTurns ?? 2) || (user < 0 && handoff !== null && !handoff.continuation_valid))) return {
+      (assistants.length >= (input.minAssistantTurns ?? 2) || (resumed && handoff !== null && !handoff.continuation_valid))) return {
     reason: "continuation", sources: [],
     text: "Harness: no active subtask with a next action is recorded for this work. Record note(kind='next', work_id=the stable task ID, what=the active subtask, next_action=the concrete next step) alongside your next useful action. " +
       (tools.includes("history") && handoff !== null ? "Use history(recent=true) to recover prior attempts before repeating exploration. " : "") +

package/src/core/control-view.ts

@@ -1,20 +1,17 @@
 /** Q24: control surfaces inspect original facts; they never own a second goal or context. */
-import { currentRequestRecords, deriveRequestState, type RequestPart, type RequestState } from "./request-state.ts";
+import { currentRequestRecords, deriveRequestState, type LedgerOptions, type RequestPart, type RequestState } from "./request-state.ts";
 import { contextDetail } from "./context-detail.ts";
 import { projectContext } from "./project.ts";
 import { assertNever } from "./exhaustive.ts";
 
 export type GoalView = { text: string; state: RequestState; gaps: string[] };
 
-export function goalView(parts: readonly RequestPart[]): GoalView | null {
-  const state = deriveRequestState(parts);
+/** The request's first words and the ledger's verdict; blockers the model reported are listed, never scored (D11). */
+export function goalView(parts: readonly RequestPart[], options: LedgerOptions = {}): GoalView | null {
+  const state = deriveRequestState(parts, options);
   const first = currentRequestRecords(parts)[0]?.event;
   if (!state || first?.t !== "user") return null;
-  const gaps = state.acceptance
-    ? state.acceptance.criteria.filter(item => item.status !== "pass" && item.status !== "accepted").map(item => `${item.description}: ${item.status}`)
-    : ["No acceptance contract; command success does not verify the goal."];
-  gaps.push(...state.reported_blockers.map(item => `Reported blocker: ${item.reason}`));
-  return { text: first.text, state, gaps };
+  return { text: first.text, state, gaps: [...state.unmet, ...state.reported_blockers.map(item => `Reported blocker: ${item.reason}`)] };
 }
 
 export type ContextLens = ReturnType<typeof contextLens>;

package/src/core/deadline.ts

@@ -7,6 +7,7 @@
  * this reason. Time arrives as arguments: core reads no clock.
  */
 import type { GuidanceEvent, LogEvent } from "./events.ts";
+import { currentRequestEvents } from "./request-state.ts";
 
 /**
  * Assumed, not measured: a quarter of the budget leaves room for one
@@ -28,7 +29,7 @@ export function deadlineNotice(
   if (!Number.isFinite(start) || !Number.isFinite(current) || !Number.isFinite(budgetMs) || budgetMs <= 0) {
     throw new RangeError("deadline needs valid timestamps and a positive budget");
   }
-  const request = events.slice(Math.max(0, events.findLastIndex((event) => event.t === "user")));
+  const request = currentRequestEvents(events);
   if (request.some((event) => event.t === "guidance" && event.reason === "deadline")) return null;
   const used = current - start;
   if (used < budgetMs * DEADLINE_FRACTION) return null;

package/src/core/derive.ts

@@ -299,13 +299,6 @@ export function deriveHandoff(input: DeriveInput): Handoff {
     });
   }
   for (const e of events) {
-    if (e.t === "snapshot") {
-      for (const [path, anchor] of anchors) {
-        const now = e.changed[path] ?? e.added[path];
-        if (e.removed.includes(path) || (now !== undefined && now !== anchor.sha256)) anchor.stale = true;
-        else if (now === anchor.sha256) delete anchor.stale;
-      }
-    }
     if (e.t === "checkpoint" && e.phase === "applied") for (const [path, change] of Object.entries(e.changes)) {
       const anchor = anchors.get(path);
       if (anchor) {

package/src/core/environment.ts

@@ -1,5 +1,6 @@
 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.
@@ -153,8 +154,7 @@ export type EnvironmentValidity = { state: "recorded" | "expired" | "scope_chang
 /** 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" || event.t === "snapshot" &&
-      (Object.keys(event.added).length > 0 || Object.keys(event.changed).length > 0 || event.removed.length > 0)) {
+    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;

package/src/core/event-validation.ts

@@ -16,7 +16,6 @@ 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 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"] !== "";
@@ -46,6 +45,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
       ["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"];
@@ -67,6 +67,18 @@ export function isLogEvent(value: unknown): value is LogEvent {
     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"]);
@@ -80,7 +92,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", "runtime_acceptance"].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", "goal"].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"])) &&
@@ -119,6 +131,10 @@ export function isLogEvent(value: unknown): value is LogEvent {
       }
       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;
@@ -140,7 +156,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
       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"] === 1 || value["working_set_version"] === 2) && ["trigger", "hard_limit", "model_checkpoint"].includes(String(value["reason"])) &&
+    case "cut": return has("handoff_ref") && (value["working_set_version"] === undefined || 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"]) &&
@@ -162,9 +178,6 @@ export function isLogEvent(value: unknown): value is LogEvent {
     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 "snapshot": return stringMap(value["added"]) && stringMap(value["changed"]) && strings(value["removed"]) &&
-      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"]);