@planu/cli 5.3.4 → 5.3.6

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/engine/universal-rules/catalog.js

@@ -10,6 +10,9 @@ import { planuApprovalGatesRule } from './rules/planu-approval-gates.js';
 import { planuReleasePolicyRule } from './rules/planu-release-policy.js';
 import { planuSddModelRoutingRule } from './rules/planu-sdd-model-routing.js';
 import { planuMinimalChangeRule } from './rules/planu-minimal-change.js';
+import { planuDebateReviewRule } from './rules/planu-debate-review.js';
+import { planuRevertProofTestsRule } from './rules/planu-revert-proof-tests.js';
+import { planuCleanCodeNoCommentsRule } from './rules/planu-clean-code-no-comments.js';
 /**
  * The full catalog of universal Planu rules.
  * Order matters: rules are installed in catalog order.
@@ -25,5 +28,8 @@ export const UNIVERSAL_RULES = [
     planuModesRule,
     agentTeamsRule,
     planuDogfoodBugsRule,
+    planuDebateReviewRule,
+    planuRevertProofTestsRule,
+    planuCleanCodeNoCommentsRule,
 ];
 //# sourceMappingURL=catalog.js.map

package/dist/engine/universal-rules/rules/agent-teams.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/agent-teams.ts — SPEC-779
-// Universal rule: Agent Teams (migrated from rules-generator.ts)
 function buildBody() {
     return `# Agent Teams (MANDATORY when 3+ specs in parallel)
 

package/dist/engine/universal-rules/rules/planu-approval-gates.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-approval-gates.ts — Universal rule: approval and done gates
 function buildBody() {
     return `# Planu Approval and Done Gates
 

package/dist/engine/universal-rules/rules/planu-bdd-criteria.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-bdd-criteria.ts — Universal rule: BDD acceptance criteria
 function buildBody() {
     return `# Planu BDD Acceptance Criteria
 

package/dist/engine/universal-rules/rules/planu-clean-code-no-comments.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuCleanCodeNoCommentsRule: UniversalRule;
+//# sourceMappingURL=planu-clean-code-no-comments.d.ts.map

package/dist/engine/universal-rules/rules/planu-clean-code-no-comments.js

@@ -0,0 +1,30 @@
+function buildBody() {
+    return `# Planu Clean Code — No Comments
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+Code must be self-documenting. A comment is allowed only when the behavior cannot be expressed through naming or structure — for example a non-obvious language semantic. Everything else is a naming problem.
+
+This rule assumes \`planu-dogfood-bugs\` already prohibits deferred-work markers such as TODO/FIXME and does not restate that prohibition.
+
+## The Rule
+
+Prohibited: narrative comments that restate the code, \`(SPEC-NNNN: ...)\` rationale blocks whose history belongs in the spec and in git blame, step-by-step or section-divider comments inside a function, and JSDoc that only repeats the signature.
+
+Replacement action: Extract a helper whose name is the comment, promote a magic value to a named constant, or introduce a named type when a shape needs explaining.
+
+## Enforcement
+
+Implementation agents add narrative comments by default. Stripping them before accepting subagent output is part of reviewing that output, not an optional cleanup pass.
+`;
+}
+export const planuCleanCodeNoCommentsRule = {
+    id: 'planu-clean-code-no-comments',
+    name: 'Planu Clean Code — No Comments',
+    description: 'Prohibits narrative comments and rationale blocks, requiring named helpers or constants instead.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-clean-code-no-comments.js.map

package/dist/engine/universal-rules/rules/planu-debate-review.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuDebateReviewRule: UniversalRule;
+//# sourceMappingURL=planu-debate-review.d.ts.map

package/dist/engine/universal-rules/rules/planu-debate-review.js

@@ -0,0 +1,38 @@
+function buildBody() {
+    return `# Planu Debate Review
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+This rule assumes \`planu-approval-gates\` (reviewer independence, self-approval prohibitions) and \`planu-sdd-model-routing\` (arbitration) and restates neither.
+
+## Reviewer Plurality And Provider Diversity
+
+Every spec and every implementation is reviewed by two independent reviewers from DIFFERENT providers, in ONE parallel round.
+
+Prohibited: running a single reviewer, or running two reviewers from the same provider, and calling the result a debate round.
+
+Replacement action: launch both reviewers in the same message so they run concurrently, and pick two different providers (for example one Claude-family model and one external model).
+
+## One Parallel Round, No Serial Confirmation Loops
+
+Prohibited: re-launching a reviewer for pass 2, pass 3, or a "confirm the fix" loop after the first round already produced verdicts.
+
+Replacement action: cross the two verdicts once — coincident findings apply directly, divergent findings are arbitrated against the source code — then close the round. Re-open a reviewer only for a specific disagreement the arbiter cannot resolve by reading the code directly.
+
+## Degradation Ladder
+
+Prohibited: silently reviewing with only one provider when a second is unavailable and presenting it as a debate round.
+
+Replacement action: when only one provider is available, run two isolated sessions of the same model instead of one, so two independent verdicts still exist before arbitration.
+`;
+}
+export const planuDebateReviewRule = {
+    id: 'planu-debate-review',
+    name: 'Planu Debate Review',
+    description: 'Requires two-provider parallel review rounds with no serial confirmation loops and a single-provider degradation ladder.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-debate-review.js.map

package/dist/engine/universal-rules/rules/planu-dogfood-bugs.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/planu-dogfood-bugs.ts — SPEC-779
-// Universal rule: Planu Dogfood Bugs (mandatory for all Planu-using projects)
 /** Shared markdown body (same for all hosts). */
 function buildBody() {
     return `# Planu Dogfood Bugs (MANDATORY — STRICT)

package/dist/engine/universal-rules/rules/planu-english-specs.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-english-specs.ts — Universal rule: specs are written in English
 function buildBody() {
     return `# Planu Artifacts Must Be Written in English
 

package/dist/engine/universal-rules/rules/planu-minimal-change.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/planu-minimal-change.ts
-// Universal rule: minimal-change implementation discipline.
 function buildBody() {
     return `# Planu Minimal Change
 

package/dist/engine/universal-rules/rules/planu-modes.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/planu-modes.ts — SPEC-779
-// Universal rule: Claude Code Mode Hints per spec phase (SPEC-494)
 function buildBody(host) {
     if (host === 'claude-code') {
         return `# Claude Code Mode Hints (MANDATORY — Planu SDD)

package/dist/engine/universal-rules/rules/planu-release-policy.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-release-policy.ts — Universal rule: release decision
 function buildBody() {
     return `# Planu Release Policy
 

package/dist/engine/universal-rules/rules/planu-revert-proof-tests.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuRevertProofTestsRule: UniversalRule;
+//# sourceMappingURL=planu-revert-proof-tests.d.ts.map

package/dist/engine/universal-rules/rules/planu-revert-proof-tests.js

@@ -0,0 +1,34 @@
+function buildBody() {
+    return `# Planu Revert-Proof Tests
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+A new test that never fails against the unfixed source proves nothing.
+
+## The Rule
+
+Prohibited: reporting a new test as passing evidence without ever having watched it fail. This includes an assertion that compares a value to itself, a mock that echoes back what it was given, and a negative assertion that holds vacuously regardless of the source under test.
+
+Replacement action: before reporting the test as evidence, revert only the source change it covers — invert the specific guard line in place, or run the test against the pre-change body read with \`git show <ref>:<path>\` — run the test, and observe it fail. Then restore the source and confirm the test passes again. Report the observed failure output, not just the final green run.
+
+Prohibited: using \`git stash\`, \`git checkout\` or \`git restore\` on a shared checkout to stage the revert. Stashes are a process-wide LIFO stack, so a concurrent agent can pop work that is not its own.
+
+A guard's regression test must fail against the unguarded variant specifically, not merely against an unrelated point in history such as HEAD.
+
+## Hard Blocks
+
+- Do not accept a test whose only run is against already-fixed source.
+- Do not accept an assertion that compares a value to itself.
+- Do not accept an assertion that cannot fail for any input.
+`;
+}
+export const planuRevertProofTestsRule = {
+    id: 'planu-revert-proof-tests',
+    name: 'Planu Revert-Proof Tests',
+    description: 'Requires new tests to be proven to fail against the unfixed source before being reported as evidence.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-revert-proof-tests.js.map

package/dist/engine/universal-rules/rules/planu-sdd-model-routing.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-sdd-model-routing.ts — Universal rule: model routing + context continuity
 function buildBody() {
     return `# Planu SDD Model Routing and Context Guarantee
 

package/dist/engine/universal-rules/rules/planu-workflow.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/planu-workflow.ts — SPEC-779
-// Universal rule: Planu Workflow (migrated from rules-generator.ts)
 function buildBody() {
     return `# Planu SDD Workflow (MANDATORY)
 

package/dist/engine/validator/validation-report-writer.js

@@ -39,7 +39,7 @@ export async function writeImplementationReviewReport(input) {
         return {
             written: true,
             path: artifact.path,
-            sha: artifact.sha,
+            sha: `sha256:${artifact.sha}`,
             reviewer,
             passed,
             gates: mergedGates,

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.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ReconcileSpecInput, ToolResult } from '../types/index.js';
+import { type ReconcileSpecInput, type ToolResult } from '../types/index.js';
 export declare function handleReconcileSpec(params: ReconcileSpecInput, server?: McpServer): Promise<ToolResult>;
 //# sourceMappingURL=reconcile-spec.d.ts.map