@planu/cli 4.13.0 → 5.0.0

package/dist/engine/spec-source-sync.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/spec-source-sync.ts — Spec-as-Source sync logic (SPEC-349)
 import { readFile } from 'node:fs/promises';
 // ---------------------------------------------------------------------------
@@ -26,9 +27,9 @@ export function detectMarkers(content) {
 export function detectLanguage(filePath) {
     const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
     const MAP = {
-        ts: 'typescript',
+        ts: technologyValue('technology-typescript-969545'),
         js: 'javascript',
-        tsx: 'typescript',
+        tsx: technologyValue('technology-typescript-969545'),
         jsx: 'javascript',
         py: 'python',
         rb: 'ruby',

package/dist/engine/spec-state-machine/transition-spec.d.ts

@@ -2,7 +2,7 @@ import type { Spec, SpecStatus } from '../../types/index.js';
 /**
  * Why this transition is happening — surfaces in audit-trail and transition_log.
  */
-export type TransitionTrigger = 'user' | 'auto-advance' | 'git-merge' | 'fs-hook' | 'sync-spec-state' | 'multi-teammate-review' | 'http' | 'dashboard' | 'reopen';
+export type TransitionTrigger = 'user' | 'auto-advance' | 'git-merge' | 'fs-hook' | 'sync-spec-state' | 'multi-teammate-review' | 'http' | 'dashboard' | 'reopen' | 'reconciliation';
 export interface TransitionContext {
     /** Why this transition is happening. */
     trigger: TransitionTrigger;
@@ -16,6 +16,11 @@ export interface TransitionContext {
     updates?: Omit<Partial<Spec>, 'status'>;
     /** Optional work scheduled after the durable transition boundary. */
     pendingBackgroundActions?: readonly string[];
+    /** Opaque binding to the selected root for post-commit recovery. */
+    transitionRootBinding?: string;
+    /** Dedicated recovery transaction binding persisted with its status entry. */
+    reconciliationRequestId?: string;
+    reconciliationBindingDigest?: string;
     /** Snapshot used by lifecycle gates; the store rejects intervening mutations. */
     expectedSpec?: Spec;
 }

package/dist/engine/spec-state-machine/transition-spec.js

@@ -20,7 +20,16 @@ export async function transitionSpec(projectId, specId, newStatus, ctx) {
         throw new Error(`Spec ${specId} not found in project ${projectId}`);
     }
     // Use the internal-only write path that bypasses the status guard
-    const after = await specStore.__internalSetStatus(projectId, specId, newStatus, ctx.updates, ctx.pendingBackgroundActions, { status: before.status, updatedAt: before.updatedAt });
+    const reconciliation = ctx.reconciliationRequestId === undefined
+        ? undefined
+        : {
+            reconciliationRequestId: ctx.reconciliationRequestId,
+            reconciliationBindingDigest: ctx.reconciliationBindingDigest,
+            trigger: ctx.trigger,
+        };
+    const after = reconciliation
+        ? await specStore.__internalSetStatus(projectId, specId, newStatus, ctx.updates, ctx.pendingBackgroundActions, { status: before.status, updatedAt: before.updatedAt }, ctx.transitionRootBinding, reconciliation)
+        : await specStore.__internalSetStatus(projectId, specId, newStatus, ctx.updates, ctx.pendingBackgroundActions, { status: before.status, updatedAt: before.updatedAt }, ctx.transitionRootBinding);
     const receipt = after.statusHistory?.at(-1);
     if (!receipt?.transitionId) {
         throw new Error(`Transition receipt was not persisted for ${specId}`);

package/dist/engine/spec-templates/custom-loader.js

@@ -4,6 +4,7 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
+import { resolvedStorageArtifactPath } from '../../storage/storage-catalog.js';
 /** Zod schema for validating custom template JSON files. */
 const templateVariableSchema = z.object({
     key: z.string().min(1),
@@ -53,14 +54,12 @@ const customTemplateSchema = z.object({
     fichaTecnicaTemplate: z.string().min(1),
     progressTemplate: z.string().min(1),
 });
-/** Default directory for custom user templates. */
-const CUSTOM_TEMPLATES_DIR = 'data/global/spec-templates/custom';
 /**
  * Loads custom templates from a directory. Each .json file is validated.
  * Malformed files generate warnings but do not block loading of other templates.
  */
 export async function loadCustomTemplates(baseDir) {
-    const dir = baseDir ?? CUSTOM_TEMPLATES_DIR;
+    const dir = baseDir ?? resolvedStorageArtifactPath('custom-spec-templates');
     const templates = [];
     const warnings = [];
     let files;

package/dist/engine/spec-templates/templates-domain-specific.js

@@ -1,7 +1,4 @@
-// engine/spec-templates/templates-domain-specific.ts — Domain-specific spec templates A (SPEC-513).
-// Auth login, auth OAuth, Stripe payment, and CRUD resource templates.
-// Templates 5-8 (REST API integration, webhook, file upload, background job) are in
-// templates-domain-specific-b.ts.
+import { technologyValue } from '../technology-registry.js';
 import { REST_API_INTEGRATION_TEMPLATE, WEBHOOK_CONSUMER_TEMPLATE, FILE_UPLOAD_TEMPLATE, BACKGROUND_JOB_TEMPLATE, } from './templates-domain-specific-b.js';
 export { REST_API_INTEGRATION_TEMPLATE, WEBHOOK_CONSUMER_TEMPLATE, FILE_UPLOAD_TEMPLATE, BACKGROUND_JOB_TEMPLATE, };
 /** Auth Login spec template — credential validation, session, rate limiting, lockout. */
@@ -223,7 +220,13 @@ export const STRIPE_PAYMENT_TEMPLATE = {
     name: 'Stripe Payment',
     category: 'integration',
     description: 'Stripe checkout sessions, webhook signature verification, refunds, and failed payment retry.',
-    tags: ['payments', 'stripe', 'webhook', 'idempotency', 'backend'],
+    tags: [
+        'payments',
+        technologyValue('technology-stripe-2bed20'),
+        'webhook',
+        'idempotency',
+        'backend',
+    ],
     complexityScore: 'M',
     estimationBase: {
         hoursMin: 20,

package/dist/engine/spec-templates/templates-perf-integration.js

@@ -1,5 +1,4 @@
-// engine/spec-templates/templates-perf-integration.ts — Performance + third-party integration templates.
-// Extracted from catalog-extra.ts to keep file sizes within limits.
+import { technologyValue } from '../technology-registry.js';
 /** Performance optimization spec template. */
 export const PERFORMANCE_OPTIMIZATION_TEMPLATE = {
     id: 'performance-optimization',
@@ -139,7 +138,7 @@ export const THIRD_PARTY_INTEGRATION_TEMPLATE = {
             key: 'ServiceName',
             label: 'Service name',
             description: 'Name of the external service to integrate',
-            example: 'Stripe',
+            example: technologyValue('technology-stripe-961a60'),
             required: true,
         },
         {

package/dist/engine/stack-auditor/manifest-reader.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // manifest-reader.ts — Reads project manifest files (SPEC-041)
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';

package/dist/engine/staleness/stale-implementing.js

@@ -5,7 +5,7 @@
 import { readFile, access, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { constants } from 'node:fs';
-import { hashProjectPath } from '../../storage/base-store.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -18,8 +18,8 @@ async function fileExists(p) {
         return false;
     }
 }
-async function getLastTransitionForSpec(projectPath, projectId, specId) {
-    const logPath = join(projectPath, 'planu', 'data', 'projects', projectId, 'transition-log.jsonl');
+async function getLastTransitionForSpec(projectId, specId) {
+    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
     try {
         const raw = await readFile(logPath, 'utf-8');
         const lines = raw.trim().split('\n').filter(Boolean);
@@ -47,8 +47,8 @@ async function getLastTransitionForSpec(projectPath, projectId, specId) {
         return null;
     }
 }
-async function getDaysInImplementing(projectPath, projectId, specId) {
-    const logPath = join(projectPath, 'planu', 'data', 'projects', projectId, 'transition-log.jsonl');
+async function getDaysInImplementing(projectId, specId) {
+    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
     try {
         const raw = await readFile(logPath, 'utf-8');
         const lines = raw.trim().split('\n').filter(Boolean);
@@ -120,8 +120,8 @@ export async function findStaleImplementing(params) {
             // No specs dir
         }
         const hasProgress = specDir !== null && (await fileExists(join(specDir, 'progress.md')));
-        const daysInStatus = await getDaysInImplementing(projectPath, projectId, spec.id);
-        const lastTransition = await getLastTransitionForSpec(projectPath, projectId, spec.id);
+        const daysInStatus = await getDaysInImplementing(projectId, spec.id);
+        const lastTransition = await getLastTransitionForSpec(projectId, spec.id);
         if (daysInStatus >= daysThreshold || daysInStatus === -1) {
             results.push({
                 specId: spec.id,

package/dist/engine/tdd-scaffold-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/tdd-scaffold-generator.ts — SPEC-323
 // Generates TDD scaffold (failing test stubs + impl skeleton) from spec ACs.
 import { readFile } from 'node:fs/promises';
@@ -41,11 +42,11 @@ async function detectFramework(projectPath) {
             ...(pkg.dependencies ?? {}),
             ...(pkg.devDependencies ?? {}),
         };
-        if ('vitest' in deps) {
-            return 'vitest';
+        if (technologyValue('technology-vitest-a9127f') in deps) {
+            return technologyValue('technology-vitest-a9127f');
         }
-        if ('jest' in deps) {
-            return 'jest';
+        if (technologyValue('technology-jest-35e99f') in deps) {
+            return technologyValue('technology-jest-35e99f');
         }
         if ('mocha' in deps) {
             return 'mocha';
@@ -56,7 +57,7 @@ async function detectFramework(projectPath) {
         // Check for Python or Java markers
         const setup = await readFile(join(projectPath, 'setup.py'), 'utf8').catch(() => null);
         if (setup !== null) {
-            return 'pytest';
+            return technologyValue('technology-pytest-2b0121');
         }
         const pom = await readFile(join(projectPath, 'pom.xml'), 'utf8').catch(() => null);
         if (pom !== null) {
@@ -174,13 +175,13 @@ function buildJunitContent(stubs) {
 }
 function buildTestContent(stubs, framework) {
     switch (framework) {
-        case 'vitest':
+        case technologyValue('technology-vitest-a9127f'):
             return buildVitestContent(stubs);
-        case 'jest':
+        case technologyValue('technology-jest-35e99f'):
             return buildJestContent(stubs);
         case 'mocha':
             return buildMochaContent(stubs);
-        case 'pytest':
+        case technologyValue('technology-pytest-2b0121'):
             return buildPytestContent(stubs);
         case 'junit':
             return buildJunitContent(stubs);
@@ -223,9 +224,21 @@ export async function generateTddScaffold(specPath, projectPath) {
         testName: criterionToTestName(criterion),
         framework,
     }));
-    const ext = framework === 'pytest' ? 'py' : framework === 'junit' ? 'java' : 'ts';
-    const testExt = framework === 'pytest' ? '_test.py' : framework === 'junit' ? 'Test.java' : '.test.ts';
-    const testDir = framework === 'pytest' ? 'tests' : framework === 'junit' ? 'src/test' : 'tests';
+    const ext = framework === technologyValue('technology-pytest-2b0121')
+        ? 'py'
+        : framework === 'junit'
+            ? 'java'
+            : 'ts';
+    const testExt = framework === technologyValue('technology-pytest-2b0121')
+        ? '_test.py'
+        : framework === 'junit'
+            ? 'Test.java'
+            : '.test.ts';
+    const testDir = framework === technologyValue('technology-pytest-2b0121')
+        ? 'tests'
+        : framework === 'junit'
+            ? 'src/test'
+            : 'tests';
     const testFilePath = join(projectPath, testDir, `${slug}${testExt}`);
     const implFilePath = join(projectPath, 'src', `${slug}.${ext}`);
     const testContent = buildTestContent(stubs, framework);

package/dist/engine/teammate-router/green-phase-verifier.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/teammate-router/green-phase-verifier.ts — SPEC-750
 // Verifies green phase: tests pass AND none of the red tests were deleted.
 import { execFile as execFileCb } from 'node:child_process';
@@ -24,7 +25,7 @@ export async function verifyGreenPhase(redHandoff, projectRoot) {
     // Step 2: Run the tests and expect them to pass now
     try {
         const testArgs = ['--pool=forks', ...redHandoff.testFiles];
-        await execFile('npx', ['vitest', 'run', ...testArgs], {
+        await execFile('npx', [technologyValue('technology-vitest-a9127f'), 'run', ...testArgs], {
             cwd: projectRoot,
             timeout: 120_000,
         });

package/dist/engine/teammate-router/red-phase-verifier.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/teammate-router/red-phase-verifier.ts — SPEC-750
 // Runs the test suite and confirms that all expected tests are failing (RED phase).
 import { execFile as execFileCb } from 'node:child_process';
@@ -12,7 +13,7 @@ export async function verifyRedPhase(handoff, projectRoot) {
     try {
         // Run just the test files from the handoff
         const testArgs = ['--pool=forks', ...handoff.testFiles];
-        await execFile('npx', ['vitest', 'run', ...testArgs], {
+        await execFile('npx', [technologyValue('technology-vitest-a9127f'), 'run', ...testArgs], {
             cwd: projectRoot,
             timeout: 120_000,
         });

package/dist/engine/technical-enricher/index.js

@@ -1,13 +1,19 @@
 // technical-enricher/index.ts — Agnostic enricher + disk runner (SPEC-696)
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseTechnicalMd } from './parse-technical.js';
 import { detectSkip } from './skip-detector.js';
 import { extractSignatures } from './signature-extractor.js';
 import { scanTestPattern } from './test-pattern-scanner.js';
-import { renderEnriched } from './render-enriched.js';
+import { hasGeneratedEnrichment, renderEnriched } from './render-enriched.js';
+import { findMarkdownSectionRange } from '../spec-format/markdown-sections.js';
+import { resolveContainedProjectFile } from '../safety/contained-project-file.js';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
 export async function enrichTechnicalContent(input) {
     const { technicalContent, specScope, projectPath } = input;
+    if (hasGeneratedEnrichment(technicalContent)) {
+        return { enriched: false, reason: 'already-enriched' };
+    }
     const parsed = parseTechnicalMd(technicalContent);
     const skipReason = detectSkip(parsed, specScope);
     if (skipReason) {
@@ -42,20 +48,22 @@ async function runEnricherFromSpecSection(opts) {
     if (!specPath) {
         return;
     }
-    const specRaw = await readFile(specPath, 'utf8');
-    const sectionMatch = /\n## Technical\n([\s\S]*)$/.exec(specRaw);
-    if (!sectionMatch?.[1]) {
+    const physicalSpecPath = await resolveContainedProjectFile(opts.projectPath, specPath);
+    const specRaw = await readFile(physicalSpecPath, 'utf8');
+    const section = findMarkdownSectionRange(specRaw, 'Technical');
+    if (!section) {
         return;
     }
+    const technicalContent = specRaw.slice(section.contentStart, section.end);
     const result = await enrichTechnicalContent({
         specId: opts.specId,
         projectPath: opts.projectPath,
-        technicalContent: sectionMatch[1],
+        technicalContent,
         specScope: opts.specScope,
     });
     if (result.enriched && result.enrichedContent) {
-        const updated = specRaw.replace(/\n## Technical\n[\s\S]*$/, `\n## Technical\n\n${result.enrichedContent}`);
-        await writeFile(specPath, updated, 'utf8');
+        const updated = `${specRaw.slice(0, section.contentStart)}${result.enrichedContent}${specRaw.slice(section.end)}`;
+        await atomicWriteFile(physicalSpecPath, updated);
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/engine/technical-enricher/render-enriched.d.ts

@@ -1,3 +1,4 @@
 import type { RenderInput } from '../../types/technical-enrichment.js';
+export declare function hasGeneratedEnrichment(content: string): boolean;
 export declare function renderEnriched(input: RenderInput): string;
 //# sourceMappingURL=render-enriched.d.ts.map

package/dist/engine/technical-enricher/render-enriched.js

@@ -1,18 +1,41 @@
 const MAX_CHARS = 3200;
-export function renderEnriched(input) {
-    const { originalContent, signatures, testSample } = input;
-    const lines = [
-        originalContent.trimEnd(),
-        '',
+const GENERATED_START = '<!-- planu:technical-enrichment:start -->';
+const GENERATED_END = '<!-- planu:technical-enrichment:end -->';
+export function hasGeneratedEnrichment(content) {
+    return (content.includes(GENERATED_START) ||
+        /^#{2,3}[ \t]+Real Signatures \(auto-extracted by SPEC-696\)[ \t]*$/m.test(content));
+}
+function appendGenerated(originalContent, blocks) {
+    const separator = originalContent.endsWith('\n') ? '' : '\n\n';
+    const generated = [
+        GENERATED_START,
         '---',
         '',
-        '## Real Signatures (auto-extracted by SPEC-696)',
-    ];
+        '### Real Signatures (auto-extracted by SPEC-696)',
+        ...blocks,
+        GENERATED_END,
+        '',
+        '',
+    ].join('\n');
+    return `${originalContent}${separator}${generated}`;
+}
+export function renderEnriched(input) {
+    const { originalContent, signatures, testSample } = input;
+    if (originalContent.length >= MAX_CHARS || hasGeneratedEnrichment(originalContent)) {
+        return originalContent;
+    }
+    const blocks = [];
+    const tryAppendBlock = (block) => {
+        const candidateBlocks = [...blocks, block];
+        if (appendGenerated(originalContent, candidateBlocks).length <= MAX_CHARS) {
+            blocks.push(block);
+        }
+    };
     for (const sig of signatures) {
         if (sig.exports.length === 0 && sig.interfaces.length === 0) {
             continue;
         }
-        lines.push('', `### \`${sig.relPath}\``, '```typescript');
+        const lines = ['', `#### \`${sig.relPath}\``, '```typescript'];
         for (const exp of sig.exports.slice(0, 5)) {
             lines.push(exp);
         }
@@ -20,15 +43,20 @@ export function renderEnriched(input) {
             lines.push(iface);
         }
         lines.push('```');
+        tryAppendBlock(lines.join('\n'));
     }
     if (testSample) {
-        lines.push('', '## Test Patterns (from existing tests)', `- Mock style: \`${testSample.mockStyle}\``, `- Has \`beforeEach\`: ${String(testSample.hasBeforeEach)}`);
+        tryAppendBlock([
+            '',
+            '### Test Patterns (from existing tests)',
+            `- Mock style: \`${testSample.mockStyle}\``,
+            `- Has \`beforeEach\`: ${String(testSample.hasBeforeEach)}`,
+        ].join('\n'));
     }
-    const result = lines.join('\n');
-    if (result.length <= MAX_CHARS) {
-        return result;
+    if (blocks.length === 0) {
+        return originalContent;
     }
-    return (result.slice(0, MAX_CHARS) +
-        '\n\n> [truncated — spec too large, enrich remaining files manually]');
+    const result = appendGenerated(originalContent, blocks);
+    return result.length <= MAX_CHARS ? result : originalContent;
 }
 //# sourceMappingURL=render-enriched.js.map

package/dist/engine/technology-registry.d.ts

@@ -0,0 +1,11 @@
+import type { TechnologyRegistry } from '../types/technology-registry.js';
+import type { TechnologySymbolMap } from '../types/technology-symbols.generated.js';
+export declare function parseTechnologyRegistry(input: {
+    authority: unknown;
+    frameworkCatalog: unknown;
+    detectionCatalog: unknown;
+}): TechnologyRegistry;
+export declare function technologyValue<K extends keyof TechnologySymbolMap>(symbol: K): TechnologySymbolMap[K];
+export declare function loadTechnologyRegistry(directory?: string): TechnologyRegistry;
+export declare function resetTechnologyRegistryCache(): void;
+//# sourceMappingURL=technology-registry.d.ts.map

package/dist/engine/technology-registry.js

@@ -0,0 +1,142 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import bundledAuthority from '../config/technology-registry.json' with { type: 'json' };
+import bundledFrameworkCatalog from '../config/framework-registry/index.json' with { type: 'json' };
+import bundledDetectionCatalog from '../config/detection-signals.json' with { type: 'json' };
+const nonBlank = z.string().trim().min(1);
+const relativeJsonFile = nonBlank.regex(/^(?!\/)(?!.*\/\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_.-]+)*\.json$/u);
+const authoritySchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    frameworkCatalog: relativeJsonFile,
+    detectionCatalog: relativeJsonFile,
+    symbols: z.record(nonBlank, nonBlank),
+})
+    .strict();
+const frameworkSchema = z
+    .object({
+    id: nonBlank,
+    displayName: nonBlank,
+    ecosystem: nonBlank,
+    frameworkVersion: nonBlank,
+    lastUpdated: nonBlank,
+    file: relativeJsonFile,
+})
+    .strict();
+const signalSchema = z
+    .object({
+    frameworkId: nonBlank,
+    ecosystem: nonBlank,
+    type: z.enum(['dependency', 'file', 'env']),
+    pattern: nonBlank,
+    manager: nonBlank.optional(),
+})
+    .strict();
+const targetSchema = z
+    .object({
+    id: nonBlank,
+    type: z.enum(['dependency', 'file', 'env']),
+    pattern: nonBlank,
+    manager: nonBlank.optional(),
+    additionalMatch: nonBlank.optional(),
+})
+    .strict();
+const frameworkCatalogSchema = z.object({ frameworks: z.array(frameworkSchema) }).strict();
+const detectionCatalogSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    description: nonBlank.optional(),
+    signals: z.array(signalSchema),
+    deployTargets: z.array(targetSchema),
+    databases: z.array(targetSchema),
+    aliases: z.array(z.object({ alias: nonBlank, canonical: nonBlank }).strict()).default([]),
+})
+    .strict();
+let cache;
+function readJsonSource(path) {
+    try {
+        const source = readFileSync(path, 'utf8');
+        return { identity: source, value: JSON.parse(source) };
+    }
+    catch (error) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: cannot read ${path}`, { cause: error });
+    }
+}
+export function parseTechnologyRegistry(input) {
+    const authority = authoritySchema.parse(input.authority);
+    const frameworks = frameworkCatalogSchema.parse(input.frameworkCatalog).frameworks;
+    const detection = detectionCatalogSchema.parse(input.detectionCatalog);
+    const duplicates = frameworks.filter((entry, index) => frameworks.slice(0, index).some((candidate) => candidate.id === entry.id));
+    if (duplicates.length > 0) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: duplicate framework ${duplicates[0]?.id ?? ''}`);
+    }
+    const canonicalTerms = new Set([
+        ...frameworks.flatMap((entry) => [entry.id, entry.displayName]),
+        ...detection.signals.map((entry) => entry.frameworkId),
+        ...detection.deployTargets.map((entry) => entry.id),
+        ...detection.databases.map((entry) => entry.id),
+        ...detection.aliases.flatMap((entry) => [entry.alias, entry.canonical]),
+    ].map((term) => term.toLowerCase()));
+    for (const [symbol, value] of Object.entries(authority.symbols)) {
+        if (!/^technology-[a-z0-9-]+-[a-f0-9]{6}$/u.test(symbol) ||
+            !canonicalTerms.has(value.toLowerCase())) {
+            throw new Error(`TECHNOLOGY_REGISTRY_INVALID: invalid symbol ${symbol}`);
+        }
+    }
+    return {
+        schemaVersion: 1,
+        frameworks,
+        signals: detection.signals,
+        deployTargets: detection.deployTargets,
+        databases: detection.databases,
+        aliases: detection.aliases,
+        symbols: authority.symbols,
+    };
+}
+export function technologyValue(symbol) {
+    const registry = cache?.registry ?? loadTechnologyRegistry();
+    const value = registry.symbols[symbol];
+    if (value === undefined) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: unknown symbol ${symbol}`);
+    }
+    return value;
+}
+export function loadTechnologyRegistry(directory) {
+    if (directory === undefined) {
+        const identity = JSON.stringify([
+            bundledAuthority,
+            bundledFrameworkCatalog,
+            bundledDetectionCatalog,
+        ]);
+        if (cache?.identity === identity) {
+            return cache.registry;
+        }
+        const registry = parseTechnologyRegistry({
+            authority: bundledAuthority,
+            frameworkCatalog: bundledFrameworkCatalog,
+            detectionCatalog: bundledDetectionCatalog,
+        });
+        cache = { identity, registry };
+        return registry;
+    }
+    const authoritySource = readJsonSource(join(directory, 'technology-registry.json'));
+    const authority = authoritySchema.parse(authoritySource.value);
+    const frameworkSource = readJsonSource(join(directory, authority.frameworkCatalog));
+    const detectionSource = readJsonSource(join(directory, authority.detectionCatalog));
+    const identity = `${authoritySource.identity}\0${frameworkSource.identity}\0${detectionSource.identity}`;
+    if (cache?.identity === identity) {
+        return cache.registry;
+    }
+    const registry = parseTechnologyRegistry({
+        authority,
+        frameworkCatalog: frameworkSource.value,
+        detectionCatalog: detectionSource.value,
+    });
+    cache = { identity, registry };
+    return registry;
+}
+export function resetTechnologyRegistryCache() {
+    cache = undefined;
+}
+//# sourceMappingURL=technology-registry.js.map

package/dist/engine/telemetry/error-reporter.d.ts

@@ -1,6 +1,5 @@
 /**
- * Returns true when remote error reporting is active (default: on).
- * Disabled by setting env var PLANU_TELEMETRY=off.
+ * Environment-only fast check. The client also enforces persisted versioned opt-in.
  */
 export declare function isErrorReportingEnabled(): boolean;
 /**

package/dist/engine/telemetry/error-reporter.js

@@ -5,23 +5,21 @@
 // No PII: only tool name, sanitized error message, version, and Node version are sent.
 import { sendTelemetryEvent } from './telemetry-client.js';
 import { PLANU_VERSION } from '../../config/version.js';
+import { redactText } from '../../security/redactor.js';
+import { TELEMETRY_CONSENT_VERSION } from './telemetry-store.js';
 /**
- * Returns true when remote error reporting is active (default: on).
- * Disabled by setting env var PLANU_TELEMETRY=off.
+ * Environment-only fast check. The client also enforces persisted versioned opt-in.
  */
 export function isErrorReportingEnabled() {
-    return process.env.PLANU_TELEMETRY !== 'off';
+    return (process.env.PLANU_TELEMETRY === 'on' &&
+        process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION));
 }
 /**
  * Sanitizes an error message by removing filesystem paths and home-dir fragments
  * so no user-specific data is transmitted.
  */
 export function sanitizeErrorMessage(message) {
-    return message
-        .replace(/\/Users\/[^\s/]+/g, '/[user]')
-        .replace(/\/home\/[^\s/]+/g, '/[user]')
-        .replace(/C:\\Users\\[^\s\\]+/g, 'C:\\[user]')
-        .slice(0, 300);
+    return redactText(message).slice(0, 300);
 }
 /** Patterns in error messages that indicate a gate/policy block (not an exception). */
 const BLOCKED_PATTERNS = [
@@ -51,21 +49,19 @@ export function classifyToolEvent(errorMessage, errorType) {
  * Call this from safe-handler catch blocks after returning isError:true to the user.
  */
 export function reportToolError(toolName, error) {
-    if (!isErrorReportingEnabled()) {
+    if (process.env.PLANU_TELEMETRY === 'off') {
         return;
     }
-    const rawMessage = error instanceof Error ? error.message : String(error);
-    const message = sanitizeErrorMessage(rawMessage);
+    const errorClass = error instanceof Error ? error.name : typeof error;
     sendTelemetryEvent({
         event: 'tool_error',
         properties: {
             tool: toolName,
-            message,
             errorType: 'exception',
+            errorClass,
             planVersion: PLANU_VERSION,
             nodeVersion: process.version,
         },
-        installationId: 'anonymous',
     });
 }
 /**
@@ -75,21 +71,18 @@ export function reportToolError(toolName, error) {
  * Fire-and-forget — never throws.
  */
 export function reportToolValidationError(toolName, message) {
-    if (!isErrorReportingEnabled()) {
+    if (process.env.PLANU_TELEMETRY === 'off') {
         return;
     }
-    const sanitized = sanitizeErrorMessage(message);
-    const event = classifyToolEvent(sanitized, 'validation');
+    const event = classifyToolEvent(message, 'validation');
     sendTelemetryEvent({
         event,
         properties: {
             tool: toolName,
-            message: sanitized,
             errorType: 'validation',
             planVersion: PLANU_VERSION,
             nodeVersion: process.version,
         },
-        installationId: 'anonymous',
     });
 }
 //# sourceMappingURL=error-reporter.js.map