@planu/cli 4.10.12 → 4.11.1

package/dist/tools/render-spec-for-provider.js

@@ -86,9 +86,10 @@ export async function handleRenderSpecForProvider(params) {
         extras: { ...output.extras, warnings: loadedSpec.warnings },
         ...(provider === 'claude'
             ? {
-                model: loadedSpec.spec.model ?? 'sonnet',
-                modelHint: loadedSpec.spec.model ?? 'sonnet',
-                budget: loadedSpec.spec.budget ?? 2000,
+                ...(output.extras?.model !== undefined ? { model: output.extras.model } : {}),
+                ...(output.extras?.modelHint !== undefined ? { modelHint: output.extras.modelHint } : {}),
+                ...(output.extras?.modelTier !== undefined ? { modelTier: output.extras.modelTier } : {}),
+                ...(output.extras?.budget !== undefined ? { budget: output.extras.budget } : {}),
                 toolCallouts: output.extras?.toolCallouts ?? [],
             }
             : {}),

package/dist/tools/reverse-engineer/handler.js

@@ -1,15 +1,70 @@
 // tools/reverse-engineer/handler.ts — MCP tool handler for reverse_engineer
-import { readFile, stat, mkdir, writeFile } from 'node:fs/promises';
+import { readFile, stat, rm } from 'node:fs/promises';
 import { join, extname, basename, relative, resolve } from 'node:path';
 import { glob } from 'glob';
 import { specStore, knowledgeStore } from '../../storage/index.js';
 import { ti } from '../../i18n/index.js';
-import { inferDifficulty } from '../../engine/estimator.js';
+import { calculateEstimation, inferDifficulty } from '../../engine/estimator.js';
 import { CODE_EXTENSIONS, detectLanguageFromExtension, getFrameworkTerminology, detectTechDebt, IGNORE_PATTERNS, } from './analyzer.js';
 import { runDeepAnalysis, enrichSpecFromAnalysis, generateAnalysisSummary, } from '../../engine/reverse-engineer/index.js';
-import { generateLeanSpecContent } from '../../engine/spec-format/lean-spec-generator.js';
-import { generateLeanTechnicalContent } from '../../engine/spec-format/lean-technical-generator.js';
-import { buildUnifiedSpecContent } from '../../engine/spec-format/unified-spec-builder.js';
+import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
+import { serializeValueOnlySpecContent } from '../../engine/spec-format/value-only-spec-serializer.js';
+function buildReverseCriteria(analysis, analyzedFiles) {
+    const criteria = [
+        {
+            text: `The reverse-engineered baseline accounts for ${String(analyzedFiles)} analyzed source files and ${String(analysis.totalLines)} source lines.`,
+            done: false,
+        },
+    ];
+    if (analysis.layers.length > 0) {
+        criteria.push({
+            text: `The documented architecture includes the detected layers: ${analysis.layers.join(', ')}.`,
+            done: false,
+        });
+    }
+    if (analysis.dependencies.length > 0) {
+        criteria.push({
+            text: `The documented dependency boundary includes: ${analysis.dependencies.slice(0, 10).join(', ')}.`,
+            done: false,
+        });
+    }
+    return criteria;
+}
+function buildReverseTechnicalContent(analysis, targetPath, analyzedFiles) {
+    const lines = [
+        '### Analysis Evidence',
+        '',
+        `- Target: \`${targetPath}\``,
+        `- Dominant language: ${analysis.dominantLanguage}`,
+        `- Source lines analyzed: ${String(analysis.totalLines)}`,
+    ];
+    if (analysis.layers.length > 0) {
+        lines.push(`- Detected layers: ${analysis.layers.join(', ')}`);
+    }
+    if (analysis.patterns.length > 0) {
+        lines.push(`- Detected patterns: ${analysis.patterns.join(', ')}`);
+    }
+    if (analyzedFiles.length > 0) {
+        lines.push('', '### Analyzed Files', '');
+        lines.push(...analyzedFiles.slice(0, 20).map((file) => `- \`${file}\``));
+    }
+    return lines.join('\n');
+}
+async function persistReverseEngineeredSpec(projectId, spec, specDir, content) {
+    await atomicWriteFile(spec.specPath, content);
+    try {
+        await specStore.createSpec(projectId, spec);
+    }
+    catch (storeError) {
+        try {
+            await rm(specDir, { recursive: true, force: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([storeError, cleanupError], `Failed to register ${spec.id} and remove its unregistered spec directory`, { cause: cleanupError });
+        }
+        throw storeError;
+    }
+}
 async function analyzeCodeStructure(files, targetPath, projectPath, isDir, depth) {
     const interfaces = [];
     const dependencies = [];
@@ -149,7 +204,7 @@ export async function handleReverseEngineer(args) {
     const difficulty = inferDifficulty(specType, scope);
     // 6. Build spec
     const specId = `SPEC-RE-${Date.now().toString(36).toUpperCase()}`;
-    const slug = dirName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    const slug = dirName.toLowerCase().replace(/[^a-z0-9]+/g, '-') || 'reverse-engineered';
     const now = new Date().toISOString();
     const spec = {
         id: specId,
@@ -165,18 +220,7 @@ export async function handleReverseEngineer(args) {
         updatedAt: now,
         specPath: '',
         technicalPath: '',
-        estimation: {
-            devHours: 0,
-            reviewHours: 0,
-            recommendedModel: 'sonnet',
-            tokensOpus: 0,
-            tokensSonnet: 0,
-            apiCostUsd: 0,
-            hourlyRate: 0,
-            humanCostUsd: 0,
-            totalCostUsd: 0,
-            tokenOptimization: { mode: 'local', reasoning: '', estimatedTokens: 0, savings: '' },
-        },
+        estimation: calculateEstimation(specType, scope, difficulty),
         actuals: null,
         target: ca.layers.includes('presentation')
             ? 'frontend'
@@ -186,7 +230,11 @@ export async function handleReverseEngineer(args) {
         tags: [...ca.patterns],
         dependencies: [],
         blockedBy: [],
-        gitBranch: '',
+        gitBranch: `${specType === 'refactor' ? 'refactor' : 'feat'}/${specId.toLowerCase()}-${slug}`,
+        generation: {
+            method: 'deterministic',
+            generatedAt: now,
+        },
         impactAnalysis: {
             affectedModules: ca.layers,
             affectedFiles: files.slice(0, 50),
@@ -207,28 +255,6 @@ export async function handleReverseEngineer(args) {
     const technicalFilePath = specFilePath;
     spec.specPath = specFilePath;
     spec.technicalPath = technicalFilePath;
-    try {
-        await mkdir(specDir, { recursive: true });
-        const leanSpec = generateLeanSpecContent({
-            spec,
-            description: `Reverse-engineered from ${targetPath}. ${String(files.length)} files analyzed.`,
-            estimation: spec.estimation,
-        });
-        const filesToModify = files.slice(0, 20).map((f) => ({
-            path: relative(projectPath, f),
-            status: 'pending',
-        }));
-        const leanTech = generateLeanTechnicalContent({
-            specId,
-            filesToModify,
-        });
-        // SPEC-709: write unified spec.md (technical content embedded as `## Technical` section)
-        const unified = buildUnifiedSpecContent(leanSpec, leanTech);
-        await writeFile(specFilePath, unified, 'utf-8');
-    }
-    catch {
-        // Best-effort — file write failure shouldn't block the tool
-    }
     // 7. Run deep-v2 analysis and enrich spec
     let deepV2Result = null;
     let deepV2Summary = null;
@@ -242,8 +268,15 @@ export async function handleReverseEngineer(args) {
         spec.tags = [...new Set([...spec.tags, ...enrichment.tags])];
         deepV2Summary = generateAnalysisSummary(deepV2Result);
     }
-    // 8. Save spec
-    await specStore.createSpec(projectId, spec);
+    // 8. Persist the document and store record as one observable operation.
+    const analyzedFiles = files.map((file) => isDir ? relative(projectPath, join(targetPath, file)) : relative(projectPath, targetPath));
+    const specContent = serializeValueOnlySpecContent({
+        spec,
+        description: `Reverse-engineered from \`${targetPath}\` using ${String(ca.limit)} source files and ${String(ca.totalLines)} source lines.`,
+        criteria: buildReverseCriteria(ca, ca.limit),
+        technical: buildReverseTechnicalContent(ca, targetPath, analyzedFiles),
+    });
+    await persistReverseEngineeredSpec(projectId, spec, specDir, specContent);
     // 9. Build output
     const analysis = {
         filesAnalyzed: ca.limit,

package/dist/tools/spec-split-handler.js

@@ -4,7 +4,7 @@ import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
 import { dirname } from 'node:path';
 import { specStore } from '../storage/index.js';
 import { analyzeSpecSize, buildChildSpecs } from '../engine/spec-splitter.js';
-import { generateProgressContent } from '../engine/progress-writer.js';
+import { serializeValueOnlySpecContent } from '../engine/spec-format/value-only-spec-serializer.js';
 import { detectOverSpec } from '../engine/complexity-budget/index.js';
 // ---------------------------------------------------------------------------
 // analyze_spec_size
@@ -111,14 +111,14 @@ export async function handleSplitSpec(input) {
             isError: true,
         };
     }
+    const sourceSpec = await enrichSpecWithCriteria(spec);
     // Resolve proposals: use provided or auto-generate
     let proposals;
     if (proposedSplits && proposedSplits.length > 0) {
         proposals = proposedSplits;
     }
     else {
-        const specWithCriteria = await enrichSpecWithCriteria(spec);
-        const analysis = analyzeSpecSize(specWithCriteria);
+        const analysis = analyzeSpecSize(sourceSpec);
         proposals = analysis.suggestedSplits;
     }
     if (proposals.length === 0) {
@@ -143,14 +143,23 @@ export async function handleSplitSpec(input) {
         return `SPEC-${String(num).padStart(3, '0')}`;
     };
     // Build child specs
-    const childSpecs = buildChildSpecs(spec, proposals, nextIdFn);
+    const childSpecs = buildChildSpecs(sourceSpec, proposals, nextIdFn);
     const childIds = childSpecs.map((c) => c.id);
-    // Persist child specs and create their directories.
-    // Technical and Progress content are embedded in the unified spec.md
-    // (SPEC-1010 PR-C: stop writing legacy technical.md / progress.md files).
-    for (const child of childSpecs) {
+    const sourceCriteria = sourceSpec.reviewNotes ?? [];
+    // Persist child specs as one value-only document; no legacy sidecars are created.
+    for (const [index, child] of childSpecs.entries()) {
         await mkdir(dirname(child.specPath), { recursive: true });
-        const content = buildChildUnifiedContent(child, spec);
+        child.generation = {
+            method: 'deterministic',
+            generatedAt: child.createdAt,
+        };
+        const proposal = proposals[index];
+        const content = serializeValueOnlySpecContent({
+            spec: child,
+            description: buildChildDescription(child, spec, proposal),
+            criteria: buildChildCriteria(proposal, sourceCriteria),
+            technical: buildChildTechnicalContent(child, spec),
+        });
         await atomicWriteFile(child.specPath, content);
         // NOTE: child.technicalPath / child.progressPath remain populated in the
         // in-memory Spec object for type compatibility (PR-D will remove fields).
@@ -218,79 +227,31 @@ function extractAcFromContent(content) {
         .map((line) => line.replace(/^[-*]\s*\[[ x]\]\s*/i, '').trim())
         .filter((line) => line.length > 10);
 }
-/**
- * Build a unified spec.md for a child spec that includes ## Technical and
- * ## Progress sections inline (SPEC-1010 PR-C: no separate technical.md /
- * progress.md files are written).
- */
-function buildChildUnifiedContent(child, original) {
-    const specBody = buildChildSpecContent(child, original);
-    const technicalBody = buildChildTechnicalContent(child, original);
-    const progressBody = generateProgressContent(child);
-    // Strip any YAML frontmatter that technical/progress generators might emit
-    const stripFm = (s) => s.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
-    return [
-        specBody.trimEnd(),
-        '',
-        '## Technical',
-        '',
-        stripFm(technicalBody),
-        '',
-        '## Progress',
-        '',
-        stripFm(progressBody),
-        '',
-    ].join('\n');
-}
-/** Generate minimal spec.md content for a child spec */
-function buildChildSpecContent(child, original) {
-    const now = new Date().toISOString().split('T')[0] ?? '';
+function buildChildDescription(child, original, proposal) {
+    const description = proposal?.description.trim();
     return [
-        '---',
-        `id: ${child.id}`,
-        `title: "${child.title}"`,
-        `type: ${child.type}`,
-        `scope: ${child.scope}`,
-        `target: ${child.target}`,
-        `status: draft`,
-        `difficulty: ${String(child.difficulty)}`,
-        `risk: ${child.risk}`,
-        `tags: [${child.tags.map((t) => JSON.stringify(t)).join(', ')}]`,
-        `created: ${now}`,
-        '---',
-        '',
         `# ${child.id}: ${child.title}`,
         '',
         '## Description',
         '',
-        child.reviewNotes?.[0] ?? `Split from ${original.id}: ${original.title}`,
-        '',
-        '## Acceptance Criteria',
-        '',
-        '- [ ] Implementation matches spec requirements',
-        '- [ ] Tests written and passing',
-        '',
-        '## Out of Scope',
-        '',
-        `- Criteria addressed by sibling specs split from ${original.id}`,
-        '',
+        ...(description ? [description, ''] : []),
+        `Split from \`${original.id}\`: ${original.title}.`,
     ].join('\n');
 }
-/** Generate minimal technical.md content for a child spec */
+function buildChildCriteria(proposal, sourceCriteria) {
+    if (!proposal) {
+        return [];
+    }
+    return proposal.criteriaIndices
+        .map((index) => sourceCriteria[index])
+        .filter((criterion) => criterion !== undefined)
+        .map((text) => ({ text, done: false }));
+}
 function buildChildTechnicalContent(child, original) {
-    return [
-        `# ${child.id}: ${child.title} — Technical`,
-        '',
-        `## Parent Spec`,
-        '',
-        `Split from \`${original.id}\`: ${original.title}`,
-        '',
-        '## Estimation',
-        '',
-        `| Dev Hours | ${String(child.estimation.devHours)}h |`,
-        `|-----------|--------|`,
-        `| Review Hours | ${String(child.estimation.reviewHours)}h |`,
-        '',
-    ].join('\n');
+    const lines = ['### Parent Spec', '', `- \`${original.id}\`: ${original.title}`];
+    if (child.dependencies.length > 0) {
+        lines.push('', '### Dependencies', '', ...child.dependencies.map((id) => `- \`${id}\``));
+    }
+    return lines.join('\n');
 }
 //# sourceMappingURL=spec-split-handler.js.map

package/dist/types/conventions.d.ts

@@ -227,8 +227,17 @@ export interface ProviderModelListModels {
         name?: string;
     }[];
 }
+/** SPEC-644: Evidence describing which provider catalogs populated the cache. */
+export interface ModelMappingCacheProvenance {
+    source: 'provider-api';
+    verifiedProviders: string[];
+}
 /** SPEC-644: Cached model tier mapping with TTL metadata. */
 export interface ModelMappingCache {
+    /** Writer schema. Optional only so legacy caches remain readable and can be invalidated. */
+    version?: 1;
+    /** Provider-catalog evidence. Missing provenance identifies a legacy, non-routable cache. */
+    provenance?: ModelMappingCacheProvenance;
     /** Map of provider ID → tier mapping (haiku/sonnet/opus → model ID). */
     providers: Record<string, ModelTierMapping>;
     /** ISO timestamp of the last fetch. */

package/dist/types/core-bridge.d.ts

@@ -75,6 +75,71 @@ export interface VectorNode {
     id: string;
     vector: number[];
 }
+export interface ProjectGraphSourceFileRs {
+    path: string;
+    hash: string;
+    size: number;
+    mtime: number;
+}
+export interface TsRelationRs {
+    from: string;
+    to: string;
+    relation: string;
+    sourceFile: string;
+    confidence: string;
+    classification: string;
+}
+export interface GraphNodeInputRs {
+    id: string;
+}
+export interface GraphEdgeInputRs {
+    id: string;
+    from: string;
+    to: string;
+    relation: string;
+}
+export interface CompactGraphEdgesRs {
+    ids: string[];
+    from: string[];
+    to: string[];
+    relations: string[];
+}
+export interface ProjectGraphLimitValuesRs {
+    maxFiles: number;
+    maxFileBytes: number;
+    maxNodes: number;
+    maxEdges: number;
+    maxDepth: number;
+}
+export interface ProjectGraphLimitsPolicyRs {
+    operational: ProjectGraphLimitValuesRs;
+    hard: ProjectGraphLimitValuesRs;
+}
+export interface ResolvedProjectGraphLimitsRs extends ProjectGraphLimitValuesRs {
+    hardMaxFiles: number;
+    hardMaxFileBytes: number;
+    hardMaxNodes: number;
+    hardMaxEdges: number;
+    hardMaxDepth: number;
+}
+export interface AffectedNodeRs {
+    nodeId: string;
+    depth: number;
+    viaRelation: string;
+}
+export interface ShortestPathResultRs {
+    nodeIds: string[];
+    edgeIds: string[];
+}
+export interface CompactGraphSliceRs {
+    nodeIds: string[];
+    edgeIds: string[];
+}
+export interface ProjectGraphNeighborRs {
+    node: string;
+    edgeId: string;
+    relation: string;
+}
 export interface PlanuCore {
     hashProjectPath(projectPath: string): string;
     isSafeProjectId(projectId: string): boolean;
@@ -97,5 +162,12 @@ export interface PlanuCore {
     fastHmacSign(secret: string, data: string): string;
     fastHmacVerify(secret: string, data: string, signature: string): boolean;
     startProjectWatcher(rootPath: string, callback: (err: Error | null, event: string) => void): void;
+    scanProjectGraphSources?(rootPath: string, limits: ResolvedProjectGraphLimitsRs): ProjectGraphSourceFileRs[];
+    extractTsRelations?(rootPath: string, paths: string[], limits: ResolvedProjectGraphLimitsRs): TsRelationRs[];
+    queryAffectedNodes?(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): AffectedNodeRs[];
+    queryAffectedNodesCompact?(seed: string, edges: CompactGraphEdgesRs, relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): AffectedNodeRs[];
+    queryShortestPath?(from: string, to: string, edges: GraphEdgeInputRs[], relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): ShortestPathResultRs;
+    selectCompactGraphSlice?(seeds: string[], nodes: GraphNodeInputRs[], edges: GraphEdgeInputRs[], limits: ResolvedProjectGraphLimitsRs): CompactGraphSliceRs;
+    selectCompactGraphSliceCompact?(seeds: string[], nodeIds: string[], edges: CompactGraphEdgesRs, limits: ResolvedProjectGraphLimitsRs): CompactGraphSliceRs;
 }
 //# sourceMappingURL=core-bridge.d.ts.map

package/dist/types/next-spec.d.ts

@@ -8,7 +8,8 @@ export interface NextSpecResult {
 export interface Spec686WaveEntry {
     specId: string;
     title: string;
-    model: 'haiku' | 'sonnet' | 'opus';
+    /** Explicit legacy routing constraint; omitted when no provider evidence exists. */
+    model?: 'haiku' | 'sonnet' | 'opus';
     parallelSafe: boolean;
     dependsOn: string[];
 }

package/dist/types/project-knowledge-graph.d.ts

@@ -1,3 +1,4 @@
+import type { AffectedNodeRs, CompactGraphSliceRs, ProjectGraphSourceFileRs, ShortestPathResultRs, TsRelationRs } from './core-bridge.js';
 export type ProjectGraphNodeType = string;
 export type ProjectGraphEdgeType = string;
 export type ProjectGraphConfidence = 'high' | 'medium' | 'low';
@@ -23,6 +24,11 @@ export interface ProjectGraphPolicy {
         maxEdges: number;
         maxListItems: number;
     };
+    limits: {
+        operational: ProjectGraphLimits;
+        hard: ProjectGraphLimits;
+        evidence: string;
+    };
     redaction: {
         maxSnippetChars: number;
         redactPatterns: string[];
@@ -39,6 +45,13 @@ export interface ProjectGraphPolicy {
     };
     toolNamePatterns: string[];
 }
+export interface ProjectGraphLimits {
+    maxFiles: number;
+    maxNodes: number;
+    maxEdges: number;
+    maxDepth: number;
+    maxFileBytes: number;
+}
 export interface ProjectGraphEvidencePointer {
     path: string;
     selector?: string;
@@ -67,6 +80,7 @@ export interface ProjectGraphEdge {
 export interface ProjectKnowledgeGraph {
     version: 1;
     graphVersion: string;
+    generation: string;
     projectId: string;
     projectPath?: string;
     generatedAt: string;
@@ -88,6 +102,38 @@ export interface ProjectGraphSource {
     path: string;
     content: string;
     hash: string;
+    size?: number;
+    mtimeMs?: number;
+    contentLoaded?: boolean;
+}
+export interface ProjectGraphSourceCacheRecord {
+    sourceId: string;
+    path: string;
+    kind: string;
+    contentHash: string;
+    extractorVersion: string;
+    nativeCoreVersion: string;
+    size: number;
+    mtimeMs: number;
+}
+export interface ProjectGraphSourceFragment extends ProjectGraphExtractionResult {
+    version: 1;
+    sourceId: string;
+    kind: string;
+    contentHash: string;
+    extractorVersion: string;
+    nativeCoreVersion: string;
+}
+export interface ProjectGraphCacheEnvelope {
+    version: 2;
+    generation: string;
+    records: Record<string, ProjectGraphSourceCacheRecord>;
+    fragments: Record<string, ProjectGraphSourceFragment>;
+}
+export interface ProjectGraphCacheReadResult {
+    cache: ProjectGraphCacheEnvelope | null;
+    knownSourceIds: string[];
+    legacy: boolean;
 }
 export interface ProjectGraphExtractionResult {
     nodes: ProjectGraphNode[];
@@ -95,9 +141,11 @@ export interface ProjectGraphExtractionResult {
 }
 export interface ProjectGraphBuildResult {
     graph: ProjectKnowledgeGraph;
+    generation: string;
     graphPath: string;
     cachePath: string;
     reprocessedSources: string[];
+    removedSources: string[];
     skippedSources: string[];
     usedCache: boolean;
 }
@@ -124,6 +172,8 @@ export interface ProjectGraphSlice {
         risks: number;
         tools: number;
         releases: number;
+        symbols: number;
+        toolHandlers: number;
     };
     tokenSavings: {
         compactNodes: number;
@@ -146,4 +196,12 @@ export interface GraphCoverageReport {
     compactNodes: number;
     compactEdges: number;
 }
+export interface NativeProjectGraphRuntime {
+    nativeActive: boolean;
+    scanSources(projectPath: string, maxFiles?: number): ProjectGraphSourceFileRs[];
+    extractTypeScriptRelations(projectPath: string, paths?: string[], maxFiles?: number): TsRelationRs[];
+    affectedNodes(seed: string, edges: ProjectGraphEdge[], depth?: number, relationFilter?: string[]): AffectedNodeRs[];
+    shortestPath(from: string, to: string, edges: ProjectGraphEdge[], relationFilter?: string[]): ShortestPathResultRs;
+    compactSlice(seeds: string[], nodes: ProjectGraphNode[], edges: ProjectGraphEdge[], maxNodes?: number, maxEdges?: number): CompactGraphSliceRs;
+}
 //# sourceMappingURL=project-knowledge-graph.d.ts.map

package/dist/types/spec/core.d.ts

@@ -1,4 +1,5 @@
 import type { SpecStatus, Difficulty, RiskLevel, SpecType, SpecScope, SpecTarget, DiagramType, ToolResult } from '../common/index.js';
+import type { SpecGenerationProvenance } from '../spec-generator.js';
 import type { SpecFormatVersion, SpecHistoryEntry } from './versioning.js';
 import type { Estimation, Actuals, ImpactAnalysis } from '../estimation.js';
 import type { ConstitutionViolation } from '../project/core.js';
@@ -53,13 +54,15 @@ export interface Spec {
     outOfScope?: string[];
     /** SPEC-615: prior decisions linked to this spec by keyword relevance. */
     priorDecisions?: string[];
-    /** SPEC-630: model routing hint derived from difficulty. */
+    /** @deprecated Legacy read-only model hint. New specs resolve routing at execution time. */
     model?: 'haiku' | 'sonnet' | 'opus';
-    /** SPEC-630: token budget derived from devHours. */
+    /** @deprecated Legacy read-only token budget. New specs resolve budgets at execution time. */
     budget?: 800 | 2000 | 4000;
-    /** SPEC-766: Generator that produced the initial spec body. */
+    /** @deprecated Legacy read-only generator provenance. */
     generatedWithModel?: string;
-    /** SPEC-766: ISO timestamp for initial spec body generation. */
+    /** Value-only provenance for the component that generated the current body. */
+    generation?: SpecGenerationProvenance;
+    /** @deprecated Legacy read-only generation timestamp. Use generation.generatedAt. */
     generatedAt?: string;
     /** SPEC-766: Non-blocking quality warnings emitted by the generator. */
     qualityWarnings?: string[];

package/dist/types/spec-format.d.ts

@@ -37,7 +37,8 @@ export interface NormalizedAcceptanceCriterion {
 export interface LeanSpecInput {
     spec: Spec;
     description: string;
-    estimation: Estimation;
+    /** @deprecated Advisory estimation is ignored by the value-only spec serializer. */
+    estimation?: Estimation;
     /** SPEC-461 Phase 3: Extra criteria from autopilot pattern detection. */
     extraCriteria?: string[];
     /** SPEC-1074: Explicit criteria after grounding filters are applied. */

package/dist/types/spec-generator.d.ts

@@ -12,11 +12,17 @@ export interface SpecGenerationRequest {
         architecture?: string;
     };
 }
+export type SpecGenerationMethod = 'deterministic' | 'internal-model' | 'host';
+export interface SpecGenerationProvenance {
+    method: SpecGenerationMethod;
+    generatedAt: string;
+    host?: string;
+    modelId?: string;
+}
 export interface SpecGenerationResult {
     specBody: string;
     technicalSection: string;
-    generatedWithModel: string;
-    generatedAt: string;
+    generation: SpecGenerationProvenance;
     qualityWarnings: string[];
     fallbackReason?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.10.12",
+  "version": "4.11.1",
   "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",
@@ -34,14 +34,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.10.12",
-    "@planu/core-darwin-x64": "4.10.12",
-    "@planu/core-linux-arm64-gnu": "4.10.12",
-    "@planu/core-linux-arm64-musl": "4.10.12",
-    "@planu/core-linux-x64-gnu": "4.10.12",
-    "@planu/core-linux-x64-musl": "4.10.12",
-    "@planu/core-win32-arm64-msvc": "4.10.12",
-    "@planu/core-win32-x64-msvc": "4.10.12"
+    "@planu/core-darwin-arm64": "4.11.1",
+    "@planu/core-darwin-x64": "4.11.1",
+    "@planu/core-linux-arm64-gnu": "4.11.1",
+    "@planu/core-linux-arm64-musl": "4.11.1",
+    "@planu/core-linux-x64-gnu": "4.11.1",
+    "@planu/core-linux-x64-musl": "4.11.1",
+    "@planu/core-win32-arm64-msvc": "4.11.1",
+    "@planu/core-win32-x64-msvc": "4.11.1"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -70,6 +70,8 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --exclude 'tests/integration/**'",
     "test:integration": "vitest run tests/integration",
+    "native:project-graph:e2e": "PLANU_NATIVE_E2E=1 vitest run tests/integration/native-project-graph-e2e.test.ts",
+    "native:project-graph:benchmark": "node scripts/benchmark-native-performance.mjs --operation project_graph_query --samples 5 --project-path . --spec-id SPEC-1119 --json",
     "check": "pnpm typecheck && pnpm lint && pnpm format:check",
     "check:strict": "pnpm typecheck && pnpm lint && pnpm format:check && pnpm audit:deadcode && pnpm audit:circular && pnpm audit:types && pnpm audit:security && pnpm audit:licenses && pnpm audit:i18n",
     "check:deps:fresh": "bash scripts/check-dependency-freshness.sh",

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.10.12",
+  "version": "4.11.1",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {