@planu/cli 4.12.3 → 4.14.1

package/dist/engine/execution-plan/desktop-distribution.js

@@ -1,8 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/execution-plan/desktop-distribution.ts — SPEC-014b
-// Distribution phase generator for desktop release specs (Electron, Tauri, .NET).
-// SRP: single responsibility — desktop app release pipeline steps.
+import { technologyValue } from '../technology-registry.js';
 /**
  * Returns true if the spec is a desktop release spec (based on tags, title, or type).
  */
@@ -11,7 +7,7 @@ export function isDesktopReleaseSpec(spec) {
     return (lower.includes('release') ||
         lower.includes('distribut') ||
         lower.includes('publish') ||
-        lower.includes('electron') ||
+        lower.includes(technologyValue('technology-electron-88b1de')) ||
         lower.includes('tauri') ||
         lower.includes('dotnet') ||
         spec.type === 'infra');
@@ -24,7 +20,7 @@ export function generateDesktopDistributionPhase(spec, startOrder) {
     const steps = [];
     let order = startOrder;
     const lower = `${spec.title} ${spec.tags.join(' ')}`.toLowerCase();
-    const isElectron = lower.includes('electron');
+    const isElectron = lower.includes(technologyValue('technology-electron-88b1de'));
     const isTauri = lower.includes('tauri');
     const isDotNet = lower.includes('dotnet') || lower.includes('.net');
     // Step 1: Platform-specific build

package/dist/engine/execution-plan/mobile-distribution.js

@@ -1,9 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/execution-plan/mobile-distribution.ts — SPEC-013
-// Distribution phase orchestrator for iOS/Android/Flutter/ReactNative/Expo release specs.
-// SRP: detects platform + delegates step generation to platform-specific modules.
-// OCP: new platforms add a new file in mobile-dist/ — no changes to this file.
+import { technologyValue } from '../technology-registry.js';
 import { generateNativeDistributionPhase } from './mobile-dist/native-steps.js';
 import { generateFlutterDistributionPhase } from './mobile-dist/flutter-steps.js';
 import { generateExpoDistributionPhase } from './mobile-dist/expo-steps.js';
@@ -15,8 +10,8 @@ import { generateReactNativeDistributionPhase } from './mobile-dist/rn-steps.js'
  */
 export function detectCrossPlatformKind(spec) {
     const lower = `${spec.title} ${spec.tags.join(' ')}`.toLowerCase();
-    if (lower.includes('flutter')) {
-        return 'flutter';
+    if (lower.includes(technologyValue('technology-flutter-be1396'))) {
+        return technologyValue('technology-flutter-be1396');
     }
     if (lower.includes('expo')) {
         return 'expo';
@@ -43,7 +38,7 @@ export function isMobileDistributionSpec(spec) {
  */
 export function generateMobileDistributionPhase(spec, startOrder) {
     const crossPlatform = detectCrossPlatformKind(spec);
-    if (crossPlatform === 'flutter') {
+    if (crossPlatform === technologyValue('technology-flutter-be1396')) {
         return generateFlutterDistributionPhase(startOrder);
     }
     if (crossPlatform === 'expo') {

package/dist/engine/execution-plan/phases.js

@@ -1,6 +1,4 @@
-// engine/execution-plan/phases.ts — Execution phase generators
-// SRP: each function generates steps for one phase of the implementation plan.
-// OCP: new phases can be added without modifying the dispatcher in generate-execution-plan.ts.
+import { technologyValue } from '../technology-registry.js';
 import { inferDataLayerFiles, inferServiceFiles, inferApiFiles, inferPageFiles, inferComponentFiles, } from './plan-utils.js';
 export { generateTestingPhase, generateIntegrationPhase } from './phases-b.js';
 export function generateSetupPhase(spec, knowledge, startOrder) {
@@ -16,7 +14,8 @@ export function generateSetupPhase(spec, knowledge, startOrder) {
         estimatedMinutes: 2,
         canRollback: true,
     });
-    if (knowledge.language === 'typescript' || knowledge.language === 'javascript') {
+    if (knowledge.language === technologyValue('technology-typescript-969545') ||
+        knowledge.language === 'javascript') {
         steps.push({
             order: order++,
             title: 'Define types and interfaces',
@@ -156,7 +155,7 @@ export function generateUIPhase(spec, knowledge, content, startOrder) {
     const steps = [];
     let order = startOrder;
     const lower = content.toLowerCase();
-    const framework = knowledge.framework ?? 'react';
+    const framework = knowledge.framework ?? technologyValue('technology-react-275976');
     steps.push({
         order: order++,
         title: 'Create page layout and routing',

package/dist/engine/execution-plan/plan-utils.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../technology-registry.js';
 // engine/execution-plan/plan-utils.ts — Utilities for execution plan generation
 // Critical path analysis, parallelization detection, and file inference helpers.
 import { readFile } from 'node:fs/promises';
@@ -48,7 +47,7 @@ export function inferServiceFiles(spec, knowledge) {
 export function inferApiFiles(spec, knowledge) {
     const firstContract = knowledge.apiContracts[0];
     const apiType = firstContract ? firstContract.type : 'rest';
-    const base = apiType === 'trpc' ? 'src/server/routers' : 'src/routes';
+    const base = apiType === technologyValue('technology-trpc-7a75ed') ? 'src/server/routers' : 'src/routes';
     return [`${base}/${spec.slug}.ts`];
 }
 export function inferPageFiles(spec, knowledge) {
@@ -56,13 +55,17 @@ export function inferPageFiles(spec, knowledge) {
     if (framework.includes('next')) {
         return [`app/${spec.slug}/page.tsx`];
     }
-    if (framework.includes('nuxt')) {
+    if (framework.includes(technologyValue('technology-nuxt-22c407'))) {
         return [`pages/${spec.slug}.vue`];
     }
     return [`src/pages/${spec.slug}.tsx`];
 }
 export function inferComponentFiles(spec, knowledge) {
-    const ext = (knowledge.framework ?? '').toLowerCase().includes('vue') ? 'vue' : 'tsx';
+    const ext = (knowledge.framework ?? '')
+        .toLowerCase()
+        .includes(technologyValue('technology-vue-564382'))
+        ? technologyValue('technology-vue-564382')
+        : 'tsx';
     return [`src/components/${spec.slug}/${spec.slug}.${ext}`];
 }
 // --- Spec content reader ---

package/dist/engine/facilitate/context-loader.js

@@ -2,7 +2,7 @@
 // engine/facilitate/context-loader.ts — SPEC-264 Loads project context from disk
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createHash } from 'node:crypto';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -39,12 +39,6 @@ function parseFrontmatter(content) {
     }
     return result;
 }
-/**
- * Compute project hash the same way base-store does (SHA-256, first 16 chars).
- */
-function hashProjectPath(projectPath) {
-    return createHash('sha256').update(projectPath).digest('hex').slice(0, 16);
-}
 /**
  * Check if two sets of keywords overlap (case-insensitive).
  */
@@ -90,8 +84,8 @@ async function loadCheckpoint(checkpointFile) {
  */
 export async function loadContext(projectPath, keywords) {
     const projectId = hashProjectPath(projectPath);
-    const specsFile = join('data', 'projects', projectId, 'specs.json');
-    const checkpointFile = join('data', 'projects', projectId, 'session-state.json');
+    const specsFile = join(projectDataDir(projectId), 'specs.json');
+    const checkpointFile = join(projectDataDir(projectId), 'session-state.json');
     const specs = await loadSpecsFromFile(specsFile);
     const lastCheckpoint = await loadCheckpoint(checkpointFile);
     const activeSpecs = specs.filter((s) => ACTIVE_STATUSES.has(s.status));

package/dist/engine/figma/code-connect-fetcher.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../technology-registry.js';
 // engine/figma/code-connect-fetcher.ts — Figma Code Connect / Dev Resources (SPEC-426)
 const FIGMA_API_BASE = 'https://api.figma.com/v1';
 // ---------------------------------------------------------------------------
@@ -7,14 +6,16 @@ const FIGMA_API_BASE = 'https://api.figma.com/v1';
 // ---------------------------------------------------------------------------
 function inferFramework(url) {
     const lower = url.toLowerCase();
-    if (lower.includes('react') || lower.includes('jsx') || lower.includes('tsx')) {
-        return 'react';
+    if (lower.includes(technologyValue('technology-react-275976')) ||
+        lower.includes('jsx') ||
+        lower.includes('tsx')) {
+        return technologyValue('technology-react-275976');
     }
-    if (lower.includes('vue')) {
-        return 'vue';
+    if (lower.includes(technologyValue('technology-vue-564382'))) {
+        return technologyValue('technology-vue-564382');
     }
-    if (lower.includes('angular')) {
-        return 'angular';
+    if (lower.includes(technologyValue('technology-angular-a39f89'))) {
+        return technologyValue('technology-angular-a39f89');
     }
     if (lower.includes('swift') || lower.includes('ios')) {
         return 'ios';

package/dist/engine/filesystem-watcher/index.d.ts

@@ -4,13 +4,13 @@ import type { FsHookConfig, FsHooksConfig, FsHookTriggerEvent, FsHookResult } fr
  */
 export declare function getDefaultHooksConfig(): FsHooksConfig;
 /**
- * Loads the hooks configuration from `.planu/hooks.json` in the given project path.
+ * Loads the hooks configuration from `planu/hooks.json` in the given project path.
  * Returns the default config if the file does not exist.
  */
 export declare function loadHooksConfig(projectPath: string): Promise<FsHooksConfig>;
 /**
- * Saves the hooks configuration to `.planu/hooks.json` in the given project path.
- * Creates the `.planu` directory if it does not exist.
+ * Saves the hooks configuration to `planu/hooks.json` in the given project path.
+ * Creates the `planu` directory if it does not exist.
  */
 export declare function saveHooksConfig(projectPath: string, config: FsHooksConfig): Promise<void>;
 /**

package/dist/engine/filesystem-watcher/index.js

@@ -2,7 +2,7 @@
 // engine/filesystem-watcher/index.ts — SPEC-329: Filesystem watcher engine
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-const HOOKS_FILE = '.planu/hooks.json';
+const HOOKS_FILE = 'planu/hooks.json';
 /**
  * Returns the default hooks configuration (disabled with no hooks).
  */
@@ -10,7 +10,7 @@ export function getDefaultHooksConfig() {
     return { enabled: false, hooks: [] };
 }
 /**
- * Loads the hooks configuration from `.planu/hooks.json` in the given project path.
+ * Loads the hooks configuration from `planu/hooks.json` in the given project path.
  * Returns the default config if the file does not exist.
  */
 export async function loadHooksConfig(projectPath) {
@@ -24,11 +24,11 @@ export async function loadHooksConfig(projectPath) {
     }
 }
 /**
- * Saves the hooks configuration to `.planu/hooks.json` in the given project path.
- * Creates the `.planu` directory if it does not exist.
+ * Saves the hooks configuration to `planu/hooks.json` in the given project path.
+ * Creates the `planu` directory if it does not exist.
  */
 export async function saveHooksConfig(projectPath, config) {
-    const dir = join(projectPath, '.planu');
+    const dir = join(projectPath, 'planu');
     await mkdir(dir, { recursive: true });
     const filePath = join(projectPath, HOOKS_FILE);
     await writeFile(filePath, JSON.stringify(config, null, 2), 'utf-8');

package/dist/engine/framework-detector.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+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';
@@ -79,12 +78,12 @@ export async function detectDatabase(projectPath, signatures) {
 }
 const KNOWN_ENGINES = new Set([
     'postgresql',
-    'supabase',
+    technologyValue('technology-supabase-4d7594'),
     'mysql',
     'sqlite',
     'mongodb',
     'firebase',
-    'redis',
+    technologyValue('technology-redis-34fb46'),
     'memcached',
     'valkey',
     'elasticsearch',
@@ -129,24 +128,24 @@ function isKnownEngine(engine) {
 export async function detectOrm(projectPath) {
     const deps = await collectDependencies(projectPath);
     const ormMap = {
-        prisma: ['@prisma/client', 'prisma'],
+        prisma: ['@prisma/client', technologyValue('technology-prisma-99497c')],
         drizzle: ['drizzle-orm'],
-        typeorm: ['typeorm'],
-        sequelize: ['sequelize'],
-        mongoose: ['mongoose'],
+        typeorm: [technologyValue('technology-typeorm-527d4d')],
+        sequelize: [technologyValue('technology-sequelize-d18291')],
+        mongoose: [technologyValue('technology-mongoose-4e1812')],
         mikro: ['@mikro-orm/core'],
         objection: ['objection'],
         knex: ['knex'],
-        sqlalchemy: ['sqlalchemy'],
-        'django-orm': ['django'],
+        sqlalchemy: [technologyValue('technology-sqlalchemy-37f268')],
+        'django-orm': [technologyValue('technology-django-7d8a08')],
         tortoise: ['tortoise-orm'],
         peewee: ['peewee'],
         gorm: ['gorm.io/gorm'],
         ent: ['entgo.io/ent'],
-        diesel: ['diesel'],
+        diesel: [technologyValue('technology-diesel-f83cff')],
         'sea-orm': ['sea-orm'],
         ecto: ['ecto'],
-        'active-record': ['activerecord'],
+        'active-record': [technologyValue('technology-activerecord-97a448')],
         eloquent: ['illuminate/database'],
     };
     for (const [orm, packages] of Object.entries(ormMap)) {
@@ -158,11 +157,11 @@ export async function detectOrm(projectPath) {
     }
     // Check for Prisma schema file
     if (await hasAnyFile(projectPath, ['prisma/schema.prisma'])) {
-        return 'prisma';
+        return technologyValue('technology-prisma-99497c');
     }
     // Check for Drizzle config
     if (await hasAnyFile(projectPath, ['drizzle.config.ts', 'drizzle.config.js'])) {
-        return 'drizzle';
+        return technologyValue('technology-drizzle-424f22');
     }
     return null;
 }
@@ -218,7 +217,7 @@ export async function detectTestCommand(projectPath, packageManager) {
     }
     if ((await fileExists(projectPath, 'pytest.ini')) ||
         (await fileExists(projectPath, 'pyproject.toml'))) {
-        return 'pytest';
+        return technologyValue('technology-pytest-2b0121');
     }
     return null;
 }

package/dist/engine/git/planu-autocommit.js

@@ -1,19 +1,20 @@
 // engine/git/planu-autocommit.ts — Idempotent git commit helper for staged planu/ docs
-import { execFile as execFileCb } from 'node:child_process';
-import { promisify } from 'node:util';
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';
-const execFile = promisify(execFileCb);
+import { runAbortableProcess } from '../abortable-process-runner.js';
 export function isPlanuAutocommitEnabled() {
     return process.env.PLANU_ENABLE_AUTOCOMMIT === 'true';
 }
-/** Run git with execFile (no shell injection risk). */
+/** Run git through the request-aware process-group supervisor. */
 async function runGit(cwd, args) {
-    const result = await execFile('git', args, {
+    const result = await runAbortableProcess('git', args, {
         cwd,
-        maxBuffer: 1024 * 1024,
-        timeout: 15_000,
+        maxBufferBytes: 1024 * 1024,
+        timeoutMs: 15_000,
     });
+    if (result.status !== 0 || result.error) {
+        throw result.error ?? new Error(result.stderr || `git exited with ${String(result.status)}`);
+    }
     return { stdout: result.stdout, stderr: result.stderr };
 }
 /** Build commit message based on reason and optional specId. */

package/dist/engine/git/repository-probe.d.ts

@@ -0,0 +1,3 @@
+/** O(1) probe that supports both normal repositories and worktree `.git` files. */
+export declare function hasGitMetadata(projectPath: string): Promise<boolean>;
+//# sourceMappingURL=repository-probe.d.ts.map

package/dist/engine/git/repository-probe.js

@@ -0,0 +1,13 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/** O(1) probe that supports both normal repositories and worktree `.git` files. */
+export async function hasGitMetadata(projectPath) {
+    try {
+        const metadata = await stat(join(projectPath, '.git'));
+        return metadata.isDirectory() || metadata.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=repository-probe.js.map

package/dist/engine/global-rules-manager.js

@@ -1,12 +1,12 @@
 // engine/global-rules-manager.ts — Global Steering Rules manager (SPEC-351)
 import { readFile, writeFile, readdir, unlink, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
+import { resolveStorageLayout } from '../storage/storage-layout.js';
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
 export function globalRulesDir() {
-    return join(homedir(), '.planu', 'global-rules');
+    return join(resolveStorageLayout().config, 'global-rules');
 }
 function ruleFile(slug) {
     return join(globalRulesDir(), `${slug}.md`);

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

@@ -50,9 +50,8 @@ function eventTypeForKind(kind) {
 export async function appendArtifact(input) {
     const { projectId, specId, kind, payload } = input;
     const lockKey = `${projectId}:${specId}:${kind}`;
-    // We use projectId as the 'projectPath' for the lock — the lock dir is relative
-    // to cwd, so we use a combined specId that encodes the artifact key
-    const lockHandle = await acquireLock('.', lockKey, { reason: `handoff.${kind}` });
+    const lockResourceId = `__handoff-${createHash('sha256').update(lockKey).digest('hex')}`;
+    const lockHandle = await acquireLock(projectId, lockResourceId, { reason: `handoff.${kind}` });
     if (lockHandle === null) {
         throw new Error(`[handoff-artifacts] Could not acquire lock for ${lockKey}`);
     }

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

@@ -1,3 +1,4 @@
+import { technologyValue } from '../../technology-registry.js';
 // engine/handoff-artifacts/schemas/red-tests-handoff.ts — SPEC-750
 // Zod schema for the red-tests handoff artifact produced by TestArchitect.
 import { z } from 'zod';
@@ -6,7 +7,13 @@ export const RedTestsHandoffSchema = z.object({
     version: z.literal(1),
     specId: z.string().min(1),
     testFiles: z.array(z.string()).min(1),
-    testFramework: z.enum(['vitest', 'jest', 'playwright', 'pytest', 'rspec']),
+    testFramework: z.enum([
+        technologyValue('technology-vitest-a9127f'),
+        technologyValue('technology-jest-35e99f'),
+        technologyValue('technology-playwright-7827e8'),
+        technologyValue('technology-pytest-2b0121'),
+        'rspec',
+    ]),
     expectedFailures: z.array(z.string()).min(1),
     authoredBy: z.string().min(1),
     authoredAt: z.string().min(1),

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -61,6 +61,8 @@ export declare const ImplementationReportV1Schema: z.ZodObject<{
     testsRun: z.ZodNumber;
     testsPassed: z.ZodNumber;
     completedAt: z.ZodISODateTime;
+    receiptId: z.ZodOptional<z.ZodString>;
+    receiptKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ValidationReportV1Schema: z.ZodObject<{
     schema_version: z.ZodString;
@@ -215,6 +217,8 @@ export declare const ARTIFACT_SCHEMAS: {
         testsRun: z.ZodNumber;
         testsPassed: z.ZodNumber;
         completedAt: z.ZodISODateTime;
+        receiptId: z.ZodOptional<z.ZodString>;
+        receiptKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly 'validation-report': z.ZodObject<{
         schema_version: z.ZodString;

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

@@ -47,6 +47,11 @@ export const ImplementationReportV1Schema = z.object({
     testsRun: z.number().int().min(0),
     testsPassed: z.number().int().min(0),
     completedAt: z.iso.datetime(),
+    receiptId: z
+        .string()
+        .regex(/^sha256:[a-f0-9]{64}$/u)
+        .optional(),
+    receiptKey: z.string().min(1).optional(),
 });
 export const ValidationReportV1Schema = z.object({
     schema_version: SchemaVersion,

package/dist/engine/hook-generator/stack-hook-templates.js

@@ -1,4 +1,4 @@
-// engine/hook-generator/stack-hook-templates.ts — Git hook templates per stack (SPEC-416)
+import { technologyValue } from '../technology-registry.js';
 // ---------------------------------------------------------------------------
 // Marker helpers — used by hook-merger for idempotent injection
 // ---------------------------------------------------------------------------
@@ -16,7 +16,7 @@ export const STACK_HOOK_TEMPLATES = {
         {
             id: 'typescript-typecheck',
             phase: 'pre-commit',
-            stack: 'typescript',
+            stack: technologyValue('technology-typescript-969545'),
             content: 'pnpm typecheck || exit 1',
             description: 'TypeScript type checking',
         },
@@ -43,7 +43,7 @@ export const STACK_HOOK_TEMPLATES = {
         {
             id: 'vitest-coverage',
             phase: 'pre-push',
-            stack: 'vitest',
+            stack: technologyValue('technology-vitest-a9127f'),
             content: 'pnpm test:coverage || exit 1',
             description: 'Vitest coverage threshold check',
         },
@@ -52,7 +52,7 @@ export const STACK_HOOK_TEMPLATES = {
         {
             id: 'jest-coverage',
             phase: 'pre-push',
-            stack: 'jest',
+            stack: technologyValue('technology-jest-35e99f'),
             content: 'pnpm test --coverage || exit 1',
             description: 'Jest coverage check',
         },

package/dist/engine/hooks/config-loader.js

@@ -25,7 +25,7 @@ const fileHookConfigSchema = z.object({
 // ---------------------------------------------------------------------------
 // Config file paths
 // ---------------------------------------------------------------------------
-const HOOKS_JSON = '.planu/hooks.json';
+const HOOKS_JSON = 'planu/hooks.json';
 const PLANU_JSON = 'planu.json';
 // ---------------------------------------------------------------------------
 // ConfigLoader

package/dist/engine/hooks/context-injector.js

@@ -2,7 +2,7 @@
 // engine/hooks/context-injector.ts — Reads project data and writes .planu/plan-context.md (SPEC-262)
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createHash } from 'node:crypto';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -12,16 +12,13 @@ const MAX_RECENT_DECISIONS = 5;
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-function hashProjectPath(projectPath) {
-    return createHash('sha256').update(projectPath).digest('hex').slice(0, 16);
-}
 /** Safely extract a string from an unknown value — returns '' when not a string */
 function str(val) {
     return typeof val === 'string' ? val : '';
 }
 async function loadSpecs(projectPath) {
     const projectId = hashProjectPath(projectPath);
-    const specsFile = join(projectPath, 'data', 'projects', projectId, 'specs.json');
+    const specsFile = join(projectDataDir(projectId), 'specs.json');
     try {
         const raw = await readFile(specsFile, 'utf-8');
         return JSON.parse(raw);
@@ -32,7 +29,7 @@ async function loadSpecs(projectPath) {
 }
 async function loadDecisions(projectPath) {
     const projectId = hashProjectPath(projectPath);
-    const decisionsFile = join(projectPath, 'data', 'projects', projectId, 'decisions.json');
+    const decisionsFile = join(projectDataDir(projectId), 'decisions.json');
     try {
         const raw = await readFile(decisionsFile, 'utf-8');
         const data = JSON.parse(raw);
@@ -73,7 +70,7 @@ function formatDecisionSummary(d) {
  */
 export async function injectPlanContext(projectPath, taskDescription) {
     const md = await buildContextMarkdown(projectPath, taskDescription);
-    const planuDir = join(projectPath, '.planu');
+    const planuDir = join(projectPath, 'planu');
     await mkdir(planuDir, { recursive: true });
     await writeFile(join(planuDir, 'plan-context.md'), md, 'utf-8');
 }

package/dist/engine/hooks/file-watcher.js

@@ -81,7 +81,6 @@ function maxTypeScriptWatchers() {
 // ---------------------------------------------------------------------------
 // FileWatcher
 // ---------------------------------------------------------------------------
-import { isNativeActive, startNativeWatcher } from '../core-bridge.js';
 export class FileWatcher extends EventEmitter {
     watcher = null;
     watchers = new Set();
@@ -107,19 +106,7 @@ export class FileWatcher extends EventEmitter {
             return;
         }
         try {
-            if (isNativeActive()) {
-                console.error('[Planu-RS] Starting high-performance Rust file watcher');
-                startNativeWatcher(this.rootDir, (err, filename) => {
-                    if (err || !filename || this.closed) {
-                        return;
-                    }
-                    const relPath = filename.replace(this.rootDir, '').replace(/^\/+/, '');
-                    void this.handleFsEvent(relPath);
-                });
-            }
-            else {
-                this.startTypeScriptWatcher();
-            }
+            this.startTypeScriptWatcher();
         }
         catch (err) {
             this.emitWatcherError(err);

package/dist/engine/hooks-reconciler.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/hooks-reconciler.ts — Detect drift between CI/quality pipeline and git hooks.
 // Read-only analysis by default; patchHooks() writes fixes when autoFix is enabled.
 import { readFileSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
@@ -44,15 +45,15 @@ function detectCapabilities(projectPath, pkg) {
             ? pkg.devDependencies
             : {}),
     };
-    const hasTypeScript = 'typescript' in allDeps ||
+    const hasTypeScript = technologyValue('technology-typescript-969545') in allDeps ||
         existsSync(join(projectPath, 'tsconfig.json')) ||
         existsSync(join(projectPath, 'tsconfig.build.json'));
     const hasEsLint = 'eslint' in allDeps ||
         existsSync(join(projectPath, 'eslint.config.js')) ||
         existsSync(join(projectPath, '.eslintrc.js')) ||
         existsSync(join(projectPath, '.eslintrc.json'));
-    const hasTestRunner = 'vitest' in allDeps ||
-        'jest' in allDeps ||
+    const hasTestRunner = technologyValue('technology-vitest-a9127f') in allDeps ||
+        technologyValue('technology-jest-35e99f') in allDeps ||
         'mocha' in allDeps ||
         existsSync(join(projectPath, 'vitest.config.ts')) ||
         existsSync(join(projectPath, 'jest.config.js'));
@@ -206,7 +207,8 @@ function buildPatchCandidates(missingChecks, pkg) {
     const prettierCoveredByLintStaged = lintStagedCoversPrettier(pkg);
     const eslintCoveredByLintStaged = lintStagedCoversEslint(pkg);
     for (const check of missingChecks) {
-        if (check.includes('TypeScript') && check.includes('pre-commit')) {
+        if (check.includes(technologyValue('technology-typescript-ed0504')) &&
+            check.includes('pre-commit')) {
             candidates.push({ hook: 'pre-commit', line: 'pnpm typecheck', description: check });
         }
         else if (check.includes('ESLint') && check.includes('pre-commit')) {

package/dist/engine/infrastructure/component-mapper.js

@@ -1,6 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/infrastructure/component-mapper.ts — Map InfraSignals to InfraComponents (SPEC-171)
+import { technologyValue } from '../technology-registry.js';
 import { getTerraformVersion } from '../../config/version-defaults.js';
 /** Normalize environment string to a valid key: 'dev' | 'staging' | 'prod'. Defaults to 'dev'. */
 export function resolveEnvironment(environment) {
@@ -38,9 +36,9 @@ function resolveDatabase(technology) {
     }
 }
 function resolveCache(technology) {
-    if (technology === 'redis') {
+    if (technology === technologyValue('technology-redis-34fb46')) {
         return {
-            kind: 'redis',
+            kind: technologyValue('technology-redis-34fb46'),
             name: 'redis-cache',
             sizeByEnv: { dev: 'cache.t3.micro', staging: 'cache.t3.small', prod: 'cache.t3.medium' },
         };
@@ -112,13 +110,13 @@ function signalToSpec(signal) {
             return resolveStorage(signal.technology);
         case 'api':
             return resolveApi(signal.technology);
-        case 'kubernetes':
+        case technologyValue('technology-kubernetes-94abcb'):
             return {
                 kind: 'k8s-deployment',
                 name: 'app-deployment',
                 sizeByEnv: { dev: 'small', staging: 'medium', prod: 'large' },
             };
-        case 'railway':
+        case technologyValue('technology-railway-e34d1c'):
             return {
                 kind: 'railway-service',
                 name: 'railway-app',