@visual-z/xeno 0.2.1 → 0.3.0

package/src/core/export.ts

@@ -91,6 +91,9 @@ function escapeHtml(s: string): string {
 
 function eventHtml(e: LogEvent): string {
   switch (e.t) {
+    case "tool_invocation": return wrap("event", "tool invocation", e.at, `${e.name} · ${e.call_id}${e.parent_call_id ? ` · parent ${e.parent_call_id}` : ""} · input ${e.input_ref.sha256} · schema ${e.schema_ref?.sha256 ?? "unavailable"}`);
+    case "checkpoint": return wrap("event", `file checkpoint ${e.phase}`, e.at, e.reason ?? Object.keys(e.changes).join("\n"));
+    case "workspace_observation": return wrap("event", "verification observation", e.at, e.fingerprint ?? e.reason ?? "unavailable");
     case "extension": return e.display ? wrap("event", e.customType, e.at, e.content || JSON.stringify(e.data)) : "";
     case "user":
       return wrap("user", "user", e.at, [e.text, ...(e.images ?? []).map(imageDescription)].join("\n"));
@@ -143,6 +146,12 @@ function eventHtml(e: LogEvent): string {
       return wrap("event", `work ${e.operation}`, e.at, `${e.work_id}: ${e.what}`);
     case "evidence_link":
       return wrap("event", "evidence link", e.at, `${e.work}: ${e.what} → ${e.source}`);
+    case "work_owner": case "work_dependencies": return wrap("event", e.t, e.at, JSON.stringify(e));
+    case "skill_loaded": return wrap("event", "skill loaded", e.at, `${e.name} · ${e.path} · ${e.sha256} · ${e.mode}`);
+    case "process_exit": return wrap("event", "process exit", e.at, `${e.session} · exit ${e.exit} · output ${e.output.sha256}`);
+    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}`);
     default:
       return assertNever(e, "eventHtml");
   }

package/src/core/failure-recovery.ts

@@ -0,0 +1,173 @@
+/** R5 / D8: replayable failure premises; advice never authorizes or automatically retries a tool. */
+import type { GuidanceEvent, LogEvent, ToolResultEvent } from "./events.ts";
+import type { ToolDiagnostic } from "./tool-contract.ts";
+import { canonicalValue } from "./continuation.ts";
+import { repairToolInput } from "./tool-input.ts";
+import { failureDiagnostic, scopeFailureGuidance } from "./tool-failure.ts";
+
+/** Reuses the existing three-attempt diagnostic hypothesis, not a measured optimum or a stop threshold. */
+export const RECOVERY_FAILURES = 3;
+type Call = { name: string; input: unknown };
+export interface FailureIdentity {
+  family: string;
+  resource: string;
+  version: string;
+  code: ToolDiagnostic["code"];
+  execution: NonNullable<ToolDiagnostic["execution"]>;
+  effects: NonNullable<ToolDiagnostic["effects"]>;
+  premise: string;
+}
+interface FailureRun {
+  identity: FailureIdentity;
+  key: string;
+  count: number;
+  sources: readonly string[];
+  notified: boolean;
+}
+export interface RecoveryState {
+  calls: ReadonlyMap<string, Call>;
+  versions: ReadonlyMap<string, string>;
+  failures: ReadonlyMap<string, FailureRun>;
+  change: number;
+}
+export function emptyRecoveryState(): RecoveryState {
+  return { calls: new Map(), versions: new Map(), failures: new Map(), change: 0 };
+}
+const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
+const digest = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+const fileTools = ["read", "write", "edit", "grep", "find", "ls"];
+const family = (name: string): string => name === "bash" || name === "exec_command" ? "command"
+  : name === "edit" || name === "write" ? "file_change" : name;
+
+function target(call: Call, identify: (path: string) => string): { family: string; resource: string; input: Record<string, unknown> } {
+  const repaired = repairToolInput(call.name, call.input), input = record(repaired) ? repaired : { value: repaired };
+  const kind = family(call.name);
+  return { family: kind, input, resource: fileTools.includes(call.name) && typeof input["path"] === "string" ? identify(input["path"])
+    : kind === "command" ? identify(typeof input["workdir"] === "string" ? input["workdir"] : ".")
+    : call.name === "write_stdin" ? `session:${String(input["session_id"])}` : call.name };
+}
+
+function groupKey(call: Call, result: ToolResultEvent, identify: (path: string) => string): string {
+  const context = target(call, identify);
+  return canonicalValue([context.family, context.resource, context.family === "command"
+    ? result.effect?.kind === "command" ? result.effect.cmd.trim() : String(context.input["command"] ?? context.input["cmd"] ?? "").trim() : null]);
+}
+
+/** Only recorded versions and structured failures are facts; stderr words never identify an error. */
+export function failureIdentity(call: Call, result: ToolResultEvent, state: RecoveryState,
+  identify: (path: string) => string): FailureIdentity | null {
+  const diagnostic = result.diagnostic;
+  if (result.ok || !diagnostic || diagnostic.execution === undefined || diagnostic.effects === undefined) return null;
+  const context = target(call, identify), data = record(result.data) ? result.data : {};
+  const current = data["sha256"];
+  const effect = result.effect;
+  const known = state.versions.get(context.resource);
+  const version = diagnostic.code === "permission_denied" ? "unknown" : current === null ? "absent" : digest(current) ? current
+    : effect?.kind === "command" && effect.workspace_observed !== false && digest(effect.workspace_sha256) ? effect.workspace_sha256
+    : digest(known) ? known : "unknown";
+  const input = context.input;
+  let premise: unknown;
+  if (diagnostic.code === "version_mismatch") {
+    const precondition = record(data["precondition"]) ? data["precondition"] : {};
+    premise = { expected: precondition["expected"] === null ? "absent"
+      : precondition["expected"] ?? input["expected_sha256"] ?? input["read_handle"] ?? "unknown" };
+  } else if (diagnostic.code === "permission_denied") {
+    // Replacement wording and requested shell timeouts cannot change a denied capability.
+    premise = { operation: context.family === "command" ? effect?.kind === "command" ? effect.cmd.trim()
+      : String(input["command"] ?? input["cmd"] ?? "").trim() : context.family };
+  } else if (context.family === "file_change" && ["not_found", "ambiguous_edit"].includes(diagnostic.code)) {
+    const edits = Array.isArray(input["edits"]) ? input["edits"] : [input];
+    premise = edits.map(edit => record(edit) ? { old_string: edit["old_string"], replace_all: edit["replace_all"] === true } : edit);
+  } else if (context.family === "command") {
+    // Shared launch contract equates bash/exec_command; arbitrary shell strings are not parsed as equivalent.
+    premise = { command: effect?.kind === "command" ? effect.cmd.trim() : String(input["command"] ?? input["cmd"] ?? "").trim(),
+      exit: effect?.kind === "command" ? effect.exit : null,
+      timeout: input["timeout"] ?? null, tty: input["tty"] === true, change: state.change };
+  } else {
+    const normalized = { ...input };
+    if (fileTools.includes(call.name) && typeof normalized["path"] === "string") normalized["path"] = context.resource;
+    premise = normalized;
+  }
+  return { family: context.family, resource: context.resource, version, code: diagnostic.code,
+    execution: diagnostic.execution, effects: diagnostic.effects, premise: canonicalValue(premise) };
+}
+
+function changedPremises(state: RecoveryState, changed: boolean, resource?: string, version?: string): RecoveryState {
+  return { ...state, change: state.change + Number(changed), failures: new Map([...state.failures].filter(([, run]) =>
+    run.identity.code === "permission_denied" || !(changed && run.identity.family === "command" ||
+      resource !== undefined && version !== undefined && run.identity.resource === resource && run.identity.version !== version))) };
+}
+
+/** Incremental disposable projection; folding the original ancestry yields exactly the same state. */
+export function advanceRecovery(state: RecoveryState, events: readonly LogEvent[], identify: (path: string) => string): RecoveryState {
+  let current = state;
+  for (const event of events) {
+    if (event.t === "user") { current = { ...current, failures: new Map() }; continue; }
+    if (event.t === "assistant") {
+      const calls = new Map(current.calls);
+      for (const block of event.blocks) if (block.type === "tool_use") calls.set(block.call_id, { name: block.name, input: block.input });
+      current = { ...current, calls }; continue;
+    }
+    if (event.t === "tool_invocation") {
+      if (event.input !== undefined) current = { ...current, calls: new Map(current.calls).set(event.call_id, { name: event.name, input: event.input }) };
+      continue;
+    }
+    if (event.t === "guidance" && event.reason === "churn") {
+      current = { ...current, failures: new Map([...current.failures].map(([group, run]) =>
+        [group, event.sources.includes(run.sources[0]!) ? { ...run, notified: true } : run])) }; continue;
+    }
+    if (event.t === "workspace_observation" && event.changed) {
+      current = changedPremises(current, true); continue;
+    }
+    if (event.t === "checkpoint" && event.phase === "applied") {
+      for (const [path, change] of Object.entries(event.changes))
+        current = changedPremises(current, change.before?.sha256 !== change.after?.sha256 || change.before?.mode !== change.after?.mode,
+          identify(path), change.after === null ? "absent" : change.after.sha256);
+      continue;
+    }
+    if (event.t !== "tool_result") continue;
+    const call = current.calls.get(event.call_id), calls = new Map(current.calls); calls.delete(event.call_id);
+    current = { ...current, calls };
+    const effect = event.effect;
+    if (effect?.kind === "edit" || effect?.kind === "read") {
+      const resource = identify(effect.path), previous = current.versions.get(resource);
+      const version = effect.kind === "edit" ? effect.sha256_after : effect.sha256;
+      const changed = effect.kind === "edit" ? effect.sha256_before !== effect.sha256_after : digest(previous) && previous !== version;
+      current = changedPremises({ ...current, versions: new Map(current.versions).set(resource, version) }, changed,
+        resource, digest(version) ? version : undefined);
+    }
+    if (!call) continue;
+    const group = groupKey(call, event, identify);
+    if (event.ok) {
+      const failures = new Map(current.failures); failures.delete(group);
+      current = { ...current, failures }; continue;
+    }
+    const identity = failureIdentity(call, event, current, identify);
+    if (!identity) continue;
+    const key = canonicalValue(identity), previous = current.failures.get(group);
+    const run: FailureRun = previous?.key === key ? { ...previous, count: previous.count + 1,
+      sources: [...previous.sources.slice(0, 2), event.id] }
+      : { identity, key, count: 1, sources: [event.id], notified: false };
+    current = { ...current, failures: new Map(current.failures).set(group, run) };
+  }
+  return current;
+}
+
+export function recoveryReview(state: RecoveryState, tools?: readonly string[]): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
+  for (const run of state.failures.values()) {
+    if (run.count < RECOVERY_FAILURES || run.notified) continue;
+    const identity = run.identity;
+    // Recompute trusted instructions; never promote arbitrary tool error text to harness instructions.
+    const diagnostic = failureDiagnostic(identity.code, "", { execution: identity.execution, effects: identity.effects });
+    const policy = tools === undefined ? diagnostic : scopeFailureGuidance(diagnostic, tools);
+    return { reason: "churn", sources: run.sources,
+      text: `Harness: ${run.count} attempts share an unchanged failure premise in the recorded facts. ` +
+        `Tool family ${JSON.stringify(identity.family)}; resource label (data) ${JSON.stringify(identity.resource.slice(0, 160))}; ` +
+        `code ${identity.code}; version ${identity.version}; execution ${identity.execution}; effects ${identity.effects}. ` +
+        `${policy.next} ` + (policy.retry === "after_inspection" ? "Inspect actual state for partial effects before any replay. " : "") +
+        "Identify which relevant premise changed before another attempt; changing replacement wording is not a new premise. " +
+        (identity.version === "unknown" ? "The resource version is unknown; this notice does not prove external state is unchanged. " : "") +
+        "This is recovery advice, not a task-failure verdict or authorization to replay. Original result references: " + run.sources.join(", ") + "." };
+  }
+  return null;
+}

package/src/core/file-precondition.ts

@@ -0,0 +1,72 @@
+/** R4 / D8: a read descriptor names immutable version premises; it grants no authority. */
+import type { ObservationReceipt } from "./read-observation.ts";
+import { isObservationArtifact } from "./observation-view.ts";
+import type { LogEvent } from "./events.ts";
+
+export interface FileIdentity { host: string; workspace: string; resource: string }
+export interface FileReadDescriptor {
+  kind: "file_read";
+  version: 1;
+  source: ObservationReceipt["source"];
+  selection: ObservationReceipt["selection"];
+}
+export interface FilePrecondition {
+  source: "read_handle" | "expected_sha256" | "session" | "create_only" | "unobserved";
+  expected: string | null;
+  read_handle?: string;
+}
+export type FilePreconditionDecision = { ok: true; precondition: FilePrecondition } |
+  { ok: false; code: "invalid_input" | "version_mismatch"; message: string; precondition?: FilePrecondition };
+
+const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
+const natural = (value: unknown): value is number => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+export const isFileDigest = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+
+/** Preserve chronology across path aliases; handoff anchors intentionally keep their legacy spelling. */
+export function latestObservedFileVersion(events: readonly LogEvent[], resource: string, identify: (path: string) => string): string | undefined {
+  for (let index = events.length - 1; index >= 0; index--) {
+    const event = events[index]!;
+    if (event.t !== "tool_result") continue;
+    const effect = event.effect;
+    if ((effect?.kind === "read" || effect?.kind === "edit") && identify(effect.path) === resource)
+      return effect.kind === "read" ? effect.sha256 : effect.sha256_after;
+  }
+  return undefined;
+}
+
+export function isFileReadDescriptor(value: unknown): value is FileReadDescriptor {
+  if (!record(value) || value["kind"] !== "file_read" || value["version"] !== 1) return false;
+  const source = value["source"], selection = value["selection"];
+  return record(source) && ["host", "workspace", "resource"].every(key => typeof source[key] === "string" && source[key] !== "") &&
+    isFileDigest(source["sha256"]) && isObservationArtifact(source["raw"]) && source["raw"].sha256 === source["sha256"] &&
+    record(selection) && natural(selection["start"]) && selection["start"] >= 1 && natural(selection["end"]) &&
+    natural(selection["total_lines"]) && selection["start"] <= selection["end"] && selection["end"] <= selection["total_lines"];
+}
+
+/** Explicit premises take precedence; an omitted premise may use the complete log projection. */
+export function checkFilePrecondition(identity: FileIdentity, current: string | null, input: {
+  descriptor?: FileReadDescriptor; read_handle?: string; expected_sha256?: string; observed?: string; create_only?: boolean;
+}): FilePreconditionDecision {
+  const invalid = (message: string): FilePreconditionDecision => ({ ok: false, code: "invalid_input", message });
+  if (input.expected_sha256 !== undefined && !isFileDigest(input.expected_sha256)) return invalid("expected_sha256 must be a lowercase SHA-256 digest");
+  if (input.observed !== undefined && !isFileDigest(input.observed)) return invalid("the observed file version is invalid; inspect the original log");
+  if (input.create_only && (input.read_handle !== undefined || input.expected_sha256 !== undefined))
+    return invalid("create_only cannot be combined with read_handle or expected_sha256");
+  if ((input.read_handle === undefined) !== (input.descriptor === undefined)) return invalid("read_handle requires its verified descriptor");
+  if (input.descriptor) {
+    if (!isFileReadDescriptor(input.descriptor) || !isFileDigest(input.read_handle)) return invalid("invalid read_handle descriptor");
+    for (const field of ["host", "workspace", "resource"] as const)
+      if (input.descriptor.source[field] !== identity[field]) return invalid(`read_handle names another ${field}; read the intended file here`);
+    if (input.expected_sha256 !== undefined && input.expected_sha256 !== input.descriptor.source.sha256)
+      return invalid("read_handle and expected_sha256 name different versions");
+  }
+  const precondition: FilePrecondition = input.create_only ? { source: "create_only", expected: null }
+    : input.descriptor ? { source: "read_handle", expected: input.descriptor.source.sha256, read_handle: input.read_handle! }
+    : input.expected_sha256 !== undefined ? { source: "expected_sha256", expected: input.expected_sha256 }
+    : input.observed !== undefined ? { source: "session", expected: input.observed }
+    : { source: "unobserved", expected: null };
+  if (precondition.source !== "unobserved" && precondition.expected !== current)
+    return { ok: false, code: "version_mismatch", precondition,
+      message: `file version changed; expected ${precondition.expected ?? "absent"}, current sha256: ${current ?? "absent"}. Read the current file before retrying.` };
+  return { ok: true, precondition };
+}

package/src/core/handoff.ts

@@ -19,6 +19,11 @@ import type { ProgressEvidence } from "./progress.ts";
 import { isExecutionOutcome, type ExecutionOutcome } from "./outcome.ts";
 import type { WorkItem } from "./work-state.ts";
 import type { EvidenceLink } from "./evidence-links.ts";
+import type { WorkingSet } from "./working-set.ts";
+import { RECOVERY_SECTIONS, RECOVERY_KINDS } from "./recovery-sources.ts";
+import type { AcceptanceState } from "./acceptance.ts";
+import type { LoadedSkill } from "./skills.ts";
+import type { ProcessObservation } from "./process-state.ts";
 import { emitYaml } from "./yaml.ts";
 
 export const HANDOFF_VERSION = 1 as const;
@@ -34,6 +39,8 @@ export type Evidence = {
   event_id: string;
   /** Exact observed workspace after the command; absence means legacy/unknown. */
   workspace_sha256?: string;
+  /** P.3: omitted on historical full-workspace observations. */
+  workspace_scope?: "source-v1";
 }
 
 export type CompletedItem = {
@@ -79,12 +86,16 @@ export type BlockedItem = {
 }
 
 export type DecisionItem = {
+  work_id?: string;
+  source?: { node: number; event_id: string };
   chose: string;
   because: string;
   rejected?: readonly string[];
 }
 
 export type PitfallItem = {
+  work_id?: string;
+  source?: { node: number; event_id: string };
   tried: string;
   failed_because: string;
 }
@@ -110,11 +121,13 @@ export type BranchRecord = {
   /** Event id in this node where the branch was spawned. */
   spawned_at: EventId;
   purpose: string;
+  background?: true;
   /** null means unresolved, which D16 requires be visible rather than quiet. */
   resolution: "merged" | "discarded" | null;
   /** Present once the branch joined; a path, never the handoff's contents. */
   handoff_ref?: string;
   summary?: string;
+  receipt_ref?: string;
   outcome?: ExecutionOutcome;
 };
 
@@ -126,6 +139,7 @@ export type VerificationItem = {
   at?: IsoTime;
   exit?: number;
   workspace_sha256?: string;
+  workspace_scope?: "source-v1";
   stale?: true;
 }
 
@@ -142,6 +156,11 @@ export type UserTurnRecord = {
 
 export type Handoff = {
   handoff_version: typeof HANDOFF_VERSION | 2;
+  working_set?: WorkingSet;
+  acceptance?: AcceptanceState;
+  loaded_skills?: readonly LoadedSkill[];
+  /** O.14: last observations only; live capabilities cannot survive a restart. */
+  processes?: readonly ProcessObservation[];
   /** V2 arrays are carried suffixes; the immutable source rebuilds every page. */
   history?: {
     source: NodeRef;
@@ -219,8 +238,8 @@ export type Handoff = {
 const ORDER: Record<string, readonly string[]> = {
   "": [
     "handoff_version", "predecessor", "history",
-    "objective", "user_turns", "user_turns_truncated",
-    "state", "decisions", "pitfalls", "file_anchors",
+    "objective", "working_set", "user_turns", "user_turns_truncated",
+    "state", "acceptance", "loaded_skills", "processes", "decisions", "pitfalls", "file_anchors",
     "verification", "branches", "open_questions", "progress_evidence", "evidence_links",
     "continuation_valid", "budget",
   ],
@@ -239,7 +258,9 @@ const ORDER: Record<string, readonly string[]> = {
   pitfalls: ["tried", "failed_because"],
   file_anchors: ["path", "sha256", "read_ranges", "touched"],
   verification: ["gate", "status", "at", "exit"],
-  branches: ["node", "spawned_at", "purpose", "resolution", "handoff_ref", "summary", "outcome"],
+  branches: ["node", "spawned_at", "purpose", "resolution", "handoff_ref", "summary", "outcome", "receipt_ref", "background"],
+  processes: ["session", "node", "event", "observed", "command", "exit", "output"],
+  "processes.output": ["sha256", "path", "bytes"],
   "branches.outcome": ["status", "reason"],
   evidence_links: ["id", "work", "what", "event", "resource", "version", "freshness", "superseded_by"],
   budget: ["nodes_on_path", "nodes_without_progress"],
@@ -279,6 +300,10 @@ export type Violation = {
     | "INVALID_EXECUTION_OUTCOME"
     | "INVALID_WORK_STATE"
     | "INVALID_EVIDENCE_LINK"
+    | "INVALID_WORKING_SET"
+    | "INVALID_ACCEPTANCE"
+    | "INVALID_SKILL_SOURCE"
+    | "INVALID_PROCESS_STATE"
     | "BAD_VERSION";
   detail: string;
 }
@@ -297,6 +322,10 @@ export function validateHandoff(h: Handoff): Violation[] {
   }
   const workIds = new Set<string>();
   for (const item of h.state.work_items ?? []) {
+    if (item.depends_on && (new Set(item.depends_on).size !== item.depends_on.length || item.depends_on.includes(item.id) ||
+      item.depends_on.some(dep => !dep.trim())) || item.owner !== undefined && (!item.owner.trim() || !item.owner_event)) {
+      v.push({ code: "INVALID_WORK_STATE", detail: `invalid dependencies or ownership for work ${item.id}` });
+    }
     const proven = item.verification === "verified" || item.verification === "stale";
     if (!item.id.trim() || workIds.has(item.id) || !item.what.trim() || !item.opened_at || !item.updated_at ||
         !["active", "blocked", "completed", "cancelled"].includes(item.status) ||
@@ -318,13 +347,29 @@ export function validateHandoff(h: Handoff): Violation[] {
   if (h.handoff_version !== HANDOFF_VERSION && h.handoff_version !== 2) {
     v.push({ code: "BAD_VERSION", detail: `expected ${HANDOFF_VERSION}, got ${h.handoff_version}` });
   }
+  if (h.working_set) {
+    const view = h.working_set;
+    if (![1, 2].includes(view.version) || view.source.node !== h.predecessor?.node || view.source.sha256 !== h.predecessor?.sha256 ||
+        !Number.isSafeInteger(view.omitted.work) || view.omitted.work < 0 || !Number.isSafeInteger(view.omitted.references) || view.omitted.references < 0 ||
+        new Set(view.work.map(item => item.id)).size !== view.work.length || view.work.some(item => !["active", "blocked"].includes(item.status)) ||
+        view.references.some(reference => !reference.event) ||
+        view.version === 2 && (!view.recovery_sections || RECOVERY_SECTIONS.some(section => {
+          const range = view.recovery_sections![section], references = view.references.filter(ref => ref.kind === RECOVERY_KINDS[section]);
+          return !range || !Number.isSafeInteger(range.total) || !Number.isSafeInteger(range.omitted) || range.omitted < 0 || range.omitted > range.total ||
+            range.total - range.omitted !== references.length || new Set(references.map(ref => ref.event)).size !== references.length ||
+            references.some(ref => !Number.isSafeInteger(ref.node) || Number(ref.node) < 0 || ref.provenance !==
+              (section === "users" ? "user_message" : section === "next_actions" ? "model_annotation" : "observation"));
+        }))) {
+      v.push({ code: "INVALID_WORKING_SET", detail: "working set must reference its source and explicit active state" });
+    }
+  }
   if (h.handoff_version === 2) {
     const history = h.history;
     if (!history || !h.predecessor || history.source.node !== h.predecessor.node ||
         history.source.sha256 !== h.predecessor.sha256) {
       v.push({ code: "INVALID_HISTORY", detail: "paged handoff must identify its immutable predecessor" });
     } else for (const [section, range] of Object.entries(history.sections)) {
-      const values = section.startsWith("state.") ? h.state[section.slice(6) as keyof Handoff["state"]]
+      const values = section === "acceptance.criteria" ? h.acceptance?.criteria : section === "acceptance.targets" ? h.acceptance?.targets : section.startsWith("state.") ? h.state[section.slice(6) as keyof Handoff["state"]]
         : h[section as keyof Handoff];
       if (!Array.isArray(values) || !Number.isSafeInteger(range.total) || !Number.isSafeInteger(range.offset) ||
           range.offset < 0 || range.total < range.offset || range.total - range.offset !== values.length) {
@@ -333,6 +378,22 @@ export function validateHandoff(h: Handoff): Violation[] {
     }
   }
 
+  if (h.acceptance?.criteria.some(item => item.status === "pass" && (!item.evidence || item.evidence.exit !== 0) ||
+      item.status === "accepted" && (item.kind !== "human" || !item.accepted_event || item.target && !item.accepted_binding))) {
+    v.push({ code: "INVALID_ACCEPTANCE", detail: "criteria need actual command or user decision evidence" });
+  }
+  if (h.acceptance?.targets?.some(target => target.status === "ready" && (!target.observation || !target.binding || !target.session || !target.pid || !target.entry || !target.build_event))) {
+    v.push({ code: "INVALID_ACCEPTANCE", detail: "ready targets need original build and owned instance observations" });
+  }
+  if (h.loaded_skills?.some(item => !/^[a-f0-9]{64}$/.test(item.sha256) || item.sha256 !== item.artifact ||
+      !item.path || !item.event || !Number.isSafeInteger(item.node) || item.node < 0)) {
+    v.push({ code: "INVALID_SKILL_SOURCE", detail: "loaded skill must reference original instruction bytes and event" });
+  }
+  if (h.processes?.some(item => !Number.isSafeInteger(item.session) || item.session < 1 || !Number.isSafeInteger(item.node) || item.node < 0 ||
+    !item.event || !["running", "exited"].includes(item.observed) || item.observed === "exited" && !Number.isInteger(item.exit) ||
+    item.output && (!/^[a-f0-9]{64}$/.test(item.output.sha256) || !Number.isSafeInteger(item.output.bytes) || item.output.bytes < 0 || !item.output.path))) {
+    v.push({ code: "INVALID_PROCESS_STATE", detail: "process state requires original observation and actual exit evidence" });
+  }
   for (const c of h.state.completed) {
     if (c.evidence.exit !== 0) {
       v.push({

package/src/core/history-query.ts

@@ -2,8 +2,9 @@
 import type { LogEvent, ToolResultEvent } from "./events.ts";
 import { canonicalValue } from "./continuation.ts";
 import { deriveEvidenceLinks, observationResources, resourceKey, type EvidenceLink } from "./evidence-links.ts";
+import type { EnvironmentValidity } from "./environment.ts";
 
-export interface HistoryEntry extends Pick<ToolResultEvent, "effect" | "outcome" | "data" | "diagnostic"> {
+export interface HistoryEntry extends Pick<ToolResultEvent, "effect" | "outcome" | "data" | "data_ref" | "diagnostic" | "observation" | "warnings"> {
   node: number;
   event: string;
   kind: string;
@@ -16,27 +17,62 @@ export interface HistoryEntry extends Pick<ToolResultEvent, "effect" | "outcome"
   work_ids?: readonly string[];
   evidence?: readonly EvidenceLink[];
   source_available?: boolean;
+  /** Runtime consumption view only; never changes the original capability receipt. */
+  environment?: EnvironmentValidity;
+  invocation?: { event: string; input: string; schema: string | null; parent_call_id?: string; origin?: "extension" };
+}
+
+/** O.15: bump when historyEntries or freshness semantics change. */
+export const HISTORY_INDEX_VERSION = 6;
+export function historyKeyInput(nodes: readonly { node: number; events: readonly LogEvent[] }[], version = HISTORY_INDEX_VERSION): string {
+  const calls = new Map<string, string>();
+  const self = (name: string | undefined) => name === "history" || name === "note";
+  return canonicalValue({ version, nodes: nodes.map(part => ({ node: part.node, events: part.events.flatMap<LogEvent>(event => {
+    // The index deliberately excludes its own reads. Effects still affect
+    // freshness, and annotations have their own durable events (O.6).
+    if (event.t === "tool_invocation") { calls.set(event.call_id, event.name); return self(event.name) ? [] : [event]; }
+    if (event.t === "tool_result" && self(calls.get(event.call_id)) && event.effect === undefined) return [];
+    if (event.t !== "assistant") return [event];
+    for (const block of event.blocks) if (block.type === "tool_use") calls.set(block.call_id, block.name);
+    const blocks = event.blocks.filter(block => block.type === "text" || block.type === "tool_use" && !self(block.name));
+    return blocks.length ? [{ ...event, blocks }] : [];
+  }) })) });
 }
 
 export function historyEntries(nodes: readonly { node: number; events: readonly LogEvent[] }[]): HistoryEntry[] {
   const entries: HistoryEntry[] = [];
   const calls = new Map<string, { name: string; input: unknown }>();
+  const invocations = new Map<string, NonNullable<HistoryEntry["invocation"]>>();
   for (const { node, events } of nodes) for (const e of events) {
     if (e.t === "assistant") {
       for (const block of e.blocks) if (block.type === "tool_use") calls.set(block.call_id, { name: block.name, input: block.input });
       const text = e.blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
       if (text) entries.push({ node, event: e.id, kind: e.t, text });
+    } else if (e.t === "tool_invocation") {
+      calls.set(e.call_id, { name: e.name, input: e.input ?? calls.get(e.call_id)?.input ?? { artifact: e.input_ref.sha256 } });
+      invocations.set(e.call_id, { event: e.id, input: e.input_ref.sha256, schema: e.schema_ref?.sha256 ?? null,
+        ...(e.origin ? { origin: e.origin } : {}),
+        ...(e.parent_call_id ? { parent_call_id: e.parent_call_id } : {}) });
     } else if (e.t === "tool_result") {
       const call = calls.get(e.call_id);
       // Indexing query results recursively would make the index amplify itself.
       if (call?.name === "history" || call?.name === "note") continue;
       entries.push({ node, event: e.id, kind: e.t, text: e.content, ok: e.ok,
         ...(call ? { tool: call.name, input: call.input } : {}),
+        ...(invocations.has(e.call_id) ? { invocation: invocations.get(e.call_id)! } : {}),
         resources: observationResources(e, call?.input),
         ...(e.effect ? { effect: e.effect } : {}), ...(e.outcome ? { outcome: e.outcome } : {}),
         ...(e.data !== undefined ? { data: e.data } : {}), ...(e.diagnostic ? { diagnostic: e.diagnostic } : {}),
+        ...(e.data_ref ? { data_ref: e.data_ref } : {}),
+        ...(e.observation ? { observation: e.observation } : {}),
+        ...(e.warnings ? { warnings: e.warnings } : {}),
         ...(e.content_ref ? { artifact: e.content_ref.sha256 } : {}) });
-    } else if (["user", "next_action", "decision", "pitfall", "blocked", "question", "claim", "work_status", "evidence_link"].includes(e.t)) {
+    } else if (e.t === "target_observation") {
+      entries.push({ node, event: e.id, kind: e.t, text: canonicalValue(e.observation),
+        ...(e.observation.manifest ? { artifact: e.observation.manifest.sha256 } : {}) });
+    } else if (e.t === "process_exit") {
+      entries.push({ node, event: e.id, kind: e.t, text: canonicalValue(e), artifact: e.output.sha256 });
+    } else if (["work_owner", "work_dependencies", "skill_loaded", "acceptance_contract", "acceptance_decision", "user", "next_action", "decision", "pitfall", "blocked", "question", "claim", "work_status", "evidence_link"].includes(e.t)) {
       entries.push({ node, event: e.id, kind: e.t, text: e.t === "user" ? e.text : canonicalValue(e),
         ...("work_id" in e && e.work_id ? { work_ids: [e.work_id] } : {}),
         ...(e.t === "evidence_link" ? { work_ids: [e.work], ...(e.resource ? { resources: [resourceKey(e.resource)] } : {}) } : {}) });

package/src/core/history.ts

@@ -1,6 +1,8 @@
 /** 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 type { RecoveryNodes } from "./recovery-sources.ts";
 
 // A carried handoff must leave room for another segment's work. This budget is
 // the existing 5k work floor, not a new segment threshold or an accuracy claim.
@@ -11,6 +13,10 @@ export const HISTORY_SECTIONS = [
   "branches", "open_questions", "progress_evidence",
   "state.work_items",
   "evidence_links",
+  "acceptance.criteria",
+  "acceptance.targets",
+  "loaded_skills",
+  "processes",
 ] as const;
 export type HistorySection = (typeof HISTORY_SECTIONS)[number];
 
@@ -22,6 +28,10 @@ export function historyItems(h: Handoff, section: HistorySection): readonly unkn
     case "state.blocked": return h.state.blocked;
     case "state.work_items": return h.state.work_items ?? [];
     case "evidence_links": return h.evidence_links ?? [];
+    case "acceptance.criteria": return h.acceptance?.criteria ?? [];
+    case "acceptance.targets": return h.acceptance?.targets ?? [];
+    case "loaded_skills": return h.loaded_skills ?? [];
+    case "processes": return h.processes ?? [];
     case "progress_evidence": return h.progress_evidence ?? [];
     default: return h[section];
   }
@@ -47,6 +57,10 @@ function suffixes(h: Handoff, offsets: Record<HistorySection, number>): Handoff
     open_questions: h.open_questions.slice(offsets.open_questions),
     progress_evidence: (h.progress_evidence ?? []).slice(offsets.progress_evidence),
     ...(h.evidence_links !== undefined ? { evidence_links: h.evidence_links.slice(offsets.evidence_links ?? 0) } : {}),
+    ...(h.acceptance ? { acceptance: { ...h.acceptance, criteria: h.acceptance.criteria.slice(offsets["acceptance.criteria"] ?? 0),
+      ...(h.acceptance.targets ? { targets: h.acceptance.targets.slice(offsets["acceptance.targets"] ?? 0) } : {}) } } : {}),
+    ...(h.loaded_skills ? { loaded_skills: h.loaded_skills.slice(offsets.loaded_skills ?? 0) } : {}),
+    ...(h.processes ? { processes: h.processes.slice(offsets.processes ?? 0) } : {}),
   };
 }
 
@@ -57,7 +71,11 @@ export function boundHandoff(full: Handoff, budget = DEFAULT_HANDOFF_TOKENS): Ha
   if (full.predecessor === null) throw new Error("history requires an immutable source");
   // An absent new section must not change legacy projections or frozen replay.
   const sections = HISTORY_SECTIONS.filter(section => (section !== "state.work_items" || full.state.work_items !== undefined) &&
-    (section !== "evidence_links" || full.evidence_links !== undefined));
+    (section !== "evidence_links" || full.evidence_links !== undefined) &&
+    (section !== "acceptance.criteria" || full.acceptance !== undefined) &&
+    (section !== "acceptance.targets" || full.acceptance?.targets !== undefined) &&
+    (section !== "loaded_skills" || full.loaded_skills !== undefined) &&
+    (section !== "processes" || full.processes !== undefined));
   const offsets = Object.fromEntries(sections.map((s) => [s, historyItems(full, s).length])) as Record<HistorySection, number>;
   const build = (): Handoff => ({
     ...suffixes(full, offsets),
@@ -98,3 +116,22 @@ export function historyPage(full: Handoff, section: HistorySection, offset: numb
   const end = Math.min(items.length, offset + limit);
   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);
+  const view = recoveryWorkingSet(full, nodes, budget * .4, tools);
+  if (!view) return legacy;
+  try { return boundHandoff({ ...full, working_set: view }, budget); }
+  catch (error) { if (error instanceof RangeError) return legacy; throw error; }
+}

package/src/core/integration-health.ts

@@ -0,0 +1,34 @@
+/** Q.13: observed connectivity is a cache, never authorization or replay evidence. */
+export type IntegrationFailureCode = "offline" | "rate_limited" | "auth_required" | "protocol_error" | "timeout" | "unknown";
+export type IntegrationTime = { at: number; tick: number };
+export type IntegrationHealth = {
+  state: "not_checked" | "ready" | "backoff" | "auth_required" | "protocol_error";
+  observed: IntegrationTime | null;
+  failures: number;
+  retryAt: number | null;
+  error: IntegrationFailureCode | null;
+};
+// Assumed bounds, not measured optima: avoid tight failure loops and unbounded server delays.
+export const INTEGRATION_BACKOFF_MS = 1_000;
+export const MAX_INTEGRATION_BACKOFF_MS = 60_000;
+export const INTEGRATION_HEALTH_TTL_MS = 30_000;
+
+export function initialIntegrationHealth(): IntegrationHealth {
+  return { state: "not_checked", observed: null, failures: 0, retryAt: null, error: null };
+}
+export function readyIntegrationHealth(now: IntegrationTime): IntegrationHealth {
+  return { ...initialIntegrationHealth(), state: "ready", observed: { ...now } };
+}
+export function failedIntegrationHealth(previous: IntegrationHealth, error: IntegrationFailureCode, now: IntegrationTime, retryAfterMs?: number): IntegrationHealth {
+  const failures = Math.min(16, previous.failures + 1);
+  const delay = Math.min(MAX_INTEGRATION_BACKOFF_MS, Math.max(INTEGRATION_BACKOFF_MS * 2 ** (failures - 1),
+    Number.isFinite(retryAfterMs) ? Math.max(0, retryAfterMs!) : 0));
+  const state = error === "auth_required" || error === "protocol_error" ? error : "backoff";
+  return { state, observed: { ...now }, failures, retryAt: state === "backoff" ? now.tick + delay : null, error };
+}
+export function integrationHealthView(health: IntegrationHealth, now: IntegrationTime) {
+  const age = health.observed === null ? null : Math.max(0, now.tick - health.observed.tick);
+  return { state: health.state, observed_at: health.observed?.at ?? null, age_ms: age,
+    stale: age === null || age >= INTEGRATION_HEALTH_TTL_MS, error: health.error,
+    failures: health.failures, retry_after_ms: health.retryAt === null ? null : Math.max(0, health.retryAt - now.tick) };
+}