@planu/cli 4.3.5 → 4.3.6

package/dist/engine/ai-cost-estimator/core.d.ts

@@ -1,7 +1,7 @@
 import type { AiCostEstimateResult, EstimateAiCostInput } from '../../types/index.js';
 /**
  * Estimates the AI cost for implementing a spec.
- * Reads the spec from planu/specs/ (or legacy docs/sdd/specs/), loads pricing from config JSON,
+ * Reads the canonical spec.md from planu/specs/, loads pricing from config JSON,
  * and returns a full AiCostEstimateResult with per-model breakdown.
  */
 export declare function estimateAiCost(input: EstimateAiCostInput): Promise<AiCostEstimateResult>;

package/dist/engine/ai-cost-estimator/core.js

@@ -34,13 +34,13 @@ function getComplexityLevel(acCount) {
 // ---------------------------------------------------------------------------
 /**
  * Estimates the AI cost for implementing a spec.
- * Reads the spec from planu/specs/ (or legacy docs/sdd/specs/), loads pricing from config JSON,
+ * Reads the canonical spec.md from planu/specs/, loads pricing from config JSON,
  * and returns a full AiCostEstimateResult with per-model breakdown.
  */
 export async function estimateAiCost(input) {
     const { specId, projectPath } = input;
     // 1. Load spec content
-    const { content: specContent } = await loadSpecContent(specId);
+    const { content: specContent } = await loadSpecContent(specId, projectPath);
     const acCount = countAcceptanceCriteria(specContent);
     // 2. Load pricing config
     const config = await loadPricingConfig();

package/dist/engine/ai-cost-estimator/spec-loader.d.ts

@@ -1,8 +1,8 @@
 /**
- * Reads spec content from a sdd/specs directory.
+ * Reads canonical spec content from planu/specs.
  * Tries to find the spec directory by matching specId prefix.
  */
-export declare function loadSpecContent(specId: string): Promise<{
+export declare function loadSpecContent(specId: string, projectPath?: string): Promise<{
     content: string;
     specDir: string;
 }>;

package/dist/engine/ai-cost-estimator/spec-loader.js

@@ -1,66 +1,37 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // engine/ai-cost-estimator/spec-loader.ts — Loads spec content and counts acceptance criteria.
 // Extracted from core.ts to keep file sizes within limits.
-import { readFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { stripFrontmatter } from '../frontmatter-parser.js';
 /**
- * Reads spec content from a sdd/specs directory.
+ * Reads canonical spec content from planu/specs.
  * Tries to find the spec directory by matching specId prefix.
  */
-export async function loadSpecContent(specId) {
-    // Try modern location first, fallback to legacy
-    let specsRoot = 'planu/specs';
+export async function loadSpecContent(specId, projectPath = process.cwd()) {
+    const specsRoot = join(projectPath, 'planu', 'specs');
+    let topEntries;
     try {
-        const { access: fsAccess } = await import('node:fs/promises');
-        await fsAccess(specsRoot);
-    }
-    catch {
-        specsRoot = 'docs/sdd/specs';
-    }
-    const { readdir } = await import('node:fs/promises');
-    let specDir = null;
-    try {
-        const topEntries = await readdir(specsRoot);
-        // Flat layout: planu/specs/SPEC-069-name/ (or legacy docs/sdd/specs/SPEC-069-name/)
-        const flatMatch = topEntries.find((e) => e.startsWith(specId));
-        if (flatMatch) {
-            specDir = join(specsRoot, flatMatch);
-        }
+        topEntries = await readdir(specsRoot);
     }
     catch {
         throw new Error(`Spec directory not found at "${specsRoot}". ` +
             'Make sure you are running from the project root.');
     }
-    if (!specDir) {
-        throw new Error(`Spec "${specId}" not found in "${specsRoot}". ` + 'Check that the spec directory exists.');
+    const flatMatch = topEntries.find((entry) => entry.startsWith(specId));
+    if (!flatMatch) {
+        throw new Error(`Spec "${specId}" not found in "${specsRoot}". Check that the spec directory exists.`);
     }
-    const parts = [];
-    // Try modern names first, fallback to legacy — only read one of each pair
-    for (const [modern, legacy] of [
-        ['spec.md', 'HU.md'],
-        ['technical.md', 'FICHA-TECNICA.md'],
-    ]) {
-        let found = false;
-        for (const filename of [modern, legacy]) {
-            if (found) {
-                break;
-            }
-            try {
-                const raw = await readFile(join(specDir, filename), 'utf-8');
-                parts.push(stripFrontmatter(raw));
-                found = true;
-            }
-            catch {
-                // File not present — try next
-            }
-        }
+    const specDir = join(specsRoot, flatMatch);
+    const specPath = join(specDir, 'spec.md');
+    try {
+        const raw = await readFile(specPath, 'utf-8');
+        return { content: stripFrontmatter(raw), specDir };
     }
-    if (parts.length === 0) {
-        throw new Error(`Spec "${specId}" has no spec files in "${specDir}". ` +
-            'Cannot estimate without spec content.');
+    catch {
+        throw new Error(`Spec "${specId}" has no canonical spec.md at "${specPath}". ` +
+            'Run Planu migration/strict cleanup before estimating cost.');
     }
-    return { content: parts.join('\n\n'), specDir };
 }
 /** Counts acceptance criteria (lines starting with "- [ ]" or "- [x]") in spec content. */
 export function countAcceptanceCriteria(specContent) {

package/dist/engine/ai-cost-estimator/token-estimator.d.ts

@@ -6,7 +6,7 @@ import type { TokenEstimate, AiModelPricingConfig } from '../../types/index.js';
 export declare function detectProjectLanguage(projectPath: string): Promise<string>;
 /**
  * Estimates input tokens for an AI agent session based on three components:
- * 1. Spec content (HU.md + FICHA-TECNICA.md)
+ * 1. Spec content (canonical spec.md)
  * 2. Codebase context (if projectPath is provided)
  * 3. MCP tool definitions overhead (fixed constant)
  */

package/dist/engine/ai-cost-estimator/token-estimator.js

@@ -119,7 +119,7 @@ function isSourceFile(filename) {
 // ---------------------------------------------------------------------------
 /**
  * Estimates input tokens for an AI agent session based on three components:
- * 1. Spec content (HU.md + FICHA-TECNICA.md)
+ * 1. Spec content (canonical spec.md)
  * 2. Codebase context (if projectPath is provided)
  * 3. MCP tool definitions overhead (fixed constant)
  */

package/dist/engine/context-intelligence/compression-guards.d.ts

@@ -0,0 +1,8 @@
+export declare function getSensitivePathRefusal(path: string): string | null;
+export declare function collectPreservedFragments(content: string): Map<string, string[]>;
+export declare function verifyPreservedFragments(original: string, candidate: string): {
+    ok: boolean;
+    checks: string[];
+};
+export declare function shouldBypassLeanMode(flow: string): boolean;
+//# sourceMappingURL=compression-guards.d.ts.map

package/dist/engine/context-intelligence/compression-guards.js

@@ -0,0 +1,74 @@
+import { basename } from 'node:path';
+const SENSITIVE_PATH_SEGMENTS = new Set([
+    '.ssh',
+    '.aws',
+    '.gnupg',
+    '.kube',
+    '.docker',
+    'secrets',
+    'credentials',
+]);
+const SENSITIVE_FILE_PATTERNS = [
+    /^\.env(?:\.|$)/i,
+    /^\.npmrc$/i,
+    /(?:secret|credential|password|token|private[-_]?key|api[-_]?key)/i,
+    /\.(?:p12|pfx|pem|key)$/i,
+];
+const PRESERVE_PATTERNS = [
+    { label: 'spec-id', pattern: /\bSPEC-\d+\b/g },
+    { label: 'acceptance-criteria', pattern: /^-\s*\[[ xX]\]\s+.+$/gm },
+    { label: 'fenced-code', pattern: /```[\s\S]*?```|~~~[\s\S]*?~~~/g },
+    { label: 'inline-code', pattern: /`[^`\n]+`/g },
+    { label: 'url', pattern: /\bhttps?:\/\/[^\s)]+/g },
+    { label: 'file-path', pattern: /\b[\w.-]+(?:\/[\w.-]+)+\.[A-Za-z0-9]+\b/g },
+    { label: 'command', pattern: /\b(?:pnpm|npm|bun|node|git|gh|npx|tsx|tsc)\s+[^\n]+/g },
+    { label: 'hash', pattern: /\b[a-f0-9]{32,64}\b/gi },
+    {
+        label: 'validation-failure',
+        pattern: /\b(?:error|failed|failure|blocked|validate|validation)\b[^\n]*/gi,
+    },
+    { label: 'approval-request', pattern: /\b(?:approve|approval|approved|forceApprove)\b[^\n]*/gi },
+    {
+        label: 'security-warning',
+        pattern: /\b(?:security|secret|credential|token|password|destructive)\b[^\n]*/gi,
+    },
+];
+export function getSensitivePathRefusal(path) {
+    const normalized = path.replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    if (segments.some((segment) => SENSITIVE_PATH_SEGMENTS.has(segment.toLowerCase()))) {
+        return `Refusing sensitive path segment in ${path}`;
+    }
+    const fileName = basename(normalized);
+    if (SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(fileName))) {
+        return `Refusing sensitive file name ${path}`;
+    }
+    return null;
+}
+export function collectPreservedFragments(content) {
+    const fragments = new Map();
+    for (const { label, pattern } of PRESERVE_PATTERNS) {
+        const matches = [...content.matchAll(pattern)].map((match) => match[0]);
+        if (matches.length > 0) {
+            fragments.set(label, [...new Set(matches)]);
+        }
+    }
+    return fragments;
+}
+export function verifyPreservedFragments(original, candidate) {
+    const fragments = collectPreservedFragments(original);
+    const checks = [];
+    for (const [label, values] of fragments.entries()) {
+        for (const value of values) {
+            if (!candidate.includes(value)) {
+                return { ok: false, checks: [`missing:${label}:${value.slice(0, 80)}`] };
+            }
+        }
+        checks.push(label);
+    }
+    return { ok: true, checks };
+}
+export function shouldBypassLeanMode(flow) {
+    return /\b(security|validation|validate|approval|approved|release|destructive|delete|rollback|force)\b/i.test(flow);
+}
+//# sourceMappingURL=compression-guards.js.map

package/dist/engine/context-intelligence/context-graph-provider.d.ts

@@ -0,0 +1,9 @@
+import type { ContextGraphInput, ContextGraphProvider, ContextImpactMap } from '../../types/context-intelligence.js';
+export declare class PlanuContextGraphProvider implements ContextGraphProvider {
+    buildImpactMap(input: ContextGraphInput): Promise<ContextImpactMap>;
+    private resolveCandidateFiles;
+    private readSpecReferencedPaths;
+    private mapFile;
+}
+export declare function createContextGraphProvider(): ContextGraphProvider;
+//# sourceMappingURL=context-graph-provider.d.ts.map

package/dist/engine/context-intelligence/context-graph-provider.js

@@ -0,0 +1,98 @@
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { glob } from 'glob';
+import { emptyImpactMap, estimateImpactBudget, mergeImpactMaps } from './impact-map.js';
+const SOURCE_EXTENSIONS = '{ts,tsx,js,jsx,mjs,cjs,py,go,rs,java,rb,cs}';
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+function extractPaths(text) {
+    const matches = text.match(/\b(?:src|tests|packages|lib)\/[\w./-]+\.[A-Za-z0-9]+\b/g) ?? [];
+    return [...new Set(matches.map(normalizePath))];
+}
+function extractImports(content) {
+    const imports = new Set();
+    const patterns = [
+        /from\s+['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[1]?.startsWith('.')) {
+                imports.add(match[1]);
+            }
+        }
+    }
+    return [...imports];
+}
+function extractSymbols(content, path) {
+    const symbols = [];
+    const lines = content.split('\n');
+    const pattern = /\b(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|const)\s+([A-Za-z_][\w]*)/;
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = pattern.exec(lines[index] ?? '');
+        if (match?.[1]) {
+            symbols.push({ name: match[1], path, line: index + 1, confidence: 0.75 });
+        }
+    }
+    return symbols;
+}
+export class PlanuContextGraphProvider {
+    async buildImpactMap(input) {
+        const candidates = await this.resolveCandidateFiles(input);
+        if (candidates.length === 0) {
+            return emptyImpactMap();
+        }
+        const maps = await Promise.all(candidates.map((path) => this.mapFile(input.projectPath, path)));
+        return mergeImpactMaps(maps, input.tokenBudget);
+    }
+    async resolveCandidateFiles(input) {
+        const fromChanged = (input.changedFiles ?? []).map(normalizePath);
+        const fromSpec = input.specId ? await this.readSpecReferencedPaths(input) : [];
+        const direct = [...new Set([...fromChanged, ...fromSpec])].filter(Boolean);
+        if (direct.length > 0) {
+            return direct.slice(0, estimateImpactBudget(input.tokenBudget) * 2);
+        }
+        const maxFiles = estimateImpactBudget(input.tokenBudget);
+        return (await glob(`**/*.${SOURCE_EXTENSIONS}`, {
+            cwd: input.projectPath,
+            nodir: true,
+            ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**', '**/coverage/**'],
+        }))
+            .map(normalizePath)
+            .slice(0, maxFiles);
+    }
+    async readSpecReferencedPaths(input) {
+        const specFiles = await glob(`planu/specs/${input.specId}-*/spec.md`, {
+            cwd: input.projectPath,
+            nodir: true,
+        });
+        const specPath = specFiles[0];
+        if (!specPath) {
+            return [];
+        }
+        const content = await readFile(join(input.projectPath, specPath), 'utf-8').catch(() => '');
+        return extractPaths(content);
+    }
+    async mapFile(projectPath, path) {
+        const normalized = normalizePath(path);
+        const absolute = join(projectPath, normalized);
+        const content = await readFile(absolute, 'utf-8').catch(() => '');
+        const imports = extractImports(content);
+        return {
+            files: [{ path: normalized, reason: 'direct-context-candidate', confidence: 0.9 }],
+            symbols: extractSymbols(content, normalized),
+            edges: imports.map((target) => ({
+                from: normalized,
+                to: normalizePath(relative(projectPath, join(absolute, '..', target))),
+                type: 'import',
+            })),
+            truncated: false,
+        };
+    }
+}
+export function createContextGraphProvider() {
+    return new PlanuContextGraphProvider();
+}
+//# sourceMappingURL=context-graph-provider.js.map

package/dist/engine/context-intelligence/eval-harness.d.ts

@@ -0,0 +1,8 @@
+import type { ContextEvalCase, ContextEvalMode, ContextEvalResult } from '../../types/context-intelligence.js';
+export declare function evaluateContextModes(cases: ContextEvalCase[]): ContextEvalResult[];
+export declare function summarizeContextEval(results: ContextEvalResult[]): {
+    cases: number;
+    averageSavingsVsBaselinePct: number;
+    bestModeCounts: Record<ContextEvalMode, number>;
+};
+//# sourceMappingURL=eval-harness.d.ts.map

package/dist/engine/context-intelligence/eval-harness.js

@@ -0,0 +1,45 @@
+function pctSaved(baseline, candidate) {
+    if (baseline <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.round(((baseline - candidate) / baseline) * 1000) / 10);
+}
+export function evaluateContextModes(cases) {
+    return cases.map((item) => {
+        const modes = {
+            baseline: item.baselineTokens,
+            'spec-guided': item.specGuidedTokens,
+            'graph-guided': item.graphGuidedTokens,
+            lean: item.leanTokens,
+            'graph+lean': item.graphLeanTokens,
+        };
+        const bestMode = Object.entries(modes).sort((a, b) => a[1] - b[1])[0]?.[0] ??
+            'baseline';
+        return {
+            id: item.id,
+            bestMode,
+            savingsVsBaselinePct: pctSaved(item.baselineTokens, modes[bestMode]),
+            modes,
+        };
+    });
+}
+export function summarizeContextEval(results) {
+    const bestModeCounts = {
+        baseline: 0,
+        'spec-guided': 0,
+        'graph-guided': 0,
+        lean: 0,
+        'graph+lean': 0,
+    };
+    let totalSavings = 0;
+    for (const result of results) {
+        bestModeCounts[result.bestMode] += 1;
+        totalSavings += result.savingsVsBaselinePct;
+    }
+    return {
+        cases: results.length,
+        averageSavingsVsBaselinePct: results.length === 0 ? 0 : Math.round((totalSavings / results.length) * 10) / 10,
+        bestModeCounts,
+    };
+}
+//# sourceMappingURL=eval-harness.js.map

package/dist/engine/context-intelligence/impact-map.d.ts

@@ -0,0 +1,6 @@
+import type { ContextImpactMap } from '../../types/context-intelligence.js';
+export declare function emptyImpactMap(): ContextImpactMap;
+export declare function clampConfidence(value: number): number;
+export declare function estimateImpactBudget(tokenBudget: number): number;
+export declare function mergeImpactMaps(maps: ContextImpactMap[], tokenBudget: number): ContextImpactMap;
+//# sourceMappingURL=impact-map.d.ts.map

package/dist/engine/context-intelligence/impact-map.js

@@ -0,0 +1,47 @@
+export function emptyImpactMap() {
+    return { files: [], symbols: [], edges: [], truncated: false };
+}
+export function clampConfidence(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function estimateImpactBudget(tokenBudget) {
+    if (tokenBudget <= 0) {
+        return 1;
+    }
+    return Math.max(1, Math.min(50, Math.floor(tokenBudget / 120)));
+}
+export function mergeImpactMaps(maps, tokenBudget) {
+    const maxFiles = estimateImpactBudget(tokenBudget);
+    const files = new Map();
+    const symbols = new Map();
+    const edges = new Map();
+    let sourceCount = 0;
+    for (const map of maps) {
+        for (const file of map.files) {
+            sourceCount += 1;
+            const existing = files.get(file.path);
+            if (!existing || existing.confidence < file.confidence) {
+                files.set(file.path, { ...file, confidence: clampConfidence(file.confidence) });
+            }
+        }
+        for (const symbol of map.symbols) {
+            symbols.set(`${symbol.path}:${symbol.name}:${String(symbol.line ?? '')}`, {
+                ...symbol,
+                confidence: clampConfidence(symbol.confidence),
+            });
+        }
+        for (const edge of map.edges) {
+            edges.set(`${edge.from}->${edge.to}:${edge.type}`, edge);
+        }
+    }
+    const rankedFiles = [...files.values()].sort((a, b) => b.confidence - a.confidence);
+    const selectedFiles = rankedFiles.slice(0, maxFiles);
+    const selectedPaths = new Set(selectedFiles.map((file) => file.path));
+    return {
+        files: selectedFiles,
+        symbols: [...symbols.values()].filter((symbol) => selectedPaths.has(symbol.path)),
+        edges: [...edges.values()].filter((edge) => selectedPaths.has(edge.from) || selectedPaths.has(edge.to)),
+        truncated: rankedFiles.length < sourceCount || rankedFiles.length > selectedFiles.length,
+    };
+}
+//# sourceMappingURL=impact-map.js.map

package/dist/engine/context-intelligence/index.d.ts

@@ -0,0 +1,7 @@
+export { PlanuContextGraphProvider, createContextGraphProvider } from './context-graph-provider.js';
+export { getSensitivePathRefusal, collectPreservedFragments, verifyPreservedFragments, shouldBypassLeanMode, } from './compression-guards.js';
+export { compressSafeContext } from './safe-context-compressor.js';
+export { evaluateContextModes, summarizeContextEval } from './eval-harness.js';
+export { emptyImpactMap, estimateImpactBudget, mergeImpactMaps } from './impact-map.js';
+export type { ContextEvalCase, ContextEvalMode, ContextEvalResult, ContextGraphInput, ContextGraphProvider, ContextImpactEdge, ContextImpactFile, ContextImpactMap, ContextImpactSymbol, SafeCompressionResult, SafeContextCompressionInput, } from '../../types/context-intelligence.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/context-intelligence/index.js

@@ -0,0 +1,6 @@
+export { PlanuContextGraphProvider, createContextGraphProvider } from './context-graph-provider.js';
+export { getSensitivePathRefusal, collectPreservedFragments, verifyPreservedFragments, shouldBypassLeanMode, } from './compression-guards.js';
+export { compressSafeContext } from './safe-context-compressor.js';
+export { evaluateContextModes, summarizeContextEval } from './eval-harness.js';
+export { emptyImpactMap, estimateImpactBudget, mergeImpactMaps } from './impact-map.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/context-intelligence/safe-context-compressor.d.ts

@@ -0,0 +1,3 @@
+import type { SafeCompressionResult, SafeContextCompressionInput } from '../../types/context-intelligence.js';
+export declare function compressSafeContext(input: SafeContextCompressionInput): SafeCompressionResult;
+//# sourceMappingURL=safe-context-compressor.d.ts.map

package/dist/engine/context-intelligence/safe-context-compressor.js

@@ -0,0 +1,75 @@
+import { Buffer } from 'node:buffer';
+import { getSensitivePathRefusal, verifyPreservedFragments, shouldBypassLeanMode, } from './compression-guards.js';
+const DEFAULT_MAX_BYTES = 200_000;
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf-8');
+}
+function compressParagraph(paragraph) {
+    if (paragraph.startsWith('```') ||
+        paragraph.startsWith('~~~') ||
+        paragraph.startsWith('- [') ||
+        /`[^`\n]+`|\bSPEC-\d+\b|\bhttps?:\/\//.test(paragraph)) {
+        return paragraph;
+    }
+    return paragraph
+        .split('\n')
+        .map((line) => line.replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .join(' ');
+}
+export function compressSafeContext(input) {
+    const originalBytes = byteLength(input.content);
+    if (input.sourcePath) {
+        const refusal = getSensitivePathRefusal(input.sourcePath);
+        if (refusal) {
+            return {
+                ok: false,
+                originalBytes,
+                compressedBytes: originalBytes,
+                refusedReason: refusal,
+                preservedChecks: [],
+            };
+        }
+    }
+    if (originalBytes > (input.maxBytes ?? DEFAULT_MAX_BYTES)) {
+        return {
+            ok: false,
+            originalBytes,
+            compressedBytes: originalBytes,
+            refusedReason: `Refusing content over ${String(input.maxBytes ?? DEFAULT_MAX_BYTES)} bytes`,
+            preservedChecks: [],
+        };
+    }
+    if (input.flow && shouldBypassLeanMode(input.flow)) {
+        return {
+            ok: true,
+            originalBytes,
+            compressedBytes: originalBytes,
+            preservedChecks: ['bypass-sensitive-flow'],
+            content: input.content,
+        };
+    }
+    const compressed = input.content
+        .split(/\n{2,}/)
+        .map((paragraph) => compressParagraph(paragraph.trim()))
+        .filter(Boolean)
+        .join('\n\n');
+    const preserved = verifyPreservedFragments(input.content, compressed);
+    if (!preserved.ok) {
+        return {
+            ok: false,
+            originalBytes,
+            compressedBytes: byteLength(compressed),
+            refusedReason: `Compression would drop preserved fragment: ${preserved.checks[0] ?? 'unknown'}`,
+            preservedChecks: preserved.checks,
+        };
+    }
+    return {
+        ok: true,
+        originalBytes,
+        compressedBytes: byteLength(compressed),
+        preservedChecks: preserved.checks,
+        content: compressed,
+    };
+}
+//# sourceMappingURL=safe-context-compressor.js.map

package/dist/engine/dashboard/data-loader.js

@@ -3,6 +3,7 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { computeDashboardMetrics, computeHealthScore } from './kanban-logic.js';
+import { extractSectionBody } from '../spec-format/read-technical-section.js';
 /** Root data directory for all project data */
 const DATA_DIR = join(process.cwd(), 'data');
 /** Safely read and parse a JSON file; returns null on any error */
@@ -190,11 +191,10 @@ export function computeHealthMetrics(project) {
 /** Read spec markdown files for the detail view */
 export async function loadSpecDetail(projectId, specId) {
     const specDir = join(DATA_DIR, 'projects', projectId, 'specs', specId);
-    const [hu, ficha, progress] = await Promise.all([
-        readTextFile(join(specDir, 'HU.md')),
-        readTextFile(join(specDir, 'FICHA-TECNICA.md')),
-        readTextFile(join(specDir, 'PROGRESS.md')),
-    ]);
+    const specMd = await readTextFile(join(specDir, 'spec.md'));
+    const hu = specMd;
+    const ficha = specMd !== null ? extractSectionBody(specMd, 'Technical') || null : null;
+    const progress = specMd !== null ? extractSectionBody(specMd, 'Progress') || null : null;
     return { hu, ficha, progress };
 }
 /** Extract code links (file references) from a technical markdown */
@@ -257,12 +257,10 @@ export function parseFrontmatter(content) {
 /** Load enhanced spec detail with code links and frontmatter */
 export async function loadSpecDetailEnhanced(projectId, specId) {
     const specDir = join(DATA_DIR, 'projects', projectId, 'specs', specId);
-    const [hu, ficha, progress, specMd] = await Promise.all([
-        readTextFile(join(specDir, 'HU.md')),
-        readTextFile(join(specDir, 'FICHA-TECNICA.md')),
-        readTextFile(join(specDir, 'PROGRESS.md')),
-        readTextFile(join(specDir, 'spec.md')),
-    ]);
+    const specMd = await readTextFile(join(specDir, 'spec.md'));
+    const hu = specMd;
+    const ficha = specMd !== null ? extractSectionBody(specMd, 'Technical') || null : null;
+    const progress = specMd !== null ? extractSectionBody(specMd, 'Progress') || null : null;
     const codeLinks = ficha ? extractCodeLinks(ficha) : [];
     const frontmatter = specMd ? parseFrontmatter(specMd) : {};
     return { hu, ficha, progress, codeLinks, frontmatter };

package/dist/engine/dashboard/templates-project.d.ts

@@ -3,7 +3,7 @@ import type { DashboardProjectSummary, DashboardUsageStats, ProjectHealthMetrics
 export declare function renderHomePage(projects: DashboardProjectSummary[], usage: DashboardUsageStats): string;
 /** Render the project detail page — spec cards + kanban board + health panel */
 export declare function renderProjectPage(project: DashboardProjectSummary, metrics: ProjectHealthMetrics, usage: DashboardUsageStats): string;
-/** Render the spec detail page — HU, FICHA, PROGRESS tabs */
+/** Render the spec detail page — canonical spec.md sections */
 export declare function renderSpecPage(projectId: string, projectName: string, specId: string, hu: string | null, ficha: string | null, progress: string | null): string;
 /** Render a 404 not found page */
 export declare function render404Page(path: string): string;

package/dist/engine/dashboard/templates-project.js

@@ -226,15 +226,17 @@ export function renderProjectPage(project, metrics, usage) {
   `;
     return renderLayout(project.name, body, getKanbanStyles(), getKanbanScript());
 }
-/** Render the spec detail page — HU, FICHA, PROGRESS tabs */
+/** Render the spec detail page — canonical spec.md sections */
 export function renderSpecPage(projectId, projectName, specId, hu, ficha, progress) {
-    const huHtml = hu !== null ? markdownToHtml(hu) : '<p style="color:var(--text-muted)">HU.md no encontrado</p>';
+    const huHtml = hu !== null
+        ? markdownToHtml(hu)
+        : '<p style="color:var(--text-muted)">spec.md no encontrado</p>';
     const fichaHtml = ficha !== null
         ? markdownToHtml(ficha)
-        : '<p style="color:var(--text-muted)">FICHA-TECNICA.md no encontrado</p>';
+        : '<p style="color:var(--text-muted)">## Technical no encontrado en spec.md</p>';
     const progressHtml = progress !== null
         ? markdownToHtml(progress)
-        : '<p style="color:var(--text-muted)">PROGRESS.md no encontrado</p>';
+        : '<p style="color:var(--text-muted)">## Progress no encontrado en spec.md</p>';
     const body = `
     <div class="breadcrumb">
       <a href="/">Inicio</a> &rsaquo;

package/dist/engine/docs-site-generator/index.js

@@ -7,6 +7,7 @@ import { renderSpecPage, renderSpecIndex } from './spec-renderer.js';
 import { renderToolsCatalog } from './tools-renderer.js';
 import { renderDiagramsPage } from './diagrams-renderer.js';
 import { stripFrontmatter } from '../frontmatter-parser.js';
+import { extractSectionBody } from '../spec-format/read-technical-section.js';
 export async function generateDocsSite(config) {
     const { projectPath, outputDir, title = 'Planu Documentation' } = config;
     const [specs, metrics] = await Promise.all([
@@ -33,7 +34,6 @@ export async function generateDocsSite(config) {
     });
     for (const spec of specs) {
         let specContent = '';
-        let techContent = '';
         try {
             const raw = await readFile(spec.specPath, 'utf-8');
             specContent = stripFrontmatter(raw);
@@ -41,16 +41,7 @@ export async function generateDocsSite(config) {
         catch {
             /* missing */
         }
-        try {
-            const techPath = spec.specPath
-                .replace(/spec\.md$/, 'technical.md')
-                .replace(/HU\.md$/, 'FICHA-TECNICA.md');
-            const rawTech = await readFile(techPath, 'utf-8');
-            techContent = stripFrontmatter(rawTech);
-        }
-        catch {
-            /* missing */
-        }
+        const techContent = extractSectionBody(specContent, 'Technical');
         pages.push({
             path: `specs/${spec.slug}.html`,
             title: spec.title,

package/dist/engine/drift-monitor.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { fastScanProjectMetadata, isNativeActive, fastDetectDriftParallel, } from './core-bridge.js';
+import { readSpecTechnicalSection } from './spec-format/read-technical-section.js';
 // ---------------------------------------------------------------------------
 // Config builder
 // ---------------------------------------------------------------------------
@@ -107,14 +108,14 @@ const TEMPORAL_DRIFT_DAYS = 30;
  * Note: score represents HEALTH (100 = no drift). Callers may invert if needed.
  */
 export async function computeDriftScore(projectPath, specId, spec, technicalPath, metadataMap) {
-    const resolvedTechnical = resolveTechnicalPath(projectPath, specId, technicalPath);
+    const resolvedSpec = resolveSpecPath(projectPath, specId, technicalPath);
     let content = '';
-    if (resolvedTechnical !== null) {
+    if (resolvedSpec !== null) {
         try {
-            content = await readFile(resolvedTechnical, 'utf8');
+            content = await readSpecTechnicalSection({ specPath: resolvedSpec });
         }
         catch {
-            // cannot read technical.md — treat all layers as fully healthy
+            // cannot read spec.md technical section — treat all layers as fully healthy
         }
     }
     const filePaths = extractFilePaths(content, projectPath);
@@ -311,13 +312,14 @@ async function computeAcCoverageScore(criteria, filePaths) {
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-/** Resolve the path to a spec's technical.md file. */
-function resolveTechnicalPath(projectPath, specId, technicalPath) {
-    /* v8 ignore next 3 */
+/** Resolve the path to a canonical spec.md file. */
+function resolveSpecPath(projectPath, specId, technicalPath) {
+    /* v8 ignore next 5 */
     if (technicalPath !== undefined && fs.existsSync(technicalPath)) {
-        return technicalPath;
+        const specPathFromLegacyHint = path.join(path.dirname(technicalPath), 'spec.md');
+        return fs.existsSync(specPathFromLegacyHint) ? specPathFromLegacyHint : null;
     }
-    // Convention: planu/specs/<specId>-<slug>/technical.md
+    // Convention: planu/specs/<specId>-<slug>/spec.md
     const specsDir = path.join(projectPath, 'planu', 'specs');
     if (!fs.existsSync(specsDir)) {
         return null;
@@ -334,10 +336,10 @@ function resolveTechnicalPath(projectPath, specId, technicalPath) {
     if (match === undefined) {
         return null;
     }
-    const candidate = path.join(specsDir, match, 'technical.md');
+    const candidate = path.join(specsDir, match, 'spec.md');
     return fs.existsSync(candidate) ? candidate : null;
 }
-/** Extract implementation file paths from technical.md content. */
+/** Extract implementation file paths from a spec's inline ## Technical content. */
 function extractFilePaths(content, projectPath) {
     const FILE_PATTERN = /\b([\w./-]+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|cs))\b/g;
     const found = new Set();

package/dist/engine/qa-gate.js

@@ -26,7 +26,12 @@ export function runQaGate(spec, projectPath) {
     const coverageThreshold = extractCoverageThreshold(spec);
     const checks = [];
     checks.push(runCheck('typecheck', 'pnpm', ['typecheck'], projectPath));
-    checks.push(runCheck('test-coverage', 'pnpm', ['test:coverage'], projectPath));
+    if (coverageThreshold === null) {
+        checks.push(runCheck('test', 'pnpm', ['test'], projectPath));
+    }
+    else {
+        checks.push(runCheck('test-coverage', 'pnpm', ['test:coverage'], projectPath));
+    }
     const passed = checks.every((c) => c.passed);
     return Promise.resolve({
         specId: spec.id,

package/dist/engine/readiness-checker.js

@@ -155,7 +155,7 @@ function scoreFilesIdentified(spec, fichaContent) {
     }
     else {
         points = 0;
-        warnings.push('No FICHA-TECNICA.md found — files to create/modify are not identified. Run create_spec_tech first.');
+        warnings.push('No inline ## Technical section found in spec.md — files to create/modify are not identified.');
     }
     return { points, blockers, warnings };
 }
@@ -180,7 +180,7 @@ function buildRecommendations(score, huPoints, criteriaPoints, filesPoints, deps
         recs.push('Add more acceptance criteria (aim for 5+ testable criteria)');
     }
     if (filesPoints < 20) {
-        recs.push('Generate FICHA-TECNICA.md with create_spec_tech to identify key files');
+        recs.push('Add an inline ## Technical section to spec.md with key files');
     }
     if (depsPoints < 30) {
         recs.push('Verify all spec dependencies are in "done" status');
@@ -360,7 +360,7 @@ export function checkReadinessInternal(body) {
     // Vague criteria detection (re-uses existing logic)
     const criteriaResult = scoreCriteria(criteriaLines.length > 0 ? criteriaLines : [], vagueWords);
     warnings.push(...criteriaResult.warnings);
-    // Technical files presence (proxy for technical.md — check src/ paths in body)
+    // Technical files presence (proxy for inline ## Technical — check src/ paths in body)
     const hasTechnicalFiles = /\bsrc\/[^\s]+\.[jt]s\b/.test(bodyContent);
     const technicalScore = hasTechnicalFiles ? 30 : 0;
     if (!hasTechnicalFiles && criteriaCount > 0) {

package/dist/engine/spec-conflict-graph.d.ts

@@ -2,7 +2,7 @@ import type { SpecConflictSafety, SpecConflictCheckResult, ConflictGraphEntry, S
 export type { SpecConflictSafety, SpecConflictCheckResult, ConflictGraphEntry, SpecConflictGraph };
 /**
  * SPEC-657: Update the conflict graph entry for a single spec.
- * Called whenever a spec's technical.md changes.
+ * Called whenever a spec's inline ## Technical section changes.
  */
 export declare function updateConflictGraphEntry(projectPath: string, specId: string): Promise<void>;
 /**

package/dist/engine/spec-conflict-graph.js

@@ -39,8 +39,7 @@ async function readTechnicalFiles(projectPath, specId) {
         return [];
     }
     const specPath = join(specsDir, folder, 'spec.md');
-    const technicalPath = join(specsDir, folder, 'technical.md');
-    const content = await readSpecTechnicalSection({ specPath, technicalPath });
+    const content = await readSpecTechnicalSection({ specPath });
     if (content.length === 0) {
         return [];
     }
@@ -62,7 +61,7 @@ async function saveGraph(projectPath, graph) {
 }
 /**
  * SPEC-657: Update the conflict graph entry for a single spec.
- * Called whenever a spec's technical.md changes.
+ * Called whenever a spec's inline ## Technical section changes.
  */
 export async function updateConflictGraphEntry(projectPath, specId) {
     const files = await readTechnicalFiles(projectPath, specId);

package/dist/engine/spec-format/read-technical-section.d.ts

@@ -2,14 +2,8 @@ import type { Spec } from '../../types/index.js';
 /**
  * Read the `## Technical` section body from a spec's unified `spec.md`.
  * Returns "" when the spec file is unreadable or the section is missing.
- *
- * The legacy `spec.technicalPath` is consulted as a transitional fallback:
- * if the spec.md does not yet contain a `## Technical` section but a
- * standalone `technical.md` still exists on disk (pre-migration data),
- * we read that file instead and strip its YAML frontmatter so callers
- * receive the body content uniformly.
  */
-export declare function readSpecTechnicalSection(spec: Pick<Spec, 'specPath' | 'technicalPath'>): Promise<string>;
+export declare function readSpecTechnicalSection(spec: Pick<Spec, 'specPath'>): Promise<string>;
 /**
  * Extract the body of a top-level (`## `) section from a markdown document.
  * Returns the content AFTER the heading line, up to the next top-level

package/dist/engine/spec-format/read-technical-section.js

@@ -1,35 +1,16 @@
 // engine/spec-format/read-technical-section.ts — SPEC-1010 PR-B
 //
 // SSR back-migration (SPEC-752, v2.4.0) folded `technical.md` into the
-// unified `spec.md` as a `## Technical` section. The reader call sites
-// that previously read the standalone `technical.md` file silently
-// degrade to "" today because the file never gets written. This helper
-// is the single source of truth for "give me the technical body for
-// this spec": it extracts the `## Technical` section from `spec.md`
-// and falls back to the legacy `technical.md` only when the unified
-// section is empty (transitional safety net for specs not yet auto-
-// migrated).
+// unified `spec.md` as a `## Technical` section. This helper is the
+// single source of truth for "give me the technical body for this spec":
+// it extracts only the canonical inline `## Technical` section.
 import { readFile } from 'node:fs/promises';
 /**
  * Read the `## Technical` section body from a spec's unified `spec.md`.
  * Returns "" when the spec file is unreadable or the section is missing.
- *
- * The legacy `spec.technicalPath` is consulted as a transitional fallback:
- * if the spec.md does not yet contain a `## Technical` section but a
- * standalone `technical.md` still exists on disk (pre-migration data),
- * we read that file instead and strip its YAML frontmatter so callers
- * receive the body content uniformly.
  */
 export async function readSpecTechnicalSection(spec) {
-    const fromUnified = await extractFromUnified(spec.specPath);
-    if (fromUnified.length > 0) {
-        return fromUnified;
-    }
-    if (!spec.technicalPath) {
-        return '';
-    }
-    const legacy = await readFile(spec.technicalPath, 'utf-8').catch(() => '');
-    return stripFrontmatter(legacy).trim();
+    return extractFromUnified(spec.specPath);
 }
 async function extractFromUnified(specPath) {
     const content = await readFile(specPath, 'utf-8').catch(() => '');
@@ -85,13 +66,6 @@ function maskFencedBlocks(body) {
         return block.replace(/[^\n]/g, ' ');
     });
 }
-/**
- * Strip a leading YAML frontmatter block (between `---` fences at the top
- * of the document). No-op if frontmatter is absent.
- */
-function stripFrontmatter(content) {
-    return content.replace(/^---\n[\s\S]*?\n---\n?/, '');
-}
 function escapeRegex(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/engine/spec-registry/scorer.d.ts

@@ -1,7 +1,7 @@
 import type { ScoreBreakdown } from '../../types/index.js';
 /**
  * Calculate a completeness score (0-100) for a spec directory.
- * Reads spec.md and technical.md, evaluates 6 quality categories.
+ * Reads canonical spec.md, evaluates 6 quality categories.
  */
 export declare function calculateCompletenessScore(specDir: string): Promise<{
     score: number;

package/dist/engine/spec-registry/scorer.js

@@ -81,7 +81,7 @@ function scoreKeyFiles(specContent, technicalContent) {
     /* v8 ignore next -- files header present but no file-like entries */
     return 0;
 }
-/** Score technical.md based on existence and length. */
+/** Score inline technical content based on existence and length. */
 function scoreTechnicalCompleteness(technicalContent) {
     if (!technicalContent) {
         return 0;
@@ -126,14 +126,13 @@ function scoreFrontmatter(specContent) {
 // ---------------------------------------------------------------------------
 /**
  * Calculate a completeness score (0-100) for a spec directory.
- * Reads spec.md and technical.md, evaluates 6 quality categories.
+ * Reads canonical spec.md, evaluates 6 quality categories.
  */
 export async function calculateCompletenessScore(specDir) {
     const specPath = join(specDir, 'spec.md');
-    const technicalPath = join(specDir, 'technical.md');
     const [specContent, technicalContent] = await Promise.all([
         readFileOrEmpty(specPath),
-        readSpecTechnicalSection({ specPath, technicalPath }),
+        readSpecTechnicalSection({ specPath }),
     ]);
     const breakdown = {
         acceptanceCriteria: scoreAcceptanceCriteria(specContent),

package/dist/engine/validator/extractors.js

@@ -17,8 +17,10 @@ export async function extractCriteria(spec) {
             const items = extractListItems(acSection);
             criteria.push(...items);
         }
-        // Also check for "Given/When/Then" patterns
-        const gwtMatches = huContent.matchAll(/(?:Given|Dado|When|Cuando|Then|Entonces)\s+(.+)/gi);
+        // Also check for explicit "Given/When/Then" patterns at line start.
+        // Keep this anchored so narrative text containing "when" is not treated
+        // as an acceptance criterion.
+        const gwtMatches = huContent.matchAll(/^\s*(?:[-*+]\s+|\d+[.)]\s+)?(?:Given|Dado|When|Cuando|Then|Entonces)\s+(.+)$/gim);
         for (const match of gwtMatches) {
             /* v8 ignore next 3 -- defensive regex capture group guard */
             if (match[1]) {

package/dist/engine/validator.d.ts

@@ -7,7 +7,7 @@ export { buildHolisticReportFromFlatScore } from './validator/holistic-report.js
 export type { HolisticValidateReport } from '../types/analysis.js';
 /**
  * Validate a spec against the actual codebase.
- * Reads the spec files (HU.md, FICHA-TECNICA.md), extracts criteria,
+ * Reads the canonical spec.md, extracts criteria,
  * then checks the filesystem/code for compliance.
  *
  * SPEC-730: The returned ValidateResult is enriched with `holisticReport`

package/dist/engine/validator.js

@@ -6,6 +6,7 @@ import { extractCriteria, extractVerifyBlocks } from './validator/extractors.js'
 import { scanCodeForSpec, checkCriterion, classifyDriftSeverity, quickQualityCheck, } from './validator/analyzer.js';
 import { resolveApplicableDimensions } from './validator/scope-resolver.js';
 import { buildHolisticReportFromFlatScore } from './validator/holistic-report.js';
+import { readEvidenceArtifacts } from './evidence-gates/artifact-reader.js';
 // Re-export the full public API so external callers never need to know
 // about the sub-module layout.
 export { generateDoR, generateDoD } from './validator/dor-dod.js';
@@ -13,9 +14,43 @@ export { generateChecklist } from './validator/checklist.js';
 // SPEC-730: export scope-resolver and holistic-report for consumers
 export { resolveApplicableDimensions, normaliseScore } from './validator/scope-resolver.js';
 export { buildHolisticReportFromFlatScore } from './validator/holistic-report.js';
+function normalizeCriterionForEvidence(value) {
+    return value
+        .replace(/^-\s*\[[ xX]\]\s*/i, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function rowHasValidationEvidence(row) {
+    const hasEvidence = [
+        row.testEvidence?.length,
+        row.contractEvidence?.length,
+        row.manualEvidence?.trim(),
+        row.validationEvidence?.trim(),
+        row.reviewerEvidence?.trim(),
+    ].some((value) => Boolean(value));
+    return row.changedFiles.length > 0 && hasEvidence;
+}
+async function readTraceabilityEvidence(spec, projectPath) {
+    try {
+        const artifacts = await readEvidenceArtifacts({
+            spec,
+            projectId: spec.projectId,
+            specId: spec.id,
+            projectPath,
+        });
+        const rows = artifacts.traceabilityMatrix?.rows ?? [];
+        return new Map(rows
+            .filter(rowHasValidationEvidence)
+            .map((row) => [normalizeCriterionForEvidence(row.acceptanceCriterion), row]));
+    }
+    catch {
+        return new Map();
+    }
+}
 /**
  * Validate a spec against the actual codebase.
- * Reads the spec files (HU.md, FICHA-TECNICA.md), extracts criteria,
+ * Reads the canonical spec.md, extracts criteria,
  * then checks the filesystem/code for compliance.
  *
  * SPEC-730: The returned ValidateResult is enriched with `holisticReport`
@@ -45,6 +80,7 @@ export async function validateSpec(spec, projectPath) {
         };
     }
     const criteria = await extractCriteria(spec);
+    const traceabilityEvidence = await readTraceabilityEvidence(spec, projectPath);
     const codeState = await scanCodeForSpec(spec, projectPath);
     // Extract verify blocks from spec file (forgiving — empty map if file unreadable)
     let verifyBlockMap = new Map();
@@ -61,7 +97,9 @@ export async function validateSpec(spec, projectPath) {
     const qualityIssues = [];
     for (const criterion of criteria) {
         const verifyBlock = verifyBlockMap.get(criterion);
-        const found = await checkCriterion(criterion, projectPath, codeState, verifyBlock);
+        const evidenceRow = traceabilityEvidence.get(normalizeCriterionForEvidence(criterion));
+        const found = evidenceRow !== undefined ||
+            (await checkCriterion(criterion, projectPath, codeState, verifyBlock));
         if (found) {
             matches.push(criterion);
         }

package/dist/tools/update-status/dod-gates.js

@@ -525,7 +525,7 @@ export async function checkQaGate(specId, projectPath, force) {
             error: 'qa_gate_not_passed',
             code: 422,
             context: { specId, reason },
-            fixHint: 'Run typecheck + test:coverage, record the result, then retry update_status(done). Or use force:true to bypass.',
+            fixHint: 'Run the QA gate and record the result: typecheck + test by default, or typecheck + test:coverage when the spec declares a coverage threshold. Then retry update_status(done). Or use force:true to bypass.',
         },
     };
 }

package/dist/types/context-intelligence.d.ts

@@ -0,0 +1,61 @@
+export interface ContextGraphInput {
+    projectPath: string;
+    specId?: string;
+    changedFiles?: string[];
+    tokenBudget: number;
+}
+export interface ContextImpactFile {
+    path: string;
+    reason: string;
+    confidence: number;
+}
+export interface ContextImpactSymbol {
+    name: string;
+    path: string;
+    line?: number;
+    confidence: number;
+}
+export interface ContextImpactEdge {
+    from: string;
+    to: string;
+    type: 'import' | 'call' | 'test' | 'spec';
+}
+export interface ContextImpactMap {
+    files: ContextImpactFile[];
+    symbols: ContextImpactSymbol[];
+    edges: ContextImpactEdge[];
+    truncated: boolean;
+}
+export interface ContextGraphProvider {
+    buildImpactMap(input: ContextGraphInput): Promise<ContextImpactMap>;
+}
+export interface SafeCompressionResult {
+    ok: boolean;
+    originalBytes: number;
+    compressedBytes: number;
+    refusedReason?: string;
+    preservedChecks: string[];
+    content?: string;
+}
+export interface SafeContextCompressionInput {
+    content: string;
+    sourcePath?: string;
+    maxBytes?: number;
+    flow?: string;
+}
+export interface ContextEvalCase {
+    id: string;
+    baselineTokens: number;
+    specGuidedTokens: number;
+    graphGuidedTokens: number;
+    leanTokens: number;
+    graphLeanTokens: number;
+}
+export type ContextEvalMode = 'baseline' | 'spec-guided' | 'graph-guided' | 'lean' | 'graph+lean';
+export interface ContextEvalResult {
+    id: string;
+    bestMode: ContextEvalMode;
+    savingsVsBaselinePct: number;
+    modes: Record<ContextEvalMode, number>;
+}
+//# sourceMappingURL=context-intelligence.d.ts.map

package/dist/types/context-intelligence.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context-intelligence.js.map

package/dist/types/qa-gate.d.ts

@@ -1,4 +1,4 @@
-export type QaCheckName = 'typecheck' | 'test-coverage';
+export type QaCheckName = 'typecheck' | 'test' | 'test-coverage';
 export interface QaCheckResult {
     name: QaCheckName;
     passed: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.3.5",
+  "version": "4.3.6",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -32,14 +32,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.3.5",
-    "@planu/core-darwin-x64": "4.3.5",
-    "@planu/core-linux-arm64-gnu": "4.3.5",
-    "@planu/core-linux-arm64-musl": "4.3.5",
-    "@planu/core-linux-x64-gnu": "4.3.5",
-    "@planu/core-linux-x64-musl": "4.3.5",
-    "@planu/core-win32-arm64-msvc": "4.3.5",
-    "@planu/core-win32-x64-msvc": "4.3.5"
+    "@planu/core-darwin-arm64": "4.3.6",
+    "@planu/core-darwin-x64": "4.3.6",
+    "@planu/core-linux-arm64-gnu": "4.3.6",
+    "@planu/core-linux-arm64-musl": "4.3.6",
+    "@planu/core-linux-x64-gnu": "4.3.6",
+    "@planu/core-linux-x64-musl": "4.3.6",
+    "@planu/core-win32-arm64-msvc": "4.3.6",
+    "@planu/core-win32-x64-msvc": "4.3.6"
   },
   "engines": {
     "node": ">=24.0.0"