@planu/cli 5.6.0 → 5.7.1

package/CHANGELOG.md

@@ -1,3 +1,44 @@
+## [5.7.1] - 2026-08-31
+
+### Bug Fixes
+- fix(release): classify cherry-pick abort cleanup for reliability gate
+- fix(test): serialize validate-execute.branches and git-setup suites to avoid full-load spawn flakes
+- fix(test): pin reliability-gate suite in serial inventory snapshot
+- fix(test): mock reliability policies output in lifecycle e2e and serialize reliability-gate suite
+- fix: ignore and untrack runtime index backup files
+- fix: untrack runtime housekeeping history leaked by runtime migration
+- fix(test-infra): address SPEC-1707 review findings in spawn retry helper and lint
+- fix(detectors): resolve datastore claims from runtime dependencies only (SPEC-1700)
+- fix(test-infra): allowlist SPEC-1706 release harness spawner in child_process lint
+- fix(test-infra): add transient spawn retry classifier and child_process lint (SPEC-1707)
+- fix: address SPEC-1706 review findings in release.sh --abort repair
+- fix: repair buried phantom bump commits in release.sh --abort (SPEC-1706)
+- fix(validate): audit spec-declared files and dedupe reliability allowlist
+- fix(validate): run reliability gate on spec-listed files before done (SPEC-1705)
+- fix(storage): exclude atomic-write temp files and tolerate vanish races in inventoryStorageRoot
+- fix: retire completed canonical migration journal on unchanged roots (SPEC-1711)
+
+
+## [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":"04661e53067d139151a01671e92fec0f4f2ddfc1"}

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/detectors/cache-db-detector.js

@@ -1,5 +1,5 @@
 import { technologyValue } from '../technology-registry.js';
-import { collectDependencies, hasAnyFile } from '../detection-utils.js';
+import { collectRuntimeDependencies, hasAnyFile } from '../detection-utils.js';
 const VALKEY_DEPS = ['valkey', '@valkey/client', 'iovalkey'];
 const REDIS_DEPS = [
     technologyValue('technology-redis-34fb46'),
@@ -17,7 +17,7 @@ const REDIS_DEPS = [
 ];
 const MEMCACHED_DEPS = ['memcached', 'memcachier', 'pymemcache', 'gomemcache', 'memcache', 'dalli'];
 export async function detectCacheEngine(projectPath) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     // Valkey first (Redis fork — more specific)
     if (VALKEY_DEPS.some((d) => deps.has(d))) {
         return 'valkey';

package/dist/engine/detectors/newsql-db-detector.js

@@ -1,4 +1,4 @@
-import { collectDependencies } from '../detection-utils.js';
+import { collectRuntimeDependencies } from '../detection-utils.js';
 const PLANETSCALE_DEPS = ['@planetscale/database', 'planetscale-go'];
 const NEON_DEPS = ['@neondatabase/serverless', 'neon-serverless'];
 const SPANNER_DEPS = [
@@ -10,7 +10,7 @@ const ALLOYDB_DEPS = ['@google-cloud/alloydb', 'google-cloud-alloydb-connector']
 const COCKROACH_DEPS = ['cockroachdb', '@cockroachlabs/serverless'];
 const TIDB_DEPS = ['tidb', 'tidb-serverless', '@tidbcloud/serverless'];
 export async function detectNewSqlDb(projectPath) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     // PlanetScale (specific SDK)
     if (PLANETSCALE_DEPS.some((d) => deps.has(d))) {
         return 'planetscale';

package/dist/engine/detectors/search-engine-detector.js

@@ -1,4 +1,4 @@
-import { collectDependencies } from '../detection-utils.js';
+import { collectRuntimeDependencies } from '../detection-utils.js';
 const ALGOLIA_DEPS = [
     'algoliasearch',
     '@algolia/client-search',
@@ -25,7 +25,7 @@ const ELASTICSEARCH_DEPS = [
     'chewy',
 ];
 export async function detectSearchEngine(projectPath) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     // Algolia (most specific deps)
     if (ALGOLIA_DEPS.some((d) => deps.has(d))) {
         return 'algolia';

package/dist/engine/detectors/vector-db-detector.js

@@ -1,4 +1,4 @@
-import { collectDependencies } from '../detection-utils.js';
+import { collectRuntimeDependencies } from '../detection-utils.js';
 const PINECONE_DEPS = ['@pinecone-database/pinecone', 'pinecone-client', 'pinecone'];
 const WEAVIATE_DEPS = ['weaviate-client', 'weaviate-ts-client', 'weaviate'];
 const QDRANT_DEPS = ['@qdrant/js-client-rest', 'qdrant-client', 'qdrant_client'];
@@ -6,7 +6,7 @@ const MILVUS_DEPS = ['@zilliz/milvus2-sdk-node', 'pymilvus', 'milvus'];
 const CHROMA_DEPS = ['chromadb', 'chromadb-client'];
 const PGVECTOR_DEPS = ['pgvector', 'pgvector-node', 'pgvector-python'];
 export async function detectVectorDb(projectPath) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     if (PINECONE_DEPS.some((d) => deps.has(d))) {
         return 'pinecone';
     }

package/dist/engine/detectors/widecolumn-db-detector.js

@@ -1,4 +1,4 @@
-import { collectDependencies } from '../detection-utils.js';
+import { collectRuntimeDependencies } from '../detection-utils.js';
 const SCYLLA_DEPS = ['scylladb', '@scylladb/driver', 'scylla-driver'];
 const CASSANDRA_DEPS = [
     'cassandra-driver',
@@ -16,7 +16,7 @@ const CLICKHOUSE_DEPS = [
 ];
 const HBASE_DEPS = ['hbase', 'hbase-client', 'happybase', 'hbase-rpc-client'];
 export async function detectWideColumnDb(projectPath) {
-    const deps = await collectDependencies(projectPath);
+    const deps = await collectRuntimeDependencies(projectPath);
     // ScyllaDB (Cassandra-compatible but more specific)
     if (SCYLLA_DEPS.some((d) => deps.has(d))) {
         return 'scylladb';

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