@skill-harness/cli 0.28.0 → 0.29.0

package/dist/decision.js

@@ -1,20 +1,72 @@
 // experiments/decision-shadow/main.mjs
-import { createHash as createHash5 } from "node:crypto";
-import { open as open4, readFile as readFile2, stat } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { open as open5, readFile as readFile2, stat } from "node:fs/promises";
+import { resolve as resolve3, join as join7 } from "node:path";
+import { openSync as openSync3, writeFileSync as writeFileSync3, fsyncSync as fsyncSync3, closeSync as closeSync3 } from "node:fs";
 
-// experiments/decision-shadow/research-commands.mjs
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join2, resolve } from "node:path";
+// experiments/decision-shadow/data-root.mjs
+import { closeSync, fsyncSync, lstatSync, mkdirSync, mkdtempSync, openSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+function resolveDataRoot({ env = process.env, home = homedir(), override } = {}) {
+  const value = override !== void 0 ? override : env.SKILL_HARNESS_DATA_ROOT !== void 0 ? env.SKILL_HARNESS_DATA_ROOT : join(home, ".skill-harness");
+  if (typeof value !== "string" || !value.trim() || /[\p{Cc}\p{Cf}]/u.test(value) || !isAbsolute(value))
+    throw new TypeError("Skill Harness data root must be a nonempty absolute path");
+  return resolve(value);
+}
+function ensurePrivateDirectory(path) {
+  const directory = resolveDataRoot({ override: path });
+  const anchor = parse(directory).root;
+  let current = anchor;
+  for (const part of relative(anchor, directory).split(sep).filter(Boolean)) {
+    current = join(current, part);
+    try {
+      mkdirSync(current, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const info2 = lstatSync(current);
+    if (!info2.isDirectory() || info2.isSymbolicLink())
+      throw new Error("Skill Harness collection path must contain ordinary directories, not links");
+  }
+  const info = lstatSync(directory);
+  if (process.platform !== "win32" && ((info.mode & 63) !== 0 || process.getuid && info.uid !== process.getuid()))
+    throw new Error("Skill Harness collection directory must be owned by the current user with mode 0700");
+  return directory;
+}
+function writePrivateNew(path, bytes) {
+  const fd = openSync(path, "wx", 384);
+  try {
+    writeFileSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function createSessionCollection(root, kind, sessionId) {
+  if (!["jev-workflow", "jev-manual"].includes(kind)) throw new TypeError("Unsupported collection kind");
+  if (typeof sessionId !== "string" || !sessionId.trim() || sessionId.length > 256 || /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(sessionId))
+    throw new TypeError("Collection requires an explicit valid session identity");
+  const base = ensurePrivateDirectory(root);
+  const family = ensurePrivateDirectory(join(base, kind));
+  const session = ensurePrivateDirectory(join(family, `session-${createHash("sha256").update(sessionId).digest("hex")}`));
+  return mkdtempSync(join(session, kind === "jev-workflow" ? "selection-" : "run-"));
+}
+
+// experiments/decision-shadow/collections.mjs
+import { constants as constants2 } from "node:fs";
+import { open as open2, opendir } from "node:fs/promises";
+import { join as join3, parse as parse2, relative as relative2, sep as sep2 } from "node:path";
 
 // experiments/decision-shadow/learning-data.mjs
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { constants } from "node:fs";
 import { open, mkdir, writeFile } from "node:fs/promises";
-import { isAbsolute, join, normalize } from "node:path";
+import { isAbsolute as isAbsolute2, join as join2, normalize } from "node:path";
 
 // experiments/decision-shadow/dataset.mjs
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var CASE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
 var SHA256 = /^[0-9a-f]{64}$/;
 var MAX_CASES = 100;
@@ -55,7 +107,7 @@ function canonical(value) {
   return JSON.stringify(value);
 }
 function hashCase(value) {
-  return createHash("sha256").update(canonical(value), "utf8").digest("hex");
+  return createHash2("sha256").update(canonical(value), "utf8").digest("hex");
 }
 function parseCases(value) {
   const root = plainObject(value, "dataset");
@@ -419,7 +471,7 @@ function trainingAssets() {
 }
 
 // experiments/decision-shadow/learning-data.mjs
-var learningDigest = (value) => createHash2("sha256").update(typeof value === "string" || Buffer.isBuffer(value) ? value : canonical2(value)).digest("hex");
+var learningDigest = (value) => createHash3("sha256").update(typeof value === "string" || Buffer.isBuffer(value) ? value : canonical2(value)).digest("hex");
 function canonical2(value) {
   return Array.isArray(value) ? `[${value.map(canonical2).join(",")}]` : value !== null && typeof value === "object" ? `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical2(value[k])}`).join(",")}}` : JSON.stringify(value);
 }
@@ -448,7 +500,7 @@ function parsedCases(cases) {
   check(Array.isArray(cases), "cases must be parsed cases");
   const raw = cases.map((c) => {
     keys(c, ["id", "input", "question", "provenance", "source", "visibility", "hash"], "parsed case");
-    const { hash: hash3, ...rest } = c;
+    const { hash: hash4, ...rest } = c;
     return rest;
   });
   const validated = parseCases({ schema: 1, cases: raw });
@@ -520,10 +572,15 @@ function parseExperiment(cases, manifest) {
   return { ...structuredClone(manifest), entries };
 }
 async function readExplicit(path, expected, limit = 1024 * 1024) {
+  sha2(expected);
+  const bytes = await readBoundedArtifact(path, limit);
+  check(learningDigest(bytes) === expected, "artifact hash mismatch");
+  return bytes;
+}
+async function readBoundedArtifact(path, limit = 1024 * 1024) {
   text(path, "artifact path", 4096);
   check(process.platform === "linux", "Evidence review requires Linux no-follow directory descriptors");
-  check(isAbsolute(path) && normalize(path) === path && !path.endsWith("/"), "artifact path must be canonical and absolute");
-  sha2(expected);
+  check(isAbsolute2(path) && normalize(path) === path && !path.endsWith("/"), "artifact path must be canonical and absolute");
   const components = path.split("/").filter(Boolean);
   check(components.length <= 128, "artifact path too deep");
   check(!components.some((p) => ["sessions", "native-sessions", "auth.json", ".env"].includes(p.toLowerCase())), "private session or credential paths are unsupported");
@@ -565,9 +622,7 @@ async function readExplicit(path, expected, limit = 1024 * 1024) {
         await h.close();
       }
     }
-    const bytes = b.subarray(0, n);
-    check(learningDigest(bytes) === expected, "artifact hash mismatch");
-    return bytes;
+    return b.subarray(0, n);
   } finally {
     if (file) await file.close();
     await Promise.allSettled(directories.map((d) => d.handle.close()));
@@ -606,6 +661,18 @@ async function reviewLabelEvidence({ cases, labels, references }) {
   }
   return { schema: 1, kind: "decision-label-evidence-review", reviewed, meaning: "Exact receipt bytes and declared provenance checked; human identity, truth, independence and rights remain explicit reviewer assertions." };
 }
+function redactSelectedInput(input, replacements) {
+  check(Array.isArray(replacements) && replacements.length <= 32, "invalid redactions");
+  let textValue = input;
+  for (const r of replacements) {
+    keys(r, ["from", "to"], "redaction");
+    text(r.from, "redaction source", 4096);
+    check(typeof r.to === "string" && /^<[A-Z0-9_ -]{1,80}>$/.test(r.to), "redaction must use a placeholder");
+    check(textValue.includes(r.from), "redaction source absent");
+    textValue = textValue.replaceAll(r.from, r.to);
+  }
+  return { input: textValue, replacements: replacements.map((r) => ({ fromSha256: learningDigest(r.from), fromCodepoints: Array.from(r.from).length, to: r.to })) };
+}
 async function importSelectedCase({ caseDocument, selection, sessionConsent, experimentEntry }) {
   const cases = parseCases(caseDocument);
   check(cases.length === 1 && cases[0].provenance === "observed", "import requires exactly one observed case");
@@ -643,16 +710,9 @@ async function importSelectedCase({ caseDocument, selection, sessionConsent, exp
     const points = Array.from(s);
     check(Number.isSafeInteger(f.start) && Number.isSafeInteger(f.end) && f.start >= 0 && f.end > f.start && f.end <= points.length, "invalid excerpt range");
     let excerpt = points.slice(f.start, f.end).join("");
-    check(Array.isArray(f.replacements) && f.replacements.length <= 32, "invalid redactions");
-    for (const r of f.replacements) {
-      keys(r, ["from", "to"], "redaction");
-      text(r.from, "redaction source", 4096);
-      check(typeof r.to === "string" && /^<[A-Z0-9_ -]{1,80}>$/.test(r.to), "redaction must use a placeholder");
-      check(excerpt.includes(r.from), "redaction source absent");
-      excerpt = excerpt.replaceAll(r.from, r.to);
-    }
-    parts.push(excerpt);
-    refs.push({ ...f, replacements: f.replacements.map((r) => ({ fromSha256: learningDigest(r.from), fromCodepoints: Array.from(r.from).length, to: r.to })) });
+    const redacted = redactSelectedInput(excerpt, f.replacements);
+    parts.push(redacted.input);
+    refs.push({ ...f, replacements: redacted.replacements });
   }
   check(parts.join("\n\n") === c.input, "case input must equal exact selected redacted fragments joined by two newlines");
   return { caseDocument: structuredClone(caseDocument), experimentEntry: e, receipt: { schema: 1, kind: "decision-selected-public-import", caseId: c.id, caseHash: c.hash, sessionId: e.sessionId, consentHash: learningDigest(consent), source: structuredClone(selection.source), fragments: refs, trainingEligible: false, automaticCollection: false } };
@@ -703,7 +763,7 @@ async function writePreparedExport({ prepared, directory }) {
   keys(prepared, ["schema", "kind", "metadata", "files"], "prepared export");
   check(prepared.schema === 2 && prepared.metadata?.schema === 2 && prepared.kind === "prepared-decision-learning-export", "unsupported prepared export");
   text(directory, "output directory", 4096);
-  check(isAbsolute(directory), "output directory must be absolute");
+  check(isAbsolute2(directory), "output directory must be absolute");
   const allowed = ["train.jsonl", "validation.jsonl", "test.jsonl", "export-manifest.json", "train-lora.py", "training-config.example.json", "requirements-training.txt", "TRAINING.md"];
   check(Object.keys(prepared.files).sort().join("|") === [...allowed].sort().join("|"), "unexpected export files");
   check(prepared.files["export-manifest.json"] === JSON.stringify(prepared.metadata, null, 2) + "\n", "export metadata mismatch");
@@ -712,10 +772,497 @@ async function writePreparedExport({ prepared, directory }) {
     if (name !== "export-manifest.json") check(prepared.metadata.files[name]?.sha256 === learningDigest(s) && prepared.metadata.files[name]?.bytes === Buffer.byteLength(s), "prepared export bytes changed");
   }
   await mkdir(directory, { mode: 448 });
-  for (const [name, s] of Object.entries(prepared.files)) await writeFile(join(directory, name), s, { encoding: "utf8", flag: "wx", mode: 384 });
+  for (const [name, s] of Object.entries(prepared.files)) await writeFile(join2(directory, name), s, { encoding: "utf8", flag: "wx", mode: 384 });
   return { directory, trainingEligible: prepared.metadata.trainingEligible, files: Object.fromEntries(Object.entries(prepared.files).map(([name, s]) => [name, { sha256: learningDigest(s), bytes: Buffer.byteLength(s) }])) };
 }
 
+// experiments/decision-shadow/collections.mjs
+var DIRECTORY = constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW;
+var LIMITS = Object.freeze({ entries: 1e4, directories: 1e4, bytes: 32 * 1024 * 1024 });
+var SESSION = /^session-([a-f0-9]{64})$/;
+var SELECTION = /^selection-[A-Za-z0-9]{6}$/;
+var RUN = /^run-[A-Za-z0-9]{6}$/;
+var IDENTIFIER = /^[A-Za-z0-9~@][A-Za-z0-9~._:/@+-]{0,255}$/;
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var sessionIdentity = (value) => typeof value === "string" && value.trim() && value.length <= 256 && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+async function openRoot(root) {
+  const anchor = parse2(root).root;
+  let handle = await open2(anchor, DIRECTORY);
+  try {
+    for (const name of relative2(anchor, root).split(sep2).filter(Boolean)) {
+      const next = await open2(`/proc/self/fd/${handle.fd}/${name}`, DIRECTORY);
+      await handle.close();
+      handle = next;
+    }
+    return handle;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+async function listCollections(value) {
+  const root = resolveDataRoot({ override: value });
+  if (process.platform !== "linux") throw Error("Collection inventory requires Linux no-follow directory descriptors");
+  const result = {
+    schema: 1,
+    kind: "decision-collection-inventory",
+    meaning: "inventory-only-not-validation",
+    collections: [],
+    count: 0,
+    gaps: [],
+    truncated: false,
+    limits: { ...LIMITS },
+    trainingEligible: false,
+    exportEligible: false
+  };
+  let entries = 0, directories = 0, bytesRead = 0;
+  const gap = (path, reason) => result.gaps.push({ path, reason });
+  const limit = (path) => {
+    if (!result.truncated) gap(path, "inventory-limit-reached");
+    result.truncated = true;
+  };
+  const directoryFailure = (path, error) => gap(path, error.code === "ENOENT" ? "directory-missing" : "linked-or-unreadable-directory");
+  async function visit(parent, name, path, fn, optional = false) {
+    if (result.truncated) return;
+    if (directories >= LIMITS.directories) {
+      limit(path);
+      return;
+    }
+    let handle2;
+    try {
+      handle2 = await open2(`/proc/self/fd/${parent.fd}/${name}`, DIRECTORY);
+      directories++;
+    } catch (error) {
+      if (!optional || error.code !== "ENOENT") directoryFailure(path, error);
+      return;
+    }
+    try {
+      await fn(handle2);
+    } finally {
+      await handle2.close();
+    }
+  }
+  async function each(handle2, path, fn) {
+    let directory;
+    try {
+      directory = await opendir(`/proc/self/fd/${handle2.fd}`);
+    } catch {
+      gap(path, "unreadable-directory");
+      return;
+    }
+    try {
+      for await (const entry of directory) {
+        if (entries >= LIMITS.entries) {
+          limit(path);
+          break;
+        }
+        entries++;
+        await fn(entry);
+        if (result.truncated) break;
+      }
+    } catch {
+      gap(path, "directory-changed-or-unreadable");
+    }
+  }
+  async function selection(path, kind, expectedSession) {
+    const file = kind === "jev-workflow" ? "selection.json" : "selected-data.json";
+    const relativePath = `${path}/${file}`;
+    const maximum = kind === "jev-workflow" ? 1024 * 1024 : 4 * 1024 * 1024;
+    if (LIMITS.bytes - bytesRead < maximum) {
+      limit(path);
+      return;
+    }
+    let bytes;
+    try {
+      bytes = await readBoundedArtifact(join3(root, relativePath), maximum);
+    } catch (error) {
+      gap(relativePath, error.code === "ENOENT" ? "selection-missing" : "linked-oversized-or-unreadable-selection");
+      return;
+    }
+    bytesRead += bytes.length;
+    let record;
+    try {
+      record = JSON.parse(bytes.toString("utf8"));
+    } catch {
+      gap(relativePath, "invalid-selection-json");
+      return;
+    }
+    const workflow = kind === "jev-workflow";
+    const recognized = object(record) && (workflow ? record.schema === 2 && record.kind === "skill-harness-selected-decision-v2" || record.schema === 3 && record.kind === "skill-harness-selected-decision-v3" : record.schema === 1 && record.kind === "decision-session-selected-data");
+    if (!recognized || !sessionIdentity(record.sessionId) || record.trainingEligible !== false || (workflow ? record.exportEligible !== false : !Array.isArray(record.cases))) {
+      gap(relativePath, "unrecognized-or-incomplete-selection");
+      return;
+    }
+    const sessionSha256 = learningDigest(record.sessionId);
+    if (expectedSession && expectedSession !== sessionSha256) {
+      gap(relativePath, "session-partition-mismatch");
+      return;
+    }
+    let provider = null, model = null;
+    if (workflow) {
+      provider = typeof record.provider === "string" && IDENTIFIER.test(record.provider) ? record.provider : null;
+      model = typeof record.model === "string" && IDENTIFIER.test(record.model) ? record.model : null;
+      if (provider === null || model === null) gap(relativePath, "invalid-provider-model-metadata");
+    }
+    result.collections.push({
+      path: relativePath,
+      sha256: learningDigest(bytes),
+      bytes: bytes.length,
+      sessionSha256,
+      recordType: record.kind,
+      recordSchema: record.schema,
+      caseCount: workflow ? 1 : record.cases.length,
+      provider,
+      model,
+      trainingEligible: false,
+      exportEligible: false
+    });
+  }
+  async function family(handle2, path, kind) {
+    await each(handle2, path, async (entry) => {
+      const session = SESSION.exec(entry.name);
+      const legacy = kind === "jev-workflow" && SELECTION.test(entry.name);
+      if (session) {
+        const sessionPath = `${path}/${entry.name}`;
+        await visit(handle2, entry.name, sessionPath, async (sessionHandle) => {
+          await each(sessionHandle, sessionPath, async (child) => {
+            const matches = (kind === "jev-workflow" ? SELECTION : RUN).test(child.name);
+            if (!matches) {
+              if (child.isSymbolicLink() || /^(selection|run)-/.test(child.name)) gap(sessionPath, "unrecognized-collection-entry");
+              return;
+            }
+            const childPath = `${sessionPath}/${child.name}`;
+            await visit(sessionHandle, child.name, childPath, () => selection(childPath, kind, session[1]));
+          });
+        });
+      } else if (legacy) {
+        const childPath = `${path}/${entry.name}`;
+        await visit(handle2, entry.name, childPath, () => selection(childPath, kind, null));
+      } else if (entry.isSymbolicLink() || /^(session|selection|run)-/.test(entry.name)) {
+        gap(path, "unrecognized-collection-entry");
+      }
+    });
+  }
+  let handle;
+  try {
+    handle = await openRoot(root);
+  } catch (error) {
+    directoryFailure(".", error);
+    return result;
+  }
+  try {
+    for (const kind of ["jev-workflow", "jev-manual"])
+      await visit(handle, kind, kind, (child) => family(child, kind, kind), true);
+  } finally {
+    await handle.close();
+  }
+  result.collections.sort((a, b) => a.path.localeCompare(b.path));
+  result.gaps.sort((a, b) => a.path.localeCompare(b.path) || a.reason.localeCompare(b.reason));
+  result.count = result.collections.length;
+  return result;
+}
+
+// experiments/decision-shadow/research-commands.mjs
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join5, resolve as resolve2 } from "node:path";
+
+// experiments/decision-shadow/workflow-import.mjs
+import { dirname, join as join4, isAbsolute as isAbsolute3, normalize as normalize2 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+
+// experiments/decision-shadow/native-jev.mjs
+import { createHash as createHash4 } from "node:crypto";
+var APIS = /* @__PURE__ */ new Set(["typesafe-system-one", "cloudflare-workers-ai-system-one"]);
+var IDENTIFIER2 = /^[A-Za-z0-9@~][A-Za-z0-9@~._:/-]{0,255}$/;
+var JEV = /(?:^|[/:])jev(?:-latest|-[0-9][A-Za-z0-9._-]*)?$/;
+var keys2 = (value) => Object.keys(value).sort().join(",");
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var identifier = (value) => typeof value === "string" && IDENTIFIER2.test(value);
+var sha256 = (value) => createHash4("sha256").update(value).digest("hex");
+function check2(condition, message) {
+  if (!condition) throw new TypeError(message);
+}
+function routeIdentity(value) {
+  return identifier(value.provider) && value.provider.toLowerCase() !== "openai" && identifier(value.model) && JEV.test(value.model.toLowerCase()) && APIS.has(value.api);
+}
+function validateNativeRoute(route) {
+  check2(isRecord(route) && keys2(route) === "api,model,modelSha256,provider,transport", "Invalid native JEV route fields");
+  check2(route.transport === "pi-classifier" && routeIdentity(route) && typeof route.modelSha256 === "string" && /^[a-f0-9]{64}$/.test(route.modelSha256), "Invalid native JEV route");
+  return Object.freeze({ ...route });
+}
+function text2(value, maximum, name) {
+  check2(typeof value === "string" && value.trim().length > 0 && Array.from(value).length <= maximum && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value), `Invalid native JEV ${name}`);
+}
+function makeNativeRequest({ input, question }) {
+  text2(input, 16e3, "input");
+  text2(question, 8192, "question");
+  return {
+    state: { input },
+    questions: { decision: {
+      type: "bool",
+      instructions: question,
+      criteria: { true: "The answer to the question is yes.", false: "The answer to the question is no." }
+    } }
+  };
+}
+function nativeRequestSha256(example) {
+  return sha256(JSON.stringify(makeNativeRequest(example)));
+}
+function metric(value, integer2 = false) {
+  if (value === void 0) return null;
+  check2(typeof value === "number" && Number.isFinite(value) && value >= 0 && (!integer2 || Number.isSafeInteger(value)), "Invalid native usage");
+  return value;
+}
+function usageOf(value) {
+  if (value === void 0) return { inputTokens: null, outputTokens: null, costUsd: null };
+  check2(isRecord(value), "Invalid native usage");
+  for (const key of ["cacheRead", "cacheWrite", "totalTokens"]) metric(value[key], true);
+  if (value.cost !== void 0) {
+    check2(isRecord(value.cost), "Invalid native usage");
+    for (const key of ["input", "output", "cacheRead", "cacheWrite"]) metric(value.cost[key]);
+  }
+  return { inputTokens: metric(value.input, true), outputTokens: metric(value.output, true), costUsd: metric(value.cost?.total) };
+}
+function normalizeNativeResult(route, result, latencyMs) {
+  route = validateNativeRoute(route);
+  const output = {
+    status: "error",
+    probability: null,
+    resolvedModel: null,
+    returnedProvider: null,
+    returnedModel: null,
+    usage: { inputTokens: null, outputTokens: null, costUsd: null },
+    costSource: null,
+    latencyMs: typeof latencyMs === "number" && Number.isFinite(latencyMs) && latencyMs >= 0 ? latencyMs : null,
+    error: "invalid provider response"
+  };
+  if (!isRecord(result) || output.latencyMs === null || result.provider !== route.provider || result.model !== route.model || result.api !== route.api) return output;
+  output.returnedProvider = result.provider;
+  output.returnedModel = result.model;
+  if (result.stopReason === "error" || result.stopReason === "aborted")
+    return { ...output, error: result.stopReason === "aborted" ? "provider request aborted" : "provider request failed" };
+  try {
+    check2(result.stopReason === "stop" && isRecord(result.answers) && keys2(result.answers) === "decision", "Invalid answer");
+    const answer = result.answers.decision;
+    check2(isRecord(answer) && answer.type === "bool" && typeof answer.probability === "number" && Number.isFinite(answer.probability) && answer.probability >= 0 && answer.probability <= 1, "Invalid answer");
+    const usage = usageOf(result.usage);
+    return {
+      ...output,
+      status: "answered",
+      probability: answer.probability,
+      usage,
+      costSource: usage.costUsd === null ? null : "pi-catalog-estimate",
+      error: null
+    };
+  } catch {
+    return output;
+  }
+}
+function validateNativePrediction(route, result) {
+  route = validateNativeRoute(route);
+  try {
+    check2(isRecord(result) && keys2(result) === "costSource,error,latencyMs,probability,resolvedModel,returnedModel,returnedProvider,status,usage", "Invalid native prediction fields");
+    check2(result.resolvedModel === null && (result.returnedProvider === null && result.returnedModel === null || result.returnedProvider === route.provider && result.returnedModel === route.model), "Invalid native prediction identity");
+    check2(isRecord(result.usage) && keys2(result.usage) === "costUsd,inputTokens,outputTokens", "Invalid native prediction usage");
+    for (const key of ["inputTokens", "outputTokens", "costUsd"])
+      if (result.usage[key] !== null) {
+        check2(result.usage[key] !== void 0, "Missing native usage field");
+        metric(result.usage[key], key !== "costUsd");
+      }
+    if (result.latencyMs !== null) {
+      check2(result.latencyMs !== void 0, "Missing native latency");
+      metric(result.latencyMs);
+    }
+    check2(result.costSource === (result.usage.costUsd === null ? null : "pi-catalog-estimate"), "Invalid native cost provenance");
+    if (result.status === "answered") {
+      check2(result.error === null && result.returnedProvider === route.provider && result.returnedModel === route.model && result.latencyMs !== null && typeof result.probability === "number" && Number.isFinite(result.probability) && result.probability >= 0 && result.probability <= 1, "Invalid native answer");
+    } else {
+      check2(result.status === "error" && result.probability === null && ["invalid provider response", "provider request failed", "provider request aborted"].includes(result.error) && Object.values(result.usage).every((value) => value === null), "Invalid native error");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// experiments/decision-shadow/workflow-import.mjs
+var QUESTION = "Given the stated stage, unresolved engineering uncertainty, requirements and selected evidence, is the proposed next action justified? Assess that action only, not final acceptance or whether mandatory later review is complete.";
+var SOURCE_KEYS = ["schema", "kind", "sessionId", "toolCallId", "frozenAt", "input", "inputSha256", "question", "provider", "model", "consent", "authorization", "provenance", "candidateIdentity", "candidateObservation", "sourceBinding", "evidenceRefs", "evidenceClaims", "inputArtifact", "redaction", "rights", "labelStatus", "trainingEligible", "exportEligible", "publicCaptureVerified"];
+var ENGINEERING_KEYS = ["schema", "kind", "source", "sessionId", "toolCallId", "candidate", "recordedAt", "evidenceRefs", "candidateIdentity", "candidateObservation", "sourceBinding", "independence", "trainingEligible", "exportEligible", "labelStatus"];
+var LIMIT = 2 * 1024 * 1024;
+function check3(ok, message) {
+  if (!ok) throw new TypeError(message);
+}
+function keys3(value, names, name) {
+  check3(value && typeof value === "object" && !Array.isArray(value) && isDeepStrictEqual(Object.keys(value).sort(), [...names].sort()), name + ": unsupported or missing fields");
+}
+function text3(value, name, max = 256) {
+  check3(typeof value === "string" && value.trim().length > 0 && value.length <= max && !value.includes("\0") && !/[\uD800-\uDFFF]/u.test(value), name + ": invalid text");
+}
+function hash(value) {
+  check3(typeof value === "string" && /^[a-f0-9]{64}$/.test(value), "invalid SHA-256");
+}
+function date2(value) {
+  check3(typeof value === "string" && /^\d{4}-\d\d-\d\dT/.test(value) && Number.isFinite(Date.parse(value)), "invalid timestamp");
+  return Date.parse(value);
+}
+function json2(bytes) {
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes));
+}
+function reference(ref) {
+  keys3(ref, ["path", "sha256"], "selected reference");
+  text3(ref.path, "artifact path", 4096);
+  hash(ref.sha256);
+}
+function unlabeled(record) {
+  check3(record.trainingEligible === false && record.exportEligible === false && record.labelStatus === "unlabeled", "retained source must remain unlabeled and ineligible");
+}
+function observed(record, sessionId, candidate) {
+  if (record.candidateIdentity === "caller-claimed") {
+    check3(record.candidateObservation === null, "caller-claimed candidate cannot include an observation");
+    return;
+  }
+  check3(record.candidateIdentity === "principal-runtime-observed", "unsupported candidate provenance");
+  const o = record.candidateObservation;
+  keys3(o, ["requestId", "sessionId", "observedAt", "candidate"], "candidate observation");
+  text3(o.requestId, "observation ID");
+  date2(o.observedAt);
+  check3(o.sessionId === sessionId && o.candidate && typeof o.candidate === "object" && !Array.isArray(o.candidate) && o.candidate.algorithm === "principal-candidate-v1" && o.candidate.id === candidate, "candidate observation identity mismatch");
+  text3(o.candidate.root, "candidate root", 4096);
+  check3(isAbsolute3(o.candidate.root) && normalize2(o.candidate.root) === o.candidate.root, "candidate root must be canonical and absolute");
+}
+function evidenceRefs(refs, retained = false) {
+  check3(Array.isArray(refs) && refs.length <= 8, "evidence must select at most 8 files");
+  const seen = /* @__PURE__ */ new Set();
+  return refs.map((ref) => {
+    keys3(ref, retained ? ["path", "sha256", "bytes", "retainedPath"] : ["path", "sha256", "bytes"], "evidence reference");
+    text3(ref.path, "original evidence path", 4096);
+    hash(ref.sha256);
+    check3(isAbsolute3(ref.path) && normalize2(ref.path) === ref.path && !seen.has(ref.path), "invalid or duplicate evidence path");
+    seen.add(ref.path);
+    check3(Number.isSafeInteger(ref.bytes) && ref.bytes >= 0 && ref.bytes <= LIMIT, "invalid evidence size");
+    return { path: ref.path, sha256: ref.sha256, bytes: ref.bytes };
+  });
+}
+async function snapshot(directory, ref, expectedName) {
+  check3(ref.retainedPath === expectedName, "unexpected retained evidence path");
+  const bytes = await readExplicit(join4(directory, expectedName), ref.sha256, LIMIT);
+  check3(bytes.length === ref.bytes, "retained evidence size mismatch");
+  return { sha256: ref.sha256, bytes: ref.bytes };
+}
+function validateSource(source) {
+  const native = source?.schema === 3 && source.kind === "skill-harness-selected-decision-v3";
+  check3(native || source?.schema === 2 && source.kind === "skill-harness-selected-decision-v2", "unsupported workflow selection contract");
+  keys3(source, native ? [...SOURCE_KEYS, "route", "requestSha256"] : SOURCE_KEYS, "workflow selection");
+  text3(source.sessionId, "session ID");
+  text3(source.toolCallId, "tool-call ID");
+  date2(source.frozenAt);
+  text3(source.input, "decision input", 32e3);
+  hash(source.inputSha256);
+  check3(Array.from(source.input).length <= 16e3 && learningDigest(source.input) === source.inputSha256, "decision input digest or size mismatch");
+  check3(source.question === QUESTION, "unsupported workflow question");
+  const route = native ? validateNativeRoute(source.route) : null;
+  check3(route ? source.provider === route.provider && source.model === route.model : source.provider === "jev" && source.model === "typesafe/jev-1.13", "unsupported workflow provider");
+  if (native) check3(source.requestSha256 === nativeRequestSha256(source), "native request digest mismatch");
+  const packet = JSON.parse(source.input);
+  keys3(packet, ["candidate", "stage", "nextAction", "uncertainty", "requirements", "evidence"], "decision packet");
+  for (const key of Object.keys(packet)) text3(packet[key], key, 32e3);
+  check3(["design", "implementation", "verification"].includes(packet.stage), "unsupported decision stage");
+  const { candidate, stage, nextAction, uncertainty, requirements, evidence } = packet;
+  check3(JSON.stringify({ candidate, stage, nextAction, uncertainty, requirements, evidence }) === source.input, "decision input is not the exact producer packet");
+  const consent = parseStorageConsent(source.consent, source.sessionId);
+  check3(consent.decision === "granted" && date2(consent.recordedAt) <= date2(source.frozenAt), "recorded session storage consent is missing or postdates selection");
+  const a = source.authorization;
+  keys3(a, ["kind", "interactionId", "sessionId", "recordedAt", ...native ? ["route"] : ["provider", "model"], "question", "maximumCalls"], "workflow authorization");
+  text3(a.interactionId, "authorization interaction");
+  const authorizationMatches = native ? a.kind === "jev-workflow-paid-scope-v2" && isDeepStrictEqual(validateNativeRoute(a.route), route) : a.kind === "jev-workflow-paid-scope" && a.provider === source.provider && a.model === source.model;
+  check3(authorizationMatches && a.sessionId === source.sessionId && a.question === QUESTION && a.maximumCalls === 3 && date2(a.recordedAt) <= date2(source.frozenAt), "workflow authorization mismatch");
+  check3(source.provenance === "tool-selected-input" && source.evidenceClaims === "unassessed" && source.redaction === "unassessed" && source.rights === "unassessed" && source.publicCaptureVerified === false, "unsupported workflow provenance claims");
+  unlabeled(source);
+  const refs = evidenceRefs(source.evidenceRefs);
+  check3(source.sourceBinding === (refs.length ? "local-reference-digests-verified" : "unassessed"), "source binding mismatch");
+  keys3(source.inputArtifact, ["path", "sha256", "encoding"], "input artifact");
+  check3(source.inputArtifact.path === "input.txt" && source.inputArtifact.sha256 === source.inputSha256 && source.inputArtifact.encoding === "utf8", "unsupported input artifact");
+  observed(source, source.sessionId, candidate);
+  return { packet, consent, refs };
+}
+async function importWorkflowCase({ caseDocument, selection, sessionConsent, experimentEntry }) {
+  const cases = parseCases(caseDocument);
+  check3(cases.length === 1 && cases[0].provenance === "observed", "workflow import requires exactly one observed case");
+  const c = cases[0];
+  const entry = parseEntry(c, experimentEntry), currentConsent = parseStorageConsent(sessionConsent, entry.sessionId);
+  check3(currentConsent.decision === "granted", "session storage declined; workflow import refused");
+  check3(entry.decisionTimeReviewed && entry.redactionReviewed, "decision-time and redaction review required");
+  keys3(selection, ["schema", "kind", "source", "replacements", "engineering"], "workflow import selection");
+  check3(selection.schema === 1 && selection.kind === "decision-selected-workflow-input", "unsupported workflow import selection");
+  reference(selection.source);
+  check3(Array.isArray(selection.engineering) && selection.engineering.length <= 8, "select at most 8 engineering records");
+  const source = json2(await readExplicit(selection.source.path, selection.source.sha256));
+  const { packet, consent, refs } = validateSource(source), directory = dirname(selection.source.path);
+  check3(source.sessionId === entry.sessionId && c.source.sha256 === selection.source.sha256 && c.source.recordId === source.toolCallId, "workflow source/session identity mismatch");
+  check3(c.question === source.question, "workflow question must match the selected decision");
+  const input = await readExplicit(join4(directory, "input.txt"), source.inputSha256);
+  check3(input.equals(Buffer.from(source.input, "utf8")), "input artifact differs from decision input");
+  const redacted = redactSelectedInput(source.input, selection.replacements);
+  check3(c.input === redacted.input, "case input must equal exact selected redacted decision input");
+  check3(!selection.replacements.length || c.visibility === "redacted", "redacted case must declare redacted visibility");
+  const mappingBytes = await readBoundedArtifact(join4(directory, "evidence.json"));
+  const mapping = json2(mappingBytes);
+  keys3(mapping, ["schema", "evidenceRefs"], "retained decision evidence");
+  check3(mapping.schema === 1 && isDeepStrictEqual(evidenceRefs(mapping.evidenceRefs, true), refs), "decision evidence mapping mismatch");
+  const decisionEvidence = [];
+  for (const [index, ref] of mapping.evidenceRefs.entries()) decisionEvidence.push(await snapshot(directory, ref, `decision-evidence-${index + 1}.bin`));
+  const engineering = [], seen = /* @__PURE__ */ new Set();
+  for (const ref of selection.engineering) {
+    reference(ref);
+    check3(dirname(ref.path) === directory && !seen.has(ref.path), "engineering record must be a distinct selected sibling");
+    seen.add(ref.path);
+    const record = json2(await readExplicit(ref.path, ref.sha256));
+    keys3(record, ENGINEERING_KEYS, "engineering evidence");
+    check3(record.schema === 1 && record.kind === "skill-harness-engineering-evidence-v1", "provider advice is not engineering evidence");
+    keys3(record.source, ["path", "sha256", "inputSha256"], "engineering source");
+    check3(record.source.path === "selection.json" && record.source.sha256 === selection.source.sha256 && record.source.inputSha256 === source.inputSha256, "engineering source mismatch");
+    text3(record.toolCallId, "engineering tool-call ID");
+    check3(record.sessionId === source.sessionId && record.candidate === packet.candidate && date2(record.recordedAt) >= date2(source.frozenAt), "engineering session/candidate/time mismatch");
+    check3(record.sourceBinding === "local-reference-digests-verified" && record.independence === "unassessed", "unsupported engineering evidence claims");
+    unlabeled(record);
+    observed(record, source.sessionId, packet.candidate);
+    check3(source.candidateIdentity !== "principal-runtime-observed" || record.candidateIdentity === "principal-runtime-observed" && record.candidateObservation.candidate.root === source.candidateObservation.candidate.root, "engineering evidence lost its matching candidate observation");
+    const linkedRefs = evidenceRefs(record.evidenceRefs, true);
+    check3(linkedRefs.length > 0, "engineering evidence requires selected files");
+    const key = learningDigest(JSON.stringify({ candidate: record.candidate, evidenceRefs: linkedRefs }));
+    check3(ref.path === join4(directory, `engineering-${key}.json`), "engineering filename does not match producer identity");
+    const artifacts = [];
+    for (const [index, saved] of record.evidenceRefs.entries()) artifacts.push(await snapshot(directory, saved, `engineering-${key}-${index + 1}.bin`));
+    engineering.push({ sha256: ref.sha256, sessionId: record.sessionId, toolCallId: record.toolCallId, candidateIdentity: record.candidateIdentity, recordedAt: record.recordedAt, artifacts, independence: "unassessed" });
+  }
+  return { caseDocument: structuredClone(caseDocument), experimentEntry: entry, receipt: {
+    schema: 1,
+    kind: "decision-selected-workflow-import",
+    caseId: c.id,
+    caseHash: c.hash,
+    sessionId: source.sessionId,
+    toolCallId: source.toolCallId,
+    source: { sha256: selection.source.sha256, recordId: source.toolCallId },
+    inputSha256: source.inputSha256,
+    ...source.schema === 3 ? { sourceContract: source.kind, nativeRouteSha256: learningDigest(source.route), nativeRequestSha256: source.requestSha256 } : {},
+    recordedConsentHash: learningDigest(consent),
+    currentConsentHash: learningDigest(currentConsent),
+    candidateIdentity: source.candidateIdentity,
+    candidateObservationSha256: source.candidateObservation ? learningDigest(source.candidateObservation) : null,
+    replacements: redacted.replacements,
+    decisionEvidence: { mappingSha256: learningDigest(mappingBytes), artifacts: decisionEvidence },
+    engineering,
+    labelStatus: "unlabeled",
+    trainingEligible: false,
+    exportEligible: false,
+    publicCaptureVerified: false,
+    automaticCollection: false,
+    providerPredictionsIncluded: false,
+    meaning: "Selected local bytes and declared producer linkage checked at import time; authenticity, source truth, independence, redaction and rights remain reviewer assertions. Export separately checks curated cases, entries, consent and independent labels; it does not reverify this receipt."
+  } };
+}
+
 // experiments/decision-shadow/workflow-fixtures.mjs
 var WORKFLOW_ORACLE_VERSION = "workflow-convergence-oracles-v1";
 function evaluateWorkflowFixture(family, facts) {
@@ -739,7 +1286,7 @@ function evaluateWorkflowFixture(family, facts) {
   }
 }
 function workflowFixtureFamilies() {
-  const root = "/fixture/pilot", hash3 = "a".repeat(64);
+  const root = "/fixture/pilot", hash4 = "a".repeat(64);
   const workspace = {
     requestedRoot: root,
     observedRoot: root,
@@ -748,8 +1295,8 @@ function workflowFixtureFamilies() {
     readablePaths: [`${root}/report.md`]
   };
   const identity2 = {
-    expected: { algorithm: "principal-candidate-v1", id: hash3 },
-    actual: { algorithm: "principal-candidate-v1", id: hash3 }
+    expected: { algorithm: "principal-candidate-v1", id: hash4 },
+    actual: { algorithm: "principal-candidate-v1", id: hash4 }
   };
   const evidence = {
     candidateMatched: true,
@@ -760,9 +1307,9 @@ function workflowFixtureFamilies() {
   const reuse = {
     operation: "static-inspection",
     purpose: "same-check",
-    currentInput: hash3,
+    currentInput: hash4,
     currentEnvironment: "node-fixture-v1",
-    previous: { state: "complete", input: hash3, environment: "node-fixture-v1", outputsVerified: true }
+    previous: { state: "complete", input: hash4, environment: "node-fixture-v1", outputsVerified: true }
   };
   return [
     {
@@ -775,7 +1322,7 @@ function workflowFixtureFamilies() {
       family: "identity",
       split: "train",
       question: "Do these records contain matching full candidate IDs under the same principal-candidate-v1 algorithm? A diff hash or another algorithm is not an interchangeable candidate ID.",
-      facts: [identity2, { ...identity2, actual: { algorithm: "git-diff-sha256", id: hash3 } }, { ...identity2, actual: { algorithm: "principal-candidate-v1", id: "b".repeat(64) } }, { expected: { algorithm: "principal-candidate-v1", id: "aaaaaaa" }, actual: { algorithm: "principal-candidate-v1", id: "aaaaaaa" } }]
+      facts: [identity2, { ...identity2, actual: { algorithm: "git-diff-sha256", id: hash4 } }, { ...identity2, actual: { algorithm: "principal-candidate-v1", id: "b".repeat(64) } }, { expected: { algorithm: "principal-candidate-v1", id: "aaaaaaa" }, actual: { algorithm: "principal-candidate-v1", id: "aaaaaaa" } }]
     },
     {
       family: "evidence",
@@ -875,30 +1422,30 @@ function createLearningFixtures({ recordedAt = "2026-10-08T00:00:00.000Z", set =
 }
 
 // experiments/decision-shadow/research.mjs
-import { createHash as createHash3, randomUUID } from "node:crypto";
-import { open as open2, readFile } from "node:fs/promises";
+import { createHash as createHash5, randomUUID } from "node:crypto";
+import { open as open3, readFile } from "node:fs/promises";
 import { DECISION_SYSTEM_PROMPT } from "@skill-harness/adapters";
 var PROMPT_REVISION = "decision-input-question-v1";
 var decisionPrompt = (c) => JSON.stringify({ input: c.input, question: c.question });
 var fullCaseSetHash = (cases) => learningDigest(cases.map((c) => ({ id: c.id, hash: c.hash })));
-var hash = (s) => createHash3("sha256").update(s).digest("hex");
-function check2(ok, message) {
+var hash2 = (s) => createHash5("sha256").update(s).digest("hex");
+function check4(ok, message) {
   if (!ok) throw TypeError(message);
 }
-function keys2(value, names, name) {
-  check2(
+function keys4(value, names, name) {
+  check4(
     value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).sort().join("|") === [...names].sort().join("|"),
     name + " has unsupported/missing fields"
   );
 }
 function sha3(value) {
-  check2(
+  check4(
     typeof value === "string" && /^[0-9a-f]{64}$/.test(value),
     "invalid digest"
   );
 }
 function selected(cases, manifest, split) {
-  check2(
+  check4(
     ["train", "validation", "test", "all"].includes(split),
     "explicit train/validation/test/all split required"
   );
@@ -908,16 +1455,16 @@ function selected(cases, manifest, split) {
 }
 function previewPi(cases, manifest, { model, thinking, split }) {
   manifest = parseExperiment(cases, manifest);
-  check2(
+  check4(
     /^openai-codex:[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(model),
     "explicit subscription model required"
   );
-  check2(
+  check4(
     ["off", "minimal", "low", "medium", "high", "xhigh"].includes(thinking),
     "explicit thinking level required"
   );
   const subset = selected(cases, manifest, split);
-  check2(subset.length > 0, "selected split is empty");
+  check4(subset.length > 0, "selected split is empty");
   return {
     schema: 1,
     kind: "decision-pi-preview",
@@ -932,7 +1479,7 @@ function previewPi(cases, manifest, { model, thinking, split }) {
       caseId: c.id,
       caseHash: c.hash,
       prompt: decisionPrompt(c),
-      promptSha256: hash(decisionPrompt(c))
+      promptSha256: hash2(decisionPrompt(c))
     }))
   };
 }
@@ -969,10 +1516,10 @@ async function runPiBaseline({
       caseHash: r.caseHash
     })),
     promptRevision: PROMPT_REVISION,
-    systemPromptSha256: hash(adapter.DECISION_SYSTEM_PROMPT),
+    systemPromptSha256: hash2(adapter.DECISION_SYSTEM_PROMPT),
     trainingEligible: false
   };
-  const file = await open2(out, "wx", 384);
+  const file = await open3(out, "wx", 384);
   const append = async (row) => {
     await file.writeFile(JSON.stringify(row) + "\n");
     await file.sync();
@@ -1021,16 +1568,16 @@ async function runPiBaseline({
     );
   return header;
 }
-function parsePiRun(text2, cases, manifest) {
+function parsePiRun(text4, cases, manifest) {
   manifest = parseExperiment(cases, manifest);
   let rows;
   try {
-    rows = text2.trim().split("\n").map((line) => JSON.parse(line));
+    rows = text4.trim().split("\n").map((line) => JSON.parse(line));
   } catch {
     throw Error("Invalid Pi run JSONL");
   }
   const [header, ...records] = rows;
-  keys2(
+  keys4(
     header,
     [
       "schema",
@@ -1049,11 +1596,11 @@ function parsePiRun(text2, cases, manifest) {
     ],
     "Pi run header"
   );
-  check2(
+  check4(
     header.schema === 2 && header.kind === "decision-pi-run" && header.trainingEligible === false,
     "unsupported Pi run"
   );
-  check2(
+  check4(
     /^[0-9a-f-]{36}$/.test(header.runId) && new Date(header.createdAt).toISOString() === header.createdAt,
     "invalid run identity/time"
   );
@@ -1062,7 +1609,7 @@ function parsePiRun(text2, cases, manifest) {
     thinking: header.thinking,
     split: header.split
   });
-  check2(
+  check4(
     header.caseSetHash === preview.caseSetHash && header.experimentHash === preview.experimentHash && header.promptRevision === PROMPT_REVISION && learningDigest(header.selected) === learningDigest(
       preview.requests.map((r) => ({
         caseId: r.caseId,
@@ -1071,21 +1618,21 @@ function parsePiRun(text2, cases, manifest) {
     ),
     "Pi run belongs to a different experiment/selection"
   );
-  check2(
-    header.systemPromptSha256 === hash(DECISION_SYSTEM_PROMPT),
+  check4(
+    header.systemPromptSha256 === hash2(DECISION_SYSTEM_PROMPT),
     "Pi system prompt revision mismatch"
   );
-  check2(records.length <= preview.requests.length, "too many Pi predictions");
+  check4(records.length <= preview.requests.length, "too many Pi predictions");
   let worker = null;
   const sessions = /* @__PURE__ */ new Set();
   for (const [i, r] of records.entries()) {
     const expected = preview.requests[i];
-    check2(
+    check4(
       r.caseId === expected.caseId && r.caseHash === expected.caseHash && r.promptSha256 === expected.promptSha256 && r.kind === "prediction" && r.trainingEligible === false,
       "Pi prediction identity/order mismatch"
     );
     if (r.status === "error") {
-      keys2(
+      keys4(
         r,
         [
           "kind",
@@ -1099,13 +1646,13 @@ function parsePiRun(text2, cases, manifest) {
         ],
         "Pi error"
       );
-      check2(
+      check4(
         r.probability === null && r.error === "Pi decision failed; no retry or fallback." && i === records.length - 1,
         "invalid Pi error prefix"
       );
       continue;
     }
-    keys2(
+    keys4(
       r,
       [
         "kind",
@@ -1126,48 +1673,48 @@ function parsePiRun(text2, cases, manifest) {
       ],
       "Pi prediction"
     );
-    check2(
+    check4(
       ["answered", "abstained"].includes(r.status) && r.resolvedModel === header.requestedModel && r.piVersion === "1.0.4" && r.systemPromptSha256 === header.systemPromptSha256,
       "Pi result route/version mismatch"
     );
-    check2(
+    check4(
       r.status === "abstained" ? r.probability === null : typeof r.probability === "number" && Number.isFinite(r.probability) && r.probability >= 0 && r.probability <= 1,
       "invalid Pi probability"
     );
-    keys2(r.nativeFinal, ["sessionId", "messageId", "sha256"], "native final");
+    keys4(r.nativeFinal, ["sessionId", "messageId", "sha256"], "native final");
     for (const k of ["sessionId", "messageId"])
-      check2(
+      check4(
         typeof r.nativeFinal[k] === "string" && r.nativeFinal[k].length > 0 && r.nativeFinal[k].length <= 256,
         "invalid native identity"
       );
     sha3(r.nativeFinal.sha256);
-    check2(
+    check4(
       !sessions.has(r.nativeFinal.sessionId),
       "Pi cases must have independent fresh sessions"
     );
     sessions.add(r.nativeFinal.sessionId);
-    keys2(r.route, ["oauth", "subscription"], "route");
-    check2(
+    keys4(r.route, ["oauth", "subscription"], "route");
+    check4(
       r.route.oauth === true && r.route.subscription === true,
       "non-subscription Pi result"
     );
-    keys2(r.usage, ["inputTokens", "outputTokens", "costUsd"], "usage");
-    check2(r.usage.costUsd === null, "subscription cost must not be estimated");
+    keys4(r.usage, ["inputTokens", "outputTokens", "costUsd"], "usage");
+    check4(r.usage.costUsd === null, "subscription cost must not be estimated");
     for (const k of ["inputTokens", "outputTokens"])
-      check2(
+      check4(
         r.usage[k] === null || Number.isSafeInteger(r.usage[k]) && r.usage[k] >= 0,
         "invalid Pi usage"
       );
-    check2(Number.isFinite(r.latencyMs) && r.latencyMs >= 0, "invalid latency");
+    check4(Number.isFinite(r.latencyMs) && r.latencyMs >= 0, "invalid latency");
     sha3(r.workerSha256);
     if (worker !== null)
-      check2(worker === r.workerSha256, "mixed worker revisions");
+      check4(worker === r.workerSha256, "mixed worker revisions");
     worker = r.workerSha256;
   }
   return {
     header,
     records,
-    runSha256: hash(text2),
+    runSha256: hash2(text4),
     cases: preview.requests.map((r) => cases.find((c) => c.id === r.caseId)),
     experimentBound: true
   };
@@ -1216,11 +1763,11 @@ function metrics(cases, labels, records) {
 }
 function compareRuns(cases, labels, manifest, runs) {
   manifest = parseExperiment(cases, manifest);
-  check2(
+  check4(
     Array.isArray(runs) && runs.length >= 1 && runs.length <= 8,
     "compare 1..8 explicit runs"
   );
-  check2(
+  check4(
     new Set(runs.map((r) => r.runSha256)).size === runs.length,
     "duplicate run files"
   );
@@ -1238,7 +1785,7 @@ function compareRuns(cases, labels, manifest, runs) {
         run.records.filter((r) => r.status === "answered" || r.status === "abstained").map((r) => r.resolvedModel)
       )
     ];
-    check2(
+    check4(
       observedModels.length <= 1,
       "mixed resolved models in one comparison arm"
     );
@@ -1249,6 +1796,12 @@ function compareRuns(cases, labels, manifest, runs) {
       runSha256: run.runSha256,
       runId: run.header.runId ?? null,
       model: run.header.requestedModel,
+      ...run.header.kind === "decision-shadow-native-run" ? {
+        route: run.header.route,
+        requestFormat: run.header.requestFormat,
+        costSource: run.header.costSource,
+        modelResolution: "Pi returns the requested model identity; backend resolution is unknown."
+      } : {},
       observedModels,
       createdAt: run.header.createdAt,
       thinking: run.header.thinking ?? null,
@@ -1313,6 +1866,7 @@ var RESEARCH_OPTIONS = {
     "out"
   ],
   "import-session": ["cases", "selection", "consent", "entry", "out"],
+  "import-workflow": ["cases", "selection", "consent", "entry", "out"],
   fixtures: ["out"]
 };
 var RESEARCH_OPTIONAL = {
@@ -1324,11 +1878,11 @@ async function researchCommand(command, flags, helpers, options) {
   const { emit = console.log, piRunner } = options;
   if (command === "fixtures") {
     const f = createLearningFixtures({ set: flags.set ?? "mechanical" });
-    const dir = resolve(flags.out);
+    const dir = resolve2(flags.out);
     await mkdir2(dir, { mode: 448 });
     const refs = [];
     for (const r of f.labelReceipts) {
-      const path = join2(dir, r.filename);
+      const path = join5(dir, r.filename);
       await writeFile2(path, r.bytes, { flag: "wx", mode: 384 });
       refs.push({ caseId: r.caseId, path, sha256: r.sha256 });
     }
@@ -1339,7 +1893,7 @@ async function researchCommand(command, flags, helpers, options) {
       "label-evidence.json": refs,
       "consents.json": []
     }))
-      await writeNew2(join2(dir, name), value);
+      await writeNew2(join5(dir, name), value);
     emit(
       JSON.stringify({
         saved: dir,
@@ -1350,15 +1904,16 @@ async function researchCommand(command, flags, helpers, options) {
     );
     return;
   }
-  if (command === "import-session") {
-    const result = await importSelectedCase({
+  if (command === "import-session" || command === "import-workflow") {
+    const importCase = command === "import-workflow" ? importWorkflowCase : importSelectedCase;
+    const result = await importCase({
       caseDocument: await jsonFile2(flags.cases),
       selection: await jsonFile2(flags.selection),
       sessionConsent: await jsonFile2(flags.consent),
       experimentEntry: await jsonFile2(flags.entry)
     });
     await writeNew2(flags.out, result);
-    emit(JSON.stringify({ saved: resolve(flags.out), trainingReady: false }));
+    emit(JSON.stringify({ saved: resolve2(flags.out), trainingReady: false }));
     return;
   }
   const manifest = parseExperiment(cases, await jsonFile2(flags.experiment));
@@ -1403,7 +1958,7 @@ async function researchCommand(command, flags, helpers, options) {
     });
     emit(
       JSON.stringify({
-        saved: resolve(flags.out),
+        saved: resolve2(flags.out),
         runId: header.runId,
         trainingEligible: false
       })
@@ -1423,7 +1978,7 @@ async function researchCommand(command, flags, helpers, options) {
     });
     const result = await writePreparedExport({
       prepared,
-      directory: resolve(flags.out)
+      directory: resolve2(flags.out)
     });
     emit(JSON.stringify(result));
     return;
@@ -1436,15 +1991,15 @@ async function researchCommand(command, flags, helpers, options) {
     });
     const runs = [];
     for (const path of flags.run) {
-      const text2 = await textFile2(path);
+      const text4 = await textFile2(path);
       let first;
       try {
-        first = JSON.parse(text2.split("\n")[0]);
+        first = JSON.parse(text4.split("\n")[0]);
       } catch {
         throw Error("Invalid run header");
       }
       if (first.kind === "decision-pi-run")
-        runs.push(parsePiRun(text2, cases, manifest));
+        runs.push(parsePiRun(text4, cases, manifest));
       else
         runs.push({
           ...await readLegacyRun(path, cases),
@@ -1457,7 +2012,7 @@ async function researchCommand(command, flags, helpers, options) {
     await writeNew2(flags.out, report);
     emit(
       JSON.stringify({
-        saved: resolve(flags.out),
+        saved: resolve2(flags.out),
         commonLabeledAnswered: report.commonLabeledAnswered,
         trainingReady: false
       })
@@ -1471,16 +2026,18 @@ async function researchCommand(command, flags, helpers, options) {
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { stdin, stderr } from "node:process";
-import { openSync, writeFileSync, fsyncSync, closeSync } from "node:fs";
+import { openSync as openSync2, writeFileSync as writeFileSync2, fsyncSync as fsyncSync2, closeSync as closeSync2 } from "node:fs";
 var STORAGE_QUESTION = "Retain this session\u2019s explicitly selected inputs and questions for future LoRA dataset review? This grants storage only, not training or use of JEV predictions as labels.";
 async function requestSessionStorage({
   sessionId = randomUUID2(),
   storage,
-  promptStorage
+  promptStorage,
+  storageRoot
 } = {}) {
   let answer = storage;
+  const question = STORAGE_QUESTION + (storageRoot ? ` Local collection root: ${storageRoot}.` : "");
   if (answer === void 0) {
-    if (promptStorage) answer = await promptStorage(STORAGE_QUESTION);
+    if (promptStorage) answer = await promptStorage(question);
     else {
       if (!stdin.isTTY || !stderr.isTTY)
         throw Error(
@@ -1489,7 +2046,7 @@ async function requestSessionStorage({
       const rl = createInterface({ input: stdin, output: stderr });
       try {
         answer = /^(y|yes)$/i.test(
-          (await rl.question(STORAGE_QUESTION + " [y/N] ")).trim()
+          (await rl.question(question + " [y/N] ")).trim()
         ) ? "yes" : "no";
       } finally {
         rl.close();
@@ -1531,15 +2088,15 @@ async function retainSelectedSessionData({
     trainingEligible: false,
     labelStatus: "unlabeled",
     providerOutputsIncluded: false,
-    cases: cases.map(({ hash: hash3, ...c }) => ({ caseHash: hash3, ...c }))
+    cases: cases.map(({ hash: hash4, ...c }) => ({ caseHash: hash4, ...c }))
   };
   assertCurrent();
-  const fd = openSync(out, "wx", 384);
+  const fd = openSync2(out, "wx", 384);
   try {
-    writeFileSync(fd, JSON.stringify(document, null, 2) + "\n");
-    fsyncSync(fd);
+    writeFileSync2(fd, JSON.stringify(document, null, 2) + "\n");
+    fsyncSync2(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
   return { retained: true, path: out, trainingReady: false };
 }
@@ -1579,7 +2136,7 @@ function makeRequest(provider, model, example) {
     }
   };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function probability(value) {
@@ -1605,11 +2162,11 @@ function isSupportedResolvedModel(value) {
   if (value === PROVIDER.model) return true;
   const prefix = `${PROVIDER.model}-`;
   if (typeof value !== "string" || !value.startsWith(prefix)) return false;
-  const snapshot = value.slice(prefix.length);
-  if (snapshot.length !== 8 || !/^\d{8}$/.test(snapshot)) return false;
-  const year = Number(snapshot.slice(0, 4));
-  const month = Number(snapshot.slice(4, 6));
-  const day = Number(snapshot.slice(6, 8));
+  const snapshot2 = value.slice(prefix.length);
+  if (snapshot2.length !== 8 || !/^\d{8}$/.test(snapshot2)) return false;
+  const year = Number(snapshot2.slice(0, 4));
+  const month = Number(snapshot2.slice(4, 6));
+  const day = Number(snapshot2.slice(6, 8));
   const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
   const monthLengths = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
   return year > 0 && month >= 1 && month <= 12 && day >= 1 && day <= monthLengths[month - 1];
@@ -1620,12 +2177,12 @@ function resolvedModel(value) {
   }
   return value;
 }
-function normalize2(payload) {
-  if (!isRecord(payload) || !isRecord(payload.answers) || Object.keys(payload.answers).length !== 1 || !isRecord(payload.usage)) {
+function normalize3(payload) {
+  if (!isRecord2(payload) || !isRecord2(payload.answers) || Object.keys(payload.answers).length !== 1 || !isRecord2(payload.usage)) {
     throw new Error("invalid provider response");
   }
   const answer = payload.answers.decision;
-  if (!isRecord(answer) || answer.type !== "noul") {
+  if (!isRecord2(answer) || answer.type !== "noul") {
     throw new Error("invalid provider response");
   }
   return {
@@ -1726,14 +2283,14 @@ async function callProvider(provider, model, example, options = {}) {
       timedOut
     ]);
     if (!response || response.ok !== true) throw new Error("provider request failed");
-    const text2 = await readBounded(response, timedOut);
+    const text4 = await readBounded(response, timedOut);
     let payload;
     try {
-      payload = JSON.parse(text2);
+      payload = JSON.parse(text4);
     } catch {
       throw new Error("invalid provider response");
     }
-    return { ...normalize2(payload), latencyMs: Math.max(0, performance.now() - startedAt) };
+    return { ...normalize3(payload), latencyMs: Math.max(0, performance.now() - startedAt) };
   } catch (error) {
     return failure(startedAt, error);
   } finally {
@@ -1744,16 +2301,16 @@ async function callProvider(provider, model, example, options = {}) {
 }
 
 // experiments/decision-shadow/public-evidence.mjs
-import { constants as constants2 } from "node:fs";
-import { open as open3 } from "node:fs/promises";
-import { createHash as createHash4 } from "node:crypto";
-import { isDeepStrictEqual } from "node:util";
-import { basename, dirname, isAbsolute as isAbsolute2, join as join3, normalize as normalize3 } from "node:path";
+import { constants as constants3 } from "node:fs";
+import { open as open4 } from "node:fs/promises";
+import { createHash as createHash6 } from "node:crypto";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute4, join as join6, normalize as normalize4 } from "node:path";
 var MAX_PUBLIC_SOURCE_FILE_BYTES = 64 * 1024 * 1024;
 var MAX_PUBLIC_SOURCE_TOTAL_BYTES = 128 * 1024 * 1024;
 var MAX_PUBLIC_SOURCE_FILES = 256;
 var MAX_PUBLIC_SOURCE_MANIFEST_BYTES = 1024 * 1024;
-var LIMITS = Object.freeze({
+var LIMITS2 = Object.freeze({
   fileBytes: MAX_PUBLIC_SOURCE_FILE_BYTES,
   totalBytes: MAX_PUBLIC_SOURCE_TOTAL_BYTES,
   files: MAX_PUBLIC_SOURCE_FILES,
@@ -1763,42 +2320,42 @@ var HASH = /^[0-9a-f]{64}$/;
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var TOOLS = ["delegate_describe", "delegate", "delegate_all", "delegate_chain"];
 var RUNTIME_PREFIX = "Runtime execution evidence (process settlement; not workspace cleanup or task acceptance):\n```json\n";
-var DIR_FLAGS = constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK;
-var FILE_FLAGS = constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK;
-var digest = (bytes) => createHash4("sha256").update(bytes).digest("hex");
-function check3(ok, message) {
+var DIR_FLAGS = constants3.O_RDONLY | constants3.O_DIRECTORY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK;
+var FILE_FLAGS = constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK;
+var digest = (bytes) => createHash6("sha256").update(bytes).digest("hex");
+function check5(ok, message) {
   if (!ok) throw new TypeError(message);
 }
-function object(value, name) {
-  check3(value !== null && typeof value === "object" && !Array.isArray(value), `${name} must be an object`);
+function object2(value, name) {
+  check5(value !== null && typeof value === "object" && !Array.isArray(value), `${name} must be an object`);
 }
-function keys3(value, expected, name) {
-  object(value, name);
-  check3(isDeepStrictEqual(Object.keys(value).sort(), [...expected].sort()), `${name} has unsupported or missing fields`);
+function keys5(value, expected, name) {
+  object2(value, name);
+  check5(isDeepStrictEqual2(Object.keys(value).sort(), [...expected].sort()), `${name} has unsupported or missing fields`);
 }
 function string(value, name, nullable = false) {
   if (nullable && value === null) return;
-  check3(typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0"), `${name} must be a bounded nonempty string`);
+  check5(typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0"), `${name} must be a bounded nonempty string`);
 }
 function publicText(value, name) {
-  check3(typeof value === "string", name + " must be a string");
+  check5(typeof value === "string", name + " must be a string");
 }
-function hash2(value, name, nullable = false) {
-  check3(nullable && value === null || typeof value === "string" && HASH.test(value), `${name} must be a lowercase SHA-256`);
+function hash3(value, name, nullable = false) {
+  check5(nullable && value === null || typeof value === "string" && HASH.test(value), `${name} must be a lowercase SHA-256`);
 }
 function integer(value, name, min = 0) {
-  check3(Number.isSafeInteger(value) && value >= min, `${name} must be a bounded integer`);
+  check5(Number.isSafeInteger(value) && value >= min, `${name} must be a bounded integer`);
 }
 function enumeration(value, allowed, name) {
-  check3(allowed.includes(value), `${name} has an unsupported value`);
+  check5(allowed.includes(value), `${name} has an unsupported value`);
 }
 function array(value, name, max = 64) {
-  check3(Array.isArray(value) && value.length <= max, `${name} must be a bounded array`);
+  check5(Array.isArray(value) && value.length <= max, `${name} must be a bounded array`);
 }
 function canonicalPath(path, name) {
   string(path, name);
-  check3(isAbsolute2(path) && normalize3(path) === path && (path === "/" || !path.endsWith("/")), `${name} must be canonical and absolute`);
-  check3(path.split("/").length <= 128, `${name} exceeds directory depth limit`);
+  check5(isAbsolute4(path) && normalize4(path) === path && (path === "/" || !path.endsWith("/")), `${name} must be canonical and absolute`);
+  check5(path.split("/").length <= 128, `${name} exceeds directory depth limit`);
 }
 function metadata(stat2) {
   return ["dev", "ino", "mode", "uid", "gid", "size", "mtimeNs", "ctimeNs"].map((key) => stat2[key].toString()).join(":");
@@ -1806,7 +2363,7 @@ function metadata(stat2) {
 function identity(stat2) {
   return ["dev", "ino", "mode"].map((key) => stat2[key].toString()).join(":");
 }
-function json2(bytes, name) {
+function json3(bytes, name) {
   try {
     return JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes));
   } catch {
@@ -1822,10 +2379,10 @@ var EvidenceReader = class {
     this.root = root;
   }
   async directory(parent, component, path, stable = false) {
-    const handle = await open3(parent ? `/proc/self/fd/${parent.handle.fd}/${component}` : "/", DIR_FLAGS);
+    const handle = await open4(parent ? `/proc/self/fd/${parent.handle.fd}/${component}` : "/", DIR_FLAGS);
     try {
       const stat2 = await handle.stat({ bigint: true });
-      check3(stat2.isDirectory(), "Evidence path component is not a directory");
+      check5(stat2.isDirectory(), "Evidence path component is not a directory");
       const record = { handle, parent, component, path, metadata: metadata(stat2), identity: identity(stat2), stable };
       this.directories.push(record);
       return record;
@@ -1846,27 +2403,27 @@ var EvidenceReader = class {
   }
   async read(path, limit = MAX_PUBLIC_SOURCE_FILE_BYTES) {
     canonicalPath(path, "Copied evidence path");
-    const capturePath = dirname(path), captureId = basename(capturePath);
-    check3(dirname(capturePath) === this.root && UUID.test(captureId), "Copied evidence must be directly inside a capture directory beneath the evidence root");
+    const capturePath = dirname2(path), captureId = basename(capturePath);
+    check5(dirname2(capturePath) === this.root && UUID.test(captureId), "Copied evidence must be directly inside a capture directory beneath the evidence root");
     const cached = this.files.get(path);
     if (cached) {
-      check3(cached.bytes.length <= limit, "Evidence file exceeds its byte limit");
+      check5(cached.bytes.length <= limit, "Evidence file exceeds its byte limit");
       return cached.bytes;
     }
-    check3(this.files.size < MAX_PUBLIC_SOURCE_FILES, "Evidence file-count limit exceeded");
+    check5(this.files.size < MAX_PUBLIC_SOURCE_FILES, "Evidence file-count limit exceeded");
     let directory = this.captures.get(captureId);
     if (!directory) {
       directory = await this.directory(this.rootDirectory, captureId, capturePath, true);
       this.captures.set(captureId, directory);
     }
     const name = basename(path);
-    const handle = await open3(`/proc/self/fd/${directory.handle.fd}/${name}`, FILE_FLAGS);
+    const handle = await open4(`/proc/self/fd/${directory.handle.fd}/${name}`, FILE_FLAGS);
     try {
       const before = await handle.stat({ bigint: true });
-      check3(before.isFile(), "Evidence must be an ordinary file");
-      check3(before.size <= BigInt(limit), "Evidence file exceeds its byte limit");
+      check5(before.isFile(), "Evidence must be an ordinary file");
+      check5(before.size <= BigInt(limit), "Evidence file exceeds its byte limit");
       const size = Number(before.size);
-      check3(this.totalBytes + size <= MAX_PUBLIC_SOURCE_TOTAL_BYTES, "Evidence total-byte limit exceeded");
+      check5(this.totalBytes + size <= MAX_PUBLIC_SOURCE_TOTAL_BYTES, "Evidence total-byte limit exceeded");
       const buffer = Buffer.alloc(size + 1);
       let length = 0;
       while (length < buffer.length) {
@@ -1874,8 +2431,8 @@ var EvidenceReader = class {
         if (!result.bytesRead) break;
         length += result.bytesRead;
       }
-      check3(length === size, "Evidence file changed size while reading");
-      check3(metadata(await handle.stat({ bigint: true })) === metadata(before), "Evidence file metadata changed while reading");
+      check5(length === size, "Evidence file changed size while reading");
+      check5(metadata(await handle.stat({ bigint: true })) === metadata(before), "Evidence file metadata changed while reading");
       const bytes = buffer.subarray(0, length);
       this.files.set(path, { handle, directory, name, metadata: metadata(before), bytes });
       this.totalBytes += length;
@@ -1888,19 +2445,19 @@ var EvidenceReader = class {
   async stable() {
     for (const directory of this.directories) {
       const current = await directory.handle.stat({ bigint: true });
-      check3(identity(current) === directory.identity && (!directory.stable || metadata(current) === directory.metadata), "Evidence directory changed during verification");
-      const reopened = await open3(directory.parent ? `/proc/self/fd/${directory.parent.handle.fd}/${directory.component}` : "/", DIR_FLAGS);
+      check5(identity(current) === directory.identity && (!directory.stable || metadata(current) === directory.metadata), "Evidence directory changed during verification");
+      const reopened = await open4(directory.parent ? `/proc/self/fd/${directory.parent.handle.fd}/${directory.component}` : "/", DIR_FLAGS);
       try {
-        check3(identity(await reopened.stat({ bigint: true })) === directory.identity, "Evidence directory path changed during verification");
+        check5(identity(await reopened.stat({ bigint: true })) === directory.identity, "Evidence directory path changed during verification");
       } finally {
         await reopened.close();
       }
     }
     for (const file of this.files.values()) {
-      check3(metadata(await file.handle.stat({ bigint: true })) === file.metadata, "Evidence file changed during verification");
-      const reopened = await open3(`/proc/self/fd/${file.directory.handle.fd}/${file.name}`, FILE_FLAGS);
+      check5(metadata(await file.handle.stat({ bigint: true })) === file.metadata, "Evidence file changed during verification");
+      const reopened = await open4(`/proc/self/fd/${file.directory.handle.fd}/${file.name}`, FILE_FLAGS);
       try {
-        check3(metadata(await reopened.stat({ bigint: true })) === file.metadata, "Evidence file path changed during verification");
+        check5(metadata(await reopened.stat({ bigint: true })) === file.metadata, "Evidence file path changed during verification");
       } finally {
         await reopened.close();
       }
@@ -1912,221 +2469,221 @@ var EvidenceReader = class {
   }
 };
 function requestedRow(row, index, tool) {
-  keys3(row, ["ordinal", "agent", "requestedDefinitionId", "definitionId", "executionId"], "Requested row");
-  check3(row.ordinal === index + 1, "Requested ordinals must be a contiguous ordered sequence");
+  keys5(row, ["ordinal", "agent", "requestedDefinitionId", "definitionId", "executionId"], "Requested row");
+  check5(row.ordinal === index + 1, "Requested ordinals must be a contiguous ordered sequence");
   string(row.agent, "Requested agent", true);
-  hash2(row.requestedDefinitionId, "Requested definition identity", true);
-  hash2(row.definitionId, "Observed definition identity", true);
+  hash3(row.requestedDefinitionId, "Requested definition identity", true);
+  hash3(row.definitionId, "Observed definition identity", true);
   string(row.executionId, "Execution identity", tool === "delegate_describe");
-  check3(row.definitionId === null || row.agent !== null, "An observed definition must identify its agent");
-  if (tool === "delegate_describe") check3(row.executionId === null && row.requestedDefinitionId === null && row.agent !== null && row.definitionId !== null, "Describe has a definition but no execution/requested definition identity");
+  check5(row.definitionId === null || row.agent !== null, "An observed definition must identify its agent");
+  if (tool === "delegate_describe") check5(row.executionId === null && row.requestedDefinitionId === null && row.agent !== null && row.definitionId !== null, "Describe has a definition but no execution/requested definition identity");
 }
 function finalIdentity(final) {
-  keys3(final, ["state", "sessionId", "messageId", "leafId", "sha256"], "Native final");
-  check3(final.state === "complete", "Native final must be complete");
+  keys5(final, ["state", "sessionId", "messageId", "leafId", "sha256"], "Native final");
+  check5(final.state === "complete", "Native final must be complete");
   for (const key of ["sessionId", "messageId", "leafId"]) string(final[key], "Native final " + key);
-  hash2(final.sha256, "Native final hash");
+  hash3(final.sha256, "Native final hash");
 }
 function workerIdentity(value, executionId) {
-  keys3(value, ["revision", "executionId", "nonce", "root", "rootDevice", "rootInode", "bootId", "pidNamespace", "helperPid", "helperStartTicks", "helperSha256", "workerPid", "ownershipPath", "receiptPath"], "Cleanup identity");
-  check3(value.revision === 1 && value.executionId === executionId, "Cleanup identity must bind the requested execution");
+  keys5(value, ["revision", "executionId", "nonce", "root", "rootDevice", "rootInode", "bootId", "pidNamespace", "helperPid", "helperStartTicks", "helperSha256", "workerPid", "ownershipPath", "receiptPath"], "Cleanup identity");
+  check5(value.revision === 1 && value.executionId === executionId, "Cleanup identity must bind the requested execution");
   for (const key of ["executionId", "nonce", "root", "rootDevice", "rootInode", "bootId", "pidNamespace", "helperStartTicks", "ownershipPath", "receiptPath"]) string(value[key], "Cleanup identity " + key);
   integer(value.helperPid, "Helper pid", 1);
   integer(value.workerPid, "Worker pid");
-  hash2(value.helperSha256, "Helper hash");
+  hash3(value.helperSha256, "Helper hash");
 }
 function cleanup(value, executionId) {
   if (value === null) return;
-  object(value, "Cleanup");
+  object2(value, "Cleanup");
   if (value.state === "not-started" || value.state === "unknown") {
     const fields = ["state", "reason"];
     if (value.state === "unknown" && Object.hasOwn(value, "identity")) fields.push("identity");
-    keys3(value, fields, "Cleanup");
+    keys5(value, fields, "Cleanup");
     publicText(value.reason, "Cleanup reason");
     if (Object.hasOwn(value, "identity")) workerIdentity(value.identity, executionId);
     return;
   }
-  keys3(value, ["state", "identity", "receipt"], "Cleanup");
-  check3(value.state === "settled", "Unsupported cleanup state");
+  keys5(value, ["state", "identity", "receipt"], "Cleanup");
+  check5(value.state === "settled", "Unsupported cleanup state");
   workerIdentity(value.identity, executionId);
-  keys3(value.receipt, ["state", "identity", "workerCode", "workerSignal", "reason", "reapedAll"], "Cleanup receipt");
-  check3(value.receipt.state === "settled" && value.receipt.reapedAll === true && isDeepStrictEqual(value.receipt.identity, value.identity), "Cleanup receipt identity or settlement mismatch");
+  keys5(value.receipt, ["state", "identity", "workerCode", "workerSignal", "reason", "reapedAll"], "Cleanup receipt");
+  check5(value.receipt.state === "settled" && value.receipt.reapedAll === true && isDeepStrictEqual2(value.receipt.identity, value.identity), "Cleanup receipt identity or settlement mismatch");
   if (value.receipt.workerCode !== null) integer(value.receipt.workerCode, "Worker exit code");
   integer(value.receipt.workerSignal, "Worker signal");
   enumeration(value.receipt.reason, ["worker-exit", "owner-loss", "cancelled", "helper-signal", "ownership-write-failed", "start-failed"], "Cleanup receipt reason");
 }
 function runtimeOutcome(outcome, index, requested) {
-  keys3(outcome, ["ordinal", "ok", "work", "control", "reason", "exitCode", "timedOut", "aborted", "truncated", "spawnFailed", "final", "cleanup", "observation", "retention"], "Runtime outcome");
-  check3(outcome.ordinal === index + 1, "Runtime ordinals must follow requested order");
-  check3(typeof outcome.ok === "boolean", "Runtime ok must be boolean");
+  keys5(outcome, ["ordinal", "ok", "work", "control", "reason", "exitCode", "timedOut", "aborted", "truncated", "spawnFailed", "final", "cleanup", "observation", "retention"], "Runtime outcome");
+  check5(outcome.ordinal === index + 1, "Runtime ordinals must follow requested order");
+  check5(typeof outcome.ok === "boolean", "Runtime ok must be boolean");
   enumeration(outcome.work, [null, "succeeded", "failed", "unknown"], "Work state");
   enumeration(outcome.control, [null, "failed"], "Control state");
   if (outcome.reason !== null) publicText(outcome.reason, "Runtime reason");
   if (outcome.exitCode !== null) integer(outcome.exitCode, "Runtime exit code");
-  for (const key of ["timedOut", "aborted", "truncated", "spawnFailed"]) check3(outcome[key] === null || typeof outcome[key] === "boolean", "Runtime flags must be nullable booleans");
+  for (const key of ["timedOut", "aborted", "truncated", "spawnFailed"]) check5(outcome[key] === null || typeof outcome[key] === "boolean", "Runtime flags must be nullable booleans");
   if (outcome.final !== null) {
-    object(outcome.final, "Runtime final");
+    object2(outcome.final, "Runtime final");
     if (outcome.final.state === "unavailable") {
-      keys3(outcome.final, ["state", "reason"], "Unavailable final");
+      keys5(outcome.final, ["state", "reason"], "Unavailable final");
       publicText(outcome.final.reason, "Unavailable final reason");
     } else finalIdentity(outcome.final);
   }
   cleanup(outcome.cleanup, requested.executionId);
   if (outcome.observation !== null) {
-    keys3(outcome.observation, ["state", "reasons"], "Observation");
+    keys5(outcome.observation, ["state", "reasons"], "Observation");
     enumeration(outcome.observation.state, ["complete", "incomplete"], "Observation state");
     array(outcome.observation.reasons, "Observation reasons");
     for (const reason of outcome.observation.reasons) publicText(reason, "Observation reason");
   }
   if (outcome.retention !== null) {
-    keys3(outcome.retention, ["status"], "Retention");
+    keys5(outcome.retention, ["status"], "Retention");
     enumeration(outcome.retention.status, ["disabled", "pending", "retained", "lost"], "Retention status");
   }
 }
 function binding(value) {
   if (value === null) return;
-  keys3(value, ["package", "phase"], "Definition binding");
-  check3(value.package === "principal-pi-skills", "Unsupported definition binding package");
+  keys5(value, ["package", "phase"], "Definition binding");
+  check5(value.package === "principal-pi-skills", "Unsupported definition binding package");
   string(value.phase, "Definition phase");
 }
-async function capture(reader, reference) {
-  keys3(reference, ["path", "sha256"], "Manifest reference");
-  hash2(reference.sha256, "Manifest hash");
-  const manifestBytes = await reader.read(reference.path, MAX_PUBLIC_SOURCE_MANIFEST_BYTES);
-  check3(digest(manifestBytes) === reference.sha256, "Manifest hash mismatch");
-  const manifest = json2(manifestBytes, "Manifest");
-  keys3(manifest, ["schema", "version", "captureId", "ownerId", "toolCallId", "tool", "state", "response", "requested", "runtimeEvidence", "finals", "definitions"], "Public manifest");
-  check3(manifest.schema === "pi-daddy-public-evidence-v1" && manifest.version === 1 && manifest.state === "returned", "Unsupported public manifest version or state");
-  check3(UUID.test(manifest.captureId) && UUID.test(manifest.ownerId), "Capture/owner identity must be a UUID");
+async function capture(reader, reference2) {
+  keys5(reference2, ["path", "sha256"], "Manifest reference");
+  hash3(reference2.sha256, "Manifest hash");
+  const manifestBytes = await reader.read(reference2.path, MAX_PUBLIC_SOURCE_MANIFEST_BYTES);
+  check5(digest(manifestBytes) === reference2.sha256, "Manifest hash mismatch");
+  const manifest = json3(manifestBytes, "Manifest");
+  keys5(manifest, ["schema", "version", "captureId", "ownerId", "toolCallId", "tool", "state", "response", "requested", "runtimeEvidence", "finals", "definitions"], "Public manifest");
+  check5(manifest.schema === "pi-daddy-public-evidence-v1" && manifest.version === 1 && manifest.state === "returned", "Unsupported public manifest version or state");
+  check5(UUID.test(manifest.captureId) && UUID.test(manifest.ownerId), "Capture/owner identity must be a UUID");
   string(manifest.toolCallId, "Tool-call identity");
   enumeration(manifest.tool, TOOLS, "Tool");
-  const directory = join3(reader.root, manifest.captureId);
-  check3(reference.path === join3(directory, "manifest.json"), "Manifest path does not bind its capture identity");
-  const refs = [{ kind: "manifest", ...reference, bytes: manifestBytes.length }];
-  const seen = /* @__PURE__ */ new Set([reference.path]);
+  const directory = join6(reader.root, manifest.captureId);
+  check5(reference2.path === join6(directory, "manifest.json"), "Manifest path does not bind its capture identity");
+  const refs = [{ kind: "manifest", ...reference2, bytes: manifestBytes.length }];
+  const seen = /* @__PURE__ */ new Set([reference2.path]);
   async function copied(ref, filename, kind) {
-    keys3(ref, ["path", "sha256", "bytes"], "Copied reference");
-    hash2(ref.sha256, "Copied hash");
+    keys5(ref, ["path", "sha256", "bytes"], "Copied reference");
+    hash3(ref.sha256, "Copied hash");
     integer(ref.bytes, "Copied byte count");
-    check3(ref.path === join3(directory, filename) && !seen.has(ref.path), "Copied reference path is foreign or reused");
+    check5(ref.path === join6(directory, filename) && !seen.has(ref.path), "Copied reference path is foreign or reused");
     seen.add(ref.path);
-    check3(ref.bytes <= MAX_PUBLIC_SOURCE_FILE_BYTES, "Copied reference exceeds file-byte limit");
+    check5(ref.bytes <= MAX_PUBLIC_SOURCE_FILE_BYTES, "Copied reference exceeds file-byte limit");
     const bytes = await reader.read(ref.path);
-    check3(bytes.length === ref.bytes && digest(bytes) === ref.sha256, "Copied reference byte count or hash mismatch");
+    check5(bytes.length === ref.bytes && digest(bytes) === ref.sha256, "Copied reference byte count or hash mismatch");
     refs.push({ kind, ...ref });
     return bytes;
   }
   array(manifest.requested, "Requested", 8);
-  check3(manifest.requested.length > 0, "Capture must identify a requested row");
-  if (manifest.tool === "delegate" || manifest.tool === "delegate_describe") check3(manifest.requested.length === 1, "Single tool requires one requested row");
+  check5(manifest.requested.length > 0, "Capture must identify a requested row");
+  if (manifest.tool === "delegate" || manifest.tool === "delegate_describe") check5(manifest.requested.length === 1, "Single tool requires one requested row");
   manifest.requested.forEach((row, index) => requestedRow(row, index, manifest.tool));
   const executionIds = manifest.requested.map((row) => row.executionId).filter((value) => value !== null);
-  check3(new Set(executionIds).size === executionIds.length, "Requested execution identities must be unique");
-  const response = json2(await copied(manifest.response, "response.json", "response"), "Public response");
-  keys3(response, ["isError", "content"], "Public response");
-  check3(typeof response.isError === "boolean", "Public isError must be boolean");
+  check5(new Set(executionIds).size === executionIds.length, "Requested execution identities must be unique");
+  const response = json3(await copied(manifest.response, "response.json", "response"), "Public response");
+  keys5(response, ["isError", "content"], "Public response");
+  check5(typeof response.isError === "boolean", "Public isError must be boolean");
   array(response.content, "Public content", 2);
   for (const block of response.content) {
-    keys3(block, ["type", "text"], "Public block");
-    check3(block.type === "text" && typeof block.text === "string", "Only public text blocks are supported");
+    keys5(block, ["type", "text"], "Public block");
+    check5(block.type === "text" && typeof block.text === "string", "Only public text blocks are supported");
   }
   array(manifest.finals, "Final copies", 8);
   array(manifest.definitions, "Definition copies", 8);
   let outcomes = [];
   if (manifest.tool === "delegate_describe") {
-    check3(manifest.runtimeEvidence === null && manifest.finals.length === 0 && response.content.length === 1 && response.isError === false, "Describe capture has no runtime/final outcome");
+    check5(manifest.runtimeEvidence === null && manifest.finals.length === 0 && response.content.length === 1 && response.isError === false, "Describe capture has no runtime/final outcome");
   } else {
     const runtime = manifest.runtimeEvidence;
-    keys3(runtime, ["version", "tool", "requested", "outcomes"], "Runtime evidence");
-    check3(runtime.version === 1 && runtime.tool === manifest.tool && runtime.requested === manifest.requested.length, "Runtime header does not match capture");
+    keys5(runtime, ["version", "tool", "requested", "outcomes"], "Runtime evidence");
+    check5(runtime.version === 1 && runtime.tool === manifest.tool && runtime.requested === manifest.requested.length, "Runtime header does not match capture");
     array(runtime.outcomes, "Runtime outcomes", 8);
     outcomes = runtime.outcomes;
-    check3(outcomes.length > 0 && outcomes.length <= manifest.requested.length, "Runtime outcome count is invalid");
-    if (manifest.tool !== "delegate_chain") check3(outcomes.length === manifest.requested.length, "Non-chain captures must retain every outcome");
+    check5(outcomes.length > 0 && outcomes.length <= manifest.requested.length, "Runtime outcome count is invalid");
+    if (manifest.tool !== "delegate_chain") check5(outcomes.length === manifest.requested.length, "Non-chain captures must retain every outcome");
     outcomes.forEach((outcome, index) => runtimeOutcome(outcome, index, manifest.requested[index]));
-    check3(response.content.length === 2 && response.content[1].text.startsWith(RUNTIME_PREFIX) && response.content[1].text.endsWith("\n```"), "Public response lacks its exact runtime evidence block");
-    const projection = json2(Buffer.from(response.content[1].text.slice(RUNTIME_PREFIX.length, -4)), "Public runtime projection");
-    check3(isDeepStrictEqual(projection, runtime), "Public runtime projection differs from manifest");
+    check5(response.content.length === 2 && response.content[1].text.startsWith(RUNTIME_PREFIX) && response.content[1].text.endsWith("\n```"), "Public response lacks its exact runtime evidence block");
+    const projection = json3(Buffer.from(response.content[1].text.slice(RUNTIME_PREFIX.length, -4)), "Public runtime projection");
+    check5(isDeepStrictEqual2(projection, runtime), "Public runtime projection differs from manifest");
     const failed = outcomes.some((outcome) => !outcome.ok || outcome.control === "failed");
-    if (manifest.tool !== "delegate_chain") check3(response.isError === failed, "Public isError differs from runtime outcome");
-    else if (failed || outcomes.length < manifest.requested.length || outcomes.some((outcome) => outcome.final?.state === "unavailable")) check3(response.isError, "Stopped chain must remain an error response");
-    check3(manifest.finals.length === outcomes.length, "Every returned outcome must retain its final availability");
+    if (manifest.tool !== "delegate_chain") check5(response.isError === failed, "Public isError differs from runtime outcome");
+    else if (failed || outcomes.length < manifest.requested.length || outcomes.some((outcome) => outcome.final?.state === "unavailable")) check5(response.isError, "Stopped chain must remain an error response");
+    check5(manifest.finals.length === outcomes.length, "Every returned outcome must retain its final availability");
   }
   for (const [index, row] of manifest.finals.entries()) {
-    keys3(row, ["ordinal", "executionId", "final"], "Final copy row");
-    check3(row.ordinal === index + 1 && row.executionId === manifest.requested[index].executionId, "Final copy identity differs from requested execution");
+    keys5(row, ["ordinal", "executionId", "final"], "Final copy row");
+    check5(row.ordinal === index + 1 && row.executionId === manifest.requested[index].executionId, "Final copy identity differs from requested execution");
     const final = outcomes[index].final;
     if (final?.state !== "complete") {
-      check3(row.final === null, "Unavailable native final cannot have a complete copy");
+      check5(row.final === null, "Unavailable native final cannot have a complete copy");
       continue;
     }
-    keys3(row.final, ["state", "sessionId", "messageId", "leafId", "sha256", "content"], "Final copy");
+    keys5(row.final, ["state", "sessionId", "messageId", "leafId", "sha256", "content"], "Final copy");
     const { content, ...identity2 } = row.final;
-    check3(isDeepStrictEqual(identity2, final), "Final copy identity differs from runtime final");
+    check5(isDeepStrictEqual2(identity2, final), "Final copy identity differs from runtime final");
     const bytes = await copied(content, `outcome-${row.ordinal}-final.txt`, "final");
-    check3(bytes.length > 0 && digest(bytes) === final.sha256, "Final copy differs from native final hash");
-    check3(Buffer.from(response.content[0].text, "utf8").includes(bytes), "Complete final bytes are absent from authored public content");
+    check5(bytes.length > 0 && digest(bytes) === final.sha256, "Final copy differs from native final hash");
+    check5(Buffer.from(response.content[0].text, "utf8").includes(bytes), "Complete final bytes are absent from authored public content");
   }
   const expectedDefinitions = manifest.requested.filter((row) => row.definitionId !== null).map((row) => JSON.stringify([row.agent, row.definitionId])).sort();
   const observedDefinitions = [];
   for (const [index, definition] of manifest.definitions.entries()) {
-    keys3(definition, ["agent", "definitionId", "sourceHash", "bodySha256", "binding", "resources", "body"], "Definition copy");
+    keys5(definition, ["agent", "definitionId", "sourceHash", "bodySha256", "binding", "resources", "body"], "Definition copy");
     string(definition.agent, "Definition agent");
-    hash2(definition.definitionId, "Definition identity");
-    hash2(definition.sourceHash, "Definition source hash", true);
-    hash2(definition.bodySha256, "Definition body hash");
+    hash3(definition.definitionId, "Definition identity");
+    hash3(definition.sourceHash, "Definition source hash", true);
+    hash3(definition.bodySha256, "Definition body hash");
     binding(definition.binding);
     observedDefinitions.push(JSON.stringify([definition.agent, definition.definitionId]));
     array(definition.resources, "Definition resources");
-    check3(definition.resources.length > 0, "Definition source resources are missing");
+    check5(definition.resources.length > 0, "Definition source resources are missing");
     for (const [resourceIndex, resource] of definition.resources.entries()) {
-      keys3(resource, ["kind", "path", "copy"], "Definition resource");
+      keys5(resource, ["kind", "path", "copy"], "Definition resource");
       enumeration(resource.kind, ["selected-skill", "package", "binding-manifest", "delegated-agent"], "Source kind");
       string(resource.path, "Original source identity");
       await copied(resource.copy, `definition-${index}-source-${resourceIndex}.bin`, "source-copy");
     }
     const body = await copied(definition.body, `definition-${index}-body.txt`, "definition-body");
-    check3(digest(body) === definition.bodySha256, "Definition body copy differs from bodySha256");
+    check5(digest(body) === definition.bodySha256, "Definition body copy differs from bodySha256");
   }
-  check3(isDeepStrictEqual(observedDefinitions.sort(), expectedDefinitions), "Copied definitions differ from observed requested definitions");
+  check5(isDeepStrictEqual2(observedDefinitions.sort(), expectedDefinitions), "Copied definitions differ from observed requested definitions");
   if (manifest.tool === "delegate_describe") {
-    const described = json2(Buffer.from(response.content[0].text), "Described definition");
+    const described = json3(Buffer.from(response.content[0].text), "Described definition");
     const definition = manifest.definitions[0];
     const expected = { version: 1, agent: definition.agent, bodySha256: definition.bodySha256, binding: definition.binding, definitionId: definition.definitionId };
     if (Object.hasOwn(described, "sourceHash")) expected.sourceHash = definition.sourceHash;
-    else check3(definition.sourceHash === null, "Described source hash is missing");
-    check3(isDeepStrictEqual(described, expected), "Described definition differs from manifest source/body identity");
+    else check5(definition.sourceHash === null, "Described source hash is missing");
+    check5(isDeepStrictEqual2(described, expected), "Described definition differs from manifest source/body identity");
   }
   return { manifest, refs, responseIsError: response.isError, outcomes };
 }
 async function verifySources(cases, selection, evidenceRoot) {
-  check3(process.platform === "linux", "Public source verification requires Linux held-directory-FD reads");
+  check5(process.platform === "linux", "Public source verification requires Linux held-directory-FD reads");
   canonicalPath(evidenceRoot, "Evidence root");
-  check3(evidenceRoot !== "/", "Evidence root cannot be the filesystem root");
+  check5(evidenceRoot !== "/", "Evidence root cannot be the filesystem root");
   array(cases, "Cases", 100);
   const raw = cases.map((item) => {
-    keys3(item, ["id", "input", "question", "provenance", "source", "visibility", "hash"], "Parsed case");
+    keys5(item, ["id", "input", "question", "provenance", "source", "visibility", "hash"], "Parsed case");
     const { hash: ignored, ...original } = item;
     return original;
   });
   const validated = parseCases({ schema: 1, cases: raw });
-  validated.forEach((item, index) => check3(item.hash === cases[index].hash, "Incoming parsed case hash is stale"));
-  keys3(selection, ["schema", "kind", "selections"], "Source selection");
-  check3(selection.schema === 1 && selection.kind === "decision-public-sources", "Unsupported source selection version");
+  validated.forEach((item, index) => check5(item.hash === cases[index].hash, "Incoming parsed case hash is stale"));
+  keys5(selection, ["schema", "kind", "selections"], "Source selection");
+  check5(selection.schema === 1 && selection.kind === "decision-public-sources", "Unsupported source selection version");
   array(selection.selections, "Selections", 100);
-  check3(selection.selections.length === validated.length, "Require exactly one ordered selection per case");
+  check5(selection.selections.length === validated.length, "Require exactly one ordered selection per case");
   for (const [index, row] of selection.selections.entries()) {
-    keys3(row, ["caseId", "caseHash", "manifest", "captureId", "toolCallId", "ordinal", "agent", "definitionId", "executionId"], "Source selection row");
+    keys5(row, ["caseId", "caseHash", "manifest", "captureId", "toolCallId", "ordinal", "agent", "definitionId", "executionId"], "Source selection row");
     const item = validated[index];
-    check3(row.caseId === item.id && row.caseHash === item.hash, "Selections must match exact ordered case identities");
-    keys3(row.manifest, ["path", "sha256"], "Manifest selection");
-    hash2(row.manifest.sha256, "Selected manifest hash");
-    check3(item.source.sha256 === row.manifest.sha256 && item.source.recordId === row.toolCallId, "Case source must bind the manifest hash and tool-call identity");
-    check3(UUID.test(row.captureId), "Selected capture identity must be a UUID");
+    check5(row.caseId === item.id && row.caseHash === item.hash, "Selections must match exact ordered case identities");
+    keys5(row.manifest, ["path", "sha256"], "Manifest selection");
+    hash3(row.manifest.sha256, "Selected manifest hash");
+    check5(item.source.sha256 === row.manifest.sha256 && item.source.recordId === row.toolCallId, "Case source must bind the manifest hash and tool-call identity");
+    check5(UUID.test(row.captureId), "Selected capture identity must be a UUID");
     string(row.toolCallId, "Selected tool-call identity");
     integer(row.ordinal, "Selected ordinal", 1);
     string(row.agent, "Selected agent", true);
-    hash2(row.definitionId, "Selected observed definition identity", true);
+    hash3(row.definitionId, "Selected observed definition identity", true);
     string(row.executionId, "Selected execution identity", true);
   }
   const reader = new EvidenceReader(evidenceRoot);
@@ -2139,11 +2696,11 @@ async function verifySources(cases, selection, evidenceRoot) {
         verified = await capture(reader, row.manifest);
         captures.set(row.manifest.path, verified);
       }
-      check3(verified.refs[0].sha256 === row.manifest.sha256, "Repeated manifest selections disagree on hash");
+      check5(verified.refs[0].sha256 === row.manifest.sha256, "Repeated manifest selections disagree on hash");
       const { manifest, refs, outcomes } = verified;
-      check3(manifest.captureId === row.captureId && manifest.toolCallId === row.toolCallId, "Selected capture/tool-call identity mismatch");
+      check5(manifest.captureId === row.captureId && manifest.toolCallId === row.toolCallId, "Selected capture/tool-call identity mismatch");
       const requested = manifest.requested[row.ordinal - 1];
-      check3(requested !== void 0 && ["ordinal", "agent", "definitionId", "executionId"].every((key) => requested[key] === row[key]), "Selected requested row identity mismatch");
+      check5(requested !== void 0 && ["ordinal", "agent", "definitionId", "executionId"].every((key) => requested[key] === row[key]), "Selected requested row identity mismatch");
       const outcome = outcomes[row.ordinal - 1];
       rows.push({
         caseId: row.caseId,
@@ -2178,7 +2735,7 @@ async function verifySources(cases, selection, evidenceRoot) {
       status: "verified-bytes-and-record-identities",
       platform: "linux",
       evidenceRoot,
-      limits: { ...LIMITS },
+      limits: { ...LIMITS2 },
       artifactCount: reader.files.size,
       totalBytes: reader.totalBytes,
       captureCount: captures.size,
@@ -2212,7 +2769,9 @@ var help = `Decision research workflow (Node >=20; qualified Pi execution needs
   preview-pi --cases FILE --experiment FILE --model openai-codex:MODEL --thinking LEVEL --split test
   run-pi --cases FILE --experiment FILE --model openai-codex:MODEL --thinking LEVEL --split test --pi-package DIR --out NEW.jsonl --allow-subscription [--pi-node PATH] [--auth-path FILE] [--timeout-ms N]
   compare --cases FILE --experiment FILE --labels FILE --label-evidence FILE --run FILE [--run FILE] --out NEW.json
+  collections [--root ABSOLUTE_DIR]
   import-session --cases FILE --selection FILE --consent FILE --entry FILE --out NEW.json
+  import-workflow --cases FILE --selection FILE --consent FILE --entry FILE --out NEW.json
   export-learning --cases FILE --experiment FILE --labels FILE --label-evidence FILE --consents FILE --mode fixture-demo|reviewed-data --out NEW_DIR
 
 JEV run asks this session whether to retain selected data for later LoRA review.
@@ -2230,6 +2789,7 @@ function argumentsFor(argv) {
   if (!command || command === "--help") return { command: "help", flags: {} };
   const commands = {
     ...RESEARCH_OPTIONS,
+    collections: [],
     preview: ["cases", "provider", "model"],
     run: ["cases", "provider", "model", "out", "allow-remote"],
     score: ["cases", "labels", "run"],
@@ -2239,7 +2799,7 @@ function argumentsFor(argv) {
   if (!Object.hasOwn(commands, command))
     throw new Error("Unknown command; use --help.");
   const required = commands[command];
-  const optional = command === "run" ? ["storage", "session-id"] : RESEARCH_OPTIONAL[command] ?? [];
+  const optional = command === "run" ? ["storage", "session-id"] : command === "collections" ? ["root"] : RESEARCH_OPTIONAL[command] ?? [];
   const allowed = [...required, ...optional];
   const flags = {};
   for (let i = 0; i < rest.length; i++) {
@@ -2278,21 +2838,21 @@ async function textFile(path) {
   }
 }
 async function jsonFile(path) {
-  const text2 = await textFile(path);
+  const text4 = await textFile(path);
   try {
-    return JSON.parse(text2);
+    return JSON.parse(text4);
   } catch {
     throw new Error("Invalid JSON input file.");
   }
 }
-function sha256(text2) {
-  return createHash5("sha256").update(text2, "utf8").digest("hex");
+function sha2562(text4) {
+  return createHash7("sha256").update(text4, "utf8").digest("hex");
 }
 function caseSetHash(cases) {
-  return sha256(JSON.stringify(cases.map((c) => ({ id: c.id, hash: c.hash }))));
+  return sha2562(JSON.stringify(cases.map((c) => ({ id: c.id, hash: c.hash }))));
 }
 function labelSetHash(labels) {
-  return sha256(
+  return sha2562(
     JSON.stringify(
       [...labels].sort(
         (a, b) => a.caseId < b.caseId ? -1 : a.caseId > b.caseId ? 1 : 0
@@ -2305,26 +2865,35 @@ function validCreatedAt(value) {
 }
 async function readRun(path, cases) {
   let rows;
-  const text2 = await textFile(path);
+  const text4 = await textFile(path);
   try {
-    rows = text2.trimEnd().split("\n").map((line) => JSON.parse(line));
+    rows = text4.trimEnd().split("\n").map((line) => JSON.parse(line));
   } catch {
     throw new Error("Invalid run JSONL; retain damaged evidence separately.");
   }
   const [header, ...records] = rows;
-  if (header?.schema !== 1 || header.kind !== "decision-shadow-run" || header.caseSetHash !== caseSetHash(cases) || header.caseCount !== cases.length || header.trainingEligible !== false || !validCreatedAt(header.createdAt) || !Object.hasOwn(terms, header.provider))
+  if (!(header?.schema === 1 && header.kind === "decision-shadow-run" || header?.schema === 2 && header.kind === "decision-shadow-native-run") || header.caseSetHash !== caseSetHash(cases) || header.caseCount !== cases.length || header.trainingEligible !== false || !validCreatedAt(header.createdAt))
     throw new Error("Run header does not match this case set.");
-  makeRequest(header.provider, header.requestedModel, cases[0]);
+  const native = header.schema === 2;
+  if (native) {
+    validateNativeRoute(header.route);
+    if (header.provider !== header.route.provider || header.requestedModel !== header.route.model || header.requestFormat !== "pi-classifier-context-v1" || header.costSource !== "pi-catalog-estimate")
+      throw new Error("Native run route does not match its header.");
+  } else {
+    if (!Object.hasOwn(terms, header.provider)) throw new Error("Invalid run provider.");
+    makeRequest(header.provider, header.requestedModel, cases[0]);
+  }
   if (records.length > cases.length)
     throw new Error("Too many prediction records.");
   for (const [index, r] of records.entries()) {
-    const validState = r?.status === "answered" ? isSupportedResolvedModel(r.resolvedModel) && r.error === null : r?.status === "error" && r.probability === null && providerErrors.has(r.error) && (r.resolvedModel === null || isSupportedResolvedModel(r.resolvedModel)) && index === records.length - 1;
+    const { kind, caseId, caseHash, requestSha256, trainingEligible, ...prediction } = r ?? {};
+    const validState = native ? validateNativePrediction(header.route, prediction) && r.requestSha256 === nativeRequestSha256(cases[index]) && (r.status !== "error" || index === records.length - 1) : r?.status === "answered" ? isSupportedResolvedModel(r.resolvedModel) && r.error === null : r?.status === "error" && r.probability === null && providerErrors.has(r.error) && (r.resolvedModel === null || isSupportedResolvedModel(r.resolvedModel)) && index === records.length - 1;
     if (!r || r.kind !== "prediction" || r.trainingEligible !== false || r.caseId !== cases[index].id || r.caseHash !== cases[index].hash || !validState || !nullableMetric(r.latencyMs) || !r.usage || !["inputTokens", "outputTokens"].every(
       (key) => nullableTokenCount(r.usage[key])
     ) || !nullableMetric(r.usage.costUsd))
       throw new Error("Invalid prediction record.");
   }
-  return { header, records, runSha256: sha256(text2) };
+  return { header, records, runSha256: sha2562(text4) };
 }
 function nullableMetric(value) {
   return value === null || typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -2371,7 +2940,7 @@ function measurements(records) {
   };
 }
 async function writeNew(path, value) {
-  const file = await open4(path, "wx", 384);
+  const file = await open5(path, "wx", 384);
   try {
     await file.writeFile(JSON.stringify(value, null, 2) + "\n");
     await file.sync();
@@ -2387,13 +2956,20 @@ async function main(argv, {
   piRunner,
   sessionConsent,
   expectedCaseSetHash,
-  beforeProviderCall
+  beforeProviderCall,
+  nativeRoute,
+  nativeProviderCall,
+  learningRoot
 } = {}) {
   const { command, flags } = argumentsFor(argv);
   if (command === "help") {
     emit(help);
     return;
   }
+  if (command === "collections") {
+    emit(JSON.stringify(await listCollections(resolveDataRoot({ env, override: flags.root })), null, 2));
+    return;
+  }
   const cases = command === "fixtures" ? null : parseCases(await jsonFile(flags.cases));
   if (Object.hasOwn(RESEARCH_OPTIONS, command))
     return researchCommand(
@@ -2419,12 +2995,12 @@ async function main(argv, {
       ...verification,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       caseSetHash: caseSetHash(cases),
-      selectionFileSha256: sha256(sourceText)
+      selectionFileSha256: sha2562(sourceText)
     };
     await writeNew(flags.out, receipt);
     emit(
       JSON.stringify({
-        saved: resolve2(flags.out),
+        saved: resolve3(flags.out),
         status: receipt.status,
         caseCount: cases.length,
         artifactCount: receipt.artifactCount,
@@ -2437,14 +3013,22 @@ async function main(argv, {
   if (command === "preview" || command === "run") {
     if (expectedCaseSetHash !== void 0 && caseSetHash(cases) !== expectedCaseSetHash)
       throw new Error("Cases changed after confirmation.");
+    if (nativeRoute !== void 0) {
+      validateNativeRoute(nativeRoute);
+      if (flags.provider !== nativeRoute.provider || flags.model !== nativeRoute.model)
+        throw new Error("Selected native provider/model changed.");
+      if (command === "run" && typeof nativeProviderCall !== "function")
+        throw new Error("Native classifier runner is unavailable.");
+    }
     const requests = cases.map(
-      (c) => makeRequest(flags.provider, flags.model, c)
+      (c) => nativeRoute ? { route: nativeRoute, context: makeNativeRequest(c), requestSha256: nativeRequestSha256(c) } : makeRequest(flags.provider, flags.model, c)
     );
     if (command === "preview") {
       emit(
         JSON.stringify(
           {
-            schema: 1,
+            schema: nativeRoute ? 2 : 1,
+            ...nativeRoute ? { requestFormat: "pi-classifier-context-v1" } : {},
             caseSetHash: caseSetHash(cases),
             count: cases.length,
             trainingEligible: false,
@@ -2460,18 +3044,33 @@ async function main(argv, {
       );
       return;
     }
+    const dataRoot = resolveDataRoot({ env, override: learningRoot });
     const consent = sessionConsent ?? await requestSessionStorage({
       sessionId: flags["session-id"],
       storage: flags.storage,
-      promptStorage
+      promptStorage,
+      storageRoot: dataRoot
     });
     const apiKey = env.OPENROUTER_API_KEY;
-    if (!apiKey?.trim())
+    if (!nativeRoute && !apiKey?.trim())
       throw new Error("Selected provider API key is not configured.");
-    const file = await open4(flags.out, "wx", 384);
+    const file = await open5(flags.out, "wx", 384);
+    let collection, collectionFd, collectionStatus = "disabled";
     const append = async (row) => {
-      await file.writeFile(JSON.stringify(row) + "\n");
+      const bytes = JSON.stringify(row) + "\n";
+      await file.writeFile(bytes);
       await file.sync();
+      if (collectionFd !== void 0) {
+        try {
+          beforeProviderCall?.();
+          writeFileSync3(collectionFd, bytes);
+          fsyncSync3(collectionFd);
+        } catch {
+          closeSync3(collectionFd);
+          collectionFd = void 0;
+          collectionStatus = "incomplete";
+        }
+      }
     };
     let failures = 0;
     try {
@@ -2483,26 +3082,45 @@ async function main(argv, {
         out: flags.out + ".learning.json",
         assertCurrent: beforeProviderCall
       });
+      if (consent.decision === "granted") {
+        beforeProviderCall?.();
+        collection = createSessionCollection(dataRoot, "jev-manual", consent.sessionId);
+        writePrivateNew(join7(collection, "consent.json"), JSON.stringify(consent, null, 2) + "\n");
+        await retainSelectedSessionData({
+          cases,
+          consent,
+          out: join7(collection, "selected-data.json"),
+          assertCurrent: beforeProviderCall
+        });
+        beforeProviderCall?.();
+        collectionFd = openSync3(join7(collection, "results.jsonl"), "wx", 384);
+        collectionStatus = "captured";
+      }
       await append({
-        schema: 1,
-        kind: "decision-shadow-run",
+        schema: nativeRoute ? 2 : 1,
+        kind: nativeRoute ? "decision-shadow-native-run" : "decision-shadow-run",
+        ...nativeRoute ? {
+          route: nativeRoute,
+          requestFormat: "pi-classifier-context-v1",
+          costSource: "pi-catalog-estimate"
+        } : {},
         provider: flags.provider,
         requestedModel: flags.model,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         caseCount: cases.length,
         caseSetHash: caseSetHash(cases),
         trainingEligible: false,
-        termsUrl: terms[flags.provider]
+        ...nativeRoute ? {} : { termsUrl: terms[flags.provider] }
       });
       for (const c of cases) {
         let result;
         try {
           if (beforeProviderCall) beforeProviderCall();
-          result = await providerCall(flags.provider, flags.model, c, {
-            apiKey
-          });
+          result = nativeRoute ? await nativeProviderCall(c) : await providerCall(flags.provider, flags.model, c, { apiKey });
+          if (nativeRoute && !validateNativePrediction(nativeRoute, result))
+            throw new Error("Invalid native classifier result.");
         } catch {
-          result = {
+          result = nativeRoute ? normalizeNativeResult(nativeRoute, null, null) : {
             status: "error",
             probability: null,
             resolvedModel: null,
@@ -2516,6 +3134,7 @@ async function main(argv, {
           caseId: c.id,
           caseHash: c.hash,
           ...result,
+          ...nativeRoute ? { requestSha256: nativeRequestSha256(c) } : {},
           trainingEligible: false
         });
         if (result.status === "error") {
@@ -2524,11 +3143,13 @@ async function main(argv, {
         }
       }
     } finally {
+      if (collectionFd !== void 0) closeSync3(collectionFd);
       await file.close();
     }
     emit(
       JSON.stringify({
-        saved: resolve2(flags.out),
+        saved: resolve3(flags.out),
+        learningCollection: { status: collectionStatus, ...collection ? { path: collection } : {} },
         errors: failures,
         trainingEligible: false
       })
@@ -2542,7 +3163,7 @@ async function main(argv, {
   const labels = parseLabels(await jsonFile(flags.labels), cases);
   if (command === "corpus") {
     await writeNew(flags.out, localCorpus(cases, labels));
-    emit(JSON.stringify({ saved: resolve2(flags.out), trainingReady: false }));
+    emit(JSON.stringify({ saved: resolve3(flags.out), trainingReady: false }));
     return;
   }
   const reports = [];
@@ -2559,6 +3180,12 @@ async function main(argv, {
     reports.push({
       provider: header.provider,
       requestedModel: header.requestedModel,
+      ...header.schema === 2 ? {
+        route: header.route,
+        requestFormat: header.requestFormat,
+        costSource: header.costSource,
+        modelResolution: "Pi returns the requested model identity; backend resolution is unknown."
+      } : {},
       resolvedModels,
       runSha256,
       createdAt: header.createdAt,