@planu/cli 5.4.0 → 5.5.0

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [5.5.0] - 2026-08-29
+
+### Features
+- feat(SPEC-1681): cache the prettier format gate with content strategy
+
+### Bug Fixes
+- fix(SPEC-1684): cap vitest workers at 6 in preflight related and full-suite runs
+- fix(storage): handle ENOENT explicitly in best-effort path normalization
+- fix(SPEC-1677,SPEC-1678): dedupe AGENTS.md changes and bound legacy skips to contract codes
+- fix(SPEC-1678): classify legacy contract failures as non-fatal skipped entries
+- fix(SPEC-1677): install and refresh planu core host assets on safe update
+- fix(SPEC-1679): normalize both roots in canonical re-check to match heal semantics
+- fix(SPEC-1679): self-heal missing registry logicalProjectId in canonical-root gate
+
+
+## [5.4.1] - 2026-08-29
+
+### Bug Fixes
+- fix(SPEC-1675): strip FILES/FUNCTIONS/TEST metadata markers from contradiction analysis
+- fix(SPEC-1676): rebuild expired project knowledge graph and re-stamp cached reuse
+
+
 ## [5.4.0] - 2026-08-29
 
 ### Features

package/dist/.planu-build.json

@@ -1 +1 @@
-{"schemaVersion":1,"commit":"1224d53c6195e75033a881982ac489bc4f2619f3"}
+{"schemaVersion":1,"commit":"2c3e47edf445a0c8422cbeec33a6a929edd764b5"}

package/dist/engine/project-graph/builder.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { collectProjectGraphSources, diffSourceHashes, hashText, hydrateProjectGraphSource, loadProjectGraphPolicy, projectGraphCachePath, projectGraphExtractorVersion, projectGraphPath, readProjectGraphArtifact, readProjectGraphCache, withProjectGraphBuildLock, writeProjectGraphArtifacts, } from './cache.js';
+import { collectProjectGraphSources, diffSourceHashes, hashText, hydrateProjectGraphSource, loadProjectGraphPolicy, projectGraphCachePath, projectGraphExtractorVersion, projectGraphPath, readProjectGraphArtifact, readProjectGraphCache, withProjectGraphBuildLock, writeProjectGraph, writeProjectGraphArtifacts, } from './cache.js';
 import { extractGitGraph, extractReleaseGraph } from './extractors/git-extractor.js';
 import { extractHandoffGraph } from './extractors/handoff-extractor.js';
 import { extractDecisionStoreGraph } from './extractors/decision-store-extractor.js';
@@ -210,13 +210,16 @@ async function buildProjectKnowledgeGraphUnlocked(args) {
         Array.isArray(existingGraph.nodes) &&
         Array.isArray(existingGraph.edges);
     if (hasConsistentExistingGraph && diff.changed.length === 0 && diff.removed.length === 0) {
+        const refreshedGeneratedAt = new Date().toISOString();
         const graphWithCurrentOversizedSources = {
             ...existingGraph,
+            generatedAt: refreshedGeneratedAt,
             oversizedSources,
         };
+        await writeProjectGraph(args.projectId, args.policy, graphWithCurrentOversizedSources);
         publishFreshProjectGraphProjection({
             projectId: args.projectId,
-            generatedAt: existingGraph.generatedAt,
+            generatedAt: refreshedGeneratedAt,
             generation: existingGraph.generation,
         });
         return {

package/dist/engine/project-graph/query.js

@@ -55,7 +55,8 @@ async function ensureFreshProjectGraph(args) {
     const freshness = await getProjectGraphFreshness(args);
     if (!freshness.exists ||
         freshness.reason === 'source_changed' ||
-        freshness.reason === 'corrupt') {
+        freshness.reason === 'corrupt' ||
+        freshness.reason === 'expired') {
         await buildProjectKnowledgeGraph(args);
         return getProjectGraphFreshness(args);
     }

package/dist/engine/scope-boundaries/contradiction-checker.js

@@ -203,14 +203,35 @@ function assertsActionNearScope(clause, outOfScopeItem) {
     }
     return false;
 }
+const METADATA_MARKER_KEYWORD = /\b(?:FILES?|FUNCTIONS?|TESTS?)\s*:/gi;
+const SENTENCE_BOUNDARY_AFTER_MARKER = /\.\s+(?=[A-Z])/;
+function stripMetadataMarkers(text) {
+    const markers = [...text.matchAll(METADATA_MARKER_KEYWORD)];
+    if (markers.length === 0) {
+        return text;
+    }
+    let result = '';
+    let cursor = 0;
+    for (let i = 0; i < markers.length; i++) {
+        const start = markers[i]?.index ?? 0;
+        result += text.slice(cursor, start);
+        const nextMarkerStart = markers[i + 1]?.index ?? text.length;
+        const searchRegion = text.slice(start, nextMarkerStart);
+        const boundaryMatch = SENTENCE_BOUNDARY_AFTER_MARKER.exec(searchRegion);
+        cursor = boundaryMatch ? start + boundaryMatch.index + 1 : nextMarkerStart;
+    }
+    result += text.slice(cursor);
+    return result.replace(/\s+/g, ' ').trim();
+}
 /**
  * Determine whether a criterion text contradicts an out-of-scope item.
  * Uses substring match first, then keyword overlap as fuzzy fallback.
  */
 function contradicts(criterionText, outOfScopeItem) {
-    const normCriterion = normalize(criterionText);
+    const strippedCriterionText = stripMetadataMarkers(criterionText);
+    const normCriterion = normalize(strippedCriterionText);
     const normScope = normalize(outOfScopeItem);
-    const clauses = splitClauses(criterionText);
+    const clauses = splitClauses(strippedCriterionText);
     const relevantClauses = clauses.filter((clause) => clauseMentionsScope(clause, outOfScopeItem));
     const hasConditionalException = /\b(?:unless|except)\b/i.test(criterionText);
     if (!hasConditionalException &&

package/dist/storage/project-identity.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, open, readFile, realpath, rename, rm, stat } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { resolveStorageLayout } from './storage-layout.js';
-import { getCanonicalRoot, readLogicalProjectId } from './global-projects-store.js';
+import { addProject, getCanonicalRoot, getProjects, readLogicalProjectId, } from './global-projects-store.js';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { isEphemeralProject } from '../engine/data-projects-gc/pattern-matcher.js';
 const IDENTITY_VERSION = 1;
@@ -205,37 +205,64 @@ function rejectsRootEscape(root, candidate) {
     const rel = relative(root, candidate);
     return rel.startsWith(`..${sep}`) || rel === '..' || isAbsolute(rel);
 }
-async function realpathClassified(path, notFoundCode) {
+async function realpathOr(path, onEnoent) {
     try {
         return await realpath(path);
     }
     catch (error) {
         if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-            throw new PortablePathError(notFoundCode, `[Planu] path not found: ${notFoundCode}`);
+            return onEnoent();
         }
         throw error;
     }
 }
+async function realpathClassified(path, code) {
+    return realpathOr(path, () => {
+        throw new PortablePathError(code, `[Planu] path not found: ${code}`);
+    });
+}
+async function normalizePathBestEffort(path) {
+    return realpathOr(path, () => resolve(path));
+}
+/** Bounded self-heal: backfill logicalProjectId via {@link addProject} using the registry entry's own stored path when exactly one path matches. */
+async function healMissingLogicalProjectId(root) {
+    const normalizedRoot = await normalizePathBestEffort(root);
+    const projects = await getProjects();
+    const normalized = await Promise.all(projects.map((p) => normalizePathBestEffort(p.path)));
+    const matches = projects.filter((_, i) => normalized[i] === normalizedRoot);
+    const [match] = matches;
+    if (matches.length !== 1 || !match) {
+        return false;
+    }
+    await addProject(match.path);
+    return true;
+}
 /**
- * Reject a candidate root that carries a tracked logical project identity but
- * is not the single registry-confirmed canonical root for it — a checkout
- * left over from a rename/fork, or an ambiguous/unregistered project never
- * resolves specs against an arbitrary directory. A candidate with no tracked
- * identity (`planu/project.json` absent) is untracked, not unverified, and
- * passes through unchanged — as does an ephemeral checkout (test fixture,
- * scratch clone), since the global registry deliberately excludes those
- * (SPEC-581) and can never confirm a root for them.
+ * Verify a candidate root with a tracked identity against the single
+ * registry-confirmed canonical root for it, fails closed on a fork/rename
+ * checkout. An untracked or ephemeral candidate passes through unchanged
+ * (SPEC-581) and skips the heal below. On a zero-match registry entry that
+ * predates `logicalProjectId`, self-heals once via {@link healMissingLogicalProjectId}
+ * before failing closed.
  */
-async function rejectsUnverifiedRoot(root) {
+async function verifyCanonicalRoot(root) {
     if (isEphemeralProject(root)) {
-        return false;
+        return undefined;
     }
     const logicalProjectId = await readLogicalProjectId(root);
     if (logicalProjectId === undefined) {
-        return false;
+        return undefined;
+    }
+    let canonical = await getCanonicalRoot(logicalProjectId);
+    if (!canonical.ok && canonical.reason === 'zero' && (await healMissingLogicalProjectId(root))) {
+        canonical = await getCanonicalRoot(logicalProjectId);
     }
-    const canonical = await getCanonicalRoot(logicalProjectId);
-    return !canonical.ok || resolve(canonical.root) !== root;
+    if (canonical.ok) {
+        return (await normalizePathBestEffort(canonical.root)) === (await normalizePathBestEffort(root))
+            ? undefined
+            : { reason: 'mismatch', roots: [canonical.root] };
+    }
+    return { reason: canonical.reason, roots: canonical.roots };
 }
 /**
  * Resolve a stored `specPath`/`technicalPath` value against the verified canonical
@@ -281,8 +308,12 @@ export async function resolvePortableSpecPath(specId, storedPath, canonicalRoot)
  * Delegates to {@link resolvePortableSpecPath} once verified.
  */
 export async function resolveVerifiedSpecPath(specId, storedPath, canonicalRoot) {
-    if (await rejectsUnverifiedRoot(resolve(canonicalRoot))) {
-        throw new PortablePathError('ROOT_UNVERIFIED', '[Planu] canonical root is not the single registry-confirmed root for this project');
+    const root = resolve(canonicalRoot);
+    const failure = await verifyCanonicalRoot(root);
+    if (failure) {
+        const registered = failure.roots.length > 0 ? `, registered=[${failure.roots.join(', ')}]` : '';
+        throw new PortablePathError('ROOT_UNVERIFIED', `[Planu] canonical root is not the single registry-confirmed root for this project ` +
+            `(reason=${failure.reason}, candidate=${root}${registered}) — run init_project on the canonical checkout`);
     }
     return resolvePortableSpecPath(specId, storedPath, canonicalRoot);
 }

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

@@ -21,7 +21,8 @@ import { regeneratePages } from '../../engine/doc-generator/portal/index.js';
 import { detectStackPatterns } from './stack-detector.js';
 import { buildProjectConfig } from './config-builder.js';
 import { runSpecMigrations, listProjectSpecs } from './migration-runner.js';
-import { reconcilePortableSpecIndex } from './portable-index-reconciler.js';
+import { reconcilePortableSpecIndex, describeReconciliationOutcome, } from './portable-index-reconciler.js';
+import { refreshCoreHostAssets } from './host-assets-writer.js';
 import { runScaffoldWriter } from './scaffold-writer.js';
 import { readAutoInstallFlag, orchestrateSkillInstalls, runHealthCheckWithBaseline, runConventionScanSafe, fireTelemetry, } from './lifecycle-helpers.js';
 import { injectProactiveRules } from '../../engine/claude-md-injector/index.js';
@@ -215,23 +216,23 @@ export async function handleInitProject(params, server) {
             const authorizedMigrations = params.authorizedMigrations ?? [];
             if (isUpdate && authorizedMigrations.length === 0) {
                 const reconciliation = await reconcilePortableSpecIndex(projectPath, projectId);
+                const repositoryFilesChanged = reconciliation.failures.length === 0 ? await refreshCoreHostAssets(projectPath) : [];
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: reconciliation.failures.length === 0
-                                ? 'Project already initialized. Safe update reconciled the portable spec index without changing repository files.'
-                                : `Portable spec index reconciliation failed for ${String(reconciliation.failures.length)} contract(s).`,
+                            text: describeReconciliationOutcome(reconciliation, repositoryFilesChanged),
                         },
                     ],
                     structuredContent: {
                         projectId,
                         ...(reconciliation.failures.length === 0 ? { projectPath } : {}),
                         isUpdate: true,
-                        repositoryFilesChanged: [],
+                        repositoryFilesChanged,
                         authorizedMigrations: [],
                         importedSpecIds: reconciliation.importedSpecIds,
                         failures: reconciliation.failures,
+                        skippedLegacy: reconciliation.skippedLegacy,
                     },
                     ...(reconciliation.failures.length > 0 ? { isError: true } : {}),
                 };

package/dist/tools/init-project/host-assets-writer.d.ts

@@ -17,5 +17,18 @@ export interface InitHostAssetsResult {
  * host configs that should stay in sync too.
  */
 export declare function detectInitAssetHosts(projectPath: string): Promise<InitAssetHost[]>;
+/** Whether `host` already has an on-disk asset surface in `projectPath` (SPEC-1677). */
+export declare function hasCoreSkillSurface(projectPath: string, host: HostId): Promise<boolean>;
+export declare function installCoreSkillsForHost(projectPath: string, host: HostId): Promise<{
+    host: HostId;
+    name: string;
+    path: string;
+}[]>;
 export declare function installInitHostAssets(projectPath: string, _knowledge: ProjectKnowledge, installSkills?: boolean): Promise<InitHostAssetsResult>;
+/**
+ * SPEC-1677: refresh Planu-owned core skills on the init_project safe-update path,
+ * restricted to detected hosts whose asset surface already exists on disk. Returns
+ * project-relative paths of every file whose content actually changed.
+ */
+export declare function refreshCoreHostAssets(projectPath: string): Promise<string[]>;
 //# sourceMappingURL=host-assets-writer.d.ts.map

package/dist/tools/init-project/host-assets-writer.js

@@ -1,6 +1,6 @@
 // tools/init-project/host-assets-writer.ts — Host-aware rules/skills installed by init_project
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import { detectHost } from '../../engine/host-detection/detect-host.js';
 import { handleCreateSkill } from '../create-skill.js';
 import { fileExists } from '../../core/shared/fs.js';
@@ -119,7 +119,25 @@ async function canRefreshCoreSkill(projectPath, host, name) {
         return true;
     }
 }
-async function installCoreSkillsForHost(projectPath, host) {
+/** Whether `host` already has an on-disk asset surface in `projectPath` (SPEC-1677). */
+export async function hasCoreSkillSurface(projectPath, host) {
+    if (host === 'codex') {
+        return fileExists(join(projectPath, 'AGENTS.md'));
+    }
+    if (host === 'gemini') {
+        return fileExists(join(projectPath, '.gemini'));
+    }
+    return fileExists(join(projectPath, '.claude'));
+}
+async function readTargetContent(path) {
+    try {
+        return await readFile(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function installCoreSkillsForHost(projectPath, host) {
     const installed = [];
     for (const fileName of CORE_SKILL_TEMPLATES) {
         const template = await readCoreSkillTemplate(fileName);
@@ -129,6 +147,8 @@ async function installCoreSkillsForHost(projectPath, host) {
         if (!(await canRefreshCoreSkill(projectPath, host, template.name))) {
             continue;
         }
+        const targetPath = coreSkillPath(projectPath, host, template.name);
+        const before = await readTargetContent(targetPath);
         const result = await handleCreateSkill({
             projectPath,
             host,
@@ -145,11 +165,11 @@ async function installCoreSkillsForHost(projectPath, host) {
             'skillFilePath' in result.structuredContent &&
             typeof result.structuredContent.skillFilePath === 'string'
             ? result.structuredContent.skillFilePath
-            : host === 'codex'
-                ? join(projectPath, 'AGENTS.md')
-                : host === 'gemini'
-                    ? join(projectPath, '.gemini', 'skills', `${template.name}.md`)
-                    : join(projectPath, '.claude', 'skills', template.name, 'SKILL.md');
+            : targetPath;
+        const after = await readTargetContent(path);
+        if (after === before) {
+            continue;
+        }
         installed.push({ host, name: template.name, path });
     }
     return installed;
@@ -195,4 +215,28 @@ export async function installInitHostAssets(projectPath, _knowledge, installSkil
     }
     return { detectedHosts, rulesInstalled, skillsInstalled, opencodeConfigured };
 }
+const CORE_SKILL_HOST_IDS = ['claude-code', 'codex', 'gemini'];
+function isCoreSkillHost(host) {
+    return CORE_SKILL_HOST_IDS.includes(host);
+}
+/**
+ * SPEC-1677: refresh Planu-owned core skills on the init_project safe-update path,
+ * restricted to detected hosts whose asset surface already exists on disk. Returns
+ * project-relative paths of every file whose content actually changed.
+ */
+export async function refreshCoreHostAssets(projectPath) {
+    const detectedHosts = await detectInitAssetHosts(projectPath);
+    const coreSkillHosts = detectedHosts.filter(isCoreSkillHost);
+    const changed = [];
+    for (const host of coreSkillHosts) {
+        if (!(await hasCoreSkillSurface(projectPath, host))) {
+            continue;
+        }
+        const installed = await installCoreSkillsForHost(projectPath, host);
+        for (const skill of installed) {
+            changed.push(relative(projectPath, skill.path));
+        }
+    }
+    return [...new Set(changed)];
+}
 //# sourceMappingURL=host-assets-writer.js.map

package/dist/tools/init-project/portable-index-reconciler.d.ts

@@ -1,4 +1,10 @@
-import type { FilesystemImportDeps, PortableIndexReconciliationResult } from '../../types/index.js';
+import type { FilesystemImportDeps, FilesystemImportFailure, PortableIndexReconciliationResult, SkippedLegacyContract } from '../../types/index.js';
+/** Autopilot-first summary of fatal reconciliation failures: what failed, why, and the next action. */
+export declare function describeReconciliationFailures(failures: FilesystemImportFailure[]): string;
+/** Autopilot-first summary of a successful reconciliation, including any legacy skips. */
+export declare function describeReconciliationSuccess(repositoryFilesChanged: string[], skippedLegacy: SkippedLegacyContract[]): string;
+/** Autopilot-first message for a reconciliation outcome, success or fatal-failure. */
+export declare function describeReconciliationOutcome(reconciliation: PortableIndexReconciliationResult, repositoryFilesChanged: string[]): string;
 /** Rebuild the mutable external index from the repository-owned portable contracts. */
 export declare function reconcilePortableSpecIndex(projectPath: string, projectId: string, deps?: FilesystemImportDeps): Promise<PortableIndexReconciliationResult>;
 //# sourceMappingURL=portable-index-reconciler.d.ts.map

package/dist/tools/init-project/portable-index-reconciler.js

@@ -1,5 +1,63 @@
 import { globalStore, specStore } from '../../storage/index.js';
 import { importFilesystemSpecs } from '../../engine/spec-migrator/filesystem-import.js';
+function classifyFailures(failures, indexedSpecIds) {
+    const remainingFailures = [];
+    const skippedLegacy = [];
+    const LEGACY_SKIPPABLE_CODES = new Set([
+        'INVALID_CONTRACT',
+        'INCOMPATIBLE_IDENTITY',
+    ]);
+    for (const failure of failures) {
+        if (indexedSpecIds.has(failure.specId) && LEGACY_SKIPPABLE_CODES.has(failure.code)) {
+            skippedLegacy.push({
+                ...failure,
+                reason: `${failure.specId} is already indexed; the on-disk contract is a historic mismatch left as-is.`,
+            });
+            continue;
+        }
+        remainingFailures.push(failure);
+    }
+    return { failures: remainingFailures, skippedLegacy };
+}
+const NEXT_ACTION_BY_CODE = {
+    READ_FAILED: 'fix file permissions or contents so spec.md can be read',
+    INVALID_CONTRACT: 'add the required portable frontmatter fields (id, title, type, scope, status, risk, target, difficulty)',
+    CREATE_FAILED: 'retry init_project once the underlying store write succeeds',
+    INCOMPATIBLE_IDENTITY: 'reconcile the spec identity (id, title, slug, uuid) with the indexed record',
+};
+/** Autopilot-first summary of fatal reconciliation failures: what failed, why, and the next action. */
+export function describeReconciliationFailures(failures) {
+    const counts = new Map();
+    for (const failure of failures) {
+        counts.set(failure.code, (counts.get(failure.code) ?? 0) + 1);
+    }
+    const codeSummary = [...counts.entries()]
+        .map(([code, count]) => `${String(count)} ${code}`)
+        .join(', ');
+    const topPaths = failures
+        .slice(0, 3)
+        .map((failure) => failure.path)
+        .join(', ');
+    const remainder = failures.length > 3 ? ', …' : '';
+    const nextActions = [...counts.keys()].map((code) => NEXT_ACTION_BY_CODE[code]).join('; ');
+    return `Portable spec index reconciliation failed for ${String(failures.length)} contract(s) (${codeSummary}). Affected: ${topPaths}${remainder}. Next: ${nextActions}.`;
+}
+/** Autopilot-first summary of a successful reconciliation, including any legacy skips. */
+export function describeReconciliationSuccess(repositoryFilesChanged, skippedLegacy) {
+    const base = repositoryFilesChanged.length === 0
+        ? 'Project already initialized. Safe update reconciled the portable spec index without changing repository files.'
+        : `Project already initialized. Safe update reconciled the portable spec index and refreshed ${String(repositoryFilesChanged.length)} core host asset file(s).`;
+    const skippedSuffix = skippedLegacy.length === 0
+        ? ''
+        : ` Skipped ${String(skippedLegacy.length)} already-indexed legacy contract(s).`;
+    return base + skippedSuffix;
+}
+/** Autopilot-first message for a reconciliation outcome, success or fatal-failure. */
+export function describeReconciliationOutcome(reconciliation, repositoryFilesChanged) {
+    return reconciliation.failures.length === 0
+        ? describeReconciliationSuccess(repositoryFilesChanged, reconciliation.skippedLegacy)
+        : describeReconciliationFailures(reconciliation.failures);
+}
 /** Rebuild the mutable external index from the repository-owned portable contracts. */
 export async function reconcilePortableSpecIndex(projectPath, projectId, deps = {
     listSpecs: specStore.listSpecs,
@@ -10,6 +68,8 @@ export async function reconcilePortableSpecIndex(projectPath, projectId, deps =
     const result = await importFilesystemSpecs(projectPath, deps, projectId, {
         strictPortableContract: true,
     });
-    return { ...result, repositoryFilesChanged: [] };
+    const indexedSpecIds = new Set((await deps.listSpecs(projectId)).map((spec) => spec.id));
+    const { failures, skippedLegacy } = classifyFailures(result.failures, indexedSpecIds);
+    return { ...result, failures, skippedLegacy, repositoryFilesChanged: [] };
 }
 //# sourceMappingURL=portable-index-reconciler.js.map

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

@@ -233,8 +233,15 @@ export interface FilesystemImportDeps {
     getSpecFresh?: (projectId: string, specId: string) => Promise<Spec | null>;
     getGlobalConfig?: () => Promise<Partial<GlobalConfig>>;
 }
+export interface SkippedLegacyContract {
+    specId: string;
+    path: string;
+    code: FilesystemImportFailureCode;
+    reason: string;
+}
 export interface PortableIndexReconciliationResult extends FilesystemImportResult {
     repositoryFilesChanged: string[];
+    skippedLegacy: SkippedLegacyContract[];
 }
 export interface ImportEntryContext {
     projectPath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Planu — MCP Server for Spec Driven Development. Cross-platform (Linux/macOS/Windows, x64/arm64).",
   "type": "module",
   "main": "dist/index.js",
@@ -40,11 +40,11 @@
     "lint:gate": "eslint src/ tests/ --max-warnings 0",
     "lint:fix": "eslint src/ tests/ --fix --max-warnings 0",
     "format": "prettier --write 'src/**/*.ts' 'tests/**/*.test.ts'",
-    "format:check": "prettier --check 'src/**/*.ts' 'tests/**/*.test.ts'",
+    "format:check": "prettier --check --cache --cache-strategy content 'src/**/*.ts' 'tests/**/*.test.ts'",
     "typecheck": "tsc --noEmit",
     "typecheck:compat": "tsc6 --noEmit",
     "verify:typescript-migration": "node scripts/verify-typescript-migration.mjs",
-    "test": "vitest run",
+    "test": "vitest run --maxWorkers=6",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --testTimeout=60000 --maxWorkers=4",
     "test:release-gate": "vitest run --exclude 'tests/integration/**'",

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "icon": "assets/plugin/icon.svg",
   "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",