@planu/cli 4.10.12 → 4.11.0

package/dist/engine/core-bridge.js

@@ -3,6 +3,7 @@ import * as nodeFs from 'node:fs';
 import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
 import { join, extname, basename, dirname, sep } from 'node:path';
 import { createHash, createHmac } from 'node:crypto';
+import { tsExtractTsRelations, tsQueryAffectedNodes, tsQueryShortestPath, resolveProjectGraphLimits, tsScanProjectGraphSources, tsSelectCompactGraphSlice, } from './core-bridge-project-graph.js';
 const require = createRequire(import.meta.url);
 function detectMusl() {
     if (process.platform !== 'linux') {
@@ -671,6 +672,60 @@ export function fastHmacVerify(secret, data, signature) {
     const n = getNative();
     return n ? n.fastHmacVerify(secret, data, signature) : tsHmacVerify(secret, data, signature);
 }
+export function fastScanProjectGraphSources(rootPath, policy, overrides = {}) {
+    const limits = resolveProjectGraphLimits(policy, overrides);
+    const n = getNative();
+    if (typeof n?.scanProjectGraphSources === 'function') {
+        return n.scanProjectGraphSources(rootPath, limits);
+    }
+    return tsScanProjectGraphSources(rootPath, limits);
+}
+export function fastExtractTsRelations(rootPath, paths, policy, overrides = {}) {
+    const limits = resolveProjectGraphLimits(policy, overrides);
+    const n = getNative();
+    if (typeof n?.extractTsRelations === 'function') {
+        return n.extractTsRelations(rootPath, paths, limits);
+    }
+    return tsExtractTsRelations(rootPath, paths, limits);
+}
+function compactEdges(edges) {
+    return {
+        ids: edges.map((edge) => edge.id),
+        from: edges.map((edge) => edge.from),
+        to: edges.map((edge) => edge.to),
+        relations: edges.map((edge) => edge.relation),
+    };
+}
+export function fastQueryAffectedNodes(seed, edges, relationFilter, policy, overrides = {}) {
+    const limits = resolveProjectGraphLimits(policy, overrides);
+    const n = getNative();
+    if (typeof n?.queryAffectedNodesCompact === 'function') {
+        return n.queryAffectedNodesCompact(seed, compactEdges(edges), relationFilter, limits);
+    }
+    if (typeof n?.queryAffectedNodes === 'function') {
+        return n.queryAffectedNodes(seed, edges, relationFilter, limits);
+    }
+    return tsQueryAffectedNodes(seed, edges, relationFilter, limits);
+}
+export function fastQueryShortestPath(from, to, edges, relationFilter, policy, overrides = {}) {
+    const limits = resolveProjectGraphLimits(policy, overrides);
+    const n = getNative();
+    if (typeof n?.queryShortestPath === 'function') {
+        return n.queryShortestPath(from, to, edges, relationFilter, limits);
+    }
+    return tsQueryShortestPath(from, to, edges, relationFilter, limits);
+}
+export function fastSelectCompactGraphSlice(seeds, nodes, edges, policy, overrides = {}) {
+    const limits = resolveProjectGraphLimits(policy, overrides);
+    const n = getNative();
+    if (typeof n?.selectCompactGraphSliceCompact === 'function') {
+        return n.selectCompactGraphSliceCompact(seeds, nodes.map((node) => node.id), compactEdges(edges), limits);
+    }
+    if (typeof n?.selectCompactGraphSlice === 'function') {
+        return n.selectCompactGraphSlice(seeds, nodes, edges, limits);
+    }
+    return tsSelectCompactGraphSlice(seeds, nodes, edges, limits);
+}
 export function startNativeWatcher(rootPath, callback) {
     const n = getNative();
     if (n && typeof n.startProjectWatcher === 'function') {

package/dist/engine/frontmatter-parser.js

@@ -13,37 +13,87 @@ export function parseFrontmatter(content) {
         return { metadata: {}, body: content };
     }
     const metadata = {};
-    for (const line of match[1].split('\n')) {
-        const kv = KV_LINE_RE.exec(line.trim());
+    const frontmatter = match[1];
+    for (const line of frontmatter.split('\n')) {
+        if (/^\s/.test(line)) {
+            continue;
+        }
+        const kv = KV_LINE_RE.exec(line);
         if (!kv?.[1] || kv[2] === undefined) {
             continue;
         }
         const key = kv[1];
         const val = kv[2].trim();
-        if (val.startsWith('[') && val.endsWith(']')) {
-            metadata[key] = val
-                .slice(1, -1)
-                .split(',')
-                .map((s) => s.trim().replace(/^["']|["']$/g, ''));
-        }
-        else if (val === 'null') {
-            metadata[key] = null;
-        }
-        else if (/^\d+$/.test(val)) {
-            metadata[key] = parseInt(val, 10);
-        }
-        else if (val === 'true') {
-            metadata[key] = true;
-        }
-        else if (val === 'false') {
-            metadata[key] = false;
-        }
-        else {
-            metadata[key] = val.replace(/^["']|["']$/g, '');
-        }
+        metadata[key] = parseScalar(val);
+    }
+    const generation = parseGenerationProvenance(frontmatter);
+    if (generation !== undefined) {
+        metadata.generation = generation;
+    }
+    const estimation = parseKnownMappingBlock(frontmatter, 'estimation');
+    if (estimation !== undefined) {
+        metadata.estimation = estimation;
     }
     return { metadata, body: match[2] };
 }
+function parseScalar(value) {
+    if (value.startsWith('[') && value.endsWith(']')) {
+        return value
+            .slice(1, -1)
+            .split(',')
+            .map((item) => item.trim().replace(/^["']|["']$/g, ''));
+    }
+    if (value === 'null') {
+        return null;
+    }
+    if (/^\d+$/.test(value)) {
+        return parseInt(value, 10);
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    return value.replace(/^["']|["']$/g, '');
+}
+function parseGenerationProvenance(frontmatter) {
+    const values = parseKnownMappingBlock(frontmatter, 'generation');
+    if (!values) {
+        return undefined;
+    }
+    const method = values.method;
+    const generatedAt = values.generatedAt;
+    if (!isGenerationMethod(method) || typeof generatedAt !== 'string' || !generatedAt) {
+        return undefined;
+    }
+    const host = typeof values.host === 'string' ? values.host : undefined;
+    const modelId = typeof values.modelId === 'string' ? values.modelId : undefined;
+    return {
+        method,
+        generatedAt,
+        ...(host ? { host } : {}),
+        ...(modelId && method !== 'deterministic' ? { modelId } : {}),
+    };
+}
+function parseKnownMappingBlock(frontmatter, key) {
+    const blockPattern = new RegExp(`^${key}:\\s*$\\n((?:^[ \\t]+.*(?:\\n|$))*)`, 'm');
+    const block = blockPattern.exec(frontmatter)?.[1];
+    if (!block) {
+        return undefined;
+    }
+    const values = {};
+    for (const line of block.split('\n')) {
+        const match = /^ {2}([A-Za-z][A-Za-z0-9_-]*):\s*(.+)$/.exec(line);
+        if (match?.[1] && match[2] !== undefined) {
+            values[match[1]] = parseScalar(match[2].trim());
+        }
+    }
+    return Object.keys(values).length > 0 ? values : undefined;
+}
+function isGenerationMethod(value) {
+    return value === 'deterministic' || value === 'internal-model' || value === 'host';
+}
 /**
  * Strip YAML frontmatter from markdown content, returning only the body.
  * If no frontmatter is present, returns the original content unchanged.

package/dist/engine/model-tier-resolver.d.ts

@@ -1,8 +1,9 @@
 import type { ModelMappingCache, ModelTier, ModelTierMapping } from '../types/index.js';
 export declare function detectAvailableProviders(): string[];
+/** @deprecated Static model defaults are intentionally empty; use provider catalog evidence. */
 export declare const STATIC_TIER_MAPPING: Record<string, ModelTierMapping>;
-/** Classify a model name into a canonical tier based on name patterns. */
-export declare function classifyModelTier(modelId: string): ModelTier;
+/** Classify a model name only when its observed ID carries a recognized tier signal. */
+export declare function classifyModelTier(modelId: string): ModelTier | undefined;
 /**
  * Build a ModelTierMapping from a list of model IDs.
  * Prefers the highest-capability model per tier (last one wins when sorted alphabetically desc).
@@ -10,8 +11,8 @@ export declare function classifyModelTier(modelId: string): ModelTier;
 export declare function buildTierMapping(modelIds: string[]): ModelTierMapping;
 /**
  * SPEC-644 AC1+AC4: Fetch model tier mapping from detected provider APIs.
- * Runs at init_project. Returns the built ModelMappingCache.
- * Silent failure — always returns a valid cache (uses static fallback).
+ * Runs at init_project. Returns only mappings observed from configured provider
+ * APIs. Silent failure leaves that provider absent from the cache.
  */
 export declare function fetchAndCacheModelMapping(projectPath: string): Promise<ModelMappingCache>;
 /**
@@ -21,8 +22,8 @@ export declare function fetchAndCacheModelMapping(projectPath: string): Promise<
  */
 export declare function triggerModelMappingRefresh(projectPath: string): void;
 /**
- * SPEC-644 AC5: Resolve the canonical tier to a provider-specific model ID.
- * Uses cached mapping if available; falls back to static Anthropic mapping.
+ * Resolve a canonical tier only when a fresh catalog for the exact provider
+ * contains that tier. The absence of evidence is represented by `undefined`.
  */
-export declare function resolveModelId(projectPath: string, tier: ModelTier, preferredProvider?: string): Promise<string>;
+export declare function resolveModelId(projectPath: string, tier: ModelTier, preferredProvider?: string): Promise<string | undefined>;
 //# sourceMappingURL=model-tier-resolver.d.ts.map

package/dist/engine/model-tier-resolver.js

@@ -1,11 +1,12 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // engine/model-tier-resolver.ts — SPEC-644: Dynamic model tier mapping from provider APIs
 // Fetches model lists from Anthropic/OpenAI/Google/Mistral and classifies into canonical tiers.
-// Caches in conventions.json with 7-day TTL. Never hardcodes model IDs.
+// Caches provider-reported model IDs in conventions.json with a 7-day TTL.
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 const TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 5_000;
+const MODEL_MAPPING_CACHE_VERSION = 1;
 // ---------------------------------------------------------------------------
 // Provider detection (AC4: env-var based)
 // ---------------------------------------------------------------------------
@@ -20,35 +21,12 @@ export function detectAvailableProviders() {
         .filter(([, envVar]) => !!process.env[envVar])
         .map(([provider]) => provider);
 }
-// ---------------------------------------------------------------------------
-// Static fallback mapping (used when API unreachable or no provider configured)
-// ---------------------------------------------------------------------------
-export const STATIC_TIER_MAPPING = {
-    anthropic: {
-        haiku: 'claude-haiku-4-5',
-        sonnet: 'claude-sonnet-4-5',
-        opus: 'claude-opus-4-5',
-    },
-    openai: {
-        haiku: 'gpt-4o-mini',
-        sonnet: 'gpt-4o',
-        opus: 'o1',
-    },
-    google: {
-        haiku: 'gemini-2.0-flash',
-        sonnet: 'gemini-1.5-pro',
-        opus: 'gemini-1.5-ultra',
-    },
-    mistral: {
-        haiku: 'mistral-small-latest',
-        sonnet: 'mistral-medium-latest',
-        opus: 'mistral-large-latest',
-    },
-};
+/** @deprecated Static model defaults are intentionally empty; use provider catalog evidence. */
+export const STATIC_TIER_MAPPING = {};
 // ---------------------------------------------------------------------------
 // Tier classification heuristics (name-based, no API response parsing)
 // ---------------------------------------------------------------------------
-/** Classify a model name into a canonical tier based on name patterns. */
+/** Classify a model name only when its observed ID carries a recognized tier signal. */
 export function classifyModelTier(modelId) {
     const id = modelId.toLowerCase();
     // opus / frontier tier keywords
@@ -59,8 +37,10 @@ export function classifyModelTier(modelId) {
     if (/haiku|\bmini\b|small|flash|\bnano\b|lite|quick/.test(id)) {
         return 'haiku';
     }
-    // default to balanced
-    return 'sonnet';
+    if (/sonnet|medium|\bpro\b|gpt-4o(?!-mini)/.test(id)) {
+        return 'sonnet';
+    }
+    return undefined;
 }
 /**
  * Build a ModelTierMapping from a list of model IDs.
@@ -69,7 +49,10 @@ export function classifyModelTier(modelId) {
 export function buildTierMapping(modelIds) {
     const byTier = { haiku: [], sonnet: [], opus: [] };
     for (const id of modelIds) {
-        byTier[classifyModelTier(id)].push(id);
+        const tier = classifyModelTier(id);
+        if (tier) {
+            byTier[tier].push(id);
+        }
     }
     // Pick one per tier — prefer the most recent (sort desc, take first)
     const pick = (ids) => ids.sort().reverse()[0] ?? '';
@@ -137,36 +120,23 @@ const PROVIDER_FETCHERS = {
     mistral: fetchMistralModels,
 };
 /**
- * Fetch model IDs for a single provider. Returns static fallback on any error.
- * SPEC-644 AC3: silent degradation when API unavailable.
+ * Fetch model IDs for a single provider. Missing/unreachable catalogs produce
+ * no routing evidence rather than a guessed model ID.
  */
 async function fetchProviderModels(provider, apiKey) {
     const fetcher = PROVIDER_FETCHERS[provider];
     if (!fetcher) {
-        return (STATIC_TIER_MAPPING[provider] ??
-            STATIC_TIER_MAPPING.anthropic ?? { haiku: '', sonnet: '', opus: '' });
+        return undefined;
     }
     try {
         const models = await withTimeout(fetcher(apiKey), FETCH_TIMEOUT_MS);
         if (!models || models.length === 0) {
-            return (STATIC_TIER_MAPPING[provider] ??
-                STATIC_TIER_MAPPING.anthropic ?? { haiku: '', sonnet: '', opus: '' });
+            return undefined;
         }
-        const mapping = buildTierMapping(models);
-        // Fill any empty tier from static fallback
-        const staticFallback = STATIC_TIER_MAPPING[provider];
-        if (staticFallback) {
-            return {
-                haiku: mapping.haiku || staticFallback.haiku,
-                sonnet: mapping.sonnet || staticFallback.sonnet,
-                opus: mapping.opus || staticFallback.opus,
-            };
-        }
-        return mapping;
+        return buildTierMapping(models);
     }
     catch {
-        return (STATIC_TIER_MAPPING[provider] ??
-            STATIC_TIER_MAPPING.anthropic ?? { haiku: '', sonnet: '', opus: '' });
+        return undefined;
     }
 }
 // ---------------------------------------------------------------------------
@@ -219,28 +189,48 @@ async function patchConventions(projectPath, modelMapping) {
 // TTL check
 // ---------------------------------------------------------------------------
 function isModelMappingStale(cache) {
-    const age = Date.now() - new Date(cache.resolvedAt).getTime();
+    const resolvedAt = new Date(cache.resolvedAt).getTime();
+    if (!Number.isFinite(resolvedAt)) {
+        return true;
+    }
+    const age = Date.now() - resolvedAt;
     return age > TTL_MS;
 }
+function isVerifiedModelMappingCache(cache) {
+    const providers = cache.providers;
+    if (cache.version !== MODEL_MAPPING_CACHE_VERSION ||
+        cache.provenance?.source !== 'provider-api' ||
+        !Array.isArray(cache.provenance.verifiedProviders) ||
+        typeof providers !== 'object' ||
+        providers === null) {
+        return false;
+    }
+    return cache.provenance.verifiedProviders.every((provider) => typeof provider === 'string' && Object.hasOwn(providers, provider));
+}
+function createVerifiedModelMappingCache(providers, resolvedAt) {
+    return {
+        version: MODEL_MAPPING_CACHE_VERSION,
+        provenance: {
+            source: 'provider-api',
+            verifiedProviders: Object.keys(providers).sort(),
+        },
+        providers,
+        resolvedAt,
+    };
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 /**
  * SPEC-644 AC1+AC4: Fetch model tier mapping from detected provider APIs.
- * Runs at init_project. Returns the built ModelMappingCache.
- * Silent failure — always returns a valid cache (uses static fallback).
+ * Runs at init_project. Returns only mappings observed from configured provider
+ * APIs. Silent failure leaves that provider absent from the cache.
  */
 export async function fetchAndCacheModelMapping(projectPath) {
     const providers = detectAvailableProviders();
     const resolvedAt = new Date().toISOString();
     if (providers.length === 0) {
-        // No providers configured — use Anthropic static fallback
-        const cache = {
-            providers: {
-                anthropic: STATIC_TIER_MAPPING.anthropic ?? { haiku: '', sonnet: '', opus: '' },
-            },
-            resolvedAt,
-        };
+        const cache = createVerifiedModelMappingCache({}, resolvedAt);
         await patchConventions(projectPath, cache).catch(() => {
             /* best-effort */
         });
@@ -249,9 +239,12 @@ export async function fetchAndCacheModelMapping(projectPath) {
     const providerMappings = {};
     await Promise.allSettled(providers.map(async (provider) => {
         const apiKey = process.env[PROVIDER_ENV_VARS[provider] ?? ''] ?? '';
-        providerMappings[provider] = await fetchProviderModels(provider, apiKey);
+        const mapping = await fetchProviderModels(provider, apiKey);
+        if (mapping) {
+            providerMappings[provider] = mapping;
+        }
     }));
-    const cache = { providers: providerMappings, resolvedAt };
+    const cache = createVerifiedModelMappingCache(providerMappings, resolvedAt);
     await patchConventions(projectPath, cache).catch(() => {
         /* best-effort */
     });
@@ -266,7 +259,11 @@ export function triggerModelMappingRefresh(projectPath) {
     void (async () => {
         try {
             const conventions = await readConventions(projectPath);
-            if (conventions?.modelMapping && !isModelMappingStale(conventions.modelMapping)) {
+            const configuredProviders = detectAvailableProviders();
+            if (conventions?.modelMapping &&
+                isVerifiedModelMappingCache(conventions.modelMapping) &&
+                !isModelMappingStale(conventions.modelMapping) &&
+                configuredProviders.every((provider) => conventions.modelMapping?.provenance?.verifiedProviders.includes(provider))) {
                 return;
             }
             await fetchAndCacheModelMapping(projectPath);
@@ -277,24 +274,24 @@ export function triggerModelMappingRefresh(projectPath) {
     })();
 }
 /**
- * SPEC-644 AC5: Resolve the canonical tier to a provider-specific model ID.
- * Uses cached mapping if available; falls back to static Anthropic mapping.
+ * Resolve a canonical tier only when a fresh catalog for the exact provider
+ * contains that tier. The absence of evidence is represented by `undefined`.
  */
 export async function resolveModelId(projectPath, tier, preferredProvider = 'anthropic') {
     try {
         const conventions = await readConventions(projectPath);
-        const providers = conventions?.modelMapping?.providers;
-        if (providers) {
-            const firstKey = Object.keys(providers)[0] ?? '';
-            const mapping = providers[preferredProvider] ?? providers[firstKey];
-            if (mapping?.[tier]) {
-                return mapping[tier];
-            }
+        const cache = conventions?.modelMapping;
+        if (!cache || !isVerifiedModelMappingCache(cache) || isModelMappingStale(cache)) {
+            return undefined;
+        }
+        if (!cache.provenance?.verifiedProviders.includes(preferredProvider)) {
+            return undefined;
         }
+        const modelId = cache.providers[preferredProvider]?.[tier];
+        return modelId === '' ? undefined : modelId;
     }
     catch {
-        /* fall through to static */
+        return undefined;
     }
-    return (STATIC_TIER_MAPPING[preferredProvider]?.[tier] ?? STATIC_TIER_MAPPING.anthropic?.[tier] ?? tier);
 }
 //# sourceMappingURL=model-tier-resolver.js.map

package/dist/engine/next-spec-resolver/orchestration-planner.d.ts

@@ -1,4 +1,5 @@
 import type { Spec } from '../../types/spec/core.js';
+import type { ModelTier } from '../../types/multi-agent.js';
 import type { Spec686Plan } from '../../types/next-spec.js';
 export type { Spec686WaveEntry, Spec686Plan } from '../../types/next-spec.js';
 export declare const MAX_WAVES = 10;
@@ -17,4 +18,8 @@ export declare const ORCHESTRATION_TRIGGER_THRESHOLD = 2;
  *   5. Increment planVersion from previous session.json value.
  */
 export declare function resolveOrchestrationPlan(projectPath: string, allSpecs: Spec[]): Promise<Spec686Plan | null>;
+/** Resolve current execution routing without requiring durable provider metadata. */
+export declare function resolveExecutionTier(spec: Partial<Pick<Spec, 'difficulty' | 'scope' | 'model'>>): ModelTier | undefined;
+/** Preserve only an explicit legacy budget; never invent a token limit from a tier. */
+export declare function resolveExecutionBudget(spec: Partial<Pick<Spec, 'difficulty' | 'scope' | 'model' | 'budget'>>): 800 | 2000 | 4000 | undefined;
 //# sourceMappingURL=orchestration-planner.d.ts.map

package/dist/engine/next-spec-resolver/orchestration-planner.js

@@ -109,10 +109,14 @@ function buildTopologicalLevels(unblocked, inDegree, dependents) {
     return levels;
 }
 function buildWaveEntry(spec, group, resolvedIds) {
+    // The wave planner has no provider capability/catalog context. Preserve an
+    // explicit legacy constraint, but do not manufacture a provider-specific tier.
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    const legacyModel = normalizeLegacyTier(spec.model);
     return {
         specId: spec.id,
         title: spec.title,
-        model: normalizeModel(spec.model),
+        ...(legacyModel ? { model: legacyModel } : {}),
         parallelSafe: group.length > 1,
         dependsOn: (Array.isArray(spec.dependencies) ? spec.dependencies : []).filter((d) => resolvedIds.has(d)),
     };
@@ -151,11 +155,36 @@ function buildSummary(approvedCount, waves) {
     });
     return `${String(approvedCount)} specs approved. Plan: ${waveParts.join(', ')}`;
 }
-function normalizeModel(model) {
-    if (model === 'haiku' || model === 'sonnet' || model === 'opus') {
-        return model;
+/** Resolve current execution routing without requiring durable provider metadata. */
+export function resolveExecutionTier(spec) {
+    const { difficulty, scope } = spec;
+    if (scope === 'cross-module' ||
+        scope === 'architectural' ||
+        difficulty === 4 ||
+        difficulty === 5) {
+        return 'opus';
     }
-    return 'sonnet';
+    if (scope === 'trivial' || difficulty === 1 || difficulty === 2) {
+        return 'haiku';
+    }
+    if (scope === 'feature' || difficulty === 3) {
+        return 'sonnet';
+    }
+    // Compatibility for legacy records that predate required difficulty/scope metadata.
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    return normalizeLegacyTier(spec.model);
+}
+/** Preserve only an explicit legacy budget; never invent a token limit from a tier. */
+export function resolveExecutionBudget(spec) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    const legacyBudget = spec.budget;
+    if (legacyBudget === 800 || legacyBudget === 2000 || legacyBudget === 4000) {
+        return legacyBudget;
+    }
+    return undefined;
+}
+function normalizeLegacyTier(value) {
+    return value === 'haiku' || value === 'sonnet' || value === 'opus' ? value : undefined;
 }
 async function readPlanVersion(projectPath) {
     try {