@planu/cli 3.9.14 → 4.1.0

package/dist/engine/marketplace-fetcher/anthropic-source.js

@@ -2,6 +2,7 @@
 // Wraps fetchAnthropicSkillContent from anthropic-adapter.ts and converts to FetchedSkill[].
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 import { fetchAnthropicSkillContent } from '../skill-registry/anthropic-adapter.js';
 import { readCache, writeCache } from './cache.js';
 // ---------------------------------------------------------------------------
@@ -107,6 +108,7 @@ async function writeSkillFile(projectPath, skillName, content) {
     const skillsDir = join(projectPath, '.claude', 'skills');
     await mkdir(skillsDir, { recursive: true });
     const filePath = join(skillsDir, `${skillName}.md`);
+    assertEnglishOnlyArtifactText(`${skillName}\n\n${content}`, 'skill');
     await writeFile(filePath, content, 'utf-8');
     return filePath;
 }

package/dist/engine/opencode/config-scaffold.js

@@ -1,6 +1,7 @@
 // src/engine/opencode/config-scaffold.ts — SPEC-966: Generate OpenCode config files
 import { mkdirSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 const PLANU_OPENCODE_RULES = `# Planu Rules for OpenCode
 
 ## SDD Workflow
@@ -73,16 +74,19 @@ export function scaffoldOpenCodeConfig(projectPath) {
     const rulesDir = join(projectPath, '.opencode', 'rules');
     mkdirSync(rulesDir, { recursive: true });
     const rulesPath = join(rulesDir, 'planu-workflow.md');
+    assertEnglishOnlyArtifactText(PLANU_OPENCODE_RULES, 'rule');
     writeFileSync(rulesPath, PLANU_OPENCODE_RULES, 'utf-8');
     files.push(rulesPath);
     // .opencode/skills/planu-sdd.md
     const skillsDir = join(projectPath, '.opencode', 'skills');
     mkdirSync(skillsDir, { recursive: true });
     const skillsPath = join(skillsDir, 'planu-sdd.md');
+    assertEnglishOnlyArtifactText(PLANU_OPENCODE_SKILLS, 'skill');
     writeFileSync(skillsPath, PLANU_OPENCODE_SKILLS, 'utf-8');
     files.push(skillsPath);
     // AGENTS.md append (or create)
     const agentsMdPath = join(projectPath, 'AGENTS.md');
+    assertEnglishOnlyArtifactText(PLANU_AGENTS_MD_BLOCK, 'agent');
     if (existsSync(agentsMdPath)) {
         writeFileSync(agentsMdPath, '\n' + PLANU_AGENTS_MD_BLOCK + '\n', { flag: 'a' });
         files.push(agentsMdPath + ' (appended)');

package/dist/engine/release/postmortem-generator.d.ts

@@ -6,7 +6,7 @@ export interface PostmortemInput {
     projectRoot?: string;
 }
 /**
- * Write a post-mortem skeleton to planu/research/postmortems/<version>-<ts>.md
+ * Write a post-mortem skeleton to external Planu project data.
  * Returns the path of the written file.
  */
 export declare function writePostmortem(input: PostmortemInput): Promise<string>;

package/dist/engine/release/postmortem-generator.js

@@ -1,6 +1,7 @@
 // engine/release/postmortem-generator.ts — SPEC-737: Post-mortem skeleton writer
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Template path
 // ---------------------------------------------------------------------------
@@ -12,7 +13,7 @@ function templatePath() {
 // Public API
 // ---------------------------------------------------------------------------
 /**
- * Write a post-mortem skeleton to planu/research/postmortems/<version>-<ts>.md
+ * Write a post-mortem skeleton to external Planu project data.
  * Returns the path of the written file.
  */
 export async function writePostmortem(input) {
@@ -20,7 +21,7 @@ export async function writePostmortem(input) {
     const isoNow = new Date().toISOString();
     const tsSlug = isoNow.replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
     const filename = `${version}-${tsSlug}.md`;
-    const outDir = join(projectRoot, 'planu', 'research', 'postmortems');
+    const outDir = join(projectDataDir(hashProjectPath(projectRoot)), 'research', 'postmortems');
     const outPath = join(outDir, filename);
     // Load template
     let template;

package/dist/engine/rules-generator/index.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { detectAiTools, getPrimaryAiTool } from '../ai-tool-detector/index.js';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 // Stack-specific architecture rules catalog
 export const ARCHITECTURE_RULES = {
     nextjs: {
@@ -300,6 +301,7 @@ export function writeRules(rules) {
             if (dir) {
                 mkdirSync(dir, { recursive: true });
             }
+            assertEnglishOnlyArtifactText(rule.content, 'rule');
             writeFileSync(rule.filePath, rule.content, 'utf-8');
             written.push(rule.filePath);
         }

package/dist/engine/rules-reconciler.js

@@ -2,6 +2,7 @@
 import { readFileSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { parseConventions } from './convention-scanner/convention-parser.js';
+import { assertEnglishOnlyArtifactText } from './spec-language/english-only.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function listRulesFiles(projectPath) {
     const rulesDir = join(projectPath, '.claude', 'rules');
@@ -122,6 +123,7 @@ function writeNewRulesFile(projectPath, category, conventions) {
     const fileName = `${category}.md`;
     const filePath = join(rulesDir, fileName);
     const content = generateRuleFileContent(category, conventions);
+    assertEnglishOnlyArtifactText(content, 'rule');
     writeFileSync(filePath, content, 'utf-8');
     return fileName;
 }

package/dist/engine/safety/cross-process-lock.js

@@ -7,7 +7,7 @@
 // SMB / NFSv3 may produce false acquires because O_EXCL is not guaranteed atomic on
 // network filesystems. For local-disk POSIX (HFS+, APFS, ext4, tmpfs) this is reliable.
 //
-// Lockfiles live at: <projectPath>/planu/.locks/<specId>.lock
+// Lockfiles live at: <projectPath>/data/.locks/planu/<specId>.lock
 // File mode: 0o600 (owner read/write only)
 import { open, unlink, readFile, mkdir, chmod } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
@@ -41,7 +41,7 @@ export class LockBusyError extends Error {
 // Internal helpers
 // ---------------------------------------------------------------------------
 function locksDir(projectPath) {
-    return join(projectPath, 'planu', '.locks');
+    return join(projectPath, 'data', '.locks', 'planu');
 }
 function lockPath(projectPath, specId) {
     return join(locksDir(projectPath), `${specId}.lock`);

package/dist/engine/session/checkpoint-writer.js

@@ -74,7 +74,6 @@ export async function writeCheckpoint(projectPath, snapshot) {
     const updated = replaceLatestCheckpoint(existing, newBlock);
     await mkdir(planuDir, { recursive: true });
     await writeFile(filePath, updated, 'utf8');
-    // Auto-commit planu/ changes so session-context.md is never left unstaged
     void (async () => {
         try {
             const { planuAutoCommit } = await import('../git/planu-autocommit.js');

package/dist/engine/session-context-generator.js

@@ -132,7 +132,10 @@ export async function generateSessionContext(projectPath, projectId) {
         await mkdir(planuDir, { recursive: true });
         const contextPath = join(planuDir, 'session-context.md');
         await writeFile(contextPath, content, 'utf-8');
-        // SPEC-598: Atomic commit — git add + commit so session-context is never left unstaged/uncommitted
+        if (process.env.PLANU_ENABLE_AUTOCOMMIT !== 'true') {
+            return;
+        }
+        // SPEC-598: opt-in atomic commit for hosts that explicitly enable Planu autocommit.
         try {
             const { execFile } = await import('node:child_process');
             const { promisify } = await import('node:util');

package/dist/engine/skill-bootstrap/skill-writer.js

@@ -1,6 +1,7 @@
 // engine/skill-bootstrap/skill-writer.ts — SPEC-439: Write skills to target AI tool files
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 const AUTO_SECTION_HEADER = '## Auto-installed Skills (Planu)';
 function targetToRelativePath(target) {
     switch (target) {
@@ -42,6 +43,7 @@ export function formatSkillsForTarget(skills, target) {
     return parts.join('\n\n');
 }
 export async function writeSkillFile(projectPath, target, content, autoMerge) {
+    assertEnglishOnlyArtifactText(content, 'skill');
     const relativePath = targetToRelativePath(target);
     const filePath = join(projectPath, relativePath);
     await mkdir(dirname(filePath), { recursive: true });

package/dist/engine/skill-generation/multi-agent-writer.js

@@ -2,6 +2,7 @@
 // Detects which AI agents are present in a project and writes adapted skill files.
 import { access, mkdir, writeFile, readFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 import { adaptSkillForAgent } from './multi-agent-adapter.js';
 // ---------------------------------------------------------------------------
 // Agent detection signals
@@ -92,6 +93,7 @@ async function writeNewFile(filePath, content) {
  * @param targets - Optional explicit list of targets (default: auto-detect)
  */
 export async function writeSkillToAllAgents(skillContent, metadata, projectPath, targets) {
+    assertEnglishOnlyArtifactText(`${metadata.name}\n\n${metadata.description}\n\n${skillContent}`, 'skill');
     const resolvedTargets = targets ?? (await detectPresentAgents(projectPath));
     const results = [];
     await Promise.all(resolvedTargets.map(async (target) => {

package/dist/engine/spec-audit/index.js

@@ -2,7 +2,7 @@
 // Orchestrates the two-tier spec drift audit.
 import { join } from 'node:path';
 import { listSpecs } from '../../storage/spec-store.js';
-import { hashProjectPath } from '../../storage/base-store.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 import { buildSpecGraph } from '../spec-dependency-graph/graph-builder.js';
 import { getSupersededSet, getSupersededMap } from '../spec-dependency-graph/superseded-set.js';
 import { scanSpecTier1 } from './tier1-scanner.js';
@@ -61,7 +61,7 @@ export async function auditSpecsDrift(opts) {
     }
     // Generate report path
     const ts = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
-    const reportPath = join(projectRoot, 'planu', 'research', `audit-full-${ts}.md`);
+    const reportPath = join(projectDataDir(projectId), 'research', `audit-full-${ts}.md`);
     const report = {
         generatedAt: new Date().toISOString(),
         totalSpecs: allSpecs.length,

package/dist/engine/spec-audit/report-writer.d.ts

@@ -1,5 +1,5 @@
 import type { AuditReport, DriftReviewPendingEntry } from '../../types/spec-audit.js';
 export declare function buildMarkdownReport(report: AuditReport): string;
-export declare function writeAuditReport(report: AuditReport, projectRoot: string): Promise<void>;
+export declare function writeAuditReport(report: AuditReport, _projectRoot: string): Promise<void>;
 export declare function appendDriftReviewToPending(entry: DriftReviewPendingEntry, projectRoot: string): Promise<void>;
 //# sourceMappingURL=report-writer.d.ts.map

package/dist/engine/spec-audit/report-writer.js

@@ -1,9 +1,10 @@
 // engine/spec-audit/report-writer.ts — SPEC-744
-// Generates the prioritised markdown drift report and appends pending.json entry.
+// Generates the prioritised markdown drift report and appends pending review entries.
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Markdown report
 // ---------------------------------------------------------------------------
@@ -57,8 +58,8 @@ export function buildMarkdownReport(report) {
 // ---------------------------------------------------------------------------
 // Write report atomically
 // ---------------------------------------------------------------------------
-export async function writeAuditReport(report, projectRoot) {
-    const dir = join(projectRoot, 'planu', 'research');
+export async function writeAuditReport(report, _projectRoot) {
+    const dir = dirname(report.reportPath);
     await mkdir(dir, { recursive: true });
     const content = buildMarkdownReport(report);
     await atomicWriteFile(report.reportPath, content);
@@ -67,7 +68,7 @@ export async function writeAuditReport(report, projectRoot) {
 // Append to pending.json
 // ---------------------------------------------------------------------------
 export async function appendDriftReviewToPending(entry, projectRoot) {
-    const pendingPath = join(projectRoot, 'planu', 'pending.json');
+    const pendingPath = join(projectDataDir(hashProjectPath(projectRoot)), 'pending.json');
     let existing = [];
     if (existsSync(pendingPath)) {
         try {

package/dist/engine/spec-language/english-only.d.ts

@@ -1,15 +1,16 @@
+import type { EnglishOnlyArtifactKind, EnglishOnlyValidationResult } from '../../types/spec-language.js';
 /**
- * Validate that persisted spec documentation is authored in English.
+ * Validate that a Planu-owned persisted artifact is authored in English.
  *
  * The detector is intentionally conservative: it ignores code fences, inline code,
  * file paths, markdown headings, and BDD keywords before looking for common
  * Spanish/Portuguese function words. It should block obvious non-English prose
  * without punishing short technical descriptions.
  */
-export declare function validateEnglishOnlySpecText(text: string): {
-    ok: boolean;
-    detectedLanguage: 'en' | 'es' | 'pt' | 'unknown';
-    reason?: string;
-    signals: string[];
-};
+export declare function validateEnglishOnlyArtifactText(text: string, kind?: EnglishOnlyArtifactKind): EnglishOnlyValidationResult;
+/**
+ * Backward-compatible spec-specific entrypoint used by create_spec/update_status gates.
+ */
+export declare function validateEnglishOnlySpecText(text: string): EnglishOnlyValidationResult;
+export declare function assertEnglishOnlyArtifactText(text: string, kind: EnglishOnlyArtifactKind): void;
 //# sourceMappingURL=english-only.d.ts.map

package/dist/engine/spec-language/english-only.js

@@ -79,14 +79,14 @@ const NON_ENGLISH_SIGNATURES = {
     ]),
 };
 /**
- * Validate that persisted spec documentation is authored in English.
+ * Validate that a Planu-owned persisted artifact is authored in English.
  *
  * The detector is intentionally conservative: it ignores code fences, inline code,
  * file paths, markdown headings, and BDD keywords before looking for common
  * Spanish/Portuguese function words. It should block obvious non-English prose
  * without punishing short technical descriptions.
  */
-export function validateEnglishOnlySpecText(text) {
+export function validateEnglishOnlyArtifactText(text, kind = 'spec') {
     const tokens = tokenizeProse(text);
     if (tokens.length < MIN_PROSE_TOKENS) {
         return { ok: true, detectedLanguage: 'unknown', signals: [] };
@@ -109,10 +109,34 @@ export function validateEnglishOnlySpecText(text) {
         ok: false,
         detectedLanguage: best.lang,
         signals,
-        reason: `Spec documents must be written in English. Detected ${languageName(best.lang)} prose ` +
+        reason: `${artifactLabel(kind)} must be written in English. Detected ${languageName(best.lang)} prose ` +
             `signals: ${signals.join(', ')}.`,
     };
 }
+/**
+ * Backward-compatible spec-specific entrypoint used by create_spec/update_status gates.
+ */
+export function validateEnglishOnlySpecText(text) {
+    return validateEnglishOnlyArtifactText(text, 'spec');
+}
+export function assertEnglishOnlyArtifactText(text, kind) {
+    const validation = validateEnglishOnlyArtifactText(text, kind);
+    if (!validation.ok) {
+        throw new Error(validation.reason ?? `${artifactLabel(kind)} must be written in English.`);
+    }
+}
+function artifactLabel(kind) {
+    switch (kind) {
+        case 'spec':
+            return 'Spec documents';
+        case 'skill':
+            return 'Skill artifacts';
+        case 'agent':
+            return 'Agent instructions';
+        case 'rule':
+            return 'Rule artifacts';
+    }
+}
 function tokenizeProse(text) {
     const withoutCode = text
         .replace(/```[\s\S]*?```/g, ' ')

package/dist/engine/spec-migrator/index.d.ts

@@ -13,4 +13,5 @@ export { findLegacyMultiFileSpecs } from './find-legacy-multifile-specs.js';
 export { foldTechnicalIntoSpec } from './fold-technical.js';
 export { foldProgressIntoSpec, isBoilerplateProgress } from './fold-progress.js';
 export { runSsrBackMigration } from './ssr-back-migration.js';
+export { PLANU_CANONICAL_POLICY, runStrictPlanuCleanup, validateStrictPlanuLayout, } from './strict-planu-cleanup.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/spec-migrator/index.js

@@ -26,4 +26,5 @@ export { findLegacyMultiFileSpecs } from './find-legacy-multifile-specs.js';
 export { foldTechnicalIntoSpec } from './fold-technical.js';
 export { foldProgressIntoSpec, isBoilerplateProgress } from './fold-progress.js';
 export { runSsrBackMigration } from './ssr-back-migration.js';
+export { PLANU_CANONICAL_POLICY, runStrictPlanuCleanup, validateStrictPlanuLayout, } from './strict-planu-cleanup.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/spec-migrator/planu-canonical-policy.d.ts

@@ -0,0 +1,9 @@
+import type { PlanuCanonicalPathPolicy } from '../../types/index.js';
+export declare const PLANU_CANONICAL_POLICY: PlanuCanonicalPathPolicy;
+export declare function isCanonicalPlanuRootFile(name: string): boolean;
+export declare function isCanonicalPlanuRootDir(name: string): boolean;
+export declare function isCanonicalSpecFile(name: string): boolean;
+export declare function mustMergeBeforeDeleteSpecFile(name: string): boolean;
+export declare function isCanonicalReleaseFile(relativeToPlanu: string): boolean;
+export declare function canonicalContractText(): string;
+//# sourceMappingURL=planu-canonical-policy.d.ts.map

package/dist/engine/spec-migrator/planu-canonical-policy.js

@@ -0,0 +1,62 @@
+// engine/spec-migrator/planu-canonical-policy.ts — SPEC-1017
+// Single source of truth for the strict Planu managed directory contract.
+export const PLANU_CANONICAL_POLICY = {
+    canonicalRootFiles: ['conventions.json', 'context.md', 'session-context.md', 'session.json'],
+    canonicalRootDirs: ['releases', 'specs'],
+    canonicalSpecFiles: ['spec.md'],
+    generatedRuntimePatterns: [
+        'planu/index.html',
+        'planu/roadmap.html',
+        'planu/status.json',
+        'planu/CHANGELOG.md',
+        'planu/.housekeeping-history.jsonl',
+        'planu/audits/',
+        'planu/handoffs/',
+        'planu/data/',
+        'planu/state/',
+        'planu/.locks/',
+        'planu/specs/data/',
+        'planu/specs/*/technical-report.html',
+        'planu/specs/*/reference/',
+        'planu/specs/*/test-stubs.ts',
+        'planu/specs/*/.analysis.json',
+        'planu/specs/*/prompt.md',
+        'planu/specs/*/implementation-brief.md',
+        'planu/specs/*/risk-register.md',
+    ],
+    legacyMergeBeforeDeleteFiles: ['technical.md', 'plan.md', 'PLAN.md', 'progress.md'],
+};
+const ROOT_FILE_SET = new Set(PLANU_CANONICAL_POLICY.canonicalRootFiles);
+const ROOT_DIR_SET = new Set(PLANU_CANONICAL_POLICY.canonicalRootDirs);
+const SPEC_FILE_SET = new Set(PLANU_CANONICAL_POLICY.canonicalSpecFiles);
+const LEGACY_MERGE_SET = new Set(PLANU_CANONICAL_POLICY.legacyMergeBeforeDeleteFiles);
+export function isCanonicalPlanuRootFile(name) {
+    return ROOT_FILE_SET.has(name);
+}
+export function isCanonicalPlanuRootDir(name) {
+    return ROOT_DIR_SET.has(name);
+}
+export function isCanonicalSpecFile(name) {
+    return SPEC_FILE_SET.has(name);
+}
+export function mustMergeBeforeDeleteSpecFile(name) {
+    return LEGACY_MERGE_SET.has(name);
+}
+export function isCanonicalReleaseFile(relativeToPlanu) {
+    return relativeToPlanu === 'releases/pending.json';
+}
+export function canonicalContractText() {
+    return [
+        'planu/',
+        '  conventions.json',
+        '  context.md',
+        '  session-context.md',
+        '  session.json',
+        '  releases/',
+        '    pending.json',
+        '  specs/',
+        '    SPEC-XXX-slug/',
+        '      spec.md',
+    ].join('\n');
+}
+//# sourceMappingURL=planu-canonical-policy.js.map

package/dist/engine/spec-migrator/planu-root-cleaner.js

@@ -1,101 +1,25 @@
-// engine/spec-migrator/planu-root-cleaner.ts — SPEC-464: Clean non-canonical files from planu/
-// Canonical structure: specs/ + status.json + conventions.json + index.html + roadmap.html
-import { readdir, stat } from 'node:fs/promises';
-import { execFileSync } from 'node:child_process';
-import { join, relative } from 'node:path';
-import { safeUnlink } from './git-aware-fs.js';
-/** Files allowed in planu/ root. Everything else gets deleted. */
-const CANONICAL_ROOT_FILES = new Set([
-    'status.json',
-    'conventions.json',
-    'index.html',
-    'roadmap.html',
-]);
-/** Directories allowed in planu/ root. */
-const CANONICAL_ROOT_DIRS = new Set(['specs']);
-/** Files allowed inside each planu/specs/SPEC-XXX/ directory. */
-const CANONICAL_SPEC_FILES = new Set(['spec.md']);
-/** Remove a file from git tracking (best-effort, silent if not a git repo or file not tracked). */
-function gitRmCached(absolutePath, cwd) {
-    try {
-        const rel = relative(cwd, absolutePath);
-        execFileSync('git', ['rm', '--cached', '--quiet', '--force', rel], {
-            cwd,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: 3_000,
-        });
-    }
-    catch {
-        // Not a git repo, file not tracked, or git not available — ignore
-    }
-}
+// engine/spec-migrator/planu-root-cleaner.ts — SPEC-1017 strict wrapper
+import { dirname } from 'node:path';
+import { runStrictPlanuCleanup } from './strict-planu-cleanup.js';
 /** Remove all non-canonical files from planu/ root and per-spec directories. */
 export async function cleanPlanuRoot(planuDir, projectPath) {
-    const result = {
-        deletedRootFiles: [],
-        deletedSpecFiles: [],
-        totalDeleted: 0,
-    };
-    // 1. Clean planu/ root
-    let entries;
-    try {
-        entries = await readdir(planuDir);
-    }
-    catch {
-        return result; // Dir doesn't exist — nothing to clean
-    }
-    for (const entry of entries) {
-        const fullPath = join(planuDir, entry);
-        try {
-            const info = await stat(fullPath);
-            if (info.isDirectory()) {
-                if (!CANONICAL_ROOT_DIRS.has(entry)) {
-                    // Non-canonical directory — skip (don't delete dirs recursively for safety)
-                    continue;
-                }
-            }
-            else if (!CANONICAL_ROOT_FILES.has(entry)) {
-                gitRmCached(fullPath, planuDir);
-                await safeUnlink(projectPath ?? planuDir, fullPath);
-                result.deletedRootFiles.push(entry);
-            }
+    const root = projectPath ?? dirname(planuDir);
+    const strict = await runStrictPlanuCleanup(root);
+    const deletedRootFiles = [];
+    const deletedSpecFiles = [];
+    for (const path of [...strict.deleted, ...strict.merged]) {
+        const normalized = path.replace(/^planu\//, '');
+        if (normalized.startsWith('specs/')) {
+            deletedSpecFiles.push(normalized.replace(/^specs\//, ''));
         }
-        catch {
-            // File disappeared between readdir and stat — ignore
+        else {
+            deletedRootFiles.push(normalized);
         }
     }
-    // 2. Clean per-spec directories
-    const specsDir = join(planuDir, 'specs');
-    let specDirs;
-    try {
-        specDirs = await readdir(specsDir);
-    }
-    catch {
-        result.totalDeleted = result.deletedRootFiles.length;
-        return result;
-    }
-    for (const specDir of specDirs) {
-        const specPath = join(specsDir, specDir);
-        try {
-            const info = await stat(specPath);
-            if (!info.isDirectory()) {
-                continue;
-            }
-            const files = await readdir(specPath);
-            for (const file of files) {
-                if (!CANONICAL_SPEC_FILES.has(file)) {
-                    const filePath = join(specPath, file);
-                    gitRmCached(filePath, planuDir);
-                    await safeUnlink(projectPath ?? planuDir, filePath);
-                    result.deletedSpecFiles.push(`${specDir}/${file}`);
-                }
-            }
-        }
-        catch {
-            // Spec dir issue — skip
-        }
-    }
-    result.totalDeleted = result.deletedRootFiles.length + result.deletedSpecFiles.length;
-    return result;
+    return {
+        deletedRootFiles,
+        deletedSpecFiles,
+        totalDeleted: strict.deleted.length + strict.merged.length,
+    };
 }
 //# sourceMappingURL=planu-root-cleaner.js.map

package/dist/engine/spec-migrator/strict-planu-cleanup.d.ts

@@ -0,0 +1,6 @@
+import type { StrictPlanuCleanupResult, StrictPlanuValidationResult } from '../../types/index.js';
+import { PLANU_CANONICAL_POLICY } from './planu-canonical-policy.js';
+export declare function runStrictPlanuCleanup(projectPath: string): Promise<StrictPlanuCleanupResult>;
+export declare function validateStrictPlanuLayout(projectPath: string): Promise<StrictPlanuValidationResult>;
+export { PLANU_CANONICAL_POLICY };
+//# sourceMappingURL=strict-planu-cleanup.d.ts.map