@nimiplatform/nimi-coding 0.2.8 → 0.3.0

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;
-}