@visual-z/xeno 0.7.2 → 0.8.1

package/src/runtime/loop.ts

@@ -25,7 +25,12 @@ import type { Handoff } from "../core/handoff.ts";
 import { boundHandoff, DEFAULT_HANDOFF_TOKENS } from "../core/history.ts";
 import { boundaryPreparation, continuationGuidance } from "../core/continuation.ts";
 import type { FrozenPrefix, Message, ProjectInput } from "../core/project.ts";
-import { projectContext, PROJECTION_VERSION, toolCallIdentityViolations } from "../core/project.ts";
+import { projectContext, toolCallIdentityViolations } from "../core/project.ts";
+import { parseSessionContext, type SessionContext } from "../core/session-format.ts";
+import { activeGoal, goalContract, goalDecision, idleGoalChecks, type ActiveGoal } from "../core/goal.ts";
+import { counterCheck } from "./counter-check.ts";
+import { runBlindChecks } from "./blind-check.ts";
+import { blindExposure, type BlindChecks } from "../core/blind-checks.ts";
 import { deriveHandoff, carryForward } from "../core/derive.ts";
 import { latestObservedFileVersion } from "../core/file-precondition.ts";
 import { latestProcessReceipt } from "../core/process-receipt.ts";
@@ -44,7 +49,7 @@ import { pendingToolCalls } from "../core/execution.ts";
 import { declaredToolNames, recordedDeclarations } from "../core/tool-discovery.ts";
 import { DISCOVERY_TOOL, DISCOVERY_TOOL_NAME, currentDeferredTools, discoveryFingerprint, discoveryPermitted, searchDeferredTools } from "./tool-discovery.ts";
 import { executionOutcome, modelOutcome, type ExecutionOutcome, type ExecutionReason } from "../core/outcome.ts";
-import { finalizationNotice, requestPhase } from "../core/request-budget.ts";
+import { finalizationNotice, requestPhase, validateRequestBudget } from "../core/request-budget.ts";
 import { stopReport } from "../core/stop-report.ts";
 import { supportsToolDisabling, type ProviderSendOptions } from "./provider-tool-policy.ts";
 import { commandCompletion } from "../core/command-contract.ts";
@@ -63,12 +68,12 @@ import { schedulingWindow } from "../core/scheduling.ts";
 import { estimateTokens, anchoredCount, scaledCounter, type TokenCounter, type Anchor } from "../core/tokens.ts";
 import { isContextOverflow } from "../core/overflow.ts";
 import { requestCompletion } from "../core/completion-review.ts";
-import { deriveRequestState, type RequestState } from "../core/request-state.ts";
+import { currentRequestRecords, deriveRequestState, type RequestState } from "../core/request-state.ts";
 import { churnReview } from "../core/churn.ts";
 import { deriveBranchReceipt } from "../core/branch-receipt.ts";
 import { skillTools, type Skill } from "../core/skills.ts";
 import type { WorkItem } from "../core/work-state.ts";
-import { parseAcceptanceContract, type AcceptanceContract, type AcceptanceState } from "../core/acceptance.ts";
+import { parseAcceptanceContract, type AcceptanceContract, type AcceptanceCriterion, type AcceptanceState } from "../core/acceptance.ts";
 import { deadlineNotice } from "../core/deadline.ts";
 import { statusOf } from "./retry.ts";
 import { assertNever } from "../core/exhaustive.ts";
@@ -83,13 +88,9 @@ import { runHistoryTool } from "./history-tools.ts";
 import { prepareWorkingNote } from "./working-notes.ts";
 import { copyAncestryTo } from "../store/sessions.ts";
 import { FailedResponseError, type Provider, type Turn, type StreamDelta } from "./provider.ts";
-import {
-  scanWorkspace, diffScans, reconcile, DEFAULT_IGNORE, workspaceVersion,
-  type FileSet, type RestoreResult,
-} from "../store/workspace.ts";
-import { putBlob, getBlob, putFileBlob } from "../store/blobs.ts";
+import { putBlob, getBlob } from "../store/blobs.ts";
 import { hydrateProcessReceipts } from "../store/process-receipts.ts";
-import { readNodeHistory, planRestoreToNode, applyRestorePlan } from "../store/restore.ts";
+import { readNodeHistory } from "../store/restore.ts";
 import { createWorktree, removeWorktree } from "../store/worktree.ts";
 import {
   parseNote, matchGate, branchTools, finishToolResult, prepareNormalizedTool, presentObservation, toolDefinition, modelToolSchema, adviceTools,
@@ -108,7 +109,8 @@ import { observeCommand } from "../store/command.ts";
 import { headTailView } from "../core/observation-view.ts";
 import { withProgress } from "./progress.ts";
 import { WorkspaceLifecycle } from "./workspace-lifecycle.ts";
-import { changedPaths, sameVersion, type CheckpointEvent, type FileChanges } from "../core/checkpoints.ts";
+import { changedPaths, invertFileChanges, sameVersion, type CheckpointEvent, type FileChanges } from "../core/checkpoints.ts";
+import type { GitCheckpoint } from "../store/git-checkpoints.ts";
 import { readEditableFile, preflightChanges, applyFileChanges } from "../store/file-checkpoints.ts";
 import { planCheckpointRestore } from "../store/checkpoint-history.ts";
 
@@ -125,6 +127,27 @@ export function systemClock(): Clock {
   };
 }
 
+/** Per-request options that are not session configuration. */
+export interface RequestOptions {
+  /**
+   * A read-only planning request (S.5 goal drafts). The Plan-mode tool gate
+   * refuses anything that could change the workspace, the request runs at
+   * most READ_ONLY_REQUEST_LIMIT model requests with the last one answering
+   * without tools, and no goal or completion check applies. A draft written
+   * without seeing the workspace guessed its commands, and a request with
+   * tools disabled outright was answered with tool calls anyway
+   * (fix-goal-read-only-draft).
+   */
+  readOnly?: boolean;
+}
+
+/**
+ * Assumed, not measured: room to list the workspace and read a few files
+ * before answering. The last request answers with tools disabled.
+ */
+export const READ_ONLY_REQUEST_LIMIT = 8;
+const READ_ONLY_HINT = "this request only reads the workspace. Use read, find or grep, then answer.";
+
 export interface LoopEvent {
   kind:
     | "turn_start"
@@ -141,8 +164,6 @@ export interface LoopEvent {
     | "stop_and_ask"
     | "branch_start"
     | "branch_done"
-    | "snapshot_failed"
-    | "undeclared_change"
     | "done";
   text?: string;
   tool?: { name: string; input: unknown };
@@ -197,18 +218,14 @@ export interface SessionConfig {
   agentProfile?: { name: string; workflowExplicit: boolean };
   /** An explicit mode command's capability default, independent of role authority. */
   workflowToolProfile?: "foundation";
-  /** P.3: legacy full snapshots are an explicit compatibility mode, never the CLI default. */
-  workspaceTracking?: "journal" | "legacy";
   shellCheckpoints?: boolean;
   skills?: readonly Skill[];
   acceptanceContract?: AcceptanceContract | null;
+  /** feat-blind-checks: hidden checks, frozen at session start; never part of any projection. */
+  blindChecks?: BlindChecks;
   strictVerification?: boolean;
-  /** O.10: opt-in carried view; legacy sessions and evaluations retain D20. */
+  /** O.10: opt-in carried view (source-priority, R9); evaluations compare it against D20's plain handoff. */
   workingSet?: boolean;
-  /** R9: CLI opts into source-priority views; absent preserves v1 experiment/old-session behavior. */
-  workingSetVersion?: 1 | 2;
-  /** R10: new CLI guidance; absence retains old carried/prefix wording on resume. */
-  guidanceVersion?: 1;
   logDir: string;
   frozen: FrozenPrefix;
   tools: ToolContext;
@@ -258,8 +275,6 @@ export interface SessionConfig {
    */
   blobDir?: string;
   imageOptions?: { readonly autoResize?: boolean; readonly blockImages?: boolean };
-  /** Directory names the scan skips, relative to the workspace root. */
-  snapshotIgnore?: readonly string[];
 }
 
 export interface SessionState {
@@ -278,7 +293,6 @@ export interface SessionState {
   /** Next free node number. Branches take one each. */
   nextNode: number;
   /** The workspace as of the last snapshot, for diffing the next one. */
-  lastScan: FileSet;
   /** Worktrees created for writing branches, by node. */
   worktrees: Map<number, { path: string; branch: string }>;
 }
@@ -353,6 +367,10 @@ export class Session {
   private cleanup: Promise<void> | null = null;
   private closing: Promise<void> | null = null;
   private turnTools: ToolContext | null = null;
+  /** The running request is read-only (RequestOptions.readOnly); every tool call goes through the Plan gate. */
+  private readOnlyRequest = false;
+  /** The source snapshot taken when the current goal request began; a counter-check reverts to it. In memory: a request never outlives its process. */
+  private goalBaseline: { request: string; snapshot: GitCheckpoint } | null = null;
   private readonly execution = new ExecutionControl();
   private readonly runtimeTargets = new RuntimeTargets();
   private rootTools: ToolQueue | undefined;
@@ -382,7 +400,7 @@ export class Session {
     stallDecision(emptyStallState(), config.stallLimit ?? DEFAULT_STALL_LIMIT);
     validateOutputRecoveryLimit(config.outputRecoveryLimit ?? DEFAULT_OUTPUT_RECOVERY_LIMIT);
     schedulingWindow([], 0, config.maxParallelTools ?? 3);
-    requestPhase(0, config.maxTurns);
+    validateRequestBudget(config.maxTurns, config.stallLimit ?? DEFAULT_STALL_LIMIT);
     this.allocation = allocation;
     this.config = { ...config, ...(config.acceptanceContract ? { acceptanceContract: parseAcceptanceContract(config.acceptanceContract) } : {}), tools: { ...config.tools, execOwner: this.execOwner, historyCache: new HistoryCache(),
       processWait: { wake: () => this.processWake.signal } } };
@@ -430,7 +448,7 @@ export class Session {
     };
     this.state = {
       node: 0, depth: 1, handoff: null, events: [], usage: [],
-      anchor: null, branchesOpened: 0, lastScan: {},
+      anchor: null, branchesOpened: 0,
       get nextNode() { return allocation.next; },
       set nextNode(value: number) { allocation.next = value; },
       worktrees: new Map(),
@@ -441,8 +459,7 @@ export class Session {
   private installWorkspace(): void {
     delete this.config.tools.workspace;
     this.config.tools.ownedStatePaths = [this.config.logDir, ...(this.config.blobDir ? [this.config.blobDir] : [])];
-    this.config.tools.legacyWorkspace = this.config.workspaceTracking === "legacy";
-    if (this.config.blobDir && this.config.workspaceTracking !== "legacy") this.config.tools.workspace = new WorkspaceLifecycle(
+    if (this.config.blobDir) this.config.tools.workspace = new WorkspaceLifecycle(
       this.config.tools.root, this.config.blobDir, this.config.shellCheckpoints === true,
       event => this.record({ ...event, id: this.clock.nextId(), at: this.clock.now() }),
       join(this.config.logDir, "checkpoints"),
@@ -492,68 +509,39 @@ export class Session {
         this.config.stallLimit ??= DEFAULT_STALL_LIMIT;
         this.config.outputRecoveryLimit ??= DEFAULT_OUTPUT_RECOVERY_LIMIT;
         await initNode(dir, 0, null, this.clock.now());
-        for await (const event of this.snapshotTurn([], true)) {
-          if (event.kind === "snapshot_failed") throw new Error(`cannot establish workspace baseline: ${event.reason}`);
-        }
         break;
 
       case "resume": {
-        this.config.acceptanceContract = null;
-        this.config.strictVerification = false;
-        this.config.workingSet = false;
-        this.config.workingSetVersion = 1;
-        delete this.config.guidanceVersion;
-        // Logs predating explicit policies meant segmented, regardless of today's default.
-        this.config.contextPolicy = "segmented";
-        this.config.maxParallelTools = 1;
-        this.config.stallLimit = 0;
-        this.config.outputRecoveryLimit = 0;
         const replayed = await replayContext(dir, plan.cursor.node);
-        if (plan.cursor.context_ref) {
-          const saved = await getBlob(join(dir, "artifacts"), plan.cursor.context_ref);
-          if (saved === null) throw new Error("missing frozen session context");
-          const context = JSON.parse(saved) as { agentProfile?: { name: string; workflowExplicit: boolean }; workflowMode?: "build" | "plan"; skills?: Skill[]; acceptanceContract?: AcceptanceContract; strictVerification?: boolean; workingSet?: boolean; workingSetVersion?: 1 | 2; guidanceVersion?: 1; projectionVersion?: number; frozen: FrozenPrefix; boundary?: Partial<BoundaryConfig>; contextPolicy?: unknown; stallLimit?: number; outputRecoveryLimit?: number; guidance?: boolean; gates: Record<string, string>; snapshotIgnore?: readonly string[]; workspaceTracking?: "journal" | "legacy"; shellCheckpoints?: boolean; workNamespace?: string; maxParallelTools?: number };
-          if (context.agentProfile !== undefined) {
-            if (!context.agentProfile || typeof context.agentProfile.name !== "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(context.agentProfile.name) || typeof context.agentProfile.workflowExplicit !== "boolean") throw Error("unsupported saved agent profile selector");
-            this.config.agentProfile = { ...context.agentProfile };
-          }
-          if (context.workflowMode !== undefined) { if (!["build", "plan"].includes(context.workflowMode)) throw Error("unsupported saved workflow mode"); this.config.tools.workflowMode = context.workflowMode; }
-          if ("workflowToolProfile" in context && context.workflowToolProfile !== undefined) {
-            if (context.workflowToolProfile !== "foundation") throw Error("unsupported saved workflow tool profile");
-            this.config.workflowToolProfile = "foundation";
-          }
-          if (context.projectionVersion !== undefined && context.projectionVersion !== PROJECTION_VERSION) throw new Error("unsupported saved projection version");
-          this.config.workingSet = context.workingSet === true;
-          if (context.workingSetVersion !== undefined && ![1, 2].includes(context.workingSetVersion)) throw new Error("unsupported saved working-set version");
-          this.config.workingSetVersion = context.workingSetVersion ?? 1;
-          if (context.guidanceVersion !== undefined && context.guidanceVersion !== 1) throw new Error("unsupported saved guidance version");
-          if (context.guidanceVersion === 1) this.config.guidanceVersion = 1;
-          this.config.workspaceTracking = context.workspaceTracking ?? "journal";
-          this.config.shellCheckpoints = context.shellCheckpoints === true;
-          if (context.acceptanceContract) { parseAcceptanceContract(context.acceptanceContract); this.config.acceptanceContract = context.acceptanceContract; }
-          this.config.strictVerification = context.strictVerification === true;
-          this.config.skills = context.skills ?? [];
-          this.installSkillResources();
-          this.config.workNamespace = context.workNamespace ?? "main";
-          this.config.maxParallelTools = context.maxParallelTools ?? 1;
-          schedulingWindow([], 0, this.config.maxParallelTools);
-          stallDecision(emptyStallState(), context.stallLimit ?? 0);
-          this.config.stallLimit = context.stallLimit ?? 0;
-          validateOutputRecoveryLimit(context.outputRecoveryLimit ?? 0);
-          this.config.outputRecoveryLimit = context.outputRecoveryLimit ?? 0;
-          this.config.frozen = context.frozen;
-          this.config.tools.gates = context.gates;
-          if (context.boundary !== undefined) this.config.boundary = context.boundary;
-          else delete this.config.boundary;
-          if (context.contextPolicy !== undefined) {
-            if (!isContextPolicy(context.contextPolicy)) throw new Error("unknown saved context policy");
-            this.config.contextPolicy = context.contextPolicy;
-          } else this.config.contextPolicy = "segmented";
-          if (context.guidance !== undefined) this.config.guidance = context.guidance;
-          else delete this.config.guidance;
-          if (context.snapshotIgnore !== undefined) this.config.snapshotIgnore = context.snapshotIgnore;
-          else delete this.config.snapshotIgnore;
-        }
+        if (!plan.cursor.context_ref) throw new Error("missing frozen session context");
+        const saved = await getBlob(join(dir, "artifacts"), plan.cursor.context_ref);
+        if (saved === null) throw new Error("missing frozen session context");
+        // S.3: one format, parsed once. Every field below was written by a
+        // session of this format, so it is restored as recorded, not defaulted.
+        const context = parseSessionContext(JSON.parse(saved));
+        if (context.agentProfile) this.config.agentProfile = { ...context.agentProfile };
+        else delete this.config.agentProfile;
+        if (context.workflowMode) this.config.tools.workflowMode = context.workflowMode;
+        if (context.workflowToolProfile) this.config.workflowToolProfile = context.workflowToolProfile;
+        this.config.workingSet = context.workingSet;
+        this.config.shellCheckpoints = context.shellCheckpoints;
+        this.config.acceptanceContract = context.acceptanceContract ?? null;
+        this.config.strictVerification = context.strictVerification;
+        this.config.skills = context.skills;
+        this.installSkillResources();
+        this.config.workNamespace = context.workNamespace;
+        this.config.maxParallelTools = context.maxParallelTools;
+        this.config.stallLimit = context.stallLimit;
+        this.config.outputRecoveryLimit = context.outputRecoveryLimit;
+        this.config.frozen = context.frozen;
+        this.config.tools.gates = context.gates;
+        this.config.contextPolicy = context.contextPolicy;
+        if (context.boundary !== undefined) this.config.boundary = context.boundary;
+        else delete this.config.boundary;
+        if (context.guidance !== undefined) this.config.guidance = context.guidance;
+        else delete this.config.guidance;
+        if (context.blindChecks) this.config.blindChecks = context.blindChecks;
+        else delete this.config.blindChecks;
         if (plan.cursor.workspace !== undefined) this.config.tools.root = plan.cursor.workspace;
         if (plan.cursor.blob_dir !== undefined) this.config.blobDir = plan.cursor.blob_dir;
         for (const id of existing) {
@@ -583,14 +571,6 @@ export class Session {
         this.state.anchor = null;
         // Compare disk against the durable file projection. Treating current
         // disk as the baseline would erase unlogged effects of a crashed tool.
-        if (this.config.blobDir && this.config.workspaceTracking === "legacy") {
-          const files = await planRestoreToNode(dir, this.state.node);
-          if (!files.ok) throw new Error(files.error);
-          this.state.lastScan = files.files;
-          for await (const event of this.snapshotTurn([], false, "idle")) {
-            if (event.kind === "snapshot_failed") throw new Error(event.reason);
-          }
-        }
         const pending = (await readNode(dir, plan.cursor.node)).events.findLast((e) => e.t === "adopt" && !e.applied);
         if (pending?.t === "adopt") {
           this.pendingAdoption = pending.branch.node;
@@ -604,7 +584,7 @@ export class Session {
     }
 
     this.installWorkspace();
-    if (this.config.workspaceTracking !== "legacy") await this.recoverFileOperations();
+    await this.recoverFileOperations();
     this.restoreDeclaredTools();
     // Consume the original pending receipt before another checkpoint can replace this projection.
     const declarationCut = await this.applyDiscoveredTools();
@@ -623,7 +603,7 @@ export class Session {
    */
   async fork(destLogDir: string, untilEvent?: string, position: "at" | "before" = "at"): Promise<void> {
     await copyAncestryTo(this.config.logDir, destLogDir, this.clock.now(), untilEvent, position);
-    if (untilEvent !== undefined && this.config.workspaceTracking !== "legacy") {
+    if (untilEvent !== undefined) {
       const cursor = await readCursor(destLogDir);
       if (!cursor) throw new Error("missing fork cursor");
       const tip = (await readNode(this.config.logDir, this.state.node)).events.at(-1);
@@ -677,9 +657,6 @@ export class Session {
       this.rootTools ??= new ToolQueue(this.config.maxParallelTools ?? 3);
       release = await this.rootTools.acquire("exclusive");
       if (!command.trim()) throw new Error("empty user command");
-      for await (const event of this.snapshotTurn([], false, "idle")) {
-        if (event.kind === "snapshot_failed") throw new Error(event.reason);
-      }
       const execute = async (): Promise<ToolResult> => {
         const captured = await observeCommand({ command, cwd: this.config.tools.root,
           outputStore: join(this.config.logDir, "artifacts"), maxOutputBytes: this.config.tools.maxOutputBytes,
@@ -696,9 +673,6 @@ export class Session {
       const event: Extract<LogEvent, { t: "user_bash" }> = { t: "user_bash", id: this.clock.nextId(), at: this.clock.now(),
         command, content: result.content, exit: result.effect.exit, excludeFromContext, outcome: result.outcome, content_ref: result.content_ref };
       await this.record(event);
-      for await (const snapshot of this.snapshotTurn([])) {
-        if (snapshot.kind === "snapshot_failed") throw new Error(snapshot.reason);
-      }
       await this.saveCursor();
       return event;
     } catch (error) {
@@ -729,12 +703,9 @@ export class Session {
     const target = await resolveHistoryPosition(dir, eventId, users.some(user => user.id === eventId) ? "before" : "at");
     const previous = (await readNode(dir, this.state.node)).events.at(-1);
     const filesFrom = { ...await digestedRef(dir, this.state.node), ...(previous ? { at_event: previous.id } : {}) };
-    for await (const event of this.snapshotTurn([], false, "idle")) {
-      if (event.kind === "snapshot_failed") throw new Error(event.reason);
-    }
     const node = this.state.nextNode++;
     await initNode(dir, node, target.parent, this.clock.now(), target.basis);
-    if (this.config.workspaceTracking !== "legacy") await appendEvent(dir, node, {
+    await appendEvent(dir, node, {
       t: "rewind", id: this.clock.nextId(), at: this.clock.now(), mode: "context", from: target.parent ?? filesFrom,
       files_from: filesFrom, prompt: target.editorText ?? "Selected conversation position", restored: [], removed: [], unrecoverable: [], divergence: [],
     });
@@ -877,29 +848,26 @@ export class Session {
    * handlers.
    */
   private async persistContext(frozen = this.config.frozen, skills = this.config.skills): Promise<string> {
-    return putBlob(join(this.config.logDir, "artifacts"), JSON.stringify({
-      projectionVersion: PROJECTION_VERSION,
-      workspaceTracking: this.config.workspaceTracking ?? "journal",
-      shellCheckpoints: this.config.shellCheckpoints === true,
-      ...(skills?.length ? { skills } : {}),
-      ...(this.config.acceptanceContract ? { acceptanceContract: this.config.acceptanceContract } : {}),
-      ...(this.config.strictVerification ? { strictVerification: true } : {}),
-      ...(this.config.workingSet ? { workingSet: true } : {}),
-      ...(this.config.workingSet && this.config.workingSetVersion === 2 ? { workingSetVersion: 2 } : {}),
-      ...(this.config.guidanceVersion === 1 ? { guidanceVersion: 1 } : {}),
+    const context: SessionContext = {
       frozen, gates: this.config.tools.gates,
-      ...(this.config.tools.workflowMode ? { workflowMode: this.config.tools.workflowMode } : {}),
-      ...(this.config.agentProfile ? { agentProfile: this.config.agentProfile } : {}),
-      ...(this.config.workflowToolProfile ? { workflowToolProfile: this.config.workflowToolProfile } : {}),
+      shellCheckpoints: this.config.shellCheckpoints === true,
+      skills: skills ?? [],
+      strictVerification: this.config.strictVerification === true,
+      workingSet: this.config.workingSet === true,
       workNamespace: this.config.workNamespace ?? "main",
       maxParallelTools: this.config.maxParallelTools ?? 3,
-      ...(this.config.boundary ? { boundary: this.config.boundary } : {}),
       contextPolicy: this.config.contextPolicy ?? DEFAULT_CONTEXT_POLICY,
       stallLimit: this.config.stallLimit ?? DEFAULT_STALL_LIMIT,
       outputRecoveryLimit: this.config.outputRecoveryLimit ?? DEFAULT_OUTPUT_RECOVERY_LIMIT,
+      ...(this.config.acceptanceContract ? { acceptanceContract: this.config.acceptanceContract } : {}),
+      ...(this.config.tools.workflowMode ? { workflowMode: this.config.tools.workflowMode } : {}),
+      ...(this.config.agentProfile ? { agentProfile: this.config.agentProfile } : {}),
+      ...(this.config.workflowToolProfile ? { workflowToolProfile: this.config.workflowToolProfile } : {}),
+      ...(this.config.boundary ? { boundary: this.config.boundary } : {}),
       ...(this.config.guidance === undefined ? {} : { guidance: this.config.guidance }),
-      ...(this.config.snapshotIgnore ? { snapshotIgnore: this.config.snapshotIgnore } : {}),
-    }));
+      ...(this.config.blindChecks ? { blindChecks: this.config.blindChecks } : {}),
+    };
+    return putBlob(join(this.config.logDir, "artifacts"), JSON.stringify(context));
   }
 
   private async saveCursor(model = this.provider.config.spec.id, provider = this.provider.config.spec.provider,
@@ -1023,32 +991,106 @@ export class Session {
   contextInput(): ProjectInput {
     return { frozen: this.config.frozen, handoff: this.state.handoff, events: this.state.events,
       logHint: { manifestPath: manifestPath(this.config.logDir),
-        ...(this.config.guidanceVersion === 1 ? { scopedGuidance: true } : {}),
         segmentPath: this.state.handoff?.predecessor?.log_ref ?? nodePath(this.config.logDir, this.state.node) } };
   }
 
   private async boundCarried(full: Handoff, tools = this.adviceNames()): Promise<Handoff> {
     return carriedHandoff(this.config.logDir, this.state.node, full, { handoff_tokens: DEFAULT_HANDOFF_TOKENS,
-      ...(this.config.workingSet ? { working_set_version: this.config.workingSetVersion ?? 1 } : {}),
-      ...(this.config.guidanceVersion === 1 ? { guidance_tools: tools } : {}) });
+      ...(this.config.workingSet ? { working_set_version: 2 as const } : {}), guidance_tools: tools });
   }
 
   async acceptanceState(): Promise<AcceptanceState | undefined> {
     if (!this.running) await this.observeEvidence();
     // External editor changes must invalidate proof before the user reads it.
-    if (!this.running) for await (const result of this.snapshotTurn([], false, "idle")) {
-      if (result.kind === "snapshot_failed") throw new Error(`cannot inspect an unobserved workspace: ${result.reason}`);
-    }
     if (!this.running) await this.refreshRuntimeTargets();
     return (await this.currentHandoff()).acceptance;
   }
 
+  /** S.5: the goal in force, derived from the active log ancestry, so it survives restarts and resume. */
+  async goal(): Promise<ActiveGoal | null> {
+    const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
+    if (!history.ok) throw new Error(history.error);
+    return activeGoal(history.nodes.flatMap(part => part.events));
+  }
+
+  /**
+   * Records a goal from criteria the user accepted out of a model draft. The
+   * draft event must be this session's assistant reply; the contract holds
+   * only what was accepted (S.2).
+   */
+  async setGoal(input: { objective: string; draft: string; criteria: readonly AcceptanceCriterion[]; accepted: readonly string[] }): Promise<ActiveGoal> {
+    if (this.running || this.isHalfRound()) throw new Error("a goal can be set only while the session is idle");
+    if (!input.objective.trim()) throw new Error("a goal needs an objective");
+    const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
+    if (!history.ok) throw new Error(history.error);
+    if (!history.nodes.some(part => part.events.some(event => event.t === "assistant" && event.id === input.draft))) throw new Error("the goal draft is not in this session");
+    const contract = goalContract(input.criteria, input.accepted);
+    const accepted = contract.criteria.map(item => item.id);
+    const event: ActiveGoal = { t: "goal", id: this.clock.nextId(), at: this.clock.now(), action: "set", objective: input.objective.trim(),
+      contract, draft: input.draft, accepted, rejected: input.criteria.map(item => item.id).filter(id => !accepted.includes(id)) };
+    await this.record(event);
+    await this.saveCursor();
+    return event;
+  }
+
+  /**
+   * The discriminating rung: each passing accepted check re-run in a clone with
+   * this request's changes undone, recorded as counter_check facts with the
+   * role each criterion was declared with. Guards run too: passing there is
+   * what makes a guard a guard (S.7). The goal's verdict does not depend on it;
+   * it tells the user which checks actually tested the change.
+   */
+  private async counterCheckRequest(state: RequestState, signal?: AbortSignal): Promise<void> {
+    const checks = state.criteria.flatMap(item => item.kind === "command" && item.status === "pass" && item.command
+      ? [{ id: item.id, command: item.command, ...(item.guard ? { guard: true as const } : {}) }] : []);
+    if (checks.length === 0 || signal?.aborted) return;
+    const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
+    if (!history.ok) throw new Error(history.error);
+    const events = currentRequestRecords(history.nodes).map(record => record.event);
+    // A snapshot taken when this request began reverts shell changes too; otherwise the journal does.
+    const workspace = this.config.tools.workspace, base = this.goalBaseline?.request === state.request.event ? this.goalBaseline.snapshot : null;
+    const now = base && workspace ? await workspace.snapshot(signal) : null;
+    const revert = base && now && workspace ? invertFileChanges(await workspace.snapshotChanges(base, now, signal)) : undefined;
+    const results = !this.config.blobDir ? checks.map(check => ({ ...check, reason: "this session keeps no file history to undo changes from" }))
+      : await counterCheck({ root: this.config.tools.root, blobs: this.config.blobDir, ownedPaths: this.config.tools.ownedStatePaths ?? [],
+        events, checks, timeoutMs: this.config.tools.timeoutMs, maxOutputBytes: this.config.tools.maxOutputBytes,
+        outputStore: join(this.config.logDir, "artifacts"), ...(revert ? { revert } : {}), ...(signal ? { signal } : {}) });
+    for (const result of results) await this.record({ t: "counter_check", id: this.clock.nextId(), at: this.clock.now(), request: state.request.event,
+      criterion: result.id, command: result.command, ...(result.guard ? { guard: true as const } : {}),
+      ...("exit" in result ? { exit: result.exit } : { reason: result.reason }) });
+  }
+
+  /**
+   * The independent rung: blind checks run on a clone of the final result once
+   * the goal's own checks pass. The scan for exposure covers the whole log, not
+   * just this request -- a blind file read yesterday is still seen.
+   */
+  private async blindCheckRequest(state: RequestState, signal?: AbortSignal): Promise<void> {
+    const blind = this.config.blindChecks;
+    if (!blind || signal?.aborted) return;
+    const nodes = await listNodes(this.config.logDir);
+    const everything = (await Promise.all(nodes.map(node => readNode(this.config.logDir, node)))).flatMap(read => read.events);
+    const exposure = blindExposure(everything, blind);
+    const results = await runBlindChecks({ root: this.config.tools.root, blind, timeoutMs: this.config.tools.timeoutMs,
+      maxOutputBytes: this.config.tools.maxOutputBytes, outputStore: join(this.config.logDir, "artifacts"), ...(signal ? { signal } : {}) });
+    for (const result of results) await this.record({ t: "blind_check", id: this.clock.nextId(), at: this.clock.now(), request: state.request.event,
+      check: result.id, exposed: exposure !== null, ...(exposure ? { exposure } : {}), ...("exit" in result ? { exit: result.exit } : { reason: result.reason }) });
+  }
+
+  async clearGoal(): Promise<boolean> {
+    if (this.running) throw new Error("a goal can be cleared only while the session is idle");
+    if (!await this.goal()) return false;
+    await this.record({ t: "goal", id: this.clock.nextId(), at: this.clock.now(), action: "clear", reason: "user" });
+    await this.saveCursor();
+    return true;
+  }
+
   async requestState(): Promise<RequestState | undefined> {
     // Use the same idle workspace/target observation boundary as /acceptance.
     if (!this.running) await this.acceptanceState();
     const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
     if (!history.ok) throw new Error(history.error);
-    return deriveRequestState(history.nodes);
+    return deriveRequestState(history.nodes, { strict: this.config.strictVerification === true, blind: this.config.blindChecks !== undefined });
   }
 
   /** Only called at paired, owned boundaries; probes never enter a pending model tool exchange. */
@@ -1131,9 +1173,6 @@ export class Session {
   /** Only the app's user command calls this; note never grants human acceptance. */
   async acceptCriterion(criterion: string): Promise<AcceptanceState> {
     if (this.running || this.isHalfRound()) throw new Error("acceptance requires an idle, paired request");
-    for await (const result of this.snapshotTurn([], true)) {
-      if (result.kind === "snapshot_failed") throw new Error(`cannot accept an unobserved workspace: ${result.reason}`);
-    }
     const current = await this.acceptanceState();
     const item = current?.criteria.find(item => item.id === criterion && item.kind === "human");
     if (!current || !item || item.kind !== "human") throw new Error("unknown human acceptance criterion");
@@ -1192,6 +1231,7 @@ export class Session {
     signal?: AbortSignal,
     pull?: (phase: Phase) => Promise<UserInput | null>,
     requestId?: string,
+    options: RequestOptions = {},
   ): AsyncGenerator<LoopEvent> {
     if (this.cleanup || this.closing) throw new Error("session is draining or disposed");
     const owned = this.execution.begin(signal);
@@ -1200,7 +1240,7 @@ export class Session {
     this.turnTools = savedTools;
     this.config.tools = { ...savedTools };
     this.installSkillResources();
-    const events = this.run(userText, owned.signal, pull, requestId);
+    const events = this.run(userText, owned.signal, pull, requestId, options);
     let terminal = false;
     let exhausted = false;
     try {
@@ -1219,10 +1259,11 @@ export class Session {
         yield item.value;
       }
       if (!terminal) {
-        const outcome = executionOutcome("snapshot_failed");
-        await this.record({ t: "outcome", id: this.clock.nextId(), at: this.clock.now(), reason: "workspace snapshot failed", outcome });
+        // Every path through run() ends with `done` or throws; this records the impossible case honestly.
+        const outcome = executionOutcome("execution_error");
+        await this.record({ t: "outcome", id: this.clock.nextId(), at: this.clock.now(), reason: "request ended without a terminal outcome", outcome });
         const request = await this.requestState();
-        yield { kind: "done", reason: "stopped: workspace snapshot failed", outcome, ...(request ? { request } : {}) };
+        yield { kind: "done", reason: "stopped: request ended without a terminal outcome", outcome, ...(request ? { request } : {}) };
       }
     } catch (error) {
       // Raw provider exceptions can contain credentials; persist only the execution fact.
@@ -1238,7 +1279,7 @@ export class Session {
         }
       } finally {
         while (this.hostPending.size > 0) await Promise.allSettled(this.hostPending);
-        this.config.tools = savedTools; this.turnTools = null;
+        this.config.tools = savedTools; this.turnTools = null; this.readOnlyRequest = false;
         if (owned.signal.aborted) this.cancel();
         owned.finish();
         if (owned.signal.aborted) await this.whenIdle();
@@ -1251,6 +1292,7 @@ export class Session {
     signal?: AbortSignal,
     pull?: (phase: Phase) => Promise<UserInput | null>,
     requestId?: string,
+    options: RequestOptions = {},
   ): AsyncGenerator<LoopEvent> {
     // A crash after a discovery receipt but before its cut is recovered from that same receipt.
     if (!signal?.aborted) await this.applyDiscoveredTools();
@@ -1265,48 +1307,53 @@ export class Session {
       await this.performCut("model_checkpoint");
     }
     const request = requestId ?? this.clock.nextId();
+    // S.5: a draft request has no goal yet and must not inherit the current one.
+    this.readOnlyRequest = options.readOnly === true;
+    const goal = options.readOnly ? null : await this.goal();
+    const contract = goal?.contract ?? this.config.acceptanceContract;
     await this.record({ t: "user", id: request, at: this.clock.now(), ...userInputData(userText, blocked) });
-    if (this.config.acceptanceContract) await this.record({ t: "acceptance_contract", id: this.clock.nextId(), at: this.clock.now(),
-      request: this.state.events.at(-1)!.id, contract: this.config.acceptanceContract });
+    if (contract) await this.record({ t: "acceptance_contract", id: this.clock.nextId(), at: this.clock.now(),
+      request: this.state.events.at(-1)!.id, contract });
+    // The state a counter-check must rebuild before it may run (feat-counter-check).
+    if (goal) {
+      await this.config.tools.workspace?.baseline(signal);
+      const snapshot = await this.config.tools.workspace?.snapshot(signal);
+      this.goalBaseline = snapshot ? { request, snapshot } : null;
+    }
     // Idle changes belong to the new prompt. Recording them before `user`
     // would silently move the preceding exchange's restore point forward.
-    for await (const event of this.snapshotTurn([])) {
-      yield event;
-      if (event.kind === "snapshot_failed") return;
-    }
 
     const counter = this.config.counter ?? estimateTokens;
-    const completedThisTurn: string[] = [];
 
     try {
       let overflowRetried = false;
       const requestStarted = this.clock.now();
-      for (let turn = 0; turn < this.config.maxTurns; turn++) {
-        const phase = requestPhase(turn, this.config.maxTurns);
-        completedThisTurn.length = 0;
+      const requestLimit = options.readOnly ? Math.min(READ_ONLY_REQUEST_LIMIT, this.config.maxTurns) : this.config.maxTurns;
+      const report = (cause: string, requests: number) => this.terminationReport(cause, requests, requestLimit);
+      for (let turn = 0; turn < requestLimit; turn++) {
+        const phase = requestPhase(turn, requestLimit);
         if (signal?.aborted) {
-          yield* this.closeInterrupted(completedThisTurn);
+          yield* this.closeInterrupted();
           return;
         }
 
         if (yield* this.checkStall()) {
-          yield { kind: "done", reason: await this.terminationReport("no-progress allowance exhausted", turn), outcome: executionOutcome("stalled") };
+          yield { kind: "done", reason: await report("no-progress allowance exhausted", turn), outcome: executionOutcome("stalled") };
           return;
         }
         if (phase === "finalize" && !supportsToolDisabling(this.provider.config.spec.api)) {
-          yield { kind: "done", reason: await this.terminationReport("work budget exhausted; protocol cannot disable tools while preserving frozen definitions", turn), outcome: executionOutcome("max_turns") };
+          yield { kind: "done", reason: await report("work budget exhausted; protocol cannot disable tools while preserving frozen definitions", turn), outcome: executionOutcome("max_turns") };
           return;
         }
         yield { kind: "turn_start", node: this.state.node };
 
         if (phase === "finalize") {
           await this.record({ t: "guidance", id: this.clock.nextId(), at: this.clock.now(), reason: "budget", sources: [], text: finalizationNotice() });
-        } else if (this.config.guidance !== false) {
+        } else if (!options.readOnly && this.config.guidance !== false) {
           const names = this.adviceNames();
           const guidance = (this.config.harnessReviews === false ? null : await this.recoveryGuidance(names)) ??
             continuationGuidance({ events: this.state.events, handoff: this.state.handoff,
             tools: names, remainingRequests: this.config.maxTurns - turn,
-            ...(this.config.guidanceVersion === 1 ? { taskAware: true } : {}),
             ...(this.config.continuationAfter === undefined ? {} : { minAssistantTurns: this.config.continuationAfter }) }) ??
             (this.config.timeBudgetMs === undefined ? null
               : deadlineNotice(requestStarted, this.clock.now(), this.config.timeBudgetMs, this.state.events)) ??
@@ -1348,12 +1395,12 @@ export class Session {
           // D11: retain a typed response receipt once, without anchoring rejected content or trusting arbitrary error fields.
           if (error instanceof FailedResponseError && error.usage !== undefined) this.state.usage.push({ ...error.usage });
           if (signal?.aborted) {
-            yield* this.closeInterrupted(completedThisTurn);
+            yield* this.closeInterrupted();
             return;
           }
           if (phase === "finalize") {
             yield { kind: "discard" };
-            yield { kind: "done", reason: await this.terminationReport("final response failed; no additional request was made", turn + 1), outcome: executionOutcome("provider_error") };
+            yield { kind: "done", reason: await report("final response failed; no additional request was made", turn + 1), outcome: executionOutcome("provider_error") };
             return;
           }
           if (!(error instanceof Error) || !isContextOverflow(error.message, statusOf(error))) throw error;
@@ -1382,7 +1429,7 @@ export class Session {
         if (signal?.aborted) {
           yield { kind: "usage", usage: result.usage, ok: true };
           yield { kind: "discard" };
-          yield* this.closeInterrupted(completedThisTurn);
+          yield* this.closeInterrupted();
           return;
         }
         const promptTokens =
@@ -1452,7 +1499,7 @@ export class Session {
             !result.blocks.some(block => block.type === "text" && block.text.trim()))) {
           for (const item of await this.answerUnpairedTools("not executed: tools are disabled in the final request", "not_started"))
             yield { kind: "tool_result", text: item.content, ok: false };
-          yield { kind: "done", reason: await this.terminationReport("request budget exhausted; final response did not provide a complete text answer", turn + 1), outcome: executionOutcome("max_turns") };
+          yield { kind: "done", reason: await report("request budget exhausted; final response did not provide a complete text answer", turn + 1), outcome: executionOutcome("max_turns") };
           return;
         }
 
@@ -1491,13 +1538,21 @@ export class Session {
             });
             continue;
           }
-          if (this.config.acceptanceContract) await this.refreshRuntimeTargets();
+          if (contract) await this.refreshRuntimeTargets();
           const state = await this.requestState();
-          const decision = !state || this.config.guidance === false || this.config.harnessReviews === false ? { action: "finish" as const }
-            : requestCompletion(state, this.config.maxTurns - turn - 1, {
-              ...(this.config.guidanceVersion === 1 ? { taskAware: true } : {}),
-              ...(this.config.strictVerification ? { strictVerification: true } : {}),
-            });
+          const remaining = requestLimit - turn - 1;
+          // S.5: an active goal replaces the one-time completion check. It keeps
+          // the request going until the ledger says the goal is met; a stated
+          // blocker, a spent budget or the stall watchdog still end the run.
+          const verdict = goal && state ? goalDecision(state, remaining, idleGoalChecks(this.state.events)) : null;
+          if (state && (verdict?.action === "met" || verdict?.action === "await_human")) {
+            await this.counterCheckRequest(state, signal);
+            await this.blindCheckRequest(state, signal);
+          }
+          if (verdict?.action === "met") await this.record({ t: "goal", id: this.clock.nextId(), at: this.clock.now(), action: "clear", reason: "met" });
+          const decision = verdict?.action === "continue" ? { action: "continue" as const, guidance: { reason: "goal" as const, sources: [state!.request.event], text: verdict.text } }
+            : verdict || !state || options.readOnly || this.config.guidance === false || this.config.harnessReviews === false ? { action: "finish" as const }
+            : requestCompletion(state, remaining);
           if (decision.action === "continue") {
             if (yield* this.maybeCut(counter, true)) {
               yield { kind: "done", reason: "stopped: no verifiable progress", outcome: executionOutcome("no_progress") };
@@ -1530,7 +1585,7 @@ export class Session {
         try { for (let callIndex = 0; callIndex < calls.length; callIndex++) {
           const call = calls[callIndex]!;
           if (signal?.aborted && !pending.has(call.call_id)) {
-            yield* this.closeInterrupted(completedThisTurn);
+            yield* this.closeInterrupted();
             return;
           }
 
@@ -1553,9 +1608,9 @@ export class Session {
             if (!settled.ok) throw settled.error;
             receipt = settled.value;
           } else {
-            if (signal?.aborted) { yield* this.closeInterrupted(completedThisTurn); return; }
+            if (signal?.aborted) { yield* this.closeInterrupted(); return; }
             yield { kind: "tool_call", tool: { name: call.name, input: call.input } };
-            if (signal?.aborted) { yield* this.closeInterrupted(completedThisTurn); return; }
+            if (signal?.aborted) { yield* this.closeInterrupted(); return; }
             const prepared = yield* this.prepareBrokerCall(call, () => branchesThisTurn++, blocked, signal);
             receipt = yield* withProgress<SessionBrokerReceipt, LoopEvent>(emit => prepared.run(emit));
           }
@@ -1567,9 +1622,8 @@ export class Session {
           yield { kind: "tool_result", text: out.content, ok: out.ok, outcome: out.outcome! };
           await receipt.commit();
 
-          completedThisTurn.push(call.call_id);
           if (signal?.aborted && pending.size === 0) {
-            yield* this.closeInterrupted(completedThisTurn);
+            yield* this.closeInterrupted();
             return;
           }
         } } finally { await Promise.allSettled(pending.values()); }
@@ -1577,7 +1631,6 @@ export class Session {
         // One scan per turn, not per tool call: a turn is the smallest unit
         // that means anything, and per-call would be the character-level
         // granularity the research warns against.
-        yield* this.snapshotTurn(calls.map((c) => c.call_id));
         const declarationNode = this.state.node;
         if (!signal?.aborted && await this.applyDiscoveredTools()) yield { kind: "cut", node: declarationNode, reason: "model_checkpoint" };
         if (this.pendingAdoption !== null) await this.adoptPendingBranch();
@@ -1596,7 +1649,7 @@ export class Session {
         }
       }
 
-      yield { kind: "done", reason: await this.terminationReport("request budget exhausted", this.config.maxTurns), outcome: executionOutcome("max_turns") };
+      yield { kind: "done", reason: await report("request budget exhausted", requestLimit), outcome: executionOutcome("max_turns") };
     } finally {
       // If the consumer aborts and stops pulling, the generator is closed
       // without running the yield* closeInterrupted path. Pairing still
@@ -1636,14 +1689,11 @@ export class Session {
     return added;
   }
 
-  private async *closeInterrupted(completedCallIds: readonly string[]): AsyncGenerator<LoopEvent> {
+  private async *closeInterrupted(): AsyncGenerator<LoopEvent> {
     const added = await this.answerUnpairedTools();
     for (const item of added) {
       yield { kind: "tool_result", text: item.content, ok: false };
     }
-    if (completedCallIds.length > 0) {
-      yield* this.snapshotTurn(completedCallIds);
-    }
     await this.recordInterrupt();
     yield { kind: "done", reason: "interrupted", outcome: executionOutcome("cancelled") };
   }
@@ -1709,78 +1759,6 @@ export class Session {
    * Returning the verdict rather than only announcing it is the point: an
    * advisory the loop ignores looks like a guard while the budget drains.
    */
-  /**
-   * Records what the workspace actually did this turn.
-   *
-   * Content goes to the blob store so a later restore has something to
-   * restore from; the event holds only digests, which is what keeps it a
-   * delta rather than a copy of the workspace.
-   */
-  private async *snapshotTurn(callIds: readonly string[], baseline = false, phase: "turn" | "idle" = "turn"): AsyncGenerator<LoopEvent> {
-    // P.3: retained only for explicit historical compatibility. New sessions never scan here.
-    if (this.config.workspaceTracking !== "legacy") return;
-    const blobDir = this.config.blobDir;
-    if (!blobDir) return;
-
-    const scan = await scanWorkspace(
-      this.config.tools.root,
-      this.config.snapshotIgnore ?? DEFAULT_IGNORE,
-    );
-    if (!scan.ok) {
-      // Reported rather than skipped: without a scan a restore would delete
-      // files it never recorded, so the caller has to know it is blind.
-      yield { kind: "snapshot_failed", reason: scan.error };
-      return;
-    }
-
-    const delta = diffScans(this.state.lastScan, scan.files);
-    const nothingHappened =
-      Object.keys(delta.added).length === 0 &&
-      Object.keys(delta.changed).length === 0 &&
-      delta.removed.length === 0;
-    if (nothingHappened) return;
-
-    // Only this turn's effects: reconciling against the whole node would
-    // report every earlier edit as declared-but-unchanged.
-    const answered = new Set(callIds);
-    const effects = this.state.events
-      .filter((e) => e.t === "tool_result" && answered.has(e.call_id) && e.effect)
-      .map((e) => (e as Extract<LogEvent, { t: "tool_result" }>).effect!);
-    const rec = reconcile(effects, delta);
-
-    for (const [path, sha] of Object.entries({ ...delta.added, ...delta.changed })) {
-      const stored = await putFileBlob(blobDir, join(this.config.tools.root, path));
-      if (stored !== sha) {
-        // The file changed between the scan and the read. Recording the
-        // digest that was actually stored keeps the event honest.
-        if (path in delta.added) delta.added[path] = stored;
-        else delta.changed[path] = stored;
-        scan.files[path] = stored;
-      }
-    }
-
-    await this.record({
-      t: "snapshot",
-      id: this.clock.nextId(),
-      at: this.clock.now(),
-      added: delta.added,
-      changed: delta.changed,
-      removed: delta.removed,
-      undeclared: baseline ? [] : rec.undeclared,
-      declared_but_unchanged: rec.declaredButUnchanged,
-      workspace_sha256: workspaceVersion(scan.files),
-      phase,
-    });
-    this.state.lastScan = scan.files;
-
-    if (!baseline && rec.undeclared.length > 0) {
-      yield {
-        kind: "undeclared_change",
-        reason: `changed with no tool claiming it: ${rec.undeclared.join(", ")}`,
-      };
-    }
-  }
-
   private get limits(): BranchLimits {
     return { ...DEFAULT_BRANCH_LIMITS, ...this.config.branches };
   }
@@ -1843,7 +1821,8 @@ export class Session {
     try {
       const events: LoopEvent[] = [];
       let emit = (event: LoopEvent) => { events.push(event); };
-      let context: ToolContext = { ...this.config.tools, imageStore: this.config.blobDir ?? join(this.config.logDir, "blobs"),
+      let context: ToolContext = { ...this.config.tools, ...(this.readOnlyRequest ? { workflowMode: "plan" as const, planHint: READ_ONLY_HINT } : {}),
+        imageStore: this.config.blobDir ?? join(this.config.logDir, "blobs"),
         advice: this.allowedNames(),
         imageAutoResize: this.config.imageOptions?.autoResize ?? true, ...(signal ? { signal } : {}) };
       if (native) context = nativeCommandContext(context);
@@ -1935,7 +1914,8 @@ export class Session {
       ...(out.outcome ? { outcome: out.outcome } : {}), ...(data !== undefined ? { data } : {}), ...(dataRef ? { data_ref: dataRef } : {}),
       ...(out.observation_sha256 !== undefined ? { observation_sha256: out.observation_sha256 } : {}),
       ...(out.observation ? { observation: out.observation } : {}), ...(out.diagnostic ? { diagnostic: out.diagnostic } : {}),
-      ...(out.warnings ? { warnings: out.warnings } : {}), ...(out.content_sha256 ? { content_sha256: out.content_sha256 } : {}),
+      ...(out.warnings ? { warnings: out.warnings } : {}), ...(out.instructions ? { instructions: out.instructions } : {}),
+      ...(out.content_sha256 ? { content_sha256: out.content_sha256 } : {}),
       ...(out.content_ref ? { content_ref: out.content_ref } : {}),
       ...(out.images?.length ? { images: submissionImages(out.images, blockedImages) } : {}), ...(out.effect ? { effect: out.effect } : {}) });
   }
@@ -2052,7 +2032,6 @@ export class Session {
     this.state.branchesOpened += 1;
     const ref = await this.nodeRefFor(node);
     // A fork point must include any preceding tool effects in this batch.
-    yield* this.snapshotTurn([]);
 
     // A writing branch needs its own checkout, or parallel branches overwrite
     // each other's files with nothing to show isolation was never in place.
@@ -2107,7 +2086,6 @@ export class Session {
     );
     branch.state.node = node;
     branch.state.nextNode = this.state.nextNode;
-    branch.state.lastScan = { ...this.state.lastScan };
     if (skill) await branch.recordSkill(skill, "fork", skillOrigin);
     this.children.set(node, branch);
     yield { kind: "branch_start", node, reason: purpose, at: Date.now() };
@@ -2115,9 +2093,6 @@ export class Session {
     let finalParts: string[] = [];
     let outcome = executionOutcome("unknown");
     try {
-      for await (const event of branch.snapshotTurn([], true)) {
-        if (event.kind === "snapshot_failed") throw new Error(`cannot establish branch baseline: ${event.reason}`);
-      }
       for await (const e of branch.send(prompt, signal)) {
         if (e.kind === "turn_start" || e.kind === "discard") finalParts = [];
         if (e.kind === "assistant_text") finalParts.push(e.text ?? "");
@@ -2342,11 +2317,6 @@ export class Session {
       }
       const checkout = this.state.worktrees.get(root);
       if (checkout) this.config.tools.root = checkout.path;
-      if (this.config.workspaceTracking === "legacy") {
-        const scan = await scanWorkspace(this.config.tools.root, this.ignore);
-        if (!scan.ok) throw new Error(`cannot adopt workspace: ${scan.error}`);
-        this.state.lastScan = scan.files;
-      }
       this.installWorkspace();
       await this.saveCursor();
       this.pendingAdoption = null;
@@ -2466,10 +2436,6 @@ export class Session {
     } catch (error) { return { ok: false, error: String(error) }; }
   }
 
-  private get ignore(): readonly string[] {
-    return this.config.snapshotIgnore ?? DEFAULT_IGNORE;
-  }
-
   /**
    * Every completed exchange, including abandoned branches and conversation-only turns.
    *
@@ -2519,14 +2485,6 @@ export class Session {
       for (const e of n.events) {
         if (e.t === "workspace_observation") continue;
         if (e.t === "checkpoint" && e.source === "restore") { close(); open = null; continue; }
-        if (e.t === "snapshot" && e.phase === "idle") {
-          close();
-          open = null;
-          points.push({ node: n.node, atEvent: e.id, prompt: "Observed workspace changes",
-            changed: Object.keys(e.added).length + Object.keys(e.changed).length + e.removed.length,
-            onPath: onPath.has(e.id) });
-          continue;
-        }
         if (e.t === "user") {
           close();
           open = { prompt: e.text, changed: 0, last: e.id, userId: e.id };
@@ -2535,10 +2493,6 @@ export class Session {
         if (!open) continue;
         open.last = e.id;
         if (e.t === "checkpoint" && e.phase === "applied") open.changed += changedPaths(e.changes).length;
-        if (e.t === "snapshot") {
-          open.changed +=
-            Object.keys(e.added).length + Object.keys(e.changed).length + e.removed.length;
-        }
       }
       close();
     }
@@ -2560,21 +2514,12 @@ export class Session {
       return { ok: true, willWrite: changedPaths(changes).filter(path => changes[path]!.after !== null),
         willDelete: changedPaths(changes).filter(path => changes[path]!.after === null) };
     }
-    if (this.config.workspaceTracking !== "legacy") {
-      try {
-        const changes = await planCheckpointRestore(this.config.logDir, this.state.node, { node: point.node, atEvent: point.atEvent });
-        if (this.config.blobDir) await preflightChanges(this.config.tools.root, this.config.blobDir, changes);
-        return { ok: true, willWrite: changedPaths(changes).filter(path => changes[path]!.after !== null),
-          willDelete: changedPaths(changes).filter(path => changes[path]!.after === null) };
-      } catch (error) { return { ok: false, error: String(error) }; }
-    }
-    const plan = await planRestoreToNode(
-      this.config.logDir, { node: point.node, atEvent: point.atEvent },
-      undefined, this.config.tools.root, this.ignore,
-    );
-    return plan.ok
-      ? { ok: true, willWrite: plan.willWrite, willDelete: plan.willDelete }
-      : { ok: false, error: plan.error };
+    try {
+      const changes = await planCheckpointRestore(this.config.logDir, this.state.node, { node: point.node, atEvent: point.atEvent });
+      if (this.config.blobDir) await preflightChanges(this.config.tools.root, this.config.blobDir, changes);
+      return { ok: true, willWrite: changedPaths(changes).filter(path => changes[path]!.after !== null),
+        willDelete: changedPaths(changes).filter(path => changes[path]!.after === null) };
+    } catch (error) { return { ok: false, error: String(error) }; }
   }
 
   /**
@@ -2592,145 +2537,9 @@ export class Session {
    * conversation node. File-only restoration appends its observed transition.
    */
   async rewind(point: RestorePoint, mode: RewindMode = "both"): Promise<RewindResult> {
-    if (this.config.workspaceTracking !== "legacy") return this.rewindJournal(point, mode);
-    const dir = this.config.logDir;
-    const root = this.config.tools.root;
-    const target = { node: point.node, atEvent: point.atEvent };
-    const movesFiles = mode !== "context";
-
-    const blobDir = this.config.blobDir;
-    // Only the modes that move files need somewhere to read them from. A
-    // context-only rewind is the one thing still worth offering a session
-    // that never took snapshots, so requiring them would refuse it for no
-    // reason.
-    if (movesFiles && !blobDir) {
-      return {
-        ok: false,
-        error: "this session stores no snapshots, so the files cannot be moved back",
-      };
-    }
-
-    // Planned before anything is written: an unresolvable target must leave
-    // the session exactly where it was, not half moved. The plan is also
-    // what every mode needs -- to apply, or to say what it is NOT applying.
-    const plan = await planRestoreToNode(dir, target, undefined, root, this.ignore);
-    if (!plan.ok) return { ok: false, error: plan.error };
-    const historical = await readCursorAt(dir, point.node, point.atEvent);
-    // Preserve idle edits before moving away from them. An unobserved file is
-    // not disposable just because the target predates it (D8/appendix H).
-    for await (const event of this.snapshotTurn([], false, "idle")) {
-      if (event.kind === "snapshot_failed") return { ok: false, error: event.reason ?? "snapshot failed" };
-    }
-    const beforeFiles = { ...this.state.lastScan };
-
-    // Computed BEFORE anything is applied. Both partial modes diverge over
-    // the same set -- where the target and the workspace as it stands now
-    // disagree -- and only the story differs, which `mode` already carries.
-    // Computing it afterwards gave "files" an empty set, because by then the
-    // disk had become the target: the note still said to re-read but named
-    // nothing, which is the vague form this is meant to replace.
-    const divergence = mode === "both" ? [] : await this.divergenceFrom(plan.files);
-
-    let moved: RestoreResult = {
-      restored: [], removed: [], unrecoverable: [],
-      note: "The workspace was left exactly as it is; only the conversation moved.",
-    };
-    if (movesFiles && blobDir) {
-      // Applied from the plan just computed rather than through
-      // restoreToNode, which would re-plan: a second traversal, and a guard
-      // here that could never fire because the only way the apply fails is a
-      // plan that failed.
-      moved = await applyRestorePlan(
-        root, blobDir, plan.files, this.ignore,
-        `the point where you were asked: ${point.prompt.slice(0, 40)}`,
-      );
-      if (moved.unrecoverable.length > 0) return { ok: true, node: this.state.node, ...moved };
-    }
-
-    const from: NodeRef = { ...await digestedRef(dir, point.node), at_event: point.atEvent };
-    const stamp = { id: this.clock.nextId(), at: this.clock.now() };
-    const event: LogEvent = {
-      t: "rewind", ...stamp, mode, from, prompt: point.prompt,
-      restored: moved.restored, removed: moved.removed,
-      unrecoverable: moved.unrecoverable, divergence,
-    };
-
-    if (mode === "files") {
-      // No fork. The conversation did not move, so the node did not either;
-      // a new node would be identical to this one but for a single event.
-      await this.record(event);
-      this.state.lastScan = beforeFiles;
-      for await (const result of this.snapshotTurn([], true)) {
-        if (result.kind === "snapshot_failed") throw new Error(result.reason);
-      }
-      return { ok: true, node: this.state.node, ...moved };
-    }
-
-    const node = this.state.nextNode++;
-    // "inherit": the point of a rewind is to continue from the target as if
-    // the turns after it had not happened, so the target's events replay.
-    await initNode(dir, node, from, this.clock.now(), "inherit");
-
-    // The running session projects from state.events, which a new node starts
-    // empty -- correct for a cut, where the handoff replaces them, and wrong
-    // here. The inherited events come from the ancestry walk, which is the
-    // same function the projection would use and already honours both the
-    // fork point and any cut further up.
-    const replayed = await replayContext(dir, node);
-
-    this.state.node = node;
-    this.state.events = [];
-    this.state.handoff = replayed.handoff;
-    this.resetDerivedToolState();
-    this.state.depth = replayed.depth;
-    // The new node's prefix has never been sent, so nothing to anchor to.
-    this.state.anchor = null;
-    // The scan baseline follows the files, which a context-only rewind did
-    // not move. Setting it to the plan there would make the next turn report
-    // the untouched workspace as a change nobody declared.
-    this.state.lastScan = plan.files;
-    // Path depth comes from replay; the monotonic allocator still accounts
-    // for every node spent outside this selected path.
-
-    await this.record(event);
-    // Recorded first, then replayed, so the rewind event stays the node's own
-    // annotation rather than something the inherited context contains.
-    this.state.events = [...replayed.contextEvents, ...this.state.events];
-    // A context-only fork inherits old file history while the disk stays
-    // newer. Record that delta now, so later replay cannot resurrect a stale
-    // workspace and the next tool starts from the actual files.
-    for await (const result of this.snapshotTurn([], true)) {
-      if (result.kind === "snapshot_failed") throw new Error(result.reason);
-    }
-    const incompatible = historical === null || !sameModel(historical, {
-      model: this.provider.config.spec.id, provider: this.provider.config.spec.provider,
-    });
-    if (incompatible) {
-      // Persist the guard before opening the new model context, including on crash recovery.
-      const current = await readCursor(dir);
-      if (current) await writeCursor(dir, { ...current, node, next_node: this.state.nextNode, needs_model_checkpoint: true });
-      await this.performCut("model_checkpoint", this.provider.config.spec.id);
-    }
-    await this.saveCursor();
-
-    return { ok: true, node: this.state.node, ...moved };
+    return this.rewindJournal(point, mode);
   }
 
-  /**
-   * Paths where the target and the workspace as it stands now disagree.
-   *
-   * Read off the disk rather than inferred from the plan, because a file a
-   * person changed by hand belongs in the answer just as much as one a
-   * rewound turn wrote.
-   */
-  private async divergenceFrom(target: FileSet): Promise<string[]> {
-    const current = await scanWorkspace(this.config.tools.root, this.ignore);
-    if (!current.ok) return [];
-    const delta = diffScans(target, current.files);
-    return [
-      ...Object.keys(delta.added), ...Object.keys(delta.changed), ...delta.removed,
-    ].sort();
-  }
 
   private resetDerivedToolState(): void {
     this.stall = null;
@@ -2767,10 +2576,10 @@ export class Session {
   /** A steering signal releases only the wait; cancellation owns process termination. */
   wakeProcessWaits(): void { this.processWake.abort(); }
 
-  private async terminationReport(cause: string, requests: number): Promise<string> {
+  private async terminationReport(cause: string, requests: number, limit = this.config.maxTurns): Promise<string> {
     const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
     if (!history.ok) throw new Error(history.error);
-    return stopReport(history.nodes.flatMap(part => part.events), requests, this.config.maxTurns, cause);
+    return stopReport(history.nodes.flatMap(part => part.events), requests, limit, cause);
   }
 
   /** N.8: build and check the replacement before committing a durable boundary. */
@@ -2965,10 +2774,10 @@ export class Session {
       const fromDisk = replayed.events;
       const retained = retainedFrom === undefined ? [] : retainedContext(replayed.contextEvents, retainedFrom);
       let guidanceTools = this.adviceNames();
-      if (this.config.guidanceVersion === 1 && nextContextRef !== undefined) {
+      if (nextContextRef !== undefined) {
         const saved = await getBlob(join(dir, "artifacts"), nextContextRef);
         if (saved === null) throw new Error("missing successor guidance context");
-        guidanceTools = this.adviceNames((JSON.parse(saved) as { frozen: FrozenPrefix }).frozen);
+        guidanceTools = this.adviceNames(parseSessionContext(JSON.parse(saved)).frozen);
       }
 
       // The cut event is part of the closed file. Digest after appending it
@@ -2986,8 +2795,8 @@ export class Session {
         next_thinking: nextThinking,
         ...(nextContextRef === undefined ? {} : { next_context_ref: nextContextRef }),
         handoff_tokens: DEFAULT_HANDOFF_TOKENS,
-        ...(this.config.workingSet ? { working_set_version: this.config.workingSetVersion ?? 1 } : {}),
-        ...(this.config.guidanceVersion === 1 ? { guidance_tools: guidanceTools } : {}),
+        ...(this.config.workingSet ? { working_set_version: 2 as const } : {}),
+        guidance_tools: guidanceTools,
         ...(retainedFrom === undefined ? {} : { retained_from: retainedFrom }),
       });
       const self = await digestedRef(dir, node);