@nimiplatform/nimi-coding 0.2.1 → 0.2.3

package/cli/lib/audit-sweep-runtime/codex-auditor-evidence.mjs

@@ -183,7 +183,7 @@ function isNonImplementationContextRef(ref) {
 }
 
 function stripNonImplementationContextRefs(refs, evidenceInventorySet) {
-  return refs.filter((ref) => evidenceInventorySet.has(ref) || !isNonImplementationContextRef(ref));
+  return refs.filter((ref) => !isNonImplementationContextRef(ref));
 }
 
 function normalizeFindingEnvelope(finding, evidenceInventorySet, authorityRefSet = new Set()) {
@@ -412,6 +412,7 @@ function normalizeOutcome(rawOutcome, index, authorityRef, evidenceInventorySet)
     ...normalizeRefs(rawOutcome.inspected_implementation_refs),
     ...normalizeRefs(rawOutcome.implementation_evidence_refs),
   ]);
+  const contextOnlyRefs = inspectedImplementationRefs.filter((ref) => isNonImplementationContextRef(ref));
   const implementationRefs = stripNonImplementationContextRefs(inspectedImplementationRefs, evidenceInventorySet);
   const invalidImplementationRefs = refsOutsideSet(implementationRefs, evidenceInventorySet);
   if (invalidImplementationRefs.length > 0) {
@@ -438,6 +439,9 @@ function normalizeOutcome(rawOutcome, index, authorityRef, evidenceInventorySet)
   if (typeof rawOutcome.implementation_not_applicable_reason === "string" && rawOutcome.implementation_not_applicable_reason.trim()) {
     normalized.implementation_not_applicable_reason = rawOutcome.implementation_not_applicable_reason.trim();
   }
+  if (!normalized.implementation_not_applicable_reason && implementationRefs.length === 0 && contextOnlyRefs.length > 0) {
+    normalized.implementation_not_applicable_reason = `Only non-implementation context refs were cited: ${uniqueRefs(contextOnlyRefs).join(", ")}.`;
+  }
   if (!normalized.reason && status === "not_applicable" && normalized.implementation_not_applicable_reason) {
     normalized.reason = normalized.implementation_not_applicable_reason;
   }
@@ -476,10 +480,17 @@ function normalizeRuleChecks(rawRuleChecks, evidenceInventorySet, authorityRefSe
     if (typeof rawCheck.negative_reasoning !== "string" || !rawCheck.negative_reasoning.trim()) {
       return { ok: false, error: `coverage.p0p1_rule_checks[${index}].negative_reasoning is required` };
     }
-    const rawRefs = stripNonImplementationContextRefs(uniqueRefs(normalizeRefs(rawCheck.implementation_refs)), evidenceInventorySet);
+    const inputRefs = uniqueRefs(normalizeRefs(rawCheck.implementation_refs));
+    const rawRefs = stripNonImplementationContextRefs(inputRefs, evidenceInventorySet);
     const refs = rawRefs.filter((ref) => evidenceInventorySet.has(ref));
     const invalidRawRefs = rawRefs.filter((ref) => !evidenceInventorySet.has(ref) && !authorityRefSet.has(ref));
-    if (rawCheck.status === "checked" && refs.length === 0) {
+    const status = rawCheck.status === "checked"
+      && refs.length === 0
+      && inputRefs.length > 0
+      && inputRefs.every((ref) => isNonImplementationContextRef(ref))
+      ? "not_applicable"
+      : rawCheck.status;
+    if (status === "checked" && refs.length === 0) {
       return { ok: false, error: `coverage.p0p1_rule_checks[${index}].implementation_refs is required when status is checked` };
     }
     if (invalidRawRefs.length > 0) {
@@ -491,7 +502,7 @@ function normalizeRuleChecks(rawRuleChecks, evidenceInventorySet, authorityRefSe
     implementationRefs.push(...refs);
     ruleChecks.push({
       id,
-      status: rawCheck.status,
+      status,
       implementation_refs: refs,
       negative_reasoning: rawCheck.negative_reasoning.trim(),
     });
@@ -524,6 +535,7 @@ function normalizeCodexSemanticOutput(rawOutput, chunk, options) {
   }
 
   const evidenceInventory = chunk.planning_basis === "spec_authority" ? (chunk.evidence_inventory ?? []) : (chunk.files ?? []);
+  const p0p1ImplementationInventory = evidenceInventory.filter((ref) => !isNonImplementationContextRef(ref));
   const evidenceInventorySet = new Set(evidenceInventory);
   const authorityRefSet = new Set(authorityRefs);
   const outcomes = [];
@@ -561,7 +573,7 @@ function normalizeCodexSemanticOutput(rawOutput, chunk, options) {
     chunk_id: chunk.chunk_id,
     auditor: {
       id: typeof rawOutput.auditor?.id === "string" && rawOutput.auditor.id.trim() ? rawOutput.auditor.id : options.auditorId,
-      mode: "codex_semantic_audit",
+      mode: options.auditorMode ?? "codex_semantic_audit",
       methodology_ref: "package://@nimiplatform/nimi-coding/methodology/audit-sweep-p0p1-recall.yaml",
       provenance: {
         kind: "semantic_audit",
@@ -591,12 +603,14 @@ function normalizeCodexSemanticOutput(rawOutput, chunk, options) {
   if (typeof rawOutput.coverage.p0p1_implementation_not_applicable_reason === "string" && rawOutput.coverage.p0p1_implementation_not_applicable_reason.trim()) {
     evidence.coverage.p0p1_implementation_not_applicable_reason = rawOutput.coverage.p0p1_implementation_not_applicable_reason.trim();
   }
-  if (!evidence.coverage.p0p1_implementation_not_applicable_reason && evidenceInventory.length === 0) {
+  if (!evidence.coverage.p0p1_implementation_not_applicable_reason && p0p1ImplementationInventory.length === 0) {
     const outcomeReasons = outcomes
       .map((outcome) => outcome.implementation_not_applicable_reason)
       .filter((reason) => typeof reason === "string" && reason.trim().length > 0);
     if (outcomeReasons.length > 0) {
       evidence.coverage.p0p1_implementation_not_applicable_reason = uniqueRefs(outcomeReasons).join(" ");
+    } else {
+      evidence.coverage.p0p1_implementation_not_applicable_reason = "The chunk has no in-scope implementation refs after excluding context/governance/authority documents.";
     }
   }
   return { ok: true, evidence };
@@ -620,6 +634,7 @@ export async function extractCodexAuditorEvidenceFile(projectRoot, options) {
     sessionRef: options.sessionRef,
     transcriptRef: options.transcriptRef,
     auditorId: options.auditorId,
+    auditorMode: options.auditorMode,
   });
   if (!normalized.ok) {
     return normalized;

package/cli/lib/audit-sweep-runtime/codex-auditor.mjs

@@ -52,8 +52,9 @@ function codexPrompt({ packet, auditorPacketRef, rawRef, sessionRef }) {
     "You only author semantic audit content: authority_outcomes reasoning/status, inspected_implementation_refs, P0/P1 rule checks, p0p1_negative_reasoning when applicable, and findings.",
     "For each authority outcome, set authority_ref to the packet authority_ref and put inspected implementation refs in inspected_implementation_refs or implementation_evidence_refs.",
     "Every implementation ref you cite must be an exact file ref from packet.selected_implementation_refs / packet.evidence_inventory.",
-    "Never put AGENTS.md, README.md, spec files, authority refs, methodology docs, or governance docs in inspected_implementation_refs, implementation_evidence_refs, coverage.p0p1_evidence_refs, findings[].implementation_refs, or coverage.p0p1_rule_checks[].implementation_refs unless that exact file appears in packet.selected_implementation_refs.",
-    "If a governance or authority document influenced reasoning but is not in packet.selected_implementation_refs, mention it only in negative_reasoning/description text, not in any implementation_refs array.",
+    "Never put AGENTS.md, README.md, spec files, authority refs, methodology docs, or governance docs in inspected_implementation_refs, implementation_evidence_refs, coverage.p0p1_evidence_refs, findings[].implementation_refs, or coverage.p0p1_rule_checks[].implementation_refs; even if packet.selected_implementation_refs includes them, treat them as context only.",
+    "If only context/governance/authority documents are available after that exclusion, use status=\"not_applicable\" for P0/P1 rule checks and explain the lack of implementation surface in negative_reasoning.",
+    "If a governance or authority document influenced reasoning, mention it only in negative_reasoning/description text, not in any implementation_refs array.",
     "Use packet.audit_depth to size your inspection: deep means inspect the selected slice thoroughly, normal means focused semantic inspection, shallow means audit generated/table/index invariants from the selected slice without expanding the omitted inventory.",
     "Return exactly one JSON object and nothing else. Do not wrap it in markdown.",
     "The JSON object must have exactly these top-level fields: chunk_id, auditor, coverage, findings.",

package/cli/lib/audit-sweep-runtime/common.mjs

@@ -20,6 +20,7 @@ export const AUDITABLE_EXTENSIONS = new Set([
   ".json",
   ".md",
   ".mjs",
+  ".prisma",
   ".proto",
   ".py",
   ".rs",
@@ -30,13 +31,24 @@ export const AUDITABLE_EXTENSIONS = new Set([
 ]);
 export const DEFAULT_EXCLUDE_PATTERNS = [
   ".git/",
+  ".agents/",
+  ".claude/",
+  ".iterate/",
   ".next/",
   ".nimi/local/",
+  ".openclaw/",
   ".turbo/",
+  "AGENTS.md",
   "archive/",
   "dist/",
+  "docs/_archive/",
   "generated/",
   "node_modules/",
+  "README.md",
+  "**/AGENTS.md",
+  "**/README.md",
+  "_archive/",
+  "**/_archive/**",
   "pnpm-lock.yaml",
   "package-lock.json",
   "yarn.lock",

package/cli/lib/audit-sweep-runtime/inventory-spec-chunks.mjs

@@ -7,26 +7,112 @@ function evidenceRootsForSpecOwner(ownerDomain, targetRootRef) {
     return [targetRootRef];
   }
   const owner = String(ownerDomain ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-  const repoWideEvidenceRoots = [".", ".github", "config", "scripts", "src", "lib", "packages", "apps", "tools", "services"];
   if (!owner || owner === "spec-meta" || owner === "spec-root") {
-    return repoWideEvidenceRoots;
+    return [];
   }
   if (owner === "project") {
-    return ["src", "lib", "packages", "apps", "tools", "services", "scripts", "config"];
+    return ["src", "lib", "packages", "apps", "tools", "services"];
   }
   return [
     owner,
+    `nimi-${owner}`,
     `src/${owner}`,
     `lib/${owner}`,
     `packages/${owner}`,
+    `packages/nimi-${owner}`,
     `apps/${owner}`,
     `tools/${owner}`,
     `services/${owner}`,
-    "scripts",
-    "config",
   ];
 }
 
+const DECLARED_EVIDENCE_REF_PATTERN = /(?:^|[\s"'`([{:;,])((?:\.\/)?(?:[A-Za-z0-9_.@+-]+\/)+[A-Za-z0-9_@+.-]+\.(?:cjs|css|go|js|jsx|json|md|mjs|prisma|proto|py|rs|ts|tsx|yaml|yml))(?:[#:)\\\],;."'`]|\s|$)/gu;
+
+function looksLikeSpecAuthorityRelativeRef(normalized) {
+  const extension = path.posix.extname(normalized);
+  if (![".md", ".yaml", ".yml"].includes(extension)) {
+    return false;
+  }
+  const parts = normalized.split("/");
+  const firstSegment = parts[0];
+  if (["tables", "generated", "kernel"].includes(firstSegment)) {
+    return true;
+  }
+  if (parts[1] === "kernel") {
+    return true;
+  }
+  const specDomainLike = /^(backend|dashboard|realm|runtime|v[0-9]+|vision|workers)$/u.test(firstSegment);
+  return specDomainLike && parts.length <= 2;
+}
+
+function normalizeDeclaredEvidenceRef(value) {
+  const normalized = String(value ?? "")
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/[),.;:]+$/u, "");
+  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("http:") || normalized.startsWith("https:")) {
+    return null;
+  }
+  if (!normalized.includes("/")) {
+    return null;
+  }
+  const firstSegment = normalized.split("/")[0];
+  if (looksLikeSpecAuthorityRelativeRef(normalized)) {
+    return null;
+  }
+  if (
+    normalized.startsWith(".nimi/spec/")
+    || normalized.startsWith(".nimi/contracts/")
+    || normalized.startsWith(".nimi/methodology/")
+    || normalized.startsWith(".nimi/local/")
+    || normalized.startsWith(".agents/")
+    || normalized.startsWith(".claude/")
+    || normalized.startsWith(".openclaw/")
+    || normalized.includes("/.nimi/spec/")
+    || normalized.includes("/.nimi/contracts/")
+    || normalized.includes("/.nimi/methodology/")
+  ) {
+    return null;
+  }
+  const basename = path.posix.basename(normalized).toLowerCase();
+  if (basename === "agents.md" || basename === "readme.md") {
+    return null;
+  }
+  return normalized;
+}
+
+function candidateEvidenceRefsForDeclaredRef(declaredRef, evidenceRoots) {
+  const normalized = String(declaredRef ?? "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+  if (!normalized) {
+    return [];
+  }
+  const candidates = [normalized];
+  for (const rootRef of evidenceRoots ?? []) {
+    const root = String(rootRef ?? "").replace(/\\/g, "/").replace(/\/$/, "");
+    if (!root || root === "." || root.startsWith(".nimi/spec") || path.posix.extname(root)) {
+      continue;
+    }
+    if (normalized === root || normalized.startsWith(`${root}/`)) {
+      candidates.push(normalized);
+    } else {
+      candidates.push(`${root}/${normalized}`);
+    }
+  }
+  return [...new Set(candidates)].sort();
+}
+
+function extractDeclaredEvidenceRefs(text) {
+  const refs = [];
+  for (const match of String(text ?? "").matchAll(DECLARED_EVIDENCE_REF_PATTERN)) {
+    const normalized = normalizeDeclaredEvidenceRef(match[1]);
+    if (normalized) {
+      refs.push(normalized);
+    }
+  }
+  return [...new Set(refs)].sort();
+}
+
 function slugPart(value) {
   return String(value)
     .replace(/[^a-zA-Z0-9]+/g, "-")
@@ -132,22 +218,34 @@ export function buildSpecChunks(includedInventory, options) {
     const rootAdmissions = (options.auditEvidenceRootAdmissions ?? [])
       .filter((admission) => admission.owner_domain === surface.ownerDomain && admission.authority_refs.includes(entry.file_ref));
     const admittedEvidenceRoots = rootAdmissions.flatMap((admission) => admission.evidence_roots);
+    const authorityText = authorityRefs
+      .map((authorityRef) => options.authorityTextByRef?.get(authorityRef) ?? "")
+      .join("\n");
+    const declaredEvidenceRefs = packageAdmission || appAdmission
+      ? []
+      : extractDeclaredEvidenceRefs(authorityText);
     const evidenceRoots = packageAdmission
       ? packageAdmission.evidence_roots
       : appAdmission
       ? appAdmission.evidence_roots
       : [...new Set([
         ...evidenceRootsForSpecOwner(surface.ownerDomain, options.targetRootRef),
+        ...declaredEvidenceRefs,
         ...admittedEvidenceRoots,
       ])].sort();
     const moduleMapRefs = surface.surface === "domain-guides" || surface.surface === "app-domain-guides"
       ? extractModuleMapRefs(options.authorityTextByRef?.get(entry.file_ref) ?? "")
       : [];
-    const declaredEvidenceTargets = moduleMapRefs
-      .map((moduleRef) => ({
+    const declaredEvidenceTargets = [
+      ...moduleMapRefs.map((moduleRef) => ({
         source_path: moduleRef,
         candidates: candidateEvidenceRefsForModuleMapPath(moduleRef, evidenceRoots),
-      }))
+      })),
+      ...declaredEvidenceRefs.map((evidenceRef) => ({
+        source_path: evidenceRef,
+        candidates: candidateEvidenceRefsForDeclaredRef(evidenceRef, evidenceRoots),
+      })),
+    ]
       .filter((target) => target.candidates.length > 0);
     chunkIndex += 1;
     const chunkId = [

package/cli/lib/audit-sweep-runtime/inventory.mjs

@@ -111,7 +111,7 @@ async function listFallbackFiles(projectRoot, targetRootRef, excludePatterns) {
 
 function classifyFile(fileRef) {
   const extension = path.posix.extname(fileRef);
-  if ([".md", ".yaml", ".yml", ".json"].includes(extension)) {
+  if ([".md", ".yaml", ".yml", ".json", ".prisma"].includes(extension)) {
     return "contract-or-doc";
   }
   if ([".test.ts", ".test.js", ".spec.ts", ".spec.js"].some((suffix) => fileRef.endsWith(suffix))) {
@@ -509,9 +509,7 @@ export async function createAuditSweepPlan(projectRoot, options) {
   const authorityTextByRef = new Map();
   if (chunkBasis.basis === "spec") {
     for (const entry of includedInventory) {
-      if ([".md", ".markdown"].includes(entry.extension)) {
-        authorityTextByRef.set(entry.file_ref, await readFile(artifactPath(projectRoot, entry.file_ref), "utf8"));
-      }
+      authorityTextByRef.set(entry.file_ref, await readFile(artifactPath(projectRoot, entry.file_ref), "utf8"));
     }
   }
   let chunks = chunkBasis.basis === "spec"

package/cli/lib/audit-sweep-runtime/validators.mjs

@@ -43,6 +43,10 @@ const RUN_EVENT_TYPES = new Set([
   "chunk_codex_audit_failed",
   "chunk_codex_auditor_output_rejected",
   "chunk_codex_auditor_output_accepted",
+  "chunk_claude_audit_prepared",
+  "chunk_claude_audit_failed",
+  "chunk_claude_auditor_output_rejected",
+  "chunk_claude_auditor_output_accepted",
   "ledger_snapshot_created",
   "remediation_map_created",
   "remediation_map_admitted",
@@ -610,7 +614,8 @@ function validateRunLedgerReplay(events, plan, chunks, findings, latestLedger, c
   check(checks, "run_replay_plan_created", eventsByType.get("plan_created")?.some((event) => event.plan_ref === planRefFromPlan(plan)) === true, "run ledger records plan_created for this plan");
   for (const chunk of chunks) {
     const dispatched = eventsByType.get("chunk_dispatched")?.some((event) => event.chunk_id === chunk.chunk_id) === true
-      || eventsByType.get("chunk_codex_audit_prepared")?.some((event) => event.chunk_id === chunk.chunk_id) === true;
+      || eventsByType.get("chunk_codex_audit_prepared")?.some((event) => event.chunk_id === chunk.chunk_id) === true
+      || eventsByType.get("chunk_claude_audit_prepared")?.some((event) => event.chunk_id === chunk.chunk_id) === true;
     const ingested = eventsByType.get("chunk_ingested")?.some((event) => event.chunk_id === chunk.chunk_id && event.evidence_ref === chunk.evidence_ref) === true;
     const frozen = eventsByType.get("chunk_frozen")?.some((event) => event.chunk_id === chunk.chunk_id) === true;
     const failed = eventsByType.get("chunk_failed")?.some((event) => event.chunk_id === chunk.chunk_id) === true;

package/cli/lib/audit-sweep.mjs

@@ -6,6 +6,7 @@ export {
 } from "./audit-sweep-runtime/chunks.mjs";
 export { ingestAuditSweepChunk } from "./audit-sweep-runtime/ingest.mjs";
 export { runCodexAuditSweepChunk } from "./audit-sweep-runtime/codex-auditor.mjs";
+export { runClaudeAuditSweepChunk } from "./audit-sweep-runtime/claude-auditor.mjs";
 export { buildAuditSweepLedger } from "./audit-sweep-runtime/ledger.mjs";
 export {
   admitAuditSweepRemediationMap,

package/cli/lib/handoff.mjs

@@ -72,13 +72,16 @@ function commandRuleAllowsCurrentState(rule, doctorResult) {
   };
 }
 function evaluateSkillReadiness(skillId, doctorResult) {
-  if (!doctorResult.ok || !doctorResult.handoffReadiness.ok) {
+  const usesV2SurfaceModel = doctorResult.specGenerationInputs?.mode === "class_filtered";
+  const canBypassV2GlobalHandoffGate = usesV2SurfaceModel
+    && ["spec_reconstruction", "doc_spec_audit"].includes(skillId);
+
+  if (!doctorResult.ok || (!doctorResult.handoffReadiness.ok && !canBypassV2GlobalHandoffGate)) {
     return {
       ok: false,
       reason: "Bootstrap or handoff validation is failing; repair doctor errors before exporting handoff payloads",
     };
   }
-  const usesV2SurfaceModel = doctorResult.specGenerationInputs?.mode === "class_filtered";
   if (usesV2SurfaceModel && (doctorResult.commandGating?.entries ?? []).length === 0) {
     if (skillId === "spec_reconstruction") {
       return {
@@ -86,6 +89,12 @@ function evaluateSkillReadiness(skillId, doctorResult) {
         reason: "Projects may delegate spec reconstruction to an external AI host when canonical tree work is needed",
       };
     }
+    if (skillId === "doc_spec_audit" && doctorResult.canonicalTree?.requiredFilesValid === true) {
+      return {
+        ok: true,
+        reason: "Skill prerequisites are satisfied by the current project-local truth",
+      };
+    }
     if (doctorResult.canonicalTree?.requiredFilesValid === true && doctorResult.specGenerationAudit?.ok === true) {
       return {
         ok: true,
@@ -338,7 +347,7 @@ export async function buildHandoffPayload(projectRoot, skillId) {
     },
     runtimeOwner: doctorResult.delegatedContracts.runtimeOwner,
     triggerMode: doctorResult.delegatedContracts.triggerMode,
-    handoffReady: doctorResult.handoffReadiness.ok,
+    handoffReady: readiness.ok,
     skill: {
       id: skillId,
       required: expectedSkill.required === "true",

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

@@ -37,6 +37,24 @@ import {
 
 const PACKAGE_REPO_ROOT = fileURLToPath(new URL("../../..", import.meta.url));
 
+function deriveV2LifecycleState(bootstrapSurface) {
+  const treeReady = bootstrapSurface.canonicalTree.requiredFilesValid === true;
+  const benchmarkMode = bootstrapSurface.specGenerationInputs?.benchmarkMode
+    ?? bootstrapSurface.blueprintReference?.mode
+    ?? "none";
+
+  return {
+    mode: "class_filtered",
+    treeState: treeReady ? "canonical_tree_ready" : "canonical_tree_in_progress",
+    authorityMode: "surface_class_validated",
+    blueprintMode: benchmarkMode,
+    reconstructionRequired: !treeReady,
+    readyForAiReconstruction: !treeReady,
+    cutoverReadiness: {},
+    activeAuthorityRoot: bootstrapSurface.specGenerationInputs?.canonicalTargetRoot ?? ".nimi/spec",
+  };
+}
+
 export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegatedSurface) {
   const checks = [...bootstrapSurface.checks, ...delegatedSurface.checks];
   const usesV2SurfaceModel = bootstrapSurface.specGenerationInputs?.mode === "class_filtered";
@@ -264,7 +282,19 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
   }
 
   const hasErrors = checks.some((check) => check.severity === "error");
-  const reconstructionRequired = bootstrapSurface.bootstrapStateContract.reconstructionRequired === true;
+  const lifecycleState = usesV2SurfaceModel
+    ? deriveV2LifecycleState(bootstrapSurface)
+    : {
+      mode: bootstrapSurface.bootstrapStateContract.mode,
+      treeState: bootstrapSurface.bootstrapStateContract.treeState,
+      authorityMode: bootstrapSurface.bootstrapStateContract.authorityMode,
+      blueprintMode: bootstrapSurface.bootstrapStateContract.blueprintMode,
+      reconstructionRequired: bootstrapSurface.bootstrapStateContract.reconstructionRequired,
+      readyForAiReconstruction: bootstrapSurface.bootstrapStateContract.readyForAiReconstruction,
+      cutoverReadiness: bootstrapSurface.bootstrapStateContract.cutoverReadiness,
+      activeAuthorityRoot: bootstrapSurface.bootstrapStateContract.activeAuthorityRoot,
+    };
+  const reconstructionRequired = lifecycleState.reconstructionRequired === true;
 
   const handoffReadiness = {
     ok: delegatedSurface.handoffContextOk
@@ -355,16 +385,7 @@ export async function finalizeDoctorState(projectRoot, bootstrapSurface, delegat
       id: bootstrapSurface.bootstrapCompatibility.contractId,
       version: bootstrapSurface.bootstrapCompatibility.contractVersion,
     },
-    lifecycleState: {
-      mode: bootstrapSurface.bootstrapStateContract.mode,
-      treeState: bootstrapSurface.bootstrapStateContract.treeState,
-      authorityMode: bootstrapSurface.bootstrapStateContract.authorityMode,
-      blueprintMode: bootstrapSurface.bootstrapStateContract.blueprintMode,
-      reconstructionRequired: bootstrapSurface.bootstrapStateContract.reconstructionRequired,
-      readyForAiReconstruction: bootstrapSurface.bootstrapStateContract.readyForAiReconstruction,
-      cutoverReadiness: bootstrapSurface.bootstrapStateContract.cutoverReadiness,
-      activeAuthorityRoot: bootstrapSurface.bootstrapStateContract.activeAuthorityRoot,
-    },
+    lifecycleState,
     specTreeModel: bootstrapSurface.specTreeModel,
     specGenerationInputs: bootstrapSurface.specGenerationInputs,
     canonicalTree: bootstrapSurface.canonicalTree,

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

@@ -64,7 +64,7 @@ const DOCTOR_NEXT_STEP_TRANSLATIONS = new Map([
   ["Repair the failing bootstrap checks, then rerun `nimicoding doctor`.", "修复失败的 bootstrap 检查项，然后重新运行 `nimicoding doctor`。"],
   ["Use an external AI host to reconstruct the declared canonical tree under `.nimi/spec`.", "使用外部 AI host 重建声明的 `.nimi/spec` canonical tree。"],
   ["Run `nimicoding blueprint-audit --write-local` after canonical tree generation when a benchmark blueprint is declared.", "当声明了 benchmark blueprint 且 canonical tree 生成完成后，运行 `nimicoding blueprint-audit --write-local`。"],
-  ["Run `nimicoding validate-spec-audit` after generating `.nimi/spec/_meta/spec-generation-audit.yaml` for the canonical tree.", "在为 canonical tree 生成 `.nimi/spec/_meta/spec-generation-audit.yaml` 后，运行 `nimicoding validate-spec-audit`。"],
+  ["Run `nimicoding validate-spec-audit` after generating the local spec generation audit for the canonical tree.", "为 canonical tree 生成本地 spec generation audit 后，运行 `nimicoding validate-spec-audit`。"],
   ["Run `nimicoding handoff --skill doc_spec_audit` and close out the result locally when the audit is complete.", "运行 `nimicoding handoff --skill doc_spec_audit`，并在审计完成后于本地 closeout 结果。"],
   ["Keep runtime ownership delegated; do not assume local skill installation or self-hosting.", "保持 runtime ownership 为 delegated；不要假设本地 skill 安装或 self-hosting。"],
   ["If you want a constrained external execution host, select one in `.nimi/config/host-adapter.yaml`.", "如果你希望使用受约束的外部执行 host，请在 `.nimi/config/host-adapter.yaml` 中选择一个。"],
@@ -86,6 +86,7 @@ function summarizeDoctorState(result) {
   const blockingChecks = result.checks.filter((check) => check.severity === "error");
   const warningChecks = result.checks.filter((check) => check.severity === "warn");
   const importantInfoChecks = result.checks.filter((check) => check.severity === "info").slice(0, 2);
+  const usesV2SurfaceModel = result.specGenerationInputs?.mode === "class_filtered";
 
   const bootstrapState = !result.bootstrapPresent
     ? localize("missing", "缺失")
@@ -93,7 +94,7 @@ function summarizeDoctorState(result) {
       ? localize("ready", "就绪")
       : localize("needs attention", "需要关注");
 
-  const canonicalTreeState = !result.specTreeModel?.ok
+  const canonicalTreeState = !usesV2SurfaceModel && !result.specTreeModel?.ok
     ? localize("invalid", "无效")
     : !result.canonicalTree.requiredFilesValid
       ? localize("incomplete", "未完成")

package/config/bootstrap.yaml

@@ -1,6 +1,6 @@
 version: 1
 initialized_by: "@nimiplatform/nimi-coding"
-cli_version: "0.2.1"
+cli_version: "0.2.2"
 bootstrap_contract: "nimicoding.bootstrap"
 bootstrap_contract_version: 1
 profile: default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimiplatform/nimi-coding",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "private": false,
   "description": "AI-native coding governance toolkit for bootstrapping .nimi/** into arbitrary projects.",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "provenance": true
   },
   "bin": {
-    "nimicoding": "./bin/nimicoding.mjs"
+    "nimicoding": "bin/nimicoding.mjs"
   },
   "packageManager": "pnpm@10.32.1",
   "engines": {