Fix CLI bugs: Required Truths and Constraints parsing

Bugs fixed:
- Required Truths showing 0/6 instead of 6/6 for converged manifolds
- Constraints showing undefined/NaN% when verification data present

Root causes:
- status.ts checked anchors.required_truths (planning-time) not verification section
- verify.ts expected generation.coverage.constraints_addressed which doesn't exist
  for all manifold types

Fixes:
- Added verification field to Manifold interface in parser.ts
- status.ts now checks verification.required_truths_satisfied first
- verify.ts now checks verification.constraints_satisfied first

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dhanesh

.gitignore

@@ -53,3 +53,4 @@ build/
 # Note: .manifold/ is NOT ignored - it should be tracked
 # for team collaboration and cross-machine continuity
 # ===========================================
+*.bun-build

cli/commands/status.ts

@@ -204,12 +204,24 @@ function printFeatureStatus(data: FeatureData, includeHistory?: boolean): void {
     println(formatKeyValue('Tensions', formatTensionSummary(resolved, manifold.tensions.length)));
   }
 
-  // Anchors
+  // Anchors - check verification section first (post-verification), then fall back to anchors (planning-time)
   if (manifold.anchors?.required_truths?.length) {
-    const satisfied = manifold.anchors.required_truths.filter(
-      rt => rt.status === 'SATISFIED'
-    ).length;
-    println(formatKeyValue('Required Truths', `${satisfied}/${manifold.anchors.required_truths.length} satisfied`));
+    const total = manifold.anchors.required_truths.length;
+    let satisfied: number;
+
+    // Check if verification has the satisfied count (post-verification is more accurate)
+    if (manifold.verification?.required_truths_satisfied) {
+      // Parse from string like "6/6 (100%)" or just use the number
+      const rtStr = String(manifold.verification.required_truths_satisfied);
+      const match = rtStr.match(/^(\d+)/);
+      satisfied = match ? parseInt(match[1], 10) : 0;
+    } else {
+      // Fall back to counting from anchors
+      satisfied = manifold.anchors.required_truths.filter(
+        rt => rt.status === 'SATISFIED'
+      ).length;
+    }
+    println(formatKeyValue('Required Truths', `${satisfied}/${total} satisfied`));
   }
 
   if (manifold.anchors?.recommended_option) {

cli/commands/verify.ts

@@ -265,12 +265,19 @@ function calculateCoverage(manifold: Manifold): NonNullable<VerificationResult['
   const constraintCounts = countConstraints(manifold);
   const totalConstraints = constraintCounts.total;
 
-  // Count satisfied from generation coverage or estimate from phase
+  // Count satisfied from verification, generation coverage, or estimate from phase
   let satisfiedConstraints = 0;
-  if (manifold.generation?.coverage) {
+
+  // Priority 1: Check verification section (most accurate, post-verification)
+  if (manifold.verification?.constraints_satisfied !== undefined) {
+    satisfiedConstraints = manifold.verification.constraints_satisfied;
+  }
+  // Priority 2: Check generation coverage
+  else if (manifold.generation?.coverage?.constraints_addressed !== undefined) {
     satisfiedConstraints = manifold.generation.coverage.constraints_addressed;
-  } else {
-    // Estimate based on phase
+  }
+  // Priority 3: Estimate based on phase
+  else {
     const phaseProgress: Record<string, number> = {
       'INITIALIZED': 0,
       'CONSTRAINED': 0.2,
@@ -282,9 +289,18 @@ function calculateCoverage(manifold: Manifold): NonNullable<VerificationResult['
     satisfiedConstraints = Math.floor(totalConstraints * (phaseProgress[manifold.phase] ?? 0));
   }
 
-  // Count required truths
+  // Count required truths - check verification first, then anchors
   const requiredTruths = manifold.anchors?.required_truths ?? [];
-  const satisfiedTruths = requiredTruths.filter(rt => rt.status === 'SATISFIED').length;
+  let satisfiedTruths = 0;
+
+  // Check if verification has the satisfied count
+  if (manifold.verification?.required_truths_satisfied) {
+    const rtStr = String(manifold.verification.required_truths_satisfied);
+    const match = rtStr.match(/^(\d+)/);
+    satisfiedTruths = match ? parseInt(match[1], 10) : 0;
+  } else {
+    satisfiedTruths = requiredTruths.filter(rt => rt.status === 'SATISFIED').length;
+  }
 
   const percentage = totalConstraints > 0
     ? Math.round((satisfiedConstraints / totalConstraints) * 100)

cli/lib/parser.ts

@@ -57,6 +57,20 @@ export interface Manifold {
 
   generation?: Generation;
   integration?: Integration;
+
+  // Inline verification data (alternative to separate .verify.yaml)
+  verification?: {
+    timestamp?: string;
+    result?: string;
+    constraints_verified?: number;
+    constraints_satisfied?: number;
+    gaps_found?: number;
+    gaps_blocking?: number;
+    gaps_nonblocking?: number;
+    required_truths_satisfied?: string | number;
+    coverage?: Record<string, string | number>;
+    verify_document?: string;
+  };
 }
 
 export interface Constraint {