@visual-z/xeno 0.7.2 → 0.8.0

package/src/core/events.ts

@@ -116,7 +116,7 @@ export interface GuidanceEvent {
   t: "guidance";
   id: EventId;
   at: IsoTime;
-  reason: "continuation" | "repetition" | "budget" | "boundary" | "stall" | "output_recovery" | "completion_review" | "churn" | "deadline" | "runtime_acceptance";
+  reason: "continuation" | "repetition" | "budget" | "boundary" | "stall" | "output_recovery" | "completion_review" | "churn" | "deadline" | "runtime_acceptance" | "goal";
   text: string;
   sources: readonly EventId[];
 }
@@ -200,6 +200,11 @@ export interface ToolResultEvent {
   diagnostic?: ToolDiagnostic;
   /** Post-operation observer failures cannot erase the operation's factual result. */
   warnings?: readonly ToolDiagnostic[];
+  /**
+   * S.6 item 3: scoped instructions first discovered by this read-only call,
+   * shown after its content. Keys identify the accepted versions on resume.
+   */
+  instructions?: { keys: readonly string[]; text: string };
 }
 
 export type ArtifactRef = { sha256: Sha256; path: string; bytes: number };
@@ -237,7 +242,8 @@ export interface CutEvent {
   /** 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;
+  /** R9: present when the source-priority working set was carried across this cut. */
+  working_set_version?: 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. */
@@ -313,33 +319,6 @@ export interface QuestionEvent {
   carried_from?: CarriedFrom;
 }
 
-/**
- * What changed in the workspace during one turn, as a delta.
- *
- * A delta rather than a full listing: repeating the whole workspace every
- * turn is the same quadratic growth D8 exists to prevent. The full set at
- * any node is the deltas along its ancestry replayed in order.
- *
- * Recorded from a scan rather than from what the tools reported, because a
- * shell command can write anywhere and its effect carries only an exit code.
- * The two are compared, and a change nobody declared is surfaced.
- */
-export interface SnapshotEvent {
-  t: "snapshot";
-  id: EventId;
-  at: IsoTime;
-  added: Record<string, Sha256>;
-  changed: Record<string, Sha256>;
-  removed: readonly string[];
-  /** Paths that changed with no tool claiming them. */
-  undeclared: readonly string[];
-  /** Paths a tool claimed to edit that did not change. */
-  declared_but_unchanged: readonly string[];
-  workspace_sha256?: Sha256;
-  /** Idle observations must not redefine a completed user exchange. */
-  phase?: "turn" | "idle";
-}
-
 /**
  * Which halves of a rewind moved.
  *
@@ -536,6 +515,34 @@ export interface AcceptanceContractEvent {
   t: "acceptance_contract"; id: EventId; at: IsoTime; request: EventId;
   contract: AcceptanceContract;
 }
+/**
+ * S.2 / S.5: an explicit goal. `set` records exactly what the user accepted
+ * from a model draft -- the draft itself stays in the assistant event it came
+ * from -- and `clear` ends it. Only the user sets or clears one by command;
+ * the harness clears it when the request ledger is verified.
+ */
+/**
+ * The discriminating rung of the evidence ladder: one accepted check re-run in
+ * a disposable clone with this request's changes undone. Only what happened is
+ * recorded -- the exit code there, or why nothing ran (the revert could not be
+ * made exact, the check did not finish) -- with the role the criterion was
+ * declared with. What that means is derived by `counterVerdict` (S.7).
+ */
+export type CounterCheckEvent = { t: "counter_check"; id: EventId; at: IsoTime; request: EventId; criterion: string; command: string; guard?: true } &
+  ({ exit: number } | { reason: string });
+
+/**
+ * The independent rung: one blind check run after the goal ended, in a clone of
+ * the final workspace. `exposed` reports whether the log shows the model ever
+ * touched the blind checks; an exposed pass does not count as independent.
+ */
+export type BlindCheckEvent = { t: "blind_check"; id: EventId; at: IsoTime; request: EventId; check: string; exposed: boolean; exposure?: string } &
+  ({ exit: number } | { reason: string });
+
+export type GoalEvent =
+  | { t: "goal"; id: EventId; at: IsoTime; action: "set"; objective: string; contract: AcceptanceContract;
+      draft: EventId; accepted: readonly string[]; rejected: readonly string[] }
+  | { t: "goal"; id: EventId; at: IsoTime; action: "clear"; reason: "met" | "user" };
 export interface AcceptanceDecisionEvent {
   t: "acceptance_decision"; id: EventId; at: IsoTime; request: EventId;
   contract_id: string; criterion: string; actor: "user";
@@ -562,6 +569,9 @@ export type LogEvent =
   | ProcessExitEvent
   | SkillLoadedEvent
   | AcceptanceContractEvent
+  | GoalEvent
+  | CounterCheckEvent
+  | BlindCheckEvent
   | AcceptanceDecisionEvent
   | TargetObservationEvent
   | ExtensionEvent
@@ -574,7 +584,6 @@ export type LogEvent =
   | ToolResultEvent
   | EvidenceLinkEvent
   | CutEvent
-  | SnapshotEvent
   | CheckpointEvent
   | WorkspaceObservationEvent
   | RewindEvent
@@ -598,8 +607,8 @@ export const HARNESS_EVENTS = [
   "target_observation",
   "process_exit",
   "skill_loaded",
-  "acceptance_contract", "acceptance_decision",
-  "user", "user_bash", "outcome", "guidance", "interrupt", "assistant", "tool_result", "cut", "snapshot", "rewind", "extension",
+  "acceptance_contract", "acceptance_decision", "goal", "counter_check", "blind_check",
+  "user", "user_bash", "outcome", "guidance", "interrupt", "assistant", "tool_result", "cut", "rewind", "extension",
 ] as const;
 export const MODEL_EVENTS = [
   "work_dependencies", "work_owner",

package/src/core/evidence-ladder.ts

@@ -0,0 +1,62 @@
+/**
+ * The evidence ladder (research doc S.1): how far a request's evidence goes,
+ * one rung at a time, read only from the request ledger.
+ *
+ *   ran             a required check has a fresh passing receipt
+ *   discriminating  the check fails once the request's changes are undone
+ *                   (a guard instead still passes there, and does not count; S.7)
+ *   independent     blind checks the model never touched pass
+ *   human           the user accepted what only a person can judge
+ *
+ * Each rung is its own fact; a higher rung does not imply the ones below it.
+ * The summary names the highest rung reached and the first gap, so the user
+ * sees what the evidence shows and what it does not, without a percentage.
+ */
+import type { RequestState } from "./request-state.ts";
+
+export type Rung = "met" | "missing" | "failed" | "not_run" | "not_applicable";
+export type EvidenceLadder = { ran: Rung; discriminating: Rung; independent: Rung; human: Rung; summary: string };
+export const RUNGS = ["ran", "discriminating", "independent", "human"] as const;
+
+const LABEL: Record<(typeof RUNGS)[number], string> = {
+  ran: "ran", discriminating: "tests the change", independent: "independent", human: "human accepted",
+};
+
+/** Null when the request had nothing to check: a conversation turn shows no ladder. */
+export function evidenceLadder(state: RequestState): EvidenceLadder | null {
+  if (state.status === "not_applicable") return null;
+  const evidence = state.evidence;
+  const ran: Rung = evidence.ran === "pass" ? "met" : evidence.ran === "fail" ? "failed" : evidence.ran === "not_applicable" ? "not_applicable" : "missing";
+  const discriminating: Rung = evidence.discriminating === "pass" ? "met" : evidence.discriminating === "vacuous" ? "failed"
+    : evidence.discriminating === "missing" ? "missing" : evidence.discriminating === "not_applicable" ? "not_applicable" : "not_run";
+  const independent: Rung = evidence.independent === "pass" ? "met" : evidence.independent === "fail" || evidence.independent === "exposed" ? "failed"
+    : evidence.independent === "not_applicable" ? "not_applicable" : "not_run";
+  const human: Rung = evidence.human === "accepted" ? "met" : evidence.human === "pending" ? "missing" : "not_applicable";
+  const rungs = { ran, discriminating, independent, human };
+  const reached = RUNGS.filter(rung => rungs[rung] === "met").at(-1);
+  const gap = RUNGS.find(rung => rungs[rung] === "failed" || rungs[rung] === "missing");
+  const why = !gap ? undefined
+    : gap === "ran" ? (ran === "failed" ? "the latest check failed" : state.acceptance ? "declared checks have not passed" : "changes not checked")
+    : gap === "discriminating" ? (discriminating === "missing" ? "no check tests the change; every check is a guard" : vacuousGap(state))
+    : gap === "independent" ? (evidence.independent === "exposed" ? "the model touched the blind checks" : "a blind check failed")
+    : "waiting for your /accept";
+  const summary = [reached ? `reached: ${LABEL[reached]}` : "nothing verified yet", ...(why ? [why] : [])].join(" · ");
+  return { ...rungs, summary };
+}
+
+/**
+ * Which checks pass without the request's changes, by id. Only line mode
+ * prints each check's counter-check; the sidebar shows just this summary, and
+ * a guard the user asked for ("nothing else changed") reads differently from
+ * a check that was meant to test the work (fix-ladder-names-vacuous-check).
+ */
+function vacuousGap(state: RequestState): string {
+  const ids = state.criteria.filter(item => item.counter === "vacuous").map(item => item.id);
+  const named = ids.length <= 2 ? ids.join(", ") : `${ids.slice(0, 2).join(", ")} +${ids.length - 2}`;
+  return `${named} ${ids.length === 1 ? "passes" : "pass"} without the changes`;
+}
+
+/** One glyph per rung for narrow status chrome: ✓ met, ✗ failed, ○ missing or not run, · not applicable. */
+export function ladderGlyph(rung: Rung): string {
+  return rung === "met" ? "✓" : rung === "failed" ? "✗" : rung === "not_applicable" ? "·" : "○";
+}

package/src/core/evidence-links.ts

@@ -32,10 +32,6 @@ export function observedVersion(events: readonly LogEvent[], resource: string):
     if (event.t === "tool_result" && event.effect && "path" in event.effect && resourceKey(event.effect.path) === resource) {
       version = event.effect.kind === "read" ? event.effect.sha256 : event.effect.sha256_after;
     }
-    if (event.t === "snapshot") {
-      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;
     }
@@ -62,12 +58,6 @@ export function deriveEvidenceLinks(previous: readonly EvidenceLink[], events: r
         const version = event.effect.kind === "read" ? event.effect.sha256 : event.effect.sha256_after;
         link.freshness = version === link.version ? "current" : "stale";
       }
-      if (event.t === "snapshot") {
-        if (event.removed.map(resourceKey).includes(link.resource)) link.freshness = "stale";
-        for (const [path, version] of Object.entries({ ...event.added, ...event.changed })) {
-          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";
       }

package/src/core/evidence.ts

@@ -19,12 +19,11 @@ export function evidenceStale(events: readonly LogEvent[], evidence: Evidence, i
     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
+    const sha = event.t === "workspace_observation" ? event.fingerprint
       : event.t === "tool_result" && event.effect?.kind === "command" ? event.effect.workspace_sha256 : undefined;
     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;
 }

package/src/core/export.ts

@@ -12,6 +12,7 @@
  */
 
 import type { AssistantBlock, LogEvent } from "./events.ts";
+import { counterVerdict } from "./acceptance.ts";
 import { assertNever } from "./exhaustive.ts";
 import { imageDescription } from "./images.ts";
 
@@ -109,17 +110,6 @@ function eventHtml(e: LogEvent): string {
       return wrap("tool", `tool_result ${e.ok ? "ok" : "fail"}`, e.at, [e.content, ...(e.images ?? []).map(imageDescription)].join("\n"));
     case "cut":
       return wrap("event", "cut", e.at, `${e.reason} → ${e.handoff_ref}`);
-    case "snapshot":
-      return wrap(
-        "event",
-        "snapshot",
-        e.at,
-        [
-          ...Object.keys(e.added).map((p) => `+ ${p}`),
-          ...Object.keys(e.changed).map((p) => `~ ${p}`),
-          ...e.removed.map((p) => `- ${p}`),
-        ].join("\n") || "(no file changes)",
-      );
     case "rewind":
       return wrap("event", `rewind ${e.mode}`, e.at, e.prompt);
     case "spawn":
@@ -152,6 +142,11 @@ function eventHtml(e: LogEvent): string {
     case "acceptance_contract": return wrap("event", "acceptance contract", e.at, JSON.stringify(e.contract));
     case "target_observation": return wrap("event", "runtime target", e.at, JSON.stringify(e.observation));
     case "acceptance_decision": return wrap("event", "human acceptance", e.at, `${e.contract_id}: ${e.criterion}`);
+    case "counter_check": return wrap("event", "counter-check", e.at,
+      `${e.criterion}${e.guard ? " (guard)" : ""} · ${counterVerdict(e)}${"reason" in e ? ` · ${e.reason}` : ` · exit ${e.exit}`}`);
+    case "blind_check": return wrap("event", "blind check", e.at, `${e.check} · ${"reason" in e ? e.reason : `exit ${e.exit}`}${e.exposed ? ` · exposed: ${e.exposure ?? "yes"}` : ""}`);
+    case "goal": return wrap("event", e.action === "set" ? "goal set" : "goal cleared", e.at,
+      e.action === "set" ? `${e.objective}\naccepted: ${e.accepted.join(", ")}${e.rejected.length ? `\nrejected: ${e.rejected.join(", ")}` : ""}` : e.reason);
     default:
       return assertNever(e, "eventHtml");
   }

package/src/core/goal.ts

@@ -0,0 +1,200 @@
+/**
+ * Explicit goals (research doc S.2 / S.5).
+ *
+ * The model drafts acceptance criteria for a goal; the user accepts them one
+ * by one; only the accepted ones become the goal's contract. Whether the goal
+ * is met is never the model's call: it is the request ledger's status, which
+ * only command receipts and the user's own acceptance decisions move (D11).
+ * The draft is itself only a claim -- it parses into candidates, and a
+ * candidate that does not validate is reported and sent back to the model to
+ * correct, never repaired by guessing.
+ */
+import { ACCEPTANCE_COMMAND_LIMIT, parseAcceptanceContract, type AcceptanceContract, type AcceptanceCriterion } from "./acceptance.ts";
+import type { GoalEvent, LogEvent } from "./events.ts";
+import type { RequestState } from "./request-state.ts";
+
+/**
+ * Assumed, not measured: enough for a goal's distinct checks, few enough that
+ * a person reads and decides on each one rather than accepting a wall.
+ */
+export const GOAL_CRITERIA_LIMIT = 8;
+
+export function goalDraftRequest(objective: string): string {
+  return [
+    `Goal: ${objective}`,
+    "",
+    "Do not start the work yet. Draft the acceptance criteria that would show this goal is met, for the user to accept or reject one by one.",
+    "You may read the workspace first (read, find, grep) to learn its real files and commands. You cannot change anything or run commands in this step.",
+    `Then reply with only a JSON object: {"criteria":[{"id":"short-id","kind":"command","description":"what it shows","command":"exact shell command"}]}, at most ${GOAL_CRITERIA_LIMIT} items.`,
+    "- kind \"command\": a command that exits 0 only when the criterion holds, and fails on the workspace as it is now if the goal is not yet done. Prefer checks that exercise new inputs over checks that only replay an example.",
+    "- \"guard\": true on a command for what the goal must not break or change, such as files to leave untouched or behaviour that must keep working. A guard passes now and must still pass when the goal is done; every command without it must fail now.",
+    "- kind \"human\" (no command): only for what a person must judge, such as tone or visual quality.",
+    "- ids: letters, digits, dot, dash, underscore, colon; unique.",
+    "If you cannot tell how to check something, make it a human criterion rather than inventing a command.",
+    "If the goal cannot be checked or achieved in this workspace at all, reply {\"criteria\": [], \"blocked\": \"the specific reason\"}.",
+  ].join("\n");
+}
+
+export type GoalDraft = { criteria: AcceptanceCriterion[]; errors: string[]; blocked?: string };
+
+/**
+ * Assumed, not measured: one correction. Instructor's reask and Pydantic AI's
+ * output retries likewise send the validation errors back for a bounded number
+ * of attempts. The slip this exists for -- a real GLM draft missing its
+ * closing brackets -- needs one; a model that fails the same schema twice is
+ * not helped by a third full request, and the user can still redraft.
+ */
+export const GOAL_DRAFT_RETRIES = 1;
+
+/** The correction request: the parser's own reasons, and the form the reply must take. */
+export function goalDraftRetry(errors: readonly string[]): string {
+  return [
+    "Harness draft check: your draft could not be used as written.",
+    ...errors.map(error => `- ${error}`),
+    "Reply again with only the complete corrected JSON object in the same form, keeping the criteria that were valid. Do not start the work.",
+  ].join("\n");
+}
+
+/**
+ * The draft among the events one draft run recorded: the last assistant reply
+ * of the first request they open. A follow-up the user queued meanwhile opens
+ * its own request and is never read as the draft; a run that recorded no
+ * request has no draft.
+ */
+export function draftReply(recorded: readonly LogEvent[]): { id: string; text: string } | null {
+  const opens = (event: LogEvent) => event.t === "user" && event.request === undefined;
+  const start = recorded.findIndex(opens);
+  if (start < 0) return null;
+  const next = recorded.findIndex((event, index) => index > start && opens(event));
+  const reply = recorded.slice(start, next < 0 ? undefined : next).findLast(event => event.t === "assistant");
+  return reply?.t === "assistant" ? { id: reply.id, text: reply.blocks.flatMap(block => block.type === "text" ? [block.text] : []).join("\n") } : null;
+}
+
+/** The first JSON object in a reply: a fenced block when present, else the outermost braces. */
+function jsonObject(text: string): unknown {
+  const fenced = /```(?:json)?\s*\n([\s\S]*?)\n```/.exec(text)?.[1];
+  const candidate = fenced ?? text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1);
+  if (!candidate.trim()) throw Error("the reply holds no JSON object");
+  return JSON.parse(candidate);
+}
+
+const ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/;
+
+/**
+ * Why one drafted item is not a criterion, in words the user can act on; null
+ * when it is one. A human item's empty or null `command`, and a `guard` of
+ * false or null, are only a model's way of saying "none" and are dropped
+ * before this runs.
+ */
+function draftItemError(item: Record<string, unknown>, seen: ReadonlySet<string>): string | null {
+  const { id, kind, description, command, guard } = item;
+  if (typeof id !== "string" || !id.trim()) return "has no id";
+  if (!ID.test(id)) return `id ${JSON.stringify(id)} may use only letters, digits, dot, dash, underscore and colon (at most 80)`;
+  if (seen.has(id)) return `repeats id ${id}`;
+  if (typeof description !== "string" || !description.trim()) return "has no description";
+  if (description.length > 300) return "has a description longer than 300 characters";
+  if (kind === "human") return command !== undefined ? "is a human criterion with a command; make it a command criterion or drop the command"
+    : guard !== undefined ? "is a human criterion marked as a guard; a guard needs a command" : null;
+  if (kind !== "command") return `has kind ${JSON.stringify(kind)}; use "command" or "human"`;
+  if (guard !== undefined && guard !== true) return `has guard ${JSON.stringify(guard)}; use true or leave it out`;
+  if (typeof command !== "string" || !command.trim()) return "needs a command";
+  if (command.length > ACCEPTANCE_COMMAND_LIMIT) return `has a command longer than ${ACCEPTANCE_COMMAND_LIMIT} characters`;
+  return null;
+}
+
+export function parseGoalDraft(text: string): GoalDraft {
+  let value: unknown;
+  try { value = jsonObject(text); }
+  catch (error) { return { criteria: [], errors: [`the draft is not readable JSON: ${error instanceof Error ? error.message : String(error)}`] }; }
+  const object = value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
+  const items = object?.["criteria"];
+  if (!Array.isArray(items)) return { criteria: [], errors: ["the draft has no criteria array"] };
+  const blockedText = object?.["blocked"];
+  const blocked = typeof blockedText === "string" && blockedText.trim() ? blockedText.trim().slice(0, 500) : undefined;
+  const criteria: AcceptanceCriterion[] = [], errors: string[] = [], seen = new Set<string>();
+  items.forEach((raw, index) => {
+    if (criteria.length >= GOAL_CRITERIA_LIMIT) { errors.push(`criterion ${index + 1}: more than ${GOAL_CRITERIA_LIMIT} criteria`); return; }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) { errors.push(`criterion ${index + 1} is not an object`); return; }
+    const item = { ...(raw as Record<string, unknown>) };
+    if (item["kind"] === "human" && (item["command"] === null || typeof item["command"] === "string" && !item["command"].trim())) delete item["command"];
+    if (item["guard"] === false || item["guard"] === null) delete item["guard"];
+    const problem = draftItemError(item, seen);
+    if (problem) { errors.push(`criterion ${index + 1} ${problem}`); return; }
+    // The one validator for criteria: a draft item is accepted exactly when a contract would accept it.
+    try {
+      const [criterion] = parseAcceptanceContract({ version: 1, id: "goal", criteria: [{ id: item["id"], kind: item["kind"], description: item["description"],
+        ...(item["kind"] === "command" ? { command: item["command"], ...(item["guard"] === true ? { guard: true } : {}) } : {}) }] }).criteria;
+      seen.add(criterion!.id); criteria.push(criterion!);
+    } catch (error) { errors.push(`criterion ${index + 1}: ${error instanceof Error ? error.message : String(error)}`); }
+  });
+  return { criteria, errors, ...(blocked ? { blocked } : {}) };
+}
+
+/** Only accepted criteria, in draft order. Accepting none is not a goal. */
+export function goalContract(criteria: readonly AcceptanceCriterion[], accepted: readonly string[]): AcceptanceContract {
+  const chosen = criteria.filter(item => accepted.includes(item.id));
+  if (chosen.length === 0) throw Error("a goal needs at least one accepted criterion");
+  return parseAcceptanceContract({ version: 1, id: "goal", scope: "request", criteria: chosen });
+}
+
+export type ActiveGoal = Extract<GoalEvent, { action: "set" }>;
+
+/** The goal in force at the end of an ancestry: the last set, unless a clear followed it. */
+export function activeGoal(events: readonly LogEvent[]): ActiveGoal | null {
+  const last = events.findLast(event => event.t === "goal");
+  return last?.t === "goal" && last.action === "set" ? last : null;
+}
+
+/**
+ * Assumed, not measured: two goal checks answered without any tool use means
+ * the model is talking past the goal, and more requests will not change that.
+ * Claude Code's /goal stops on the same signal ("no tool use for several
+ * turns in a row"). Too low would stop a model that needed one more reply to
+ * plan; too high spends requests on replies that do nothing.
+ */
+export const GOAL_IDLE_LIMIT = 2;
+
+/** Goal checks since the last tool result: each one the model answered without acting. */
+export function idleGoalChecks(events: readonly LogEvent[]): number {
+  let count = 0;
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i]!;
+    if (event.t === "tool_result" || event.t === "user" && event.request === undefined) break;
+    if (event.t === "guidance" && event.reason === "goal") count++;
+  }
+  return count;
+}
+
+export type GoalDecision =
+  | { action: "met" }
+  | { action: "await_human" }
+  | { action: "stop"; reason: string }
+  | { action: "continue"; text: string };
+
+/**
+ * What a goal does when the model ends a turn. Reads the request ledger, so
+ * the loop and every goal view agree. A reported blocker stops the loop --
+ * spending more requests against a stated blocker is the user's call -- but
+ * leaves the goal active: the statement is not evidence it cannot be met.
+ */
+export function goalDecision(state: RequestState, remainingRequests: number, idleChecks = 0): GoalDecision {
+  if (state.status === "verified") return { action: "met" };
+  if (state.status === "awaiting_human") return { action: "await_human" };
+  if (state.reported_blockers.length > 0) return { action: "stop", reason: `the model reported a blocker: ${state.reported_blockers.at(-1)!.reason}` };
+  if (remainingRequests < 1) return { action: "stop", reason: "the request budget is spent" };
+  if (idleChecks >= GOAL_IDLE_LIMIT) return { action: "stop", reason: `the model answered ${idleChecks} goal checks without acting` };
+  const missing = state.criteria.filter(item => item.kind === "command" && item.status !== "pass");
+  // An unchanged workspace failing the same way twice: rerunning is pointless,
+  // and the accepted check may be what is wrong. The model may not rewrite it;
+  // only the user can redraft a goal (S.2).
+  const stuck = missing.filter(item => (item.repeated_failures ?? 0) >= 2), rerun = missing.filter(item => !stuck.includes(item));
+  return { action: "continue", text: [
+    `Harness goal check: the goal is not met yet. Unmet: ${state.unmet.join("; ")}.`,
+    ...(rerun.length ? ["Run each missing check exactly, as a separate invocation:",
+      ...rerun.map(item => `- ${item.id}${item.guard ? " (a guard: it must keep passing)" : ""}: ${JSON.stringify(item.command)}`)] : []),
+    ...stuck.map(item => `- ${item.id} failed ${item.repeated_failures} times in a row against an unchanged workspace. Do not rerun it as is: change the work, ` +
+      "or, if the check itself may itself be broken (a syntax error, a missing tool, or a test of the wrong thing), record which check is broken and why " +
+      "with note(kind='blocked') and stop. Do not rewrite or replace an accepted check; the user can redraft the goal with /goal."),
+    "Keep working toward the goal. If something outside your control blocks it, record the specific blocker with note(kind='blocked') and stop.",
+  ].join("\n") };
+}

package/src/core/history.ts

@@ -1,7 +1,7 @@
 /** D20: bounded carried state, with deterministic pages rebuilt from the log. */
 import { emitHandoff, type Handoff } from "./handoff.ts";
 import { estimateTokens } from "./tokens.ts";
-import { workingSet, recoveryWorkingSet } from "./working-set.ts";
+import { recoveryWorkingSet } from "./working-set.ts";
 import type { RecoveryNodes } from "./recovery-sources.ts";
 
 // A carried handoff must leave room for another segment's work. This budget is
@@ -117,16 +117,6 @@ export function historyPage(full: Handoff, section: HistorySection, offset: numb
   return { total: items.length, offset, next: end < items.length ? end : null, items: items.slice(offset, end) };
 }
 
-/** O.10: the optional priority view shares the original total budget. */
-export function boundWorkingHandoff(full: Handoff, budget = DEFAULT_HANDOFF_TOKENS): Handoff {
-  const legacy = boundHandoff(full, budget);
-  // 40% is a declared allocation hypothesis, not a measured context threshold.
-  const view = workingSet(full, budget * .4);
-  if (!view) return legacy;
-  try { return boundHandoff({ ...full, working_set: view }, budget); }
-  catch (error) { if (error instanceof RangeError) return legacy; throw error; }
-}
-
 /** R9 uses the same budget; originals are supplied by the ancestry owner. */
 export function boundRecoveryHandoff(full: Handoff, nodes: RecoveryNodes, budget = DEFAULT_HANDOFF_TOKENS, tools?: readonly string[]): Handoff {
   const legacy = boundHandoff(full, budget);

package/src/core/json-event.ts

@@ -30,8 +30,6 @@ export type JsonLoopKind =
   | "stop_and_ask"
   | "branch_start"
   | "branch_done"
-  | "snapshot_failed"
-  | "undeclared_change"
   | "done";
 
 /**
@@ -127,10 +125,6 @@ export function toJsonEvent(e: JsonLoopEvent, at: string): Record<string, unknow
         ...(e.text !== undefined ? { text: e.text } : {}),
         at,
       };
-    case "snapshot_failed":
-      return { type: "snapshot_failed", ...(e.reason !== undefined ? { reason: e.reason } : {}), at };
-    case "undeclared_change":
-      return { type: "undeclared_change", ...(e.reason !== undefined ? { reason: e.reason } : {}), at };
     default:
       return assertNever(e.kind, "toJsonEvent");
   }

package/src/core/outcome.ts

@@ -14,7 +14,6 @@ const STATUS = {
   provider_error: "failed",
   execution_error: "failed",
   projection_invalid: "failed",
-  snapshot_failed: "failed",
   tool_failed: "failed",
   unknown: "unknown",
 } as const;

package/src/core/program-status.ts

@@ -3,6 +3,15 @@ import type { ExecutionOutcome } from "./outcome.ts";
 
 export type ProgramStatus = { state: "idle" | "working" | "done" | "blocked" | "error" | "clear";
   kind?: "permission" | "question" | "auth"; msg?: string };
+/** S.1: what a finished turn's ledger says, in one line; the status itself stays "done". */
+const FINISHED: Readonly<Record<string, string>> = {
+  verified: "Goal verified against its contract",
+  checked: "Turn finished; changes passed a fresh check",
+  unchecked: "Turn finished; changes not checked",
+  needs_work: "Turn finished; declared checks incomplete",
+  not_applicable: "Turn finished",
+};
+
 export function programStatus(input: { running: boolean; waiting?: "permission" | "question" | "auth" | null;
   outcome?: ExecutionOutcome; goal?: string }): ProgramStatus {
   if (input.waiting) return { state: "blocked", kind: input.waiting, msg: input.waiting === "auth" ? "Sign in to continue" : input.waiting === "permission" ? "Tool approval required" : "User input required" };
@@ -10,8 +19,8 @@ export function programStatus(input: { running: boolean; waiting?: "permission"
   if (input.outcome?.status === "cancelled") return { state: "idle", msg: "Turn cancelled" };
   if (input.outcome?.status === "failed") return { state: "error", msg: "Turn failed; inspect the session" };
   if (input.outcome?.status === "stopped") return { state: "blocked", kind: "question", msg: "Turn stopped; review evidence before continuing" };
-  if (input.goal === "awaiting_human" || input.goal === "blocked") return { state: "blocked", kind: "question", msg: "Goal awaits user review" };
-  if (input.outcome?.reason === "model_end") return { state: "done", msg: input.goal === "verified" ? "Goal verified against its contract" : "Turn finished; goal verification incomplete" };
+  if (input.goal === "awaiting_human") return { state: "blocked", kind: "question", msg: "Goal awaits user review" };
+  if (input.outcome?.reason === "model_end") return { state: "done", msg: FINISHED[input.goal ?? "not_applicable"] ?? FINISHED["not_applicable"]! };
   return { state: "idle", msg: "Ready for a request" };
 }
 export const PROGRAM_STATUS_QUERY = "\x1b]7501;?\x1b\\";

package/src/core/progress.ts

@@ -66,9 +66,12 @@ export function deriveProgress(
     if (event.t !== "tool_result") continue;
     const name = calls.get(event.call_id);
     calls.delete(event.call_id);
-    if (!event.ok) continue;
-    const source = { node, event_id: event.id };
     const effect = event.effect;
+    // A failed tool that never ran observed nothing. A command that ran and
+    // exited nonzero did observe something (S.6 item 2): its output counts
+    // like any other, but it is never a check.
+    if (!event.ok && effect?.kind !== "command") continue;
+    const source = { node, event_id: event.id };
     const observation = event.observation_sha256 ?? event.content_ref?.sha256 ?? event.content_sha256;
     if (effect?.kind === "read" && effect.sha256 !== "") observations.add(versionKey(effect.path, effect.sha256));
     if (effect?.kind === "read" && effect.sha256 !== "") {
@@ -88,18 +91,21 @@ export function deriveProgress(
         if (observation === undefined || !observations.has(observation)) progressed = true;
         if (observation !== undefined) observations.add(observation);
       }
-    } else if (effect?.kind === "command" && effect.exit === 0) {
-      // D9 revision (2026-09-29, user-approved): output never seen before is a
-      // new observation, exactly as for read/grep. A model exploring with
-      // `sed -n` or `grep` in the shell is gathering evidence too; the digest
-      // excludes wall time, so an unchanged `git status` repeats and stalls.
+    } else if (effect?.kind === "command") {
+      // D9 revisions (2026-09-29 and S.6 item 2, user-approved): output never
+      // seen before is a new observation, exactly as for read/grep, whatever
+      // the exit code. A model exploring with `sed -n` or `grep` in the shell
+      // is gathering evidence too, and a grep with no match exits 1 after the
+      // earlier pipeline stages printed what was asked for. The digest
+      // excludes wall time, so an unchanged `git status` or the same failure
+      // repeats and stalls.
       if (observation !== undefined && !observations.has(observation)) {
         observations.add(observation);
         evidence.push({ kind: "observation", sha256: observation, source });
         progressed = true;
       }
       const key = checkKey(effect.cmd, effect.gate, effect.workspace_sha256);
-      if (!checks.has(key)) {
+      if (event.ok && effect.exit === 0 && !checks.has(key)) {
         checks.add(key);
         evidence.push({ kind: "check", command: effect.cmd, source,
           ...(effect.gate === undefined ? {} : { gate: effect.gate }),