@planu/cli 5.6.0 → 5.7.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [5.7.0] - 2026-08-31
+
+### Features
+- feat: registry-mapped ~/.planu demolisher and storage isolation guard (SPEC-1709)
+- feat(lifecycle): SPEC-1703 declared architectural-premise drift routes reconcile_spec demotion
+- feat: add done-drift missing-files compliance check (SPEC-1701)
+- feat(telemetry): SPEC-1704 anonymous event envelope v1 and consent CLI
+
+### Bug Fixes
+- fix: serialize prepublish-guard suite to avoid full-load spawn flake
+- fix: declare telemetry and test-home env vars in schema and serialize lock-lease suite
+- fix: reuse shared pathExists helper in legacy planu demolisher (SPEC-1709)
+- fix: harden legacy planu demolisher (symlinks, canonical root) SPEC-1709
+- fix: enforce mcp trust boundary and bind drift source into receipt digest (SPEC-1703)
+- fix: exclude globs and directory refs from done-drift check, wire early return (SPEC-1701)
+- fix(telemetry): close legacy properties, validate ids, truncate show output (SPEC-1704)
+- fix(gates): destination-aware premise matching and tool-level AC1 coverage (SPEC-1702 review fixes)
+- fix(gates): SPEC-1702 cross-spec premise contradiction detection
+
+
 ## [5.6.0] - 2026-08-31
 
 ### Features

package/dist/.planu-build.json

@@ -1 +1 @@
-{"schemaVersion":1,"commit":"fa03e03df9ac0a344ac184a06f67f4de5956d0d6"}
+{"schemaVersion":1,"commit":"e145c9f04adb18813ddff699db636c390b20a776"}

package/dist/cli/commands/telemetry.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from '../../types/cli.js';
+export declare const telemetryCommand: CliCommand;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/cli/commands/telemetry.js

@@ -0,0 +1,118 @@
+// cli/commands/telemetry.ts — planu telemetry status|enable|disable|show (SPEC-1704)
+import { isTelemetryEnabled, readTelemetryConfig, enableTelemetry, disableTelemetry, } from '../../engine/telemetry/telemetry-store.js';
+import { buildTelemetryEnvelope, TELEMETRY_SESSION_ID, } from '../../engine/telemetry/event-envelope.js';
+import { bold, dim, green, red } from '../colors.js';
+const NOTICE = 'Planu telemetry, when enabled, sends anonymous usage events (tool name, result, duration ' +
+    'bucket, operating system, Node major version, Planu version) tagged with a random per-install ' +
+    'id. It never sends prompts, tool arguments or results, spec content, source code, file paths, ' +
+    'usernames, hostnames, repository names, environment variables, tokens, or raw stack traces. ' +
+    'Run `planu telemetry disable` to opt out anytime.';
+const TRUNCATED_ID_LENGTH = 8;
+const SAMPLE_INSTALLATION_ID = '00000000-0000-4000-8000-000000000000';
+const SAMPLE_DURATION_MS = 450;
+function truncateId(id) {
+    if (!id) {
+        return '(none)';
+    }
+    return `${id.slice(0, TRUNCATED_ID_LENGTH)}…`;
+}
+function activeSuppressionFlags() {
+    const active = [];
+    if (process.env.PLANU_TELEMETRY_DISABLED === '1') {
+        active.push('PLANU_TELEMETRY_DISABLED=1');
+    }
+    if (process.env.DO_NOT_TRACK === '1') {
+        active.push('DO_NOT_TRACK=1');
+    }
+    if (process.env.CI === 'true') {
+        active.push('CI=true');
+    }
+    if (process.env.PLANU_TELEMETRY === 'off') {
+        active.push('PLANU_TELEMETRY=off');
+    }
+    return active;
+}
+async function runStatus(flags) {
+    const enabled = await isTelemetryEnabled();
+    const config = await readTelemetryConfig();
+    const suppressionFlagsActive = activeSuppressionFlags();
+    if (flags?.json) {
+        process.stdout.write(JSON.stringify({
+            enabled,
+            consentVersion: config?.consentVersion,
+            anonymousInstallationId: truncateId(config?.anonymousInstallationId),
+            suppressionFlagsActive,
+        }) + '\n');
+        return;
+    }
+    const lines = [
+        `${bold('Telemetry:')} ${enabled ? green('enabled') : red('disabled')}`,
+        `${dim('Installation id:')} ${truncateId(config?.anonymousInstallationId)}`,
+    ];
+    if (suppressionFlagsActive.length > 0) {
+        lines.push(`${dim('Suppressed by:')} ${suppressionFlagsActive.join(', ')}`);
+    }
+    process.stdout.write(lines.join('\n') + '\n');
+}
+async function runEnable(flags) {
+    const config = await enableTelemetry();
+    if (flags?.json) {
+        process.stdout.write(JSON.stringify({
+            enabled: true,
+            anonymousInstallationId: truncateId(config.anonymousInstallationId),
+        }) + '\n');
+        return;
+    }
+    process.stdout.write(`${green('Telemetry enabled.')} ${NOTICE}\n`);
+}
+async function runDisable(flags) {
+    await disableTelemetry();
+    if (flags?.json) {
+        process.stdout.write(JSON.stringify({ enabled: false }) + '\n');
+        return;
+    }
+    process.stdout.write(`${red('Telemetry disabled.')} No anonymous usage events will be sent.\n`);
+}
+async function runShow() {
+    const config = await readTelemetryConfig();
+    const envelope = buildTelemetryEnvelope('mcp_tool_completed', {
+        anonymousInstallationId: SAMPLE_INSTALLATION_ID,
+        sessionId: TELEMETRY_SESSION_ID,
+        toolName: 'planu_status',
+        result: 'success',
+        durationMs: SAMPLE_DURATION_MS,
+    });
+    process.stdout.write(`${dim('Current installation id:')} ${truncateId(config?.anonymousInstallationId)}\n`);
+    const displayEnvelope = {
+        ...envelope,
+        anonymousInstallationId: truncateId(envelope.anonymousInstallationId),
+    };
+    process.stdout.write(JSON.stringify(displayEnvelope, null, 2) + '\n');
+}
+export const telemetryCommand = {
+    name: 'telemetry',
+    description: 'Manage local telemetry consent (status | enable | disable | show)',
+    usage: 'planu telemetry <status|enable|disable|show> [--json]',
+    async run(args, flags) {
+        const subcommand = args[0] ?? 'status';
+        switch (subcommand) {
+            case 'status':
+                await runStatus(flags);
+                return;
+            case 'enable':
+                await runEnable(flags);
+                return;
+            case 'disable':
+                await runDisable(flags);
+                return;
+            case 'show':
+                await runShow();
+                return;
+            default:
+                process.stderr.write(`${red('Error:')} Unknown telemetry subcommand "${subcommand}"\n`);
+                process.stderr.write(`Usage: ${telemetryCommand.usage}\n`);
+                process.exitCode = 1;
+        }
+    },
+};
+//# sourceMappingURL=telemetry.js.map

package/dist/cli/router.js

@@ -4,7 +4,7 @@ import { PLANU_VERSION } from '../config/version.js';
 import { red, bold, cyan, dim } from './colors.js';
 // Lazy-load commands to avoid importing tool handlers when not needed
 async function loadCommands() {
-    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { packageHandoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = await Promise.all([
+    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { packageHandoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand }, { telemetryCommand },] = await Promise.all([
         import('./commands/init.js'),
         import('./commands/create.js'),
         import('./commands/list.js'),
@@ -27,6 +27,7 @@ async function loadCommands() {
         import('./commands/inspect.js'),
         import('./commands/offline.js'),
         import('./commands/job.js'),
+        import('./commands/telemetry.js'),
     ]);
     const cmds = [
         initCommand,
@@ -51,6 +52,7 @@ async function loadCommands() {
         inspectCommand,
         offlineCommand,
         jobCommand,
+        telemetryCommand,
     ];
     const map = new Map();
     for (const cmd of cmds) {

package/dist/config/environment-schema.json

@@ -218,6 +218,13 @@
       "sensitivity": "private",
       "default": null
     },
+    {
+      "name": "PLANU_TELEMETRY_DISABLED",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_TELEMETRY_ENDPOINT",
       "type": "string",
@@ -232,6 +239,13 @@
       "sensitivity": "secret",
       "default": null
     },
+    {
+      "name": "PLANU_TEST_HOME",
+      "type": "string",
+      "scope": "test",
+      "sensitivity": "public",
+      "default": null
+    },
     {
       "name": "PLANU_TIMING",
       "type": "boolean",

package/dist/engine/contradiction-detector.d.ts

@@ -1,4 +1,4 @@
-import type { ConflictReport, Contradiction, SpecAnalysisInput } from '../types/index.js';
+import type { ConflictReport, Contradiction, CrossSpecPremiseFinding, SpecAnalysisInput } from '../types/index.js';
 /**
  * Detect semantic contradictions between a list of specs.
  * Each spec is compared against every other spec for all known patterns.
@@ -12,4 +12,5 @@ export declare function buildConflictReport(specs: SpecAnalysisInput[]): Conflic
  * Format a ConflictReport as a markdown string.
  */
 export declare function formatConflictReport(report: ConflictReport): string;
+export declare function detectCrossSpecPremiseContradictions(targetSpecId: string, targetRawContent: string, projectPath: string | undefined): Promise<CrossSpecPremiseFinding[]>;
 //# sourceMappingURL=contradiction-detector.d.ts.map

package/dist/engine/contradiction-detector.js

@@ -1,3 +1,8 @@
+// engine/contradiction-detector.ts — Semantic contradiction detection (SPEC-038)
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findMarkdownSectionRange } from './spec-format/markdown-sections.js';
+import { getUniqueTopLevelFrontmatterString, stripFrontmatter } from './frontmatter-parser.js';
 // ---------------------------------------------------------------------------
 // Contradiction patterns
 // ---------------------------------------------------------------------------
@@ -155,4 +160,214 @@ export function formatConflictReport(report) {
     }
     return lines.join('\n');
 }
+const DIRECTIONAL_PHRASE_PAIRS = [
+    { phraseA: 'out of', phraseB: 'into' },
+    { phraseA: 're-roots at', phraseB: 'relocates to' },
+    { phraseA: 'removes', phraseB: 'adds' },
+    { phraseA: 'enables', phraseB: 'disables' },
+];
+const SIGNIFICANT_WORD_STOPWORDS = new Set([
+    'this',
+    'that',
+    'with',
+    'from',
+    'into',
+    'spec',
+    'specs',
+    'after',
+    'before',
+    'while',
+    'their',
+    'them',
+    'about',
+    'have',
+    'will',
+    'when',
+    'then',
+    'also',
+    'were',
+    'been',
+    'these',
+    'those',
+]);
+function splitBodyIntoSentenceFragments(body) {
+    const sentences = [];
+    for (const line of body.split('\n')) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.length === 0) {
+            continue;
+        }
+        for (const clause of trimmedLine.split(/(?<=[.!?])\s+/)) {
+            const sentence = clause.trim();
+            if (sentence.length > 0) {
+                sentences.push(sentence);
+            }
+        }
+    }
+    return sentences;
+}
+/** Extracts distinct "SPEC-NNNN" references from body text, excluding the spec's own ID. */
+function extractReferencedSpecIds(body, excludeSpecId) {
+    const ids = new Set();
+    for (const match of body.matchAll(/\bSPEC-(\d+)\b/gi)) {
+        const number = match[1];
+        if (!number) {
+            continue;
+        }
+        const id = `SPEC-${number}`;
+        if (id.toUpperCase() !== excludeSpecId.toUpperCase()) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+/** Extracts backtick-quoted file paths declared under a spec's "## Files" section. */
+function extractFilesSectionPaths(body) {
+    const section = findMarkdownSectionRange(body, 'Files');
+    const paths = new Set();
+    if (!section) {
+        return paths;
+    }
+    const sectionText = body.slice(section.contentStart, section.end);
+    for (const match of sectionText.matchAll(/`([\w./-]+\.[A-Za-z0-9]+)`/g)) {
+        const path = match[1];
+        if (path) {
+            paths.add(path);
+        }
+    }
+    return paths;
+}
+function extractSignificantWords(sentence) {
+    const words = sentence.toLowerCase().match(/[a-z][a-z0-9._/-]{3,}/g) ?? [];
+    return new Set(words.filter((word) => !SIGNIFICANT_WORD_STOPWORDS.has(word)));
+}
+function shareSignificantWord(sentenceA, sentenceB) {
+    const wordsA = extractSignificantWords(sentenceA);
+    for (const word of extractSignificantWords(sentenceB)) {
+        if (wordsA.has(word)) {
+            return true;
+        }
+    }
+    return false;
+}
+const DESTINATION_TOKEN_PATTERN = /^`([^`]+)`|^([\w][\w./-]*)/;
+function normalizeDestinationToken(token) {
+    return token.replace(/`/g, '').replace(/\/+$/, '').toLowerCase();
+}
+function extractDestinationToken(sentence, phrase) {
+    const phraseIndex = sentence.toLowerCase().indexOf(phrase);
+    if (phraseIndex === -1) {
+        return null;
+    }
+    const after = sentence.slice(phraseIndex + phrase.length).trimStart();
+    const match = DESTINATION_TOKEN_PATTERN.exec(after);
+    const token = match?.[1] ?? match?.[2];
+    if (!token) {
+        return null;
+    }
+    const isBacktickQuoted = match?.[1] !== undefined;
+    if (!isBacktickQuoted && !/[./]/.test(token)) {
+        return null;
+    }
+    return normalizeDestinationToken(token);
+}
+function sameDestination(targetSentence, targetPhrase, siblingSentence, siblingPhrase) {
+    const targetDestination = extractDestinationToken(targetSentence, targetPhrase);
+    const siblingDestination = extractDestinationToken(siblingSentence, siblingPhrase);
+    return (targetDestination !== null &&
+        siblingDestination !== null &&
+        targetDestination === siblingDestination);
+}
+function findOppositeDirectionSentence(targetSentence, siblingSentences) {
+    const lowerTarget = targetSentence.toLowerCase();
+    for (const pair of DIRECTIONAL_PHRASE_PAIRS) {
+        const targetHasA = lowerTarget.includes(pair.phraseA);
+        const targetPhrase = targetHasA ? pair.phraseA : pair.phraseB;
+        const oppositePhrase = targetHasA ? pair.phraseB : pair.phraseA;
+        if (!targetHasA && !lowerTarget.includes(pair.phraseB)) {
+            continue;
+        }
+        for (const siblingSentence of siblingSentences) {
+            if (siblingSentence.toLowerCase().includes(oppositePhrase) &&
+                shareSignificantWord(targetSentence, siblingSentence) &&
+                !sameDestination(targetSentence, targetPhrase, siblingSentence, oppositePhrase)) {
+                return siblingSentence;
+            }
+        }
+    }
+    return null;
+}
+async function readSiblingSpecMarkdown(projectPath, siblingSpecId) {
+    const specsDir = join(projectPath, 'planu', 'specs');
+    let entries;
+    try {
+        entries = await readdir(specsDir);
+    }
+    catch {
+        return null;
+    }
+    const dirPrefix = `${siblingSpecId}-`.toLowerCase();
+    const dirName = entries.find((entry) => entry.toLowerCase() === siblingSpecId.toLowerCase() ||
+        entry.toLowerCase().startsWith(dirPrefix));
+    if (!dirName) {
+        return null;
+    }
+    try {
+        return await readFile(join(specsDir, dirName, 'spec.md'), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function detectCrossSpecPremiseContradictions(targetSpecId, targetRawContent, projectPath) {
+    if (!projectPath) {
+        return [];
+    }
+    const targetBody = stripFrontmatter(targetRawContent);
+    const referencedSpecIds = extractReferencedSpecIds(targetBody, targetSpecId);
+    if (referencedSpecIds.length === 0) {
+        return [];
+    }
+    const targetFilePaths = extractFilesSectionPaths(targetBody);
+    if (targetFilePaths.size === 0) {
+        return [];
+    }
+    const targetSentences = splitBodyIntoSentenceFragments(targetBody);
+    const findings = [];
+    for (const siblingSpecId of referencedSpecIds) {
+        const siblingRawContent = await readSiblingSpecMarkdown(projectPath, siblingSpecId);
+        if (!siblingRawContent) {
+            continue;
+        }
+        const siblingStatus = getUniqueTopLevelFrontmatterString(siblingRawContent, 'status');
+        if (siblingStatus !== 'done' && siblingStatus !== 'approved') {
+            continue;
+        }
+        const siblingBody = stripFrontmatter(siblingRawContent);
+        const siblingFilePaths = extractFilesSectionPaths(siblingBody);
+        const sharedFilePath = [...targetFilePaths].find((path) => siblingFilePaths.has(path));
+        if (!sharedFilePath) {
+            continue;
+        }
+        const claimSentences = targetSentences.filter((sentence) => sentence.toUpperCase().includes(siblingSpecId.toUpperCase()));
+        if (claimSentences.length === 0) {
+            continue;
+        }
+        const siblingSentences = splitBodyIntoSentenceFragments(siblingBody);
+        for (const targetSentence of claimSentences) {
+            const siblingSentence = findOppositeDirectionSentence(targetSentence, siblingSentences);
+            if (siblingSentence) {
+                findings.push({
+                    targetSpecId,
+                    siblingSpecId,
+                    targetSentence,
+                    siblingSentence,
+                    sharedFilePath,
+                });
+                break;
+            }
+        }
+    }
+    return findings;
+}
 //# sourceMappingURL=contradiction-detector.js.map

package/dist/engine/handoff-artifacts/schemas.js

@@ -168,6 +168,10 @@ export const ReconciliationReceiptV1Schema = z.object({
     transitionId: z.string().min(1).optional(),
     phase: z.enum(['prepared', 'status-committed', 'spec-synced', 'audit-appended']).optional(),
     auditPending: z.boolean().optional(),
+    driftSource: z
+        .literal('declared-architectural-premise')
+        .optional()
+        .describe('Set when the reconciliation demotion evidence is an orchestrator-declared drift rather than an automated validation-report finding.'),
 });
 // ---------------------------------------------------------------------------
 // Schema registry

package/dist/engine/housekeeping/legacy-planu-demolisher.d.ts

@@ -0,0 +1,3 @@
+import type { LegacyPlanuDemolisherOptions, LegacyPlanuDemolitionReport } from '../../types/housekeeping.js';
+export declare function demolishLegacyPlanuRoot(options?: LegacyPlanuDemolisherOptions): Promise<LegacyPlanuDemolitionReport>;
+//# sourceMappingURL=legacy-planu-demolisher.d.ts.map

package/dist/engine/housekeeping/legacy-planu-demolisher.js

@@ -0,0 +1,164 @@
+// engine/housekeeping/legacy-planu-demolisher.ts — SPEC-1709
+import { homedir } from 'node:os';
+import { lstat, readdir, realpath, rm, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { isAbsolute, join, relative } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1709
+import { globalDataDir, projectDataDir } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1709
+import { getRegistry, readLogicalProjectId } from '../../storage/global-projects-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1709
+import { migrateCanonicalStorage } from '../../storage/migrations/canonical-storage.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1709
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { pathExistsStrictByStat as pathExists } from '../../core/shared/fs.js';
+const CANONICAL_ROOT_COLLISION_REASON = 'legacy root coincides with the canonical storage root; refusing to demolish';
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function isInsideDirectory(parent, candidate) {
+    const rel = relative(parent, candidate);
+    return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+async function realpathOrSelf(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return path;
+    }
+}
+async function isRealPathContained(parentReal, candidate) {
+    const candidateReal = await realpathOrSelf(candidate);
+    return candidateReal === parentReal || isInsideDirectory(parentReal, candidateReal);
+}
+async function canonicalRootCollidesWithLegacy(legacyRoot) {
+    const legacyReal = await realpathOrSelf(legacyRoot);
+    const canonicalCandidates = [resolveStorageLayout().data, globalDataDir()];
+    for (const candidate of canonicalCandidates) {
+        if (await isRealPathContained(legacyReal, candidate)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function directorySizeBytes(root) {
+    let total = 0;
+    const entries = await readdir(root, { withFileTypes: true });
+    for (const entry of entries) {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            total += await directorySizeBytes(path);
+        }
+        else if (entry.isFile()) {
+            total += (await stat(path)).size;
+        }
+    }
+    return total;
+}
+async function defaultResolveDestination(project) {
+    const logicalProjectId = await readLogicalProjectId(project.path);
+    const projectId = logicalProjectId !== undefined
+        ? logicalProjectId.replaceAll('-', '').toLowerCase()
+        : project.hash;
+    return projectDataDir(projectId);
+}
+async function buildDestinationMap(registry, resolveDestination) {
+    const map = new Map();
+    for (const project of registry.projects) {
+        const destination = await resolveDestination(project);
+        const fullDigest = sha256Hex(project.path);
+        map.set(fullDigest, destination);
+        map.set(fullDigest.slice(0, 16), destination);
+    }
+    return map;
+}
+async function migrateOrRecordFailure(dirName, dirPath, destination, migrated, failures) {
+    const sizeBeforeMigration = await directorySizeBytes(dirPath);
+    try {
+        const migration = await migrateCanonicalStorage({
+            legacyRoots: [dirPath],
+            destinationRoot: destination,
+        });
+        if (migration.status === 'error' || migration.status === 'rolled-back') {
+            failures.push({ dir: dirName, reason: migration.reason ?? migration.status });
+            return 0;
+        }
+        migrated.push(dirName);
+        return sizeBeforeMigration;
+    }
+    catch (error) {
+        failures.push({ dir: dirName, reason: error instanceof Error ? error.message : String(error) });
+        return 0;
+    }
+}
+async function sweepLegacyProjectsDir(legacyProjectsDir, trustedProjectsDirReal, destinationMap) {
+    const migrated = [];
+    const failures = [];
+    let demolishedUnmappable = 0;
+    let freedBytes = 0;
+    if (!(await pathExists(legacyProjectsDir))) {
+        return { migrated, demolishedUnmappable, failures, freedBytes };
+    }
+    const entries = await readdir(legacyProjectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const dirPath = join(legacyProjectsDir, entry.name);
+        if (entry.isSymbolicLink()) {
+            freedBytes += (await lstat(dirPath)).size;
+            await rm(dirPath, { force: true });
+            demolishedUnmappable += 1;
+            continue;
+        }
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        if (!(await isRealPathContained(trustedProjectsDirReal, dirPath))) {
+            failures.push({ dir: entry.name, reason: 'path escapes the legacy projects directory' });
+            continue;
+        }
+        const destination = destinationMap.get(entry.name);
+        if (destination !== undefined) {
+            freedBytes += await migrateOrRecordFailure(entry.name, dirPath, destination, migrated, failures);
+            continue;
+        }
+        freedBytes += await directorySizeBytes(dirPath);
+        await rm(dirPath, { recursive: true, force: true });
+        demolishedUnmappable += 1;
+    }
+    return { migrated, demolishedUnmappable, failures, freedBytes };
+}
+async function remainingProjectEntryCount(legacyProjectsDir) {
+    if (!(await pathExists(legacyProjectsDir))) {
+        return 0;
+    }
+    const entries = await readdir(legacyProjectsDir, { withFileTypes: true });
+    return entries.length;
+}
+export async function demolishLegacyPlanuRoot(options = {}) {
+    const legacyRoot = options.legacyRoot ?? join(homedir(), '.planu');
+    if (await canonicalRootCollidesWithLegacy(legacyRoot)) {
+        return {
+            status: 'retained',
+            migrated: [],
+            demolishedUnmappable: 0,
+            failures: [{ dir: '.', reason: CANONICAL_ROOT_COLLISION_REASON }],
+            freedBytes: 0,
+        };
+    }
+    if (!(await pathExists(legacyRoot))) {
+        return { status: 'absent', migrated: [], demolishedUnmappable: 0, failures: [], freedBytes: 0 };
+    }
+    const registry = options.registry ?? (await getRegistry());
+    const resolveDestination = options.resolveDestination ?? defaultResolveDestination;
+    const destinationMap = await buildDestinationMap(registry, resolveDestination);
+    const legacyProjectsDir = join(legacyRoot, 'data', 'projects');
+    const trustedProjectsDirReal = join(await realpathOrSelf(legacyRoot), 'data', 'projects');
+    const { migrated, demolishedUnmappable, failures, freedBytes: sweptBytes, } = await sweepLegacyProjectsDir(legacyProjectsDir, trustedProjectsDirReal, destinationMap);
+    if ((await remainingProjectEntryCount(legacyProjectsDir)) > 0) {
+        return { status: 'retained', migrated, demolishedUnmappable, failures, freedBytes: 0 };
+    }
+    const freedBytes = sweptBytes + (await directorySizeBytes(legacyRoot));
+    await rm(legacyRoot, { recursive: true, force: true });
+    return { status: 'demolished', migrated, demolishedUnmappable, failures, freedBytes };
+}
+//# sourceMappingURL=legacy-planu-demolisher.js.map