odai-dsh-agent 0.2.5 → 0.2.6

package/preset/odai/runtime/skill-evolution.mjs

@@ -1,23 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
-import {
-  closeSync,
-  existsSync,
-  fsyncSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  readdirSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, relative, resolve } from "node:path";
-
 import { ODAI_RUNTIME_CONTRACT, loadSkillBundle, readSkillBundleFile } from "./skill-bundle.mjs";
 import { acquireOwnedStoreLock } from "./store-lock.mjs";
-
+import { isUnknownRecord } from "./runtime-types.mjs";
 const STORE_SCHEMA_VERSION = 1;
 const STATE_FILE = "state.json";
 const METADATA_FILE = "metadata.json";
@@ -31,1383 +18,1422 @@ const MAX_OBJECTIVE_CHARS = 2_000;
 const MAX_EVIDENCE_ITEMS = 20;
 const MAX_EVIDENCE_CHARS = 2_000;
 const PROTECTED_GOVERNANCE_FILES = Object.freeze(["SKILL.md", "references/dao.md"]);
-
 function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
+    return createHash("sha256").update(value).digest("hex");
 }
-
 function assertPlainObject(value, field) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError(`${field} must be an object`);
-  }
-  return value;
+    if (!isUnknownRecord(value)) {
+        throw new TypeError(`${field} must be an object`);
+    }
+    return value;
 }
-
 function assertExactFields(value, allowed, field) {
-  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
-  if (unknown.length > 0) throw new TypeError(`${field} has unknown fields: ${unknown.join(", ")}`);
+    const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (unknown.length > 0)
+        throw new TypeError(`${field} has unknown fields: ${unknown.join(", ")}`);
 }
-
 function nonEmptyString(value, field, maximum = Number.POSITIVE_INFINITY) {
-  if (typeof value !== "string" || value.trim() === "") throw new TypeError(`${field} must be a non-empty string`);
-  const normalized = value.trim();
-  if (normalized.length > maximum) throw new TypeError(`${field} exceeds ${maximum} characters`);
-  return normalized;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new TypeError(`${field} must be a non-empty string`);
+    const normalized = value.trim();
+    if (normalized.length > maximum)
+        throw new TypeError(`${field} exceeds ${maximum} characters`);
+    return normalized;
 }
-
 function exactDigest(value, field) {
-  if (typeof value !== "string" || !DIGEST_PATTERN.test(value)) {
-    throw new TypeError(`${field} must be a lowercase SHA-256 digest`);
-  }
-  return value;
+    if (typeof value !== "string" || !DIGEST_PATTERN.test(value)) {
+        throw new TypeError(`${field} must be a lowercase SHA-256 digest`);
+    }
+    return value;
 }
-
 function validTimestamp(value, field) {
-  const timestamp = nonEmptyString(value, field);
-  if (!Number.isFinite(Date.parse(timestamp))) throw new TypeError(`${field} must be an ISO timestamp`);
-  return timestamp;
+    const timestamp = nonEmptyString(value, field);
+    if (!Number.isFinite(Date.parse(timestamp)))
+        throw new TypeError(`${field} must be an ISO timestamp`);
+    return timestamp;
 }
-
 function utf8Text(buffer, field) {
-  if (buffer.byteLength > MAX_FILE_BYTES) throw new Error(`${field} exceeds ${MAX_FILE_BYTES} bytes`);
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-  } catch (error) {
-    throw new Error(`${field} must be valid UTF-8: ${error instanceof Error ? error.message : String(error)}`);
-  }
+    if (buffer.byteLength > MAX_FILE_BYTES)
+        throw new Error(`${field} exceeds ${MAX_FILE_BYTES} bytes`);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    }
+    catch (error) {
+        throw new Error(`${field} must be valid UTF-8: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
-
 function assertUtf8String(value, field) {
-  if (typeof value !== "string") throw new TypeError(`${field} must be a string`);
-  if (Buffer.from(value, "utf8").toString("utf8") !== value) throw new TypeError(`${field} must be valid UTF-8`);
-  return value;
+    if (typeof value !== "string")
+        throw new TypeError(`${field} must be a string`);
+    if (Buffer.from(value, "utf8").toString("utf8") !== value)
+        throw new TypeError(`${field} must be valid UTF-8`);
+    return value;
 }
-
 function stringList(value, field, minimum = 0) {
-  if (!Array.isArray(value) || value.length < minimum || value.length > MAX_EVIDENCE_ITEMS) {
-    throw new TypeError(`${field} must contain ${minimum}-${MAX_EVIDENCE_ITEMS} strings`);
-  }
-  return Object.freeze(value.map((item, index) => nonEmptyString(item, `${field}[${index}]`, MAX_EVIDENCE_CHARS)));
+    if (!Array.isArray(value) || value.length < minimum || value.length > MAX_EVIDENCE_ITEMS) {
+        throw new TypeError(`${field} must contain ${minimum}-${MAX_EVIDENCE_ITEMS} strings`);
+    }
+    return Object.freeze(value.map((item, index) => nonEmptyString(item, `${field}[${index}]`, MAX_EVIDENCE_CHARS)));
 }
-
 function safeGenerationId(value, field = "generationId") {
-  return exactDigest(value, field);
+    return exactDigest(value, field);
 }
-
 function safePath(root, ...segments) {
-  const target = resolve(root, ...segments);
-  const fromRoot = relative(resolve(root), target);
-  if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
-    throw new Error(`Odai evolution path escapes its root: ${target}`);
-  }
-  return target;
+    const target = resolve(root, ...segments);
+    const fromRoot = relative(resolve(root), target);
+    if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+        throw new Error(`Odai evolution path escapes its root: ${target}`);
+    }
+    return target;
 }
-
 function assertRegularFile(path, label) {
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink() || !stat.isFile()) throw new Error(`${label} must be a regular file`);
-  return stat;
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw new Error(`${label} must be a regular file`);
+    return stat;
 }
-
 function assertRegularDirectory(path, label) {
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`${label} must be a regular directory`);
-  return path;
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw new Error(`${label} must be a regular directory`);
+    return path;
 }
-
 function ensureStoreRoot(root) {
-  if (!existsSync(root)) mkdirSync(root, { recursive: true, mode: 0o700 });
-  return assertRegularDirectory(root, "Odai skill evolution root");
+    if (!existsSync(root))
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+    return assertRegularDirectory(root, "Odai skill evolution root");
 }
-
 function ensureStoreDirectory(root, name) {
-  ensureStoreRoot(root);
-  const path = safePath(root, name);
-  if (!existsSync(path)) mkdirSync(path, { mode: 0o700 });
-  return assertRegularDirectory(path, `Odai skill evolution ${name} directory`);
+    ensureStoreRoot(root);
+    const path = safePath(root, name);
+    if (!existsSync(path))
+        mkdirSync(path, { mode: 0o700 });
+    return assertRegularDirectory(path, `Odai skill evolution ${name} directory`);
 }
-
 function requireStoreDirectory(root, name) {
-  ensureStoreRoot(root);
-  const path = safePath(root, name);
-  if (!existsSync(path)) throw new Error(`Odai skill evolution ${name} directory is missing`);
-  return assertRegularDirectory(path, `Odai skill evolution ${name} directory`);
+    ensureStoreRoot(root);
+    const path = safePath(root, name);
+    if (!existsSync(path))
+        throw new Error(`Odai skill evolution ${name} directory is missing`);
+    return assertRegularDirectory(path, `Odai skill evolution ${name} directory`);
 }
-
 function readJsonFile(path, label, maximumBytes) {
-  const stat = assertRegularFile(path, label);
-  if (stat.size > maximumBytes) throw new Error(`${label} exceeds ${maximumBytes} bytes`);
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new Error(`cannot read ${label}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return assertPlainObject(parsed, label);
+    const stat = assertRegularFile(path, label);
+    if (stat.size > maximumBytes)
+        throw new Error(`${label} exceeds ${maximumBytes} bytes`);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`cannot read ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return assertPlainObject(parsed, label);
 }
-
 function syncDirectory(path) {
-  let handle;
-  try {
-    handle = openSync(path, "r");
-    fsyncSync(handle);
-  } catch {
-    // Directory fsync is unavailable on Windows; each file is still synced.
-  } finally {
-    if (handle !== undefined) closeSync(handle);
-  }
+    let handle;
+    try {
+        handle = openSync(path, "r");
+        fsyncSync(handle);
+    }
+    catch {
+        // Directory fsync is unavailable on Windows; each file is still synced.
+    }
+    finally {
+        if (handle !== undefined)
+            closeSync(handle);
+    }
 }
-
 function writeDurableFile(path, content) {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const handle = openSync(path, "wx", 0o600);
-  try {
-    writeFileSync(handle, content);
-    fsyncSync(handle);
-  } finally {
-    closeSync(handle);
-  }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const handle = openSync(path, "wx", 0o600);
+    try {
+        writeFileSync(handle, content);
+        fsyncSync(handle);
+    }
+    finally {
+        closeSync(handle);
+    }
 }
-
 function writeJsonAtomic(path, value) {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const serialized = `${JSON.stringify(value, null, 2)}\n`;
-  if (Buffer.byteLength(serialized, "utf8") > MAX_STATE_BYTES) {
-    throw new Error(`Odai skill evolution state exceeds ${MAX_STATE_BYTES} bytes`);
-  }
-  const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
-  try {
-    writeDurableFile(temporary, serialized);
-    renameSync(temporary, path);
-    syncDirectory(dirname(path));
-  } finally {
-    rmSync(temporary, { force: true });
-  }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const serialized = `${JSON.stringify(value, null, 2)}\n`;
+    if (Buffer.byteLength(serialized, "utf8") > MAX_STATE_BYTES) {
+        throw new Error(`Odai skill evolution state exceeds ${MAX_STATE_BYTES} bytes`);
+    }
+    const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        writeDurableFile(temporary, serialized);
+        renameSync(temporary, path);
+        syncDirectory(dirname(path));
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
 }
-
 function emptyState() {
-  return Object.freeze({ schemaVersion: STORE_SCHEMA_VERSION, revision: 0, history: Object.freeze([]) });
+    return Object.freeze({ schemaVersion: STORE_SCHEMA_VERSION, revision: 0, history: Object.freeze([]) });
 }
-
 function normalizeHistoryEvent(value, index) {
-  const event = assertPlainObject(value, `Odai evolution state.history[${index}]`);
-  assertExactFields(event, ["revision", "action", "from", "to", "at", "evidence"], `Odai evolution state.history[${index}]`);
-  if (!Number.isSafeInteger(event.revision) || event.revision !== index + 1) {
-    throw new TypeError(`Odai evolution state.history[${index}].revision must be ${index + 1}`);
-  }
-  if (!["activate", "rollback", "deactivate"].includes(event.action)) {
-    throw new TypeError(`Odai evolution state.history[${index}].action is invalid`);
-  }
-  const from = event.from === null ? null : safeGenerationId(event.from, `Odai evolution state.history[${index}].from`);
-  const to = event.to === null ? null : safeGenerationId(event.to, `Odai evolution state.history[${index}].to`);
-  if (from === to) throw new TypeError(`Odai evolution state.history[${index}] does not change the active generation`);
-  return Object.freeze({
-    revision: event.revision,
-    action: event.action,
-    from,
-    to,
-    at: validTimestamp(event.at, `Odai evolution state.history[${index}].at`),
-    evidence: stringList(event.evidence, `Odai evolution state.history[${index}].evidence`, 1),
-  });
+    const event = assertPlainObject(value, `Odai evolution state.history[${index}]`);
+    assertExactFields(event, ["revision", "action", "from", "to", "at", "evidence"], `Odai evolution state.history[${index}]`);
+    if (typeof event.revision !== "number" || !Number.isSafeInteger(event.revision) || event.revision !== index + 1) {
+        throw new TypeError(`Odai evolution state.history[${index}].revision must be ${index + 1}`);
+    }
+    if (event.action !== "activate" && event.action !== "rollback" && event.action !== "deactivate") {
+        throw new TypeError(`Odai evolution state.history[${index}].action is invalid`);
+    }
+    const from = event.from === null ? null : safeGenerationId(event.from, `Odai evolution state.history[${index}].from`);
+    const to = event.to === null ? null : safeGenerationId(event.to, `Odai evolution state.history[${index}].to`);
+    if (from === to)
+        throw new TypeError(`Odai evolution state.history[${index}] does not change the active generation`);
+    return Object.freeze({
+        revision: event.revision,
+        action: event.action,
+        from,
+        to,
+        at: validTimestamp(event.at, `Odai evolution state.history[${index}].at`),
+        evidence: stringList(event.evidence, `Odai evolution state.history[${index}].evidence`, 1),
+    });
 }
-
 export function readSkillEvolutionState(root) {
-  if (!existsSync(root)) return emptyState();
-  assertRegularDirectory(root, "Odai skill evolution root");
-  const path = resolve(root, STATE_FILE);
-  if (!existsSync(path)) return emptyState();
-  const value = readJsonFile(path, "Odai skill evolution state", MAX_STATE_BYTES);
-  assertExactFields(value, ["schemaVersion", "revision", "activeGenerationId", "history"], "Odai skill evolution state");
-  if (value.schemaVersion !== STORE_SCHEMA_VERSION) {
-    throw new TypeError(`Odai skill evolution state has unsupported schemaVersion ${String(value.schemaVersion)}`);
-  }
-  if (!Number.isSafeInteger(value.revision) || value.revision < 0) {
-    throw new TypeError("Odai skill evolution state.revision must be a non-negative integer");
-  }
-  if (!Array.isArray(value.history) || value.history.length !== value.revision) {
-    throw new TypeError("Odai skill evolution state.history must match revision");
-  }
-  const history = Object.freeze(value.history.map(normalizeHistoryEvent));
-  let prior = null;
-  for (const [index, event] of history.entries()) {
-    if (event.from !== prior) throw new TypeError(`Odai skill evolution state.history[${index}].from breaks the active-pointer chain`);
-    if (event.action === "activate" && event.to === null) {
-      throw new TypeError(`Odai skill evolution state.history[${index}].activate requires a target generation`);
-    }
-    if (event.action === "deactivate" && (event.from === null || event.to !== null)) {
-      throw new TypeError(`Odai skill evolution state.history[${index}].deactivate must clear an active generation`);
-    }
-    if (event.action === "rollback" && event.from === null) {
-      throw new TypeError(`Odai skill evolution state.history[${index}].rollback requires an active generation`);
-    }
-    prior = event.to;
-  }
-  const activeGenerationId = value.activeGenerationId === undefined
-    ? undefined
-    : safeGenerationId(value.activeGenerationId, "Odai skill evolution state.activeGenerationId");
-  const expectedActive = prior ?? undefined;
-  if (activeGenerationId !== expectedActive) {
-    throw new TypeError("Odai skill evolution state.activeGenerationId does not match its history");
-  }
-  return Object.freeze({
-    schemaVersion: STORE_SCHEMA_VERSION,
-    revision: value.revision,
-    ...(activeGenerationId ? { activeGenerationId } : {}),
-    history,
-  });
+    if (!existsSync(root))
+        return emptyState();
+    assertRegularDirectory(root, "Odai skill evolution root");
+    const path = resolve(root, STATE_FILE);
+    if (!existsSync(path))
+        return emptyState();
+    const value = readJsonFile(path, "Odai skill evolution state", MAX_STATE_BYTES);
+    assertExactFields(value, ["schemaVersion", "revision", "activeGenerationId", "history"], "Odai skill evolution state");
+    if (value.schemaVersion !== STORE_SCHEMA_VERSION) {
+        throw new TypeError(`Odai skill evolution state has unsupported schemaVersion ${String(value.schemaVersion)}`);
+    }
+    if (typeof value.revision !== "number" || !Number.isSafeInteger(value.revision) || value.revision < 0) {
+        throw new TypeError("Odai skill evolution state.revision must be a non-negative integer");
+    }
+    if (!Array.isArray(value.history) || value.history.length !== value.revision) {
+        throw new TypeError("Odai skill evolution state.history must match revision");
+    }
+    const history = Object.freeze(value.history.map(normalizeHistoryEvent));
+    let prior = null;
+    for (const [index, event] of history.entries()) {
+        if (event.from !== prior)
+            throw new TypeError(`Odai skill evolution state.history[${index}].from breaks the active-pointer chain`);
+        if (event.action === "activate" && event.to === null) {
+            throw new TypeError(`Odai skill evolution state.history[${index}].activate requires a target generation`);
+        }
+        if (event.action === "deactivate" && (event.from === null || event.to !== null)) {
+            throw new TypeError(`Odai skill evolution state.history[${index}].deactivate must clear an active generation`);
+        }
+        if (event.action === "rollback" && event.from === null) {
+            throw new TypeError(`Odai skill evolution state.history[${index}].rollback requires an active generation`);
+        }
+        prior = event.to;
+    }
+    const activeGenerationId = value.activeGenerationId === undefined
+        ? undefined
+        : safeGenerationId(value.activeGenerationId, "Odai skill evolution state.activeGenerationId");
+    const expectedActive = prior ?? undefined;
+    if (activeGenerationId !== expectedActive) {
+        throw new TypeError("Odai skill evolution state.activeGenerationId does not match its history");
+    }
+    return Object.freeze({
+        schemaVersion: STORE_SCHEMA_VERSION,
+        revision: value.revision,
+        ...(activeGenerationId ? { activeGenerationId } : {}),
+        history,
+    });
 }
-
 export function resolveSkillEvolutionRoot(configuredPath, env = process.env) {
-  if (configuredPath !== undefined) {
-    if (typeof configuredPath !== "string" || configuredPath.trim() === "") {
-      throw new TypeError("config.governance.evolutionRoot must be a non-empty string");
-    }
-    return resolve(configuredPath.trim());
-  }
-  const dshHome = typeof env.DSH_HOME === "string" && env.DSH_HOME.trim() !== ""
-    ? resolve(env.DSH_HOME.trim())
-    : resolve(homedir(), ".dsh");
-  return resolve(dshHome, "odai", "skill-evolution");
+    if (configuredPath !== undefined) {
+        if (typeof configuredPath !== "string" || configuredPath.trim() === "") {
+            throw new TypeError("config.governance.evolutionRoot must be a non-empty string");
+        }
+        return resolve(configuredPath.trim());
+    }
+    const dshHome = typeof env.DSH_HOME === "string" && env.DSH_HOME.trim() !== ""
+        ? resolve(env.DSH_HOME.trim())
+        : resolve(homedir(), ".dsh");
+    return resolve(dshHome, "odai", "skill-evolution");
 }
-
 export function skillEvolutionDisabled(env = process.env) {
-  return env.ODAI_DISABLE_EVOLUTION === "1";
+    return env.ODAI_DISABLE_EVOLUTION === "1";
 }
-
 function manifestValue(bundle) {
-  return {
-    schemaVersion: bundle.manifest.schemaVersion,
-    name: bundle.manifest.name,
-    skillVersion: bundle.manifest.skillVersion,
-    runtimeContract: bundle.manifest.runtimeContract,
-    requiredFiles: [...bundle.manifest.requiredFiles],
-  };
+    return {
+        schemaVersion: bundle.manifest.schemaVersion,
+        name: bundle.manifest.name,
+        skillVersion: bundle.manifest.skillVersion,
+        runtimeContract: bundle.manifest.runtimeContract,
+        requiredFiles: [...bundle.manifest.requiredFiles],
+    };
 }
-
 function snapshotBundle(bundle) {
-  const files = new Map();
-  for (const path of bundle.manifest.requiredFiles) {
-    const content = readSkillBundleFile(bundle, path);
-    if (content.byteLength > MAX_FILE_BYTES) throw new Error(`Odai skill file ${path} exceeds ${MAX_FILE_BYTES} bytes`);
-    files.set(path, content);
-  }
-  return Object.freeze({ manifest: Object.freeze(manifestValue(bundle)), files });
+    const files = new Map();
+    for (const path of bundle.manifest.requiredFiles) {
+        const content = readSkillBundleFile(bundle, path);
+        if (content.byteLength > MAX_FILE_BYTES)
+            throw new Error(`Odai skill file ${path} exceeds ${MAX_FILE_BYTES} bytes`);
+        files.set(path, content);
+    }
+    return Object.freeze({ manifest: Object.freeze(manifestValue(bundle)), files });
 }
-
 function cloneSnapshot(snapshot) {
-  return {
-    manifest: { ...snapshot.manifest, requiredFiles: [...snapshot.manifest.requiredFiles] },
-    files: new Map([...snapshot.files].map(([path, content]) => [path, Buffer.from(content)])),
-  };
+    return {
+        manifest: { ...snapshot.manifest, requiredFiles: [...snapshot.manifest.requiredFiles] },
+        files: new Map([...snapshot.files].map(([path, content]) => [path, Buffer.from(content)])),
+    };
 }
-
 function writeBundleSnapshot(root, snapshot) {
-  mkdirSync(root, { recursive: true, mode: 0o700 });
-  writeDurableFile(resolve(root, "manifest.json"), `${JSON.stringify(snapshot.manifest, null, 2)}\n`);
-  for (const [path, content] of snapshot.files) {
-    writeDurableFile(resolve(root, ...path.split("/")), content);
-  }
-  syncDirectory(root);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    writeDurableFile(resolve(root, "manifest.json"), `${JSON.stringify(snapshot.manifest, null, 2)}\n`);
+    for (const [path, content] of snapshot.files) {
+        writeDurableFile(resolve(root, ...path.split("/")), content);
+    }
+    syncDirectory(root);
 }
-
 function assertEvolvablePath(path, manifest, field = "path") {
-  const normalized = nonEmptyString(path, field);
-  if (!EVOLVABLE_PATH.test(normalized) || !manifest.requiredFiles.includes(normalized)) {
-    throw new TypeError(`${field} must name an existing Odai governance Markdown file`);
-  }
-  return normalized;
+    const normalized = nonEmptyString(path, field);
+    if (!EVOLVABLE_PATH.test(normalized) || !manifest.requiredFiles.includes(normalized)) {
+        throw new TypeError(`${field} must name an existing Odai governance Markdown file`);
+    }
+    return normalized;
 }
-
 function countOccurrences(text, needle) {
-  let count = 0;
-  let offset = 0;
-  while (true) {
-    const index = text.indexOf(needle, offset);
-    if (index < 0) return count;
-    count += 1;
-    offset = index + needle.length;
-  }
+    let count = 0;
+    let offset = 0;
+    while (true) {
+        const index = text.indexOf(needle, offset);
+        if (index < 0)
+            return count;
+        count += 1;
+        offset = index + needle.length;
+    }
 }
-
 function normalizeProposedChanges(value, manifest) {
-  if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
-    throw new TypeError("changes must contain 1-20 file changes");
-  }
-  const paths = new Set();
-  let totalBytes = 0;
-  return Object.freeze(value.map((raw, index) => {
-    const change = assertPlainObject(raw, `changes[${index}]`);
-    assertExactFields(change, ["path", "expectedSha256", "replacements"], `changes[${index}]`);
-    const path = assertEvolvablePath(change.path, manifest, `changes[${index}].path`);
-    if (paths.has(path)) throw new TypeError(`changes contains duplicate path ${path}`);
-    paths.add(path);
-    const expectedSha256 = exactDigest(change.expectedSha256, `changes[${index}].expectedSha256`);
-    if (!Array.isArray(change.replacements) || change.replacements.length === 0 || change.replacements.length > 20) {
-      throw new TypeError(`changes[${index}].replacements must contain 1-20 replacements`);
-    }
-    const replacements = Object.freeze(change.replacements.map((rawReplacement, replacementIndex) => {
-      const replacement = assertPlainObject(rawReplacement, `changes[${index}].replacements[${replacementIndex}]`);
-      assertExactFields(replacement, ["oldString", "newString"], `changes[${index}].replacements[${replacementIndex}]`);
-      const oldString = assertUtf8String(replacement.oldString, `changes[${index}].replacements[${replacementIndex}].oldString`);
-      const newString = assertUtf8String(replacement.newString, `changes[${index}].replacements[${replacementIndex}].newString`);
-      if (oldString.length === 0) throw new TypeError(`changes[${index}].replacements[${replacementIndex}].oldString must not be empty`);
-      if (oldString === newString) throw new TypeError(`changes[${index}].replacements[${replacementIndex}] does not change content`);
-      totalBytes += Buffer.byteLength(oldString) + Buffer.byteLength(newString);
-      if (totalBytes > MAX_TOTAL_REPLACEMENT_BYTES) {
-        throw new TypeError(`changes exceeds ${MAX_TOTAL_REPLACEMENT_BYTES} replacement bytes`);
-      }
-      return Object.freeze({ oldString, newString });
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new TypeError("changes must contain 1-20 file changes");
+    }
+    const paths = new Set();
+    let totalBytes = 0;
+    return Object.freeze(value.map((raw, index) => {
+        const change = assertPlainObject(raw, `changes[${index}]`);
+        assertExactFields(change, ["path", "expectedSha256", "replacements"], `changes[${index}]`);
+        const path = assertEvolvablePath(change.path, manifest, `changes[${index}].path`);
+        if (paths.has(path))
+            throw new TypeError(`changes contains duplicate path ${path}`);
+        paths.add(path);
+        const expectedSha256 = exactDigest(change.expectedSha256, `changes[${index}].expectedSha256`);
+        if (!Array.isArray(change.replacements) || change.replacements.length === 0 || change.replacements.length > 20) {
+            throw new TypeError(`changes[${index}].replacements must contain 1-20 replacements`);
+        }
+        const replacements = Object.freeze(change.replacements.map((rawReplacement, replacementIndex) => {
+            const replacement = assertPlainObject(rawReplacement, `changes[${index}].replacements[${replacementIndex}]`);
+            assertExactFields(replacement, ["oldString", "newString"], `changes[${index}].replacements[${replacementIndex}]`);
+            const oldString = assertUtf8String(replacement.oldString, `changes[${index}].replacements[${replacementIndex}].oldString`);
+            const newString = assertUtf8String(replacement.newString, `changes[${index}].replacements[${replacementIndex}].newString`);
+            if (oldString.length === 0)
+                throw new TypeError(`changes[${index}].replacements[${replacementIndex}].oldString must not be empty`);
+            if (oldString === newString)
+                throw new TypeError(`changes[${index}].replacements[${replacementIndex}] does not change content`);
+            totalBytes += Buffer.byteLength(oldString) + Buffer.byteLength(newString);
+            if (totalBytes > MAX_TOTAL_REPLACEMENT_BYTES) {
+                throw new TypeError(`changes exceeds ${MAX_TOTAL_REPLACEMENT_BYTES} replacement bytes`);
+            }
+            return Object.freeze({ oldString, newString });
+        }));
+        return Object.freeze({ path, expectedSha256, replacements });
     }));
-    return Object.freeze({ path, expectedSha256, replacements });
-  }));
 }
-
 function applyExactReplacements(text, replacements, field) {
-  let result = text;
-  for (const [index, replacement] of replacements.entries()) {
-    const count = countOccurrences(result, replacement.oldString);
-    if (count !== 1) throw new Error(`${field}.replacements[${index}].oldString must match exactly once; found ${count}`);
-    result = result.replace(replacement.oldString, replacement.newString);
-  }
-  return result;
+    let result = text;
+    for (const [index, replacement] of replacements.entries()) {
+        const count = countOccurrences(result, replacement.oldString);
+        if (count !== 1)
+            throw new Error(`${field}.replacements[${index}].oldString must match exactly once; found ${count}`);
+        result = result.replace(replacement.oldString, replacement.newString);
+    }
+    return result;
 }
-
 function mergePatchGroups(parentPatches, proposedChanges, upstreamSnapshot, effectiveSnapshot) {
-  const patches = new Map(parentPatches.map((patch) => [patch.path, {
-    path: patch.path,
-    baseSha256: patch.baseSha256,
-    replacements: patch.replacements.map((replacement) => ({ ...replacement })),
-  }]));
-  const finalSnapshot = cloneSnapshot(effectiveSnapshot);
-
-  for (const change of proposedChanges) {
-    const current = finalSnapshot.files.get(change.path);
-    if (!current) throw new Error(`current Odai bundle is missing ${change.path}`);
-    if (sha256(current) !== change.expectedSha256) throw new Error(`changes for ${change.path} use a stale file digest`);
-    const text = utf8Text(current, change.path);
-    const next = applyExactReplacements(text, change.replacements, `changes for ${change.path}`);
-    const nextBuffer = Buffer.from(next, "utf8");
-    if (nextBuffer.byteLength > MAX_FILE_BYTES) throw new Error(`${change.path} exceeds ${MAX_FILE_BYTES} bytes after replacement`);
-    finalSnapshot.files.set(change.path, nextBuffer);
-    const patch = patches.get(change.path) ?? {
-      path: change.path,
-      baseSha256: sha256(upstreamSnapshot.files.get(change.path)),
-      replacements: [],
-    };
-    patch.replacements.push(...change.replacements.map((replacement) => ({ ...replacement })));
-    patches.set(change.path, patch);
-  }
-
-  const normalized = [];
-  for (const patch of [...patches.values()].sort((left, right) => left.path.localeCompare(right.path))) {
-    const base = upstreamSnapshot.files.get(patch.path);
-    const result = finalSnapshot.files.get(patch.path);
-    if (!base || !result) throw new Error(`Odai evolution patch path disappeared: ${patch.path}`);
-    if (sha256(base) === sha256(result)) continue;
-    normalized.push(Object.freeze({
-      path: patch.path,
-      baseSha256: sha256(base),
-      resultSha256: sha256(result),
-      replacements: Object.freeze(patch.replacements.map((replacement) => Object.freeze({ ...replacement }))),
-    }));
-  }
-  if (normalized.length === 0) return { status: "absorbed", snapshot: finalSnapshot, patches: Object.freeze([]) };
-  return { status: "candidate", snapshot: finalSnapshot, patches: Object.freeze(normalized) };
+    const patches = new Map(parentPatches.map((patch) => [patch.path, {
+            path: patch.path,
+            baseSha256: patch.baseSha256,
+            replacements: patch.replacements.map((replacement) => ({ ...replacement })),
+        }]));
+    const finalSnapshot = cloneSnapshot(effectiveSnapshot);
+    for (const change of proposedChanges) {
+        const current = finalSnapshot.files.get(change.path);
+        if (!current)
+            throw new Error(`current Odai bundle is missing ${change.path}`);
+        if (sha256(current) !== change.expectedSha256)
+            throw new Error(`changes for ${change.path} use a stale file digest`);
+        const text = utf8Text(current, change.path);
+        const next = applyExactReplacements(text, change.replacements, `changes for ${change.path}`);
+        const nextBuffer = Buffer.from(next, "utf8");
+        if (nextBuffer.byteLength > MAX_FILE_BYTES)
+            throw new Error(`${change.path} exceeds ${MAX_FILE_BYTES} bytes after replacement`);
+        finalSnapshot.files.set(change.path, nextBuffer);
+        const upstreamBase = upstreamSnapshot.files.get(change.path);
+        if (!upstreamBase)
+            throw new Error(`upstream Odai bundle is missing ${change.path}`);
+        const patch = patches.get(change.path) ?? {
+            path: change.path,
+            baseSha256: sha256(upstreamBase),
+            replacements: [],
+        };
+        patch.replacements.push(...change.replacements.map((replacement) => ({ ...replacement })));
+        patches.set(change.path, patch);
+    }
+    const normalized = [];
+    for (const patch of [...patches.values()].sort((left, right) => left.path.localeCompare(right.path))) {
+        const base = upstreamSnapshot.files.get(patch.path);
+        const result = finalSnapshot.files.get(patch.path);
+        if (!base || !result)
+            throw new Error(`Odai evolution patch path disappeared: ${patch.path}`);
+        if (sha256(base) === sha256(result))
+            continue;
+        normalized.push(Object.freeze({
+            path: patch.path,
+            baseSha256: sha256(base),
+            resultSha256: sha256(result),
+            replacements: Object.freeze(patch.replacements.map((replacement) => Object.freeze({ ...replacement }))),
+        }));
+    }
+    if (normalized.length === 0)
+        return { status: "absorbed", snapshot: finalSnapshot, patches: Object.freeze([]) };
+    return { status: "candidate", snapshot: finalSnapshot, patches: Object.freeze(normalized) };
 }
-
 function normalizePatchMetadata(value, manifest) {
-  if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
-    throw new TypeError("Odai evolution metadata.patches must contain 1-20 patches");
-  }
-  const paths = new Set();
-  return Object.freeze(value.map((raw, index) => {
-    const patch = assertPlainObject(raw, `Odai evolution metadata.patches[${index}]`);
-    assertExactFields(patch, ["path", "baseSha256", "resultSha256", "replacements"], `Odai evolution metadata.patches[${index}]`);
-    const path = assertEvolvablePath(patch.path, manifest, `Odai evolution metadata.patches[${index}].path`);
-    if (paths.has(path)) throw new TypeError(`Odai evolution metadata contains duplicate patch path ${path}`);
-    paths.add(path);
-    if (!Array.isArray(patch.replacements) || patch.replacements.length === 0 || patch.replacements.length > 100) {
-      throw new TypeError(`Odai evolution metadata.patches[${index}].replacements is invalid`);
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new TypeError("Odai evolution metadata.patches must contain 1-20 patches");
     }
-    return Object.freeze({
-      path,
-      baseSha256: exactDigest(patch.baseSha256, `Odai evolution metadata.patches[${index}].baseSha256`),
-      resultSha256: exactDigest(patch.resultSha256, `Odai evolution metadata.patches[${index}].resultSha256`),
-      replacements: Object.freeze(patch.replacements.map((rawReplacement, replacementIndex) => {
-        const replacement = assertPlainObject(rawReplacement, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}]`);
-        assertExactFields(replacement, ["oldString", "newString"], `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}]`);
-        const oldString = assertUtf8String(replacement.oldString, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}].oldString`);
-        const newString = assertUtf8String(replacement.newString, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}].newString`);
-        if (!oldString || oldString === newString) throw new TypeError(`Odai evolution metadata.patches[${index}].replacements[${replacementIndex}] is invalid`);
-        return Object.freeze({ oldString, newString });
-      })),
-    });
-  }));
+    const paths = new Set();
+    return Object.freeze(value.map((raw, index) => {
+        const patch = assertPlainObject(raw, `Odai evolution metadata.patches[${index}]`);
+        assertExactFields(patch, ["path", "baseSha256", "resultSha256", "replacements"], `Odai evolution metadata.patches[${index}]`);
+        const path = assertEvolvablePath(patch.path, manifest, `Odai evolution metadata.patches[${index}].path`);
+        if (paths.has(path))
+            throw new TypeError(`Odai evolution metadata contains duplicate patch path ${path}`);
+        paths.add(path);
+        if (!Array.isArray(patch.replacements) || patch.replacements.length === 0 || patch.replacements.length > 100) {
+            throw new TypeError(`Odai evolution metadata.patches[${index}].replacements is invalid`);
+        }
+        return Object.freeze({
+            path,
+            baseSha256: exactDigest(patch.baseSha256, `Odai evolution metadata.patches[${index}].baseSha256`),
+            resultSha256: exactDigest(patch.resultSha256, `Odai evolution metadata.patches[${index}].resultSha256`),
+            replacements: Object.freeze(patch.replacements.map((rawReplacement, replacementIndex) => {
+                const replacement = assertPlainObject(rawReplacement, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}]`);
+                assertExactFields(replacement, ["oldString", "newString"], `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}]`);
+                const oldString = assertUtf8String(replacement.oldString, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}].oldString`);
+                const newString = assertUtf8String(replacement.newString, `Odai evolution metadata.patches[${index}].replacements[${replacementIndex}].newString`);
+                if (!oldString || oldString === newString)
+                    throw new TypeError(`Odai evolution metadata.patches[${index}].replacements[${replacementIndex}] is invalid`);
+                return Object.freeze({ oldString, newString });
+            })),
+        });
+    }));
 }
-
 function normalizeGenerationAuthorization(value) {
-  const authorization = assertPlainObject(value, "Odai evolution generation metadata.authorization");
-  assertExactFields(authorization, ["action", "phrase", "turn", "eventSeq", "messageId"], "Odai evolution generation metadata.authorization");
-  if (!["propose", "rebase"].includes(authorization.action)) {
-    throw new TypeError("Odai evolution generation metadata.authorization.action is invalid");
-  }
-  if (!Number.isSafeInteger(authorization.turn) || authorization.turn < 0) {
-    throw new TypeError("Odai evolution generation metadata.authorization.turn must be a non-negative integer");
-  }
-  if (!Number.isSafeInteger(authorization.eventSeq) || authorization.eventSeq < 0) {
-    throw new TypeError("Odai evolution generation metadata.authorization.eventSeq must be a non-negative integer");
-  }
-  return Object.freeze({
-    action: authorization.action,
-    phrase: nonEmptyString(authorization.phrase, "Odai evolution generation metadata.authorization.phrase", 200),
-    turn: authorization.turn,
-    eventSeq: authorization.eventSeq,
-    messageId: nonEmptyString(authorization.messageId, "Odai evolution generation metadata.authorization.messageId", 200),
-  });
+    const authorization = assertPlainObject(value, "Odai evolution generation metadata.authorization");
+    assertExactFields(authorization, ["action", "phrase", "turn", "eventSeq", "messageId"], "Odai evolution generation metadata.authorization");
+    if (authorization.action !== "propose" && authorization.action !== "rebase") {
+        throw new TypeError("Odai evolution generation metadata.authorization.action is invalid");
+    }
+    if (typeof authorization.turn !== "number" || !Number.isSafeInteger(authorization.turn) || authorization.turn < 0) {
+        throw new TypeError("Odai evolution generation metadata.authorization.turn must be a non-negative integer");
+    }
+    if (typeof authorization.eventSeq !== "number" || !Number.isSafeInteger(authorization.eventSeq) || authorization.eventSeq < 0) {
+        throw new TypeError("Odai evolution generation metadata.authorization.eventSeq must be a non-negative integer");
+    }
+    return Object.freeze({
+        action: authorization.action,
+        phrase: nonEmptyString(authorization.phrase, "Odai evolution generation metadata.authorization.phrase", 200),
+        turn: authorization.turn,
+        eventSeq: authorization.eventSeq,
+        messageId: nonEmptyString(authorization.messageId, "Odai evolution generation metadata.authorization.messageId", 200),
+    });
 }
-
 function generationIdentity(metadata) {
-  return {
-    schemaVersion: STORE_SCHEMA_VERSION,
-    parentGenerationId: metadata.parentGenerationId ?? null,
-    createdAt: metadata.createdAt,
-    objective: metadata.objective,
-    ...(metadata.authorization ? {
-      authorization: {
-        action: metadata.authorization.action,
-        phrase: metadata.authorization.phrase,
-        turn: metadata.authorization.turn,
-        eventSeq: metadata.authorization.eventSeq,
-        messageId: metadata.authorization.messageId,
-      },
-    } : {}),
-    base: {
-      source: metadata.base.source,
-      provider: metadata.base.provider,
-      skillVersion: metadata.base.skillVersion,
-      runtimeContract: metadata.base.runtimeContract,
-      digest: metadata.base.digest,
-    },
-    result: {
-      skillVersion: metadata.result.skillVersion,
-      runtimeContract: metadata.result.runtimeContract,
-      digest: metadata.result.digest,
-    },
-    patches: metadata.patches.map((patch) => ({
-      path: patch.path,
-      baseSha256: patch.baseSha256,
-      resultSha256: patch.resultSha256,
-      replacements: patch.replacements.map((replacement) => ({
-        oldString: replacement.oldString,
-        newString: replacement.newString,
-      })),
-    })),
-  };
+    return {
+        schemaVersion: STORE_SCHEMA_VERSION,
+        parentGenerationId: metadata.parentGenerationId ?? null,
+        createdAt: metadata.createdAt,
+        objective: metadata.objective,
+        ...(metadata.authorization ? {
+            authorization: {
+                action: metadata.authorization.action,
+                phrase: metadata.authorization.phrase,
+                turn: metadata.authorization.turn,
+                eventSeq: metadata.authorization.eventSeq,
+                messageId: metadata.authorization.messageId,
+            },
+        } : {}),
+        base: {
+            source: metadata.base.source,
+            provider: metadata.base.provider,
+            skillVersion: metadata.base.skillVersion,
+            runtimeContract: metadata.base.runtimeContract,
+            digest: metadata.base.digest,
+        },
+        result: {
+            skillVersion: metadata.result.skillVersion,
+            runtimeContract: metadata.result.runtimeContract,
+            digest: metadata.result.digest,
+        },
+        patches: metadata.patches.map((patch) => ({
+            path: patch.path,
+            baseSha256: patch.baseSha256,
+            resultSha256: patch.resultSha256,
+            replacements: patch.replacements.map((replacement) => ({
+                oldString: replacement.oldString,
+                newString: replacement.newString,
+            })),
+        })),
+    };
 }
-
 function generationIdFor(metadata) {
-  return sha256(Buffer.from(JSON.stringify(generationIdentity(metadata)), "utf8"));
+    return sha256(Buffer.from(JSON.stringify(generationIdentity(metadata)), "utf8"));
 }
-
 function normalizeGenerationMetadata(value, expectedId) {
-  const metadata = assertPlainObject(value, "Odai evolution generation metadata");
-  assertExactFields(metadata, ["schemaVersion", "generationId", "parentGenerationId", "createdAt", "objective", "authorization", "base", "result", "patches"], "Odai evolution generation metadata");
-  if (metadata.schemaVersion !== STORE_SCHEMA_VERSION) throw new TypeError("Odai evolution generation metadata schema is unsupported");
-  const generationId = safeGenerationId(metadata.generationId, "Odai evolution generation metadata.generationId");
-  if (generationId !== expectedId) throw new Error(`Odai evolution generation directory ${expectedId} contains metadata for ${generationId}`);
-  const parentGenerationId = metadata.parentGenerationId === undefined
-    ? undefined
-    : safeGenerationId(metadata.parentGenerationId, "Odai evolution generation metadata.parentGenerationId");
-  if (parentGenerationId === generationId) throw new Error("Odai evolution generation cannot parent itself");
-  const base = assertPlainObject(metadata.base, "Odai evolution generation metadata.base");
-  const result = assertPlainObject(metadata.result, "Odai evolution generation metadata.result");
-  assertExactFields(base, ["source", "provider", "skillVersion", "runtimeContract", "digest"], "Odai evolution generation metadata.base");
-  assertExactFields(result, ["skillVersion", "runtimeContract", "digest"], "Odai evolution generation metadata.result");
-  return {
-    schemaVersion: STORE_SCHEMA_VERSION,
-    generationId,
-    ...(parentGenerationId ? { parentGenerationId } : {}),
-    createdAt: validTimestamp(metadata.createdAt, "Odai evolution generation metadata.createdAt"),
-    objective: nonEmptyString(metadata.objective, "Odai evolution generation metadata.objective", MAX_OBJECTIVE_CHARS),
-    ...(metadata.authorization === undefined ? {} : { authorization: normalizeGenerationAuthorization(metadata.authorization) }),
-    base: {
-      source: nonEmptyString(base.source, "Odai evolution generation metadata.base.source"),
-      provider: nonEmptyString(base.provider, "Odai evolution generation metadata.base.provider"),
-      skillVersion: nonEmptyString(base.skillVersion, "Odai evolution generation metadata.base.skillVersion"),
-      runtimeContract: base.runtimeContract,
-      digest: exactDigest(base.digest, "Odai evolution generation metadata.base.digest"),
-    },
-    result: {
-      skillVersion: nonEmptyString(result.skillVersion, "Odai evolution generation metadata.result.skillVersion"),
-      runtimeContract: result.runtimeContract,
-      digest: exactDigest(result.digest, "Odai evolution generation metadata.result.digest"),
-    },
-    patches: metadata.patches,
-  };
+    const metadata = assertPlainObject(value, "Odai evolution generation metadata");
+    assertExactFields(metadata, ["schemaVersion", "generationId", "parentGenerationId", "createdAt", "objective", "authorization", "base", "result", "patches"], "Odai evolution generation metadata");
+    if (metadata.schemaVersion !== STORE_SCHEMA_VERSION)
+        throw new TypeError("Odai evolution generation metadata schema is unsupported");
+    const generationId = safeGenerationId(metadata.generationId, "Odai evolution generation metadata.generationId");
+    if (generationId !== expectedId)
+        throw new Error(`Odai evolution generation directory ${expectedId} contains metadata for ${generationId}`);
+    const parentGenerationId = metadata.parentGenerationId === undefined
+        ? undefined
+        : safeGenerationId(metadata.parentGenerationId, "Odai evolution generation metadata.parentGenerationId");
+    if (parentGenerationId === generationId)
+        throw new Error("Odai evolution generation cannot parent itself");
+    const base = assertPlainObject(metadata.base, "Odai evolution generation metadata.base");
+    const result = assertPlainObject(metadata.result, "Odai evolution generation metadata.result");
+    assertExactFields(base, ["source", "provider", "skillVersion", "runtimeContract", "digest"], "Odai evolution generation metadata.base");
+    assertExactFields(result, ["skillVersion", "runtimeContract", "digest"], "Odai evolution generation metadata.result");
+    return {
+        schemaVersion: STORE_SCHEMA_VERSION,
+        generationId,
+        ...(parentGenerationId ? { parentGenerationId } : {}),
+        createdAt: validTimestamp(metadata.createdAt, "Odai evolution generation metadata.createdAt"),
+        objective: nonEmptyString(metadata.objective, "Odai evolution generation metadata.objective", MAX_OBJECTIVE_CHARS),
+        ...(metadata.authorization === undefined ? {} : { authorization: normalizeGenerationAuthorization(metadata.authorization) }),
+        base: {
+            source: nonEmptyString(base.source, "Odai evolution generation metadata.base.source"),
+            provider: nonEmptyString(base.provider, "Odai evolution generation metadata.base.provider"),
+            skillVersion: nonEmptyString(base.skillVersion, "Odai evolution generation metadata.base.skillVersion"),
+            runtimeContract: base.runtimeContract,
+            digest: exactDigest(base.digest, "Odai evolution generation metadata.base.digest"),
+        },
+        result: {
+            skillVersion: nonEmptyString(result.skillVersion, "Odai evolution generation metadata.result.skillVersion"),
+            runtimeContract: result.runtimeContract,
+            digest: exactDigest(result.digest, "Odai evolution generation metadata.result.digest"),
+        },
+        patches: metadata.patches,
+    };
 }
-
 function walkTree(root, prefix = "") {
-  const found = [];
-  for (const entry of readdirSync(root, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
-    const path = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isSymbolicLink()) throw new Error(`Odai evolution bundle contains a symbolic link: ${path}`);
-    if (entry.isDirectory()) found.push(...walkTree(resolve(root, entry.name), path));
-    else if (entry.isFile()) found.push(path);
-    else throw new Error(`Odai evolution bundle contains an unsupported filesystem entry: ${path}`);
-  }
-  return found;
+    const found = [];
+    for (const entry of readdirSync(root, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+        const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isSymbolicLink())
+            throw new Error(`Odai evolution bundle contains a symbolic link: ${path}`);
+        if (entry.isDirectory())
+            found.push(...walkTree(resolve(root, entry.name), path));
+        else if (entry.isFile())
+            found.push(path);
+        else
+            throw new Error(`Odai evolution bundle contains an unsupported filesystem entry: ${path}`);
+    }
+    return found;
 }
-
 function assertExactBundleTree(root, manifest) {
-  const expected = new Set(["manifest.json", ...manifest.requiredFiles]);
-  const actual = walkTree(root);
-  for (const path of actual) {
-    if (!expected.has(path)) throw new Error(`Odai evolution bundle contains undeclared file ${path}`);
-  }
-  for (const path of expected) {
-    if (!actual.includes(path)) throw new Error(`Odai evolution bundle is missing ${path}`);
-  }
+    const expected = new Set(["manifest.json", ...manifest.requiredFiles]);
+    const actual = walkTree(root);
+    for (const path of actual) {
+        if (!expected.has(path))
+            throw new Error(`Odai evolution bundle contains undeclared file ${path}`);
+    }
+    for (const path of expected) {
+        if (!actual.includes(path))
+            throw new Error(`Odai evolution bundle is missing ${path}`);
+    }
 }
-
 function generationAuthorizationProfile(baseSnapshot, resultSnapshot, patches) {
-  const reasons = new Set();
-  for (const path of PROTECTED_GOVERNANCE_FILES) {
-    const base = baseSnapshot.files.get(path);
-    const result = resultSnapshot.files.get(path);
-    if (!base || !result || !base.equals(result)) reasons.add(`protected-file:${path}`);
-  }
-  for (const patch of patches) {
-    if (patch.replacements.some((replacement) => !replacement.newString.includes(replacement.oldString))) {
-      reasons.add(`destructive-replacement:${patch.path}`);
-    }
-  }
-  const breakingReasons = Object.freeze([...reasons].sort());
-  return Object.freeze({
-    level: breakingReasons.length > 0 ? "breaking" : "standard",
-    breakingReasons,
-  });
+    const reasons = new Set();
+    for (const path of PROTECTED_GOVERNANCE_FILES) {
+        const base = baseSnapshot.files.get(path);
+        const result = resultSnapshot.files.get(path);
+        if (!base || !result || !base.equals(result))
+            reasons.add(`protected-file:${path}`);
+    }
+    for (const patch of patches) {
+        if (patch.replacements.some((replacement) => !replacement.newString.includes(replacement.oldString))) {
+            reasons.add(`destructive-replacement:${patch.path}`);
+        }
+    }
+    const breakingReasons = Object.freeze([...reasons].sort());
+    return Object.freeze({
+        level: breakingReasons.length > 0 ? "breaking" : "standard",
+        breakingReasons,
+    });
 }
-
 function activationPhrase(generationId, level) {
-  return `ACTIVATE${level === "breaking" ? " BREAKING" : ""} ODAI EVOLUTION ${generationId}`;
+    return `ACTIVATE${level === "breaking" ? " BREAKING" : ""} ODAI EVOLUTION ${generationId}`;
 }
-
 function validateGeneration(root, generationId, ancestry = new Set()) {
-  const id = safeGenerationId(generationId);
-  if (ancestry.has(id)) throw new Error(`Odai evolution lineage contains a cycle at ${id}`);
-  const nextAncestry = new Set(ancestry);
-  nextAncestry.add(id);
-  requireStoreDirectory(root, "generations");
-  const generationRoot = safePath(root, "generations", id);
-  const stat = lstatSync(generationRoot);
-  if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`Odai evolution generation ${id} must be a regular directory`);
-  const children = readdirSync(generationRoot).sort();
-  if (JSON.stringify(children) !== JSON.stringify(["base", "bundle", METADATA_FILE].sort())) {
-    throw new Error(`Odai evolution generation ${id} contains undeclared entries`);
-  }
-  const rawMetadata = readJsonFile(resolve(generationRoot, METADATA_FILE), `Odai evolution generation ${id} metadata`, MAX_METADATA_BYTES);
-  const initial = normalizeGenerationMetadata(rawMetadata, id);
-  const baseBundle = loadSkillBundle(resolve(generationRoot, "base/SKILL.md"), { source: "evolution-base", provider: "odai-evolution-store" });
-  const resultBundle = loadSkillBundle(resolve(generationRoot, "bundle/SKILL.md"), { source: "evolution", provider: "odai-evolution-store" });
-  assertExactBundleTree(resolve(generationRoot, "base"), baseBundle.manifest);
-  assertExactBundleTree(resolve(generationRoot, "bundle"), resultBundle.manifest);
-  if (baseBundle.digest !== initial.base.digest) throw new Error(`Odai evolution generation ${id} base digest does not match metadata`);
-  if (resultBundle.digest !== initial.result.digest) {
-    throw new Error(`Odai evolution generation ${id} result digest does not match metadata`);
-  }
-  if (JSON.stringify(manifestValue(baseBundle)) !== JSON.stringify(manifestValue(resultBundle))) {
-    throw new Error(`Odai evolution generation ${id} changes the skill manifest`);
-  }
-  if (initial.base.skillVersion !== baseBundle.manifest.skillVersion
-    || initial.base.runtimeContract !== baseBundle.manifest.runtimeContract
-    || initial.result.skillVersion !== resultBundle.manifest.skillVersion
-    || initial.result.runtimeContract !== resultBundle.manifest.runtimeContract) {
-    throw new Error(`Odai evolution generation ${id} metadata does not match its manifests`);
-  }
-  const patches = normalizePatchMetadata(initial.patches, baseBundle.manifest);
-  if (generationIdFor({ ...initial, patches }) !== id) {
-    throw new Error(`Odai evolution generation ${id} identity does not cover its stored provenance`);
-  }
-  const baseSnapshot = snapshotBundle(baseBundle);
-  const replay = cloneSnapshot(baseSnapshot);
-  for (const patch of patches) {
-    const baseContent = baseSnapshot.files.get(patch.path);
-    if (sha256(baseContent) !== patch.baseSha256) throw new Error(`Odai evolution patch ${patch.path} base digest is invalid`);
-    const resultText = applyExactReplacements(utf8Text(baseContent, patch.path), patch.replacements, `Odai evolution patch ${patch.path}`);
-    const resultContent = Buffer.from(resultText, "utf8");
-    if (sha256(resultContent) !== patch.resultSha256) throw new Error(`Odai evolution patch ${patch.path} result digest is invalid`);
-    replay.files.set(patch.path, resultContent);
-  }
-  const resultSnapshot = snapshotBundle(resultBundle);
-  for (const path of baseBundle.manifest.requiredFiles) {
-    const expected = replay.files.get(path);
-    const actual = resultSnapshot.files.get(path);
-    if (!expected.equals(actual)) throw new Error(`Odai evolution generation ${id} has an untracked change in ${path}`);
-  }
-  const authorization = generationAuthorizationProfile(baseSnapshot, resultSnapshot, patches);
-  if (initial.parentGenerationId) validateGeneration(root, initial.parentGenerationId, nextAncestry);
-  return Object.freeze({
-    root: generationRoot,
-    metadata: Object.freeze({
-      ...initial,
-      base: Object.freeze(initial.base),
-      result: Object.freeze(initial.result),
-      patches,
-    }),
-    baseBundle,
-    resultBundle,
-    baseSnapshot,
-    resultSnapshot,
-    authorization,
-  });
+    const id = safeGenerationId(generationId);
+    if (ancestry.has(id))
+        throw new Error(`Odai evolution lineage contains a cycle at ${id}`);
+    const nextAncestry = new Set(ancestry);
+    nextAncestry.add(id);
+    requireStoreDirectory(root, "generations");
+    const generationRoot = safePath(root, "generations", id);
+    const stat = lstatSync(generationRoot);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw new Error(`Odai evolution generation ${id} must be a regular directory`);
+    const children = readdirSync(generationRoot).sort();
+    if (JSON.stringify(children) !== JSON.stringify(["base", "bundle", METADATA_FILE].sort())) {
+        throw new Error(`Odai evolution generation ${id} contains undeclared entries`);
+    }
+    const rawMetadata = readJsonFile(resolve(generationRoot, METADATA_FILE), `Odai evolution generation ${id} metadata`, MAX_METADATA_BYTES);
+    const initial = normalizeGenerationMetadata(rawMetadata, id);
+    const baseBundle = loadSkillBundle(resolve(generationRoot, "base/SKILL.md"), { source: "evolution-base", provider: "odai-evolution-store" });
+    const resultBundle = loadSkillBundle(resolve(generationRoot, "bundle/SKILL.md"), { source: "evolution", provider: "odai-evolution-store" });
+    assertExactBundleTree(resolve(generationRoot, "base"), baseBundle.manifest);
+    assertExactBundleTree(resolve(generationRoot, "bundle"), resultBundle.manifest);
+    if (baseBundle.digest !== initial.base.digest)
+        throw new Error(`Odai evolution generation ${id} base digest does not match metadata`);
+    if (resultBundle.digest !== initial.result.digest) {
+        throw new Error(`Odai evolution generation ${id} result digest does not match metadata`);
+    }
+    if (JSON.stringify(manifestValue(baseBundle)) !== JSON.stringify(manifestValue(resultBundle))) {
+        throw new Error(`Odai evolution generation ${id} changes the skill manifest`);
+    }
+    if (initial.base.skillVersion !== baseBundle.manifest.skillVersion
+        || initial.base.runtimeContract !== baseBundle.manifest.runtimeContract
+        || initial.result.skillVersion !== resultBundle.manifest.skillVersion
+        || initial.result.runtimeContract !== resultBundle.manifest.runtimeContract) {
+        throw new Error(`Odai evolution generation ${id} metadata does not match its manifests`);
+    }
+    const patches = normalizePatchMetadata(initial.patches, baseBundle.manifest);
+    if (generationIdFor({ ...initial, patches }) !== id) {
+        throw new Error(`Odai evolution generation ${id} identity does not cover its stored provenance`);
+    }
+    const baseSnapshot = snapshotBundle(baseBundle);
+    const replay = cloneSnapshot(baseSnapshot);
+    for (const patch of patches) {
+        const baseContent = baseSnapshot.files.get(patch.path);
+        if (!baseContent)
+            throw new Error(`Odai evolution patch path is missing from base: ${patch.path}`);
+        if (sha256(baseContent) !== patch.baseSha256)
+            throw new Error(`Odai evolution patch ${patch.path} base digest is invalid`);
+        const resultText = applyExactReplacements(utf8Text(baseContent, patch.path), patch.replacements, `Odai evolution patch ${patch.path}`);
+        const resultContent = Buffer.from(resultText, "utf8");
+        if (sha256(resultContent) !== patch.resultSha256)
+            throw new Error(`Odai evolution patch ${patch.path} result digest is invalid`);
+        replay.files.set(patch.path, resultContent);
+    }
+    const resultSnapshot = snapshotBundle(resultBundle);
+    for (const path of baseBundle.manifest.requiredFiles) {
+        const expected = replay.files.get(path);
+        const actual = resultSnapshot.files.get(path);
+        if (!expected || !actual || !expected.equals(actual))
+            throw new Error(`Odai evolution generation ${id} has an untracked change in ${path}`);
+    }
+    const authorization = generationAuthorizationProfile(baseSnapshot, resultSnapshot, patches);
+    if (initial.parentGenerationId)
+        validateGeneration(root, initial.parentGenerationId, nextAncestry);
+    return Object.freeze({
+        root: generationRoot,
+        metadata: Object.freeze({
+            ...initial,
+            base: Object.freeze(initial.base),
+            result: Object.freeze(initial.result),
+            patches,
+        }),
+        baseBundle,
+        resultBundle,
+        baseSnapshot,
+        resultSnapshot,
+        authorization,
+    });
 }
-
 function generationSummary(validated) {
-  return Object.freeze({
-    generationId: validated.metadata.generationId,
-    ...(validated.metadata.parentGenerationId ? { parentGenerationId: validated.metadata.parentGenerationId } : {}),
-    createdAt: validated.metadata.createdAt,
-    objective: validated.metadata.objective,
-    ...(validated.metadata.authorization ? { creationAuthorization: validated.metadata.authorization } : {}),
-    baseDigest: validated.metadata.base.digest,
-    resultDigest: validated.metadata.result.digest,
-    skillVersion: validated.metadata.result.skillVersion,
-    runtimeContract: validated.metadata.result.runtimeContract,
-    changedPaths: Object.freeze(validated.metadata.patches.map((patch) => patch.path)),
-    authorizationLevel: validated.authorization.level,
-    activationPhrase: activationPhrase(validated.metadata.generationId, validated.authorization.level),
-    breakingReasons: validated.authorization.breakingReasons,
-  });
+    return Object.freeze({
+        generationId: validated.metadata.generationId,
+        ...(validated.metadata.parentGenerationId ? { parentGenerationId: validated.metadata.parentGenerationId } : {}),
+        createdAt: validated.metadata.createdAt,
+        objective: validated.metadata.objective,
+        ...(validated.metadata.authorization ? { creationAuthorization: validated.metadata.authorization } : {}),
+        baseDigest: validated.metadata.base.digest,
+        resultDigest: validated.metadata.result.digest,
+        skillVersion: validated.metadata.result.skillVersion,
+        runtimeContract: validated.metadata.result.runtimeContract,
+        changedPaths: Object.freeze(validated.metadata.patches.map((patch) => patch.path)),
+        authorizationLevel: validated.authorization.level,
+        activationPhrase: activationPhrase(validated.metadata.generationId, validated.authorization.level),
+        breakingReasons: validated.authorization.breakingReasons,
+    });
 }
-
 function listGenerations(root) {
-  if (existsSync(root)) assertRegularDirectory(root, "Odai skill evolution root");
-  const generationsRoot = resolve(root, "generations");
-  if (!existsSync(generationsRoot)) return { generations: Object.freeze([]), diagnostics: Object.freeze([]) };
-  assertRegularDirectory(generationsRoot, "Odai skill evolution generations directory");
-  const generations = [];
-  const diagnostics = [];
-  for (const entry of readdirSync(generationsRoot, { withFileTypes: true })) {
-    if (!entry.isDirectory() || !DIGEST_PATTERN.test(entry.name)) {
-      diagnostics.push(Object.freeze({ generationId: entry.name, error: "invalid generation entry" }));
-      continue;
+    if (existsSync(root))
+        assertRegularDirectory(root, "Odai skill evolution root");
+    const generationsRoot = resolve(root, "generations");
+    if (!existsSync(generationsRoot))
+        return { generations: Object.freeze([]), diagnostics: Object.freeze([]) };
+    assertRegularDirectory(generationsRoot, "Odai skill evolution generations directory");
+    const generations = [];
+    const diagnostics = [];
+    for (const entry of readdirSync(generationsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !DIGEST_PATTERN.test(entry.name)) {
+            diagnostics.push(Object.freeze({ generationId: entry.name, error: "invalid generation entry" }));
+            continue;
+        }
+        try {
+            generations.push(generationSummary(validateGeneration(root, entry.name)));
+        }
+        catch (error) {
+            diagnostics.push(Object.freeze({ generationId: entry.name, error: error instanceof Error ? error.message : String(error) }));
+        }
     }
-    try {
-      generations.push(generationSummary(validateGeneration(root, entry.name)));
-    } catch (error) {
-      diagnostics.push(Object.freeze({ generationId: entry.name, error: error instanceof Error ? error.message : String(error) }));
-    }
-  }
-  generations.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-  diagnostics.sort((left, right) => left.generationId.localeCompare(right.generationId));
-  return { generations: Object.freeze(generations), diagnostics: Object.freeze(diagnostics) };
+    generations.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+    diagnostics.sort((left, right) => left.generationId.localeCompare(right.generationId));
+    return { generations: Object.freeze(generations), diagnostics: Object.freeze(diagnostics) };
 }
-
-function createGeneration(root, upstreamBundle, finalSnapshot, patches, options = {}) {
-  const upstreamSnapshot = snapshotBundle(upstreamBundle);
-  const generationsRoot = ensureStoreDirectory(root, "generations");
-  const temporary = safePath(root, "generations", `.tmp-${process.pid}-${randomUUID()}`);
-  try {
-    writeBundleSnapshot(resolve(temporary, "base"), upstreamSnapshot);
-    writeBundleSnapshot(resolve(temporary, "bundle"), finalSnapshot);
-    const baseBundle = loadSkillBundle(resolve(temporary, "base/SKILL.md"));
-    const resultBundle = loadSkillBundle(resolve(temporary, "bundle/SKILL.md"));
-    if (baseBundle.digest !== upstreamBundle.digest) throw new Error("Odai evolution base changed while creating a candidate");
-    if (resultBundle.digest === baseBundle.digest) return { status: "absorbed" };
-    const identity = {
-      schemaVersion: STORE_SCHEMA_VERSION,
-      ...(options.parentGenerationId ? { parentGenerationId: options.parentGenerationId } : {}),
-      createdAt: options.now(),
-      objective: options.objective,
-      authorization: options.authorization,
-      base: {
-        source: upstreamBundle.source,
-        provider: upstreamBundle.provider,
-        skillVersion: baseBundle.manifest.skillVersion,
-        runtimeContract: baseBundle.manifest.runtimeContract,
-        digest: baseBundle.digest,
-      },
-      result: {
-        skillVersion: resultBundle.manifest.skillVersion,
-        runtimeContract: resultBundle.manifest.runtimeContract,
-        digest: resultBundle.digest,
-      },
-      patches,
-    };
-    const generationId = generationIdFor(identity);
-    const metadata = { generationId, ...identity };
-    writeDurableFile(resolve(temporary, METADATA_FILE), `${JSON.stringify(metadata, null, 2)}\n`);
-    syncDirectory(temporary);
-    const destination = safePath(root, "generations", generationId);
-    if (existsSync(destination)) {
-      const existing = validateGeneration(root, generationId);
-      return { status: "reused", generation: existing };
-    }
-    renameSync(temporary, destination);
-    syncDirectory(generationsRoot);
-    return { status: "candidate", generation: validateGeneration(root, generationId) };
-  } finally {
-    rmSync(temporary, { recursive: true, force: true });
-  }
+function createGeneration(root, upstreamBundle, finalSnapshot, patches, options) {
+    const upstreamSnapshot = snapshotBundle(upstreamBundle);
+    const generationsRoot = ensureStoreDirectory(root, "generations");
+    const temporary = safePath(root, "generations", `.tmp-${process.pid}-${randomUUID()}`);
+    try {
+        writeBundleSnapshot(resolve(temporary, "base"), upstreamSnapshot);
+        writeBundleSnapshot(resolve(temporary, "bundle"), finalSnapshot);
+        const baseBundle = loadSkillBundle(resolve(temporary, "base/SKILL.md"));
+        const resultBundle = loadSkillBundle(resolve(temporary, "bundle/SKILL.md"));
+        if (baseBundle.digest !== upstreamBundle.digest)
+            throw new Error("Odai evolution base changed while creating a candidate");
+        if (resultBundle.digest === baseBundle.digest)
+            return { status: "absorbed" };
+        const identity = {
+            schemaVersion: STORE_SCHEMA_VERSION,
+            ...(options.parentGenerationId ? { parentGenerationId: options.parentGenerationId } : {}),
+            createdAt: options.now(),
+            objective: options.objective,
+            authorization: options.authorization,
+            base: {
+                source: upstreamBundle.source,
+                provider: upstreamBundle.provider,
+                skillVersion: baseBundle.manifest.skillVersion,
+                runtimeContract: baseBundle.manifest.runtimeContract,
+                digest: baseBundle.digest,
+            },
+            result: {
+                skillVersion: resultBundle.manifest.skillVersion,
+                runtimeContract: resultBundle.manifest.runtimeContract,
+                digest: resultBundle.digest,
+            },
+            patches,
+        };
+        const generationId = generationIdFor(identity);
+        const metadata = { generationId, ...identity };
+        writeDurableFile(resolve(temporary, METADATA_FILE), `${JSON.stringify(metadata, null, 2)}\n`);
+        syncDirectory(temporary);
+        const destination = safePath(root, "generations", generationId);
+        if (existsSync(destination)) {
+            const existing = validateGeneration(root, generationId);
+            return { status: "reused", generation: existing };
+        }
+        renameSync(temporary, destination);
+        syncDirectory(generationsRoot);
+        return { status: "candidate", generation: validateGeneration(root, generationId) };
+    }
+    finally {
+        rmSync(temporary, { recursive: true, force: true });
+    }
 }
-
 function appendStateChange(root, state, action, target, evidence, now) {
-  const from = state.activeGenerationId ?? null;
-  const to = target ?? null;
-  if (from === to) return state;
-  const event = {
-    revision: state.revision + 1,
-    action,
-    from,
-    to,
-    at: now(),
-    evidence,
-  };
-  const next = {
-    schemaVersion: STORE_SCHEMA_VERSION,
-    revision: event.revision,
-    ...(target ? { activeGenerationId: target } : {}),
-    history: [...state.history, event],
-  };
-  writeJsonAtomic(resolve(root, STATE_FILE), next);
-  return readSkillEvolutionState(root);
+    const from = state.activeGenerationId ?? null;
+    const to = target ?? null;
+    if (from === to)
+        return state;
+    const event = {
+        revision: state.revision + 1,
+        action,
+        from,
+        to,
+        at: now(),
+        evidence,
+    };
+    const next = {
+        schemaVersion: STORE_SCHEMA_VERSION,
+        revision: event.revision,
+        ...(target ? { activeGenerationId: target } : {}),
+        history: [...state.history, event],
+    };
+    writeJsonAtomic(resolve(root, STATE_FILE), next);
+    return readSkillEvolutionState(root);
 }
-
 function preserveConflict(root, generation, upstreamBundle, conflicts, authorization, now) {
-  const attemptId = randomUUID();
-  const conflictsRoot = ensureStoreDirectory(root, "conflicts");
-  const temporary = safePath(root, "conflicts", `.tmp-${process.pid}-${attemptId}`);
-  const destination = safePath(root, "conflicts", attemptId);
-  try {
-    for (const path of new Set(conflicts.map((conflict) => conflict.path))) {
-      const base = generation.baseSnapshot.files.get(path);
-      const ours = generation.resultSnapshot.files.get(path);
-      const theirs = upstreamBundle.manifest.requiredFiles.includes(path) ? readSkillBundleFile(upstreamBundle, path) : undefined;
-      if (base) writeDurableFile(resolve(temporary, "base", ...path.split("/")), base);
-      if (ours) writeDurableFile(resolve(temporary, "ours", ...path.split("/")), ours);
-      if (theirs) writeDurableFile(resolve(temporary, "theirs", ...path.split("/")), theirs);
-    }
-    const report = {
-      schemaVersion: STORE_SCHEMA_VERSION,
-      attemptId,
-      createdAt: now(),
-      generationId: generation.metadata.generationId,
-      oldBaseDigest: generation.metadata.base.digest,
-      upstreamDigest: upstreamBundle.digest,
-      authorization,
-      conflicts,
-    };
-    writeDurableFile(resolve(temporary, "report.json"), `${JSON.stringify(report, null, 2)}\n`);
-    syncDirectory(temporary);
-    renameSync(temporary, destination);
-    syncDirectory(conflictsRoot);
-    return Object.freeze(report);
-  } finally {
-    rmSync(temporary, { recursive: true, force: true });
-  }
+    const attemptId = randomUUID();
+    const conflictsRoot = ensureStoreDirectory(root, "conflicts");
+    const temporary = safePath(root, "conflicts", `.tmp-${process.pid}-${attemptId}`);
+    const destination = safePath(root, "conflicts", attemptId);
+    try {
+        for (const path of new Set(conflicts.map((conflict) => conflict.path))) {
+            const base = generation.baseSnapshot.files.get(path);
+            const ours = generation.resultSnapshot.files.get(path);
+            const theirs = upstreamBundle.manifest.requiredFiles.includes(path) ? readSkillBundleFile(upstreamBundle, path) : undefined;
+            if (base)
+                writeDurableFile(resolve(temporary, "base", ...path.split("/")), base);
+            if (ours)
+                writeDurableFile(resolve(temporary, "ours", ...path.split("/")), ours);
+            if (theirs)
+                writeDurableFile(resolve(temporary, "theirs", ...path.split("/")), theirs);
+        }
+        const report = {
+            schemaVersion: STORE_SCHEMA_VERSION,
+            attemptId,
+            createdAt: now(),
+            generationId: generation.metadata.generationId,
+            oldBaseDigest: generation.metadata.base.digest,
+            upstreamDigest: upstreamBundle.digest,
+            authorization,
+            conflicts,
+        };
+        writeDurableFile(resolve(temporary, "report.json"), `${JSON.stringify(report, null, 2)}\n`);
+        syncDirectory(temporary);
+        renameSync(temporary, destination);
+        syncDirectory(conflictsRoot);
+        return Object.freeze(report);
+    }
+    finally {
+        rmSync(temporary, { recursive: true, force: true });
+    }
 }
-
 function rebaseGeneration(root, generation, upstreamBundle, authorization, now) {
-  if (generation.metadata.base.digest === upstreamBundle.digest) return { status: "up-to-date", generation };
-  const upstreamSnapshot = snapshotBundle(upstreamBundle);
-  const result = cloneSnapshot(upstreamSnapshot);
-  const nextPatches = [];
-  const conflicts = [];
-
-  for (const patch of generation.metadata.patches) {
-    const upstreamContent = upstreamSnapshot.files.get(patch.path);
-    if (!upstreamContent) {
-      conflicts.push({ path: patch.path, replacement: 0, reason: "path-removed-upstream" });
-      continue;
-    }
-    let text = utf8Text(upstreamContent, patch.path);
-    const retained = [];
-    for (const [index, replacement] of patch.replacements.entries()) {
-      const oldCount = countOccurrences(text, replacement.oldString);
-      if (oldCount === 1) {
-        text = text.replace(replacement.oldString, replacement.newString);
-        retained.push(replacement);
-        continue;
-      }
-      const alreadyApplied = replacement.newString === ""
-        ? oldCount === 0
-        : oldCount === 0 && countOccurrences(text, replacement.newString) === 1;
-      if (!alreadyApplied) {
-        conflicts.push({
-          path: patch.path,
-          replacement: index,
-          reason: oldCount > 1 ? "old-context-ambiguous" : "old-context-missing",
-        });
-      }
-    }
-    if (conflicts.some((conflict) => conflict.path === patch.path)) continue;
-    const content = Buffer.from(text, "utf8");
-    result.files.set(patch.path, content);
-    if (sha256(content) !== sha256(upstreamContent)) {
-      nextPatches.push(Object.freeze({
-        path: patch.path,
-        baseSha256: sha256(upstreamContent),
-        resultSha256: sha256(content),
-        replacements: Object.freeze(retained.map((replacement) => Object.freeze({ ...replacement }))),
-      }));
-    }
-  }
-
-  if (conflicts.length > 0) {
-    return { status: "conflict", report: preserveConflict(root, generation, upstreamBundle, conflicts, authorization, now) };
-  }
-  if (nextPatches.length === 0) return { status: "absorbed" };
-  return createGeneration(root, upstreamBundle, result, Object.freeze(nextPatches), {
-    parentGenerationId: generation.metadata.generationId,
-    objective: `Rebase ${generation.metadata.generationId.slice(0, 12)}: ${generation.metadata.objective}`.slice(0, MAX_OBJECTIVE_CHARS),
-    authorization,
-    now,
-  });
+    if (generation.metadata.base.digest === upstreamBundle.digest)
+        return { status: "up-to-date", generation };
+    const upstreamSnapshot = snapshotBundle(upstreamBundle);
+    const result = cloneSnapshot(upstreamSnapshot);
+    const nextPatches = [];
+    const conflicts = [];
+    for (const patch of generation.metadata.patches) {
+        const upstreamContent = upstreamSnapshot.files.get(patch.path);
+        if (!upstreamContent) {
+            conflicts.push({ path: patch.path, replacement: 0, reason: "path-removed-upstream" });
+            continue;
+        }
+        let text = utf8Text(upstreamContent, patch.path);
+        const retained = [];
+        for (const [index, replacement] of patch.replacements.entries()) {
+            const oldCount = countOccurrences(text, replacement.oldString);
+            if (oldCount === 1) {
+                text = text.replace(replacement.oldString, replacement.newString);
+                retained.push(replacement);
+                continue;
+            }
+            const alreadyApplied = replacement.newString === ""
+                ? oldCount === 0
+                : oldCount === 0 && countOccurrences(text, replacement.newString) === 1;
+            if (!alreadyApplied) {
+                conflicts.push({
+                    path: patch.path,
+                    replacement: index,
+                    reason: oldCount > 1 ? "old-context-ambiguous" : "old-context-missing",
+                });
+            }
+        }
+        if (conflicts.some((conflict) => conflict.path === patch.path))
+            continue;
+        const content = Buffer.from(text, "utf8");
+        result.files.set(patch.path, content);
+        if (sha256(content) !== sha256(upstreamContent)) {
+            nextPatches.push(Object.freeze({
+                path: patch.path,
+                baseSha256: sha256(upstreamContent),
+                resultSha256: sha256(content),
+                replacements: Object.freeze(retained.map((replacement) => Object.freeze({ ...replacement }))),
+            }));
+        }
+    }
+    if (conflicts.length > 0) {
+        return { status: "conflict", report: preserveConflict(root, generation, upstreamBundle, conflicts, authorization, now) };
+    }
+    if (nextPatches.length === 0)
+        return { status: "absorbed" };
+    return createGeneration(root, upstreamBundle, result, Object.freeze(nextPatches), {
+        parentGenerationId: generation.metadata.generationId,
+        objective: `Rebase ${generation.metadata.generationId.slice(0, 12)}: ${generation.metadata.objective}`.slice(0, MAX_OBJECTIVE_CHARS),
+        authorization,
+        now,
+    });
 }
-
 function upstreamSelection(selection) {
-  return selection?.upstream ?? selection;
+    return selection?.upstream ?? selection;
 }
-
 function selectionSummary(selection) {
-  return Object.freeze({
-    source: selection.bundle.source,
-    skillVersion: selection.bundle.manifest.skillVersion,
-    runtimeContract: selection.bundle.manifest.runtimeContract,
-    digest: selection.bundle.digest,
-  });
-}
-
-export function applySkillEvolutionSelection(upstream, root, options = {}) {
-  if (!upstream?.bundle) throw new TypeError("an upstream Odai skill selection is required");
-  if (options.disabled === true) {
-    return Object.freeze({
-      ...upstream,
-      evolution: Object.freeze({ status: "disabled", hostOverride: true }),
-      upstream,
-    });
-  }
-  let state;
-  try {
-    state = readSkillEvolutionState(root);
-  } catch (error) {
-    return Object.freeze({
-      ...upstream,
-      status: "fallback",
-      reasonCode: "evolution-state-invalid",
-      detail: error instanceof Error ? error.message : String(error),
-      evolution: Object.freeze({ status: "fallback", reasonCode: "evolution-state-invalid" }),
-      upstream,
-    });
-  }
-  if (!state.activeGenerationId) return upstream;
-  let generation;
-  try {
-    generation = validateGeneration(root, state.activeGenerationId);
-  } catch (error) {
-    return Object.freeze({
-      ...upstream,
-      status: "fallback",
-      reasonCode: "evolution-generation-invalid",
-      detail: error instanceof Error ? error.message : String(error),
-      evolution: Object.freeze({
-        status: "fallback",
-        reasonCode: "evolution-generation-invalid",
-        generationId: state.activeGenerationId,
-      }),
-      upstream,
-    });
-  }
-  if (generation.metadata.base.source !== "bundled" || upstream.bundle.source !== "bundled") {
     return Object.freeze({
-      ...upstream,
-      status: "fallback",
-      reasonCode: "evolution-scope-mismatch",
-      detail: `active evolution is based on ${generation.metadata.base.source}, current upstream is ${upstream.bundle.source}`,
-      evolution: Object.freeze({
-        status: "fallback",
-        reasonCode: "evolution-scope-mismatch",
-        generationId: state.activeGenerationId,
-      }),
-      upstream,
+        source: selection.bundle.source,
+        skillVersion: selection.bundle.manifest.skillVersion,
+        runtimeContract: selection.bundle.manifest.runtimeContract,
+        digest: selection.bundle.digest,
     });
-  }
-  if (generation.resultBundle.manifest.runtimeContract !== ODAI_RUNTIME_CONTRACT) {
+}
+export function applySkillEvolutionSelection(upstream, root, options = {}) {
+    if (!upstream?.bundle)
+        throw new TypeError("an upstream Odai skill selection is required");
+    if (options.disabled === true) {
+        return Object.freeze({
+            ...upstream,
+            evolution: Object.freeze({ status: "disabled", hostOverride: true }),
+            upstream,
+        });
+    }
+    let state;
+    try {
+        state = readSkillEvolutionState(root);
+    }
+    catch (error) {
+        return Object.freeze({
+            ...upstream,
+            status: "fallback",
+            reasonCode: "evolution-state-invalid",
+            detail: error instanceof Error ? error.message : String(error),
+            evolution: Object.freeze({ status: "fallback", reasonCode: "evolution-state-invalid" }),
+            upstream,
+        });
+    }
+    if (!state.activeGenerationId)
+        return upstream;
+    let generation;
+    try {
+        generation = validateGeneration(root, state.activeGenerationId);
+    }
+    catch (error) {
+        return Object.freeze({
+            ...upstream,
+            status: "fallback",
+            reasonCode: "evolution-generation-invalid",
+            detail: error instanceof Error ? error.message : String(error),
+            evolution: Object.freeze({
+                status: "fallback",
+                reasonCode: "evolution-generation-invalid",
+                generationId: state.activeGenerationId,
+            }),
+            upstream,
+        });
+    }
+    if (generation.metadata.base.source !== "bundled" || upstream.bundle.source !== "bundled") {
+        return Object.freeze({
+            ...upstream,
+            status: "fallback",
+            reasonCode: "evolution-scope-mismatch",
+            detail: `active evolution is based on ${generation.metadata.base.source}, current upstream is ${upstream.bundle.source}`,
+            evolution: Object.freeze({
+                status: "fallback",
+                reasonCode: "evolution-scope-mismatch",
+                generationId: state.activeGenerationId,
+            }),
+            upstream,
+        });
+    }
+    if (generation.resultBundle.manifest.runtimeContract !== ODAI_RUNTIME_CONTRACT) {
+        return Object.freeze({
+            ...upstream,
+            status: "fallback",
+            reasonCode: "evolution-runtime-contract-mismatch",
+            detail: `active evolution runtimeContract ${generation.resultBundle.manifest.runtimeContract} is incompatible with ${ODAI_RUNTIME_CONTRACT}`,
+            evolution: Object.freeze({
+                status: "fallback",
+                reasonCode: "evolution-runtime-contract-mismatch",
+                generationId: state.activeGenerationId,
+            }),
+            upstream,
+        });
+    }
+    const rebaseRequired = generation.metadata.base.digest !== upstream.bundle.digest;
     return Object.freeze({
-      ...upstream,
-      status: "fallback",
-      reasonCode: "evolution-runtime-contract-mismatch",
-      detail: `active evolution runtimeContract ${generation.resultBundle.manifest.runtimeContract} is incompatible with ${ODAI_RUNTIME_CONTRACT}`,
-      evolution: Object.freeze({
-        status: "fallback",
-        reasonCode: "evolution-runtime-contract-mismatch",
-        generationId: state.activeGenerationId,
-      }),
-      upstream,
+        ...upstream,
+        status: "selected",
+        reasonCode: "evolution-active",
+        bundle: generation.resultBundle,
+        evolution: Object.freeze({
+            status: "active",
+            generationId: state.activeGenerationId,
+            baseDigest: generation.metadata.base.digest,
+            upstreamDigest: upstream.bundle.digest,
+            rebaseRequired,
+        }),
+        upstream,
     });
-  }
-  const rebaseRequired = generation.metadata.base.digest !== upstream.bundle.digest;
-  return Object.freeze({
-    ...upstream,
-    status: "selected",
-    reasonCode: "evolution-active",
-    bundle: generation.resultBundle,
-    evolution: Object.freeze({
-      status: "active",
-      generationId: state.activeGenerationId,
-      baseDigest: generation.metadata.base.digest,
-      upstreamDigest: upstream.bundle.digest,
-      rebaseRequired,
-    }),
-    upstream,
-  });
 }
-
 function requireController(execution) {
-  if (!execution.agent) throw new Error("odai_skill_evolution requires an owning agent session");
-  const header = execution.agent.session?.header;
-  if (header?.origin === "subagent" || (Number.isSafeInteger(header?.delegationDepth) && header.delegationDepth > 0)) {
-    throw new Error("child agents may not inspect or change Odai skill evolution");
-  }
+    if (!execution.agent)
+        throw new Error("odai_skill_evolution requires an owning agent session");
+    const header = execution.agent.session?.header;
+    const delegationDepth = header?.delegationDepth;
+    if (header?.origin === "subagent" || (typeof delegationDepth === "number" && Number.isSafeInteger(delegationDepth) && delegationDepth > 0)) {
+        throw new Error("child agents may not inspect or change Odai skill evolution");
+    }
 }
-
 function requireHumanAuthorization(agent, phrase, action) {
-  const events = agent?.session?.events;
-  if (!Array.isArray(events)) throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
-  let boundaryIndex = -1;
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    if (events[index]?.type === "turn/start" || events[index]?.type === "turn/end") {
-      boundaryIndex = index;
-      break;
-    }
-  }
-  const boundary = events[boundaryIndex];
-  if (boundary?.type !== "turn/start" || !Number.isSafeInteger(boundary.data?.turn) || boundary.data.turn < 0) {
-    throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
-  }
-  let event;
-  for (let index = events.length - 1; index > boundaryIndex; index -= 1) {
-    const candidate = events[index];
-    if (candidate?.type === "user/message"
-      && candidate.data?.role === "user"
-      && candidate.data?.source?.kind === "user") {
-      event = candidate;
-      break;
-    }
-  }
-  const message = event?.data;
-  const block = Array.isArray(message?.content) && message.content.length === 1 ? message.content[0] : undefined;
-  if (!event
-    || !Number.isSafeInteger(event.seq)
-    || event.seq < 0
-    || typeof message.id !== "string"
-    || message.id.length === 0
-    || message.id.length > 200
-    || block?.type !== "text"
-    || typeof block.text !== "string"
-    || block.text !== phrase) {
-    throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
-  }
-  return Object.freeze({
-    action,
-    phrase,
-    turn: boundary.data.turn,
-    eventSeq: event.seq,
-    messageId: message.id,
-  });
+    const events = agent?.session?.events;
+    if (!Array.isArray(events))
+        throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
+    let boundaryIndex = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index]?.type === "turn/start" || events[index]?.type === "turn/end") {
+            boundaryIndex = index;
+            break;
+        }
+    }
+    const boundary = events[boundaryIndex];
+    const boundaryTurn = boundary?.data?.turn;
+    if (boundary?.type !== "turn/start" || typeof boundaryTurn !== "number" || !Number.isSafeInteger(boundaryTurn) || boundaryTurn < 0) {
+        throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
+    }
+    let event;
+    for (let index = events.length - 1; index > boundaryIndex; index -= 1) {
+        const candidate = events[index];
+        if (candidate?.type === "user/message"
+            && candidate.data?.role === "user"
+            && isUnknownRecord(candidate.data?.source)
+            && candidate.data.source.kind === "user") {
+            event = candidate;
+            break;
+        }
+    }
+    const message = event?.data;
+    const block = Array.isArray(message?.content) && message.content.length === 1 ? message.content[0] : undefined;
+    const eventSeq = event?.seq;
+    if (!event
+        || typeof eventSeq !== "number"
+        || !Number.isSafeInteger(eventSeq)
+        || eventSeq < 0
+        || !message
+        || typeof message.id !== "string"
+        || message.id.length === 0
+        || message.id.length > 200
+        || block?.type !== "text"
+        || typeof block.text !== "string"
+        || block.text !== phrase) {
+        throw new Error(`current open turn must contain exactly this direct human message: ${phrase}`);
+    }
+    return Object.freeze({
+        action,
+        phrase,
+        turn: boundaryTurn,
+        eventSeq,
+        messageId: message.id,
+    });
 }
-
 function authorizationEvidence(authorization) {
-  return Object.freeze([
-    `direct-human-action:${authorization.action}`,
-    `direct-human-turn:${authorization.turn}`,
-    `direct-human-event-seq:${authorization.eventSeq}`,
-    `direct-human-message-id:${authorization.messageId}`,
-    `direct-human-phrase:${authorization.phrase}`,
-  ]);
+    return Object.freeze([
+        `direct-human-action:${authorization.action}`,
+        `direct-human-turn:${authorization.turn}`,
+        `direct-human-event-seq:${authorization.eventSeq}`,
+        `direct-human-message-id:${authorization.messageId}`,
+        `direct-human-phrase:${authorization.phrase}`,
+    ]);
 }
-
 function actionAuthorizationPhrase(action, current, target) {
-  if (action === "rebase") return `REBASE ODAI EVOLUTION ${target}`;
-  if (action === "rollback") return `ROLLBACK ODAI EVOLUTION ${current} TO ${target ?? "BUNDLED"}`;
-  if (action === "deactivate") return `DEACTIVATE ODAI EVOLUTION ${current}`;
-  throw new TypeError(`unsupported Odai evolution authorization action: ${action}`);
+    if (action === "rebase")
+        return `REBASE ODAI EVOLUTION ${target}`;
+    if (action === "rollback")
+        return `ROLLBACK ODAI EVOLUTION ${current} TO ${target ?? "BUNDLED"}`;
+    if (action === "deactivate")
+        return `DEACTIVATE ODAI EVOLUTION ${current}`;
+    throw new TypeError(`unsupported Odai evolution authorization action: ${action}`);
 }
-
 function proposalAuthorization(objective, expectedBundleDigest, changes) {
-  const proposalDigest = sha256(Buffer.from(JSON.stringify({
-    objective,
-    expectedBundleDigest,
-    changes: changes.map((change) => ({
-      path: change.path,
-      expectedSha256: change.expectedSha256,
-      replacements: change.replacements.map((replacement) => ({
-        oldString: replacement.oldString,
-        newString: replacement.newString,
-      })),
-    })),
-  }), "utf8"));
-  return Object.freeze({
-    proposalDigest,
-    proposalPhrase: `PROPOSE ODAI EVOLUTION ${proposalDigest}`,
-  });
+    const proposalDigest = sha256(Buffer.from(JSON.stringify({
+        objective,
+        expectedBundleDigest,
+        changes: changes.map((change) => ({
+            path: change.path,
+            expectedSha256: change.expectedSha256,
+            replacements: change.replacements.map((replacement) => ({
+                oldString: replacement.oldString,
+                newString: replacement.newString,
+            })),
+        })),
+    }), "utf8"));
+    return Object.freeze({
+        proposalDigest,
+        proposalPhrase: `PROPOSE ODAI EVOLUTION ${proposalDigest}`,
+    });
 }
-
 function assertActionArguments(args, action, allowed) {
-  if (!args || typeof args !== "object" || Array.isArray(args)) throw new TypeError("arguments must be an object");
-  if (args.action !== action) throw new TypeError(`action must be ${action}`);
-  assertExactFields(args, ["action", ...allowed], `${action} arguments`);
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        throw new TypeError("arguments must be an object");
+    if (args.action !== action)
+        throw new TypeError(`action must be ${action}`);
+    assertExactFields(args, ["action", ...allowed], `${action} arguments`);
 }
-
 function activeSummary(root, state, currentUpstream) {
-  if (!state.activeGenerationId) return undefined;
-  const generation = validateGeneration(root, state.activeGenerationId);
-  return Object.freeze({
-    ...generationSummary(generation),
-    rebaseRequired: generation.metadata.base.digest !== currentUpstream.bundle.digest,
-  });
+    if (!state.activeGenerationId)
+        return undefined;
+    const generation = validateGeneration(root, state.activeGenerationId);
+    return Object.freeze({
+        ...generationSummary(generation),
+        rebaseRequired: generation.metadata.base.digest !== currentUpstream.bundle.digest,
+    });
 }
-
 function renderEvolutionResult(value) {
-  if (value.action === "show") {
-    if (value.status === "inactive") return "No Odai user evolution is active.";
-    if (value.status === "disabled") return "Odai user evolution is bypassed by ODAI_DISABLE_EVOLUTION=1.";
-    if (value.status === "fallback") return `Odai user evolution is unavailable: ${value.error}`;
-    return `Active Odai evolution ${value.active.generationId}; rebaseRequired=${String(value.active.rebaseRequired)}.`;
-  }
-  if (value.action === "inspect") return `Inspected ${value.path} from bundle ${value.bundleDigest}.`;
-  if (value.action === "propose" && value.status === "authorization-required") {
-    return `No candidate was written. To authorize this exact proposal, the current direct human message must be exactly: ${value.proposalPhrase}`;
-  }
-  if (["propose", "rebase"].includes(value.action) && ["candidate", "reused"].includes(value.status)) {
-    return `Created inactive Odai evolution candidate ${value.generation.generationId}. Explicit activation is still required.`;
-  }
-  if (value.status === "conflict") return `Odai evolution rebase conflict ${value.attemptId}; the active generation was not changed.`;
-  if (value.status === "absorbed") return "The proposed evolution is already represented by the upstream bundle; no generation was created.";
-  if (value.status === "up-to-date") return "The evolution generation already uses the current upstream digest.";
-  if (value.action === "validate") {
-    const reasons = value.generation.breakingReasons.length > 0
-      ? ` Breaking reasons: ${value.generation.breakingReasons.join(", ")}.`
-      : "";
-    return `Validated Odai evolution generation ${value.generation.generationId} (${value.generation.authorizationLevel}).${reasons} To authorize activation, the latest direct human message must be exactly: ${value.generation.activationPhrase}`;
-  }
-  if (["activate", "rollback"].includes(value.action)) return `Odai evolution ${value.activeGenerationId ?? "bundled upstream"} will become active from the next user turn.`;
-  if (value.action === "deactivate") return "Odai user evolution is deactivated from the next user turn.";
-  return `Odai evolution ${value.action}: ${value.status}.`;
+    if (value.action === "show") {
+        if (value.status === "inactive")
+            return "No Odai user evolution is active.";
+        if (value.status === "disabled")
+            return "Odai user evolution is bypassed by ODAI_DISABLE_EVOLUTION=1.";
+        if (value.status === "fallback")
+            return `Odai user evolution is unavailable: ${value.error}`;
+        return value.active
+            ? `Active Odai evolution ${value.active.generationId}; rebaseRequired=${String(value.active.rebaseRequired)}.`
+            : "No Odai user evolution is active.";
+    }
+    if (value.action === "inspect")
+        return `Inspected ${value.path} from bundle ${value.bundleDigest}.`;
+    if (value.action === "propose" && value.status === "authorization-required") {
+        return `No candidate was written. To authorize this exact proposal, the current direct human message must be exactly: ${value.proposalPhrase}`;
+    }
+    if (["propose", "rebase"].includes(value.action) && ["candidate", "reused"].includes(value.status)) {
+        return value.generation
+            ? `Created inactive Odai evolution candidate ${value.generation.generationId}. Explicit activation is still required.`
+            : "Created an inactive Odai evolution candidate. Explicit activation is still required.";
+    }
+    if (value.status === "conflict")
+        return `Odai evolution rebase conflict ${value.attemptId}; the active generation was not changed.`;
+    if (value.status === "absorbed")
+        return "The proposed evolution is already represented by the upstream bundle; no generation was created.";
+    if (value.status === "up-to-date")
+        return "The evolution generation already uses the current upstream digest.";
+    if (value.action === "validate") {
+        if (!value.generation)
+            return "Odai evolution validation returned no generation.";
+        const reasons = value.generation.breakingReasons.length > 0
+            ? ` Breaking reasons: ${value.generation.breakingReasons.join(", ")}.`
+            : "";
+        return `Validated Odai evolution generation ${value.generation.generationId} (${value.generation.authorizationLevel}).${reasons} To authorize activation, the latest direct human message must be exactly: ${value.generation.activationPhrase}`;
+    }
+    if (["activate", "rollback"].includes(value.action))
+        return `Odai evolution ${value.activeGenerationId ?? "bundled upstream"} will become active from the next user turn.`;
+    if (value.action === "deactivate")
+        return "Odai user evolution is deactivated from the next user turn.";
+    return `Odai evolution ${value.action}: ${value.status}.`;
 }
-
 export function createSkillEvolutionTool(root, options = {}) {
-  const currentSelectionFor = typeof options.currentSelectionFor === "function" ? options.currentSelectionFor : () => options.selection;
-  const onChanged = typeof options.onChanged === "function" ? options.onChanged : () => {};
-  const now = typeof options.now === "function" ? options.now : () => new Date().toISOString();
-  const disabled = options.disabled === true;
-
-  const current = (agent) => {
-    const selection = currentSelectionFor(agent);
-    if (!selection?.bundle) throw new Error("current Odai skill selection is unavailable");
-    return selection;
-  };
-  const currentUpstream = (agent) => upstreamSelection(current(agent));
-  const requireEnabled = () => {
-    if (disabled) throw new Error("Odai skill evolution is disabled by ODAI_DISABLE_EVOLUTION=1");
-  };
-
-  return {
-    name: "odai_skill_evolution",
-    description: [
-      "Inspect and manage immutable user evolution generations for Odai governance Markdown only when the user asks.",
-      "Every write action requires an action- and content-bound phrase as the only block in the current open turn's latest genuine user message; model text and model-supplied evidence never authorize mutation.",
-      "Propose and rebase create inactive candidates. Any SKILL.md or references/dao.md change, or a replacement that removes its old text, requires the distinct ACTIVATE BREAKING phrase. Active-pointer changes start next turn.",
-      "Never change manifests, scripts, runtime code, or installed package files.",
-    ].join(" "),
-    parameters: {
-      type: "object",
-      additionalProperties: false,
-      required: ["action"],
-      properties: {
-        action: { type: "string", enum: ["show", "inspect", "propose", "validate", "activate", "rebase", "rollback", "deactivate"] },
-        path: { type: "string" },
-        generationId: { type: "string" },
-        objective: { type: "string" },
-        expectedBundleDigest: { type: "string" },
-        expectedUpstreamDigest: { type: "string" },
-        changes: {
-          type: "array",
-          items: {
+    const currentSelectionFor = typeof options.currentSelectionFor === "function"
+        ? options.currentSelectionFor
+        : () => options.selection;
+    const onChanged = typeof options.onChanged === "function" ? options.onChanged : () => { };
+    const now = typeof options.now === "function" ? options.now : () => new Date().toISOString();
+    const disabled = options.disabled === true;
+    const current = (agent) => {
+        const selection = currentSelectionFor(agent);
+        if (!selection?.bundle)
+            throw new Error("current Odai skill selection is unavailable");
+        return selection;
+    };
+    const requireEnabled = () => {
+        if (disabled)
+            throw new Error("Odai skill evolution is disabled by ODAI_DISABLE_EVOLUTION=1");
+    };
+    return {
+        name: "odai_skill_evolution",
+        description: [
+            "Inspect and manage immutable user evolution generations for Odai governance Markdown only when the user asks.",
+            "Every write action requires an action- and content-bound phrase as the only block in the current open turn's latest genuine user message; model text and model-supplied evidence never authorize mutation.",
+            "Propose and rebase create inactive candidates. Any SKILL.md or references/dao.md change, or a replacement that removes its old text, requires the distinct ACTIVATE BREAKING phrase. Active-pointer changes start next turn.",
+            "Never change manifests, scripts, runtime code, or installed package files.",
+        ].join(" "),
+        parameters: {
             type: "object",
             additionalProperties: false,
-            required: ["path", "expectedSha256", "replacements"],
+            required: ["action"],
             properties: {
-              path: { type: "string" },
-              expectedSha256: { type: "string" },
-              replacements: {
-                type: "array",
-                items: {
-                  type: "object",
-                  additionalProperties: false,
-                  required: ["oldString", "newString"],
-                  properties: { oldString: { type: "string" }, newString: { type: "string" } },
+                action: { type: "string", enum: ["show", "inspect", "propose", "validate", "activate", "rebase", "rollback", "deactivate"] },
+                path: { type: "string" },
+                generationId: { type: "string" },
+                objective: { type: "string" },
+                expectedBundleDigest: { type: "string" },
+                expectedUpstreamDigest: { type: "string" },
+                changes: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["path", "expectedSha256", "replacements"],
+                        properties: {
+                            path: { type: "string" },
+                            expectedSha256: { type: "string" },
+                            replacements: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    required: ["oldString", "newString"],
+                                    properties: { oldString: { type: "string" }, newString: { type: "string" } },
+                                },
+                            },
+                        },
+                    },
                 },
-              },
             },
-          },
         },
-      },
-    },
-    output: {
-      schema: {
-        type: "object",
-        additionalProperties: true,
-        required: ["action", "status"],
-        properties: { action: { type: "string" }, status: { type: "string" } },
-      },
-      render(_args, value) {
-        return [{ type: "text", text: renderEvolutionResult(value) }];
-      },
-    },
-    execute(args, execution) {
-      requireController(execution);
-      if (!args || typeof args !== "object" || Array.isArray(args)) throw new TypeError("arguments must be an object");
-      const selection = current(execution.agent);
-      const upstream = upstreamSelection(selection);
-
-      if (args.action === "show") {
-        assertActionArguments(args, "show", []);
-        if (disabled) return Promise.resolve(Object.freeze({ action: "show", status: "disabled", root, upstream: selectionSummary(upstream) }));
-        let state;
-        try {
-          state = readSkillEvolutionState(root);
-          const listed = listGenerations(root);
-          const active = activeSummary(root, state, upstream);
-          return Promise.resolve(Object.freeze({
-            action: "show",
-            status: active ? "active" : "inactive",
-            root,
-            upstream: selectionSummary(upstream),
-            ...(active ? { active } : {}),
-            generations: listed.generations,
-            diagnostics: listed.diagnostics,
-          }));
-        } catch (error) {
-          return Promise.resolve(Object.freeze({
-            action: "show",
-            status: "fallback",
-            root,
-            upstream: selectionSummary(upstream),
-            error: error instanceof Error ? error.message : String(error),
-          }));
-        }
-      }
-
-      if (args.action === "inspect") {
-        assertActionArguments(args, "inspect", ["path", "generationId"]);
-        const bundle = args.generationId === undefined
-          ? selection.bundle
-          : validateGeneration(root, safeGenerationId(args.generationId)).resultBundle;
-        const path = assertEvolvablePath(args.path, bundle.manifest);
-        const content = readSkillBundleFile(bundle, path);
-        return Promise.resolve(Object.freeze({
-          action: "inspect",
-          status: "inspected",
-          path,
-          source: args.generationId ? "generation" : "effective",
-          bundleDigest: bundle.digest,
-          upstreamDigest: upstream.bundle.digest,
-          sha256: sha256(content),
-          content: utf8Text(content, path),
-          rebaseRequired: selection.evolution?.rebaseRequired === true,
-        }));
-      }
-
-      requireEnabled();
-      if (args.action === "propose") {
-        assertActionArguments(args, "propose", ["objective", "expectedBundleDigest", "changes"]);
-        if (upstream.bundle.source !== "bundled") throw new Error("Odai evolution proposals require the bundled upstream source");
-        if (selection.evolution?.rebaseRequired === true) throw new Error("active Odai evolution requires rebase before another proposal");
-        const expectedBundleDigest = exactDigest(args.expectedBundleDigest, "expectedBundleDigest");
-        if (expectedBundleDigest !== selection.bundle.digest) throw new Error("expectedBundleDigest does not match the current immutable turn snapshot");
-        const objective = nonEmptyString(args.objective, "objective", MAX_OBJECTIVE_CHARS);
-        const changes = normalizeProposedChanges(args.changes, selection.bundle.manifest);
-        const proposal = proposalAuthorization(objective, expectedBundleDigest, changes);
-        let humanAuthorization;
-        try {
-          humanAuthorization = requireHumanAuthorization(execution.agent, proposal.proposalPhrase, "propose");
-        } catch {
-          return Promise.resolve(Object.freeze({
-            action: "propose",
-            status: "authorization-required",
-            proposalDigest: proposal.proposalDigest,
-            proposalPhrase: proposal.proposalPhrase,
-          }));
-        }
-        const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
-        try {
-          const state = readSkillEvolutionState(root);
-          if ((state.activeGenerationId ?? undefined) !== (selection.evolution?.generationId ?? undefined)) {
-            throw new Error("Odai evolution active pointer changed; retry from a new user turn");
-          }
-          const parent = state.activeGenerationId ? validateGeneration(root, state.activeGenerationId) : undefined;
-          const upstreamSnapshot = snapshotBundle(upstream.bundle);
-          const effectiveSnapshot = snapshotBundle(selection.bundle);
-          const merged = mergePatchGroups(parent?.metadata.patches ?? [], changes, upstreamSnapshot, effectiveSnapshot);
-          if (merged.status === "absorbed") return Promise.resolve(Object.freeze({ action: "propose", status: "absorbed" }));
-          const created = createGeneration(root, upstream.bundle, merged.snapshot, merged.patches, {
-            ...(parent ? { parentGenerationId: parent.metadata.generationId } : {}),
-            objective,
-            authorization: humanAuthorization,
-            now,
-          });
-          const result = Object.freeze({
-            action: "propose",
-            status: created.status,
-            generation: generationSummary(created.generation),
-            activeGenerationId: state.activeGenerationId,
-          });
-          onChanged(execution.agent, result);
-          return Promise.resolve(result);
-        } finally {
-          release();
-        }
-      }
-
-      if (args.action === "validate") {
-        assertActionArguments(args, "validate", ["generationId"]);
-        const generation = validateGeneration(root, safeGenerationId(args.generationId));
-        return Promise.resolve(Object.freeze({ action: "validate", status: "valid", generation: generationSummary(generation) }));
-      }
-
-      if (args.action === "activate") {
-        assertActionArguments(args, "activate", ["generationId", "expectedUpstreamDigest"]);
-        const generationId = safeGenerationId(args.generationId);
-        const expectedUpstreamDigest = exactDigest(args.expectedUpstreamDigest, "expectedUpstreamDigest");
-        if (upstream.bundle.source !== "bundled" || upstream.bundle.digest !== expectedUpstreamDigest) {
-          throw new Error("current bundled upstream does not match expectedUpstreamDigest");
-        }
-        const generation = validateGeneration(root, generationId);
-        if (generation.metadata.base.digest !== upstream.bundle.digest) throw new Error("candidate must be rebased onto the current bundled upstream before activation");
-        const expectedState = readSkillEvolutionState(root);
-        if (expectedState.activeGenerationId === generationId) {
-          return Promise.resolve(Object.freeze({ action: "activate", status: "already-active", activeGenerationId: generationId, requiresNextTurn: false }));
-        }
-        const authorization = requireHumanAuthorization(
-          execution.agent,
-          activationPhrase(generationId, generation.authorization.level),
-          "activate",
-        );
-        const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
-        try {
-          validateGeneration(root, generationId);
-          const state = readSkillEvolutionState(root);
-          if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
-            throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
-          }
-          const next = appendStateChange(root, state, "activate", generationId, authorizationEvidence(authorization), now);
-          const result = Object.freeze({ action: "activate", status: "active", activeGenerationId: next.activeGenerationId, requiresNextTurn: true });
-          onChanged(execution.agent, result);
-          return Promise.resolve(result);
-        } finally {
-          release();
-        }
-      }
-
-      if (args.action === "rebase") {
-        assertActionArguments(args, "rebase", ["generationId", "expectedUpstreamDigest"]);
-        const generationId = safeGenerationId(args.generationId);
-        const expectedUpstreamDigest = exactDigest(args.expectedUpstreamDigest, "expectedUpstreamDigest");
-        if (upstream.bundle.source !== "bundled" || upstream.bundle.digest !== expectedUpstreamDigest) {
-          throw new Error("current bundled upstream does not match expectedUpstreamDigest");
-        }
-        const generation = validateGeneration(root, generationId);
-        const authorization = requireHumanAuthorization(
-          execution.agent,
-          actionAuthorizationPhrase("rebase", undefined, generationId),
-          "rebase",
-        );
-        const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
-        try {
-          const lockedGeneration = validateGeneration(root, generationId);
-          const rebased = rebaseGeneration(root, lockedGeneration, upstream.bundle, authorization, now);
-          let result;
-          if (["candidate", "reused"].includes(rebased.status)) {
-            result = Object.freeze({ action: "rebase", status: rebased.status, generation: generationSummary(rebased.generation), activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
-          } else if (rebased.status === "conflict") {
-            result = Object.freeze({ action: "rebase", status: "conflict", attemptId: rebased.report.attemptId, conflicts: Object.freeze(rebased.report.conflicts), activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
-          } else {
-            result = Object.freeze({ action: "rebase", status: rebased.status, activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
-          }
-          onChanged(execution.agent, result);
-          return Promise.resolve(result);
-        } finally {
-          release();
-        }
-      }
-
-      if (args.action === "rollback") {
-        assertActionArguments(args, "rollback", ["generationId"]);
-        const expectedState = readSkillEvolutionState(root);
-        if (!expectedState.activeGenerationId) return Promise.resolve(Object.freeze({ action: "rollback", status: "inactive", requiresNextTurn: false }));
-        let target = args.generationId === undefined ? undefined : safeGenerationId(args.generationId);
-        if (target === undefined) {
-          const previous = [...expectedState.history].reverse().find((event) => event.to === expectedState.activeGenerationId && event.from !== event.to);
-          target = previous?.from ?? undefined;
-        }
-        if (target === expectedState.activeGenerationId) {
-          return Promise.resolve(Object.freeze({ action: "rollback", status: "already-active", activeGenerationId: target, requiresNextTurn: false }));
-        }
-        if (target && !expectedState.history.some((event) => event.to === target)) {
-          throw new Error(`rollback target ${target} was never an active Odai evolution generation`);
-        }
-        if (target) {
-          const generation = validateGeneration(root, target);
-          if (generation.resultBundle.manifest.runtimeContract !== ODAI_RUNTIME_CONTRACT) {
-            throw new Error(`rollback target ${target} is incompatible with runtime contract ${ODAI_RUNTIME_CONTRACT}`);
-          }
-        }
-        const authorization = requireHumanAuthorization(
-          execution.agent,
-          actionAuthorizationPhrase("rollback", expectedState.activeGenerationId, target),
-          "rollback",
-        );
-        const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
-        try {
-          const state = readSkillEvolutionState(root);
-          if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
-            throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
-          }
-          const next = appendStateChange(root, state, "rollback", target, authorizationEvidence(authorization), now);
-          const result = Object.freeze({ action: "rollback", status: target ? "active" : "inactive", activeGenerationId: next.activeGenerationId, requiresNextTurn: true });
-          onChanged(execution.agent, result);
-          return Promise.resolve(result);
-        } finally {
-          release();
-        }
-      }
-
-      if (args.action === "deactivate") {
-        assertActionArguments(args, "deactivate", []);
-        const expectedState = readSkillEvolutionState(root);
-        if (!expectedState.activeGenerationId) return Promise.resolve(Object.freeze({ action: "deactivate", status: "inactive", requiresNextTurn: false }));
-        const authorization = requireHumanAuthorization(
-          execution.agent,
-          actionAuthorizationPhrase("deactivate", expectedState.activeGenerationId),
-          "deactivate",
-        );
-        const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
-        try {
-          const state = readSkillEvolutionState(root);
-          if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
-            throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
-          }
-          appendStateChange(root, state, "deactivate", undefined, authorizationEvidence(authorization), now);
-          const result = Object.freeze({ action: "deactivate", status: "inactive", requiresNextTurn: true });
-          onChanged(execution.agent, result);
-          return Promise.resolve(result);
-        } finally {
-          release();
-        }
-      }
-
-      throw new TypeError("action must be show, inspect, propose, validate, activate, rebase, rollback, or deactivate");
-    },
-  };
+        output: {
+            schema: {
+                type: "object",
+                additionalProperties: true,
+                required: ["action", "status"],
+                properties: { action: { type: "string" }, status: { type: "string" } },
+            },
+            render(_args, value) {
+                return [{ type: "text", text: renderEvolutionResult(value) }];
+            },
+        },
+        execute(args, execution) {
+            requireController(execution);
+            if (!args || typeof args !== "object" || Array.isArray(args))
+                throw new TypeError("arguments must be an object");
+            const selection = current(execution.agent);
+            const upstream = upstreamSelection(selection);
+            if (args.action === "show") {
+                assertActionArguments(args, "show", []);
+                if (disabled)
+                    return Promise.resolve(Object.freeze({ action: "show", status: "disabled", root, upstream: selectionSummary(upstream) }));
+                let state;
+                try {
+                    state = readSkillEvolutionState(root);
+                    const listed = listGenerations(root);
+                    const active = activeSummary(root, state, upstream);
+                    return Promise.resolve(Object.freeze({
+                        action: "show",
+                        status: active ? "active" : "inactive",
+                        root,
+                        upstream: selectionSummary(upstream),
+                        ...(active ? { active } : {}),
+                        generations: listed.generations,
+                        diagnostics: listed.diagnostics,
+                    }));
+                }
+                catch (error) {
+                    return Promise.resolve(Object.freeze({
+                        action: "show",
+                        status: "fallback",
+                        root,
+                        upstream: selectionSummary(upstream),
+                        error: error instanceof Error ? error.message : String(error),
+                    }));
+                }
+            }
+            if (args.action === "inspect") {
+                assertActionArguments(args, "inspect", ["path", "generationId"]);
+                const bundle = args.generationId === undefined
+                    ? selection.bundle
+                    : validateGeneration(root, safeGenerationId(args.generationId)).resultBundle;
+                const path = assertEvolvablePath(args.path, bundle.manifest);
+                const content = readSkillBundleFile(bundle, path);
+                return Promise.resolve(Object.freeze({
+                    action: "inspect",
+                    status: "inspected",
+                    path,
+                    source: args.generationId ? "generation" : "effective",
+                    bundleDigest: bundle.digest,
+                    upstreamDigest: upstream.bundle.digest,
+                    sha256: sha256(content),
+                    content: utf8Text(content, path),
+                    rebaseRequired: selection.evolution?.rebaseRequired === true,
+                }));
+            }
+            requireEnabled();
+            if (args.action === "propose") {
+                assertActionArguments(args, "propose", ["objective", "expectedBundleDigest", "changes"]);
+                if (upstream.bundle.source !== "bundled")
+                    throw new Error("Odai evolution proposals require the bundled upstream source");
+                if (selection.evolution?.rebaseRequired === true)
+                    throw new Error("active Odai evolution requires rebase before another proposal");
+                const expectedBundleDigest = exactDigest(args.expectedBundleDigest, "expectedBundleDigest");
+                if (expectedBundleDigest !== selection.bundle.digest)
+                    throw new Error("expectedBundleDigest does not match the current immutable turn snapshot");
+                const objective = nonEmptyString(args.objective, "objective", MAX_OBJECTIVE_CHARS);
+                const changes = normalizeProposedChanges(args.changes, selection.bundle.manifest);
+                const proposal = proposalAuthorization(objective, expectedBundleDigest, changes);
+                let humanAuthorization;
+                try {
+                    humanAuthorization = requireHumanAuthorization(execution.agent, proposal.proposalPhrase, "propose");
+                }
+                catch {
+                    return Promise.resolve(Object.freeze({
+                        action: "propose",
+                        status: "authorization-required",
+                        proposalDigest: proposal.proposalDigest,
+                        proposalPhrase: proposal.proposalPhrase,
+                    }));
+                }
+                const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
+                try {
+                    const state = readSkillEvolutionState(root);
+                    if ((state.activeGenerationId ?? undefined) !== (selection.evolution?.generationId ?? undefined)) {
+                        throw new Error("Odai evolution active pointer changed; retry from a new user turn");
+                    }
+                    const parent = state.activeGenerationId ? validateGeneration(root, state.activeGenerationId) : undefined;
+                    const upstreamSnapshot = snapshotBundle(upstream.bundle);
+                    const effectiveSnapshot = snapshotBundle(selection.bundle);
+                    const merged = mergePatchGroups(parent?.metadata.patches ?? [], changes, upstreamSnapshot, effectiveSnapshot);
+                    if (merged.status === "absorbed")
+                        return Promise.resolve(Object.freeze({ action: "propose", status: "absorbed" }));
+                    const created = createGeneration(root, upstream.bundle, merged.snapshot, merged.patches, {
+                        ...(parent ? { parentGenerationId: parent.metadata.generationId } : {}),
+                        objective,
+                        authorization: humanAuthorization,
+                        now,
+                    });
+                    if (created.status === "absorbed") {
+                        return Promise.resolve(Object.freeze({ action: "propose", status: "absorbed" }));
+                    }
+                    const result = Object.freeze({
+                        action: "propose",
+                        status: created.status,
+                        generation: generationSummary(created.generation),
+                        activeGenerationId: state.activeGenerationId,
+                    });
+                    onChanged(execution.agent, result);
+                    return Promise.resolve(result);
+                }
+                finally {
+                    release();
+                }
+            }
+            if (args.action === "validate") {
+                assertActionArguments(args, "validate", ["generationId"]);
+                const generation = validateGeneration(root, safeGenerationId(args.generationId));
+                return Promise.resolve(Object.freeze({ action: "validate", status: "valid", generation: generationSummary(generation) }));
+            }
+            if (args.action === "activate") {
+                assertActionArguments(args, "activate", ["generationId", "expectedUpstreamDigest"]);
+                const generationId = safeGenerationId(args.generationId);
+                const expectedUpstreamDigest = exactDigest(args.expectedUpstreamDigest, "expectedUpstreamDigest");
+                if (upstream.bundle.source !== "bundled" || upstream.bundle.digest !== expectedUpstreamDigest) {
+                    throw new Error("current bundled upstream does not match expectedUpstreamDigest");
+                }
+                const generation = validateGeneration(root, generationId);
+                if (generation.metadata.base.digest !== upstream.bundle.digest)
+                    throw new Error("candidate must be rebased onto the current bundled upstream before activation");
+                const expectedState = readSkillEvolutionState(root);
+                if (expectedState.activeGenerationId === generationId) {
+                    return Promise.resolve(Object.freeze({ action: "activate", status: "already-active", activeGenerationId: generationId, requiresNextTurn: false }));
+                }
+                const authorization = requireHumanAuthorization(execution.agent, activationPhrase(generationId, generation.authorization.level), "activate");
+                const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
+                try {
+                    validateGeneration(root, generationId);
+                    const state = readSkillEvolutionState(root);
+                    if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
+                        throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
+                    }
+                    const next = appendStateChange(root, state, "activate", generationId, authorizationEvidence(authorization), now);
+                    const result = Object.freeze({ action: "activate", status: "active", activeGenerationId: next.activeGenerationId, requiresNextTurn: true });
+                    onChanged(execution.agent, result);
+                    return Promise.resolve(result);
+                }
+                finally {
+                    release();
+                }
+            }
+            if (args.action === "rebase") {
+                assertActionArguments(args, "rebase", ["generationId", "expectedUpstreamDigest"]);
+                const generationId = safeGenerationId(args.generationId);
+                const expectedUpstreamDigest = exactDigest(args.expectedUpstreamDigest, "expectedUpstreamDigest");
+                if (upstream.bundle.source !== "bundled" || upstream.bundle.digest !== expectedUpstreamDigest) {
+                    throw new Error("current bundled upstream does not match expectedUpstreamDigest");
+                }
+                validateGeneration(root, generationId);
+                const authorization = requireHumanAuthorization(execution.agent, actionAuthorizationPhrase("rebase", undefined, generationId), "rebase");
+                const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
+                try {
+                    const lockedGeneration = validateGeneration(root, generationId);
+                    const rebased = rebaseGeneration(root, lockedGeneration, upstream.bundle, authorization, now);
+                    let result;
+                    if (rebased.status === "candidate" || rebased.status === "reused") {
+                        result = Object.freeze({ action: "rebase", status: rebased.status, generation: generationSummary(rebased.generation), activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
+                    }
+                    else if (rebased.status === "conflict") {
+                        result = Object.freeze({ action: "rebase", status: "conflict", attemptId: rebased.report.attemptId, conflicts: Object.freeze(rebased.report.conflicts), activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
+                    }
+                    else {
+                        result = Object.freeze({ action: "rebase", status: rebased.status, activeGenerationId: readSkillEvolutionState(root).activeGenerationId });
+                    }
+                    onChanged(execution.agent, result);
+                    return Promise.resolve(result);
+                }
+                finally {
+                    release();
+                }
+            }
+            if (args.action === "rollback") {
+                assertActionArguments(args, "rollback", ["generationId"]);
+                const expectedState = readSkillEvolutionState(root);
+                if (!expectedState.activeGenerationId)
+                    return Promise.resolve(Object.freeze({ action: "rollback", status: "inactive", requiresNextTurn: false }));
+                let target = args.generationId === undefined ? undefined : safeGenerationId(args.generationId);
+                if (target === undefined) {
+                    const previous = [...expectedState.history].reverse().find((event) => event.to === expectedState.activeGenerationId && event.from !== event.to);
+                    target = previous?.from ?? undefined;
+                }
+                if (target === expectedState.activeGenerationId) {
+                    return Promise.resolve(Object.freeze({ action: "rollback", status: "already-active", activeGenerationId: target, requiresNextTurn: false }));
+                }
+                if (target && !expectedState.history.some((event) => event.to === target)) {
+                    throw new Error(`rollback target ${target} was never an active Odai evolution generation`);
+                }
+                if (target) {
+                    const generation = validateGeneration(root, target);
+                    if (generation.resultBundle.manifest.runtimeContract !== ODAI_RUNTIME_CONTRACT) {
+                        throw new Error(`rollback target ${target} is incompatible with runtime contract ${ODAI_RUNTIME_CONTRACT}`);
+                    }
+                }
+                const authorization = requireHumanAuthorization(execution.agent, actionAuthorizationPhrase("rollback", expectedState.activeGenerationId, target), "rollback");
+                const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
+                try {
+                    const state = readSkillEvolutionState(root);
+                    if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
+                        throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
+                    }
+                    const next = appendStateChange(root, state, "rollback", target, authorizationEvidence(authorization), now);
+                    const result = Object.freeze({ action: "rollback", status: target ? "active" : "inactive", activeGenerationId: next.activeGenerationId, requiresNextTurn: true });
+                    onChanged(execution.agent, result);
+                    return Promise.resolve(result);
+                }
+                finally {
+                    release();
+                }
+            }
+            if (args.action === "deactivate") {
+                assertActionArguments(args, "deactivate", []);
+                const expectedState = readSkillEvolutionState(root);
+                if (!expectedState.activeGenerationId)
+                    return Promise.resolve(Object.freeze({ action: "deactivate", status: "inactive", requiresNextTurn: false }));
+                const authorization = requireHumanAuthorization(execution.agent, actionAuthorizationPhrase("deactivate", expectedState.activeGenerationId), "deactivate");
+                const release = acquireOwnedStoreLock(resolve(root, STATE_FILE), "Odai skill evolution store");
+                try {
+                    const state = readSkillEvolutionState(root);
+                    if (state.revision !== expectedState.revision || state.activeGenerationId !== expectedState.activeGenerationId) {
+                        throw new Error("Odai evolution active pointer changed after authorization; retry from a new user turn");
+                    }
+                    appendStateChange(root, state, "deactivate", undefined, authorizationEvidence(authorization), now);
+                    const result = Object.freeze({ action: "deactivate", status: "inactive", requiresNextTurn: true });
+                    onChanged(execution.agent, result);
+                    return Promise.resolve(result);
+                }
+                finally {
+                    release();
+                }
+            }
+            throw new TypeError("action must be show, inspect, propose, validate, activate, rebase, rollback, or deactivate");
+        },
+    };
 }
+//# sourceMappingURL=skill-evolution.mjs.map