@planu/cli 5.3.5 → 5.3.7

package/dist/engine/planu-core.linux-x64-musl.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.7",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.5",
+      "version": "5.3.7",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "0116080409d8d34a70bcd11545d83ef0055475bac5338e1390eb2694296f64e1"
+          "content": "bf270b2b6a40ba2211487f2da514183717cdc24b28cbee53f8d62af0462317bd"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.5",
+      "ref": "pkg:cargo/planu-core@5.3.7",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

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.7",
+  "engineVersion": "5.3.7",
+  "buildId": "1-5.3.7-aarch64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "69f0804044cbbf83b24eba6c91ba56052d502fdf605cb87de1e372606a1ff030",
+  "artifactSha256": "847e2a53bcb46266d1795f1888e17bcadcd07dedfd09c2f6380e448f04c840e3",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-arm64-msvc.node.sbom.json",
-    "sha256": "69209ba0e316391778bbe7204080e36bb793efc060e77a9007b9d954081545d7"
+    "sha256": "1221ffeb6dfc3a3fe1870d6ec5d19849358bc274a446c9cc8f82928bcd75840b"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "1ebfd1609a251513993d8635170963f6dab1420e",
+    "sourceCommit": "2ec2f2db1b564d710e56bee0b7637b49c540ca32",
     "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": "/fpd0zTa2Tum1iVlKiMFfDiMgZivT8GSHaBXHIrSnG1to4HblxZzbvVtB1t6SzT/VazXFaJrsVN6mgi5PM+0Bw=="
   }
 }

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.7",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.5",
+      "version": "5.3.7",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "69f0804044cbbf83b24eba6c91ba56052d502fdf605cb87de1e372606a1ff030"
+          "content": "847e2a53bcb46266d1795f1888e17bcadcd07dedfd09c2f6380e448f04c840e3"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.5",
+      "ref": "pkg:cargo/planu-core@5.3.7",
       "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.7",
+  "engineVersion": "5.3.7",
+  "buildId": "1-5.3.7-x86_64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "x64",
   "libc": null,
-  "artifactSha256": "266c514673274fe29f5d625cf33524e203371741f320e6933c0231824506e433",
+  "artifactSha256": "60ce324d882d46aaf9ce76f136fc1690133f02da345141846014ad69c64b0d1c",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-x64-msvc.node.sbom.json",
-    "sha256": "ba40d6627f3bacbc78c068a377d420a1d6cfebe1e75e7e90b4b94c726f7b71ea"
+    "sha256": "959a4bc45bae58e8b9152af89c6ef6da56f762017677b93ceb1f82c7f245fd27"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "1ebfd1609a251513993d8635170963f6dab1420e",
+    "sourceCommit": "2ec2f2db1b564d710e56bee0b7637b49c540ca32",
     "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": "ma06pJyrfthlcVjNUlZW0ledijIuGYUE77VdST+TzST4J5dzTOO7eMYjJbideY/xL+FUcwqLYquiApnRJQvBAw=="
   }
 }

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.7",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.5",
+      "version": "5.3.7",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "266c514673274fe29f5d625cf33524e203371741f320e6933c0231824506e433"
+          "content": "60ce324d882d46aaf9ce76f136fc1690133f02da345141846014ad69c64b0d1c"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.5",
+      "ref": "pkg:cargo/planu-core@5.3.7",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/runtime-policy.js

@@ -47,6 +47,7 @@ const runtimePolicySchema = z
         .object({
         defaultDeadlineMs: z.number().int().positive(),
         durableLintTimeoutMs: z.number().int().positive(),
+        perGateTimeoutMs: z.number().int().positive(),
         complianceCommandTimeoutMs: z.number().int().positive(),
         noProgressTimeoutMs: z.number().int().positive(),
         submissionLockWaitMs: z.number().int().positive(),
@@ -72,6 +73,12 @@ const runtimePolicySchema = z
     })
         .refine((value) => value.durableLintTimeoutMs < value.complianceCommandTimeoutMs, {
         message: 'durableLintTimeoutMs must be below complianceCommandTimeoutMs',
+    })
+        .refine((value) => value.durableLintTimeoutMs < value.perGateTimeoutMs, {
+        message: 'durableLintTimeoutMs must be below perGateTimeoutMs',
+    })
+        .refine((value) => value.perGateTimeoutMs < value.noProgressTimeoutMs, {
+        message: 'perGateTimeoutMs must be below noProgressTimeoutMs',
     })
         .refine((value) => value.complianceCommandTimeoutMs + PROCESS_TERMINATION_GRACE_MS <
         value.noProgressTimeoutMs, {

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/,
@@ -55,18 +57,21 @@ function preservesBoundary(text) {
         /\bno changes? to\b/,
     ].some((pattern) => pattern.test(normalized));
 }
+const CLAUSE_KEYWORD_OR_PUNCTUATION = /\b(?:but|while|although|however)\b|[,;]/i;
+const SENTENCE_ENDING_PERIOD = /\.(?=\s|$)/;
 function splitClauses(text) {
     return text
-        .split(/\b(?:but|while|although|however)\b|[,;.]/i)
+        .split(CLAUSE_KEYWORD_OR_PUNCTUATION)
+        .flatMap((segment) => segment.split(SENTENCE_ENDING_PERIOD))
         .map((clause) => clause.trim())
         .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 +89,12 @@ function hasAffirmativeDrift(text, outOfScopeItem) {
     }
     return false;
 }
+function containsKeyword(normalizedHaystack, keyword) {
+    return new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(normalizedHaystack);
+}
+function isDirectPhraseMatch(normCriterion, normScope) {
+    return containsKeyword(normCriterion, normScope) || containsKeyword(normScope, normCriterion);
+}
 function clauseMatchesScope(clause, outOfScopeItem) {
     const normalizedClause = normalize(clause);
     const normalizedScope = normalize(outOfScopeItem);
@@ -91,10 +102,16 @@ 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);
+    const scopeKeywords = keywords(outOfScopeItem);
+    const mentionCandidates = scopeKeywords.length > 0 ? scopeKeywords : [normalize(outOfScopeItem)];
+    return mentionCandidates.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,30 +119,21 @@ 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
-    if (normCriterion.includes(normScope)) {
-        return true;
-    }
-    // 2. Reverse — the out-of-scope item contains the whole criterion (unlikely but safe)
-    if (normScope.includes(normCriterion)) {
+    if (isDirectPhraseMatch(normCriterion, normScope)) {
         return true;
     }
-    // 3. Keyword overlap: if 2+ significant keywords from outOfScope appear in criterion
-    const scopeKws = keywords(outOfScopeItem);
-    if (scopeKws.length === 0) {
+    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) => ({