@planu/cli 5.5.3 → 5.7.0

package/CHANGELOG.md

@@ -1,3 +1,61 @@
+## [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
+- feat(init-project): regenerate conventions.md from folded conventions.json (SPEC-1699)
+- feat(init-project): fold legacy planu/ root artifacts on update (SPEC-1699)
+- feat(init-project): gitignore legacy planu/ root files (SPEC-1699)
+- feat(create-spec): refresh the regenerable spec index after writing spec.md (SPEC-1699)
+- feat(storage): add regenerable spec.md index (SPEC-1699)
+
+### Bug Fixes
+- fix(test): reconcile suites with SPEC-1699 runtime relocation and serialize frozen-lockfile suite
+- fix(storage): classify retention and current-project catch degradations
+- fix(release): require the exact tsgo package dir, not any node_modules content
+- fix(release): drop CI=true from frozen-lockfile install, probe tsgo native package
+- fix(SPEC-1696): accept inline YAML arrays for scenario tests in frontmatter
+- fix(storage): close retention review gaps from Codex CHANGES_REQUIRED
+- fix(storage): enforce retention budgets on runtime storage writers
+- fix(SPEC-1694): report the actual test runner instead of Unknown
+- fix(SPEC-1694): promote framework/database claims only from runtime dependencies
+- fix: parse ordered-list markers in BDD criteria extraction (SPEC-1688)
+- fix: repair release-gate collateral fallout from SPEC-1699 fold (blocker 6 sweep)
+- fix: release.sh repoints version marker to planu/project.json (SPEC-1699 blocker 6)
+- fix: reconcile-release-pending falls back to legacy pending.json (SPEC-1699 blocker 4)
+- fix: legacy-root-migration idempotency and fail-safe malformed handling (SPEC-1699 blocker 3)
+- fix: append-releases fails closed on ledger errors (SPEC-1699 blocker 5)
+- fix: verify spec.md digest at the spec-store read choke point (SPEC-1699 blocker 2)
+- fix(housekeeping): protect planu/.runtime as the canonical runtime home (SPEC-1699)
+- fix: address implementation-review blockers for SPEC-1695 runtime relocation
+- fix: reroute default proposal/export/docs-site outputs to planu/.runtime (SPEC-1695)
+- fix: relocate runtime artifacts to planu/.runtime (SPEC-1695)
+
+### Refactoring
+- refactor(release): fold pending release ledger into planu/project.json (SPEC-1699)
+- refactor: relocate session.json and session-context.md under planu/.runtime (SPEC-1699)
+- refactor: route spec resources through the current-project spec index (SPEC-1699)
+- refactor: canonical planu/ set shrinks to project.json + specs/ (SPEC-1699)
+
+
 ## [5.5.3] - 2026-08-30
 
 ### Bug Fixes

package/dist/.planu-build.json

@@ -1 +1 @@
-{"schemaVersion":1,"commit":"5060255598e14cab792b6b5b0d75a077f23fe018"}
+{"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/autopilot/bootstrap.js

@@ -52,7 +52,7 @@ function registerImplementingCascadeListener() {
     });
 }
 // SPEC-649: registerDoneCascadeListener (optimize_context on done) removed — cascade reduced to
-// exactly 2 actions: session.json update + releases/pending.json append.
+// exactly 2 actions: session.json update + project.json releases append.
 /**
  * SPEC-628: Fire-and-forget auto_fix_health on cron:daily.
  * Moved from update_status(done) cascade to reduce latency on done transitions.

package/dist/engine/cascade-hooks/core/append-releases.js

@@ -35,13 +35,17 @@ export function normalizePendingReleaseEntries(value) {
         throw new Error('Pending release ledger is not an array');
     }
     const deduped = new Map();
+    const preserved = [];
     for (const entry of value) {
         if (!isValidPendingReleaseEntry(entry) || !hasParsableCompletionDate(entry)) {
+            // Unknown/invalid shape: never silently drop ledger data — pass it
+            // through verbatim so a human can inspect and fix it later.
+            preserved.push(entry);
             continue;
         }
         deduped.set(entry.specId, entry);
     }
-    return [...deduped.values()];
+    return [...preserved, ...deduped.values()];
 }
 export function reconcilePublishedPendingEntries(entries, release, isCommitReachable = requireIsCommitReachable) {
     if (!release) {
@@ -78,16 +82,23 @@ async function captureHeadCommit(projectPath) {
         return undefined;
     }
 }
+function extractReleasesField(parsedProject) {
+    return parsedProject !== null &&
+        typeof parsedProject === 'object' &&
+        !Array.isArray(parsedProject)
+        ? parsedProject.releases
+        : undefined;
+}
 async function rewritePendingLedger(input) {
     let pendingList = [];
     try {
-        const raw = await readFile(input.pendingPath, 'utf-8');
-        pendingList = normalizePendingReleaseEntries(JSON.parse(raw));
+        const raw = await readFile(input.projectJsonPath, 'utf-8');
+        pendingList = normalizePendingReleaseEntries(extractReleasesField(JSON.parse(raw)) ?? []);
     }
     catch (error) {
         if (error.code !== 'ENOENT') {
             reportClassifiedDegradation('PENDING_RELEASE_LEDGER_UNREADABLE', error);
-            return;
+            throw error instanceof Error ? error : new Error(String(error));
         }
     }
     pendingList = reconcilePublishedPendingEntries(pendingList, input.releaseInfo, input.isCommitReachable).filter((entry) => entry.specId !== input.specId);
@@ -97,7 +108,7 @@ async function rewritePendingLedger(input) {
         completedAt: new Date().toISOString().substring(0, 10),
         ...(input.implementationCommit ? { implementationCommit: input.implementationCommit } : {}),
     });
-    await input.writePendingReleaseLedger(input.pendingPath, pendingList);
+    await input.writePendingReleaseLedger(input.projectJsonPath, pendingList);
 }
 async function actuallyAppendReleasesPending(ctx, opts) {
     const { projectPath, projectId, specId } = ctx;
@@ -116,19 +127,19 @@ async function actuallyAppendReleasesPending(ctx, opts) {
         return;
     }
     const { isCommitReachable, resolveLatestReleaseTag, withPendingReleaseLock, writePendingReleaseLedger, } = helpers;
-    const releasesDir = join(projectPath, 'planu', 'releases');
-    const pendingPath = join(releasesDir, 'pending.json');
+    const planuDir = join(projectPath, 'planu');
+    const projectJsonPath = join(planuDir, 'project.json');
     await new Promise((resolve, reject) => {
         opts.signal.addEventListener('abort', () => {
             reject(new Error('CoreActionTimeoutError: append-releases-pending timed out'));
         });
         (async () => {
-            await mkdir(releasesDir, { recursive: true });
+            await mkdir(planuDir, { recursive: true });
             const spec = await specStore.getSpec(projectId, specId);
             const releaseInfo = await resolveLatestReleaseTag(projectPath);
             const implementationCommit = await captureHeadCommit(projectPath);
-            await withPendingReleaseLock(pendingPath, { timeoutMs: 1_500, signal: opts.signal }, () => rewritePendingLedger({
-                pendingPath,
+            await withPendingReleaseLock(projectJsonPath, { timeoutMs: 1_500, signal: opts.signal }, () => rewritePendingLedger({
+                projectJsonPath,
                 specId,
                 title: spec?.title ?? specId,
                 implementationCommit,
@@ -150,8 +161,7 @@ async function actuallyAppendReleasesPending(ctx, opts) {
             resolve();
         })
             .catch((err) => {
-            void err; // best-effort — surface as result, not throw
-            resolve();
+            reject(err instanceof Error ? err : new Error(String(err)));
         });
     });
 }

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/detection-utils.d.ts

@@ -4,6 +4,7 @@ export { fileExists };
 declare const IGNORE_DIRS: string[];
 export declare function hasAnyFile(basePath: string, patterns: string[]): Promise<boolean>;
 export declare function collectDependencies(projectPath: string): Promise<Set<string>>;
+export declare function collectRuntimeDependencies(projectPath: string): Promise<Set<string>>;
 export declare function loadStackSignatures(): Promise<StackSignatures>;
 export declare function loadArchPatterns(): Promise<ArchPatternsFile>;
 export declare function readJsonFile(filePath: string): Promise<Record<string, unknown> | null>;

package/dist/engine/detection-utils.js

@@ -53,6 +53,17 @@ export async function collectDependencies(projectPath) {
     await collectPhpDeps(projectPath, deps);
     return deps;
 }
+export async function collectRuntimeDependencies(projectPath) {
+    const deps = new Set();
+    await collectNodeRuntimeDeps(projectPath, deps);
+    await collectPythonRequirements(projectPath, deps);
+    await collectPyprojectDeps(projectPath, deps);
+    await collectGoDeps(projectPath, deps);
+    await collectRubyDeps(projectPath, deps);
+    await collectRustDeps(projectPath, deps);
+    await collectPhpRuntimeDeps(projectPath, deps);
+    return deps;
+}
 async function collectNodeDeps(projectPath, deps) {
     try {
         const pkgJson = JSON.parse(await readFile(join(projectPath, 'package.json'), 'utf-8'));
@@ -67,6 +78,17 @@ async function collectNodeDeps(projectPath, deps) {
         // No package.json
     }
 }
+async function collectNodeRuntimeDeps(projectPath, deps) {
+    try {
+        const pkgJson = JSON.parse(await readFile(join(projectPath, 'package.json'), 'utf-8'));
+        for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+            deps.add(dep);
+        }
+    }
+    catch {
+        // No package.json
+    }
+}
 async function collectPythonRequirements(projectPath, deps) {
     try {
         const content = await readFile(join(projectPath, 'requirements.txt'), 'utf-8');
@@ -181,6 +203,17 @@ async function collectPhpDeps(projectPath, deps) {
         // No composer.json
     }
 }
+async function collectPhpRuntimeDeps(projectPath, deps) {
+    try {
+        const composerJson = JSON.parse(await readFile(join(projectPath, 'composer.json'), 'utf-8'));
+        for (const dep of Object.keys(composerJson.require ?? {})) {
+            deps.add(dep);
+        }
+    }
+    catch {
+        // No composer.json
+    }
+}
 export async function loadStackSignatures() {
     try {
         const configPath = new URL('../config/stack-signatures.json', import.meta.url);

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

@@ -16,7 +16,7 @@ export { computeVelocity } from './data-aggregators/velocity-aggregator.js';
 export { computeBurndown } from './data-aggregators/burndown-aggregator.js';
 export { detectBottlenecks } from './data-aggregators/bottleneck-detector.js';
 export { computeAccuracy } from './data-aggregators/accuracy-aggregator.js';
-export { scheduleRegeneration, regeneratePages } from './portal-regenerator.js';
+export { scheduleRegeneration, regeneratePages, portalPageOutputPath, } from './portal-regenerator.js';
 export { notifyStoreChange } from './regen-hook.js';
 export { getAffectedPages } from './dirty-flag-map.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -19,7 +19,7 @@ export { computeBurndown } from './data-aggregators/burndown-aggregator.js';
 export { detectBottlenecks } from './data-aggregators/bottleneck-detector.js';
 export { computeAccuracy } from './data-aggregators/accuracy-aggregator.js';
 // SPEC-146 — Auto-regeneration on store changes
-export { scheduleRegeneration, regeneratePages } from './portal-regenerator.js';
+export { scheduleRegeneration, regeneratePages, portalPageOutputPath, } from './portal-regenerator.js';
 export { notifyStoreChange } from './regen-hook.js';
 export { getAffectedPages } from './dirty-flag-map.js';
 //# sourceMappingURL=index.js.map