@nimiplatform/nimi-coding 0.3.1 → 0.4.0

package/cli/lib/internal/validators-shared.mjs

@@ -1,12 +0,0 @@
-export const VALIDATOR_CLI_RESULT_CONTRACT = "validator-cli-result.v1";
-
-export const VALIDATOR_NATIVE_REFUSAL_CODES = {
-  SPEC_TREE_MISSING: "SPEC_TREE_MISSING",
-  SPEC_TREE_INVALID: "SPEC_TREE_INVALID",
-  SPEC_AUDIT_MISSING: "SPEC_AUDIT_MISSING",
-  SPEC_AUDIT_INVALID: "SPEC_AUDIT_INVALID",
-};
-
-export function makeValidatorRefusal(code, message) {
-  return { code, message };
-}

package/cli/lib/internal/validators-spec-helpers.mjs

@@ -1,52 +0,0 @@
-import { readdir } from "node:fs/promises";
-import path from "node:path";
-
-export async function collectTreeFiles(rootPath) {
-  async function walk(currentPath) {
-    let entries;
-    try {
-      entries = await readdir(currentPath, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-
-    const files = [];
-    for (const entry of entries) {
-      const childPath = path.join(currentPath, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...await walk(childPath));
-      } else if (entry.isFile()) {
-        files.push(path.relative(rootPath, childPath).split(path.sep).join(path.posix.sep));
-      }
-    }
-    return files.sort();
-  }
-
-  return walk(rootPath);
-}
-export function isSourceRefWithinDeclaredRoots(sourceRef, declaredInputs) {
-  const roots = [
-    ...declaredInputs.code_roots,
-    ...declaredInputs.docs_roots,
-    ...declaredInputs.structure_roots,
-    ...(declaredInputs.benchmark_blueprint_root ? [declaredInputs.benchmark_blueprint_root] : []),
-  ];
-
-  return roots.some((root) => (
-    root === "."
-      ? !path.posix.isAbsolute(sourceRef)
-      : sourceRef === root || sourceRef.startsWith(`${root}/`)
-  ));
-}
-
-export function isDeclaredInputsCompatibleWithConfig(declaredInputs, generationInputs, blueprintReference) {
-  const blueprintRoot = blueprintReference.present ? blueprintReference.root : null;
-  const rootsAlign = (declaredRoots, configuredRoots) =>
-    declaredRoots.every((entry) => configuredRoots.includes(entry));
-
-  return rootsAlign(declaredInputs.code_roots, generationInputs.codeRoots ?? [])
-    && rootsAlign(declaredInputs.docs_roots, generationInputs.docsRoots ?? [])
-    && rootsAlign(declaredInputs.structure_roots, generationInputs.structureRoots ?? [])
-    && declaredInputs.human_note_paths.length === 0
-    && declaredInputs.benchmark_blueprint_root === blueprintRoot;
-}

package/cli/lib/internal/validators-spec.mjs

@@ -1,380 +0,0 @@
-import path from "node:path";
-
-import {
-  SPEC_GENERATION_AUDIT_CONTRACT_REF,
-  SPEC_GENERATION_AUDIT_COVERAGE_STATUS_ENUM,
-  SPEC_GENERATION_AUDIT_SOURCE_BASIS_ENUM,
-} from "../../constants.mjs";
-import {
-  loadBlueprintReference,
-  loadSpecGenerationAuditContract,
-  loadSpecGenerationInputsConfig,
-} from "../contracts.mjs";
-import { readTextIfFile } from "../fs-helpers.mjs";
-import { isPlainObject } from "../value-helpers.mjs";
-import { parseYamlText } from "../yaml-helpers.mjs";
-import {
-  makeValidatorRefusal,
-  VALIDATOR_NATIVE_REFUSAL_CODES,
-} from "./validators-shared.mjs";
-import {
-  validateDomainAdmission,
-  validateGuidanceBodies,
-  validatePlacement,
-  validateProjectionEdges,
-  validateTableFamily,
-} from "./surface-taxonomy-validators.mjs";
-import {
-  collectTreeFiles,
-  isDeclaredInputsCompatibleWithConfig,
-  isSourceRefWithinDeclaredRoots,
-} from "./validators-spec-helpers.mjs";
-
-async function loadRequiredFiles(projectRoot) {
-  const text = await readTextIfFile(path.join(projectRoot, ".nimi", "methodology", "spec-reconstruction.yaml"));
-  const parsed = parseYamlText(text);
-  return Array.isArray(parsed?.reconstruction?.target_tree_shape?.minimal_required_outputs)
-    ? parsed.reconstruction.target_tree_shape.minimal_required_outputs.map(String)
-    : [];
-}
-function normalizeAuditFileClass(entry) {
-  return typeof entry.surface_class === "string"
-    ? entry.surface_class
-    : String(entry.file_class ?? "");
-}
-
-function toPortableProjectPath(projectRoot, absolutePath) {
-  return path.relative(projectRoot, absolutePath).split(path.sep).join(path.posix.sep);
-}
-
-function invalidTree(errors, warnings, message) {
-  return {
-    ok: false,
-    errors,
-    warnings,
-    refusal: makeValidatorRefusal(VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_TREE_INVALID, message),
-  };
-}
-
-export async function validateSpecTree(rootPath, options = {}) {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const generationInputs = await loadSpecGenerationInputsConfig(projectRoot);
-  const errors = [];
-  const warnings = [];
-
-  if (!generationInputs.ok || generationInputs.mode !== "class_filtered") {
-    return invalidTree(
-      [`invalid spec generation inputs config: ${generationInputs.path}`],
-      warnings,
-      "spec tree validation requires class-filtered generation inputs",
-    );
-  }
-
-  const targetRoot = path.resolve(rootPath);
-  const expectedRoot = path.resolve(projectRoot, generationInputs.canonicalTargetRoot);
-  if (targetRoot !== expectedRoot) {
-    errors.push(`spec tree root mismatch: expected ${expectedRoot} but received ${targetRoot}`);
-  }
-
-  const files = await collectTreeFiles(targetRoot);
-  if (files.length === 0) {
-    return {
-      ok: false,
-      errors: errors.length > 0 ? errors : [`missing spec tree root: ${targetRoot}`],
-      warnings,
-      refusal: makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_TREE_MISSING,
-        "spec tree root is missing or empty",
-      ),
-    };
-  }
-
-  const canonicalRoot = generationInputs.canonicalTargetRoot;
-  const requiredFiles = await loadRequiredFiles(projectRoot);
-  const missingRequired = requiredFiles
-    .map((entry) => path.posix.relative(canonicalRoot, entry))
-    .filter((entry) => !files.includes(entry));
-  if (missingRequired.length > 0) {
-    errors.push(`missing required canonical files: ${missingRequired.join(", ")}`);
-  }
-
-  const rootRef = path.relative(projectRoot, targetRoot).split(path.sep).join(path.posix.sep) || ".";
-  const reports = await Promise.all([
-    validatePlacement(projectRoot, { rootRef }),
-    validateDomainAdmission(projectRoot, { rootRef }),
-    validateTableFamily(projectRoot, { rootRef }),
-    validateProjectionEdges(projectRoot, { rootRef }),
-    validateGuidanceBodies(projectRoot, { rootRef }),
-  ]);
-  for (const report of reports) {
-    for (const error of report.errors ?? []) {
-      if (!errors.includes(error)) errors.push(error);
-    }
-    for (const warning of report.warnings ?? []) {
-      if (!warnings.includes(warning)) warnings.push(warning);
-    }
-  }
-
-  return {
-    ok: errors.length === 0,
-    errors,
-    warnings,
-    refusal: errors.length === 0
-      ? null
-      : makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_TREE_INVALID,
-        `spec tree is invalid: ${path.basename(targetRoot)}`,
-      ),
-    summary: {
-      profile: "surface_taxonomy_v2",
-      canonicalRoot,
-      totalFiles: files.length,
-      requiredFiles: requiredFiles.length,
-      missingRequired,
-      classifiedFiles: reports[0]?.summary?.total ?? files.length,
-      unexpectedFiles: [],
-      conflictingFiles: [],
-    },
-  };
-}
-
-export async function validateSpecAudit(auditPath, options = {}) {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const generationInputs = await loadSpecGenerationInputsConfig(projectRoot);
-  const blueprintReference = await loadBlueprintReference(projectRoot);
-  const auditContract = await loadSpecGenerationAuditContract(projectRoot);
-  const errors = [];
-  const warnings = [];
-
-  if (!generationInputs.ok || generationInputs.mode !== "class_filtered") {
-    return {
-      ok: false,
-      errors: [`invalid spec generation inputs config: ${generationInputs.path}`],
-      warnings,
-      refusal: makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_AUDIT_INVALID,
-        "spec audit validation requires class-filtered generation inputs",
-      ),
-    };
-  }
-  if (!auditContract.ok) {
-    return {
-      ok: false,
-      errors: [`invalid spec generation audit contract: ${auditContract.path}`],
-      warnings,
-      refusal: makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_AUDIT_INVALID,
-        "spec audit validation requires a valid audit contract",
-      ),
-    };
-  }
-  if (!blueprintReference.ok) {
-    errors.push(`invalid blueprint reference: ${blueprintReference.path}`);
-  }
-
-  const absoluteAuditPath = path.resolve(auditPath);
-  const auditText = await readTextIfFile(absoluteAuditPath);
-  if (auditText === null) {
-    return {
-      ok: false,
-      errors: [`missing file: ${absoluteAuditPath}`],
-      warnings,
-      refusal: makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_AUDIT_MISSING,
-        "spec generation audit artifact is missing",
-      ),
-    };
-  }
-
-  const parsed = parseYamlText(auditText);
-  const audit = parsed?.spec_generation_audit;
-  if (!isPlainObject(parsed) || !isPlainObject(audit)) {
-    return {
-      ok: false,
-      errors: [`invalid YAML document: ${absoluteAuditPath}`],
-      warnings,
-      refusal: makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_AUDIT_INVALID,
-        "spec generation audit artifact is not valid YAML",
-      ),
-    };
-  }
-
-  if (parsed.version !== 2) errors.push("spec generation audit version must be 2");
-  if (String(parsed.contract_ref ?? "") !== SPEC_GENERATION_AUDIT_CONTRACT_REF) {
-    errors.push(`spec generation audit contract_ref must be ${SPEC_GENERATION_AUDIT_CONTRACT_REF}`);
-  }
-
-  const missingTopLevelFields = auditContract.requiredTopLevelFields.filter((field) => !(field in audit));
-  if (missingTopLevelFields.length > 0) {
-    errors.push(`spec generation audit is missing required fields: ${missingTopLevelFields.join(", ")}`);
-  }
-
-  const declaredInputs = {
-    code_roots: Array.isArray(audit?.input_roots?.code_roots) ? audit.input_roots.code_roots.map(String) : [],
-    docs_roots: Array.isArray(audit?.input_roots?.docs_roots) ? audit.input_roots.docs_roots.map(String) : [],
-    structure_roots: Array.isArray(audit?.input_roots?.structure_roots) ? audit.input_roots.structure_roots.map(String) : [],
-    human_note_paths: Array.isArray(audit?.input_roots?.human_note_paths) ? audit.input_roots.human_note_paths.map(String) : [],
-    benchmark_blueprint_root: audit?.input_roots?.benchmark_blueprint_root === null
-      ? null
-      : typeof audit?.input_roots?.benchmark_blueprint_root === "string"
-        ? audit.input_roots.benchmark_blueprint_root
-        : null,
-  };
-
-  if (String(audit.generation_mode ?? "") !== "class_filtered") {
-    errors.push("spec generation audit generation_mode must be class_filtered");
-  }
-  const canonicalRoot = generationInputs.canonicalTargetRoot;
-  if (String(audit.canonical_target_root ?? "") !== canonicalRoot) {
-    errors.push(`spec generation audit canonical_target_root must be ${canonicalRoot}`);
-  }
-  if (String(audit.declared_profile ?? "") !== "surface_taxonomy_v2") {
-    errors.push("spec generation audit declared_profile must be surface_taxonomy_v2");
-  }
-  if (!isDeclaredInputsCompatibleWithConfig(declaredInputs, generationInputs, blueprintReference)) {
-    errors.push("spec generation audit input_roots must match declared generation inputs and optional blueprint root");
-  }
-
-  const treeFiles = await collectTreeFiles(path.resolve(projectRoot, canonicalRoot));
-  if (treeFiles.length === 0) {
-    errors.push(`missing spec tree root: ${path.resolve(projectRoot, canonicalRoot)}`);
-  }
-  const auditedFiles = treeFiles.filter((entry) => !entry.startsWith("_meta/"));
-  const fileEntries = Array.isArray(audit.files) ? audit.files : [];
-  if (!Array.isArray(audit.files)) errors.push("spec generation audit files must be an array");
-
-  const fileEntryRefs = audit.file_entry_refs === undefined
-    ? []
-    : Array.isArray(audit.file_entry_refs)
-      ? audit.file_entry_refs.map(String)
-      : null;
-  if (fileEntryRefs === null) {
-    errors.push("spec generation audit file_entry_refs must be an array when present");
-  }
-
-  const referencedFileEntries = [];
-  for (const entryRef of fileEntryRefs ?? []) {
-    const expectedPrefix = ".nimi/local/state/spec-generation/spec-generation-audit/";
-    const absoluteEntryRef = path.resolve(projectRoot, entryRef);
-    const relativeEntryRef = toPortableProjectPath(projectRoot, absoluteEntryRef);
-    if (!entryRef || path.isAbsolute(entryRef) || relativeEntryRef !== entryRef || !entryRef.startsWith(expectedPrefix)) {
-      errors.push(`spec generation audit file_entry_ref must stay under ${expectedPrefix}: ${entryRef}`);
-      continue;
-    }
-    const entryText = await readTextIfFile(absoluteEntryRef);
-    const entryParsed = parseYamlText(entryText);
-    const entryPayload = entryParsed?.spec_generation_audit_file_entries;
-    if (!isPlainObject(entryParsed) || !isPlainObject(entryPayload) || entryParsed.version !== 2) {
-      errors.push(`spec generation audit file_entry_ref is invalid: ${entryRef}`);
-      continue;
-    }
-    if (String(entryParsed.contract_ref ?? "") !== SPEC_GENERATION_AUDIT_CONTRACT_REF) {
-      errors.push(`spec generation audit file_entry_ref contract_ref is invalid: ${entryRef}`);
-    }
-    if (String(entryPayload.parent_ref ?? "") !== toPortableProjectPath(projectRoot, absoluteAuditPath)) {
-      errors.push(`spec generation audit file_entry_ref parent_ref is invalid: ${entryRef}`);
-    }
-    if (!Array.isArray(entryPayload.files)) {
-      errors.push(`spec generation audit file_entry_ref files must be an array: ${entryRef}`);
-      continue;
-    }
-    referencedFileEntries.push(...entryPayload.files);
-  }
-
-  const auditEntryByRelativePath = new Map();
-  for (const entry of [...fileEntries, ...referencedFileEntries]) {
-    if (!isPlainObject(entry)) {
-      errors.push("spec generation audit file entries must be mappings");
-      continue;
-    }
-    const missingFields = auditContract.requiredFileEntryFields.filter((field) => !(field in entry));
-    if (missingFields.length > 0) {
-      errors.push(`spec generation audit file entry is missing required fields: ${missingFields.join(", ")}`);
-      continue;
-    }
-    const canonicalPath = String(entry.canonical_path ?? "");
-    if (!canonicalPath.startsWith(`${canonicalRoot}/`)) {
-      errors.push(`spec generation audit canonical_path must stay under ${canonicalRoot}: ${canonicalPath}`);
-      continue;
-    }
-    const relativePath = path.posix.relative(canonicalRoot, canonicalPath);
-    if (relativePath.startsWith("_meta/")) {
-      errors.push(`spec generation audit must not record _meta files: ${canonicalPath}`);
-      continue;
-    }
-    if (auditEntryByRelativePath.has(relativePath)) {
-      errors.push(`duplicate spec generation audit entry: ${canonicalPath}`);
-      continue;
-    }
-
-    if (!Array.isArray(entry.source_refs) || entry.source_refs.length === 0) {
-      errors.push(`spec generation audit source_refs must be non-empty for ${canonicalPath}`);
-    } else {
-      const invalidRefs = entry.source_refs.filter((ref) => !isSourceRefWithinDeclaredRoots(ref, declaredInputs));
-      if (invalidRefs.length > 0) {
-        errors.push(`spec generation audit source_refs escape declared inputs for ${canonicalPath}: ${invalidRefs.join(", ")}`);
-      }
-    }
-    if (!SPEC_GENERATION_AUDIT_SOURCE_BASIS_ENUM.includes(String(entry.source_basis ?? ""))) {
-      errors.push(`spec generation audit source_basis is invalid for ${canonicalPath}`);
-    }
-    if (!SPEC_GENERATION_AUDIT_COVERAGE_STATUS_ENUM.includes(String(entry.coverage_status ?? ""))) {
-      errors.push(`spec generation audit coverage_status is invalid for ${canonicalPath}`);
-    }
-    if (!Array.isArray(entry.unresolved_items) || entry.unresolved_items.some((item) => typeof item !== "string")) {
-      errors.push(`spec generation audit unresolved_items must be strings for ${canonicalPath}`);
-    }
-    if ((entry.source_basis !== "grounded" || entry.coverage_status !== "complete")
-      && (!Array.isArray(entry.unresolved_items) || entry.unresolved_items.length === 0)) {
-      errors.push(`inferred or partial files must declare unresolved_items for ${canonicalPath}`);
-    }
-    auditEntryByRelativePath.set(relativePath, entry);
-  }
-
-  const missingAuditEntries = auditedFiles.filter((entry) => !auditEntryByRelativePath.has(entry));
-  if (missingAuditEntries.length > 0) {
-    errors.push(`spec generation audit is missing canonical files: ${missingAuditEntries.join(", ")}`);
-  }
-  for (const relativePath of auditEntryByRelativePath.keys()) {
-    if (!auditedFiles.includes(relativePath)) {
-      errors.push(`spec generation audit entry points to a non-existent canonical file: ${relativePath}`);
-    }
-  }
-
-  const requiredFiles = (await loadRequiredFiles(projectRoot))
-    .map((entry) => path.posix.relative(canonicalRoot, entry))
-    .filter((entry) => !entry.startsWith("_meta/"));
-  for (const requiredFile of requiredFiles) {
-    const entry = auditEntryByRelativePath.get(requiredFile);
-    if (!entry) errors.push(`required canonical file is missing an audit entry: ${requiredFile}`);
-    else if (entry.coverage_status === "placeholder_not_allowed") {
-      errors.push(`required canonical file must not be placeholder_not_allowed: ${requiredFile}`);
-    }
-  }
-
-  const values = [...auditEntryByRelativePath.values()];
-  return {
-    ok: errors.length === 0,
-    errors,
-    warnings,
-    refusal: errors.length === 0
-      ? null
-      : makeValidatorRefusal(
-        VALIDATOR_NATIVE_REFUSAL_CODES.SPEC_AUDIT_INVALID,
-        `spec generation audit is invalid: ${path.basename(absoluteAuditPath)}`,
-      ),
-    summary: {
-      canonicalRoot,
-      declaredProfile: "surface_taxonomy_v2",
-      auditedFiles: values.length,
-      requiredAuditedFiles: requiredFiles.length,
-      missingAuditEntries,
-      completeFiles: values.filter((entry) => entry.coverage_status === "complete").length,
-      partialFiles: values.filter((entry) => entry.coverage_status === "partial").length,
-      placeholderFiles: values.filter((entry) => entry.coverage_status === "placeholder_not_allowed").length,
-      unresolvedFiles: values.filter((entry) => entry.unresolved_items?.length > 0).length,
-      inferredFiles: values.filter((entry) => entry.source_basis !== "grounded").length,
-    },
-  };
-}

package/cli/lib/validators.mjs

@@ -1,30 +0,0 @@
-import {
-  VALIDATOR_CLI_RESULT_CONTRACT,
-  VALIDATOR_NATIVE_REFUSAL_CODES,
-} from "./internal/validators-shared.mjs";
-import {
-  validateSpecAudit as validateSpecAuditInternal,
-  validateSpecTree as validateSpecTreeInternal,
-} from "./internal/validators-spec.mjs";
-
-export { VALIDATOR_NATIVE_REFUSAL_CODES };
-
-export function validateSpecTree(rootPath, options = {}) {
-  return validateSpecTreeInternal(rootPath, options);
-}
-export function validateSpecAudit(auditPath, options = {}) {
-  return validateSpecAuditInternal(auditPath, options);
-}
-
-export function buildValidatorCliReport(validator, filePath, report) {
-  return {
-    contract: VALIDATOR_CLI_RESULT_CONTRACT,
-    validator,
-    target_ref: filePath,
-    ok: Boolean(report.ok),
-    refusal: report.refusal || null,
-    errors: report.errors || [],
-    warnings: report.warnings || [],
-    ...(report.summary ? { summary: report.summary } : {}),
-  };
-}

package/config/bootstrap.yaml

@@ -1,6 +0,0 @@
-version: 2
-initialized_by: "@nimiplatform/nimi-coding"
-cli_version: "0.3.1"
-bootstrap_contract: "nimicoding.bootstrap"
-bootstrap_contract_version: 2
-profile: governance

package/config/spec-generation-inputs.yaml

@@ -1,41 +0,0 @@
-version: 3
-contract_ref: .nimi/contracts/spec-generation-inputs.schema.yaml
-spec_generation_inputs:
-  mode: class_filtered
-  canonical_target_root: .nimi/spec
-  code_inputs: []
-  docs_inputs:
-    - root: .nimi/spec
-      class_filter: product_authority_only
-      allowed_surface_classes: [product_authority, product_authority_table, thin_guidance, host_projection_anchor, support_registry]
-      forbidden_surface_classes: [derived_view, tracked_derived_projection, spec_generation_state, audit_evidence_state, operational_local_artifact, nimicoding_managed_projection, methodology_authority]
-      owner: nimi_host
-      use_as_authority: true
-      projection_edge_ref: null
-  structure_inputs: []
-  local_inputs:
-    - root: .nimi/local
-      owner: external_tooling
-      allowed_surface_classes: [spec_generation_state, audit_evidence_state, operational_local_artifact]
-      use_as_authority: false
-  forbidden_source_classes:
-    - derived_view
-    - tracked_derived_projection
-    - spec_generation_state
-    - audit_evidence_state
-    - operational_local_artifact
-    - nimicoding_managed_projection
-  generation_order:
-    - classify_inputs
-    - validate_placement
-    - product_authority
-    - product_authority_tables
-    - thin_guides
-    - derived_views
-    - generation_audit
-  inference_rules:
-    - no_blanket_docs_roots
-    - no_generated_as_authority
-    - no_derived_views_written_to_local
-    - no_audit_or_operational_state_as_authority
-  acceptance_mode: placement_validity_before_generation

package/contracts/domain-admission.schema.yaml

@@ -1,56 +0,0 @@
-version: 2
-contract:
-  id: nimicoding.domain-admission.v2
-  owner: nimi-coding
-  purpose: Require explicit admission for every host spec domain before it is product authority.
-required_top_level_fields:
-  - version
-  - domain_admissions
-  - domain_authority_class_enum
-  - semantic_constraints
-domain_admission_required_fields:
-  - domain_id
-  - domain_root
-  - authority_class
-  - owner
-  - admitted_by
-  - allowed_surface_classes
-  - forbidden_surface_classes
-  - validation_commands
-  - migration_disposition_when_unadmitted
-shared_enum_ref: shared-enums.yaml
-domain_admissions:
-  - domain_id: project
-    domain_root: .nimi/spec/project
-    authority_class: active_product
-    owner: project
-    admitted_by: nimicoding_init_default_project_domain
-    allowed_surface_classes: [product_authority, product_authority_table, thin_guidance, support_registry]
-    forbidden_surface_classes: [derived_view, spec_generation_state, audit_evidence_state, operational_local_artifact, methodology_authority]
-    validation_commands: [pnpm exec nimicoding validate-spec-tree -- .nimi/spec]
-    migration_disposition_when_unadmitted: block
-domain_authority_class_enum:
-  - active_product
-  - package_projection_anchor_only
-  - migration_input_only
-  - excluded_from_spec
-migration_disposition_when_unadmitted_enum:
-  - move_local
-  - move_package
-  - split
-  - delete
-  - block
-domain_rules:
-  - domain_id: project
-    required_authority_class: active_product
-    admission_required: true
-semantic_constraints:
-  - directory_presence_does_not_admit_product_authority
-  - unadmitted_domain_must_not_be_used_as_implementation_authority
-  - product_domain_admission_must_name_validation_commands
-  - package_projection_domains_must_not_define_product_rules
-  - active_product_domain_does_not_admit_generated_evidence_or_state_surfaces
-  - product_authority_tables_must_declare_table_family
-  - thin_guidance_must_not_carry_rule_body
-  - package_default_domain_admission_must_remain_generic_project_skeleton
-  - product_hosts_must_own_domain_specific_admission_as_host_profile_override

package/contracts/migration-inventory.schema.yaml

@@ -1,15 +0,0 @@
-version: 2
-contract:
-  id: nimicoding.spec-migration-inventory.v2
-  owner: nimi-coding
-  purpose: Describe a non-mutating migration plan for spec surface cleanup.
-required_entry_fields: [source_path, current_inferred_class, target_class, disposition, target_root, owner, required_confirmation, ambiguity, evidence, validation_commands]
-target_class_enum: [product_authority, product_authority_table, thin_guidance, host_instruction, tracked_derived_projection, derived_view, spec_generation_state, audit_evidence_state, operational_local_artifact, methodology_authority, nimicoding_managed_projection, host_projection_anchor, support_registry]
-disposition_enum: [keep, move_package, move_local, split, rewrite, delete, block]
-required_confirmation_enum: [none, product_semantic_fork, owner_ambiguity, package_boundary_ambiguity, destructive_deletion]
-plan_fields: [contract, ok, version, root, inventory, disposition_enum, target_class_enum, semantic_constraints, summary, enum_validation, required_confirmations, groups, migration_groups, mutation_policy]
-semantic_constraints:
-  - inventory_and_plan_commands_must_not_modify_source_files
-  - unresolved_semantic_forks_remain_blocking
-  - migration_groups_are_descriptive_and_do_not_schedule_work
-  - emitted_plans_are_local_non_authority_state

package/contracts/negative-fixtures.yaml

@@ -1,26 +0,0 @@
-version: 2
-contract:
-  id: nimicoding.spec-surface-negative-fixtures.v2
-  owner: nimi-coding
-fixtures:
-  - id: generated-view-under-authority
-    setup: .nimi/spec/project/kernel/generated/overview.md
-    expected_failure: derived_view_under_product_authority_root
-  - id: generation-state-under-authority
-    setup: .nimi/spec/_meta/spec-generation-audit.yaml
-    expected_failure: spec_generation_state_under_spec
-  - id: package-contract-promoted-to-spec
-    setup: .nimi/contracts/surface-taxonomy.schema.yaml copied under .nimi/spec/project/kernel
-    expected_failure: package_methodology_under_host_spec
-  - id: unknown-domain
-    setup: .nimi/spec/unadmitted/kernel/index.md
-    expected_failure: missing_domain_admission
-  - id: table-without-family
-    setup: .nimi/spec/project/kernel/tables/rules.yaml without table_family
-    expected_failure: missing_table_family
-  - id: guidance-with-rule-body
-    setup: .nimi/spec/project.md containing normative rule body
-    expected_failure: guidance_defines_rule_body
-semantic_constraints:
-  - every_fail_closed_rule_requires_a_negative_fixture
-  - fixtures_must_name_the_exact_refusal_code