@nimiplatform/nimi-coding 0.2.8 → 0.3.1

package/cli/lib/doctor.mjs

@@ -1,18 +1,163 @@
-import { inspectDoctorBootstrapSurface } from "./internal/doctor-bootstrap-surface.mjs";
-import { inspectDoctorDelegatedSurface } from "./internal/doctor-delegated-surface.mjs";
-import { finalizeDoctorState } from "./internal/doctor-finalize.mjs";
-import { formatDoctorResult as formatDoctorResultInternal } from "./internal/doctor-format.mjs";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+
+import { SPEC_GENERATION_AUDIT_REF } from "../constants.mjs";
+import { getBootstrapSeedEntries } from "../seeds/bootstrap.mjs";
+import { inspectBootstrapCompatibility } from "./bootstrap.mjs";
+import { loadSpecGenerationInputsConfig } from "./contracts.mjs";
+import { pathExists, readTextIfFile } from "./fs-helpers.mjs";
+import { runSeedSync, SYNC_MODE } from "./sync.mjs";
+import { localize, styleHeading, styleLabel, styleStatus } from "./ui.mjs";
+
+function check(id, ok, severity, detail) {
+  return { id, ok, severity: ok ? "ok" : severity, detail };
+}
+
+async function directoryHasFiles(root) {
+  const info = await pathExists(root);
+  if (!info || !info.isDirectory()) return false;
+  const entries = await readdir(root, { withFileTypes: true });
+  return entries.length > 0;
+}
+
+async function managedEntrypoints(projectRoot) {
+  const refs = [];
+  for (const ref of ["AGENTS.md", "CLAUDE.md"]) {
+    const text = await readTextIfFile(path.join(projectRoot, ref));
+    if (text?.includes("nimicoding:managed:")) refs.push(ref);
+  }
+  return refs;
+}
 
 export async function inspectDoctorState(projectRoot) {
-  const bootstrapSurface = await inspectDoctorBootstrapSurface(projectRoot);
-  if (bootstrapSurface.done) {
-    return bootstrapSurface.result;
+  const checks = [];
+  const bootstrap = await inspectBootstrapCompatibility(projectRoot);
+  checks.push(check(
+    "bootstrap_contract",
+    bootstrap.status === "supported",
+    "error",
+    bootstrap.status === "supported"
+      ? "bootstrap contract is supported"
+      : "bootstrap contract is missing or unsupported",
+  ));
+
+  let seedSync = null;
+  if (bootstrap.status === "supported") {
+    seedSync = await runSeedSync(projectRoot, SYNC_MODE.CHECK);
+    checks.push(check(
+      "managed_projection",
+      seedSync.ok,
+      "error",
+      seedSync.ok
+        ? `all ${seedSync.summary.total} package-managed files are aligned`
+        : `${seedSync.checkFailures.length} package-managed files are missing or drifted`,
+    ));
   }
 
-  const delegatedSurface = await inspectDoctorDelegatedSurface(projectRoot, bootstrapSurface);
-  return finalizeDoctorState(projectRoot, bootstrapSurface, delegatedSurface);
+  const generationInputs = await loadSpecGenerationInputsConfig(projectRoot);
+  checks.push(check(
+    "spec_generation_inputs",
+    generationInputs.ok && generationInputs.mode === "class_filtered",
+    "error",
+    generationInputs.ok && generationInputs.mode === "class_filtered"
+      ? "spec generation inputs use class-filtered authority"
+      : "spec generation inputs are missing or invalid",
+  ));
+
+  const specRoot = path.join(projectRoot, ".nimi", "spec");
+  const specPresent = await directoryHasFiles(specRoot);
+  checks.push(check(
+    "spec_tree",
+    true,
+    "info",
+    specPresent
+      ? "canonical spec tree is present; conformance is checked by validate-spec-tree or project-specific validators"
+      : "canonical spec tree has not been constructed yet",
+  ));
+
+  const auditPath = path.join(projectRoot, SPEC_GENERATION_AUDIT_REF);
+  const auditPresent = Boolean(await pathExists(auditPath));
+  checks.push(check(
+    "spec_generation_audit",
+    true,
+    "info",
+    auditPresent
+      ? "spec generation audit is present; conformance is checked by validate-spec-audit"
+      : "spec generation audit is not present",
+  ));
+
+  const entrypoints = await managedEntrypoints(projectRoot);
+  checks.push(check(
+    "entrypoint_integration",
+    true,
+    "info",
+    entrypoints.length > 0
+      ? `managed methodology guidance is present in ${entrypoints.join(", ")}`
+      : "managed methodology guidance is not installed",
+  ));
+
+  const seedEntries = await getBootstrapSeedEntries();
+  const ok = checks.every((entry) => entry.severity !== "error");
+
+  return {
+    ok,
+    projectRoot,
+    bootstrap,
+    managedProjection: seedSync,
+    generationInputs: {
+      ok: generationInputs.ok,
+      mode: generationInputs.mode ?? null,
+      canonicalTargetRoot: generationInputs.canonicalTargetRoot ?? null,
+    },
+    spec: {
+      present: specPresent,
+      ok: null,
+      summary: null,
+    },
+    generationAudit: {
+      present: auditPresent,
+      ok: null,
+      summary: null,
+    },
+    entrypoints,
+    managedFileCount: seedEntries.length,
+    checks,
+  };
 }
 
 export function formatDoctorResult(result, options = {}) {
-  return formatDoctorResultInternal(result, options);
+  const lines = [
+    styleHeading(`nimicoding doctor: ${result.projectRoot}`),
+    "",
+    styleLabel(localize("Summary:", "摘要：")),
+    `  - ${localize("status", "状态")}: ${styleStatus(result.ok ? "ok" : "needs_attention")}`,
+    `  - bootstrap: ${result.bootstrap.status}`,
+    `  - managed_projection: ${result.managedProjection?.ok === true ? "aligned" : "invalid"}`,
+    `  - spec: ${!result.spec.present ? "not_constructed" : "present_not_validated"}`,
+    `  - generation_audit: ${!result.generationAudit.present ? "not_present" : "present_not_validated"}`,
+    "",
+    styleLabel(localize("Checks:", "检查项：")),
+  ];
+
+  const visibleChecks = options.verbose
+    ? result.checks
+    : result.checks.filter((entry) => entry.severity !== "ok" || !entry.ok);
+  if (visibleChecks.length === 0) {
+    lines.push(`  - ${localize("No blocking issues found.", "没有发现阻塞问题。")}`);
+  } else {
+    for (const entry of visibleChecks) {
+      const marker = entry.ok ? "info" : entry.severity;
+      lines.push(`  - [${marker}] ${entry.detail}`);
+    }
+  }
+
+  if (!result.spec.present) {
+    lines.push(
+      "",
+      styleLabel(localize("Next:", "下一步：")),
+      "  - Build canonical product authority under .nimi/spec, then run nimicoding validate-spec-tree.",
+    );
+  }
+
+  return `${lines.join("\n")}\n`;
 }

package/cli/lib/entrypoints.mjs

@@ -10,85 +10,66 @@ import {
 import { pathExists } from "./fs-helpers.mjs";
 
 function managedAgentsBlock() {
-  return `${AGENTS_BEGIN}
-# Nimi Coding Managed Block
-
-- Read .nimi/methodology, .nimi/spec, and .nimi/contracts before high-risk changes.
-- Treat .nimi as the primary AI truth surface for this project.
-- Treat \`/.nimi/spec/**\` as the current repo-wide product authority for this project, and use Git history for retired pre-cutover authority evidence.
-- If .nimi/spec remains bootstrap-only, use .nimi/methodology/spec-reconstruction.yaml and .nimi/config/skills.yaml to drive AI-side truth reconstruction.
-- Treat .nimi/methodology/spec-target-truth-profile.yaml as repo-local support guidance for future governance slices, not as the canonical reconstruction completion target or a guaranteed fresh-bootstrap seed.
-- Treat .nimi/contracts/spec-reconstruction-result.yaml, .nimi/contracts/doc-spec-audit-result.yaml, .nimi/contracts/high-risk-execution-result.yaml, and .nimi/contracts/high-risk-admission.schema.yaml as machine contracts for reconstruction, audit, local-only high-risk closeout summaries, and local-only high-risk admission evidence.
-- Treat .nimi/config/skill-manifest.yaml, .nimi/config/host-profile.yaml, .nimi/config/host-adapter.yaml, .nimi/config/external-execution-artifacts.yaml, .nimi/config/skill-installer.yaml, .nimi/methodology/skill-runtime.yaml, .nimi/methodology/skill-installer-result.yaml, .nimi/methodology/skill-handoff.yaml, and admitted package-owned adapter profiles under adapters/**/profile.yaml as the canonical bridge to any external AI/skill execution.
-- Treat standalone nimicoding as boundary-complete for bootstrap, handoff, validation, projection, and explicit admission only; do not assume packaged run-kernel, provider, scheduler, notification, or automation ownership.
-- Treat .nimi/config/installer-evidence.yaml and .nimi/methodology/skill-installer-summary-projection.yaml as the operational-to-semantic installer projection boundary; do not promote concrete evidence artifacts into semantic truth.
-- Treat high-risk external execution closeout, decision, ingest, and review payloads under .nimi/local/** as local-only operational projections; they do not promote semantic truth automatically, even when manager-owned.
-- Use high-risk packetized execution only when authority, ownership, or cross-layer risk justifies it.
-- Keep inline manager-worker as the default methodology posture; do not assume a separate worker runtime is mandatory.
-- Keep code changes AI-context-efficient: favor bounded, cohesive files and split by responsibility during implementation instead of first concentrating unrelated logic into one file.
-- Keep the methodology continuity-agnostic; do not assume daemon, heartbeat, or persistent manager ownership.
-- Treat cutover readiness as preflight evidence only; the authority flip must come from an admitted cutover batch, not from readiness green by itself.
-- Do not treat this managed block as a replacement for project-specific rules outside .nimi.
-${AGENTS_END}`;
+  return [
+    AGENTS_BEGIN,
+    "# Nimi Coding Managed Block",
+    "",
+    "- Product and repository authority lives under `/.nimi/spec/**`.",
+    "- Read `/.nimi/spec/INDEX.md` first, then the affected kernel contracts and tables.",
+    "- Read `/.nimi/methodology/**` for reasoning principles and `/.nimi/contracts/**` for spec construction and validation contracts.",
+    "- Treat `/.nimi/{config,contracts,methodology}/**` as package-managed governance support, never as product authority.",
+    "- Keep generation evidence under `/.nimi/local/state/spec-generation/**`; it must not become product truth.",
+    "- Do not treat this managed block as a replacement for project-specific rules.",
+    AGENTS_END,
+  ].join("\n");
 }
-
 function managedClaudeBlock() {
-  return `${CLAUDE_BEGIN}
-# Nimi Coding Managed Block
-
-Use the project's .nimi layer as the primary AI truth surface.
-
-Priority:
-1. .nimi/methodology
-2. .nimi/spec
-3. .nimi/contracts
-4. .nimi/config
-5. repository-local AI entrypoint files
-
-If the project still exposes only bootstrap seed files, use the reconstruction guidance, result contracts, manifest, host-profile, host-adapter, admitted package-owned adapter profiles, installer, runtime contract, installer result contract, collapsed installer summary projection lifecycle contract, operational evidence guidance, and handoff truth under .nimi rather than assuming skills are already installed.
+  return [
+    CLAUDE_BEGIN,
+    "# Nimi Coding Managed Block",
+    "",
+    "Authority order:",
+    "1. `/.nimi/spec/**`",
+    "2. `/.nimi/methodology/**`",
+    "3. `/.nimi/contracts/**`",
+    "4. `/.nimi/config/**`",
+    "5. repository-local AI entry files",
+    "",
+    "Nimi Coding owns methodology, canonical spec construction, and deterministic validation only.",
+    "Keep local generation evidence outside product authority.",
+    CLAUDE_END,
+  ].join("\n");
+}
 
-Default posture:
-- use risk-shaped methodology only for authority-bearing or high-risk work
-- prefer inline manager-worker unless a later admitted packet expands runtime ownership
-- keep code changes AI-context-efficient: prefer bounded cohesive files and split by responsibility during implementation instead of first concentrating unrelated logic into one file
-- keep continuity-agnostic semantics; do not assume persistent automation or self-hosting
-- treat handoff --json as the authoritative machine contract and handoff --prompt as a human-readable projection only
-- treat \`/.nimi/spec/**\` as today's repo-wide authority, treat pre-cutover authority history as Git-only, and treat cutover readiness as historical preflight evidence rather than the authority source
-${CLAUDE_END}`;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
 }
 
-function upsertManagedBlock(existing, begin, end, block) {
-  const pattern = new RegExp(
-    `${begin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`,
+function blockPattern(begin, end, leading = false) {
+  return new RegExp(
+    `${leading ? "(?:\\n\\n)?" : ""}${escapeRegExp(begin)}[\\s\\S]*?${escapeRegExp(end)}${leading ? "(?:\\n)?" : ""}`,
   );
+}
 
+function upsertManagedBlock(existing, begin, end, block) {
+  const pattern = blockPattern(begin, end);
   if (pattern.test(existing)) {
     return existing.replace(pattern, block);
   }
-
   const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
   return `${existing}${prefix}${block}\n`;
 }
 
 function removeManagedBlock(existing, begin, end) {
-  const pattern = new RegExp(
-    `(?:\\n\\n)?${begin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\n)?`,
-  );
-
+  const pattern = blockPattern(begin, end, true);
   if (!pattern.test(existing)) {
-    return {
-      changed: false,
-      next: existing,
-      deleteFile: false,
-    };
+    return { changed: false, next: existing, deleteFile: false };
   }
-
   const next = existing
     .replace(pattern, "\n")
     .replace(/\n{3,}/g, "\n\n")
     .replace(/^\n+/, "")
     .trimEnd();
-
   return {
     changed: true,
     next: next.length === 0 ? "" : `${next}\n`,
@@ -99,59 +80,32 @@ function removeManagedBlock(existing, begin, end) {
 function computeTextFileUpdate(existing, block, begin, end, header) {
   const base = existing ?? header;
   const next = upsertManagedBlock(base, begin, end, block);
-  return {
-    changed: next !== base,
-    next,
-  };
+  return { changed: next !== base, next };
 }
 
 async function upsertTextFile(filePath, block, begin, end, header) {
   const existing = (await pathExists(filePath)) ? await readFile(filePath, "utf8") : header;
   const computed = computeTextFileUpdate(existing, block, begin, end, header);
-
-  if (!computed.changed) {
-    return false;
-  }
-
+  if (!computed.changed) return false;
   await writeFile(filePath, computed.next, "utf8");
   return true;
 }
 
 async function removeManagedTextFile(filePath, begin, end, emptyFallbackHeader = null) {
   const existing = (await pathExists(filePath)) ? await readFile(filePath, "utf8") : null;
-  if (existing === null) {
-    return {
-      changed: false,
-      removedFile: false,
-    };
-  }
-
+  if (existing === null) return { changed: false, removedFile: false };
   const computed = removeManagedBlock(existing, begin, end);
-  if (!computed.changed) {
-    return {
-      changed: false,
-      removedFile: false,
-    };
-  }
-
+  if (!computed.changed) return { changed: false, removedFile: false };
   if (computed.deleteFile || (emptyFallbackHeader && computed.next.trim() === emptyFallbackHeader.trim())) {
     await rm(filePath, { force: true });
-    return {
-      changed: true,
-      removedFile: true,
-    };
+    return { changed: true, removedFile: true };
   }
-
   await writeFile(filePath, computed.next, "utf8");
-  return {
-    changed: true,
-    removedFile: false,
-  };
+  return { changed: true, removedFile: false };
 }
 
-export async function previewEntrypointIntegration(projectRoot) {
-  const updates = [];
-  const files = [
+function entrypointDefinitions(projectRoot) {
+  return [
     {
       path: path.join(projectRoot, "AGENTS.md"),
       block: managedAgentsBlock(),
@@ -169,106 +123,48 @@ export async function previewEntrypointIntegration(projectRoot) {
       relativePath: "CLAUDE.md",
     },
   ];
+}
 
-  for (const file of files) {
+export async function previewEntrypointIntegration(projectRoot) {
+  const updates = [];
+  for (const file of entrypointDefinitions(projectRoot)) {
     const existing = (await pathExists(file.path)) ? await readFile(file.path, "utf8") : null;
-    const computed = computeTextFileUpdate(existing, file.block, file.begin, file.end, file.header);
-    if (computed.changed) {
+    if (computeTextFileUpdate(existing, file.block, file.begin, file.end, file.header).changed) {
       updates.push(file.relativePath);
     }
   }
-
   return updates;
 }
 
 export async function integrateEntrypoints(projectRoot) {
   const updated = [];
-
-  if (
-    await upsertTextFile(
-      path.join(projectRoot, "AGENTS.md"),
-      managedAgentsBlock(),
-      AGENTS_BEGIN,
-      AGENTS_END,
-      "# AGENTS.md\n",
-    )
-  ) {
-    updated.push("AGENTS.md");
-  }
-
-  if (
-    await upsertTextFile(
-      path.join(projectRoot, "CLAUDE.md"),
-      managedClaudeBlock(),
-      CLAUDE_BEGIN,
-      CLAUDE_END,
-      "# CLAUDE.md\n",
-    )
-  ) {
-    updated.push("CLAUDE.md");
+  for (const file of entrypointDefinitions(projectRoot)) {
+    if (await upsertTextFile(file.path, file.block, file.begin, file.end, file.header)) {
+      updated.push(file.relativePath);
+    }
   }
-
   return updated;
 }
 
 export async function previewEntrypointRemoval(projectRoot) {
   const updates = [];
-  const files = [
-    {
-      path: path.join(projectRoot, "AGENTS.md"),
-      begin: AGENTS_BEGIN,
-      end: AGENTS_END,
-      relativePath: "AGENTS.md",
-    },
-    {
-      path: path.join(projectRoot, "CLAUDE.md"),
-      begin: CLAUDE_BEGIN,
-      end: CLAUDE_END,
-      relativePath: "CLAUDE.md",
-    },
-  ];
-
-  for (const file of files) {
+  for (const file of entrypointDefinitions(projectRoot)) {
     const existing = (await pathExists(file.path)) ? await readFile(file.path, "utf8") : null;
-    if (existing === null) {
-      continue;
-    }
-
-    const computed = removeManagedBlock(existing, file.begin, file.end);
-    if (computed.changed) {
+    if (existing !== null && removeManagedBlock(existing, file.begin, file.end).changed) {
       updates.push(file.relativePath);
     }
   }
-
   return updates;
 }
 
 export async function removeManagedEntrypoints(projectRoot) {
   const updatedFiles = [];
   const removedFiles = [];
-
-  const agentsResult = await removeManagedTextFile(
-    path.join(projectRoot, "AGENTS.md"),
-    AGENTS_BEGIN,
-    AGENTS_END,
-    "# AGENTS.md",
-  );
-  if (agentsResult.changed) {
-    (agentsResult.removedFile ? removedFiles : updatedFiles).push("AGENTS.md");
-  }
-
-  const claudeResult = await removeManagedTextFile(
-    path.join(projectRoot, "CLAUDE.md"),
-    CLAUDE_BEGIN,
-    CLAUDE_END,
-    "# CLAUDE.md",
-  );
-  if (claudeResult.changed) {
-    (claudeResult.removedFile ? removedFiles : updatedFiles).push("CLAUDE.md");
+  for (const file of entrypointDefinitions(projectRoot)) {
+    const result = await removeManagedTextFile(file.path, file.begin, file.end, file.header.trim());
+    if (result.changed) {
+      (result.removedFile ? removedFiles : updatedFiles).push(file.relativePath);
+    }
   }
-
-  return {
-    updatedFiles,
-    removedFiles,
-  };
+  return { updatedFiles, removedFiles };
 }

package/cli/lib/internal/contracts-loaders.mjs

@@ -1,39 +1,17 @@
 import path from "node:path";
 
 import {
-  AUDIT_SWEEP_RESULT_CONTRACT_REF,
-  ACCEPTANCE_SCHEMA_REF,
   BLUEPRINT_REFERENCE_REF,
-  COMMAND_GATING_MATRIX_REF,
-  DOC_SPEC_AUDIT_RESULT_CONTRACT_REF,
-  EXTERNAL_HOST_COMPATIBILITY_CONTRACT_REF,
-  EXECUTION_PACKET_SCHEMA_REF,
-  HIGH_RISK_ADMISSION_CONTRACT_REF,
-  HIGH_RISK_EXECUTION_RESULT_CONTRACT_REF,
-  ORCHESTRATION_STATE_SCHEMA_REF,
-  PROMPT_SCHEMA_REF,
   SPEC_GENERATION_AUDIT_CONTRACT_REF,
   SPEC_GENERATION_INPUTS_CONTRACT_REF,
   SPEC_GENERATION_INPUTS_REF,
-  SPEC_RECONSTRUCTION_RESULT_CONTRACT_REF,
-  SPEC_TREE_MODEL_REF,
-  WORKER_OUTPUT_SCHEMA_REF,
 } from "../../constants.mjs";
 import { readTextIfFile } from "../fs-helpers.mjs";
 import {
   parseBlueprintReference,
-  parseCommandGatingMatrix,
-  parseAuditSweepContract,
-  parseDocSpecAuditContract,
-  parseExternalHostCompatibilityContract,
-  parseHighRiskAdmissionContract,
-  parseHighRiskExecutionContract,
-  parseHighRiskSchemaContract,
   parseSpecGenerationAuditContract,
   parseSpecGenerationInputsConfig,
   parseSpecGenerationInputsContract,
-  parseSpecReconstructionContract,
-  parseSpecTreeModel,
 } from "./contracts-parse.mjs";
 
 async function loadParsedYaml(projectRoot, relativePath, parse) {
@@ -44,19 +22,6 @@ async function loadParsedYaml(projectRoot, relativePath, parse) {
     ...parse(text),
   };
 }
-
-export function loadSpecReconstructionContract(projectRoot) {
-  return loadParsedYaml(
-    projectRoot,
-    SPEC_RECONSTRUCTION_RESULT_CONTRACT_REF,
-    parseSpecReconstructionContract,
-  );
-}
-
-export function loadSpecTreeModelContract(projectRoot) {
-  return loadParsedYaml(projectRoot, SPEC_TREE_MODEL_REF, parseSpecTreeModel);
-}
-
 export function loadSpecGenerationInputsContract(projectRoot) {
   return loadParsedYaml(
     projectRoot,
@@ -77,56 +42,6 @@ export function loadSpecGenerationInputsConfig(projectRoot) {
   return loadParsedYaml(projectRoot, SPEC_GENERATION_INPUTS_REF, parseSpecGenerationInputsConfig);
 }
 
-export function loadCommandGatingMatrix(projectRoot) {
-  return loadParsedYaml(projectRoot, COMMAND_GATING_MATRIX_REF, parseCommandGatingMatrix);
-}
-
 export function loadBlueprintReference(projectRoot) {
   return loadParsedYaml(projectRoot, BLUEPRINT_REFERENCE_REF, parseBlueprintReference);
 }
-
-export function loadDocSpecAuditContract(projectRoot) {
-  return loadParsedYaml(projectRoot, DOC_SPEC_AUDIT_RESULT_CONTRACT_REF, parseDocSpecAuditContract);
-}
-
-export function loadAuditSweepContract(projectRoot) {
-  return loadParsedYaml(projectRoot, AUDIT_SWEEP_RESULT_CONTRACT_REF, parseAuditSweepContract);
-}
-
-export function loadHighRiskExecutionContract(projectRoot) {
-  return loadParsedYaml(projectRoot, HIGH_RISK_EXECUTION_RESULT_CONTRACT_REF, parseHighRiskExecutionContract);
-}
-
-export function loadHighRiskAdmissionContract(projectRoot) {
-  return loadParsedYaml(projectRoot, HIGH_RISK_ADMISSION_CONTRACT_REF, parseHighRiskAdmissionContract);
-}
-
-export function loadExternalHostCompatibilityContract(projectRoot) {
-  return loadParsedYaml(
-    projectRoot,
-    EXTERNAL_HOST_COMPATIBILITY_CONTRACT_REF,
-    parseExternalHostCompatibilityContract,
-  );
-}
-
-export async function loadHighRiskSchemaContracts(projectRoot) {
-  const contractRefs = [
-    EXECUTION_PACKET_SCHEMA_REF,
-    ORCHESTRATION_STATE_SCHEMA_REF,
-    PROMPT_SCHEMA_REF,
-    WORKER_OUTPUT_SCHEMA_REF,
-    ACCEPTANCE_SCHEMA_REF,
-  ];
-
-  const results = [];
-  for (const schemaRef of contractRefs) {
-    const text = await readTextIfFile(path.join(projectRoot, schemaRef));
-    results.push({
-      path: schemaRef,
-      text,
-      ...parseHighRiskSchemaContract(text, schemaRef),
-    });
-  }
-
-  return results;
-}