@nimiplatform/nimi-coding 0.1.0 → 0.2.1

package/cli/lib/internal/doctor-finalize.mjs

@@ -39,6 +39,7 @@ const PACKAGE_REPO_ROOT = fileURLToPath(new URL("../../..", import.meta.url));
 
 export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegatedSurface) {
   const checks = [...bootstrapSurface.checks, ...delegatedSurface.checks];
+  const usesV2SurfaceModel = bootstrapSurface.specGenerationInputs?.mode === "class_filtered";
 
   const specContract = await loadSpecReconstructionContract(projectRoot);
   const auditContract = await loadDocSpecAuditContract(projectRoot);
@@ -170,7 +171,7 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
     ),
   );
 
-  const lifecycleAligned = (
+  const lifecycleAligned = usesV2SurfaceModel || (
     bootstrapSurface.bootstrapStateContract.treeState === "bootstrap_only"
     && bootstrapSurface.canonicalTree.ready === false
   ) || (
@@ -187,7 +188,9 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
     buildCheck(
       "bootstrap_lifecycle_alignment",
       lifecycleAligned,
-      lifecycleAligned
+      usesV2SurfaceModel
+        ? "v2 host-local surface model does not require bootstrap-state lifecycle alignment"
+        : lifecycleAligned
         ? `bootstrap-state lifecycle ${bootstrapSurface.bootstrapStateContract.treeState ?? "unknown"} is aligned with the current canonical tree readiness`
         : bootstrapSurface.bootstrapStateContract.treeState === "canonical_tree_ready"
           ? "bootstrap-state declares canonical_tree_ready but required canonical files are still missing"
@@ -203,7 +206,8 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
     detail: auditArtifact.reason,
   });
 
-  const auditArtifactConsistent = !auditArtifact.present
+  const auditArtifactConsistent = usesV2SurfaceModel
+    || !auditArtifact.present
     || auditArtifact.outcome !== "completed"
     || bootstrapSurface.canonicalTree.requiredFilesValid;
   checks.push(
@@ -268,7 +272,7 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
       && delegatedSurface.contractRuntimeOwnersAligned
       && delegatedSurface.delegatedModeAligned
       && delegatedSurface.selfHostedAligned
-      && bootstrapSurface.completionTruth.ok
+      && (usesV2SurfaceModel || bootstrapSurface.completionTruth.ok)
       && delegatedSurface.resultContractAlignment
       && delegatedSurface.adapterSelectionValid
       && adapterProfilesValid
@@ -281,12 +285,12 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
       && highRiskAdmissionsTruthValid
       && externalExecutionArtifacts.ok
       && packageBoundaryTruthOk
-      && bootstrapSurface.specTreeModel.ok
+      && (usesV2SurfaceModel || bootstrapSurface.specTreeModel.ok)
       && bootstrapSurface.specGenerationInputsContract.ok
       && bootstrapSurface.specGenerationAuditContract.ok
       && bootstrapSurface.specGenerationInputs.ok
       && (!bootstrapSurface.canonicalTree.requiredFilesValid || bootstrapSurface.specGenerationAudit.ok)
-      && bootstrapSurface.commandGatingMatrix.ok
+      && (usesV2SurfaceModel || bootstrapSurface.commandGatingMatrix.ok)
       && bootstrapSurface.blueprintReferenceAligned
       && lifecycleAligned,
     requiredContextOrder: delegatedSurface.handoffRequiredContext,
@@ -304,7 +308,7 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
     nextSteps.push("Run `nimicoding blueprint-audit --write-local` after canonical tree generation when a benchmark blueprint is declared.");
   }
   if (bootstrapSurface.canonicalTree.requiredFilesValid && !bootstrapSurface.specGenerationAudit.ok) {
-    nextSteps.push("Run `nimicoding validate-spec-audit` after generating `.nimi/spec/_meta/spec-generation-audit.yaml` for the canonical tree.");
+    nextSteps.push("Run `nimicoding validate-spec-audit` after generating the local spec generation audit for the canonical tree.");
   }
   if (!auditArtifact.present && bootstrapSurface.canonicalTree.requiredFilesValid) {
     nextSteps.push("Run `nimicoding handoff --skill doc_spec_audit` and close out the result locally when the audit is complete.");
@@ -328,7 +332,7 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
     })),
   };
 
-  const completionStatus = !bootstrapSurface.completionTruth.ok || !packageBoundaryTruthOk
+  const completionStatus = (!usesV2SurfaceModel && !bootstrapSurface.completionTruth.ok) || !packageBoundaryTruthOk
     ? STANDALONE_COMPLETION_STATUS.DRIFTED
     : !hasErrors
       ? STANDALONE_COMPLETION_STATUS.COMPLETE

package/cli/lib/internal/doctor-inspectors.mjs

@@ -265,7 +265,40 @@ export function inspectBootstrapStateContract(bootstrapStateText) {
 
 export async function inspectCanonicalTree(projectRoot, specTreeModel) {
   if (!specTreeModel.ok) {
-    return emptyCanonicalTree();
+    const reconstructionText = await readTextIfFile(path.join(projectRoot, ".nimi", "methodology", "spec-reconstruction.yaml"));
+    const reconstruction = parseYamlText(reconstructionText);
+    const requiredFiles = Array.isArray(reconstruction?.reconstruction?.target_tree_shape?.minimal_required_outputs)
+      ? reconstruction.reconstruction.target_tree_shape.minimal_required_outputs.map(String)
+      : [];
+    const canonicalRoot = typeof reconstruction?.reconstruction?.target_root === "string"
+      ? reconstruction.reconstruction.target_root
+      : ".nimi/spec";
+    const present = [];
+    const missing = [];
+
+    for (const relativePath of requiredFiles) {
+      const info = await pathExists(path.join(projectRoot, relativePath));
+      if (info && info.isFile()) {
+        present.push(relativePath);
+      } else {
+        missing.push(relativePath);
+      }
+    }
+
+    if (requiredFiles.length === 0) {
+      return emptyCanonicalTree();
+    }
+
+    return {
+      profile: "surface_taxonomy_v1",
+      canonicalRoot,
+      requiredFiles,
+      present,
+      missing,
+      invalid: [],
+      requiredFilesValid: missing.length === 0,
+      ready: missing.length === 0,
+    };
   }
 
   const requiredFiles = specTreeModel.requiredFilesByProfile[specTreeModel.profile] ?? [];

package/cli/lib/internal/governance/ai/ai-context-budget-core.mjs

@@ -4,6 +4,9 @@ import path from 'node:path';
 import { execSync } from 'node:child_process';
 import YAML from 'yaml';
 
+const GOVERNANCE_CONFIG_RELATIVE_PATH = '.nimi/config/governance.yaml';
+const GOVERNANCE_CONTEXT_BUDGET_SECTION = 'ai_governance.context_budget';
+
 function escapeRegex(input) {
   return input.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
 }
@@ -89,21 +92,50 @@ function parseDateMaybe(input) {
   return parsed;
 }
 
-function countLines(buffer) {
+function measureLineShape(buffer) {
   if (!buffer || buffer.length === 0) {
-    return 0;
+    return {
+      lines: 0,
+      maxLineBytes: 0,
+      averageLineBytes: 0,
+    };
   }
+
   let lines = 1;
+  let currentLineBytes = 0;
+  let maxLineBytes = 0;
+
   for (const byte of buffer) {
     if (byte === 10) {
+      maxLineBytes = Math.max(maxLineBytes, currentLineBytes);
+      currentLineBytes = 0;
       lines += 1;
+      continue;
+    }
+    currentLineBytes += 1;
+  }
+  maxLineBytes = Math.max(maxLineBytes, currentLineBytes);
+
+  return {
+    lines,
+    maxLineBytes,
+    averageLineBytes: buffer.byteLength / lines,
+  };
+}
+
+function getPathSection(source, sectionPath) {
+  let current = source;
+  for (const segment of sectionPath.split('.')) {
+    if (!current || typeof current !== 'object') {
+      return null;
     }
+    current = current[segment];
   }
-  return lines;
+  return current && typeof current === 'object' ? current : null;
 }
 
-function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel) {
-  const parsed = inlineConfig ?? (() => {
+function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel, configSection) {
+  const rawParsed = inlineConfig ?? (() => {
     const configPath = path.join(cwd, relativePath);
     if (!fs.existsSync(configPath)) {
       throw new Error(`budget config not found: ${relativePath}`);
@@ -111,18 +143,19 @@ function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel) {
     const raw = fs.readFileSync(configPath, 'utf8');
     return YAML.parse(raw);
   })();
+  const parsed = configSection ? getPathSection(rawParsed, configSection) : rawParsed;
   if (!parsed || typeof parsed !== 'object') {
-    throw new Error(`invalid budget config format: ${relativePath}`);
+    throw new Error(`invalid budget config format: ${relativePath}${configSection ? `#${configSection}` : ''}`);
   }
   if (!parsed.profiles || typeof parsed.profiles !== 'object') {
-    throw new Error(`budget config missing profiles: ${relativePath}`);
+    throw new Error(`budget config missing profiles: ${relativePath}${configSection ? `#${configSection}` : ''}`);
   }
   const defaultProfile = String(parsed.default_profile || 'production');
   if (!parsed.profiles[defaultProfile]) {
     throw new Error(`default profile not found in profiles: ${defaultProfile}`);
   }
   return {
-    configPath: configPathLabel || relativePath,
+    configPath: configPathLabel || (configSection ? `${relativePath}#${configSection}` : relativePath),
     parsed,
     defaultProfile,
   };
@@ -174,12 +207,15 @@ function waiverAllowedForProfile(profileId) {
 
 export function evaluateAiContextBudget(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const configRelativePath = options.configRelativePath || 'config/ai/ai-context-budget.yaml';
+  const configRelativePath = options.configRelativePath || GOVERNANCE_CONFIG_RELATIVE_PATH;
+  const configSection = options.configSection
+    ?? (options.config || options.configRelativePath ? null : GOVERNANCE_CONTEXT_BUDGET_SECTION);
   const { parsed, defaultProfile, configPath } = loadBudgetConfig(
     cwd,
     configRelativePath,
     options.config || null,
     options.configPathLabel || null,
+    configSection,
   );
 
   const excludeMatchers = compileMatchers(parsed.exclude || []);
@@ -247,12 +283,27 @@ export function evaluateAiContextBudget(options = {}) {
     }
 
     const buffer = fs.readFileSync(absolutePath);
-    const lines = countLines(buffer);
+    const { lines, maxLineBytes, averageLineBytes } = measureLineShape(buffer);
     const bytes = buffer.byteLength;
 
     const linesSeverity = toSeverity(lines, profile.warning_lines, profile.error_lines);
     const bytesSeverity = toSeverity(bytes, profile.warning_bytes, profile.error_bytes);
-    const severity = maxSeverity(linesSeverity, bytesSeverity);
+    const maxLineBytesSeverity = toSeverity(
+      maxLineBytes,
+      profile.warning_max_line_bytes,
+      profile.error_max_line_bytes,
+    );
+    const averageLineBytesSeverity = toSeverity(
+      averageLineBytes,
+      profile.warning_average_line_bytes,
+      profile.error_average_line_bytes,
+    );
+    const severity = [
+      linesSeverity,
+      bytesSeverity,
+      maxLineBytesSeverity,
+      averageLineBytesSeverity,
+    ].reduce((current, next) => maxSeverity(current, next), "none");
 
     const waiver = waiverMap.get(relativePath) || null;
     const waiverExpired = waiver?.until ? waiver.until.getTime() < Date.now() : false;
@@ -263,13 +314,21 @@ export function evaluateAiContextBudget(options = {}) {
       profile: profileId,
       lines,
       bytes,
+      maxLineBytes,
+      averageLineBytes,
       severity,
       linesSeverity,
       bytesSeverity,
+      maxLineBytesSeverity,
+      averageLineBytesSeverity,
       warningLines: profile.warning_lines,
       errorLines: profile.error_lines,
       warningBytes: profile.warning_bytes,
       errorBytes: profile.error_bytes,
+      warningMaxLineBytes: profile.warning_max_line_bytes,
+      errorMaxLineBytes: profile.error_max_line_bytes,
+      warningAverageLineBytes: profile.warning_average_line_bytes,
+      errorAverageLineBytes: profile.error_average_line_bytes,
       waiver,
       waiverExpired,
       waived,
@@ -285,7 +344,10 @@ export function evaluateAiContextBudget(options = {}) {
     if (right.lines !== left.lines) {
       return right.lines - left.lines;
     }
-    return right.bytes - left.bytes;
+    if (right.bytes !== left.bytes) {
+      return right.bytes - left.bytes;
+    }
+    return right.maxLineBytes - left.maxLineBytes;
   });
 
   return {

package/cli/lib/internal/governance/ai/ai-structure-budget-core.mjs

@@ -4,6 +4,9 @@ import path from 'node:path';
 import { execSync } from 'node:child_process';
 import YAML from 'yaml';
 
+const GOVERNANCE_CONFIG_RELATIVE_PATH = '.nimi/config/governance.yaml';
+const GOVERNANCE_STRUCTURE_BUDGET_SECTION = 'ai_governance.structure_budget';
+
 function escapeRegex(input) {
   return input.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
 }
@@ -77,8 +80,19 @@ function parseDateMaybe(input) {
   return parsed;
 }
 
-function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel) {
-  const parsed = inlineConfig ?? (() => {
+function getPathSection(source, sectionPath) {
+  let current = source;
+  for (const segment of sectionPath.split('.')) {
+    if (!current || typeof current !== 'object') {
+      return null;
+    }
+    current = current[segment];
+  }
+  return current && typeof current === 'object' ? current : null;
+}
+
+function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel, configSection) {
+  const rawParsed = inlineConfig ?? (() => {
     const configPath = path.join(cwd, relativePath);
     if (!fs.existsSync(configPath)) {
       throw new Error(`budget config not found: ${relativePath}`);
@@ -86,14 +100,15 @@ function loadBudgetConfig(cwd, relativePath, inlineConfig, configPathLabel) {
     const raw = fs.readFileSync(configPath, 'utf8');
     return YAML.parse(raw);
   })();
+  const parsed = configSection ? getPathSection(rawParsed, configSection) : rawParsed;
   if (!parsed || typeof parsed !== 'object') {
-    throw new Error(`invalid budget config format: ${relativePath}`);
+    throw new Error(`invalid budget config format: ${relativePath}${configSection ? `#${configSection}` : ''}`);
   }
   if (!Array.isArray(parsed.rules) || parsed.rules.length === 0) {
-    throw new Error(`budget config missing rules: ${relativePath}`);
+    throw new Error(`budget config missing rules: ${relativePath}${configSection ? `#${configSection}` : ''}`);
   }
   return {
-    configPath: configPathLabel || relativePath,
+    configPath: configPathLabel || (configSection ? `${relativePath}#${configSection}` : relativePath),
     parsed,
   };
 }
@@ -244,12 +259,15 @@ function compareRows(left, right) {
 
 export function evaluateAiStructureBudget(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const configRelativePath = options.configRelativePath || 'config/ai/ai-structure-budget.yaml';
+  const configRelativePath = options.configRelativePath || GOVERNANCE_CONFIG_RELATIVE_PATH;
+  const configSection = options.configSection
+    ?? (options.config || options.configRelativePath ? null : GOVERNANCE_STRUCTURE_BUDGET_SECTION);
   const { parsed, configPath } = loadBudgetConfig(
     cwd,
     configRelativePath,
     options.config || null,
     options.configPathLabel || null,
+    configSection,
   );
   const excludeMatchers = compileMatchers(parsed.exclude || []);
   const compiledRules = (parsed.rules || []).map((rule) => ({

package/cli/lib/internal/governance/ai/check-agents-freshness.mjs

@@ -2,12 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 const DEFAULT_TARGETS = [
-  { rel: "AGENTS.md", maxLines: 100 },
-  { rel: "nimi-backend/AGENTS.md", maxLines: 80 },
-  { rel: "nimi-dashboard/AGENTS.md", maxLines: 65 },
-  { rel: ".nimi/spec/AGENTS.md", maxLines: 70 },
-  { rel: "scripts/AGENTS.md", maxLines: 45 },
-  { rel: "tests/AGENTS.md", maxLines: 35 },
+  { rel: "AGENTS.md", maxLines: 120 },
 ];
 
 const DEFAULT_REQUIRED_SECTIONS = [
@@ -17,7 +12,7 @@ const DEFAULT_REQUIRED_SECTIONS = [
   "## Verification Commands",
 ];
 
-const DEFAULT_STALE_TOKENS = ["AISC-", "R-WORLD-", "R-AGENT-", "SOCIAL-013", "ECON-014"];
+const DEFAULT_STALE_TOKENS = [];
 
 const GENERIC_PNPM_COMMANDS = new Set([
   "install",
@@ -39,18 +34,7 @@ function readJson(filePath) {
 
 function collectKnownPnpmScripts(projectRoot) {
   const rootPkg = readJson(path.join(projectRoot, "package.json"));
-  const scripts = new Set(Object.keys(rootPkg.scripts || {}));
-
-  for (const rel of ["nimi-backend/package.json", "nimi-dashboard/package.json"]) {
-    const abs = path.join(projectRoot, rel);
-    if (!fs.existsSync(abs)) continue;
-    const pkg = readJson(abs);
-    for (const name of Object.keys(pkg.scripts || {})) {
-      scripts.add(name);
-    }
-  }
-
-  return scripts;
+  return new Set(Object.keys(rootPkg.scripts || {}));
 }
 
 function validatePnpmCommand(command, knownScripts, failures, relPath) {
@@ -93,7 +77,7 @@ function validatePathToken(token, failures, relPath, agentsDir, projectRoot) {
   }
 }
 
-export function runAgentsFreshnessCheck(options = {}) {
+export function evaluateAgentsFreshnessCheck(options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const config = options.config || {};
   const targets = Array.isArray(config.targets) && config.targets.length > 0
@@ -143,13 +127,24 @@ export function runAgentsFreshnessCheck(options = {}) {
     }
   }
 
-  if (failures.length > 0) {
+  return {
+    targets,
+    requiredSections,
+    staleTokens,
+    failures,
+  };
+}
+
+export function runAgentsFreshnessCheck(options = {}) {
+  const report = evaluateAgentsFreshnessCheck(options);
+
+  if (report.failures.length > 0) {
     process.stderr.write(
-      `agents freshness check failed:\n${failures.map((entry) => `- ${entry}`).join("\n")}\n`,
+      `agents freshness check failed:\n${report.failures.map((entry) => `- ${entry}`).join("\n")}\n`,
     );
     return 1;
   }
 
-  process.stdout.write(`agents freshness check passed (${targets.length} files)\n`);
+  process.stdout.write(`agents freshness check passed (${report.targets.length} files)\n`);
   return 0;
 }