@planu/cli 5.3.5 → 5.3.6

package/dist/engine/planu-core.win32-arm64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.5",
-  "engineVersion": "5.3.5",
-  "buildId": "1-5.3.5-aarch64-pc-windows-msvc",
+  "cliVersion": "5.3.6",
+  "engineVersion": "5.3.6",
+  "buildId": "1-5.3.6-aarch64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "69f0804044cbbf83b24eba6c91ba56052d502fdf605cb87de1e372606a1ff030",
+  "artifactSha256": "16659d578e84674eeab01f7f53943e46ae8b2c1836fef583eb126a4eee15c2ff",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-arm64-msvc.node.sbom.json",
-    "sha256": "69209ba0e316391778bbe7204080e36bb793efc060e77a9007b9d954081545d7"
+    "sha256": "411f35f08ebc1f8dc65a665bc355e2b10dc0b8db2bb279e33bb1a4d49f1bad34"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "1ebfd1609a251513993d8635170963f6dab1420e",
+    "sourceCommit": "2dae5f5028632004802bad4c143eb86d8abba774",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "CBuCyMiMXamGF99MF2n+dvmeHDR3NBXjUAgiutEjRmTakq+qdh6fPiGXQKli5kRhd5O4nfNWobIsaWJ+vSCdBA=="
+    "value": "om/6aNSNCXZ8rbF+dw+8mWFhr1Zj0+z06pFccowCC3dcXtzDkLwDuquUlcHq8OSmFJNyjXFJ5i+OopjRPXKqCg=="
   }
 }

package/dist/engine/planu-core.win32-arm64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.5",
+      "bom-ref": "pkg:cargo/planu-core@5.3.6",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.5",
+      "version": "5.3.6",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "69f0804044cbbf83b24eba6c91ba56052d502fdf605cb87de1e372606a1ff030"
+          "content": "16659d578e84674eeab01f7f53943e46ae8b2c1836fef583eb126a4eee15c2ff"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.5",
+      "ref": "pkg:cargo/planu-core@5.3.6",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.win32-x64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.5",
-  "engineVersion": "5.3.5",
-  "buildId": "1-5.3.5-x86_64-pc-windows-msvc",
+  "cliVersion": "5.3.6",
+  "engineVersion": "5.3.6",
+  "buildId": "1-5.3.6-x86_64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "x64",
   "libc": null,
-  "artifactSha256": "266c514673274fe29f5d625cf33524e203371741f320e6933c0231824506e433",
+  "artifactSha256": "e6750baae63b969de18daae8150796a785638847bb7b3645b214b252f0bf32d3",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-x64-msvc.node.sbom.json",
-    "sha256": "ba40d6627f3bacbc78c068a377d420a1d6cfebe1e75e7e90b4b94c726f7b71ea"
+    "sha256": "323e01b4f75869ec688a26524c5e4aa756a6ad5c0e7fd968a9090ad6e58a75bf"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "1ebfd1609a251513993d8635170963f6dab1420e",
+    "sourceCommit": "2dae5f5028632004802bad4c143eb86d8abba774",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "zQa9uJfhQpDFLD3/iWUJQGPjUjlqm66DKR9VX+2kbc7dGmYODAxXYLxxJKnFKnpjyaToedkLmurajIE4zMODAA=="
+    "value": "YmufISTxo4Tx7ceRSzMxv6fXdoi19oHTokfKkevZzBkaCi3msjDRWJqerPQjjDr5Vkip8LB+2oQUS2DC3Ea+AQ=="
   }
 }

package/dist/engine/planu-core.win32-x64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.5",
+      "bom-ref": "pkg:cargo/planu-core@5.3.6",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.5",
+      "version": "5.3.6",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "266c514673274fe29f5d625cf33524e203371741f320e6933c0231824506e433"
+          "content": "e6750baae63b969de18daae8150796a785638847bb7b3645b214b252f0bf32d3"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.5",
+      "ref": "pkg:cargo/planu-core@5.3.6",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/scope-boundaries/contradiction-checker.js

@@ -47,6 +47,8 @@ function keywords(phrase) {
 function preservesBoundary(text) {
     const normalized = normalize(text);
     return [
+        /\balongside the (?:existing|current)\b/,
+        /\balready (?:targets?|does|do|supports?|covers?|handles?)\b/,
         /\bremains? unchanged\b/,
         /\bkeeps?\b.{0,80}\bunchanged\b/,
         /\bpreserves?\b.{0,80}\b(?:behavior|contract|boundary|semantics|state)\b/,
@@ -62,11 +64,11 @@ function splitClauses(text) {
         .filter(Boolean);
 }
 function hasAffirmativeDrift(text, outOfScopeItem) {
-    const action = /\b(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?)\b/g;
+    const action = /\b(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?|exposes?|exposed)\b/g;
     const actionSegments = text.split(/\band\b/i).map(normalize);
     for (const [index, segment] of actionSegments.entries()) {
         const inheritsRelevantSubject = index > 0 &&
-            /^(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?)\b/.test(segment) &&
+            /^(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?|exposes?|exposed)\b/.test(segment) &&
             clauseMatchesScope(actionSegments[index - 1] ?? '', outOfScopeItem);
         for (const match of segment.matchAll(action)) {
             const before = segment.slice(Math.max(0, match.index - 24), match.index);
@@ -84,6 +86,9 @@ function hasAffirmativeDrift(text, outOfScopeItem) {
     }
     return false;
 }
+function containsKeyword(normalizedHaystack, keyword) {
+    return new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(normalizedHaystack);
+}
 function clauseMatchesScope(clause, outOfScopeItem) {
     const normalizedClause = normalize(clause);
     const normalizedScope = normalize(outOfScopeItem);
@@ -91,10 +96,14 @@ function clauseMatchesScope(clause, outOfScopeItem) {
         return true;
     }
     const scopeKeywords = keywords(outOfScopeItem);
-    const matchCount = scopeKeywords.filter((keyword) => normalizedClause.includes(keyword)).length;
+    const matchCount = scopeKeywords.filter((keyword) => containsKeyword(normalizedClause, keyword)).length;
     const threshold = scopeKeywords.length <= 2 ? scopeKeywords.length : 2;
     return scopeKeywords.length > 0 && matchCount >= threshold;
 }
+function clauseMentionsScope(clause, outOfScopeItem) {
+    const normalizedClause = normalize(clause);
+    return keywords(outOfScopeItem).some((keyword) => containsKeyword(normalizedClause, keyword));
+}
 /**
  * Determine whether a criterion text contradicts an out-of-scope item.
  * Uses substring match first, then keyword overlap as fuzzy fallback.
@@ -102,11 +111,12 @@ function clauseMatchesScope(clause, outOfScopeItem) {
 function contradicts(criterionText, outOfScopeItem) {
     const normCriterion = normalize(criterionText);
     const normScope = normalize(outOfScopeItem);
-    const relevantClauses = splitClauses(criterionText).filter((clause) => clauseMatchesScope(clause, outOfScopeItem));
+    const clauses = splitClauses(criterionText);
+    const relevantClauses = clauses.filter((clause) => clauseMentionsScope(clause, outOfScopeItem));
     const hasConditionalException = /\b(?:unless|except)\b/i.test(criterionText);
     if (!hasConditionalException &&
-        relevantClauses.length > 0 &&
-        relevantClauses.every((clause) => preservesBoundary(clause) && !hasAffirmativeDrift(clause, outOfScopeItem))) {
+        relevantClauses.some(preservesBoundary) &&
+        !relevantClauses.some((clause) => hasAffirmativeDrift(clause, outOfScopeItem))) {
         return false;
     }
     // 1. Direct substring match
@@ -117,15 +127,12 @@ function contradicts(criterionText, outOfScopeItem) {
     if (normScope.includes(normCriterion)) {
         return true;
     }
-    // 3. Keyword overlap: if 2+ significant keywords from outOfScope appear in criterion
-    const scopeKws = keywords(outOfScopeItem);
-    if (scopeKws.length === 0) {
+    // 3. Keyword overlap, scoped to a single clause: if 2+ significant keywords from
+    // outOfScope appear within the same clause of the criterion
+    if (keywords(outOfScopeItem).length === 0) {
         return false;
     }
-    const matchCount = scopeKws.filter((kw) => normCriterion.includes(kw)).length;
-    // For 1 keyword: require it to match; for 2 keywords: require both; for 3+: require 2
-    const threshold = scopeKws.length === 1 ? 1 : scopeKws.length === 2 ? 2 : 2;
-    return matchCount >= threshold;
+    return clauses.some((clause) => clauseMatchesScope(clause, outOfScopeItem));
 }
 /**
  * Check acceptance criteria against the spec's outOfScope declarations.

package/dist/engine/spec-format/acceptance-criteria.js

@@ -5,7 +5,7 @@ import { stripFencedBlocks } from './text-fences.js';
 import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
 const BDD_STEP = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
 const BDD_START = /^(GIVEN|DADO)\b/i;
-const TECHNICAL_MARKER = /^(FILES|FUNCTIONS|TEST|OWNER|NOTE):/i;
+const TECHNICAL_MARKER = /^(FILES|FUNCTIONS|TEST|OWNER|NOTE|AB\s*-?\s*\d+|ANTICIPATED TEST BREAK|TEST BREAK):/i;
 const EXPLICIT_CRITERION_HEADING = /^#{3,6}\s+((?:AC|AB)\s*-?\s*\d+)\b/i;
 function extractBddBlocks(section) {
     const lines = section.split('\n').map((line) => line.trim());
@@ -93,7 +93,10 @@ function extractSectionCriteria(section) {
     const listItems = extractListItems(section).filter((item) => !TECHNICAL_MARKER.test(item));
     if (listItems.length > 0) {
         const nonStepItems = listItems.filter((item) => !BDD_STEP.test(item));
-        return nonStepItems.length > 0 ? nonStepItems : extractBddBlocks(section);
+        if (nonStepItems.length === listItems.length) {
+            return nonStepItems.length > 0 ? nonStepItems : extractBddBlocks(section);
+        }
+        return [...extractBddBlocks(section), ...nonStepItems];
     }
     return extractBddBlocks(section);
 }

package/dist/engine/spec-migrator/filesystem-import.js

@@ -1,7 +1,39 @@
 // spec-migrator/filesystem-import.ts — Import specs from disk into the store
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { calculateEstimation } from '../estimator.js';
 import { parseFrontmatterLocal, validSpecType, validSpecScope, validSpecStatus, validRiskLevel, validSpecTarget, validDifficulty, } from './frontmatter-parser.js';
+const RECOMMENDED_MODELS = new Set(['opus', 'sonnet', 'mixed']);
+const EXECUTION_MODES = new Set(['local', 'template', 'light-llm', 'full-llm']);
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isFiniteNonNegative(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function isValidTokenStrategy(value) {
+    return (isPlainObject(value) &&
+        typeof value.mode === 'string' &&
+        EXECUTION_MODES.has(value.mode) &&
+        typeof value.reasoning === 'string' &&
+        isFiniteNonNegative(value.estimatedTokens) &&
+        typeof value.savings === 'string');
+}
+function isValidPortableEstimation(value) {
+    return (isPlainObject(value) &&
+        isFiniteNonNegative(value.devHours) &&
+        value.devHours > 0 &&
+        isFiniteNonNegative(value.reviewHours) &&
+        typeof value.recommendedModel === 'string' &&
+        RECOMMENDED_MODELS.has(value.recommendedModel) &&
+        isFiniteNonNegative(value.tokensOpus) &&
+        isFiniteNonNegative(value.tokensSonnet) &&
+        isFiniteNonNegative(value.apiCostUsd) &&
+        isFiniteNonNegative(value.hourlyRate) &&
+        isFiniteNonNegative(value.humanCostUsd) &&
+        isFiniteNonNegative(value.totalCostUsd) &&
+        isValidTokenStrategy(value.tokenOptimization));
+}
 const SPEC_FOLDER_ID_RE = /^(SPEC-\d{3,})/;
 function optionalString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
@@ -50,14 +82,20 @@ function generationFromMetadata(metadata, fallbackGeneratedAt) {
         ...(modelId ? { modelId } : {}),
     };
 }
-// eslint-disable-next-line max-lines-per-function, complexity -- portable metadata is normalized at one boundary
-function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metadata) {
+// eslint-disable-next-line complexity -- portable metadata is normalized at one boundary
+function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metadata, globalConfig) {
     const now = new Date().toISOString();
     const folder = join(projectPath, 'planu', 'specs', entryName);
     const specPath = join(folder, 'spec.md');
     const slug = entryName.replace(/^SPEC-\d{3,}-/, '');
     const stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
     const generation = generationFromMetadata(metadata, now);
+    const type = validSpecType(metadata.type) ?? 'feature';
+    const scope = validSpecScope(metadata.scope) ?? 'feature';
+    const difficulty = validDifficulty(metadata.difficulty) ?? 3;
+    const estimation = isValidPortableEstimation(metadata.estimation)
+        ? metadata.estimation
+        : calculateEstimation(type, scope, difficulty, globalConfig);
     return {
         id: specId,
         ...(optionalString(metadata.uuid) ? { uuid: optionalString(metadata.uuid) } : {}),
@@ -71,10 +109,10 @@ function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metada
         title: typeof metadata.title === 'string' ? metadata.title : specId,
         slug,
         ...(optionalString(metadata.feature) ? { feature: optionalString(metadata.feature) } : {}),
-        type: validSpecType(metadata.type) ?? 'feature',
-        scope: validSpecScope(metadata.scope) ?? 'feature',
+        type,
+        scope,
         status: validSpecStatus(metadata.status) ?? 'draft',
-        difficulty: validDifficulty(metadata.difficulty) ?? 3,
+        difficulty,
         risk: validRiskLevel(metadata.risk) ?? 'medium',
         target: validSpecTarget(metadata.target) ?? 'backend',
         projectId,
@@ -83,23 +121,7 @@ function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metada
         specPath,
         technicalPath: specPath,
         progressPath: '',
-        estimation: {
-            devHours: 0,
-            reviewHours: 0,
-            recommendedModel: 'sonnet',
-            tokensOpus: 0,
-            tokensSonnet: 0,
-            apiCostUsd: 0,
-            hourlyRate: 0,
-            humanCostUsd: 0,
-            totalCostUsd: 0,
-            tokenOptimization: {
-                mode: 'local',
-                reasoning: 'imported from filesystem',
-                estimatedTokens: 0,
-                savings: '',
-            },
-        },
+        estimation,
         actuals: null,
         tags: stringList(metadata.tags),
         dependencies: stringList(metadata.dependencies),
@@ -125,6 +147,60 @@ function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metada
         impactAnalysis: null,
     };
 }
+async function resolveGlobalConfig(deps) {
+    return (await deps.getGlobalConfig?.()) ?? {};
+}
+async function importSpecEntry(entry, ctx) {
+    const idMatch = SPEC_FOLDER_ID_RE.exec(entry.name);
+    if (!idMatch?.[1]) {
+        return;
+    }
+    const specId = idMatch[1];
+    const specMdPath = join(ctx.specsRoot, entry.name, 'spec.md');
+    const relativeSpecPath = `planu/specs/${entry.name}/spec.md`;
+    let spec;
+    try {
+        const content = await readFile(specMdPath, 'utf-8');
+        const { metadata } = parseFrontmatterLocal(content);
+        if (ctx.options.strictPortableContract === true && !isValidPortableMetadata(specId, metadata)) {
+            ctx.failures.push({ specId, path: relativeSpecPath, code: 'INVALID_CONTRACT' });
+            return;
+        }
+        spec = buildSpecFromMetadata(specId, entry.name, ctx.projectPath, ctx.projectId, metadata, ctx.globalConfig);
+    }
+    catch {
+        ctx.failures.push({ specId, path: relativeSpecPath, code: 'READ_FAILED' });
+        return;
+    }
+    const existing = ctx.specsById.get(specId);
+    if (existing !== undefined) {
+        if (!compatibleIdentity(existing, spec)) {
+            ctx.failures.push({ specId, path: relativeSpecPath, code: 'INCOMPATIBLE_IDENTITY' });
+        }
+        return;
+    }
+    if (ctx.storeSpecs.some((stored) => hasAnyUuidIdentity(stored, spec))) {
+        ctx.failures.push({ specId, path: relativeSpecPath, code: 'INCOMPATIBLE_IDENTITY' });
+        return;
+    }
+    try {
+        await ctx.deps.createSpec(ctx.projectId, spec);
+        ctx.specsById.set(specId, spec);
+        ctx.importedSpecIds.push(specId);
+    }
+    catch {
+        const winner = await ctx.deps.getSpecFresh?.(ctx.projectId, specId).catch(() => null);
+        if (winner !== undefined && winner !== null && compatibleIdentity(winner, spec)) {
+            ctx.specsById.set(specId, winner);
+            return;
+        }
+        ctx.failures.push({
+            specId,
+            path: relativeSpecPath,
+            code: winner ? 'INCOMPATIBLE_IDENTITY' : 'CREATE_FAILED',
+        });
+    }
+}
 /**
  * Import specs that exist on disk (planu/specs/) but are missing from the store.
  * Reads frontmatter from each spec.md and creates a minimal Spec record in the store.
@@ -136,6 +212,7 @@ export async function importFilesystemSpecs(projectPath, deps, projectId, option
     const importedSpecIds = [];
     const storeSpecs = await deps.listSpecs(projectId);
     const specsById = new Map(storeSpecs.map((spec) => [spec.id, spec]));
+    const globalConfig = await resolveGlobalConfig(deps);
     let entries;
     try {
         entries = await readdir(specsRoot, { withFileTypes: true });
@@ -143,58 +220,21 @@ export async function importFilesystemSpecs(projectPath, deps, projectId, option
     catch {
         return { importedCount: 0, importedSpecIds, failures, errors: [] };
     }
+    const ctx = {
+        projectPath,
+        projectId,
+        deps,
+        options,
+        specsRoot,
+        globalConfig,
+        storeSpecs,
+        specsById,
+        importedSpecIds,
+        failures,
+    };
     for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const idMatch = SPEC_FOLDER_ID_RE.exec(entry.name);
-        if (!idMatch?.[1]) {
-            continue;
-        }
-        const specId = idMatch[1];
-        const specMdPath = join(specsRoot, entry.name, 'spec.md');
-        const relativeSpecPath = `planu/specs/${entry.name}/spec.md`;
-        let spec;
-        try {
-            const content = await readFile(specMdPath, 'utf-8');
-            const { metadata } = parseFrontmatterLocal(content);
-            if (options.strictPortableContract === true && !isValidPortableMetadata(specId, metadata)) {
-                failures.push({ specId, path: relativeSpecPath, code: 'INVALID_CONTRACT' });
-                continue;
-            }
-            spec = buildSpecFromMetadata(specId, entry.name, projectPath, projectId, metadata);
-        }
-        catch {
-            failures.push({ specId, path: relativeSpecPath, code: 'READ_FAILED' });
-            continue;
-        }
-        const existing = specsById.get(specId);
-        if (existing !== undefined) {
-            if (!compatibleIdentity(existing, spec)) {
-                failures.push({ specId, path: relativeSpecPath, code: 'INCOMPATIBLE_IDENTITY' });
-            }
-            continue;
-        }
-        if (storeSpecs.some((stored) => hasAnyUuidIdentity(stored, spec))) {
-            failures.push({ specId, path: relativeSpecPath, code: 'INCOMPATIBLE_IDENTITY' });
-            continue;
-        }
-        try {
-            await deps.createSpec(projectId, spec);
-            specsById.set(specId, spec);
-            importedSpecIds.push(specId);
-        }
-        catch {
-            const winner = await deps.getSpecFresh?.(projectId, specId).catch(() => null);
-            if (winner !== undefined && winner !== null && compatibleIdentity(winner, spec)) {
-                specsById.set(specId, winner);
-                continue;
-            }
-            failures.push({
-                specId,
-                path: relativeSpecPath,
-                code: winner ? 'INCOMPATIBLE_IDENTITY' : 'CREATE_FAILED',
-            });
+        if (entry.isDirectory()) {
+            await importSpecEntry(entry, ctx);
         }
     }
     return {

package/dist/engine/spec-migrator/frontmatter-parser.js

@@ -14,8 +14,8 @@ function parseScalar(val) {
     if (val === 'null') {
         return null;
     }
-    if (/^\d+$/.test(val)) {
-        return parseInt(val, 10);
+    if (/^-?\d+(\.\d+)?$/.test(val)) {
+        return Number(val);
     }
     return val.replace(/^["']|["']$/g, '');
 }
@@ -25,29 +25,31 @@ export function parseFrontmatterLocal(content) {
         return { metadata: {} };
     }
     const metadata = {};
-    let activeObject = null;
+    const stack = [];
     for (const line of match[1].split('\n')) {
         const indent = line.length - line.trimStart().length;
         const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        let top = stack.at(-1);
+        while (top !== undefined && indent <= top.indent) {
+            stack.pop();
+            top = stack.at(-1);
+        }
+        const container = top?.value ?? metadata;
         const object = FM_OBJECT_RE.exec(trimmed);
         if (object?.[1]) {
             const value = {};
-            metadata[object[1]] = value;
-            activeObject = { indent, value };
+            container[object[1]] = value;
+            stack.push({ indent, value });
             continue;
         }
         const kv = FM_KV_RE.exec(trimmed);
         if (!kv?.[1] || kv[2] === undefined) {
             continue;
         }
-        const key = kv[1];
-        const val = kv[2].trim();
-        if (activeObject !== null && indent > activeObject.indent) {
-            activeObject.value[key] = parseScalar(val);
-            continue;
-        }
-        activeObject = null;
-        metadata[key] = parseScalar(val);
+        container[kv[1]] = parseScalar(kv[2].trim());
     }
     return { metadata };
 }

package/dist/tools/auto-reconcile.js

@@ -49,7 +49,7 @@ async function reconcileSingleSpec(projectId, specId) {
     // Run living-spec analysis for completion update
     const knowledge = await knowledgeStore.getKnowledge(projectId);
     if (knowledge?.projectPath) {
-        const report = await analyzeLivingSpec(spec, knowledge.projectPath);
+        const report = await analyzeLivingSpec(spec, knowledge.projectPath, { writeProgress: true });
         // Completion percentage update is a safe change
         changes.push(createLogEntry(specId, 'completion-update', `Completion updated to ${String(report.completionPercent)}%`, 'unknown', `${String(report.completionPercent)}%`));
         // Timestamp update is safe

package/dist/tools/challenge-spec/challenge-report.js

@@ -102,7 +102,7 @@ export function buildChallengeReport(input) {
     ], scenarioNames);
     const resolvedScenarios = new Set(resolutionEvidence.map((item) => item.scenario));
     const addressedCount = resolvedScenarios.size;
-    const requiredCount = requiredResolvedChallenges(input.scenarios.length);
+    const requiredCount = requiredResolvedChallenges(scenarioNames.size);
     return {
         runAt: input.runAt ?? new Date().toISOString(),
         totalScenarios: input.scenarios.length,

package/dist/tools/init-project/portable-index-reconciler.js

@@ -1,10 +1,11 @@
-import { specStore } from '../../storage/index.js';
+import { globalStore, specStore } from '../../storage/index.js';
 import { importFilesystemSpecs } from '../../engine/spec-migrator/filesystem-import.js';
 /** Rebuild the mutable external index from the repository-owned portable contracts. */
 export async function reconcilePortableSpecIndex(projectPath, projectId, deps = {
     listSpecs: specStore.listSpecs,
     createSpec: specStore.createSpec,
     getSpecFresh: specStore.getSpecFresh,
+    getGlobalConfig: globalStore.getGlobalConfig,
 }) {
     const result = await importFilesystemSpecs(projectPath, deps, projectId, {
         strictPortableContract: true,

package/dist/tools/reconcile-spec.js

@@ -464,7 +464,9 @@ export async function handleReconcileSpec(params, server) {
         if (livingSpec) {
             const projectKnowledge = await knowledgeStore.getKnowledge(projectId);
             if (projectKnowledge?.projectPath) {
-                livingSpecReport = await analyzeLivingSpec(spec, projectKnowledge.projectPath);
+                livingSpecReport = await analyzeLivingSpec(spec, projectKnowledge.projectPath, {
+                    writeProgress: true,
+                });
             }
         }
         const appliedChangesReport = appliedChanges.map((c) => ({

package/dist/tools/safe-handler.js

@@ -3,7 +3,6 @@
 // instead of crashing the server. Includes cancellation-aware execution deadlines.
 import { withUsageTracking } from './usage-tracking.js';
 import { sanitizePath } from './sanitize-path.js';
-import { ensureHooksStarted } from './start-hooks.js';
 import { ensureWorkersStarted } from '../engine/workers/index.js';
 import { recordError } from '../storage/error-telemetry-store.js';
 import { hashProjectPath } from '../storage/base-store.js';
@@ -158,7 +157,6 @@ function sanitizeArgs(args, toolName) {
         // planu_status is a read-only snapshot. Starting background services here made
         // its latency depend on repository size and violated the MCP readOnlyHint.
         if (toolName !== 'planu_status') {
-            ensureHooksStarted(obj.projectPath);
             ensureWorkersStarted(obj.projectPath);
         }
         // Read-only check: track whether planu.json exists (no file writes)

package/dist/tools/start-hooks/engine.d.ts

@@ -1,13 +1,12 @@
 import type { ToolResult } from '../../types/index.js';
-import type { StartHooksInput, StopHooksInput } from '../../types/file-hooks.js';
+import type { StartHooksInput, StopHooksInput, HookStatusInput } from '../../types/file-hooks.js';
 import { HookEngine } from '../../engine/hooks/hook-engine.js';
 import { FileWatcher } from '../../engine/hooks/file-watcher.js';
 import { ConfigLoader } from '../../engine/hooks/config-loader.js';
 export declare function getEngineInstance(): HookEngine | null;
 export declare function getWatcherInstance(): FileWatcher | null;
 export declare function getConfigLoaderInstance(): ConfigLoader | null;
-export declare function ensureHooksStarted(projectPath: string): void;
 export declare function handleStartHooks(args: StartHooksInput): Promise<ToolResult>;
 export declare function handleStopHooks(_args: StopHooksInput): Promise<ToolResult>;
-export declare function handleHookStatus(): Promise<ToolResult>;
+export declare function handleHookStatus(args?: HookStatusInput): Promise<ToolResult>;
 //# sourceMappingURL=engine.d.ts.map