@planu/cli 4.3.4 → 4.3.6

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [4.3.5] - 2026-05-24
+
+### Features
+- feat(codegraph): expose Colby CodeGraph setup and status tools on the official MCP surface
+
+### Bug Fixes
+- fix(create-spec): render structured post-creation suggestions as readable next steps
+- fix(mcp): guard malformed human-facing tool output before it reaches clients
+
+
 ## [4.3.4] - 2026-05-22
 
 **Tarball SHA-256:** `e1ac042fd623c1421d7a0788fed14c369472489180ffe80eb8bce4d422d360d8`
@@ -3938,4 +3948,4 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · Versioning:
 - Mermaid diagram generation (architecture, sequence, state machine, ER, data flow)
 - Multi-language i18n (EN/ES/PT) for generated specs
 - Clean Architecture (hexagonal) — engine, tools, storage, types layers
-- 10,857 tests with ≥95% coverage
+- 10,857 tests with ≥95% coverage

package/dist/config/license-plans.json

@@ -42,12 +42,14 @@
     "check_update_status",
     "check_versions",
     "clarify_requirements",
+    "code_graph_status",
     "compliance_coverage_report",
     "compliance_gap_analysis",
     "compliance_gate_status",
     "compliance_score_report",
     "config_health",
     "configure_approval_policy",
+    "configure_code_graph",
     "configure_compliance",
     "configure_deploy_target",
     "configure_memory",

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/code-graph-configurator.d.ts

@@ -19,5 +19,5 @@ export declare function buildStatusResult(config: ClaudeJsonConfig): CodeGraphSt
 /**
  * Return the key used in .claude.json for a given action.
  */
-export declare function actionToProviderKey(action: 'setup-codegraph-context' | 'setup-pathfinder' | 'setup-axon'): string;
+export declare function actionToProviderKey(action: 'setup-colby-codegraph' | 'setup-codegraph-context' | 'setup-pathfinder' | 'setup-axon'): string;
 //# sourceMappingURL=code-graph-configurator.d.ts.map

package/dist/engine/code-graph-configurator.js

@@ -2,6 +2,12 @@
 // Provider definitions
 // ---------------------------------------------------------------------------
 const PROVIDER_DEFS = [
+    {
+        key: 'codegraph',
+        provider: 'colby-codegraph',
+        command: 'npx',
+        args: ['-y', '@colbymchenry/codegraph', 'serve', '--mcp'],
+    },
     {
         key: 'codegraphcontext',
         provider: 'codegraph-context',
@@ -71,6 +77,7 @@ export function buildStatusResult(config) {
  */
 export function actionToProviderKey(action) {
     const map = {
+        'setup-colby-codegraph': 'codegraph',
         'setup-codegraph-context': 'codegraphcontext',
         'setup-pathfinder': 'code-pathfinder',
         'setup-axon': 'axon',

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 };