@nimiplatform/nimi-coding 0.3.0 → 0.4.0

package/cli/lib/blueprint-audit.mjs

@@ -1,363 +0,0 @@
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import YAML from "yaml";
-
-import { loadBlueprintReference, loadSpecGenerationInputsConfig } from "./contracts.mjs";
-import { pathExists } from "./fs-helpers.mjs";
-import {
-  localize,
-  styleHeading,
-  styleLabel,
-  styleStatus,
-} from "./ui.mjs";
-
-const BLUEPRINT_AUDIT_CONTRACT_VERSION = "nimicoding.blueprint-audit.v2";
-const DEFAULT_REPORT_PATH = ".nimi/local/state/spec-generation/blueprint-equivalence-audit.json";
-
-async function collectFiles(rootPath, relativePrefix = "") {
-  const info = await pathExists(rootPath);
-  if (!info || !info.isDirectory()) {
-    return [];
-  }
-
-  const entries = await readdir(rootPath, { withFileTypes: true });
-  const collected = [];
-  for (const entry of entries) {
-    const absoluteChildPath = path.join(rootPath, entry.name);
-    const relativeChildPath = relativePrefix ? path.posix.join(relativePrefix, entry.name) : entry.name;
-    if (entry.isDirectory()) {
-      collected.push(...await collectFiles(absoluteChildPath, relativeChildPath));
-    } else if (entry.isFile()) {
-      collected.push(relativeChildPath.split(path.sep).join(path.posix.sep));
-    }
-  }
-
-  return collected.sort();
-}
-
-async function collectDomainInventory(rootPath) {
-  const info = await pathExists(rootPath);
-  if (!info || !info.isDirectory()) {
-    return {
-      domains: [],
-      hasIndex: false,
-      files: [],
-    };
-  }
-
-  const entries = await readdir(rootPath, { withFileTypes: true });
-  const domains = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-
-    const kernelPath = path.join(rootPath, entry.name, "kernel");
-    const kernelInfo = await pathExists(kernelPath);
-    if (kernelInfo?.isDirectory()) {
-      domains.push(entry.name);
-    }
-  }
-
-  const indexInfo = await pathExists(path.join(rootPath, "INDEX.md"));
-  const files = await collectFiles(rootPath);
-
-  return {
-    domains: domains.sort(),
-    hasIndex: Boolean(indexInfo?.isFile()),
-    files,
-  };
-}
-
-function categorizeBlueprintFiles(files) {
-  const kernelMarkdown = [];
-  const kernelTables = [];
-  const kernelGenerated = [];
-  const domainGuides = [];
-
-  for (const relativePath of files) {
-    if (/^([^/]+)\/kernel\/[^/]+\.md$/.test(relativePath)) {
-      kernelMarkdown.push(relativePath);
-      continue;
-    }
-
-    if (/^([^/]+)\/kernel\/tables\/.+\.(ya?ml)$/.test(relativePath)) {
-      kernelTables.push(relativePath);
-      continue;
-    }
-
-    if (/^([^/]+)\/kernel\/generated\/.+\.md$/.test(relativePath)) {
-      kernelGenerated.push(relativePath);
-      continue;
-    }
-
-    if (/^[^/]+\/[^/]+\.md$/.test(relativePath)) {
-      domainGuides.push(relativePath);
-    }
-  }
-
-  return {
-    kernelMarkdown,
-    kernelTables,
-    kernelGenerated,
-    domainGuides,
-  };
-}
-
-function compareFileSets(blueprintFiles, canonicalFiles) {
-  const canonicalSet = new Set(canonicalFiles);
-  const blueprintSet = new Set(blueprintFiles);
-
-  return {
-    present: blueprintFiles.filter((filePath) => canonicalSet.has(filePath)),
-    missing: blueprintFiles.filter((filePath) => !canonicalSet.has(filePath)),
-    extra: canonicalFiles.filter((filePath) => !blueprintSet.has(filePath)),
-  };
-}
-
-function buildSummarySection(compareResult) {
-  return {
-    present: compareResult.present.length,
-    missing: compareResult.missing.length,
-    extra: compareResult.extra.length,
-  };
-}
-
-function collectIds(value, ids = []) {
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      collectIds(entry, ids);
-    }
-    return ids;
-  }
-
-  if (value && typeof value === "object") {
-    if (typeof value.id === "string") {
-      ids.push(value.id);
-    }
-    for (const nestedValue of Object.values(value)) {
-      collectIds(nestedValue, ids);
-    }
-  }
-
-  return ids;
-}
-
-async function compareRuleIds(blueprintAbsoluteRoot, canonicalAbsoluteRoot, presentTablePaths) {
-  const files = [];
-  const aggregateMissing = new Set();
-  const aggregateExtra = new Set();
-  const parseErrors = [];
-
-  for (const relativePath of presentTablePaths) {
-    try {
-      const blueprintText = await readFile(path.join(blueprintAbsoluteRoot, relativePath), "utf8");
-      const canonicalText = await readFile(path.join(canonicalAbsoluteRoot, relativePath), "utf8");
-      const blueprintIds = Array.from(new Set(collectIds(YAML.parse(blueprintText)))).sort();
-      const canonicalIds = Array.from(new Set(collectIds(YAML.parse(canonicalText)))).sort();
-      const missingIds = blueprintIds.filter((entry) => !canonicalIds.includes(entry));
-      const extraIds = canonicalIds.filter((entry) => !blueprintIds.includes(entry));
-
-      missingIds.forEach((entry) => aggregateMissing.add(entry));
-      extraIds.forEach((entry) => aggregateExtra.add(entry));
-
-      files.push({
-        path: relativePath,
-        blueprintIds: blueprintIds.length,
-        canonicalIds: canonicalIds.length,
-        missingIds,
-        extraIds,
-      });
-    } catch (error) {
-      parseErrors.push({
-        path: relativePath,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-
-  return {
-    comparedFiles: files.length,
-    files,
-    parseErrors,
-    missingRuleIds: Array.from(aggregateMissing).sort(),
-    extraRuleIds: Array.from(aggregateExtra).sort(),
-  };
-}
-
-export async function buildBlueprintAuditPayload(projectRoot, options = {}) {
-  const blueprintReference = await loadBlueprintReference(projectRoot);
-  const specGenerationInputs = await loadSpecGenerationInputsConfig(projectRoot);
-
-  const canonicalRoot = options.canonicalRoot
-    ?? specGenerationInputs.canonicalTargetRoot
-    ?? ".nimi/spec";
-  const blueprintRoot = options.blueprintRoot
-    ?? blueprintReference.root
-    ?? specGenerationInputs.benchmarkBlueprintRoot
-    ?? null;
-
-  if (!blueprintRoot) {
-    return {
-      ok: false,
-      exitCode: 2,
-      inputError: true,
-      error: `${localize(
-        "nimicoding blueprint-audit refused: no blueprint root is declared; pass --blueprint-root or add project-local blueprint reference metadata.",
-        "nimicoding blueprint-audit 已拒绝：没有声明 blueprint root；请传入 --blueprint-root，或补充项目本地 blueprint reference 元数据。",
-      )}\n`,
-    };
-  }
-
-  const blueprintAbsoluteRoot = path.resolve(projectRoot, blueprintRoot);
-  const canonicalAbsoluteRoot = path.resolve(projectRoot, canonicalRoot);
-  const blueprintInventory = await collectDomainInventory(blueprintAbsoluteRoot);
-  const canonicalInventory = await collectDomainInventory(canonicalAbsoluteRoot);
-
-  const missingDomains = blueprintInventory.domains.filter((domainId) => !canonicalInventory.domains.includes(domainId));
-  const extraDomains = canonicalInventory.domains.filter((domainId) => !blueprintInventory.domains.includes(domainId));
-  const blueprintFiles = categorizeBlueprintFiles(blueprintInventory.files);
-  const canonicalFiles = categorizeBlueprintFiles(canonicalInventory.files);
-
-  const kernelMarkdown = compareFileSets(blueprintFiles.kernelMarkdown, canonicalFiles.kernelMarkdown);
-  const kernelTables = compareFileSets(blueprintFiles.kernelTables, canonicalFiles.kernelTables);
-  const kernelGenerated = {
-    present: [],
-    missing: [],
-    extra: [],
-  };
-  const domainGuides = compareFileSets(blueprintFiles.domainGuides, canonicalFiles.domainGuides);
-  const ruleIdPreservation = await compareRuleIds(
-    blueprintAbsoluteRoot,
-    canonicalAbsoluteRoot,
-    kernelTables.present,
-  );
-
-  const indexPresent = blueprintInventory.hasIndex ? canonicalInventory.hasIndex : true;
-  const ok = missingDomains.length === 0
-    && kernelMarkdown.missing.length === 0
-    && kernelTables.missing.length === 0
-    && domainGuides.missing.length === 0
-    && ruleIdPreservation.missingRuleIds.length === 0
-    && ruleIdPreservation.parseErrors.length === 0
-    && indexPresent;
-
-  const reportPath = path.join(projectRoot, DEFAULT_REPORT_PATH);
-  const nextSteps = [];
-  if (missingDomains.length > 0 || kernelMarkdown.missing.length > 0 || kernelTables.missing.length > 0 || !indexPresent) {
-    nextSteps.push("Resolve the missing blueprint structure under `/.nimi/spec/**` before claiming equivalence.");
-  }
-  if (domainGuides.missing.length > 0) {
-    nextSteps.push("Thin and map domain guides only after kernel coverage is in place.");
-  }
-  if (ruleIdPreservation.missingRuleIds.length > 0 || ruleIdPreservation.parseErrors.length > 0) {
-    nextSteps.push("Preserve benchmark rule IDs in canonical kernel tables before treating the canonical tree as benchmark-equivalent.");
-  }
-
-  return {
-    contractVersion: BLUEPRINT_AUDIT_CONTRACT_VERSION,
-    ok,
-    exitCode: ok ? 0 : 1,
-    projectRoot,
-    blueprintRoot,
-    canonicalRoot,
-    blueprintReference,
-    specGenerationInputs: {
-      ok: specGenerationInputs.ok,
-      mode: specGenerationInputs.mode,
-      acceptanceMode: specGenerationInputs.acceptanceMode,
-      benchmarkBlueprintRoot: specGenerationInputs.benchmarkBlueprintRoot,
-    },
-    inventory: {
-      blueprintDomains: blueprintInventory.domains,
-      canonicalDomains: canonicalInventory.domains,
-      missingDomains,
-      extraDomains,
-      indexPresent,
-    },
-    comparison: {
-      kernelMarkdown: {
-        ...buildSummarySection(kernelMarkdown),
-        missingPaths: kernelMarkdown.missing,
-      },
-      kernelTables: {
-        ...buildSummarySection(kernelTables),
-        missingPaths: kernelTables.missing,
-      },
-      kernelGenerated: {
-        ...buildSummarySection(kernelGenerated),
-        missingPaths: kernelGenerated.missing,
-      },
-      domainGuides: {
-        ...buildSummarySection(domainGuides),
-        missingPaths: domainGuides.missing,
-      },
-    },
-    structuralGaps: {
-      missingDomains,
-      missingKernelMarkdown: kernelMarkdown.missing,
-      missingKernelTables: kernelTables.missing,
-      indexMissing: !indexPresent,
-    },
-    semanticMappingGaps: {
-      ruleIdPreservation,
-    },
-    derivedViewGaps: {
-      missingKernelGenerated: kernelGenerated.missing,
-      missingDomainGuides: domainGuides.missing,
-    },
-    artifactPath: reportPath,
-    nextSteps,
-  };
-}
-
-export function formatBlueprintAuditPayload(payload) {
-  const lines = [
-    styleHeading(`nimicoding blueprint-audit: ${payload.projectRoot}`),
-    "",
-    styleLabel(localize("Summary:", "摘要：")),
-    `  - ${localize("status", "状态")}: ${styleStatus(payload.ok ? "ok" : "needs_attention")}`,
-    `  - ${localize("blueprint root", "blueprint root")}: ${payload.blueprintRoot}`,
-    `  - ${localize("canonical root", "canonical root")}: ${payload.canonicalRoot}`,
-    `  - ${localize("missing domains", "缺失域")}: ${payload.inventory.missingDomains.length}`,
-    `  - ${localize("kernel markdown missing", "缺失 kernel markdown")}: ${payload.comparison.kernelMarkdown.missing}`,
-    `  - ${localize("kernel tables missing", "缺失 kernel tables")}: ${payload.comparison.kernelTables.missing}`,
-    `  - ${localize("generated views missing", "缺失 generated 视图")}: ${payload.comparison.kernelGenerated.missing}`,
-    `  - ${localize("guide mappings missing", "缺失 guide 映射")}: ${payload.comparison.domainGuides.missing}`,
-    `  - ${localize("rule ids missing", "缺失 rule id")}: ${payload.semanticMappingGaps.ruleIdPreservation.missingRuleIds.length}`,
-    "",
-    styleLabel(localize("Coverage:", "覆盖情况：")),
-    `  - ${localize("blueprint domains", "blueprint 域")}: ${payload.inventory.blueprintDomains.length}`,
-    `  - ${localize("canonical domains", "canonical 域")}: ${payload.inventory.canonicalDomains.length}`,
-    `  - ${localize("INDEX present", "INDEX 已存在")}: ${payload.inventory.indexPresent ? "true" : "false"}`,
-  ];
-
-  if (payload.inventory.missingDomains.length > 0) {
-    lines.push(`  - ${localize("missing domain ids", "缺失域 ID")}: ${payload.inventory.missingDomains.join(", ")}`);
-  }
-
-  if (payload.semanticMappingGaps.ruleIdPreservation.missingRuleIds.length > 0) {
-    lines.push(`  - ${localize("missing rule ids", "缺失 rule id")}: ${payload.semanticMappingGaps.ruleIdPreservation.missingRuleIds.join(", ")}`);
-  }
-
-  if (payload.semanticMappingGaps.ruleIdPreservation.parseErrors.length > 0) {
-    lines.push(`  - ${localize("rule-id parse errors", "rule-id 解析错误")}: ${payload.semanticMappingGaps.ruleIdPreservation.parseErrors.length}`);
-  }
-
-  if (payload.nextSteps.length > 0) {
-    lines.push("", styleLabel(localize("Next:", "下一步：")));
-    for (const step of payload.nextSteps) {
-      lines.push(`  - ${localize(step, step)}`);
-    }
-  }
-
-  return `${lines.join("\n")}\n`;
-}
-
-export async function writeBlueprintAuditArtifact(projectRoot, payload) {
-  await mkdir(path.dirname(payload.artifactPath), { recursive: true });
-  await writeFile(payload.artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-  return {
-    jsonRef: path.relative(projectRoot, payload.artifactPath).split(path.sep).join(path.posix.sep),
-  };
-}

package/cli/lib/contracts.mjs

@@ -1,21 +0,0 @@
-import {
-  loadBlueprintReference as loadBlueprintReferenceInternal,
-  loadSpecGenerationAuditContract as loadSpecGenerationAuditContractInternal,
-  loadSpecGenerationInputsConfig as loadSpecGenerationInputsConfigInternal,
-  loadSpecGenerationInputsContract as loadSpecGenerationInputsContractInternal,
-} from "./internal/contracts-loaders.mjs";
-
-export function loadSpecGenerationInputsContract(projectRoot) {
-  return loadSpecGenerationInputsContractInternal(projectRoot);
-}
-export function loadSpecGenerationAuditContract(projectRoot) {
-  return loadSpecGenerationAuditContractInternal(projectRoot);
-}
-
-export function loadSpecGenerationInputsConfig(projectRoot) {
-  return loadSpecGenerationInputsConfigInternal(projectRoot);
-}
-
-export function loadBlueprintReference(projectRoot) {
-  return loadBlueprintReferenceInternal(projectRoot);
-}

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

@@ -1,47 +0,0 @@
-import path from "node:path";
-
-import {
-  BLUEPRINT_REFERENCE_REF,
-  SPEC_GENERATION_AUDIT_CONTRACT_REF,
-  SPEC_GENERATION_INPUTS_CONTRACT_REF,
-  SPEC_GENERATION_INPUTS_REF,
-} from "../../constants.mjs";
-import { readTextIfFile } from "../fs-helpers.mjs";
-import {
-  parseBlueprintReference,
-  parseSpecGenerationAuditContract,
-  parseSpecGenerationInputsConfig,
-  parseSpecGenerationInputsContract,
-} from "./contracts-parse.mjs";
-
-async function loadParsedYaml(projectRoot, relativePath, parse) {
-  const text = await readTextIfFile(path.join(projectRoot, relativePath));
-  return {
-    path: relativePath,
-    text,
-    ...parse(text),
-  };
-}
-export function loadSpecGenerationInputsContract(projectRoot) {
-  return loadParsedYaml(
-    projectRoot,
-    SPEC_GENERATION_INPUTS_CONTRACT_REF,
-    parseSpecGenerationInputsContract,
-  );
-}
-
-export function loadSpecGenerationAuditContract(projectRoot) {
-  return loadParsedYaml(
-    projectRoot,
-    SPEC_GENERATION_AUDIT_CONTRACT_REF,
-    parseSpecGenerationAuditContract,
-  );
-}
-
-export function loadSpecGenerationInputsConfig(projectRoot) {
-  return loadParsedYaml(projectRoot, SPEC_GENERATION_INPUTS_REF, parseSpecGenerationInputsConfig);
-}
-
-export function loadBlueprintReference(projectRoot) {
-  return loadParsedYaml(projectRoot, BLUEPRINT_REFERENCE_REF, parseBlueprintReference);
-}

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

@@ -1,192 +0,0 @@
-import {
-  SPEC_GENERATION_AUDIT_COVERAGE_STATUS_ENUM,
-  SPEC_GENERATION_AUDIT_REQUIRED_TOP_LEVEL_FIELDS,
-  SPEC_GENERATION_AUDIT_SOURCE_BASIS_ENUM,
-} from "../../constants.mjs";
-import { arraysEqual, isPlainObject, toStringArray } from "../value-helpers.mjs";
-import { parseYamlText } from "../yaml-helpers.mjs";
-
-const ACCEPTANCE_MODES = [
-  "semantic_and_structural_parity_when_blueprint_exists",
-  "placement_validity_before_generation",
-];
-const SPEC_GENERATION_INPUT_FIELDS = [
-  "mode",
-  "canonical_target_root",
-  "code_inputs",
-  "docs_inputs",
-  "structure_inputs",
-  "local_inputs",
-  "forbidden_source_classes",
-  "generation_order",
-  "inference_rules",
-  "acceptance_mode",
-];
-const SPEC_GENERATION_INPUT_DOCUMENT_FIELDS = [
-  "version",
-  "contract_ref",
-  "spec_generation_inputs",
-];
-
-function toStringOrNull(value) {
-  return typeof value === "string" ? value : null;
-}
-
-function hasExactFields(value, expectedFields) {
-  return isPlainObject(value)
-    && arraysEqual(Object.keys(value).sort(), [...expectedFields].sort());
-}
-
-function isAllowedAuthorityRoot(root) {
-  return typeof root === "string"
-    && (root === ".nimi/spec" || root.startsWith(".nimi/spec/"))
-    && !root.includes("..");
-}
-
-export function parseSpecGenerationAuditContract(text) {
-  const parsed = parseYamlText(text);
-  const requiredTopLevelFields = toStringArray(parsed?.required_top_level_fields);
-  const requiredFileEntryFields = toStringArray(parsed?.required_file_entry_fields);
-  const sourceBasisEnum = toStringArray(parsed?.source_basis_enum);
-  const coverageStatusEnum = toStringArray(parsed?.coverage_status_enum);
-  const hardConstraints = toStringArray(parsed?.hard_constraints);
-  const expectedTopLevelFields = [
-    ...SPEC_GENERATION_AUDIT_REQUIRED_TOP_LEVEL_FIELDS.slice(0, 4),
-    "placement_report_ref",
-    ...SPEC_GENERATION_AUDIT_REQUIRED_TOP_LEVEL_FIELDS.slice(4),
-  ];
-  const expectedFileEntryFields = [
-    "canonical_path",
-    "surface_class",
-    "source_refs",
-    "source_basis",
-    "coverage_status",
-    "unresolved_items",
-  ];
-
-  return {
-    ok: parsed?.version === 2
-      && String(parsed?.audit_contract?.id ?? "") === "canonical_spec_generation_audit"
-      && String(parsed?.audit_contract?.target_ref ?? "") === ".nimi/local/state/spec-generation/spec-generation-audit.yaml"
-      && arraysEqual(requiredTopLevelFields, expectedTopLevelFields)
-      && arraysEqual(requiredFileEntryFields, expectedFileEntryFields)
-      && arraysEqual(sourceBasisEnum, SPEC_GENERATION_AUDIT_SOURCE_BASIS_ENUM)
-      && arraysEqual(coverageStatusEnum, SPEC_GENERATION_AUDIT_COVERAGE_STATUS_ENUM)
-      && hardConstraints.includes("every_generated_canonical_file_requires_a_matching_audit_entry")
-      && hardConstraints.includes("required_canonical_files_must_not_be_placeholder_not_allowed")
-      && hardConstraints.includes("unresolved_or_inferred_content_must_be_explicit")
-      && hardConstraints.includes("source_refs_must_stay_within_class_filtered_declared_inputs")
-      && hardConstraints.includes("no_empty_success_looking_audit_entries"),
-    requiredTopLevelFields,
-    requiredFileEntryFields,
-    sourceBasisEnum,
-    coverageStatusEnum,
-    hardConstraints,
-  };
-}
-
-export function parseSpecGenerationInputsContract(text) {
-  const parsed = parseYamlText(text);
-  const contract = parsed?.input_contract;
-  const requiredFields = toStringArray(parsed?.required_fields);
-  const generationOrderEnum = toStringArray(parsed?.generation_order_enum);
-  const hardConstraints = toStringArray(parsed?.hard_constraints);
-
-  return {
-    ok: parsed?.version === 3
-      && String(contract?.id ?? "") === "canonical_spec_generation_inputs"
-      && String(contract?.owner ?? "") === "nimi-coding"
-      && arraysEqual(toStringArray(parsed?.mode_enum), ["class_filtered"])
-      && arraysEqual(requiredFields, SPEC_GENERATION_INPUT_FIELDS)
-      && generationOrderEnum.includes("classify_inputs")
-      && generationOrderEnum.includes("validate_placement")
-      && hardConstraints.includes("docs_roots_blanket_ingestion_is_forbidden")
-      && hardConstraints.includes("each_input_file_must_have_an_accepted_surface_class_before_render"),
-    requiredFields,
-    generationOrderEnum,
-    hardConstraints,
-  };
-}
-
-export function parseSpecGenerationInputsConfig(text) {
-  const parsed = parseYamlText(text);
-  const config = parsed?.spec_generation_inputs;
-  const codeInputs = Array.isArray(config?.code_inputs) ? config.code_inputs : [];
-  const docsInputs = Array.isArray(config?.docs_inputs) ? config.docs_inputs : [];
-  const structureInputs = Array.isArray(config?.structure_inputs) ? config.structure_inputs : [];
-  const localInputs = Array.isArray(config?.local_inputs) ? config.local_inputs : [];
-  const forbiddenSourceClasses = toStringArray(config?.forbidden_source_classes);
-  const generationOrder = toStringArray(config?.generation_order);
-  const inferenceRules = toStringArray(config?.inference_rules);
-  const acceptanceMode = toStringOrNull(config?.acceptance_mode);
-
-  return {
-    ok: hasExactFields(parsed, SPEC_GENERATION_INPUT_DOCUMENT_FIELDS)
-      && hasExactFields(config, SPEC_GENERATION_INPUT_FIELDS)
-      && parsed.version === 3
-      && String(parsed?.contract_ref ?? "") === ".nimi/contracts/spec-generation-inputs.schema.yaml"
-      && config?.mode === "class_filtered"
-      && config?.canonical_target_root === ".nimi/spec"
-      && docsInputs.length > 0
-      && docsInputs.every((entry) => isPlainObject(entry)
-        && isAllowedAuthorityRoot(entry.root)
-        && Array.isArray(entry.allowed_surface_classes)
-        && Array.isArray(entry.forbidden_surface_classes)
-        && entry.use_as_authority === true)
-      && Array.isArray(codeInputs)
-      && Array.isArray(structureInputs)
-      && Array.isArray(localInputs)
-      && forbiddenSourceClasses.length > 0
-      && generationOrder.includes("classify_inputs")
-      && generationOrder.includes("validate_placement")
-      && inferenceRules.includes("no_blanket_docs_roots")
-      && ACCEPTANCE_MODES.includes(acceptanceMode),
-    mode: toStringOrNull(config?.mode),
-    canonicalTargetRoot: toStringOrNull(config?.canonical_target_root),
-    codeRoots: codeInputs.map((entry) => String(entry?.root ?? "")).filter(Boolean),
-    docsRoots: docsInputs.map((entry) => String(entry?.root ?? "")).filter(Boolean),
-    structureRoots: structureInputs.map((entry) => String(entry?.root ?? "")).filter(Boolean),
-    localRoots: localInputs.map((entry) => String(entry?.root ?? "")).filter(Boolean),
-    humanNotePaths: [],
-    benchmarkBlueprintRoot: null,
-    benchmarkMode: "none",
-    acceptanceMode,
-    generationOrder,
-    inferenceRules,
-  };
-}
-
-export function parseBlueprintReference(text) {
-  if (!text) {
-    return {
-      ok: true,
-      present: false,
-      mode: null,
-      root: null,
-      canonicalTargetRoot: null,
-      equivalenceContractRef: null,
-    };
-  }
-
-  const parsed = parseYamlText(text);
-  const reference = parsed?.blueprint_reference;
-  const mode = toStringOrNull(reference?.mode);
-  const root = toStringOrNull(reference?.root);
-  const canonicalTargetRoot = toStringOrNull(reference?.canonical_target_root);
-  const equivalenceContractRef = toStringOrNull(reference?.equivalence_contract_ref);
-  const localRefValid = equivalenceContractRef === null
-    || (equivalenceContractRef.startsWith(".nimi/local/") && !equivalenceContractRef.includes(".."));
-
-  return {
-    ok: parsed?.version === 2
-      && ["repo_spec_blueprint", "custom_blueprint"].includes(mode)
-      && typeof root === "string"
-      && canonicalTargetRoot === ".nimi/spec"
-      && localRefValid,
-    present: true,
-    mode,
-    root,
-    canonicalTargetRoot,
-    equivalenceContractRef,
-  };
-}

package/cli/lib/internal/governance/runner.mjs

@@ -1,35 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-export function runNodeScript(scriptPath, args = [], options = {}) {
-  const result = spawnSync(process.execPath, [scriptPath, ...args], {
-    cwd: options.cwd ?? process.cwd(),
-    env: { ...process.env, ...(options.env ?? {}) },
-    stdio: "pipe",
-    encoding: "utf8",
-    shell: false,
-  });
-
-  return {
-    ok: result.status === 0,
-    exitCode: result.status ?? 1,
-    stdout: result.stdout || "",
-    stderr: result.stderr || "",
-  };
-}
-
-export function runCommand(command, options = {}) {
-  const result = spawnSync(command, {
-    cwd: options.cwd ?? process.cwd(),
-    env: { ...process.env, ...(options.env ?? {}) },
-    stdio: "pipe",
-    encoding: "utf8",
-    shell: true,
-  });
-
-  return {
-    ok: result.status === 0,
-    exitCode: result.status ?? 1,
-    stdout: result.stdout || "",
-    stderr: result.stderr || "",
-  };
-}