@planu/cli 5.5.3 → 5.7.0

package/dist/engine/doc-generator/portal/portal-regenerator.d.ts

@@ -1,13 +1,18 @@
-import type { StoreType } from '../../../types/portal.js';
+import type { RegeneratedPortalPage, StoreType } from '../../../types/portal.js';
 /**
  * Schedule a debounced regeneration (500 ms window).
  * Multiple calls within the window are coalesced per project.
  */
 export declare function scheduleRegeneration(projectPath: string, changedStores: StoreType[]): void;
+/**
+ * SPEC-1695: Absolute path of a portal page's HTML output, under the
+ * per-project storage-layout cache directory (planu/.runtime/cache).
+ */
+export declare function portalPageOutputPath(projectPath: string, page: RegeneratedPortalPage): string;
 /**
  * Immediately regenerate all portal pages affected by the given store changes.
- * Creates planu/ directory if it does not exist.
- * Returns the list of page keys that were successfully written.
+ * Creates the storage-layout cache directory if it does not exist.
+ * Returns the absolute output paths of the pages that were successfully written.
  * Never throws.
  */
 export declare function regeneratePages(projectPath: string, changedStores: StoreType[]): Promise<string[]>;

package/dist/engine/doc-generator/portal/portal-regenerator.js

@@ -3,6 +3,8 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath } from '../../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1699
+import { projectRuntimeDir } from '../../../storage/storage-layout.js';
 import { getAffectedPages } from './dirty-flag-map.js';
 import { withAudit } from '../../../engine/autopilot/audit-logger.js';
 // Debounce state keyed by projectPath to avoid cross-project interference
@@ -30,16 +32,24 @@ export function scheduleRegeneration(projectPath, changedStores) {
     }, 500);
     debounceTimers.set(projectPath, timer);
 }
+/**
+ * SPEC-1695: Absolute path of a portal page's HTML output, under the
+ * per-project storage-layout cache directory (planu/.runtime/cache).
+ */
+export function portalPageOutputPath(projectPath, page) {
+    const filename = page === 'index' ? 'index.html' : `${page}.html`;
+    return join(projectRuntimeDir(projectPath, 'cache'), filename);
+}
 /**
  * Immediately regenerate all portal pages affected by the given store changes.
- * Creates planu/ directory if it does not exist.
- * Returns the list of page keys that were successfully written.
+ * Creates the storage-layout cache directory if it does not exist.
+ * Returns the absolute output paths of the pages that were successfully written.
  * Never throws.
  */
 export async function regeneratePages(projectPath, changedStores) {
-    const planuDir = join(projectPath, 'planu');
+    const cacheDir = projectRuntimeDir(projectPath, 'cache');
     try {
-        await mkdir(planuDir, { recursive: true });
+        await mkdir(cacheDir, { recursive: true });
     }
     catch {
         return [];
@@ -51,10 +61,9 @@ export async function regeneratePages(projectPath, changedStores) {
             await withAudit(projectPath, 'portal_regeneration', `regeneratePage(${page})`, async () => {
                 const html = await generatePage(projectPath, page);
                 if (html) {
-                    const filename = page === 'index' ? 'index.html' : `${page}.html`;
-                    const filePath = join(planuDir, filename);
+                    const filePath = portalPageOutputPath(projectPath, page);
                     await writeFile(filePath, html, 'utf-8');
-                    regenerated.push(page);
+                    regenerated.push(filePath);
                 }
             });
         }

package/dist/engine/evidence-gates/evidence-autofill.d.ts

@@ -1,6 +1,6 @@
 import type { AutofillTraceabilityMatrixArgs, AutofillTraceabilityMatrixResult } from '../../types/evidence-autofill.js';
 /** Exact Planu lifecycle files every spec branch mutates; never counted as implementation drift. */
-export declare const PLANU_BOOKKEEPING_FILES: readonly ['planu/context.md', 'planu/session-context.md', 'planu/session.json', 'planu/status.json', 'planu/releases/pending.json', 'planu/conventions.json'];
+export declare const PLANU_BOOKKEEPING_FILES: readonly ['planu/context.md', 'planu/session-context.md', 'planu/session.json', 'planu/status.json', 'planu/project.json', 'planu/conventions.json'];
 /** Normalizes a spec.md path (absolute or already repo-relative) to a repo-relative,
  * forward-slash path so it can be compared against `git diff` output. */
 export declare function toRepoRelativePath(specPath: string, projectPath?: string): string;

package/dist/engine/evidence-gates/evidence-autofill.js

@@ -42,7 +42,7 @@ export const PLANU_BOOKKEEPING_FILES = [
     'planu/session-context.md',
     'planu/session.json',
     'planu/status.json',
-    'planu/releases/pending.json',
+    'planu/project.json',
     'planu/conventions.json',
 ];
 const OTHER_SPEC_MD_PATTERN = /^planu\/specs\/[^/]+\/spec\.md$/;

package/dist/engine/framework-detector.js

@@ -1,7 +1,7 @@
 import { technologyValue } from './technology-registry.js';
 // Planu — Framework, ORM, and database detection
 import { join } from 'node:path';
-import { fileExists, hasAnyFile, collectDependencies, readJsonFile } from './detection-utils.js';
+import { fileExists, hasAnyFile, collectDependencies, collectRuntimeDependencies, readJsonFile, } from './detection-utils.js';
 /**
  * Detect the primary framework from indicator files and dependencies.
  */
@@ -14,8 +14,9 @@ export async function detectFramework(projectPath, signatures) {
             }
         }
     }
-    // Check dependencies
-    const deps = await collectDependencies(projectPath);
+    // Check runtime dependencies only — a framework declared solely in
+    // devDependencies is tooling, not the project's runtime stack.
+    const deps = await collectRuntimeDependencies(projectPath);
     for (const [fw, sig] of Object.entries(signatures.frameworks)) {
         for (const dep of sig.dependencies) {
             if (deps.has(dep)) {
@@ -55,9 +56,9 @@ export async function detectFrameworkVersion(projectPath, framework, signatures)
  * Detect the database engine from indicator files and dependencies.
  */
 export async function detectDatabase(projectPath, signatures) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     for (const [, sig] of Object.entries(signatures.databases)) {
-        // Check indicator files
+        // Check indicator files (migration dirs, connection configs)
         for (const indicator of sig.indicators) {
             if (await hasAnyFile(projectPath, [indicator])) {
                 if (isKnownEngine(sig.engine)) {
@@ -65,7 +66,8 @@ export async function detectDatabase(projectPath, signatures) {
                 }
             }
         }
-        // Check dependencies
+        // Check runtime dependencies only — a driver declared solely in
+        // devDependencies never produces a Database claim.
         for (const dep of sig.dependencies) {
             if (deps.has(dep)) {
                 if (isKnownEngine(sig.engine)) {

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/history-log.d.ts

@@ -1,4 +1,5 @@
 import type { HousekeepingHistoryEntry } from '../../types/housekeeping.js';
 export declare function housekeepingHistoryPath(projectPath: string): string;
+export declare function migrateLegacyHousekeepingHistory(projectPath: string): Promise<string | null>;
 export declare function appendHousekeepingEntry(projectPath: string, input: Omit<HousekeepingHistoryEntry, 'id' | 'deletedAt' | 'prevSha' | 'sha256'>): Promise<HousekeepingHistoryEntry>;
 //# sourceMappingURL=history-log.d.ts.map

package/dist/engine/housekeeping/history-log.js

@@ -1,14 +1,68 @@
 // engine/housekeeping/history-log.ts — SPEC-751
 // Hash-chained JSONL backup log for deleted housekeeping items.
 // Mirrors the SPEC-723/734 transition-log pattern for recoverability.
+import { existsSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
-import { appendFile, readFile, mkdir } from 'node:fs/promises';
+import { appendFile, readFile, mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1699
+import { projectRuntimeDir } from '../../storage/storage-layout.js';
 // ---------------------------------------------------------------------------
-// Path helper
+// Path helpers
 // ---------------------------------------------------------------------------
+const HISTORY_FILENAME = '.housekeeping-history.jsonl';
 export function housekeepingHistoryPath(projectPath) {
-    return join(projectPath, 'planu', '.housekeeping-history.jsonl');
+    return join(projectRuntimeDir(projectPath, 'state'), HISTORY_FILENAME);
+}
+function legacyHousekeepingHistoryPath(projectPath) {
+    return join(projectPath, 'planu', HISTORY_FILENAME);
+}
+/**
+ * SPEC-1695: One-time migration of the legacy planu/.housekeeping-history.jsonl
+ * into the storage-layout location. Copies content, verifies it round-tripped,
+ * then deletes the legacy file. Idempotent — a missing legacy file or an
+ * already-populated new file is a no-op.
+ * Returns the legacy path when a migration happened, otherwise null.
+ */
+function entryId(line) {
+    try {
+        return JSON.parse(line).id ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function jsonlLines(content) {
+    return content.split('\n').filter((line) => line.trim().length > 0);
+}
+export async function migrateLegacyHousekeepingHistory(projectPath) {
+    const legacyPath = legacyHousekeepingHistoryPath(projectPath);
+    const newPath = housekeepingHistoryPath(projectPath);
+    if (!existsSync(legacyPath)) {
+        return null;
+    }
+    const legacyContent = await readFile(legacyPath, 'utf-8');
+    if (!existsSync(newPath)) {
+        await mkdir(dirname(newPath), { recursive: true });
+        await writeFile(newPath, legacyContent, 'utf-8');
+        const verified = await readFile(newPath, 'utf-8');
+        if (verified !== legacyContent) {
+            throw new Error('[Planu] housekeeping history migration verification failed');
+        }
+        await rm(legacyPath, { force: true });
+        return legacyPath;
+    }
+    const destinationContent = await readFile(newPath, 'utf-8');
+    const destinationIds = new Set(jsonlLines(destinationContent).map(entryId));
+    const missingLines = jsonlLines(legacyContent).filter((line) => {
+        const id = entryId(line);
+        return id === null || !destinationIds.has(id);
+    });
+    if (missingLines.length > 0) {
+        await appendFile(newPath, missingLines.map((line) => `${line}\n`).join(''), 'utf-8');
+    }
+    await rm(legacyPath, { force: true });
+    return legacyPath;
 }
 // ---------------------------------------------------------------------------
 // Hash chain helpers
@@ -47,6 +101,7 @@ async function readLastSha(filePath) {
     }
 }
 async function doAppend(filePath, input) {
+    await migrateLegacyHousekeepingHistory(input.projectPath);
     await mkdir(dirname(filePath), { recursive: true });
     const prevSha = await readLastSha(filePath);
     const partial = {

package/dist/engine/housekeeping/index.d.ts

@@ -2,7 +2,8 @@ export { findStaleBranches } from './find-stale-branches.js';
 export { findStaleWorktrees } from './find-stale-worktrees.js';
 export { findStaleStashes } from './find-stale-stashes.js';
 export { runHousekeepingSweep } from './sweep-runner.js';
-export { appendHousekeepingEntry, housekeepingHistoryPath } from './history-log.js';
+export { appendHousekeepingEntry, housekeepingHistoryPath, migrateLegacyHousekeepingHistory, } from './history-log.js';
+export { sweepRuntimeResidue } from './runtime-residue-sweep.js';
 export { cleanOrphanBrainstormingMarkdowns } from './orphan-brainstorming-cleaner.js';
 export { cleanEphemeralArtifacts } from './ephemeral-artifacts-cleaner.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/housekeeping/index.js

@@ -4,7 +4,8 @@ export { findStaleBranches } from './find-stale-branches.js';
 export { findStaleWorktrees } from './find-stale-worktrees.js';
 export { findStaleStashes } from './find-stale-stashes.js';
 export { runHousekeepingSweep } from './sweep-runner.js';
-export { appendHousekeepingEntry, housekeepingHistoryPath } from './history-log.js';
+export { appendHousekeepingEntry, housekeepingHistoryPath, migrateLegacyHousekeepingHistory, } from './history-log.js';
+export { sweepRuntimeResidue } from './runtime-residue-sweep.js';
 export { cleanOrphanBrainstormingMarkdowns } from './orphan-brainstorming-cleaner.js';
 export { cleanEphemeralArtifacts } from './ephemeral-artifacts-cleaner.js';
 //# sourceMappingURL=index.js.map

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

package/dist/engine/housekeeping/runtime-residue-sweep.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeResidueSweepResult } from '../../types/housekeeping.js';
+/**
+ * Delete every legacy runtime-residue path from planu/ without ever touching
+ * canonicalRootFiles / canonicalRootDirs. Idempotent — a checkout with no
+ * residue returns an empty removed list. Wired into init_project and the
+ * session-start housekeeping path so existing client checkouts self-heal.
+ */
+export declare function sweepRuntimeResidue(projectPath: string): Promise<RuntimeResidueSweepResult>;
+//# sourceMappingURL=runtime-residue-sweep.d.ts.map

package/dist/engine/housekeeping/runtime-residue-sweep.js

@@ -0,0 +1,57 @@
+// engine/housekeeping/runtime-residue-sweep.ts — SPEC-1695
+// Removes legacy runtime artifacts that PLANU_CANONICAL_POLICY already
+// classifies as regenerable (generatedRuntimePatterns), so a client checkout
+// self-heals on init_project / session start instead of accumulating residue.
+import { rm } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { glob } from 'glob';
+import { PLANU_CANONICAL_POLICY, isCanonicalPlanuRootFile, } from '../spec-migrator/planu-canonical-policy.js';
+import { migrateLegacyHousekeepingHistory } from './history-log.js';
+const HOUSEKEEPING_HISTORY_PATTERN = 'planu/.housekeeping-history.jsonl';
+const RUNTIME_HOME_TOP_DIR = PLANU_CANONICAL_POLICY.runtimeHomeDir
+    .replace(/^planu\//, '')
+    .replace(/\/$/, '');
+function isProtectedPath(planuDir, absolutePath) {
+    const rel = relative(planuDir, absolutePath);
+    if (rel === '' || rel.startsWith('..')) {
+        return true;
+    }
+    const top = rel.split(sep)[0] ?? '';
+    if (isCanonicalPlanuRootFile(top)) {
+        return true;
+    }
+    return top === RUNTIME_HOME_TOP_DIR || rel === 'releases' || rel === 'specs';
+}
+async function removeMatches(projectPath, pattern) {
+    const planuDir = join(projectPath, 'planu');
+    const relativePattern = pattern.replace(/^planu\//, '').replace(/\/$/, '');
+    const matches = await glob(relativePattern, { cwd: planuDir, dot: true, absolute: true });
+    const removed = [];
+    for (const absolutePath of matches) {
+        if (isProtectedPath(planuDir, absolutePath)) {
+            continue;
+        }
+        await rm(absolutePath, { recursive: true, force: true });
+        removed.push(absolutePath);
+    }
+    return removed;
+}
+/**
+ * Delete every legacy runtime-residue path from planu/ without ever touching
+ * canonicalRootFiles / canonicalRootDirs. Idempotent — a checkout with no
+ * residue returns an empty removed list. Wired into init_project and the
+ * session-start housekeeping path so existing client checkouts self-heal.
+ */
+export async function sweepRuntimeResidue(projectPath) {
+    const removed = [];
+    const patterns = PLANU_CANONICAL_POLICY.generatedRuntimePatterns.filter((pattern) => pattern !== HOUSEKEEPING_HISTORY_PATTERN);
+    for (const pattern of patterns) {
+        removed.push(...(await removeMatches(projectPath, pattern)));
+    }
+    const migratedHistoryPath = await migrateLegacyHousekeepingHistory(projectPath);
+    if (migratedHistoryPath) {
+        removed.push(migratedHistoryPath);
+    }
+    return { removed };
+}
+//# sourceMappingURL=runtime-residue-sweep.js.map