@disclosureos/cli 1.0.0 → 2.0.0-beta.0

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname6, join as join10 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/utils/args.ts
 var SHORT_FLAG_MAP = {
@@ -158,8 +158,8 @@ var CLASSIFICATION_TEMPLATE = [
     evidenceRefs: []
   }
 ];
-function getTemplate(name) {
-  const data = name === "observation" ? buildObservation(false) : name === "observation-full" ? buildObservation(true) : name === "assessment" ? ASSESSMENT_TEMPLATE : CLASSIFICATION_TEMPLATE;
+function getTemplate(name2) {
+  const data = name2 === "observation" ? buildObservation(false) : name2 === "observation-full" ? buildObservation(true) : name2 === "assessment" ? ASSESSMENT_TEMPLATE : CLASSIFICATION_TEMPLATE;
   return JSON.stringify(data, null, 2);
 }
 
@@ -177,8 +177,8 @@ function writeOutput(filePath, data) {
 function findJSONFiles(dirPath, recursive) {
   const resolved = resolve(dirPath);
   if (!existsSync(resolved)) return [];
-  const stat = statSync(resolved);
-  if (stat.isFile()) {
+  const stat2 = statSync(resolved);
+  if (stat2.isFile()) {
     return extname(resolved) === ".json" ? [resolved] : [];
   }
   const results = [];
@@ -259,8 +259,8 @@ function resolveTemplateName(args2) {
   console.log(error(`Unknown template: "${sub}"`));
   return null;
 }
-function getTypeScriptTemplate(name) {
-  switch (name) {
+function getTypeScriptTemplate(name2) {
+  switch (name2) {
     case "observation":
       return TS_OBSERVATION;
     case "observation-full":
@@ -395,7 +395,7 @@ Generate typed templates for DisclosureOS data structures.
 }
 
 // src/commands/validate.ts
-import { parseEvidenceRef } from "@disclosureos/records/shared";
+import { parseEvidenceRef, isSensorRef } from "@disclosureos/records/shared";
 import { parseEnrichedObservation } from "@disclosureos/schema";
 function validate(args2) {
   if (args2.flags["help"]) {
@@ -413,10 +413,10 @@ function validate(args2) {
   const seen = /* @__PURE__ */ new Set();
   const files = [];
   const emptyTargets = [];
-  for (const target of targets) {
-    const found = findJSONFiles(target, recursive);
+  for (const target2 of targets) {
+    const found = findJSONFiles(target2, recursive);
     if (found.length === 0) {
-      emptyTargets.push(target);
+      emptyTargets.push(target2);
       continue;
     }
     for (const f of found) {
@@ -503,7 +503,7 @@ function validateFileStructured(filePath, strict) {
   const obs = data;
   const structuralErrors = parseEnrichedObservation(obs).issues;
   const semanticErrors = validateSemantics(obs);
-  const warnings = [...validateEvidenceRefs(obs), ...strict ? validateStrict(obs) : []];
+  const warnings = [...validateEvidenceRefs(obs), ...validateSensorRefs(obs), ...strict ? validateStrict(obs) : []];
   const allErrors = [...structuralErrors, ...semanticErrors];
   return {
     file: filePath,
@@ -527,7 +527,7 @@ function validateFile(filePath, strict) {
   const obs = data;
   const structuralErrors = parseEnrichedObservation(obs).issues;
   const semanticErrors = validateSemantics(obs);
-  const warnings = [...validateEvidenceRefs(obs), ...strict ? validateStrict(obs) : []];
+  const warnings = [...validateEvidenceRefs(obs), ...validateSensorRefs(obs), ...strict ? validateStrict(obs) : []];
   const allErrors = [...structuralErrors, ...semanticErrors];
   if (allErrors.length > 0 || warnings.length > 0) {
     console.log(`
@@ -628,6 +628,25 @@ function validateEvidenceRefs(obs) {
   }
   return warnings;
 }
+function validateSensorRefs(obs) {
+  const warnings = [];
+  const sensorEvidence = obs["sensorEvidence"];
+  if (!sensorEvidence || typeof sensorEvidence !== "object") return warnings;
+  const sensors = sensorEvidence["sensors"];
+  if (!Array.isArray(sensors)) return warnings;
+  sensors.forEach((sensor, i) => {
+    if (!sensor || typeof sensor !== "object") return;
+    const ref = sensor["sensorRef"];
+    if (ref === void 0) return;
+    if (typeof ref !== "string" || !isSensorRef(ref)) {
+      warnings.push({
+        path: `sensorEvidence.sensors[${i}].sensorRef`,
+        message: `malformed sensor ref ${JSON.stringify(ref)} (expected "<org-slug>:<sensor-id>", e.g. "eldaeon:dionysus-passive-radar")`
+      });
+    }
+  });
+  return warnings;
+}
 function validateStrict(obs) {
   const warnings = [];
   const recommended = ["summary", "description", "objectCharacteristics", "sourceData", "witnesses"];
@@ -679,6 +698,7 @@ Validate observation JSON files against the full schema.
   console.log(`  \u2022 OCS node IDs in origin classifications (if present)`);
   console.log(`  \u2022 Unknown top-level keys rejected (third-party data belongs under "extensions")`);
   console.log(`  \u2022 Evidence refs on claims resolve to in-record evidence (warns on dangling)`);
+  console.log(`  \u2022 Sensor refs follow the "<org-slug>:<sensor-id>" manifest convention (warns on malformed)`);
   console.log(`  \u2022 Semantic sanity (non-negative duration, speed, counts)
 `);
   console.log(`${dim("Examples:")}`);
@@ -690,306 +710,3675 @@ Validate observation JSON files against the full schema.
 `);
 }
 
-// src/commands/completeness.ts
-import { parseEnrichedObservation as parseEnrichedObservation2 } from "@disclosureos/schema";
-import { getCompleteness } from "@disclosureos/scoring";
-function completeness(args2) {
-  if (args2.flags["help"]) {
+// src/commands/manifest.ts
+import { validateSensorManifest } from "@disclosureos/instruments";
+function manifest(args2) {
+  if (args2.flags["help"] || args2.subcommand !== "validate") {
     printUsage3();
+    if (!args2.flags["help"] && args2.subcommand !== void 0 && args2.subcommand !== "validate") {
+      process.exit(1);
+    }
     return;
   }
-  const targets = [args2.subcommand, ...args2.positional].filter((t) => !!t);
+  const targets = args2.positional.filter((t) => !!t);
   if (targets.length === 0) {
     printUsage3();
     return;
   }
   const recursive = !!args2.flags["recursive"];
   const jsonMode = !!args2.flags["json"];
-  const seen = /* @__PURE__ */ new Set();
-  const files = [];
-  const emptyTargets = [];
-  for (const target of targets) {
-    const found = findJSONFiles(target, recursive);
-    if (found.length === 0) {
-      emptyTargets.push(target);
-      continue;
-    }
-    for (const f of found) {
-      if (!seen.has(f)) {
-        seen.add(f);
-        files.push(f);
-      }
-    }
+  const files = [...new Set(targets.flatMap((target2) => findJSONFiles(target2, recursive)))];
+  if (files.length === 0) {
+    console.log(error(`No JSON files found at: ${targets.join(", ")}`));
+    process.exit(1);
   }
+  const results = files.map(validateManifestFile);
   if (jsonMode) {
-    runJsonMode2(files, emptyTargets);
+    const valid = results.every((result) => result.valid);
+    console.log(JSON.stringify({ files: results, valid }, null, 2));
+    if (!valid) process.exit(1);
     return;
   }
-  for (const t of emptyTargets) {
-    console.log(error(`No JSON files found at: ${t}`));
-  }
-  if (files.length === 0) {
-    process.exit(1);
-  }
-  let hasErrors = false;
-  const percentages = [];
-  const reqPercentages = [];
-  for (const file of files) {
-    const result = scoreFile(file);
+  let failed = false;
+  for (const result of results) {
     if (!result.valid) {
-      hasErrors = true;
+      failed = true;
+      console.log(`
+${error(`${result.file} INVALID`)}`);
+      for (const issue of result.errors) {
+        console.log(`  ${error(`${issue.path}: ${issue.message}`)}`);
+      }
       continue;
     }
-    percentages.push(result.percentage);
-    reqPercentages.push(result.requiredPercentage);
+    const summary = result.summary;
+    console.log(`
+${success(`${result.file}`)}`);
+    console.log(`  ${dim(formatManifestLine(summary))}`);
+    console.log(`  ${dim("by modality:")} ${Object.entries(summary.byModality).map(([m, n]) => `${m} ${n}`).join(", ")}`);
+    if (summary.proposedSensorTypes.length > 0) {
+      console.log(`  ${dim(`proposed sensor types (${summary.proposedSensorTypes.length}):`)} ${summary.proposedSensorTypes.join(", ")}`);
+    }
+    if (summary.proposedDetectionMethods.length > 0) {
+      console.log(`  ${dim(`proposed detection methods (${summary.proposedDetectionMethods.length}):`)} ${summary.proposedDetectionMethods.join(", ")}`);
+    }
   }
   console.log("");
-  if (hasErrors || emptyTargets.length > 0) {
-    console.log(error("Some files could not be scored (see errors above)."));
+  if (failed) {
+    console.log(error(`Validation failed`));
     process.exit(1);
   }
-  const mean = avg(percentages);
-  const reqMean = avg(reqPercentages);
-  console.log(
-    success(
-      `${files.length} file(s) scored \u2014 mean completeness ${mean}%, required fields ${reqMean}%`
-    )
-  );
+  console.log(success(`All ${files.length} manifest(s) valid`));
 }
-function avg(values) {
-  return values.length > 0 ? Math.round(values.reduce((a, b) => a + b, 0) / values.length) : 0;
+function formatManifestLine(summary) {
+  return `${summary.org} (${summary.orgSlug}) \u2014 ${summary.sensors} sensors, ${summary.futureUpgrades} future upgrades`;
 }
-function scoreFile(filePath) {
+function validateManifestFile(file) {
   let data;
   try {
-    data = readJSON(filePath);
+    data = readJSON(file);
   } catch {
-    console.log(error(`Failed to parse: ${filePath}`));
-    return emptyResult(filePath, "Failed to parse JSON");
-  }
-  if (!data || typeof data !== "object") {
-    console.log(error(`${filePath}: not a valid JSON object`));
-    return emptyResult(filePath, "Not a valid JSON object");
+    return { file, valid: false, errors: [{ path: "", message: "Failed to parse JSON" }] };
   }
-  const parsed = parseEnrichedObservation2(data);
-  if (!parsed.success) {
-    console.log(error(`${filePath}: invalid observation (${parsed.issues.length} issue${parsed.issues.length !== 1 ? "s" : ""})`));
-    for (const issue of parsed.issues.slice(0, 5)) {
-      console.log(`  ${dim(`${issue.path}: ${issue.message}`)}`);
-    }
-    return emptyResult(filePath, "Invalid observation");
+  const issues = validateSensorManifest(data);
+  if (issues.length > 0) {
+    return { file, valid: false, errors: issues };
   }
-  const comp = getCompleteness(data);
-  console.log(`
-${dim(filePath)}`);
-  console.log(`  Completeness: ${comp.percentage}%  (${comp.present}/${comp.total} fields)`);
-  console.log(`  Required:     ${comp.requiredPercentage}%  (${comp.requiredPresent}/${comp.requiredTotal})`);
-  if (comp.missing.length > 0) {
-    const shown = comp.missing.slice(0, 10);
-    console.log(`  Missing (top ${shown.length}):`);
-    for (const path of shown) {
-      console.log(`    ${dim("\u2022")} ${path}`);
+  const parsed = data;
+  const byModality = {};
+  const proposedSensorTypes = [];
+  const proposedDetectionMethods = [];
+  for (const sensor of parsed.sensors) {
+    byModality[sensor.modality] = (byModality[sensor.modality] ?? 0) + 1;
+    if (sensor.recordsMapping?.proposedSensorType && sensor.recordsMapping.sensorType) {
+      proposedSensorTypes.push(sensor.recordsMapping.sensorType);
     }
-    if (comp.missing.length > shown.length) {
-      console.log(`    ${dim(`\u2026 and ${comp.missing.length - shown.length} more`)}`);
+    if (sensor.recordsMapping?.proposedDetectionMethod && sensor.recordsMapping.detectionMethod) {
+      proposedDetectionMethods.push(sensor.recordsMapping.detectionMethod);
     }
   }
-  return {
-    file: filePath,
-    valid: true,
-    percentage: comp.percentage,
-    requiredPercentage: comp.requiredPercentage,
-    present: comp.present,
-    total: comp.total,
-    missing: comp.missing
-  };
-}
-function emptyResult(file, errorMsg) {
   return {
     file,
-    valid: false,
-    percentage: 0,
-    requiredPercentage: 0,
-    present: 0,
-    total: 0,
-    missing: [],
-    error: errorMsg
-  };
-}
-function runJsonMode2(files, emptyTargets) {
-  const fileResults = [];
-  for (const file of files) {
-    fileResults.push(scoreFileQuiet(file));
-  }
-  const validResults = fileResults.filter((r) => r.valid);
-  const meanPercentage = avg(validResults.map((r) => r.percentage));
-  const meanRequired = avg(validResults.map((r) => r.requiredPercentage));
-  const allValid = fileResults.every((r) => r.valid) && emptyTargets.length === 0;
-  const output = {
-    files: fileResults,
-    emptyTargets,
-    totals: {
-      files: files.length,
-      meanPercentage,
-      meanRequiredPercentage: meanRequired,
-      emptyTargets: emptyTargets.length
-    },
-    valid: allValid
-  };
-  console.log(JSON.stringify(output, null, 2));
-  if (!allValid) {
-    process.exit(1);
-  }
-}
-function scoreFileQuiet(filePath) {
-  let data;
-  try {
-    data = readJSON(filePath);
-  } catch {
-    return emptyResult(filePath, "Failed to parse JSON");
-  }
-  if (!data || typeof data !== "object") {
-    return emptyResult(filePath, "Not a valid JSON object");
-  }
-  const parsed = parseEnrichedObservation2(data);
-  if (!parsed.success) {
-    return emptyResult(filePath, `Invalid observation (${parsed.issues.length} issue${parsed.issues.length !== 1 ? "s" : ""})`);
-  }
-  const comp = getCompleteness(data);
-  return {
-    file: filePath,
     valid: true,
-    percentage: comp.percentage,
-    requiredPercentage: comp.requiredPercentage,
-    present: comp.present,
-    total: comp.total,
-    missing: comp.missing
+    errors: [],
+    summary: {
+      org: parsed.org,
+      orgSlug: parsed.orgSlug,
+      sensors: parsed.sensors.length,
+      byModality,
+      proposedSensorTypes,
+      proposedDetectionMethods,
+      futureUpgrades: parsed.futureUpgrades?.length ?? 0
+    }
   };
 }
 function printUsage3() {
-  console.log(heading(`${BRAND} completeness`));
+  console.log(heading(`${BRAND} manifest`));
   console.log(`
-Measure how fully observation JSON files populate the records schema.
+Validate sensor-manifest JSON files (@disclosureos/instruments).
 `);
   console.log(`${dim("Usage:")}`);
-  console.log(`  disclosureos completeness <path...> [options]
-`);
-  console.log(`${dim("Paths:")}`);
-  console.log(`  Accepts one or more files, directories, or shell globs.
+  console.log(`  disclosureos manifest validate <path...> [options]
 `);
   console.log(`${dim("Options:")}`);
-  console.log(`  --recursive, -r      Score all JSON files in directories recursively`);
+  console.log(`  --recursive, -r      Validate all JSON files in directories recursively`);
   console.log(`  --json, -j           Output results as structured JSON (for CI and scripts)`);
   console.log(`  --help, -h           Show this help message
 `);
-  console.log(`${dim("Scoring:")}`);
-  console.log(`  Files must be structurally valid observations before completeness is measured.`);
-  console.log(`  Invalid JSON or invalid observations exit non-zero without a score.
-`);
-  console.log(`${dim("Output:")}`);
-  console.log(`  \u2022 Completeness percentage (0\u2013100) \u2014 how many schema fields are populated`);
-  console.log(`  \u2022 Required field percentage \u2014 coverage of required fields only`);
-  console.log(`  \u2022 Top missing field paths \u2014 the next fields to target
+  console.log(`${dim("Validation checks:")}`);
+  console.log(`  \u2022 Manifest structure (org, orgSlug, sensors, calibration, timing, measurements)`);
+  console.log(`  \u2022 Sensor ids unique and kebab-case`);
+  console.log(`  \u2022 recordsMapping values exist in the records enums or carry proposed* flags
 `);
   console.log(`${dim("Examples:")}`);
-  console.log(`  disclosureos completeness ./data/nimitz.json`);
-  console.log(`  disclosureos completeness ./data/ --recursive`);
-  console.log(`  disclosureos completeness ./out/*.json --json
+  console.log(`  disclosureos manifest validate ./manifests/eldaeon-sensors.json`);
+  console.log(`  disclosureos manifest validate ./manifests/ --recursive --json
 `);
 }
 
-// src/commands/registry.ts
-import { deriveFieldPaths } from "@disclosureos/scoring";
+// src/commands/packet.ts
 import {
-  ALL_OBSERVABLES,
-  TECHNOLOGY_OBSERVABLES,
-  BIOLOGICS_OBSERVABLES,
-  ASSESSMENT_LEVELS
-} from "@disclosureos/observables";
+  constants,
+  openSync,
+  closeSync,
+  fstatSync,
+  readSync,
+  lstatSync
+} from "fs";
+import { resolve as resolve2, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createHash } from "crypto";
 import {
-  OCS_TAXONOMY,
-  getNode,
-  getChildren,
-  getTestableNodes,
-  ORIGIN_DOMAINS,
-  ORIGIN_DOMAIN_LABELS
-} from "@disclosureos/origins";
-function registry(args2) {
-  if (args2.flags["help"]) {
-    printUsage4();
+  ReproductionPacketSchema,
+  evaluateReproductionPacket
+} from "@disclosureos/schema/experimental/v2";
+import { parseExperimentalClaimHistory } from "@disclosureos/records/experimental/v2";
+var MANIFEST_LIMIT = 8 * 1024 * 1024;
+var TOTAL_LIMIT = 256 * 1024 * 1024;
+var FILE_LIMIT = 4096;
+var hash = (bytes2) => createHash("sha256").update(bytes2).digest("hex");
+function readLocal(path, limit) {
+  const fd = openSync(
+    path,
+    constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+  );
+  try {
+    const stat2 = fstatSync(fd);
+    if (!stat2.isFile()) throw Error("Expected a regular file.");
+    if (stat2.size > limit) throw Error("Packet exceeds the CLI memory limit.");
+    const chunks = [];
+    let size = 0;
+    for (; ; ) {
+      const chunk = Buffer.alloc(Math.min(65536, limit - size + 1));
+      const count = readSync(fd, chunk, 0, chunk.length, null);
+      if (!count) break;
+      size += count;
+      if (size > limit) throw Error("Packet exceeds the CLI memory limit.");
+      chunks.push(chunk.subarray(0, count));
+    }
+    return Buffer.concat(chunks, size);
+  } finally {
+    closeSync(fd);
+  }
+}
+var json = (bytes2) => JSON.parse(
+  new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2)
+);
+var object = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw Error("Expected a JSON object.");
+  return value;
+};
+function usage() {
+  console.log(`DisclosureOS experimental packet workflow
+
+  disclosureos packet inspect <packet.json> [--json]
+  disclosureos packet validate <packet.json> [--json]
+  disclosureos packet reproduce <packet.json> [--json]
+
+Files are read from files/<file ID> beside packet.json. Inspection reads only the
+manifest; validation verifies files and research prerequisites. Reproduction runs
+only the built-in synthetic-radial-velocity-mean v1 control, never bundled code.
+Limits: 8 MiB manifest, 4096 files, 256 MiB combined file bytes. No network access.
+Exit codes: 0 success, 1 failed or incomplete check, 2 usage or manifest-read error.
+Use --json for the complete validator diagnostics and unchecked scientific limits.`);
+}
+function emit(output, jsonMode) {
+  if (jsonMode) {
+    console.log(JSON.stringify(output, null, 2));
     return;
   }
-  const sub = args2.subcommand;
-  switch (sub) {
-    case "fields":
-      registryFields(args2);
-      break;
-    case "observables":
-      registryObservables(args2);
-      break;
-    case "origins":
-      registryOrigins(args2);
-      break;
-    default:
-      printUsage4();
+  console.log(
+    `DisclosureOS packet ${output.command}: ${output.success ? "passed" : "failed or incomplete"}`
+  );
+  if (output.packetId)
+    console.log(
+      `Packet: ${output.packetId}
+Manifest SHA-256: ${output.manifestSha256}`
+    );
+  if (output.inspection)
+    console.log(
+      `${output.inspection.fileCount} declared files; ${output.inspection.declaredBytes} bytes.
+File identity and research prerequisites: not checked.
+Next: disclosureos packet validate <packet.json>`
+    );
+  if (output.validation) {
+    const v = output.validation;
+    console.log(
+      `Structural: ${v.checks.structural}; semantic: ${v.checks.semantic}; profile: ${v.checks.profile}; external: ${v.checks.external}`
+    );
+    for (const i of v.issues)
+      console.log(`${i.code} ${i.pointer}: ${i.message}`);
+    if (v.success && output.command === "validate")
+      console.log(
+        "Next: disclosureos packet reproduce <packet.json> (synthetic control only)."
+      );
+  }
+  if (output.reproduction) {
+    const r = output.reproduction;
+    console.log(
+      `Reproduction: ${r.status}${r.value === void 0 ? "" : `; ${r.value} ${r.unit}, tolerance ${r.absoluteTolerance}`}`
+    );
+    if (r.message) console.log(r.message);
   }
+  for (const i of output.issues)
+    console.log(`${i.code} ${i.pointer}: ${i.message}`);
+  console.log("Scientific eligibility: not checked.");
 }
-function registryFields(args2) {
-  const group = args2.flags["category"];
-  const paths = deriveFieldPaths();
-  const groups = /* @__PURE__ */ new Map();
-  for (const field of paths) {
-    const top = field.path.split(".")[0] ?? field.path;
-    const list = groups.get(top) ?? [];
-    list.push(field);
-    groups.set(top, list);
+function reproduce(packet2, files) {
+  const method = packet2.method;
+  const result = {
+    status: "not_checked",
+    executor: "disclosureos-cli/synthetic-mean/0.1.0",
+    runtime: process.version,
+    methodId: method.id,
+    methodVersion: method.version,
+    unit: method.unit,
+    absoluteTolerance: method.absoluteTolerance
+  };
+  if (method.id !== "synthetic-radial-velocity-mean" || method.version !== "1") {
+    result.message = "Unsupported method. This CLI never executes packet-supplied implementations.";
+    return result;
   }
-  console.log(heading("Observation Field Registry (schema-derived)"));
-  if (group) {
-    const fields = groups.get(group);
-    if (!fields || fields.length === 0) {
-      console.log(`
-  No fields found for group "${group}"`);
-      return;
-    }
-    console.log(`
-  Group: ${group}
-`);
-    const rows = fields.map((f) => [f.path, f.required ? "required" : "optional"]);
-    console.log(table(rows));
-  } else {
-    for (const groupName of [...groups.keys()].sort()) {
-      const fields = groups.get(groupName);
-      console.log(`
-  ${groupName} (${fields.length} fields)`);
-      for (const f of fields) {
-        console.log(bullet(`${f.path}${f.required ? " [required]" : ""}`));
-      }
-    }
+  try {
+    result.executorSha256 = hash(
+      readLocal(fileURLToPath(import.meta.url), TOTAL_LIMIT)
+    );
+    if (method.unit !== "m/s" || packet2.assets.context.find((a) => a.ref === "product:captured-raw")?.fileRef !== method.inputRef || packet2.assets.observation.find((a) => a.ref === "product:summary")?.fileRef !== method.expectedOutputRef)
+      throw Error("Method does not match the fixed synthetic control mapping.");
+    const input = object(json(files.get(method.inputRef))), expected = object(json(files.get(method.expectedOutputRef)));
+    const samples = input["samples"];
+    if (!Array.isArray(samples) || !samples.length || !samples.every(
+      (v) => typeof v === "number" && Number.isFinite(v)
+    ))
+      throw Error("Expected a nonempty array of finite samples.");
+    let sum = 0;
+    for (const value2 of samples) sum += value2;
+    const value = sum / samples.length, expectedValue = expected["velocity"];
+    if (!Number.isFinite(value) || typeof expectedValue !== "number" || !Number.isFinite(expectedValue))
+      throw Error("Nonfinite or malformed calculation result.");
+    result.value = value;
+    result.expected = expectedValue;
+    const history2 = parseExperimentalClaimHistory(
+      json(files.get(packet2.documents.history))
+    );
+    const measurement = history2.success ? history2.data.observation.measurements.find(
+      (m) => `measurement:${m.id}` === method.measurementRef
+    ) : void 0;
+    if (!measurement || measurement.value.unit !== method.unit || Math.abs(value - expectedValue) > method.absoluteTolerance || Math.abs(value - measurement.value.value) > method.absoluteTolerance)
+      throw Error(
+        "Computed result differs from the expected output or measurement beyond the declared tolerance."
+      );
+    result.status = "passed";
+    return result;
+  } catch (error2) {
+    result.status = "failed";
+    result.message = error2 instanceof Error ? error2.message : "Calculation failed.";
+    return result;
   }
-  console.log(`
-  ${dim(`Total: ${paths.length} schema-derived field paths`)}
-`);
 }
-function registryObservables(args2) {
-  const biologicsOnly = !!args2.flags["biologics"];
-  const techOnly = !!args2.flags["technology"];
-  console.log(heading("Observable Registry"));
-  if (!biologicsOnly) {
-    console.log(`
-  Technology Observables (AATIP-derived)
-`);
-    const techObs = Object.values(TECHNOLOGY_OBSERVABLES);
-    for (const obs of techObs) {
-      console.log(`  ${obs.code}  ${obs.label}`);
-      if (obs.description) {
-        console.log(`       ${dim(obs.description)}`);
-      }
-    }
+async function packet(args2) {
+  if (args2.flags["help"]) {
+    usage();
+    return;
   }
-  if (!techOnly) {
-    console.log(`
-  Biologics Observables (NHI Detection)
+  const output = {
+    command: args2.subcommand,
+    success: false,
+    issues: [],
+    scientificEligibility: "not_checked"
+  };
+  const jsonMode = !!args2.flags["json"];
+  if (!["inspect", "validate", "reproduce"].includes(args2.subcommand) || args2.positional.length !== 1 || Object.keys(args2.flags).some((f) => !["json", "help"].includes(f))) {
+    output.issues.push({
+      code: "CLI.USAGE",
+      pointer: "",
+      message: "Use packet inspect|validate|reproduce <packet.json> [--json]."
+    });
+    emit(output, jsonMode);
+    if (!jsonMode) usage();
+    process.exitCode = 2;
+    return;
+  }
+  let path, bytes2, input;
+  try {
+    path = resolve2(args2.positional[0]);
+    bytes2 = readLocal(path, MANIFEST_LIMIT);
+    input = json(bytes2);
+    output.manifestSha256 = hash(bytes2);
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.MANIFEST",
+      pointer: "",
+      message: error2 instanceof Error ? error2.message : "Cannot read manifest."
+    });
+    emit(output, jsonMode);
+    process.exitCode = 2;
+    return;
+  }
+  const parsed = ReproductionPacketSchema.safeParse(input);
+  if (!parsed.success) {
+    output.validation = await evaluateReproductionPacket(input);
+    emit(output, jsonMode);
+    process.exitCode = 1;
+    return;
+  }
+  const data = parsed.data;
+  output.packetId = data.id;
+  if (args2.subcommand === "inspect") {
+    output.inspection = {
+      fileCount: data.files.length,
+      declaredBytes: data.files.reduce((n, f) => n + f.byteLength, 0),
+      documents: data.documents,
+      method: data.method,
+      fileIdentity: "not_checked",
+      researchPrerequisites: "not_checked"
+    };
+    output.success = true;
+    emit(output, jsonMode);
+    return;
+  }
+  const files = /* @__PURE__ */ new Map();
+  if (data.files.length > FILE_LIMIT || data.files.reduce((n, f) => n + f.byteLength, 0) > TOTAL_LIMIT) {
+    output.issues.push({
+      code: "CLI.LIMIT",
+      pointer: "/files",
+      message: "Declared packet exceeds 4096 files or 256 MiB."
+    });
+    emit(output, jsonMode);
+    process.exitCode = 1;
+    return;
+  }
+  const directory5 = join(dirname(path), "files");
+  let remaining = TOTAL_LIMIT;
+  try {
+    if (!lstatSync(directory5).isDirectory())
+      throw Error("files must be a real directory, not a symlink.");
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.FILES_DIRECTORY",
+      pointer: "/files",
+      message: error2 instanceof Error ? error2.message : "Cannot read files directory."
+    });
+  }
+  if (!output.issues.length)
+    for (const [i, file] of data.files.entries())
+      try {
+        if (files.has(file.id)) continue;
+        const bytes3 = readLocal(join(directory5, file.id), remaining);
+        files.set(file.id, bytes3);
+        remaining -= bytes3.byteLength;
+      } catch (error2) {
+        output.issues.push({
+          code: "CLI.FILE_READ",
+          pointer: `/files/${i}`,
+          message: error2 instanceof Error ? error2.message : "Cannot read file."
+        });
+      }
+  output.validation = await evaluateReproductionPacket(input, { files });
+  output.success = output.validation.success && !output.issues.length;
+  if (args2.subcommand === "reproduce" && output.success) {
+    output.reproduction = reproduce(data, files);
+    output.success = output.reproduction.status === "passed";
+  }
+  emit(output, jsonMode);
+  if (!output.success) process.exitCode = 1;
+}
+
+// src/commands/dataset.ts
+import { lstatSync as lstatSync2 } from "fs";
+import { resolve as resolve3, dirname as dirname2, join as join2 } from "path";
+import { createHash as createHash2 } from "crypto";
+import {
+  DatasetReleaseSchema,
+  ReproductionPacketSchema as ReproductionPacketSchema2,
+  evaluateDatasetRelease
+} from "@disclosureos/schema/experimental/v2";
+var LIMIT = 256 * 1024 * 1024;
+var MANIFEST_LIMIT2 = 8 * 1024 * 1024;
+var json2 = (bytes2) => JSON.parse(
+  new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2)
+);
+function directory(path) {
+  if (!lstatSync2(path).isDirectory())
+    throw Error("Expected a real directory, not a symlink.");
+}
+async function dataset(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "DisclosureOS experimental dataset workflow\n\n  disclosureos dataset inspect <dataset.json> [--json]\n  disclosureos dataset validate <dataset.json> [--json]\n\nMember packets live at packets/<entry ID>/packet.json and files/<file ID>.\nInspection reads only the release manifest. Validation checks pinned packets and\nnominal session membership. No code execution or inferred scientific eligibility.\nLimits: 128 packets, 4096 total files, 256 MiB total packet/file bytes.\nExit: 0 success, 1 failed/incomplete, 2 usage or release-manifest read error."
+    );
+    return;
+  }
+  const output = {
+    command: args2.subcommand,
+    success: false,
+    issues: [],
+    scientificEligibility: "not_checked",
+    authorization: "not_checked"
+  };
+  const emit3 = () => {
+    if (args2.flags["json"]) {
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(
+      `DisclosureOS dataset ${args2.subcommand}: ${output.success ? "passed" : "failed or incomplete"}`
+    );
+    if (output.manifestSha256)
+      console.log(`Manifest SHA-256: ${output.manifestSha256}`);
+    if (output.inspection)
+      console.log(JSON.stringify(output.inspection, null, 2));
+    if (output.validation) {
+      console.log(JSON.stringify(output.validation.checks));
+      for (const i of output.validation.issues)
+        console.log(`${i.code} ${i.pointer}: ${i.message}`);
+      for (const packet2 of output.validation.packets)
+        for (const i of packet2.validation?.issues ?? [])
+          console.log(
+            `${packet2.packetRef} ${i.code} ${i.pointer}: ${i.message}`
+          );
+    }
+    for (const i of output.issues)
+      console.log(`${i.code} ${i.pointer}: ${i.message}`);
+    console.log("Scientific eligibility and authorization: not checked.");
+  };
+  if (!["inspect", "validate"].includes(args2.subcommand) || args2.positional.length !== 1 || Object.keys(args2.flags).some((f) => !["json", "help"].includes(f))) {
+    output.issues.push({
+      code: "CLI.USAGE",
+      pointer: "",
+      message: "Use dataset inspect|validate <dataset.json> [--json]."
+    });
+    emit3();
+    process.exitCode = 2;
+    return;
+  }
+  let input, path;
+  try {
+    path = resolve3(args2.positional[0]);
+    const bytes2 = readLocal(path, MANIFEST_LIMIT2);
+    output.manifestSha256 = createHash2("sha256").update(bytes2).digest("hex");
+    input = json2(bytes2);
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.MANIFEST",
+      pointer: "",
+      message: error2 instanceof Error ? error2.message : "Cannot read dataset manifest."
+    });
+    emit3();
+    process.exitCode = 2;
+    return;
+  }
+  const parsed = DatasetReleaseSchema.safeParse(input);
+  if (!parsed.success) {
+    output.validation = await evaluateDatasetRelease(input);
+    emit3();
+    process.exitCode = 1;
+    return;
+  }
+  const release = parsed.data;
+  if (args2.subcommand === "inspect") {
+    output.inspection = {
+      id: release.id,
+      version: release.version,
+      packetCount: release.packets.length,
+      sessions: release.sessions,
+      access: release.access,
+      license: release.license,
+      fileIdentity: "not_checked",
+      membership: "not_checked"
+    };
+    output.success = true;
+    emit3();
+    return;
+  }
+  if (release.packets.length > 128) {
+    output.issues.push({
+      code: "CLI.LIMIT",
+      pointer: "/packets",
+      message: "At most 128 packets are supported."
+    });
+    emit3();
+    process.exitCode = 1;
+    return;
+  }
+  const packets = /* @__PURE__ */ new Map();
+  let remaining = LIMIT, count = 0;
+  const root = join2(dirname2(path), "packets");
+  try {
+    directory(root);
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.PACKET_DIRECTORY",
+      pointer: "/packets",
+      message: error2 instanceof Error ? error2.message : "Cannot read packets directory."
+    });
+  }
+  if (!output.issues.length)
+    for (const [i, entry] of release.packets.entries()) {
+      if (packets.has(entry.id)) continue;
+      const base = join2(root, entry.id), issuesPath = `/packets/${i}`;
+      try {
+        directory(base);
+        const manifest2 = readLocal(
+          join2(base, "packet.json"),
+          Math.min(remaining, MANIFEST_LIMIT2)
+        );
+        remaining -= manifest2.byteLength;
+        const files = /* @__PURE__ */ new Map();
+        packets.set(entry.id, { manifest: manifest2, files });
+        const packet2 = ReproductionPacketSchema2.safeParse(json2(manifest2));
+        if (!packet2.success) continue;
+        if (count + packet2.data.files.length > 4096)
+          throw Error("Dataset exceeds the 4096-file limit.");
+        count += packet2.data.files.length;
+        directory(join2(base, "files"));
+        for (const file of packet2.data.files) {
+          if (files.has(file.id)) continue;
+          try {
+            const bytes2 = readLocal(join2(base, "files", file.id), remaining);
+            remaining -= bytes2.byteLength;
+            files.set(file.id, bytes2);
+          } catch (error2) {
+            output.issues.push({
+              code: "CLI.FILE_READ",
+              pointer: issuesPath,
+              message: error2 instanceof Error ? error2.message : "Cannot read member file."
+            });
+          }
+        }
+      } catch (error2) {
+        output.issues.push({
+          code: "CLI.PACKET_READ",
+          pointer: issuesPath,
+          message: error2 instanceof Error ? error2.message : "Cannot read member packet."
+        });
+      }
+    }
+  output.validation = await evaluateDatasetRelease(input, { packets });
+  output.success = output.validation.success && !output.issues.length;
+  emit3();
+  if (!output.success) process.exitCode = 1;
+}
+
+// src/commands/intake.ts
+import { mkdirSync, writeFileSync as writeFileSync2, rmSync, lstatSync as lstatSync3 } from "fs";
+import { resolve as resolve4, dirname as dirname3, join as join3, basename } from "path";
+import { randomUUID, createHash as createHash3 } from "crypto";
+import {
+  SourceIntakeSchema,
+  evaluateSourceIntake
+} from "@disclosureos/schema/experimental/v2";
+var LIMIT2 = 256 * 1024 * 1024;
+var hash2 = (bytes2) => createHash3("sha256").update(bytes2).digest("hex");
+var decode = (bytes2) => JSON.parse(
+  new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2)
+);
+var unknown = () => ({
+  state: "unknown",
+  reason: "Not established at file intake."
+});
+async function intake(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "DisclosureOS experimental source intake\n\n  disclosureos intake create <file...> --out <new-directory> [--json]\n  disclosureos intake inspect <intake.json> [--json]\n  disclosureos intake validate <intake.json> [--json]\n\nCreate copies exact bytes into files/<ID> and records receipt time and hashes.\nContext, format, role, access and licensing remain explicitly unknown. No decoding\nor assessment is inferred. Destination must not exist. Limits: 4096 files,\n256 MiB combined bytes, 8 MiB manifest. No network access.\nExit: 0 success, 1 failed/incomplete, 2 usage or file-operation error."
+    );
+    return;
+  }
+  const output = {
+    command: args2.subcommand,
+    success: false,
+    issues: [],
+    researchEligibility: "not_checked"
+  };
+  const emit3 = () => {
+    if (args2.flags["json"]) {
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(
+      `DisclosureOS intake ${args2.subcommand}: ${output.success ? "passed" : "failed or incomplete"}`
+    );
+    if (output.path) console.log(`Receipt: ${output.path}`);
+    if (output.manifestSha256)
+      console.log(`Manifest SHA-256: ${output.manifestSha256}`);
+    if (output.inspection) {
+      console.log(
+        `${output.inspection.artifacts.length} artifacts; file identity not checked.`
+      );
+      console.log(JSON.stringify(output.inspection, null, 2));
+    }
+    if (output.validation) {
+      console.log(JSON.stringify(output.validation.checks));
+      for (const i of output.validation.issues)
+        console.log(`${i.code} ${i.pointer}: ${i.message}`);
+      for (const gap of output.validation.gaps)
+        console.log(
+          `MISSING ${gap.pointer}: ${gap.reason} Next: ${gap.nextAction}`
+        );
+    }
+    for (const i of output.issues)
+      console.log(`${i.code} ${i.pointer}: ${i.message}`);
+    console.log(
+      "Research eligibility, artifact contents and authorization: not checked."
+    );
+  };
+  const create = args2.subcommand === "create";
+  if (!["create", "inspect", "validate"].includes(args2.subcommand) || Object.keys(args2.flags).some(
+    (f) => !["help", "json", ...create ? ["out"] : []].includes(f)
+  ) || (create ? args2.positional.length < 1 || typeof args2.flags["out"] !== "string" : args2.positional.length !== 1)) {
+    output.issues.push({
+      code: "CLI.USAGE",
+      pointer: "",
+      message: "Use intake create <file...> --out <new-directory>, or inspect|validate <intake.json>."
+    });
+    emit3();
+    process.exitCode = 2;
+    return;
+  }
+  const files = /* @__PURE__ */ new Map();
+  let remaining = LIMIT2;
+  if (create) {
+    let destination, created = false;
+    try {
+      if (args2.positional.length > 4096)
+        throw Error("At most 4096 source files are supported.");
+      const artifacts = [];
+      for (const [i, path2] of args2.positional.entries()) {
+        const bytes3 = readLocal(resolve4(path2), remaining);
+        remaining -= bytes3.length;
+        const id = `file-${i + 1}`;
+        files.set(id, bytes3);
+        artifacts.push({
+          id,
+          originalName: basename(path2),
+          role: "unknown",
+          format: unknown(),
+          sha256: hash2(bytes3),
+          byteLength: bytes3.length,
+          context: {
+            instrument: unknown(),
+            calibration: unknown(),
+            clock: unknown(),
+            acquisitionTime: unknown()
+          }
+        });
+      }
+      const receipt = {
+        kind: "source_intake",
+        schemaVersion: "0.1.0",
+        id: `intake-${randomUUID()}`,
+        receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: { publisher: unknown() },
+        access: "unknown",
+        license: unknown(),
+        artifacts
+      };
+      const bytes2 = Buffer.from(JSON.stringify(receipt, null, 2) + "\n");
+      if (bytes2.length > 8 * 1024 * 1024)
+        throw Error("Generated manifest exceeds 8 MiB.");
+      output.validation = await evaluateSourceIntake(receipt, { files });
+      if (!output.validation.success)
+        throw Error("Receipt did not pass file identity checks.");
+      destination = resolve4(args2.flags["out"]);
+      mkdirSync(destination, { mode: 448 });
+      created = true;
+      mkdirSync(join3(destination, "files"), { mode: 448 });
+      for (const [id, b] of files)
+        writeFileSync2(join3(destination, "files", id), b, {
+          flag: "wx",
+          mode: 384
+        });
+      writeFileSync2(join3(destination, "intake.json"), bytes2, {
+        flag: "wx",
+        mode: 384
+      });
+      output.path = join3(destination, "intake.json");
+      output.manifestSha256 = hash2(bytes2);
+      output.success = true;
+    } catch (error2) {
+      if (created && destination)
+        rmSync(destination, { recursive: true, force: true });
+      output.issues.push({
+        code: "CLI.INTAKE_CREATE",
+        pointer: "",
+        message: error2 instanceof Error ? error2.message : "Intake creation failed."
+      });
+      process.exitCode = 2;
+    }
+    emit3();
+    return;
+  }
+  let input, path;
+  try {
+    path = resolve4(args2.positional[0]);
+    const bytes2 = readLocal(path, 8 * 1024 * 1024);
+    output.manifestSha256 = hash2(bytes2);
+    input = decode(bytes2);
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.MANIFEST",
+      pointer: "",
+      message: error2 instanceof Error ? error2.message : "Cannot read intake manifest."
+    });
+    emit3();
+    process.exitCode = 2;
+    return;
+  }
+  const parsed = SourceIntakeSchema.safeParse(input);
+  if (!parsed.success) {
+    output.validation = await evaluateSourceIntake(input);
+    emit3();
+    process.exitCode = 1;
+    return;
+  }
+  if (args2.subcommand === "inspect") {
+    output.inspection = parsed.data;
+    output.fileIdentity = "not_checked";
+    output.success = true;
+    emit3();
+    return;
+  }
+  if (parsed.data.artifacts.length > 4096 || parsed.data.artifacts.reduce((n, a) => n + a.byteLength, 0) > LIMIT2) {
+    output.issues.push({
+      code: "CLI.LIMIT",
+      pointer: "/artifacts",
+      message: "Intake exceeds 4096 artifacts or 256 MiB."
+    });
+    emit3();
+    process.exitCode = 1;
+    return;
+  }
+  const directory5 = join3(dirname3(path), "files");
+  try {
+    if (!lstatSync3(directory5).isDirectory())
+      throw Error("Expected a real files directory, not a symlink.");
+  } catch (error2) {
+    output.issues.push({
+      code: "CLI.FILES_DIRECTORY",
+      pointer: "/artifacts",
+      message: error2 instanceof Error ? error2.message : "Cannot read files directory."
+    });
+  }
+  if (!output.issues.length)
+    for (const [i, a] of parsed.data.artifacts.entries())
+      try {
+        if (files.has(a.id)) continue;
+        const b = readLocal(join3(directory5, a.id), remaining);
+        remaining -= b.length;
+        files.set(a.id, b);
+      } catch (error2) {
+        output.issues.push({
+          code: "CLI.FILE_READ",
+          pointer: `/artifacts/${i}`,
+          message: error2 instanceof Error ? error2.message : "Cannot read artifact."
+        });
+      }
+  output.validation = await evaluateSourceIntake(input, { files });
+  output.success = output.validation.success && !output.issues.length;
+  emit3();
+  if (!output.success) process.exitCode = 1;
+}
+
+// src/commands/profile-prepare.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, rmSync as rmSync2, lstatSync as lstatSync4 } from "fs";
+import { resolve as resolve5, dirname as dirname4, join as join4 } from "path";
+import { createHash as createHash4 } from "crypto";
+import {
+  ProfilePreparationSchema,
+  evaluateProfileEvaluation
+} from "@disclosureos/schema/experimental/v2";
+var META = 8 * 1024 * 1024;
+var TOTAL = 256 * 1024 * 1024;
+var FILES = 4096;
+var pin = (bytes2) => ({
+  sha256: createHash4("sha256").update(bytes2).digest("hex"),
+  byteLength: bytes2.length
+});
+function directory2(path) {
+  if (!lstatSync4(path).isDirectory())
+    throw Error("Expected a real directory, not a symlink.");
+}
+var decode2 = (bytes2) => JSON.parse(
+  new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes2)
+);
+async function prepareProfile(args2) {
+  const output = {
+    command: "prepare",
+    success: false,
+    issues: [],
+    scientificEligibility: "not_checked"
+  };
+  let destination, created = false;
+  const emit3 = () => {
+    if (args2.flags["json"]) console.log(JSON.stringify(output, null, 2));
+    else {
+      console.log(
+        "DisclosureOS profile preparation: " + (output.success ? "bundle prepared" : "not prepared")
+      );
+      if (output.path) console.log("Bundle: " + JSON.stringify(output.path));
+      if (output.profileStatus)
+        console.log(
+          "Profile outcome: " + output.profileStatus + "; receipt " + (output.receiptCreated ? "created (unsigned)" : "not created")
+        );
+      for (const i of output.issues)
+        console.log(i.code + ": " + JSON.stringify(i.message));
+      console.log(
+        "Preparation success is not a passing profile. Run profile check on evaluation.json for requirements and next actions."
+      );
+    }
+  };
+  if (args2.positional.length !== 1 || typeof args2.flags["out"] !== "string" || Object.keys(args2.flags).some((f) => !["json", "out", "help"].includes(f))) {
+    output.issues.push({
+      code: "CLI.USAGE",
+      message: "Use profile prepare <plan.json> --out <new-directory> [--json]."
+    });
+    emit3();
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const planPath = resolve5(args2.positional[0]), base = dirname4(planPath);
+    directory2(base);
+    const planBytes = readLocal(planPath, META), parsed = ProfilePreparationSchema.safeParse(decode2(planBytes));
+    output.planSha256 = pin(planBytes).sha256;
+    if (!parsed.success) {
+      output.issues.push(
+        ...parsed.error.issues.map((i) => ({
+          code: "PREPARE.PLAN",
+          message: i.path.join("/") + ": " + i.message
+        }))
+      );
+      emit3();
+      process.exitCode = 1;
+      return;
+    }
+    const plan = parsed.data, deps = [
+      ...plan.dependencies.vocabularies,
+      plan.dependencies.implementation,
+      plan.dependencies.environment
+    ];
+    if (plan.assets.length + deps.length + 2 > FILES)
+      throw Error("Preparation exceeds 4096 input files.");
+    if (new Set(deps.map((d) => d.ref)).size !== deps.length || new Set(plan.dependencies.vocabularies.map((d) => d.id)).size !== plan.dependencies.vocabularies.length || new Set(plan.assets.map((a) => a.ref)).size !== plan.assets.length || new Set(plan.assets.map((a) => a.fileRef)).size !== plan.assets.length)
+      throw Error("Duplicate dependency, vocabulary or asset references.");
+    let remaining = TOTAL - planBytes.length;
+    const read = (path, limit) => {
+      const parts = path.split("/");
+      let parent = base;
+      for (const part of parts.slice(0, -1)) {
+        parent = join4(parent, part);
+        directory2(parent);
+      }
+      const bytes2 = readLocal(join4(base, ...parts), Math.min(limit, remaining));
+      remaining -= bytes2.length;
+      if (!bytes2.length)
+        throw Error(
+          "Empty inputs cannot receive positive-length evaluation pins: " + path
+        );
+      return bytes2;
+    };
+    const historyBytes = read(plan.history, META), selectionBytes = read(plan.selection, META);
+    decode2(historyBytes);
+    decode2(selectionBytes);
+    const assetFiles = new Map(
+      plan.assets.map((a) => [a.fileRef, read(a.path, remaining)])
+    );
+    const dependencyFiles = new Map(
+      deps.map((d) => [d.ref, read(d.path, remaining)])
+    );
+    const dependency = (d) => ({
+      ref: d.ref,
+      id: d.id,
+      version: d.version,
+      ...pin(dependencyFiles.get(d.ref))
+    });
+    const manifest2 = {
+      kind: "profile_evaluation",
+      schemaVersion: "0.1.0",
+      id: plan.id,
+      workflow: plan.workflow,
+      history: pin(historyBytes),
+      selection: pin(selectionBytes),
+      assets: plan.assets.map((a) => ({
+        ref: a.ref,
+        fileRef: a.fileRef,
+        ...pin(assetFiles.get(a.fileRef))
+      })),
+      dependencies: {
+        vocabularies: plan.dependencies.vocabularies.map(dependency),
+        implementation: dependency(plan.dependencies.implementation),
+        environment: dependency(plan.dependencies.environment)
+      }
+    };
+    const evaluation = await evaluateProfileEvaluation(
+      manifest2,
+      { historyBytes, selectionBytes, assetFiles, dependencyFiles }
+    );
+    if (!evaluation.receipt)
+      throw Error(
+        "Pinned inputs did not produce a receipt: " + JSON.stringify(evaluation.issues)
+      );
+    const manifestBytes = Buffer.from(JSON.stringify(manifest2, null, 2) + "\n"), receiptBytes = Buffer.from(
+      JSON.stringify(evaluation.receipt, null, 2) + "\n"
+    );
+    if (manifestBytes.length > META || receiptBytes.length > META)
+      throw Error("Generated metadata exceeds 8 MiB.");
+    const inputBytes = historyBytes.length + selectionBytes.length + [...assetFiles.values(), ...dependencyFiles.values()].reduce(
+      (n, b) => n + b.length,
+      0
+    );
+    if (inputBytes + manifestBytes.length + receiptBytes.length > TOTAL)
+      throw Error("Generated bundle exceeds 256 MiB.");
+    destination = resolve5(args2.flags["out"]);
+    directory2(dirname4(destination));
+    mkdirSync2(destination, { mode: 448 });
+    created = true;
+    for (const name2 of ["assets", "dependencies"])
+      mkdirSync2(join4(destination, name2), { mode: 448 });
+    const write = (path, bytes2) => writeFileSync3(join4(destination, path), bytes2, {
+      flag: "wx",
+      mode: 384
+    });
+    write("history.json", historyBytes);
+    write("selection.json", selectionBytes);
+    write("evaluation.json", manifestBytes);
+    write("receipt.json", receiptBytes);
+    for (const [ref, bytes2] of assetFiles) write("assets/" + ref, bytes2);
+    for (const [ref, bytes2] of dependencyFiles)
+      write("dependencies/" + ref, bytes2);
+    output.success = true;
+    output.path = destination;
+    output.profileStatus = evaluation.checks.profile;
+    output.profileSuccess = evaluation.success;
+    output.receiptCreated = true;
+  } catch (error2) {
+    if (created && destination)
+      rmSync2(destination, { recursive: true, force: true });
+    output.issues.push({
+      code: "PREPARE.INPUT_OR_WRITE",
+      message: error2 instanceof Error ? error2.message : String(error2)
+    });
+    process.exitCode = 2;
+  }
+  emit3();
+}
+
+// src/commands/profile.ts
+import { lstatSync as lstatSync5 } from "fs";
+import { resolve as resolve6, dirname as dirname5, join as join5 } from "path";
+import { createHash as createHash5 } from "crypto";
+import {
+  ProfileEvaluationSchema,
+  evaluateProfileEvaluation as evaluateProfileEvaluation2,
+  RELEASED_DOCUMENT_PROFILE,
+  HISTORICAL_TESTIMONY_PROFILE,
+  PHYSICAL_SAMPLE_PROFILE,
+  INSTRUMENT_RESEARCH_PREREQUISITES_PROFILE
+} from "@disclosureos/schema/experimental/v2";
+var META2 = 8 * 1024 * 1024;
+var TOTAL2 = 256 * 1024 * 1024;
+var FILES2 = 4096;
+var catalog = [
+  {
+    id: "instrument-research",
+    title: "Instrument research",
+    profile: INSTRUMENT_RESEARCH_PREREQUISITES_PROFILE,
+    workflow: null,
+    command: "disclosureos packet validate <packet.json>",
+    useWhen: "Instrument observations with acquisition, calibration, timing and measurement records.",
+    limits: "Checks documented research prerequisites; does not establish scientific validity."
+  },
+  {
+    id: "released-documents",
+    title: "Released documents",
+    profile: RELEASED_DOCUMENT_PROFILE,
+    workflow: "released-documents:0.1.0",
+    command: "disclosureos profile check <evaluation.json>",
+    useWhen: "Explicitly selected public document sources and their direct extractions.",
+    limits: "Does not authenticate releases or establish the truth of document contents."
+  },
+  {
+    id: "historical-testimony",
+    title: "Historical testimony",
+    profile: HISTORICAL_TESTIMONY_PROFILE,
+    workflow: "historical-testimony:0.1.0",
+    command: "disclosureos profile check <evaluation.json>",
+    useWhen: "Selected testimony accounts, including restricted accounts and documented pseudonyms.",
+    limits: "Does not assess witness credibility, firsthand knowledge or independent corroboration."
+  },
+  {
+    id: "physical-samples",
+    title: "Physical samples",
+    profile: PHYSICAL_SAMPLE_PROFILE,
+    workflow: "physical-samples:0.1.0",
+    command: "disclosureos profile check <evaluation.json>",
+    useWhen: "Declared collected specimens with collection and custody records.",
+    limits: "Does not cover derived samples or mixtures, or certify physical identity, custody truth, composition or origin."
+  }
+];
+var safe = (value) => value.replace(
+  /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g,
+  (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0")
+);
+var line = (value) => console.log(safe(value));
+var label3 = (value) => {
+  const words = value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+var status = (value) => ({
+  passed: "passed",
+  failed: "failed",
+  not_checked: "not checked",
+  satisfied: "satisfied",
+  missing: "missing",
+  not_applicable: "not applicable"
+})[value] ?? value;
+function emit2(output, jsonMode) {
+  if (jsonMode) {
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  line("DisclosureOS experimental profile checks");
+  if (output.catalog) {
+    for (const p of output.catalog) {
+      line("");
+      line(p.title);
+      line("  Use for: " + p.useWhen);
+      line("  Run: " + p.command);
+      if (p.workflow) line("  Manifest workflow: " + p.workflow);
+      line("  Limit: " + p.limits);
+    }
+    line("");
+    line(
+      "Choose the profile from the source records; no automatic selection or aggregate score is applied."
+    );
+    return;
+  }
+  if (output.inspection) {
+    const i = output.inspection;
+    line("Selected: " + i.title);
+    line("Workflow: " + i.workflow);
+    line(
+      `Declared files: ${i.assetCount} source files, ${i.dependencyCount} dependencies, history and selection`
+    );
+    line(
+      "Manifest inspected. Input integrity and profile outcome: not checked. No receipt created."
+    );
+  }
+  const evaluation = output.evaluation;
+  if (evaluation) {
+    if (!output.inspection) {
+      line(
+        "Selected: " + (catalog.find((p2) => p2.workflow === output.selectedWorkflow)?.title ?? "Manifest not accepted")
+      );
+      if (output.selectedWorkflow) line("Workflow: " + output.selectedWorkflow);
+    }
+    line("Input integrity: " + status(evaluation.checks.external));
+    line("Profile outcome: " + status(evaluation.checks.profile));
+    line(
+      "Receipt: " + (evaluation.receipt ? "created (unsigned)" : "not created")
+    );
+    const p = evaluation.profile;
+    if (p) {
+      const rows = "documents" in p ? p.documents : "accounts" in p ? p.accounts : p.samples;
+      for (const row of rows) {
+        line("");
+        line(
+          ("sourceRef" in row ? row.sourceRef : row.sampleId) + ": " + status(row.status)
+        );
+        for (const r of row.requirements) {
+          line(
+            `  ${r.importance === "required" ? "Required" : "Recommended"} | ${r.label}: ${status(r.status)}`
+          );
+          line("    " + r.reason);
+          for (const issue of r.issues) line("    Next: " + issue.nextAction);
+          if (r.blockedBy.length)
+            line("    Blocked by: " + r.blockedBy.map(label3).join(", "));
+        }
+      }
+      if (!rows.length)
+        for (const issue of p.issues) {
+          line(issue.code + " " + issue.pointer + ": " + issue.message);
+          line("  Next: " + issue.nextAction);
+        }
+      line("");
+      line("Profile limits:");
+      for (const [key, value] of Object.entries(p))
+        if (value === "not_checked") line("  " + label3(key) + ": not checked");
+    }
+    if (!p)
+      for (const issue of evaluation.issues)
+        line(issue.code + " " + issue.pointer + ": " + issue.message);
+    line(
+      "A receipt preserves a result; it does not make a failed or unchecked profile pass."
+    );
+    line("Implementation and environment execution: not attested.");
+  }
+  for (const issue of output.issues) {
+    line(issue.code + " " + issue.pointer + ": " + issue.message);
+    line("  Next: " + issue.nextAction);
+  }
+  line(
+    "Scientific eligibility: not checked. Use --json for the full result and receipt."
+  );
+}
+function directory3(path) {
+  const s = lstatSync5(path);
+  if (!s.isDirectory() || s.isSymbolicLink())
+    throw Error("Expected a real directory.");
+}
+async function profile(args2) {
+  if (args2.flags["help"]) {
+    console.log(`DisclosureOS experimental profile checks
+
+  disclosureos profile prepare <plan.json> --out <new-directory> [--json]
+  disclosureos profile list [--json]
+  disclosureos profile inspect <evaluation.json> [--json]
+  disclosureos profile check <evaluation.json> [--json]
+
+The manifest explicitly selects released-documents:0.1.0, historical-testimony:0.1.0
+or physical-samples:0.1.0. Instrument research uses packet validate.
+Inspect reads only the manifest. Check reads history.json, selection.json,
+assets/<fileRef> and dependencies/<ref> beside it. No network access or supplied-code execution.
+Limits: 8 MiB metadata, 4096 input files, 256 MiB total bytes.
+Prepare writes a new private bundle from a profile_preparation plan; preparation
+success does not mean the profile passed. Other commands are read-only.
+Exit: 0 prepared/listed/inspected or profile passed with receipt, 1 failed/unchecked checks,
+2 usage or unreadable/malformed manifest. Full JSON may contain restricted metadata;
+apply access policy before sharing. No automatic profile selection or aggregate score.`);
+    return;
+  }
+  if (args2.subcommand === "prepare") {
+    await prepareProfile(args2);
+    return;
+  }
+  const output = {
+    command: args2.subcommand,
+    success: false,
+    issues: [],
+    scientificEligibility: "not_checked"
+  };
+  const finish = (code) => {
+    emit2(output, !!args2.flags["json"]);
+    if (code) process.exitCode = code;
+  };
+  if (!["list", "inspect", "check"].includes(args2.subcommand) || args2.positional.length !== (args2.subcommand === "list" ? 0 : 1) || Object.keys(args2.flags).some((f) => !["json", "help"].includes(f))) {
+    output.issues.push({
+      code: "CLI.USAGE",
+      pointer: "",
+      message: "Use profile list or profile inspect|check <evaluation.json> [--json].",
+      nextAction: "Run disclosureos profile --help for explicit workflow and input layout."
+    });
+    finish(2);
+    return;
+  }
+  if (args2.subcommand === "list") {
+    output.catalog = catalog;
+    output.success = true;
+    finish(0);
+    return;
+  }
+  let input, manifestBytes, path;
+  try {
+    path = resolve6(args2.positional[0]);
+    manifestBytes = readLocal(path, META2);
+    output.manifestSha256 = createHash5("sha256").update(manifestBytes).digest("hex");
+    input = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+        manifestBytes
+      )
+    );
+  } catch {
+    output.issues.push({
+      code: "CLI.MANIFEST",
+      pointer: "",
+      message: "Cannot read the manifest as regular-file UTF-8 JSON within 8 MiB.",
+      nextAction: "Supply a local evaluation manifest without a BOM or symlink; keep the file within the metadata limit."
+    });
+    finish(2);
+    return;
+  }
+  const parsed = ProfileEvaluationSchema.safeParse(input), preflight = await evaluateProfileEvaluation2(input);
+  if (!parsed.success || preflight.checks.semantic === "failed") {
+    output.evaluation = preflight;
+    finish(1);
+    return;
+  }
+  output.selectedWorkflow = parsed.data.workflow;
+  const manifest2 = parsed.data, dependencies = [
+    ...manifest2.dependencies.vocabularies,
+    manifest2.dependencies.implementation,
+    manifest2.dependencies.environment
+  ];
+  const selected = catalog.find((p) => p.workflow === manifest2.workflow);
+  if (args2.subcommand === "inspect") {
+    output.inspection = {
+      id: manifest2.id,
+      workflow: manifest2.workflow,
+      title: selected.title,
+      profile: manifest2.workflow === "released-documents:0.1.0" ? RELEASED_DOCUMENT_PROFILE : manifest2.workflow === "historical-testimony:0.1.0" ? HISTORICAL_TESTIMONY_PROFILE : PHYSICAL_SAMPLE_PROFILE,
+      assetCount: manifest2.assets.length,
+      dependencyCount: dependencies.length,
+      declaredInputBytes: manifest2.history.byteLength + manifest2.selection.byteLength + manifest2.assets.reduce((n, a) => n + a.byteLength, 0) + dependencies.reduce((n, d) => n + d.byteLength, 0),
+      inputIntegrity: "not_checked",
+      profileOutcome: "not_checked",
+      receipt: "not_created"
+    };
+    output.success = true;
+    finish(0);
+    return;
+  }
+  if (manifest2.assets.length + dependencies.length + 2 > FILES2 || manifestBytes.length + manifest2.history.byteLength + manifest2.selection.byteLength + manifest2.assets.reduce((n, a) => n + a.byteLength, 0) + dependencies.reduce((n, d) => n + d.byteLength, 0) > TOTAL2) {
+    output.issues.push({
+      code: "CLI.LIMIT",
+      pointer: "",
+      message: "Declared inputs exceed the 4096-file or 256 MiB budget.",
+      nextAction: "Use a bounded evaluation input set; do not omit necessary records merely to make a profile pass."
+    });
+    finish(1);
+    return;
+  }
+  const root = dirname5(path);
+  let remaining = TOTAL2 - manifestBytes.length;
+  try {
+    directory3(root);
+  } catch {
+    output.issues.push({
+      code: "CLI.DIRECTORY",
+      pointer: "",
+      message: "The bundle root must be a real directory.",
+      nextAction: "Use a local directory without a symlink root."
+    });
+    finish(1);
+    return;
+  }
+  const read = (relative, limit) => {
+    try {
+      const bytes2 = readLocal(join5(root, relative), Math.min(remaining, limit));
+      remaining -= bytes2.length;
+      return bytes2;
+    } catch {
+      output.issues.push({
+        code: "CLI.INPUT_FILE",
+        pointer: relative,
+        message: "Cannot read this input as a regular file within its byte budget.",
+        nextAction: "Provide the original pinned local file, respecting access restrictions; do not substitute another file."
+      });
+      return void 0;
+    }
+  };
+  const historyBytes = read("history.json", META2), selectionBytes = read("selection.json", META2);
+  const assetFiles = /* @__PURE__ */ new Map(), dependencyFiles = /* @__PURE__ */ new Map();
+  for (const [name2, entries, map] of [
+    ["assets", manifest2.assets.map((a) => a.fileRef), assetFiles],
+    ["dependencies", dependencies.map((d) => d.ref), dependencyFiles]
+  ]) {
+    try {
+      directory3(join5(root, name2));
+    } catch {
+      output.issues.push({
+        code: "CLI.DIRECTORY",
+        pointer: name2,
+        message: "Expected a real input directory.",
+        nextAction: "Keep the assets and dependencies directories beside the manifest, including an empty assets directory when no files are declared."
+      });
+      continue;
+    }
+    for (const ref of entries) {
+      const bytes2 = read(name2 + "/" + ref, remaining);
+      if (bytes2) map.set(ref, bytes2);
+    }
+  }
+  output.evaluation = await evaluateProfileEvaluation2(input, {
+    ...historyBytes ? { historyBytes } : {},
+    ...selectionBytes ? { selectionBytes } : {},
+    assetFiles,
+    dependencyFiles
+  });
+  output.success = output.evaluation.success && output.issues.length === 0;
+  finish(output.success ? 0 : 1);
+}
+
+// src/commands/migration-compatibility.ts
+import { createHash as createHash8 } from "crypto";
+import {
+  MigrationCompatibilitySchema
+} from "@disclosureos/schema/experimental/v2";
+import {
+  parseAcquisitionContext
+} from "@disclosureos/instruments/experimental/v2";
+
+// src/commands/migration-review.ts
+import { createHash as createHash7 } from "crypto";
+import {
+  MigrationReviewSchema
+} from "@disclosureos/schema/experimental/v2";
+import { parseExperimentalClaimHistory as parseExperimentalClaimHistory3 } from "@disclosureos/records/experimental/v2";
+
+// src/commands/migration-plan.ts
+import { createHash as createHash6 } from "crypto";
+import { parseEnrichedObservation as parseEnrichedObservation2 } from "@disclosureos/schema";
+import {
+  parseExperimentalClaimHistory as parseExperimentalClaimHistory2
+} from "@disclosureos/records/experimental/v2";
+var POLICY = "legacy-migration-dry-run:0.1.0";
+var sha256 = (bytes2) => createHash6("sha256").update(bytes2).digest("hex");
+var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var escape = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
+function fields(value) {
+  const pending = [{ value, pointer: "", depth: 0 }];
+  const leaves = [];
+  let visited = 0;
+  while (pending.length) {
+    const item = pending.pop();
+    if (++visited > 1e5 || item.depth > 64)
+      throw new Error("Record exceeds 100000 nodes or depth 64");
+    const entries = item.value !== null && typeof item.value === "object" ? Object.entries(item.value) : [];
+    if (!entries.length) leaves.push(item.pointer);
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const [key, value2] = entries[i];
+      pending.push({
+        value: value2,
+        pointer: `${item.pointer}/${escape(key)}`,
+        depth: item.depth + 1
+      });
+    }
+  }
+  return leaves;
+}
+function mapping(pointer, candidate) {
+  if (candidate && ["/id", "/createdAt", "/updatedAt", "/summary"].includes(pointer)) {
+    return {
+      pointer,
+      disposition: "mapped",
+      target: `/observation${pointer}`,
+      reason: pointer === "/id" ? "Deterministic namespace and legacy ID hash; original ID retained in legacy data." : "Copied without inference."
+    };
+  }
+  return {
+    pointer,
+    disposition: "unresolved",
+    reason: !candidate ? "Quarantined record retained; no candidate mapping applied." : pointer === "/status" ? "Candidate is a review draft; original publication status retained only in legacy data." : pointer.startsWith("/temporal/") ? "Time scale, precision, provenance and possible sentinel use require explicit review." : pointer.startsWith("/location/") ? "Reference frame, provenance and possible sentinel use require explicit review; zero is retained." : "Retained only in versioned legacy data; requires explicit mapping. Legacy evaluations are not v2 claims or comparable scores."
+  };
+}
+function buildMigrationReport(bytes2, namespace) {
+  const input = JSON.parse(
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes2)
+  );
+  const rows = Array.isArray(input) ? input : [input];
+  if (!rows.length || rows.length > 1e4)
+    throw new Error("Input must contain 1 to 10000 records");
+  const digest = sha256(bytes2);
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (object2(row) && typeof row.id === "string")
+      counts.set(row.id, (counts.get(row.id) ?? 0) + 1);
+  }
+  const records = rows.map((legacy, index) => {
+    const sourcePointer = Array.isArray(input) ? `/${index}` : "";
+    const reasons = [];
+    let pointers = [];
+    try {
+      pointers = fields(legacy);
+    } catch (error2) {
+      reasons.push(error2.message);
+    }
+    if (object2(legacy) && typeof legacy.id === "string" && counts.get(legacy.id) > 1) {
+      reasons.push(
+        "Duplicate legacy ID in this input; all occurrences quarantined."
+      );
+    }
+    const validation = reasons.length ? void 0 : parseEnrichedObservation2(legacy);
+    if (validation && !validation.success) {
+      reasons.push(
+        ...validation.issues.map((issue) => `${issue.path}: ${issue.message}`)
+      );
+    }
+    let candidate;
+    if (!reasons.length && object2(legacy)) {
+      const id = `legacy-${sha256(JSON.stringify([namespace, legacy.id]))}`;
+      const proposal = {
+        kind: "claim_history",
+        schemaVersion: "0.1.0",
+        id: `${id}-history`,
+        observation: {
+          kind: "observation",
+          schemaVersion: "0.1.0",
+          id,
+          status: "draft",
+          createdAt: legacy.createdAt,
+          updatedAt: legacy.updatedAt,
+          ...legacy.summary !== void 0 ? { summary: legacy.summary } : {},
+          eventTime: { state: "unknown", reason: "unavailable" },
+          position: { state: "unknown", reason: "unavailable" },
+          sources: [
+            {
+              id: "legacy-input",
+              kind: "other",
+              access: "unknown",
+              digest: { algorithm: "sha256", value: digest }
+            }
+          ],
+          products: [],
+          methods: [],
+          frames: [],
+          assertions: [],
+          measurements: [],
+          processing: []
+        },
+        claims: []
+      };
+      const parsed = parseExperimentalClaimHistory2(proposal);
+      if (parsed.success) candidate = parsed.data;
+      else
+        reasons.push(
+          ...parsed.issues.map((issue) => `${issue.pointer}: ${issue.message}`)
+        );
+    }
+    return {
+      sourcePointer,
+      sourceId: object2(legacy) && typeof legacy.id === "string" ? legacy.id : null,
+      decision: candidate ? "candidate_requires_review" : "quarantined",
+      legacy: {
+        format: "disclosureos-v1-input",
+        validation: validation?.success ? "valid" : validation ? "invalid" : "not_checked",
+        // Do not re-serialize an over-depth tree; exact bytes and row pointer retain it.
+        ...pointers.length ? { data: legacy } : { retainedIn: "source.bytes" }
+      },
+      ...candidate ? { candidate } : {},
+      reasons,
+      mappingComplete: pointers.length > 0,
+      mapping: pointers.map(
+        (pointer) => mapping(pointer, candidate !== void 0)
+      )
+    };
+  });
+  const candidates = records.filter(
+    (row) => row.decision === "candidate_requires_review"
+  ).length;
+  return {
+    kind: "legacy_migration_dry_run",
+    schemaVersion: "0.1.0",
+    policy: POLICY,
+    namespace,
+    source: {
+      sha256: digest,
+      byteLength: bytes2.byteLength,
+      encoding: "base64",
+      bytes: Buffer.from(bytes2).toString("base64")
+    },
+    counts: {
+      input: rows.length,
+      candidates,
+      quarantined: rows.length - candidates,
+      migrated: 0
+    },
+    records
+  };
+}
+
+// src/commands/migration-review.ts
+var hash3 = (bytes2) => createHash7("sha256").update(bytes2).digest("hex");
+function decimalKey(literal) {
+  const [mantissa = "", exponent = "0"] = literal.toLowerCase().split("e");
+  if (exponent.replace(/^[+-]/, "").length > 6)
+    throw new Error("JSON numeric exponent exceeds review budget");
+  const negative = mantissa.startsWith("-");
+  const unsigned = negative ? mantissa.slice(1) : mantissa;
+  const [whole = "", fraction = ""] = unsigned.split(".");
+  let digits = (whole + fraction).replace(/^0+/, "");
+  if (!digits) return "0";
+  const withoutTrailing = digits.replace(/0+$/, "");
+  const scale = Number(exponent) - fraction.length + digits.length - withoutTrailing.length;
+  digits = withoutTrailing;
+  return `${negative ? "-" : ""}${digits}e${scale}`;
+}
+function reviewedJson(bytes2) {
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
+  const value = JSON.parse(text);
+  const stack = [];
+  for (let i = 0; i < text.length; ) {
+    const char = text[i];
+    if (char === "{" || char === "[") {
+      stack.push(char === "{" ? /* @__PURE__ */ new Set() : null);
+      if (stack.length > 64) throw new Error("Reviewed JSON exceeds depth 64");
+      i++;
+      continue;
+    }
+    if (char === "}" || char === "]") {
+      stack.pop();
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      const start = i++;
+      while (i < text.length) {
+        if (text[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (text[i++] === '"') break;
+      }
+      let after = i;
+      while (/\s/.test(text[after] ?? "") && after < text.length) after++;
+      if (text[after] === ":") {
+        const key = JSON.parse(text.slice(start, i));
+        const keys = stack[stack.length - 1];
+        if (keys?.has(key))
+          throw new Error(
+            "Duplicate JSON object key; reviewed mapping requires unambiguous input"
+          );
+        keys?.add(key);
+      }
+      continue;
+    }
+    if (char === "-" || char >= "0" && char <= "9") {
+      const start = i++;
+      while (i < text.length && !/[\s,\]}]/.test(text[i])) i++;
+      const literal = text.slice(start, i);
+      const number = Number(literal);
+      if (!Number.isFinite(number) || Number.isInteger(number) && !Number.isSafeInteger(number) || Object.is(number, -0) || decimalKey(literal) !== decimalKey(String(number))) {
+        throw new Error(
+          "Unsafe JSON numeric representation; reviewed mapping requires explicit source normalization"
+        );
+      }
+      continue;
+    }
+    i++;
+  }
+  return value;
+}
+function applyDecisions(row, decisions, plan, digest) {
+  if (!decisions.length) return { ...row, review: { status: "not_requested" } };
+  if (!row.candidate)
+    return {
+      ...row,
+      review: { status: "rejected", reason: "Base row is quarantined." }
+    };
+  const candidate = structuredClone(row.candidate);
+  const issues = [];
+  const mapped = /* @__PURE__ */ new Map();
+  const observation = { ...candidate.observation };
+  for (const decision of decisions) {
+    const prefix = decision.field === "eventTime" ? "/temporal/" : "/location/";
+    for (const pointer of decision.sourcePointers) {
+      if (!pointer.startsWith(prefix) || !row.mapping.some((field) => field.pointer === pointer)) {
+        issues.push(`Unknown or out-of-domain source pointer: ${pointer}`);
+      }
+      mapped.set(pointer, {
+        target: `/observation/${decision.field}`,
+        reason: decision.rationale
+      });
+    }
+    observation[decision.field] = decision.value;
+    if (decision.field === "position") observation.frames = decision.frames;
+  }
+  observation.extensions = {
+    "disclosureos.migration": {
+      policy: "legacy-migration-review:0.1.0",
+      reviewSha256: digest,
+      sourceId: row.sourceId,
+      sourcePointer: row.sourcePointer,
+      reviewedBy: plan.reviewedBy,
+      reviewedAt: plan.reviewedAt,
+      decisions,
+      reviewerIdentity: "not_authenticated",
+      scientificValidity: "not_checked"
+    }
+  };
+  const validated = parseExperimentalClaimHistory3({
+    ...candidate,
+    observation
+  });
+  if (!validated.success)
+    issues.push(
+      ...validated.issues.map((issue) => `${issue.pointer}: ${issue.message}`)
+    );
+  if (issues.length || !validated.success) {
+    const { candidate: omitted, ...rest } = row;
+    void omitted;
+    return {
+      ...rest,
+      decision: "quarantined",
+      reasons: [...row.reasons, ...issues],
+      mapping: row.mapping.map((field) => ({
+        pointer: field.pointer,
+        disposition: "unresolved",
+        reason: "Reviewed mapping rejected; no candidate emitted."
+      })),
+      review: { status: "rejected" }
+    };
+  }
+  return {
+    ...row,
+    candidate: validated.data,
+    mapping: row.mapping.map(
+      (field) => mapped.has(field.pointer) ? {
+        pointer: field.pointer,
+        disposition: "mapped",
+        ...mapped.get(field.pointer)
+      } : field
+    ),
+    review: {
+      status: "applied",
+      reviewerIdentity: "not_authenticated",
+      scientificValidity: "not_checked"
+    }
+  };
+}
+function reviewMigration(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "disclosureos migrate review <legacy.json> <review.json> [--json]\nApply explicit time/position decisions to review drafts; no imports or file writes."
+    );
+    return;
+  }
+  try {
+    if (args2.positional.length !== 2 || Object.keys(args2.flags).some((key) => key !== "json")) {
+      throw new Error(
+        "Usage: disclosureos migrate review <legacy.json> <review.json> [--json]"
+      );
+    }
+    const reviewBytes = readLocal(args2.positional[1], 2 * 1024 * 1024);
+    const source = readLocal(args2.positional[0], 8 * 1024 * 1024);
+    const report = buildReviewedMigration(source, reviewBytes);
+    if (args2.flags["json"]) console.log(JSON.stringify(report, null, 2));
+    else {
+      console.log(
+        `Experimental migration review: ${report.counts.input} inputs, ${report.counts.candidates} candidates, ${report.counts.quarantined} quarantined, 0 migrated.`
+      );
+      for (const row of report.records)
+        console.log(
+          JSON.stringify({
+            sourceId: row.sourceId,
+            decision: row.decision,
+            review: row.review,
+            unresolvedFields: row.mapping.filter(
+              (field) => field.disposition === "unresolved"
+            ).length,
+            reasons: row.reasons
+          })
+        );
+      console.log(
+        "Review identity and scientific validity remain unchecked. Use --json for pinned inputs, decisions and candidate mappings."
+      );
+    }
+    if (report.counts.quarantined) process.exitCode = 1;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "review_input",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+function buildReviewedMigration(source, reviewBytes) {
+  const parsed = MigrationReviewSchema.safeParse(reviewedJson(reviewBytes));
+  if (!parsed.success)
+    throw new Error(`Invalid review plan: ${parsed.error.message}`);
+  const plan = parsed.data;
+  if (hash3(source) !== plan.source.sha256 || source.byteLength !== plan.source.byteLength)
+    throw new Error(
+      "Source byte pin mismatch; regenerate and review decisions for the exact input"
+    );
+  reviewedJson(source);
+  const base = buildMigrationReport(source, plan.namespace);
+  const seen = /* @__PURE__ */ new Set();
+  const sourceIds = new Set(base.records.map((row) => row.sourceId));
+  const byId = /* @__PURE__ */ new Map();
+  for (const decision of plan.decisions) {
+    const key = JSON.stringify([decision.sourceId, decision.field]);
+    if (seen.has(key))
+      throw new Error("Duplicate decision for source ID and field");
+    seen.add(key);
+    const group = byId.get(decision.sourceId) ?? [];
+    group.push(decision);
+    byId.set(decision.sourceId, group);
+    if (!sourceIds.has(decision.sourceId))
+      throw new Error("Review decision names an unknown source ID");
+    if (new Set(decision.sourcePointers).size !== decision.sourcePointers.length)
+      throw new Error("Duplicate source pointer in review decision");
+  }
+  const digest = hash3(reviewBytes);
+  const records = base.records.map(
+    (row) => applyDecisions(row, byId.get(row.sourceId ?? "") ?? [], plan, digest)
+  );
+  const candidates = records.filter(
+    (row) => row.decision === "candidate_requires_review"
+  ).length;
+  return {
+    ...base,
+    kind: "legacy_migration_review_result",
+    policy: "legacy-migration-review:0.1.0",
+    review: {
+      sha256: digest,
+      byteLength: reviewBytes.byteLength,
+      encoding: "base64",
+      bytes: Buffer.from(reviewBytes).toString("base64"),
+      reviewerIdentity: "not_authenticated"
+    },
+    records,
+    counts: {
+      input: records.length,
+      candidates,
+      quarantined: records.length - candidates,
+      migrated: 0
+    }
+  };
+}
+
+// src/commands/migration-compatibility.ts
+var hash4 = (b) => createHash8("sha256").update(b).digest("hex");
+function unpack(blob) {
+  const bytes2 = Buffer.from(blob.bytes, "base64");
+  if (bytes2.toString("base64") !== blob.bytes || bytes2.length !== blob.byteLength || hash4(bytes2) !== blob.sha256)
+    throw new Error(
+      "Embedded artifact byte pin mismatch or noncanonical base64"
+    );
+  return bytes2;
+}
+var fieldPolicy = (pointer) => {
+  const root = pointer.split("/")[1];
+  if (["temporal", "location"].includes(root ?? ""))
+    return {
+      disposition: "unresolved",
+      reason: "Explicit time/frame review is available through migrate review; no sentinel or datum inference."
+    };
+  if (root === "sensorEvidence")
+    return {
+      disposition: "unresolved",
+      reason: "Sensor revision, acquisition, units and measurement provenance require explicit review; bare sensor labels and calibrated booleans are insufficient."
+    };
+  if ([
+    "observableAssessments",
+    "origin",
+    "investigation",
+    "testimony",
+    "physicalEvidence",
+    "documents",
+    "provenance",
+    "media",
+    "featuredMedia",
+    "internalNotes",
+    "extensions",
+    "status",
+    "schemaVersion",
+    "identifiers",
+    "dataSourceId",
+    "description",
+    "objectCharacteristics",
+    "eventType",
+    "sourceData",
+    "movement",
+    "witnesses",
+    "responseImpact",
+    "environment",
+    "relations",
+    "aviation"
+  ].includes(root ?? ""))
+    return {
+      disposition: "retained_without_conversion",
+      reason: "Retained in the original legacy envelope; no automatic v2 assertion, claim, measurement, publication or evaluation conversion is supported."
+    };
+  return {
+    disposition: "unresolved",
+    reason: "No supported conversion for this field; original bytes remain authoritative."
+  };
+};
+function compatibilityReport(source, namespace, reviewBytes) {
+  reviewedJson(source);
+  const base = buildMigrationReport(source, namespace);
+  let plan;
+  let context;
+  const decisions = /* @__PURE__ */ new Map();
+  const rowsById = /* @__PURE__ */ new Map();
+  for (const row of base.records) {
+    const group = rowsById.get(row.sourceId) ?? [];
+    group.push(row);
+    rowsById.set(row.sourceId, group);
+  }
+  if (reviewBytes) {
+    plan = MigrationCompatibilitySchema.parse(reviewedJson(reviewBytes));
+    if (plan.namespace !== namespace || plan.source.sha256 !== base.source.sha256 || plan.source.byteLength !== source.length)
+      throw new Error("Sensor review namespace or source pin mismatch");
+    context = parseAcquisitionContext(reviewedJson(unpack(plan.context)));
+    if (!context.success)
+      throw new Error(
+        "Invalid acquisition context: " + context.issues.map((i) => i.message).join("; ")
+      );
+    for (const d of plan.decisions) {
+      const key = JSON.stringify([d.sourceId, d.sensorPointer]);
+      if (decisions.has(key))
+        throw new Error("Duplicate sensor revision decision");
+      const rows = rowsById.get(d.sourceId) ?? [];
+      if (rows.length !== 1 || !rows[0].candidate)
+        throw new Error("Sensor review requires a unique, valid legacy row");
+      if (!rows[0].mapping.some((f) => f.pointer === d.sensorPointer))
+        throw new Error("Unknown legacy sensor pointer");
+      decisions.set(key, d);
+    }
+  }
+  const acquisitions = new Map(
+    context?.success ? context.data.acquisitions.map(
+      (a) => [`acquisition:${a.id}`, a]
+    ) : []
+  );
+  const manifests = new Map(
+    context?.success ? context.data.manifests.map((m) => [`manifest:${m.id}`, m]) : []
+  );
+  const records = base.records.map((row) => {
+    const sensors2 = row.mapping.filter(
+      (f) => /^\/sensorEvidence\/sensors\/(?:0|[1-9][0-9]*)\/sensorRef$/.test(
+        f.pointer
+      )
+    ).map((f) => {
+      const d = decisions.get(JSON.stringify([row.sourceId, f.pointer]));
+      const unresolved = {
+        sourcePointer: f.pointer,
+        status: "unresolved"
+      };
+      if (!d)
+        return {
+          ...unresolved,
+          reason: "No explicit revision review supplied."
+        };
+      try {
+        if (!("data" in row.legacy))
+          throw new Error("Legacy row data unavailable");
+        const data = row.legacy.data;
+        const sensor = data.sensorEvidence.sensors[Number(f.pointer.split("/")[3])];
+        if (sensor?.sensorRef !== d.legacyRef)
+          throw new Error("Declared legacy reference differs from source");
+        const acquisition = acquisitions.get(d.acquisitionRef);
+        if (!acquisition || acquisition.manifest.state !== "pinned")
+          throw new Error(
+            "Acquisition must explicitly pin a manifest; no automatic revision selection"
+          );
+        const manifestRef = acquisition.manifest.ref;
+        const manifest2 = manifests.get(manifestRef);
+        if (!manifest2) throw new Error("Pinned manifest is unavailable");
+        const manifestBytes = unpack(d.manifest);
+        unpack(d.provenance);
+        if (hash4(manifestBytes) !== manifest2.artifact.digest.value || manifestBytes.length !== manifest2.artifact.byteLength)
+          throw new Error("Manifest bytes differ from acquisition revision");
+        return {
+          sourcePointer: f.pointer,
+          status: "reviewed_revision_pin",
+          legacyRef: d.legacyRef,
+          acquisitionRef: d.acquisitionRef,
+          instrumentRef: acquisition.instrumentRef,
+          manifestRef,
+          manifestVersion: manifest2.version,
+          manifest: {
+            sha256: d.manifest.sha256,
+            byteLength: d.manifest.byteLength
+          },
+          provenance: {
+            sha256: d.provenance.sha256,
+            byteLength: d.provenance.byteLength,
+            locator: d.provenanceLocator
+          },
+          rationale: d.rationale,
+          associationSupport: "reviewer_declared_not_verified",
+          calibration: "not_checked",
+          measurementConversion: "not_performed"
+        };
+      } catch (error2) {
+        return {
+          ...unresolved,
+          reason: error2 instanceof Error ? error2.message : String(error2)
+        };
+      }
+    });
+    const fields2 = row.mapping.map((f) => ({
+      pointer: f.pointer,
+      ...f.disposition === "mapped" ? { disposition: "mapped", target: f.target, reason: f.reason } : row.candidate ? fieldPolicy(f.pointer) : {
+        disposition: "unresolved",
+        reason: "Source row quarantined; no conversion supported."
+      }
+    }));
+    return {
+      sourcePointer: row.sourcePointer,
+      sourceId: row.sourceId,
+      rowStatus: row.decision,
+      reasons: row.reasons,
+      mappingComplete: row.mappingComplete,
+      fields: fields2,
+      sensors: sensors2
+    };
+  });
+  const allFields = records.flatMap((r) => r.fields), sensors = records.flatMap((r) => r.sensors);
+  return {
+    kind: "legacy_migration_compatibility_report",
+    schemaVersion: "0.1.0",
+    policy: "legacy-migration-compatibility:0.1.0",
+    namespace,
+    source: base.source,
+    ...plan && reviewBytes ? {
+      review: {
+        sha256: hash4(reviewBytes),
+        byteLength: reviewBytes.length,
+        encoding: "base64",
+        bytes: Buffer.from(reviewBytes).toString("base64"),
+        reviewedBy: plan.reviewedBy,
+        reviewedAt: plan.reviewedAt,
+        reviewerIdentity: "not_authenticated"
+      }
+    } : {},
+    records,
+    counts: {
+      input: records.length,
+      candidates: base.counts.candidates,
+      quarantined: base.counts.quarantined,
+      fields: allFields.length,
+      mapped: allFields.filter((f) => f.disposition === "mapped").length,
+      retainedWithoutConversion: allFields.filter(
+        (f) => f.disposition === "retained_without_conversion"
+      ).length,
+      unresolved: allFields.filter((f) => f.disposition === "unresolved").length,
+      sensorReferences: sensors.length,
+      reviewedRevisionPins: sensors.filter(
+        (s) => s.status === "reviewed_revision_pin"
+      ).length,
+      unresolvedSensorReferences: sensors.filter(
+        (s) => s.status === "unresolved"
+      ).length,
+      indexImported: 0
+    },
+    scientificValidity: "not_checked",
+    applicationChanges: "none",
+    scope: "compatibility_inventory_and_declared_revision_review"
+  };
+}
+function migrationCompatibility(args2) {
+  const usage2 = "migrate compatibility <legacy.json> [sensor-review.json] --id <namespace> [--json]";
+  if (args2.flags["help"]) {
+    console.log(usage2);
+    return;
+  }
+  try {
+    const namespace = args2.flags["id"];
+    if (![1, 2].includes(args2.positional.length) || typeof namespace !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(namespace) || Object.keys(args2.flags).some((k) => !["id", "json"].includes(k)))
+      throw new Error(usage2);
+    const report = compatibilityReport(
+      readLocal(args2.positional[0], 8 * 1024 * 1024),
+      namespace,
+      args2.positional[1] ? readLocal(args2.positional[1], 2 * 1024 * 1024) : void 0
+    );
+    if (args2.flags["json"]) console.log(JSON.stringify(report, null, 2));
+    else
+      console.log(
+        `Compatibility: ${report.counts.input} rows; ${report.counts.mapped} mapped fields, ${report.counts.retainedWithoutConversion} retained without conversion, ${report.counts.unresolved} unresolved.
+Sensor references: ${report.counts.reviewedRevisionPins} reviewed pins, ${report.counts.unresolvedSensorReferences} unresolved. No application changes.`
+      );
+    if (report.counts.quarantined || report.counts.unresolved || report.counts.unresolvedSensorReferences)
+      process.exitCode = 1;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_compatibility",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+
+// src/commands/migration-legacy-scores.ts
+import { createHash as createHash9 } from "crypto";
+import { MigrationLegacyScoresSchema } from "@disclosureos/schema/experimental/v2";
+import {
+  CompletenessResultSchema,
+  ScoreResultSchema,
+  SCORING_SCHEMA_VERSION
+} from "@disclosureos/scoring";
+var hash5 = (bytes2) => createHash9("sha256").update(bytes2).digest("hex");
+var archive = (bytes2) => ({
+  sha256: hash5(bytes2),
+  byteLength: bytes2.byteLength,
+  encoding: "base64",
+  bytes: Buffer.from(bytes2).toString("base64")
+});
+function preserveLegacyScores(source, planBytes) {
+  const plan = MigrationLegacyScoresSchema.parse(reviewedJson(planBytes));
+  const sourceDigest = hash5(source), reviewDigest = hash5(planBytes);
+  if (sourceDigest !== plan.source.sha256 || source.byteLength !== plan.source.byteLength)
+    throw new Error("Legacy score source byte pin mismatch");
+  const input = reviewedJson(source);
+  const rows = Array.isArray(input) ? input : [input];
+  if (!rows.length || rows.length > 1e4)
+    throw new Error("Legacy score source requires 1 to 10000 rows");
+  const pointers = rows.map((_, i) => Array.isArray(input) ? `/${i}` : "");
+  const decisions = /* @__PURE__ */ new Map();
+  const knownPointers = new Set(pointers);
+  for (const decision of plan.decisions) {
+    if (!knownPointers.has(decision.sourcePointer))
+      throw new Error("Decision names an unknown whole-row source pointer");
+    if (decisions.has(decision.sourcePointer))
+      throw new Error("Duplicate decision for legacy score row");
+    decisions.set(decision.sourcePointer, decision);
+  }
+  const records = rows.map((data, index) => {
+    const sourcePointer = pointers[index];
+    const decision = decisions.get(sourcePointer);
+    const legacy = { format: "standalone_legacy_score_input", data };
+    if (!decision)
+      return {
+        sourcePointer,
+        disposition: "pending_review",
+        legacy,
+        reasons: [
+          "No explicit output contract, methodology version or observation association supplied."
+        ]
+      };
+    const reasons = [];
+    if (decision.outputContractVersion !== "2.0.0" || SCORING_SCHEMA_VERSION !== "2.0.0")
+      reasons.push(
+        "Unsupported historical scoring output contract; retained without conversion."
+      );
+    const validation = reasons.length ? void 0 : decision.resultKind === "compellingness" ? ScoreResultSchema.safeParse(data) : CompletenessResultSchema.safeParse(data);
+    if (validation && !validation.success)
+      reasons.push(
+        ...validation.error.issues.map(
+          (i) => `${i.path.join(".")}: ${i.message}`
+        )
+      );
+    if (decision.resultKind === "compellingness" && data && typeof data === "object" && !Array.isArray(data) && data.scoringVersion !== decision.methodologyVersion)
+      reasons.push(
+        "Declared methodology version does not match the stored scoringVersion"
+      );
+    if (reasons.length)
+      return {
+        sourcePointer,
+        disposition: "quarantined",
+        legacy,
+        decision,
+        reasons
+      };
+    const observationIdentity = `legacy-${hash5(
+      JSON.stringify([plan.namespace, decision.sourceId])
+    )}`;
+    return {
+      sourcePointer,
+      disposition: "preserved_historical",
+      legacy,
+      decision,
+      reasons,
+      historicalOutput: {
+        kind: "legacy_score_history",
+        schemaVersion: "0.1.0",
+        id: `legacy-score-${hash5(
+          JSON.stringify([
+            plan.namespace,
+            sourceDigest,
+            sourcePointer,
+            reviewDigest
+          ])
+        )}`,
+        association: {
+          sourceId: decision.sourceId,
+          observationIdentity,
+          verification: "declared_not_verified"
+        },
+        resultKind: decision.resultKind,
+        outputContract: {
+          package: "@disclosureos/scoring",
+          version: decision.outputContractVersion
+        },
+        methodologyVersion: decision.methodologyVersion,
+        // Keep original values, including additional fields. Never substitute stripping parser output.
+        value: data,
+        validation: "historical_output_shape_only",
+        calculation: "not_recomputed",
+        scientificValidity: "not_checked",
+        comparableToV2: false,
+        rankingEligibility: "excluded"
+      }
+    };
+  });
+  return {
+    kind: "legacy_score_preservation_report",
+    schemaVersion: "0.1.0",
+    policy: "legacy-score-preservation:0.1.0",
+    namespace: plan.namespace,
+    source: archive(source),
+    review: archive(planBytes),
+    reviewedBy: plan.reviewedBy,
+    reviewedAt: plan.reviewedAt,
+    reviewerIdentity: "not_authenticated",
+    records,
+    counts: {
+      input: rows.length,
+      preservedHistorical: records.filter(
+        (r) => r.disposition === "preserved_historical"
+      ).length,
+      pendingReview: records.filter((r) => r.disposition === "pending_review").length,
+      quarantined: records.filter((r) => r.disposition === "quarantined").length,
+      v2Evaluations: 0,
+      indexImported: 0
+    },
+    rankingPolicy: "exclude_legacy_scores_from_v2_rankings"
+  };
+}
+function legacyScores(args2) {
+  const usage2 = "migrate legacy-scores <scores.json> <preservation-plan.json> [--json]";
+  if (args2.flags["help"]) {
+    console.log(usage2);
+    return;
+  }
+  try {
+    if (args2.positional.length !== 2 || Object.keys(args2.flags).some((k) => k !== "json"))
+      throw new Error(usage2);
+    const report = preserveLegacyScores(
+      readLocal(args2.positional[0], 8 * 1024 * 1024),
+      readLocal(args2.positional[1], 2 * 1024 * 1024)
+    );
+    if (args2.flags["json"]) console.log(JSON.stringify(report, null, 2));
+    else
+      console.log(
+        `Legacy scores: ${report.counts.preservedHistorical} historical outputs preserved, ${report.counts.pendingReview} pending review, ${report.counts.quarantined} quarantined, 0 v2 evaluations.
+Historical values remain excluded from v2 rankings. Use --json for private retained data and declared associations.`
+      );
+    if (report.counts.quarantined || report.counts.pendingReview)
+      process.exitCode = 1;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "legacy_score_input",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+
+// src/commands/migration-read-path.ts
+import { createHash as createHash14, randomUUID as randomUUID3 } from "crypto";
+import {
+  mkdirSync as mkdirSync6,
+  lstatSync as lstatSync9,
+  readdirSync as readdirSync5,
+  openSync as openSync3,
+  writeFileSync as writeFileSync7,
+  fsyncSync as fsyncSync2,
+  closeSync as closeSync3,
+  linkSync as linkSync2,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { resolve as resolve11, join as join9, isAbsolute } from "path";
+
+// src/commands/migration-apply.ts
+import { createHash as createHash13, randomUUID as randomUUID2 } from "crypto";
+import {
+  mkdirSync as mkdirSync5,
+  lstatSync as lstatSync8,
+  readdirSync as readdirSync4,
+  openSync as openSync2,
+  writeFileSync as writeFileSync6,
+  fsyncSync,
+  closeSync as closeSync2,
+  linkSync,
+  unlinkSync
+} from "fs";
+import { resolve as resolve10, join as join8 } from "path";
+
+// src/commands/migration-ledger.ts
+import { createHash as createHash11 } from "crypto";
+import {
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync5,
+  rmSync as rmSync4,
+  lstatSync as lstatSync7,
+  readdirSync as readdirSync3
+} from "fs";
+import { resolve as resolve8, join as join7 } from "path";
+
+// src/commands/migration-export.ts
+import { createHash as createHash10 } from "crypto";
+import {
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync4,
+  rmSync as rmSync3,
+  lstatSync as lstatSync6,
+  readdirSync as readdirSync2
+} from "fs";
+import { resolve as resolve7, join as join6 } from "path";
+var POLICY2 = "legacy-migration-export:0.1.0";
+var TOTAL_LIMIT2 = 256 * 1024 * 1024;
+var json3 = (value) => Buffer.from(JSON.stringify(value, null, 2) + "\n");
+var pin2 = (bytes2) => ({
+  sha256: createHash10("sha256").update(bytes2).digest("hex"),
+  byteLength: bytes2.byteLength
+});
+function assembleMigrationBundle(source, review) {
+  const report = buildReviewedMigration(source, review);
+  const files = /* @__PURE__ */ new Map([
+    ["source.json", source],
+    ["review.json", review]
+  ]);
+  let total = source.byteLength + review.byteLength;
+  const add = (path, bytes2) => {
+    total += bytes2.byteLength;
+    if (total > TOTAL_LIMIT2)
+      throw new Error("Migration export exceeds 256 MiB budget");
+    files.set(path, bytes2);
+  };
+  add("report.json", json3(report));
+  const rows = report.records.map((row) => {
+    if ("candidate" in row && row.candidate && row.review.status === "applied") {
+      const path = `candidates/${row.candidate.observation.id}.json`;
+      add(path, json3(row.candidate));
+      return {
+        sourcePointer: row.sourcePointer,
+        sourceId: row.sourceId,
+        disposition: "exported",
+        path
+      };
+    }
+    return {
+      sourcePointer: row.sourcePointer,
+      sourceId: row.sourceId,
+      disposition: row.decision === "quarantined" ? "quarantined" : "pending_review"
+    };
+  });
+  const count = (disposition) => rows.filter((row) => row.disposition === disposition).length;
+  const manifest2 = {
+    kind: "legacy_migration_export",
+    schemaVersion: "0.1.0",
+    policy: POLICY2,
+    namespace: report.namespace,
+    counts: {
+      input: rows.length,
+      exported: count("exported"),
+      pendingReview: count("pending_review"),
+      quarantined: count("quarantined"),
+      migrated: 0
+    },
+    rows,
+    files: [...files].map(([path, bytes2]) => ({ path, ...pin2(bytes2) })),
+    reviewerIdentity: "not_authenticated",
+    scientificValidity: "not_checked"
+  };
+  add("manifest.json", json3(manifest2));
+  return { files, manifest: manifest2 };
+}
+function privateDirectory(path) {
+  const stat2 = lstatSync6(path);
+  if (!stat2.isDirectory() || (stat2.mode & 63) !== 0)
+    throw new Error("Expected a private real directory (0700)");
+}
+function compare(destination, bundle) {
+  privateDirectory(destination);
+  privateDirectory(join6(destination, "candidates"));
+  const rootNames = [
+    "candidates",
+    "manifest.json",
+    "report.json",
+    "review.json",
+    "source.json"
+  ];
+  const candidateNames = [...bundle.files.keys()].filter((path) => path.startsWith("candidates/")).map((path) => path.slice(11));
+  if (JSON.stringify(readdirSync2(destination).sort()) !== JSON.stringify(rootNames.sort()) || JSON.stringify(readdirSync2(join6(destination, "candidates")).sort()) !== JSON.stringify(candidateNames.sort())) {
+    throw new Error("Bundle conflict: unexpected or missing files");
+  }
+  for (const [path, expected] of bundle.files) {
+    const file = join6(destination, path);
+    const stat2 = lstatSync6(file);
+    if (!stat2.isFile() || (stat2.mode & 63) !== 0)
+      throw new Error(`Bundle conflict: nonprivate or nonregular file ${path}`);
+    const actual = readLocal(file, expected.byteLength);
+    if (!Buffer.from(actual).equals(Buffer.from(expected)))
+      throw new Error(`Bundle conflict: content differs at ${path}`);
+  }
+}
+function exportMigration(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "disclosureos migrate export <legacy.json> <review.json> --out <bundle> [--json]\ndisclosureos migrate verify <bundle> [--json]\nPrivate review artifacts only; no database imports."
+    );
+    return;
+  }
+  let created;
+  try {
+    const verify = args2.subcommand === "verify";
+    const output = args2.flags["out"];
+    if (verify ? args2.positional.length !== 1 || Object.keys(args2.flags).some((key) => key !== "json") : args2.positional.length !== 2 || typeof output !== "string" || Object.keys(args2.flags).some((key) => !["out", "json"].includes(key))) {
+      throw new Error(
+        "Usage: migrate export <legacy.json> <review.json> --out <bundle> [--json], or migrate verify <bundle> [--json]"
+      );
+    }
+    const destination = resolve7(
+      verify ? args2.positional[0] : output
+    );
+    if (verify) privateDirectory(destination);
+    const source = readLocal(
+      verify ? join6(destination, "source.json") : args2.positional[0],
+      8 * 1024 * 1024
+    );
+    const review = readLocal(
+      verify ? join6(destination, "review.json") : args2.positional[1],
+      2 * 1024 * 1024
+    );
+    const bundle = assembleMigrationBundle(source, review);
+    let action = "verified";
+    if (!verify) {
+      try {
+        mkdirSync3(destination, { mode: 448 });
+        created = destination;
+      } catch (error2) {
+        if (error2.code !== "EEXIST") throw error2;
+      }
+      if (created) {
+        mkdirSync3(join6(destination, "candidates"), { mode: 448 });
+        for (const [path, bytes2] of bundle.files)
+          writeFileSync4(join6(destination, path), bytes2, {
+            mode: 384,
+            flag: "wx"
+          });
+        action = "created";
+      } else action = "reused";
+    }
+    compare(destination, bundle);
+    created = void 0;
+    const result = {
+      success: true,
+      action,
+      directory: destination,
+      policy: POLICY2,
+      counts: bundle.manifest.counts,
+      manifest: pin2(bundle.files.get("manifest.json")),
+      verification: "current_code_replay",
+      migrationStatus: "not_imported",
+      reviewerIdentity: "not_authenticated",
+      scientificValidity: "not_checked"
+    };
+    if (args2.flags["json"]) console.log(JSON.stringify(result, null, 2));
+    else
+      console.log(
+        `Migration bundle ${action}: ${result.counts.exported} exported, ${result.counts.pendingReview} pending review, ${result.counts.quarantined} quarantined, 0 migrated.
+${destination}`
+      );
+    if (result.counts.quarantined || result.counts.pendingReview)
+      process.exitCode = 1;
+  } catch (error2) {
+    if (created) rmSync3(created, { recursive: true, force: true });
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_export",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+function verifiedMigrationBundle(destination) {
+  privateDirectory(destination);
+  const bundle = assembleMigrationBundle(
+    readLocal(join6(destination, "source.json"), 8 * 1024 * 1024),
+    readLocal(join6(destination, "review.json"), 2 * 1024 * 1024)
+  );
+  compare(destination, bundle);
+  return bundle;
+}
+
+// src/commands/migration-ledger.ts
+var POLICY3 = "legacy-migration-ledger:0.1.0";
+var pin3 = (bytes2) => ({
+  sha256: createHash11("sha256").update(bytes2).digest("hex"),
+  byteLength: bytes2.byteLength
+});
+var json4 = (value) => Buffer.from(JSON.stringify(value, null, 2) + "\n");
+var privateDir = (path) => {
+  const s = lstatSync7(path);
+  if (!s.isDirectory() || s.mode & 63)
+    throw new Error("Expected a private real ledger directory");
+};
+function planLedger(bundles) {
+  const unique = new Map(
+    bundles.map((bundle) => [
+      pin3(bundle.files.get("manifest.json")).sha256,
+      bundle
+    ])
+  );
+  const files = /* @__PURE__ */ new Map();
+  const dirs = /* @__PURE__ */ new Set(["", "inputs"]);
+  let total = 0;
+  const add = (path, bytes2) => {
+    total += bytes2.byteLength;
+    if (total > 256 * 1024 * 1024 || files.size >= 2e4)
+      throw new Error("Ledger exceeds 256 MiB or 20000-file budget");
+    files.set(path, bytes2);
+  };
+  const identities = /* @__PURE__ */ new Map();
+  const receipts = [...unique].sort(([a], [b]) => a.localeCompare(b)).map(([bundleId, bundle]) => {
+    const root = `inputs/${bundleId}`;
+    dirs.add(root);
+    dirs.add(`${root}/candidates`);
+    for (const [path, bytes2] of bundle.files) add(`${root}/${path}`, bytes2);
+    const rows2 = bundle.manifest.rows.map((row) => {
+      if (row.disposition !== "exported" || !row.path)
+        return { ...row, status: row.disposition };
+      const path = `${root}/${row.path}`;
+      const revision = pin3(bundle.files.get(row.path)).sha256;
+      const identity = row.path.slice("candidates/".length, -".json".length);
+      const revisions = identities.get(identity) ?? /* @__PURE__ */ new Map();
+      const occurrences = revisions.get(revision) ?? [];
+      occurrences.push({ bundleId, sourcePointer: row.sourcePointer, path });
+      revisions.set(revision, occurrences);
+      identities.set(identity, revisions);
+      return { ...row, identity, revision, status: "staged" };
+    });
+    return {
+      bundleId,
+      namespace: bundle.manifest.namespace,
+      manifest: pin3(bundle.files.get("manifest.json")),
+      rows: rows2
+    };
+  });
+  const inventory = [...identities].sort(([a], [b]) => a.localeCompare(b)).map(([identity, revisions]) => ({
+    identity,
+    status: revisions.size === 1 ? "ready_for_import_review" : "conflict",
+    revisions: [...revisions].sort(([a], [b]) => a.localeCompare(b)).map(([sha2562, occurrences]) => ({ sha256: sha2562, occurrences }))
+  }));
+  const conflicts = new Set(
+    inventory.filter((item) => item.status === "conflict").map((item) => item.identity)
+  );
+  const finalized = receipts.map((receipt) => ({
+    ...receipt,
+    rows: receipt.rows.map((row) => ({
+      ...row,
+      status: "identity" in row && conflicts.has(row.identity) ? "conflict" : row.status
+    }))
+  }));
+  const rows = finalized.flatMap((receipt) => receipt.rows);
+  const count = (status2) => rows.filter((row) => row.status === status2).length;
+  const ledger = {
+    kind: "legacy_migration_ledger",
+    schemaVersion: "0.1.0",
+    policy: POLICY3,
+    counts: {
+      bundles: unique.size,
+      input: rows.length,
+      stagedRows: count("staged"),
+      conflictRows: count("conflict"),
+      pendingReview: count("pending_review"),
+      quarantined: count("quarantined"),
+      identities: inventory.length,
+      conflictingIdentities: conflicts.size,
+      migrated: 0
+    },
+    receipts: finalized,
+    identities: inventory,
+    files: [...files].map(([path, bytes2]) => ({ path, ...pin3(bytes2) })),
+    verification: "current_code_replay",
+    reviewerIdentity: "not_authenticated",
+    applicationStatus: "not_imported"
+  };
+  add("ledger.json", json4(ledger));
+  return { files, dirs, ledger };
+}
+function compareLedger(root, plan) {
+  for (const dir of plan.dirs) {
+    const path = join7(root, dir);
+    privateDir(path);
+    const expected = /* @__PURE__ */ new Set();
+    const prefix = dir ? `${dir}/` : "";
+    for (const name2 of [...plan.dirs, ...plan.files.keys()])
+      if (name2.startsWith(prefix) && name2 !== dir)
+        expected.add(name2.slice(prefix.length).split("/")[0]);
+    if (JSON.stringify(readdirSync3(path).sort()) !== JSON.stringify([...expected].sort()))
+      throw new Error("Ledger conflict: missing or unexpected entries");
+  }
+  for (const [path, bytes2] of plan.files) {
+    const file = join7(root, path), stat2 = lstatSync7(file);
+    if (!stat2.isFile() || stat2.mode & 63)
+      throw new Error("Ledger conflict: nonprivate or nonregular artifact");
+    if (!Buffer.from(readLocal(file, bytes2.byteLength)).equals(Buffer.from(bytes2)))
+      throw new Error(`Ledger conflict: changed artifact ${path}`);
+  }
+}
+function migrationLedger(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "migrate ledger <bundle>... --out <ledger> [--json]\nmigrate ledger-verify <ledger> [--json]\nImmutable local staging receipts; no application imports."
+    );
+    return;
+  }
+  let created;
+  try {
+    const verify = args2.subcommand === "ledger-verify", output = args2.flags["out"];
+    if (verify ? args2.positional.length !== 1 || Object.keys(args2.flags).some((key) => key !== "json") : !args2.positional.length || args2.positional.length > 16 || typeof output !== "string" || Object.keys(args2.flags).some((key) => !["out", "json"].includes(key)))
+      throw new Error(
+        "Usage: migrate ledger <1-16 bundles> --out <ledger>, or migrate ledger-verify <ledger>"
+      );
+    const root = resolve8(verify ? args2.positional[0] : output);
+    let paths;
+    if (verify) {
+      privateDir(root);
+      privateDir(join7(root, "inputs"));
+      const ids = readdirSync3(join7(root, "inputs")).sort();
+      if (!ids.length || ids.length > 16 || ids.some((id) => !/^[a-f0-9]{64}$/.test(id)))
+        throw new Error("Invalid ledger input inventory");
+      paths = ids.map((id) => join7(root, "inputs", id));
+    } else paths = args2.positional.map((path) => resolve8(path));
+    let bytes2 = 0, entries = 0;
+    const bundles = paths.map((path) => {
+      const bundle = verifiedMigrationBundle(path);
+      for (const data of bundle.files.values()) bytes2 += data.byteLength;
+      entries += bundle.files.size;
+      if (bytes2 > 256 * 1024 * 1024 || entries >= 2e4)
+        throw new Error("Ledger input budget exceeded");
+      return bundle;
+    });
+    const plan = planLedger(bundles);
+    let action = "verified";
+    if (!verify) {
+      try {
+        mkdirSync4(root, { mode: 448 });
+        created = root;
+      } catch (error2) {
+        if (error2.code !== "EEXIST") throw error2;
+      }
+      if (created) {
+        for (const dir of plan.dirs)
+          if (dir) mkdirSync4(join7(root, dir), { mode: 448 });
+        for (const [path, data] of plan.files)
+          writeFileSync5(join7(root, path), data, { mode: 384, flag: "wx" });
+        action = "created";
+      } else action = "reused";
+    }
+    compareLedger(root, plan);
+    created = void 0;
+    const result = {
+      success: true,
+      action,
+      directory: root,
+      ledger: pin3(plan.files.get("ledger.json")),
+      counts: plan.ledger.counts,
+      applicationStatus: "not_imported",
+      verification: "current_code_replay"
+    };
+    if (args2.flags["json"]) console.log(JSON.stringify(result, null, 2));
+    else
+      console.log(
+        `Migration ledger ${action}: ${result.counts.stagedRows} staged, ${result.counts.conflictRows} conflicting, ${result.counts.pendingReview} pending, ${result.counts.quarantined} quarantined, 0 migrated.
+${root}`
+      );
+    if (result.counts.conflictRows || result.counts.pendingReview || result.counts.quarantined)
+      process.exitCode = 1;
+  } catch (error2) {
+    if (created) rmSync4(created, { recursive: true, force: true });
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_ledger",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+function verifiedMigrationLedger(root) {
+  privateDir(root);
+  privateDir(join7(root, "inputs"));
+  const ids = readdirSync3(join7(root, "inputs")).sort();
+  if (!ids.length || ids.length > 16 || ids.some((id) => !/^[a-f0-9]{64}$/.test(id)))
+    throw new Error("Invalid ledger input inventory");
+  let bytes2 = 0, entries = 0;
+  const bundles = ids.map((id) => {
+    const bundle = verifiedMigrationBundle(join7(root, "inputs", id));
+    for (const data of bundle.files.values()) bytes2 += data.byteLength;
+    entries += bundle.files.size;
+    if (bytes2 > 256 * 1024 * 1024 || entries >= 2e4)
+      throw new Error("Ledger input budget exceeded");
+    return bundle;
+  });
+  const plan = planLedger(bundles);
+  compareLedger(root, plan);
+  return plan;
+}
+
+// src/commands/migration-resolution.ts
+import { createHash as createHash12 } from "crypto";
+import { resolve as resolve9 } from "path";
+import {
+  MigrationResolutionSchema
+} from "@disclosureos/schema/experimental/v2";
+var pin4 = (bytes2) => ({
+  sha256: createHash12("sha256").update(bytes2).digest("hex"),
+  byteLength: bytes2.byteLength
+});
+function resolveMigration(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "migrate resolve <ledger> <decisions.json> [--json]\nExplicit pinned selection/defer decisions only; no application imports."
+    );
+    return;
+  }
+  try {
+    if (args2.positional.length !== 2 || Object.keys(args2.flags).some((key) => key !== "json"))
+      throw new Error(
+        "Usage: migrate resolve <ledger> <decisions.json> [--json]"
+      );
+    const bytes2 = readLocal(args2.positional[1], 2 * 1024 * 1024);
+    const snapshot = verifiedMigrationLedger(resolve9(args2.positional[0]));
+    const report = buildMigrationResolution(snapshot, bytes2);
+    if (args2.flags["json"]) console.log(JSON.stringify(report, null, 2));
+    else {
+      console.log(
+        `Migration resolution: ${report.selected.length} selected candidates, ${report.counts.deferredRows} deferred rows, ${report.counts.unresolvedRows} unresolved rows, ${report.counts.pendingReview} pending, ${report.counts.quarantined} quarantined, 0 migrated.`
+      );
+      for (const identity of report.identities)
+        console.log(
+          JSON.stringify({
+            identity: identity.identity,
+            status: identity.status,
+            decision: identity.decision
+          })
+        );
+      console.log(
+        "Selections are application planning choices, not scientific findings. Use --json for pinned decisions and complete row accounting."
+      );
+    }
+    if (report.counts.deferredRows || report.counts.unresolvedRows || report.counts.pendingReview || report.counts.quarantined)
+      process.exitCode = 1;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_resolution",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+function buildMigrationResolution(snapshot, bytes2) {
+  const parsed = MigrationResolutionSchema.safeParse(reviewedJson(bytes2));
+  if (!parsed.success)
+    throw new Error(`Invalid resolution plan: ${parsed.error.message}`);
+  const plan = parsed.data;
+  const ledgerPin = pin4(snapshot.files.get("ledger.json"));
+  if (plan.ledger.sha256 !== ledgerPin.sha256 || plan.ledger.byteLength !== ledgerPin.byteLength)
+    throw new Error(
+      "Ledger byte pin mismatch; decisions require the exact verified snapshot"
+    );
+  const inventory = new Map(
+    snapshot.ledger.identities.map((identity) => [identity.identity, identity])
+  );
+  const decisions = /* @__PURE__ */ new Map();
+  for (const decision of plan.decisions) {
+    if (decisions.has(decision.identity))
+      throw new Error("Duplicate resolution decision for identity");
+    const identity = inventory.get(decision.identity);
+    if (!identity) throw new Error("Resolution names an unknown identity");
+    if (decision.action === "select" && !identity.revisions.some(
+      (revision) => revision.sha256 === decision.revision
+    ))
+      throw new Error(
+        "Selected revision does not belong to the named identity"
+      );
+    decisions.set(decision.identity, decision);
+  }
+  const identities = snapshot.ledger.identities.map((identity) => {
+    const decision = decisions.get(identity.identity);
+    return {
+      ...identity,
+      ledgerStatus: identity.status,
+      status: decision?.action === "select" ? "selected" : decision ? "deferred" : "unresolved",
+      ...decision ? { decision } : {}
+    };
+  });
+  const selected = identities.flatMap((identity) => {
+    const decision = decisions.get(identity.identity);
+    if (decision?.action !== "select") return [];
+    const revision = identity.revisions.find(
+      (revision2) => revision2.sha256 === decision.revision
+    );
+    const occurrence = revision.occurrences[0];
+    return [
+      {
+        identity: identity.identity,
+        revision: revision.sha256,
+        path: occurrence.path,
+        candidate: pin4(snapshot.files.get(occurrence.path)),
+        occurrences: revision.occurrences
+      }
+    ];
+  });
+  const receipts = snapshot.ledger.receipts.map((receipt) => ({
+    ...receipt,
+    rows: receipt.rows.map((row) => {
+      if (!("identity" in row)) return { ...row, ledgerStatus: row.status };
+      const decision = decisions.get(row.identity);
+      const status2 = decision?.action === "select" ? decision.revision === row.revision ? "selected" : "not_selected" : decision ? "deferred" : "unresolved";
+      return { ...row, ledgerStatus: row.status, status: status2 };
+    })
+  }));
+  const rows = receipts.flatMap((receipt) => receipt.rows), count = (status2) => rows.filter((row) => row.status === status2).length;
+  return {
+    kind: "legacy_migration_resolution_result",
+    schemaVersion: "0.1.0",
+    policy: "legacy-migration-resolution:0.1.0",
+    ledger: ledgerPin,
+    plan: {
+      ...pin4(bytes2),
+      encoding: "base64",
+      bytes: Buffer.from(bytes2).toString("base64")
+    },
+    decidedBy: plan.decidedBy,
+    decidedAt: plan.decidedAt,
+    identities,
+    selected,
+    receipts,
+    counts: {
+      input: rows.length,
+      selectedRows: count("selected"),
+      notSelectedRows: count("not_selected"),
+      deferredRows: count("deferred"),
+      unresolvedRows: count("unresolved"),
+      pendingReview: count("pending_review"),
+      quarantined: count("quarantined"),
+      selectedCandidates: selected.length,
+      migrated: 0
+    },
+    decisionIdentity: "not_authenticated",
+    scientificValidity: "not_checked",
+    applicationStatus: "not_imported",
+    verification: "current_code_replay"
+  };
+}
+
+// src/commands/migration-apply.ts
+var POLICY4 = "legacy-migration-application:0.1.0";
+var LIMIT3 = 256 * 1024 * 1024;
+var pin5 = (bytes2) => ({
+  sha256: createHash13("sha256").update(bytes2).digest("hex"),
+  byteLength: bytes2.byteLength
+});
+var json5 = (value) => Buffer.from(JSON.stringify(value, null, 2) + "\n");
+var stat = (path) => {
+  try {
+    return lstatSync8(path);
+  } catch (error2) {
+    if (error2.code === "ENOENT") return void 0;
+    throw error2;
+  }
+};
+function directory4(path) {
+  const s = lstatSync8(path);
+  if (!s.isDirectory() || s.mode & 63)
+    throw new Error("Expected a private real application directory");
+}
+function exact(path, bytes2) {
+  const s = lstatSync8(path);
+  if (!s.isFile() || s.mode & 63)
+    throw new Error("Application artifact must be a private regular file");
+  if (!Buffer.from(readLocal(path, bytes2.byteLength)).equals(Buffer.from(bytes2)))
+    throw new Error(`Application conflict: changed artifact ${path}`);
+}
+function prepare(ledger, decisions) {
+  const snapshot = verifiedMigrationLedger(ledger), resolution = buildMigrationResolution(snapshot, decisions), c = resolution.counts;
+  if (c.deferredRows || c.unresolvedRows || c.pendingReview || c.quarantined || !resolution.selected.length)
+    throw new Error(
+      "Local application requires explicit selections for all identities, no pending/quarantined rows and at least one candidate"
+    );
+  const files = /* @__PURE__ */ new Map(), dirs = /* @__PURE__ */ new Set(["", ".pending", "ledger", "candidates"]);
+  let total = 0;
+  const add = (path, bytes2) => {
+    total += bytes2.byteLength;
+    if (total > LIMIT3 || files.size >= 3e4)
+      throw new Error("Application exceeds 256 MiB or 30000-file budget");
+    files.set(path, bytes2);
+  };
+  for (const dir of snapshot.dirs) if (dir) dirs.add(`ledger/${dir}`);
+  for (const [path, bytes2] of snapshot.files) add(`ledger/${path}`, bytes2);
+  add("resolution.json", decisions);
+  add("resolution-report.json", json5(resolution));
+  const candidates = resolution.selected.map((item) => {
+    const path = `candidates/${item.identity}.json`;
+    const bytes2 = snapshot.files.get(item.path);
+    add(path, bytes2);
+    return { ...item, path };
+  });
+  const receipt = {
+    kind: "legacy_migration_application_receipt",
+    schemaVersion: "0.1.0",
+    policy: POLICY4,
+    status: "complete",
+    target: "private_local_candidate_store",
+    ledger: resolution.ledger,
+    resolution: pin5(decisions),
+    counts: {
+      inputRows: c.input,
+      selectedRows: c.selectedRows,
+      retainedHistoricalRows: c.notSelectedRows,
+      appliedCandidates: candidates.length,
+      indexImported: 0
+    },
+    candidates,
+    files: [...files].map(([path, bytes2]) => ({ path, ...pin5(bytes2) })),
+    decisionIdentity: "not_authenticated",
+    scientificValidity: "not_checked",
+    readPath: "not_activated"
+  };
+  add("receipt.json", json5(receipt));
+  const intent = json5({
+    kind: "legacy_migration_application_intent",
+    schemaVersion: "0.1.0",
+    policy: POLICY4,
+    ledger: resolution.ledger,
+    resolution: pin5(decisions),
+    receipt: pin5(files.get("receipt.json"))
+  });
+  add("intent.json", intent);
+  return { files, dirs, receipt };
+}
+function inspect(root, plan, complete) {
+  directory4(root);
+  const children = /* @__PURE__ */ new Map();
+  for (const dir of plan.dirs) children.set(dir, /* @__PURE__ */ new Set());
+  for (const path of [...plan.dirs, ...plan.files.keys()]) {
+    if (!path) continue;
+    const slash = path.lastIndexOf("/");
+    children.get(slash < 0 ? "" : path.slice(0, slash)).add(path.slice(slash + 1));
+  }
+  for (const dir of plan.dirs) {
+    const path = join8(root, dir);
+    if (!stat(path)) {
+      if (complete)
+        throw new Error("Completed application is missing a directory");
+      continue;
+    }
+    directory4(path);
+    if (dir !== ".pending" && readdirSync4(path).some((name2) => !children.get(dir).has(name2)))
+      throw new Error("Application conflict: unexpected entries");
+  }
+  for (const [path, bytes2] of plan.files) {
+    if (stat(join8(root, path))) exact(join8(root, path), bytes2);
+    else if (complete)
+      throw new Error(`Completed application is missing ${path}`);
+  }
+  const pending = join8(root, ".pending");
+  if (stat(pending)) {
+    const names = readdirSync4(pending);
+    if (names.length > 64)
+      throw new Error("Application staging-file budget exceeded");
+    const expected = new Map(
+      [...plan.files.values()].map((bytes2) => [pin5(bytes2).sha256, bytes2])
+    );
+    let total = 0;
+    for (const name2 of names) {
+      if (!/^[a-f0-9]{64}-[a-f0-9-]{36}$/.test(name2))
+        throw new Error("Unexpected application staging file");
+      const bytes2 = expected.get(name2.slice(0, 64));
+      if (!bytes2) throw new Error("Unknown staged content");
+      const path = join8(pending, name2), s = stat(path);
+      if (!s) continue;
+      if (!s.isFile() || s.mode & 63)
+        throw new Error("Invalid staging file");
+      total += s.size;
+      if (total > LIMIT3)
+        throw new Error("Application staging-byte budget exceeded");
+      let partial;
+      try {
+        partial = readLocal(path, bytes2.byteLength);
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        throw error2;
+      }
+      if (!Buffer.from(bytes2).subarray(0, partial.byteLength).equals(Buffer.from(partial)))
+        throw new Error("Conflicting staged bytes");
+    }
+  }
+}
+function publish(root, path, bytes2) {
+  const target2 = join8(root, path);
+  if (stat(target2)) {
+    exact(target2, bytes2);
+    return;
+  }
+  const temporary = join8(
+    root,
+    ".pending",
+    `${pin5(bytes2).sha256}-${randomUUID2()}`
+  );
+  let fd;
+  try {
+    fd = openSync2(temporary, "wx", 384);
+    writeFileSync6(fd, bytes2);
+    fsyncSync(fd);
+    closeSync2(fd);
+    fd = void 0;
+    try {
+      linkSync(temporary, target2);
+    } catch (error2) {
+      if (error2.code !== "EEXIST") throw error2;
+      exact(target2, bytes2);
+    }
+  } finally {
+    if (fd !== void 0) closeSync2(fd);
+    if (stat(temporary)) unlinkSync(temporary);
+  }
+}
+function verifiedMigrationApplication(root) {
+  directory4(root);
+  const plan = prepare(
+    join8(root, "ledger"),
+    readLocal(join8(root, "resolution.json"), 2 * 1024 * 1024)
+  );
+  inspect(root, plan, true);
+  return plan;
+}
+function applyMigration(args2) {
+  if (args2.flags["help"]) {
+    console.log(
+      "migrate apply <ledger> <decisions.json> --out <store> [--json]\nmigrate apply-verify <store> [--json]\nPrivate local application only; Index read paths remain unchanged."
+    );
+    return;
+  }
+  try {
+    const verify = args2.subcommand === "apply-verify", out = args2.flags["out"];
+    if (verify ? args2.positional.length !== 1 || Object.keys(args2.flags).some((key) => key !== "json") : args2.positional.length !== 2 || typeof out !== "string" || Object.keys(args2.flags).some((key) => !["out", "json"].includes(key)))
+      throw new Error(
+        "Usage: migrate apply <ledger> <decisions.json> --out <store>, or migrate apply-verify <store>"
+      );
+    const root = resolve10(verify ? args2.positional[0] : out);
+    if (verify) directory4(root);
+    const plan = prepare(
+      verify ? join8(root, "ledger") : resolve10(args2.positional[0]),
+      readLocal(
+        verify ? join8(root, "resolution.json") : args2.positional[1],
+        2 * 1024 * 1024
+      )
+    );
+    let created = false;
+    if (!verify) {
+      try {
+        mkdirSync5(root, { mode: 448 });
+        created = true;
+      } catch (error2) {
+        if (error2.code !== "EEXIST") throw error2;
+      }
+    }
+    if (created) {
+      mkdirSync5(join8(root, ".pending"), { mode: 448 });
+      publish(root, "intent.json", plan.files.get("intent.json"));
+    } else exact(join8(root, "intent.json"), plan.files.get("intent.json"));
+    const completed = !!stat(join8(root, "receipt.json"));
+    inspect(root, plan, verify || completed);
+    if (!verify && !completed) {
+      for (const dir of plan.dirs)
+        if (dir) {
+          try {
+            mkdirSync5(join8(root, dir), { mode: 448 });
+          } catch (error2) {
+            if (error2.code !== "EEXIST") throw error2;
+            directory4(join8(root, dir));
+          }
+        }
+      for (const [path, bytes2] of plan.files)
+        if (path !== "receipt.json") publish(root, path, bytes2);
+      inspect(root, plan, false);
+      publish(root, "receipt.json", plan.files.get("receipt.json"));
+    }
+    inspect(root, plan, true);
+    const result = {
+      success: true,
+      action: verify ? "verified" : completed ? "reused" : created ? "applied" : "resumed",
+      directory: root,
+      receipt: pin5(plan.files.get("receipt.json")),
+      counts: plan.receipt.counts,
+      target: plan.receipt.target,
+      readPath: "not_activated",
+      verification: "current_code_replay"
+    };
+    if (args2.flags["json"]) console.log(JSON.stringify(result, null, 2));
+    else
+      console.log(
+        `Local migration ${result.action}: ${result.counts.appliedCandidates} candidates, ${result.counts.retainedHistoricalRows} historical rows retained, 0 Index imports.
+${root}`
+      );
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_application",
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+
+// src/commands/migration-read-path.ts
+var HASH = /^[a-f0-9]{64}$/;
+var LIMIT4 = 16384;
+var MAX_EVENTS = 1024;
+var bytes = (value) => Buffer.from(JSON.stringify(value, null, 2) + "\n");
+var pin6 = (value) => ({
+  sha256: createHash14("sha256").update(value).digest("hex"),
+  byteLength: value.byteLength
+});
+var name = (sequence) => `${String(sequence).padStart(6, "0")}.json`;
+function privateDirectory2(path) {
+  const stat2 = lstatSync9(path);
+  if (!stat2.isDirectory() || stat2.mode & 63)
+    throw new Error("Selector requires private real directories");
+}
+function privateFile(path) {
+  const stat2 = lstatSync9(path);
+  if (!stat2.isFile() || stat2.mode & 63)
+    throw new Error("Selector requires private regular files");
+  return readLocal(path, LIMIT4);
+}
+function object3(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid read transition object");
+  return value;
+}
+function target(value) {
+  const v = object3(value);
+  if (v.kind === "legacy") return { kind: "legacy" };
+  const p = object3(v.receipt);
+  if (v.kind !== "local_store" || typeof v.directory !== "string" || v.directory.length > 4096 || !isAbsolute(v.directory) || resolve11(v.directory) !== v.directory || typeof p.sha256 !== "string" || !HASH.test(p.sha256) || !Number.isSafeInteger(p.byteLength) || p.byteLength < 1 || p.byteLength > 256 * 1024 * 1024)
+    throw new Error("Invalid pinned local store target");
+  return {
+    kind: "local_store",
+    directory: v.directory,
+    receipt: { sha256: p.sha256, byteLength: p.byteLength }
+  };
+}
+function history(root) {
+  privateDirectory2(root);
+  privateDirectory2(join9(root, ".pending"));
+  const names = readdirSync5(root).filter((v) => v !== ".pending").sort();
+  if (!names.length || names.length > MAX_EVENTS || names.some((v, i) => v !== name(i)))
+    throw new Error(
+      "Selector history is missing, noncontiguous or exceeds its budget"
+    );
+  const pending = readdirSync5(join9(root, ".pending"));
+  if (pending.length > 64) throw new Error("Selector staging budget exceeded");
+  for (const n of pending) {
+    if (!/^[a-f0-9-]{36}$/.test(n))
+      throw new Error("Unexpected selector staging entry");
+    try {
+      privateFile(join9(root, ".pending", n));
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+    }
+  }
+  const entries = [];
+  for (const [i, n] of names.entries()) {
+    const raw = privateFile(join9(root, n));
+    const v = object3(reviewedJson(raw));
+    const t = target(v.target);
+    const previous = entries.at(-1)?.id ?? null;
+    let action;
+    let rollbackTo = null;
+    if (i === 0 && v.action === "initialize" && t.kind === "legacy")
+      action = "initialize";
+    else if (i > 0 && v.action === "activate" && t.kind === "local_store")
+      action = "activate";
+    else if (i > 0 && v.action === "rollback" && typeof v.rollbackTo === "string") {
+      const earlier = entries.find((e) => e.id === v.rollbackTo);
+      if (!earlier || !bytes(earlier.event.target).equals(bytes(t)))
+        throw new Error("Rollback must restore an earlier recorded target");
+      action = "rollback";
+      rollbackTo = v.rollbackTo;
+    } else throw new Error("Invalid read transition action");
+    const event = {
+      kind: "legacy_migration_read_transition",
+      schemaVersion: "0.1.0",
+      sequence: i,
+      previous,
+      action,
+      target: t,
+      rollbackTo
+    };
+    if (!bytes(event).equals(Buffer.from(raw)))
+      throw new Error("Changed or noncanonical selector history");
+    entries.push({ id: pin6(raw).sha256, event });
+  }
+  return entries;
+}
+function verifiedTarget(t) {
+  if (t.kind === "legacy") return [];
+  const plan = verifiedMigrationApplication(t.directory);
+  if (!bytes(pin6(plan.files.get("receipt.json"))).equals(bytes(t.receipt)))
+    throw new Error("Selected store receipt does not match its activation pin");
+  return plan.receipt.candidates.map((c) => ({
+    identity: c.identity,
+    revision: c.revision,
+    candidate: JSON.parse(
+      Buffer.from(plan.files.get(c.path)).toString("utf8")
+    )
+  }));
+}
+function publish2(root, event) {
+  const raw = bytes(event);
+  if (raw.length > LIMIT4)
+    throw new Error("Read transition exceeds byte budget");
+  const temporary = join9(root, ".pending", randomUUID3());
+  let fd;
+  try {
+    fd = openSync3(temporary, "wx", 384);
+    writeFileSync7(fd, raw);
+    fsyncSync2(fd);
+    closeSync3(fd);
+    fd = void 0;
+    linkSync2(temporary, join9(root, name(event.sequence)));
+  } finally {
+    if (fd !== void 0) closeSync3(fd);
+    try {
+      unlinkSync2(temporary);
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+    }
+  }
+}
+function migrationReadPath(args2) {
+  const usage2 = "migrate read-init --out <selector> [--json]\nmigrate read-path <selector> [--json]\nmigrate read-activate <selector> <completed-store> --id <expected-head> [--json]\nmigrate read-rollback <selector> <earlier-head> --id <expected-head> [--json]";
+  if (args2.flags["help"]) {
+    console.log(usage2);
+    return;
+  }
+  let currentHead;
+  try {
+    const init = args2.subcommand === "read-init", read = args2.subcommand === "read-path";
+    const allowed = init ? ["out", "json"] : read ? ["json"] : ["id", "json"];
+    if (Object.keys(args2.flags).some((k) => !allowed.includes(k)) || args2.positional.length !== (init ? 0 : read ? 1 : 2) || init && typeof args2.flags["out"] !== "string" || !init && !read && (typeof args2.flags["id"] !== "string" || !HASH.test(args2.flags["id"])))
+      throw new Error(usage2);
+    const root = resolve11(
+      init ? args2.flags["out"] : args2.positional[0]
+    );
+    if (init) {
+      mkdirSync6(root, { mode: 448 });
+      mkdirSync6(join9(root, ".pending"), { mode: 448 });
+      publish2(root, {
+        kind: "legacy_migration_read_transition",
+        schemaVersion: "0.1.0",
+        sequence: 0,
+        previous: null,
+        action: "initialize",
+        target: { kind: "legacy" },
+        rollbackTo: null
+      });
+    }
+    let entries = history(root);
+    currentHead = entries.at(-1).id;
+    if (!init && !read) {
+      const head2 = entries.at(-1);
+      if (args2.flags["id"] !== head2.id)
+        throw new Error(
+          "Stale expected read head; inspect the current selector before retrying"
+        );
+      if (entries.length >= MAX_EVENTS)
+        throw new Error("Selector transition budget exceeded");
+      let t;
+      let rollbackTo = null;
+      if (args2.subcommand === "read-activate") {
+        const directory5 = resolve11(args2.positional[1]);
+        const plan = verifiedMigrationApplication(directory5);
+        t = {
+          kind: "local_store",
+          directory: directory5,
+          receipt: pin6(plan.files.get("receipt.json"))
+        };
+      } else {
+        const earlier = entries.slice(0, -1).find((e) => e.id === args2.positional[1]);
+        if (!earlier)
+          throw new Error(
+            "Rollback target must be an earlier head in this selector"
+          );
+        t = earlier.event.target;
+        rollbackTo = earlier.id;
+        verifiedTarget(t);
+      }
+      publish2(root, {
+        kind: "legacy_migration_read_transition",
+        schemaVersion: "0.1.0",
+        sequence: entries.length,
+        previous: head2.id,
+        action: rollbackTo ? "rollback" : "activate",
+        target: t,
+        rollbackTo
+      });
+      entries = history(root);
+    }
+    const head = entries.at(-1);
+    currentHead = head.id;
+    const candidates = verifiedTarget(head.event.target);
+    const result = {
+      success: true,
+      scope: "private_local_read_selector",
+      head: head.id,
+      target: head.event.target,
+      history: entries,
+      candidates,
+      indexImported: 0,
+      scientificValidity: "not_checked",
+      decisionIdentity: "not_authenticated",
+      verification: "current_code_replay"
+    };
+    if (args2.flags["json"]) console.log(JSON.stringify(result, null, 2));
+    else
+      console.log(
+        `Local read path: ${head.event.target.kind}; ${candidates.length} verified candidates.
+Head: ${head.id}
+Index read path unchanged.`
+      );
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({
+          success: false,
+          stage: "migration_read_path",
+          head: currentHead,
+          error: message
+        })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+
+// src/commands/migrate.ts
+function migrate(args2) {
+  if (args2.subcommand === "compatibility") {
+    migrationCompatibility(args2);
+    return;
+  }
+  if (args2.subcommand === "legacy-scores") {
+    legacyScores(args2);
+    return;
+  }
+  if (["read-init", "read-path", "read-activate", "read-rollback"].includes(
+    args2.subcommand
+  )) {
+    migrationReadPath(args2);
+    return;
+  }
+  if (args2.subcommand === "apply" || args2.subcommand === "apply-verify") {
+    applyMigration(args2);
+    return;
+  }
+  if (args2.subcommand === "resolve") {
+    resolveMigration(args2);
+    return;
+  }
+  if (args2.subcommand === "ledger" || args2.subcommand === "ledger-verify") {
+    migrationLedger(args2);
+    return;
+  }
+  if (args2.subcommand === "export" || args2.subcommand === "verify") {
+    exportMigration(args2);
+    return;
+  }
+  if (args2.subcommand === "review") {
+    reviewMigration(args2);
+    return;
+  }
+  if (args2.flags["help"]) {
+    console.log(
+      "disclosureos migrate dry-run <legacy.json> --id <source-namespace> [--json]\nFor explicit mappings: disclosureos migrate review <legacy.json> <review.json> [--json]\nExport: disclosureos migrate export <legacy.json> <review.json> --out <bundle> [--json]\nVerify: disclosureos migrate verify <bundle> [--json]\nLedger: disclosureos migrate ledger <bundle>... --out <ledger> [--json]\nVerify ledger: disclosureos migrate ledger-verify <ledger> [--json]\nResolve: disclosureos migrate resolve <ledger> <decisions.json> [--json]\nApply locally: disclosureos migrate apply <ledger> <decisions.json> --out <store> [--json]\nVerify application: disclosureos migrate apply-verify <store> [--json]\nRead selector: disclosureos migrate read-path <selector> [--json]\nSee migrate read-init --help for activation and rollback.\nPreserve historical scores: disclosureos migrate legacy-scores <scores.json> <plan.json> [--json]\nField inventory and sensor review: disclosureos migrate compatibility <legacy.json> [sensor-review.json] --id <namespace> [--json]\nExperimental local artifacts only; no Index database writes."
+    );
+    return;
+  }
+  try {
+    const namespace = args2.flags["id"];
+    if (args2.subcommand !== "dry-run" || args2.positional.length !== 1 || typeof namespace !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(namespace) || Object.keys(args2.flags).some((key) => !["id", "json"].includes(key))) {
+      throw new Error(
+        "Usage: disclosureos migrate dry-run <legacy.json> --id <source-namespace> [--json]"
+      );
+    }
+    const bytes2 = readLocal(args2.positional[0], 8 * 1024 * 1024);
+    const report = buildMigrationReport(bytes2, namespace);
+    if (args2.flags["json"]) console.log(JSON.stringify(report, null, 2));
+    else {
+      console.log(
+        `Experimental migration dry run: ${report.counts.input} inputs, ${report.counts.candidates} review candidates, ${report.counts.quarantined} quarantined, 0 migrated.`
+      );
+      for (const row of report.records) {
+        console.log(
+          JSON.stringify({
+            sourcePointer: row.sourcePointer,
+            sourceId: row.sourceId,
+            decision: row.decision,
+            unresolvedFields: row.mapping.filter(
+              (field) => field.disposition === "unresolved"
+            ).length,
+            reasons: row.reasons
+          })
+        );
+      }
+      console.log(
+        "Use --json for exact source bytes, retained legacy data, candidates and field mappings. Every candidate requires explicit mapping review."
+      );
+    }
+    if (report.counts.quarantined > 0) process.exitCode = 1;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (args2.flags["json"])
+      console.log(
+        JSON.stringify({ success: false, stage: "input", error: message })
+      );
+    else console.error(message);
+    process.exitCode = 2;
+  }
+}
+
+// src/commands/completeness.ts
+import { parseEnrichedObservation as parseEnrichedObservation3 } from "@disclosureos/schema";
+import { getPopulationCoverage } from "@disclosureos/scoring";
+function completeness(args2) {
+  const population = args2.command === "population-coverage";
+  if (args2.flags["help"]) {
+    printUsage4(population);
+    return;
+  }
+  const targets = [args2.subcommand, ...args2.positional].filter((t) => !!t);
+  if (targets.length === 0) {
+    printUsage4(population);
+    return;
+  }
+  const recursive = !!args2.flags["recursive"];
+  const jsonMode = !!args2.flags["json"];
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  const emptyTargets = [];
+  for (const target2 of targets) {
+    const found = findJSONFiles(target2, recursive);
+    if (found.length === 0) {
+      emptyTargets.push(target2);
+      continue;
+    }
+    for (const f of found) {
+      if (!seen.has(f)) {
+        seen.add(f);
+        files.push(f);
+      }
+    }
+  }
+  if (jsonMode) {
+    runJsonMode2(files, emptyTargets);
+    return;
+  }
+  for (const t of emptyTargets) {
+    console.log(error(`No JSON files found at: ${t}`));
+  }
+  if (files.length === 0) {
+    process.exit(1);
+  }
+  let hasErrors = false;
+  const percentages = [];
+  const reqPercentages = [];
+  for (const file of files) {
+    const result = scoreFile(file, population);
+    if (!result.valid) {
+      hasErrors = true;
+      continue;
+    }
+    percentages.push(result.percentage);
+    reqPercentages.push(result.requiredPercentage);
+  }
+  console.log("");
+  if (hasErrors || emptyTargets.length > 0) {
+    console.log(error("Some files could not be scored (see errors above)."));
+    process.exit(1);
+  }
+  const mean = avg(percentages);
+  const reqMean = avg(reqPercentages);
+  console.log(
+    success(
+      `${files.length} file(s) scored \u2014 mean ${population ? "population coverage" : "completeness"} ${mean}%, required fields ${reqMean}%`
+    )
+  );
+}
+function avg(values) {
+  return values.length > 0 ? Math.round(values.reduce((a, b) => a + b, 0) / values.length) : 0;
+}
+function scoreFile(filePath, population = false) {
+  let data;
+  try {
+    data = readJSON(filePath);
+  } catch {
+    console.log(error(`Failed to parse: ${filePath}`));
+    return emptyResult(filePath, "Failed to parse JSON");
+  }
+  if (!data || typeof data !== "object") {
+    console.log(error(`${filePath}: not a valid JSON object`));
+    return emptyResult(filePath, "Not a valid JSON object");
+  }
+  const parsed = parseEnrichedObservation3(data);
+  if (!parsed.success) {
+    console.log(error(`${filePath}: invalid observation (${parsed.issues.length} issue${parsed.issues.length !== 1 ? "s" : ""})`));
+    for (const issue of parsed.issues.slice(0, 5)) {
+      console.log(`  ${dim(`${issue.path}: ${issue.message}`)}`);
+    }
+    return emptyResult(filePath, "Invalid observation");
+  }
+  const comp = getPopulationCoverage(data);
+  console.log(`
+${dim(filePath)}`);
+  console.log(`  ${population ? "Population coverage" : "Completeness"}: ${comp.percentage}%  (${comp.present}/${comp.total} fields)`);
+  console.log(`  Required:     ${comp.requiredPercentage}%  (${comp.requiredPresent}/${comp.requiredTotal})`);
+  if (comp.missing.length > 0) {
+    const shown = comp.missing.slice(0, 10);
+    console.log(`  Missing (top ${shown.length}):`);
+    for (const path of shown) {
+      console.log(`    ${dim("\u2022")} ${path}`);
+    }
+    if (comp.missing.length > shown.length) {
+      console.log(`    ${dim(`\u2026 and ${comp.missing.length - shown.length} more`)}`);
+    }
+  }
+  return {
+    file: filePath,
+    valid: true,
+    percentage: comp.percentage,
+    requiredPercentage: comp.requiredPercentage,
+    present: comp.present,
+    total: comp.total,
+    missing: comp.missing
+  };
+}
+function emptyResult(file, errorMsg) {
+  return {
+    file,
+    valid: false,
+    percentage: 0,
+    requiredPercentage: 0,
+    present: 0,
+    total: 0,
+    missing: [],
+    error: errorMsg
+  };
+}
+function runJsonMode2(files, emptyTargets) {
+  const fileResults = [];
+  for (const file of files) {
+    fileResults.push(scoreFileQuiet(file));
+  }
+  const validResults = fileResults.filter((r) => r.valid);
+  const meanPercentage = avg(validResults.map((r) => r.percentage));
+  const meanRequired = avg(validResults.map((r) => r.requiredPercentage));
+  const allValid = fileResults.every((r) => r.valid) && emptyTargets.length === 0;
+  const output = {
+    files: fileResults,
+    emptyTargets,
+    totals: {
+      files: files.length,
+      meanPercentage,
+      meanRequiredPercentage: meanRequired,
+      emptyTargets: emptyTargets.length
+    },
+    valid: allValid
+  };
+  console.log(JSON.stringify(output, null, 2));
+  if (!allValid) {
+    process.exit(1);
+  }
+}
+function scoreFileQuiet(filePath) {
+  let data;
+  try {
+    data = readJSON(filePath);
+  } catch {
+    return emptyResult(filePath, "Failed to parse JSON");
+  }
+  if (!data || typeof data !== "object") {
+    return emptyResult(filePath, "Not a valid JSON object");
+  }
+  const parsed = parseEnrichedObservation3(data);
+  if (!parsed.success) {
+    return emptyResult(filePath, `Invalid observation (${parsed.issues.length} issue${parsed.issues.length !== 1 ? "s" : ""})`);
+  }
+  const comp = getPopulationCoverage(data);
+  return {
+    file: filePath,
+    valid: true,
+    percentage: comp.percentage,
+    requiredPercentage: comp.requiredPercentage,
+    present: comp.present,
+    total: comp.total,
+    missing: comp.missing
+  };
+}
+function printUsage4(population = false) {
+  const command = population ? "population-coverage" : "completeness";
+  console.log(heading(`${BRAND} ${command}`));
+  console.log(`
+Measure how fully observation JSON files populate the records schema.
+`);
+  console.log(`${dim("Usage:")}`);
+  console.log(`  disclosureos ${command} <path...> [options]
+`);
+  console.log(`${dim("Paths:")}`);
+  console.log(`  Accepts one or more files, directories, or shell globs.
+`);
+  console.log(`${dim("Options:")}`);
+  console.log(`  --recursive, -r      Score all JSON files in directories recursively`);
+  console.log(`  --json, -j           Output results as structured JSON (for CI and scripts)`);
+  console.log(`  --help, -h           Show this help message
+`);
+  if (population) console.log("  Counts field presence in the legacy schema, not analytical readiness or scientific quality.\n");
+  console.log(`${dim("Scoring:")}`);
+  console.log(`  Files must be structurally valid observations before ${population ? "population coverage" : "completeness"} is measured.`);
+  console.log(`  Invalid JSON or invalid observations exit non-zero without a score.
+`);
+  console.log(`${dim("Output:")}`);
+  console.log(`  \u2022 ${population ? "Population coverage" : "Completeness"} percentage (0\u2013100) \u2014 how many schema fields are populated`);
+  console.log(`  \u2022 Required field percentage \u2014 coverage of required fields only`);
+  console.log(`  \u2022 Top missing field paths \u2014 ${population ? "absent paths, without applicability or priority judgments" : "the next fields to target"}
+`);
+  console.log(`${dim("Examples:")}`);
+  console.log(`  disclosureos ${command} ./data/nimitz.json`);
+  console.log(`  disclosureos ${command} ./data/ --recursive`);
+  console.log(`  disclosureos ${command} ./out/*.json --json
+`);
+}
+
+// src/commands/registry.ts
+import { deriveFieldPaths } from "@disclosureos/scoring";
+import {
+  ALL_OBSERVABLES,
+  TECHNOLOGY_OBSERVABLES,
+  BIOLOGICS_OBSERVABLES,
+  ASSESSMENT_LEVELS
+} from "@disclosureos/observables";
+import {
+  OCS_TAXONOMY,
+  getNode,
+  getChildren,
+  getTestableNodes,
+  ORIGIN_DOMAINS,
+  ORIGIN_DOMAIN_LABELS
+} from "@disclosureos/origins";
+function registry(args2) {
+  if (args2.flags["help"]) {
+    printUsage5();
+    return;
+  }
+  const sub = args2.subcommand;
+  switch (sub) {
+    case "fields":
+      registryFields(args2);
+      break;
+    case "observables":
+      registryObservables(args2);
+      break;
+    case "origins":
+      registryOrigins(args2);
+      break;
+    default:
+      printUsage5();
+  }
+}
+function registryFields(args2) {
+  const group = args2.flags["category"];
+  const paths = deriveFieldPaths();
+  const groups = /* @__PURE__ */ new Map();
+  for (const field of paths) {
+    const top = field.path.split(".")[0] ?? field.path;
+    const list = groups.get(top) ?? [];
+    list.push(field);
+    groups.set(top, list);
+  }
+  console.log(heading("Observation Field Registry (schema-derived)"));
+  if (group) {
+    const fields2 = groups.get(group);
+    if (!fields2 || fields2.length === 0) {
+      console.log(`
+  No fields found for group "${group}"`);
+      return;
+    }
+    console.log(`
+  Group: ${group}
+`);
+    const rows = fields2.map((f) => [f.path, f.required ? "required" : "optional"]);
+    console.log(table(rows));
+  } else {
+    for (const groupName of [...groups.keys()].sort()) {
+      const fields2 = groups.get(groupName);
+      console.log(`
+  ${groupName} (${fields2.length} fields)`);
+      for (const f of fields2) {
+        console.log(bullet(`${f.path}${f.required ? " [required]" : ""}`));
+      }
+    }
+  }
+  console.log(`
+  ${dim(`Total: ${paths.length} schema-derived field paths`)}
+`);
+}
+function registryObservables(args2) {
+  const biologicsOnly = !!args2.flags["biologics"];
+  const techOnly = !!args2.flags["technology"];
+  console.log(heading("Observable Registry"));
+  if (!biologicsOnly) {
+    console.log(`
+  Technology Observables (AATIP-derived)
+`);
+    const techObs = Object.values(TECHNOLOGY_OBSERVABLES);
+    for (const obs of techObs) {
+      console.log(`  ${obs.code}  ${obs.label}`);
+      if (obs.description) {
+        console.log(`       ${dim(obs.description)}`);
+      }
+    }
+  }
+  if (!techOnly) {
+    console.log(`
+  Biologics Observables (NHI Detection)
 `);
     const bioObs = Object.values(BIOLOGICS_OBSERVABLES);
     for (const obs of bioObs) {
@@ -1070,7 +4459,7 @@ ${label("ID", node.id)}`);
   }
   console.log("");
 }
-function printUsage4() {
+function printUsage5() {
   console.log(heading(`${BRAND} registry`));
   console.log(`
 Introspect DisclosureOS field, observable, and origin registries.
@@ -1110,7 +4499,7 @@ import {
 var FIELD_PATH_COUNT = deriveFieldPaths2().length;
 function info(args2) {
   if (args2.flags["help"]) {
-    printUsage5();
+    printUsage6();
     return;
   }
   const sub = args2.subcommand;
@@ -1257,7 +4646,7 @@ ${label("ID", node.id)}`);
   }
   console.log("");
 }
-function printUsage5() {
+function printUsage6() {
   console.log(heading(`${BRAND} info`));
   console.log(`
 Quick reference for DisclosureOS types and definitions.
@@ -1291,6 +4680,25 @@ if (args.flags["version"]) {
     case "validate":
       validate(args);
       break;
+    case "migrate":
+      migrate(args);
+      break;
+    case "profile":
+      await profile(args);
+      break;
+    case "intake":
+      await intake(args);
+      break;
+    case "dataset":
+      await dataset(args);
+      break;
+    case "packet":
+      await packet(args);
+      break;
+    case "manifest":
+      manifest(args);
+      break;
+    case "population-coverage":
     case "completeness":
       completeness(args);
       break;
@@ -1322,7 +4730,14 @@ function printHelp() {
   console.log(`${dim("Commands:")}`);
   console.log(`  scaffold       Generate typed data structure templates`);
   console.log(`  validate       Validate observation JSON files`);
-  console.log(`  completeness   Measure how fully observations populate the schema`);
+  console.log(`  manifest       Validate sensor-manifest JSON files`);
+  console.log(`  packet         Inspect, validate, or reproduce an experimental v2 packet`);
+  console.log(`  dataset        Inspect or validate an experimental dataset release`);
+  console.log(`  intake         Receive and verify unassessed source files locally`);
+  console.log(`  migrate        Plan experimental v1-to-v2 migration without importing`);
+  console.log(`  profile        List, inspect, or run explicit experimental profile checks`);
+  console.log(`  population-coverage  Count populated legacy observation fields`);
+  console.log(`  completeness   Legacy name for population coverage`);
   console.log(`  registry       Introspect field, observable, and origin registries`);
   console.log(`  info           Quick reference for types and definitions`);
   console.log(`  help           Show this help message`);
@@ -1335,7 +4750,7 @@ function printHelp() {
   console.log(`${dim("Examples:")}`);
   console.log(`  disclosureos scaffold observation --full`);
   console.log(`  disclosureos validate ./data/ --recursive`);
-  console.log(`  disclosureos completeness ./out/ --recursive`);
+  console.log(`  disclosureos population-coverage ./out/ --recursive`);
   console.log(`  disclosureos registry origins --id 1.1.3`);
   console.log(`  disclosureos info observable TO-3
 `);
@@ -1345,8 +4760,8 @@ function printVersion() {
 }
 function readCliVersion() {
   try {
-    const packagePath = join(
-      dirname(fileURLToPath(import.meta.url)),
+    const packagePath = join10(
+      dirname6(fileURLToPath2(import.meta.url)),
       "..",
       "package.json"
     );