@planu/cli 5.1.1 → 5.3.0

package/dist/tools/init-project/handler.js

@@ -11,6 +11,7 @@ import { analyzeProject, checkProjectCompleteness } from '../../engine/analyzer.
 import { parseProjectQualityRules } from '../../engine/auditor-claude-md.js';
 import { detectMissingAreas, buildRequestPrompt } from '../../engine/context-merger.js';
 import { detectProjectPrivacyConfig, maybeGenerateEnvExample, buildBeginnerEnvGuide, } from './helpers.js';
+import { buildDefaultPrivacyConfig } from '../../engine/pii-detector.js';
 import { checkBundledVersionGap } from '../../engine/version-detector/bundled-version-checker.js';
 import { checkAndFixBundledVersion } from '../../engine/mcp-config/mcp-config-writer.js';
 import { buildInitProjectResult } from './result-builder.js';
@@ -86,6 +87,25 @@ function detectMultipleFrameworks(stack) {
     }
     return null;
 }
+/**
+ * SPEC-1343: Runs one independent, best-effort pipeline stage in isolation so it can be
+ * batched with `Promise.all` alongside other independent stages. A rejection never
+ * propagates to the caller — it resolves to `fallback` and is flagged via `failed`/`error`
+ * so init_project can still succeed and surface the failure in its result summary (AC2).
+ */
+async function runOptionalStage(name, fallback, task) {
+    try {
+        return { name, value: await task(), failed: false };
+    }
+    catch (err) {
+        return {
+            name,
+            value: fallback,
+            failed: true,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
 // eslint-disable-next-line max-lines-per-function
 export async function handleInitProject(params, server) {
     // eslint-disable-next-line max-lines-per-function, complexity
@@ -256,8 +276,14 @@ export async function handleInitProject(params, server) {
             const globalConfig = await globalStore.getGlobalConfig();
             const effectiveLocale = locale ?? globalConfig.defaultLocale;
             const effectiveExperience = experienceLevel ?? globalConfig.defaultExperienceLevel;
-            // Run full project analysis
-            const knowledge = await analyzeProject(projectPath, projectId, effectiveLocale, effectiveExperience);
+            // SPEC-1343: analyzeProject (full tree scan) and detectStackPatterns are both
+            // independent read-only scans of the same project tree — run them concurrently
+            // instead of back-to-back so wall time is ~1x the slower stage, not the sum (AC1).
+            const [knowledge, stackResult] = await Promise.all([
+                analyzeProject(projectPath, projectId, effectiveLocale, effectiveExperience),
+                detectStackPatterns(projectPath),
+            ]);
+            const { modernPatterns, dddConfig, agileDetection, orchestratorInfo, composeMultiplatform } = stackResult;
             if (approvedTechnologyContract !== null) {
                 knowledge.language = approvedTechnologyContract.language ?? knowledge.language;
                 knowledge.framework =
@@ -330,9 +356,6 @@ export async function handleInitProject(params, server) {
             if (hourlyRate !== undefined) {
                 await globalStore.updateGlobalConfig({ hourlyRate });
             }
-            // SPEC-033: Detect modern architecture patterns and stack info
-            const stackResult = await detectStackPatterns(projectPath);
-            const { modernPatterns, dddConfig, agileDetection, orchestratorInfo, composeMultiplatform } = stackResult;
             // SPEC-568: Smart tool group activation based on detected stack.
             // Runs before saveKnowledge so the snapshot can be persisted in one write.
             const groupProfileSnapshot = applyStackBasedGroupActivations(knowledge.stack);
@@ -352,16 +375,54 @@ export async function handleInitProject(params, server) {
             addProject(projectPath).catch(() => {
                 /* best-effort — never block init_project */
             });
+            // SPEC-1343: buildProjectConfig -> runSpecMigrations must stay ordered (config must be
+            // written before migrations run against it, and runSpecMigrations is invoked exactly
+            // once per run, AC3). That ordered chain is independent of the read-only discovery
+            // batch below, so both run concurrently (AC1/AC4).
             // SPEC-131: Build legal profile and generate planu.json / What's New
             // SPEC-313: Pass workMode to persist in planu.json
-            const configResult = await buildProjectConfig(projectPath, projectId, knowledge, workMode);
+            const configAndMigrations = (async () => {
+                const configResult = await buildProjectConfig(projectPath, projectId, knowledge, workMode);
+                // Run spec migrations (v0.30 -> v0.40, legacy paths, prefix normalization)
+                const migrations = await runSpecMigrations(projectPath, projectId, knowledge, {
+                    repositoryMigration: 'initialization',
+                });
+                return { configResult, migrations };
+            })();
+            // SPEC-1343: Independent, best-effort discovery stages (skills fetch, privacy
+            // detection, health check, convention scan) — none of these feed each other, so they
+            // batch into a single Promise.all with per-stage error isolation. A failing optional
+            // stage falls back to a safe default instead of failing init_project (AC2).
+            const [recommendedSkillsOutcome, privacyConfigOutcome, healthReportOutcome, conventionScanOutcome,] = await Promise.all([
+                runOptionalStage('fetchRecommendedSkills', [], () => fetchRecommendedSkills(knowledge)),
+                runOptionalStage('detectProjectPrivacyConfig', buildDefaultPrivacyConfig('GDPR', []), () => detectProjectPrivacyConfig(projectPath)),
+                runOptionalStage('runHealthCheckWithBaseline', null, async () => {
+                    const allSpecs = await listProjectSpecs(projectId);
+                    const specSummaries = allSpecs.map((s) => ({
+                        specId: s.id,
+                        status: s.status,
+                        gitBranch: s.gitBranch,
+                        updatedAt: s.updatedAt,
+                    }));
+                    return runHealthCheckWithBaseline(projectPath, projectId, knowledge, specSummaries);
+                }),
+                runOptionalStage('runConventionScanSafe', 'failed', () => runConventionScanSafe(projectPath)),
+            ]);
+            const recommendedSkills = recommendedSkillsOutcome.value;
+            const privacyConfig = privacyConfigOutcome.value;
+            const healthReport = healthReportOutcome.value;
+            const conventionScanStatus = conventionScanOutcome.value;
+            const optionalStageFailures = [
+                recommendedSkillsOutcome,
+                privacyConfigOutcome,
+                healthReportOutcome,
+                conventionScanOutcome,
+            ]
+                .filter((outcome) => outcome.failed)
+                .map((outcome) => `${outcome.name}: ${outcome.error ?? 'unknown error'}`);
+            const { configResult, migrations } = await configAndMigrations;
             const { planuConfigPath, planuConfigGenerated, whatsNew } = configResult;
-            // Run spec migrations (v0.30 -> v0.40, legacy paths, prefix normalization)
-            const { discoveryResult, migrationResult, folderMigrationResult, criticalMigrationFailures, nonCriticalWarnings: nonCriticalMigrationWarnings, migrationReportPath, changedPaths: migrationChangedPaths = [], } = await runSpecMigrations(projectPath, projectId, knowledge, {
-                repositoryMigration: 'initialization',
-            });
-            // Auto-fetch recommended skills based on detected stack
-            const recommendedSkills = await fetchRecommendedSkills(knowledge);
+            const { discoveryResult, migrationResult, folderMigrationResult, criticalMigrationFailures, nonCriticalWarnings: nonCriticalMigrationWarnings, migrationReportPath, changedPaths: migrationChangedPaths = [], } = migrations;
             // Auto-install or queue skills (opt-out via planu.json or input param, SPEC-185)
             const autoInstallFromConfig = autoInstallSkills ?? (await readAutoInstallFlag(planuConfigPath));
             const { skillsAutoInstalled, skillsPendingInstall, skillsSkipped } = await orchestrateSkillInstalls(recommendedSkills, projectPath, autoInstallFromConfig);
@@ -393,17 +454,6 @@ export async function handleInitProject(params, server) {
             const beginnerEnvGuide = effectiveExperience === 'beginner' && envVars.length > 0
                 ? buildBeginnerEnvGuide(envVars)
                 : null;
-            // SPEC-030: Detect legal framework and third-party data processors
-            const privacyConfig = await detectProjectPrivacyConfig(projectPath);
-            // SPEC-180: Project health check (best-effort)
-            const allSpecs = await listProjectSpecs(projectId);
-            const specSummaries = allSpecs.map((s) => ({
-                specId: s.id,
-                status: s.status,
-                gitBranch: s.gitBranch,
-                updatedAt: s.updatedAt,
-            }));
-            const healthReport = await runHealthCheckWithBaseline(projectPath, projectId, knowledge, specSummaries);
             // SPEC-491: Auto-cleanup planu/ — remove legacy HTMLs, migrate to lean spec format (fire-and-forget)
             import('../../engine/spec-migrator/planu-root-cleaner.js')
                 .then(({ cleanPlanuRoot }) => cleanPlanuRoot(join(projectPath, 'planu')))
@@ -414,8 +464,6 @@ export async function handleInitProject(params, server) {
             void withAudit(projectPath, 'init_project', 'regeneratePages', () => regeneratePages(projectPath, ['knowledge', 'risks', 'decisions']), (pages) => ({ pages: pages.length })).catch(() => {
                 /* best-effort — never fail init */
             });
-            // SPEC-228: Deep scan — detect conventions and write planu/conventions.json (best-effort)
-            const conventionScanStatus = await runConventionScanSafe(projectPath);
             // SPEC-645: Detect LLM client and cache in conventions.json (fire-and-forget)
             void import('../../engine/client-detection.js')
                 .then(({ detectAndCacheClient }) => detectAndCacheClient(projectPath))
@@ -480,6 +528,11 @@ export async function handleInitProject(params, server) {
             }
             // SPEC-469: Build autopilot summary from setup steps performed
             const collector = new AutopilotSummaryCollector();
+            // SPEC-1343 AC2: surface optional discovery-stage failures in the result summary
+            // instead of failing init_project.
+            for (const failure of optionalStageFailures) {
+                collector.pushFail('discovery-stage-failed', failure);
+            }
             if (knowledge.stack.length > 0) {
                 collector.pushOk('stack-detection', `Stack detected: ${knowledge.stack.join(', ')}`);
             }

package/dist/tools/learn.js

@@ -3,8 +3,8 @@
 // to pattern-store for future use by estimation, auditing, and spec generation.
 // SPEC-011: adds dispatchFeedbackEvent for feedback loop dispatch.
 import { patternStore, knowledgeStore } from '../storage/index.js';
+import { SemanticIndexStore } from '../storage/semantic-index-store.js';
 import { t, ti } from '../i18n/index.js';
-import { TFIDFEngine } from '../engine/vector-store/tfidf.js';
 import { cosineSimilarity } from '../engine/vector-store/similarity.js';
 import { compactJson } from './output-formatter.js';
 /** Default cosine similarity threshold for semantic deduplication. */
@@ -45,7 +45,7 @@ export async function handleLearn(args) {
         };
     }
     // 3. Semantic deduplication check (SPEC-075 AC-08)
-    const dedupWarning = checkSemanticDuplicate(existingPatterns, pattern, type);
+    const dedupWarning = await checkSemanticDuplicate(projectId, existingPatterns, pattern, type);
     // 4. Create new pattern (store even if semantically similar — just warn)
     const patternId = `PAT-${type.substring(0, 3).toUpperCase()}-${Date.now().toString(36).toUpperCase()}`;
     const learnedPattern = {
@@ -93,18 +93,20 @@ export async function handleLearn(args) {
 /**
  * SPEC-075 AC-08: Check existing patterns for semantic similarity using TF-IDF.
  * Returns a DedupWarning if a pattern with cosine similarity > threshold exists.
+ * SPEC-1345: the same-type corpus is loaded from a persisted, incrementally
+ * updated TF-IDF index instead of being rebuilt from scratch on every call.
  */
-function checkSemanticDuplicate(existingPatterns, newPattern, patternType, threshold = DEFAULT_DEDUP_THRESHOLD) {
+async function checkSemanticDuplicate(projectId, existingPatterns, newPattern, patternType, threshold = DEFAULT_DEDUP_THRESHOLD) {
     // Filter to same-type patterns only
     const sameType = existingPatterns.filter((p) => p.type === patternType);
     if (sameType.length === 0) {
         return undefined;
     }
-    // Build TF-IDF engine from existing patterns + the new one
-    const tfidf = new TFIDFEngine();
-    for (const p of sameType) {
-        tfidf.addDocument(p.pattern);
-    }
+    const indexStore = new SemanticIndexStore(projectId, `pattern-${patternType}`);
+    const tfidf = await indexStore.loadOrBuild(sameType.map((p) => ({ id: p.id, content: p.pattern })));
+    // Embed the candidate in-memory only (it isn't stored yet, so it never
+    // becomes part of the persisted corpus) so the IDF reflects it, matching
+    // the previous non-persisted behavior.
     tfidf.addDocument(newPattern);
     // Embed the new pattern
     const newEmbedding = tfidf.embed(newPattern);

package/dist/tools/registry/auth.js

@@ -22,8 +22,6 @@ export async function handleRegistryLogin(args) {
         const token = args.token;
         const user = args.user;
         const email = args.email;
-        const rawPlan = args.plan;
-        const plan = rawPlan ?? 'free';
         const expiresAt = args.expiresAt;
         if (!token || !user || !email) {
             return {
@@ -37,7 +35,6 @@ export async function handleRegistryLogin(args) {
             token: await storeSecretField('global/registry/pat', 'registry-pat', token),
             user,
             email,
-            plan,
             expiresAt: expiresAt ?? new Date(Date.now() + TOKEN_EXPIRY_MS).toISOString(),
         };
         const credPath = credentialsPath();
@@ -45,12 +42,7 @@ export async function handleRegistryLogin(args) {
         await chmod(resolveStorageLayout().secrets, 0o700);
         await writeFile(credPath, JSON.stringify(credentials, null, 2), 'utf-8');
         await chmod(credPath, 0o600);
-        return compactResult([
-            `Done: Logged in successfully`,
-            `**user**: ${user}`,
-            `**email**: ${email}`,
-            `**plan**: ${plan}`,
-        ].join('\n'));
+        return compactResult([`Done: Logged in successfully`, `**user**: ${user}`, `**email**: ${email}`].join('\n'));
     }
     catch (error) {
         /* v8 ignore start -- unexpected runtime errors */
@@ -100,7 +92,6 @@ export async function handleRegistryWhoami(_args) {
         const info = {
             user: cred.user,
             email: cred.email,
-            plan: cred.plan,
             expiresAt: cred.expiresAt,
             expired: isExpired,
             authenticated: !isExpired,
@@ -108,7 +99,6 @@ export async function handleRegistryWhoami(_args) {
         return compactResult([
             `**user**: ${info.user}`,
             `**email**: ${info.email}`,
-            `**plan**: ${info.plan}`,
             `**expiresAt**: ${info.expiresAt}`,
             `**expired**: ${String(info.expired)}`,
             `**authenticated**: ${String(info.authenticated)}`,

package/dist/tools/semantic-search-handler.js

@@ -1,7 +1,7 @@
 // tools/semantic-search-handler.ts — Handler for semantic_search tool.
 // SPEC-075 AC-07: Generates TF-IDF embedding of query, searches backend.
 import { getOrCreateBackend } from '../storage/vector-store/backend-factory.js';
-import { TFIDFEngine } from '../engine/vector-store/tfidf.js';
+import { SemanticIndexStore } from '../storage/semantic-index-store.js';
 /**
  * Handle a semantic_search request.
  * Embeds the query with TF-IDF, then searches the vector backend.
@@ -33,11 +33,10 @@ export async function handleSemanticSearch(args) {
             ],
         };
     }
-    // Build TF-IDF from existing corpus
-    const tfidf = new TFIDFEngine();
-    for (const doc of allDocs) {
-        tfidf.addDocument(doc.content);
-    }
+    // SPEC-1345: load the persisted TF-IDF index for this scope, incrementally
+    // reconciled against the current corpus (no full rebuild for unchanged docs).
+    const indexStore = new SemanticIndexStore(projectId, scope);
+    const tfidf = await indexStore.loadOrBuild(allDocs.map((doc) => ({ id: doc.id, content: doc.content })));
     // Embed the query
     const queryEmbedding = tfidf.embed(query);
     // Search

package/dist/tools/status-handler.js

@@ -79,18 +79,28 @@ function parseSpecNumber(id) {
     const match = /SPEC-(\d+)/i.exec(id);
     return match?.[1] !== undefined ? parseInt(match[1], 10) : 0;
 }
+function selectActiveSpec(specs) {
+    // Lifecycle-first ordering: implementing always outranks review, regardless of SPEC number.
+    // Within the same lifecycle status, the tie-break is descending SPEC number (most recent first).
+    for (const status of ['implementing', 'review']) {
+        const candidates = specs
+            .filter((s) => s.status === status)
+            .sort((a, b) => parseSpecNumber(b.id) - parseSpecNumber(a.id));
+        const candidate = candidates[0];
+        if (candidate !== undefined) {
+            return { id: candidate.id, title: candidate.title, status };
+        }
+    }
+    return null;
+}
 async function getStatusSpecSnapshot(projectId) {
     try {
         const specs = await listSpecs(projectId);
-        const inProgress = specs
-            .filter((s) => s.status === 'implementing' || s.status === 'review')
-            .sort((a, b) => parseSpecNumber(b.id) - parseSpecNumber(a.id));
+        const active = selectActiveSpec(specs.filter((s) => s.status === 'implementing' || s.status === 'review'));
         const approved = specs
             .filter((s) => s.status === 'approved')
             .sort((a, b) => parseSpecNumber(a.id) - parseSpecNumber(b.id));
-        const activeItem = inProgress[0];
         const nextItem = approved[0];
-        const active = activeItem !== undefined ? { id: activeItem.id, title: activeItem.title } : null;
         const next = nextItem !== undefined ? { id: nextItem.id, title: nextItem.title } : null;
         return { active, next, queueCount: approved.length };
     }
@@ -130,6 +140,9 @@ async function getSLABreaches(projectId) {
 // ---------------------------------------------------------------------------
 function buildSuggestion(snapshot) {
     if (snapshot.active !== null) {
+        if (snapshot.active.status === 'review') {
+            return `Resolve review for ${snapshot.active.id} — it is not yet implementing`;
+        }
         return `Continue ${snapshot.active.id} — it may be blocking others`;
     }
     if (snapshot.next !== null) {
@@ -145,7 +158,7 @@ function buildOutput(params) {
     const lines = ['Planu Status', '━━━━━━━━━━━━━━━'];
     if (snapshot.active !== null) {
         const title = snapshot.active.title.slice(0, 40);
-        lines.push(`ACTIVE    ${snapshot.active.id} ${title} (in-progress)`);
+        lines.push(`ACTIVE    ${snapshot.active.id} ${title} (${snapshot.active.status})`);
     }
     else {
         lines.push(`ACTIVE    (none)`);

package/dist/tools/validate.js

@@ -730,7 +730,9 @@ function buildValidateStructuredContent(args) {
     const minimalityBlockingFindings = args.minimalityReport?.findings.filter((finding) => finding.blocksDone) ?? [];
     const blockers = [
         ...args.result.missing.map((missing) => `missing: ${missing}`),
-        ...args.indeterminate.map((item) => `indeterminate: ${item}`),
+        // SPEC-1367 review finding 6: matches detectDrift's "needs-evidence"
+        // wording — display text only, the `indeterminate` field/enum is unchanged.
+        ...args.indeterminate.map((item) => `needs-evidence: ${item}`),
         ...args.qualityGateSummary.failures.map((failure) => `gate: ${failure}`),
         ...args.qualityIssues
             .filter((issue) => isBlockingQualitySeverity(issue.severity))
@@ -872,7 +874,9 @@ function buildCompactValidateText(args) {
     const MAX_FAILURES = 5;
     const labelledFailures = [
         ...missing.map((criterion) => ({ label: 'missing', criterion })),
-        ...indeterminate.map((criterion) => ({ label: 'indeterminate', criterion })),
+        // SPEC-1367 review finding 6: display label only — matches detectDrift's
+        // "needs-evidence" wording; the underlying `indeterminate` array is unchanged.
+        ...indeterminate.map((criterion) => ({ label: 'needs-evidence', criterion })),
     ];
     const shownFailures = labelledFailures.slice(0, MAX_FAILURES);
     const remainingCount = labelledFailures.length - shownFailures.length;

package/dist/tools/validation-loop-handler.js

@@ -34,22 +34,20 @@ export async function handleSpecHealthCheck(input) {
         content: [{ type: 'text', text: lines.join('\n') }],
     };
 }
-import { isNativeActive, fastScanSpecs } from '../engine/core-bridge.js';
+import { fastScanSpecsAsync } from '../engine/core-bridge.js';
 export async function handleHealthCheckAll(input) {
-    if (isNativeActive()) {
-        const briefs = fastScanSpecs(input.projectPath);
-        if (briefs) {
-            // Sort worst to best
-            briefs.sort((a, b) => a.healthScore - b.healthScore);
-            const lines = [
-                `Health check for all ${briefs.length} specs (sorted worst to best) [NATIVE]:`,
-                ``,
-                ...briefs.map((b) => `  ${b.id}: ${b.healthScore}/100`),
-            ];
-            return {
-                content: [{ type: 'text', text: lines.join('\n') }],
-            };
-        }
+    const { value: briefs, degradationNotice } = await fastScanSpecsAsync(input.projectPath);
+    if (briefs) {
+        // Sort worst to best
+        briefs.sort((a, b) => a.healthScore - b.healthScore);
+        const lines = [
+            `Health check for all ${briefs.length} specs (sorted worst to best) [NATIVE]:`,
+            ``,
+            ...briefs.map((b) => `  ${b.id}: ${b.healthScore}/100`),
+        ];
+        return {
+            content: [{ type: 'text', text: lines.join('\n') }],
+        };
     }
     const projectId = hashProjectPath(input.projectPath);
     const specs = await specStore.listSpecs(projectId);
@@ -66,6 +64,9 @@ export async function handleHealthCheckAll(input) {
         ``,
         ...scores.map((s) => `  ${s.specId}: ${s.total}/100`),
     ];
+    if (degradationNotice !== undefined) {
+        lines.push('', degradationNotice);
+    }
     return {
         content: [{ type: 'text', text: lines.join('\n') }],
     };

package/dist/types/analysis.d.ts

@@ -203,6 +203,8 @@ export interface ValidateResult {
 export type CriterionEvidenceStatus = 'proven' | 'missing' | 'indeterminate';
 export interface CriterionEvidenceResult {
     status: CriterionEvidenceStatus;
+    /** SPEC-1367: citation for how the status was grounded (e.g. probe runner output, matched literal). */
+    evidence?: string;
 }
 export interface CodeState {
     affectedFiles: string[];

package/dist/types/spec-language-translation.d.ts

@@ -0,0 +1,18 @@
+import type { InteractiveQuestion } from './interactive-question.js';
+/** Outcome of resolving the English-only gate for create_spec's title/description. */
+export type EnglishOnlyGateAction = 'ok' | 'ask' | 'translated' | 'reject';
+/** Result of `resolveEnglishOnlySpecGate`. Shape depends on `action`. */
+export interface EnglishOnlyGateResolution {
+    action: EnglishOnlyGateAction;
+    /** Set for 'ask' | 'translated' | 'reject' — the language detected in the original input. */
+    originalLanguage?: 'es' | 'pt';
+    /** Set for 'ask' — the translation clarification questions to relay via AskUserQuestion. */
+    questions?: InteractiveQuestion[];
+    /** Set for 'reject' — human-readable reason from the underlying language detector. */
+    reason?: string;
+    /** Set for 'translated' — the English title to use instead of the original. */
+    englishTitle?: string;
+    /** Set for 'translated' — the English description to use instead of the original. */
+    englishDescription?: string;
+}
+//# sourceMappingURL=spec-language-translation.d.ts.map

package/dist/types/spec-language-translation.js

@@ -0,0 +1,5 @@
+// types/spec-language-translation.ts — SPEC-1342: translation-request shapes for the
+// English-only spec gate. Lets create_spec offer an in-band translation clarification
+// round instead of hard-rejecting non-English title/description input.
+export {};
+//# sourceMappingURL=spec-language-translation.js.map

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

@@ -87,8 +87,6 @@ export interface RegistryCredentials {
     user: string;
     /** Email associated with the account. */
     email: string;
-    /** License plan level. */
-    plan: 'free' | 'pro';
     /** ISO 8601 token expiration timestamp. */
     expiresAt: string;
 }

package/dist/types/status.d.ts

@@ -10,10 +10,12 @@ export interface GitState {
 export interface SessionState {
     lastCiStatus?: string;
 }
+export type StatusActiveLifecycleStatus = 'implementing' | 'review';
 export interface StatusSpecSnapshot {
     active: {
         id: string;
         title: string;
+        status: StatusActiveLifecycleStatus;
     } | null;
     next: {
         id: string;

package/dist/types/validation-receipt.d.ts

@@ -28,6 +28,13 @@ export interface ValidationFreshnessLease {
     readonly epoch: string;
     readonly generation: number;
 }
+/**
+ * Classification of one raw filesystem watcher event feeding the freshness
+ * barrier: a direct relevant/ignored child path, a synthetic root event (the
+ * host OS reporting activity on the watched directory itself), or an
+ * ambiguous filename-less event that needs authoritative verification.
+ */
+export type ValidationWatchEventClassification = 'direct-relevant' | 'ignored' | 'synthetic' | 'ambiguous';
 export interface ValidationFreshnessWatchState {
     readonly epoch: string;
     readonly expiresAt: number;

package/dist/types/vector-store.d.ts

@@ -21,6 +21,24 @@ export interface TFIDFConfig {
     minDocFrequency: number;
     stopWords: Set<string>;
 }
+/** Serializable TF-IDF engine state (SPEC-1345: persisted index). */
+export interface TFIDFExportedState {
+    schemaVersion: number;
+    docFreq: [string, number][];
+    docCount: number;
+}
+/** A single corpus document as seen by the persisted semantic index (SPEC-1345). */
+export interface SemanticIndexDoc {
+    id: string;
+    content: string;
+}
+/** On-disk shape of a persisted TF-IDF index + hash manifest (SPEC-1345). */
+export interface PersistedSemanticIndex {
+    schemaVersion: number;
+    docHashes: Record<string, string>;
+    docTokens: Record<string, string[]>;
+    tfidfState: TFIDFExportedState;
+}
 /** Configuration for the HNSW index. */
 export interface HNSWConfig {
     M: number;

package/dist/types/workers.d.ts

@@ -8,7 +8,6 @@ export interface WorkerTrigger {
     /** Interval in ms for schedule triggers */
     intervalMs?: number;
 }
-export type WorkerTier = 'free' | 'pro';
 export interface WorkerDefinition {
     name: string;
     description: string;
@@ -19,7 +18,6 @@ export interface WorkerDefinition {
     /** Minimum ms between executions */
     cooldownMs: number;
     enabled: boolean;
-    tier: WorkerTier;
 }
 export type WorkerFindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'warning' | 'info';
 export interface WorkerFinding {
@@ -66,7 +64,6 @@ export interface WorkerOverride {
     enabled?: boolean;
     cooldownMs?: number;
     priority?: number;
-    tier?: WorkerTier;
 }
 export interface WorkerProjectConfig {
     overrides: Record<string, WorkerConfigOverride>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.1.1",
+  "version": "5.3.0",
   "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",
@@ -35,14 +35,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "5.1.1",
-    "@planu/core-darwin-x64": "5.1.1",
-    "@planu/core-linux-arm64-gnu": "5.1.1",
-    "@planu/core-linux-arm64-musl": "5.1.1",
-    "@planu/core-linux-x64-gnu": "5.1.1",
-    "@planu/core-linux-x64-musl": "5.1.1",
-    "@planu/core-win32-arm64-msvc": "5.1.1",
-    "@planu/core-win32-x64-msvc": "5.1.1"
+    "@planu/core-darwin-arm64": "5.3.0",
+    "@planu/core-darwin-x64": "5.3.0",
+    "@planu/core-linux-arm64-gnu": "5.3.0",
+    "@planu/core-linux-arm64-musl": "5.3.0",
+    "@planu/core-linux-x64-gnu": "5.3.0",
+    "@planu/core-linux-x64-musl": "5.3.0",
+    "@planu/core-win32-arm64-msvc": "5.3.0",
+    "@planu/core-win32-x64-msvc": "5.3.0"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -161,8 +161,8 @@
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.115.0",
-    "@hono/node-server": "2.0.11",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@hono/node-server": "2.1.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "glob": "^13.0.6",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
@@ -173,16 +173,16 @@
     "@commitlint/config-conventional": "^21.2.0",
     "@eslint/js": "^10.0.1",
     "@lhci/cli": "0.15.1",
-    "@napi-rs/cli": "3.7.4",
+    "@napi-rs/cli": "3.8.2",
     "@noble/hashes": "2.2.0",
-    "@playwright/test": "1.62.0",
+    "@playwright/test": "1.62.1",
     "@scure/base": "2.2.0",
     "@secretlint/secretlint-rule-no-homedir": "^13.0.4",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.4",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
-    "@supabase/supabase-js": "^2.110.8",
-    "@types/node": "^26.1.1",
+    "@supabase/supabase-js": "^2.112.0",
+    "@types/node": "^26.1.2",
     "@types/qrcode": "1.5.6",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitejs/plugin-vue": "^6.0.8",
@@ -196,17 +196,17 @@
     "husky": "^9.1.7",
     "javascript-obfuscator": "^5.5.0",
     "jiti": "2.7.0",
-    "knip": "^6.29.0",
-    "lint-staged": "^17.2.0",
+    "knip": "^6.31.0",
+    "lint-staged": "^17.3.0",
     "madge": "^8.0.0",
     "prettier": "^3.9.6",
     "qrcode": "1.5.4",
     "secretlint": "^13.0.4",
     "tsc-alias": "^1.9.1",
-    "type-coverage": "^2.29.7",
+    "type-coverage": "^2.30.1",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "typescript-eslint": "^8.65.0",
-    "vite": "^8.1.5",
+    "typescript-eslint": "^8.66.0",
+    "vite": "^8.2.0",
     "vitest": "^4.1.10",
     "vue": "^3.5.40"
   }