@planu/cli 4.13.0 → 5.0.0

package/dist/engine/handoff-packager.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { stripFrontmatter } from './frontmatter-parser.js';
 import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 import { extractAcceptanceCriteriaTexts } from './spec-format/acceptance-criteria.js';
+import { extractListItems, findMarkdownSectionRange } from './spec-format/markdown-sections.js';
 // ── Parsing helpers ──────────────────────────────────────────────────────────
 function extractObjective(huContent, spec) {
     if (!huContent) {
@@ -71,16 +72,369 @@ function extractFilesFromFicha(fichaContent) {
     }
     return { toModify, toCreate };
 }
+function sectionContentAtLevel(content, heading, level) {
+    let offset = 0;
+    while (offset < content.length) {
+        const range = findMarkdownSectionRange(content.slice(offset), heading);
+        if (range === null) {
+            return null;
+        }
+        if (range.level === level) {
+            return content.slice(offset + range.contentStart, offset + range.end);
+        }
+        const nextOffset = offset + range.end;
+        if (nextOffset <= offset) {
+            return null;
+        }
+        offset = nextOffset;
+    }
+    return null;
+}
+function ownershipItems(content) {
+    const visibleLines = [];
+    const fenced = [];
+    let fence = null;
+    for (const line of content.split('\n')) {
+        const marker = /^[ \t]{0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+        if (marker) {
+            const type = marker[0];
+            if (fence === null) {
+                fence = { marker: type, length: marker.length };
+            }
+            else if (fence.marker === type && marker.length >= fence.length) {
+                fence = null;
+            }
+            continue;
+        }
+        if (fence !== null) {
+            const trimmed = line.trim();
+            if (trimmed.length > 0) {
+                fenced.push(extractListItems(line)[0] ?? trimmed);
+            }
+            continue;
+        }
+        visibleLines.push(line);
+    }
+    return { items: extractListItems(visibleLines.join('\n')), fenced };
+}
+/** Normalize one repository-relative ownership path without retaining unsafe input in diagnostics. */
+export function normalizeOwnedPath(value) {
+    const trimmed = value.trim();
+    if (/^none\.?$/i.test(trimmed)) {
+        return { status: 'none' };
+    }
+    const backticked = /^`([^`]+)`/.exec(trimmed)?.[1];
+    const candidate = (backticked ?? trimmed.split(/\s+(?:—|–|-)\s+|\s+\(/, 1)[0] ?? '').trim();
+    if (candidate.length === 0) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_EMPTY' };
+    }
+    if (candidate.startsWith('```') || candidate.startsWith('~~~')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_FENCED' };
+    }
+    if (candidate.includes('\0')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_NUL' };
+    }
+    if (/^[\\/]{2}/.test(candidate)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_UNC' };
+    }
+    const normalizedSeparators = candidate.replaceAll('\\', '/');
+    if (normalizedSeparators.startsWith('/')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_ABSOLUTE' };
+    }
+    if (normalizedSeparators.startsWith('~/')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_HOME_RELATIVE' };
+    }
+    if (/^[A-Za-z]:\//.test(normalizedSeparators)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_DRIVE_ABSOLUTE' };
+    }
+    if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(normalizedSeparators)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_URI' };
+    }
+    if (normalizedSeparators.split('/').includes('..')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_TRAVERSAL' };
+    }
+    const path = normalizedSeparators.replace(/\/+/g, '/').replace(/^(?:\.\/)+/, '');
+    return path.length > 0
+        ? { status: 'valid', path }
+        : { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_EMPTY' };
+}
+/** Normalize a raw traceability changed-file value without interpreting Markdown or prose. */
+export function normalizeChangedFilePath(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes('`') ||
+        /^(?:#{1,6}|[-*+]|\d+[.)]|>)\s/u.test(trimmed) ||
+        /^\[[ xX]\]\s/u.test(trimmed)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_MARKDOWN' };
+    }
+    if (/\s/u.test(trimmed)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_DESCRIPTION' };
+    }
+    return normalizeOwnedPath(trimmed);
+}
+export function extractCanonicalFileOwnership(content) {
+    const filesSection = sectionContentAtLevel(content, 'Files', 2);
+    if (filesSection === null) {
+        return { present: false, toModify: [], toCreate: [], toTest: [], blockers: [] };
+    }
+    const blockers = [];
+    const addBlocker = (blocker) => {
+        if (!blockers.includes(blocker)) {
+            blockers.push(blocker);
+        }
+    };
+    const parseSection = (heading) => {
+        const subsection = sectionContentAtLevel(filesSection, heading, 3);
+        if (subsection === null) {
+            return [];
+        }
+        const { items, fenced } = ownershipItems(subsection);
+        for (const _value of fenced) {
+            addBlocker('INVALID_FILE_OWNERSHIP_FENCED');
+        }
+        const paths = [];
+        for (const value of items) {
+            const normalized = normalizeOwnedPath(value);
+            if (normalized.status === 'invalid') {
+                addBlocker(normalized.code);
+            }
+            else if (normalized.status === 'valid' && !paths.includes(normalized.path)) {
+                paths.push(normalized.path);
+            }
+        }
+        return paths;
+    };
+    const toCreate = parseSection('Create');
+    const toModify = parseSection('Modify');
+    const toTest = parseSection('Test');
+    const conflicts = [...new Set([...toCreate, ...toModify, ...toTest])].filter((path) => [toCreate, toModify, toTest].filter((paths) => paths.includes(path)).length > 1);
+    for (const path of conflicts) {
+        addBlocker(`CONFLICTING_FILE_OWNERSHIP: ${path}`);
+    }
+    return {
+        present: true,
+        toCreate: toCreate.filter((path) => !conflicts.includes(path)),
+        toModify: toModify.filter((path) => !conflicts.includes(path)),
+        toTest: toTest.filter((path) => !conflicts.includes(path)),
+        blockers,
+    };
+}
+const SAFE_OWNERSHIP_ANNOTATION = /^[\p{L}\p{N} .,_:-]+$/u;
+function isSafeOwnershipResidual(value) {
+    let remaining = value.trim();
+    while (remaining.length > 0) {
+        remaining = remaining.trimStart();
+        if (remaining.length === 0) {
+            return true;
+        }
+        const connector = /^(?:and|or)\b/iu.exec(remaining)?.[0];
+        if (connector) {
+            remaining = remaining.slice(connector.length);
+            continue;
+        }
+        if (',;&'.includes(remaining[0] ?? '')) {
+            remaining = remaining.slice(1);
+            continue;
+        }
+        if (remaining.startsWith('(')) {
+            const end = remaining.indexOf(')');
+            if (end < 2 || !SAFE_OWNERSHIP_ANNOTATION.test(remaining.slice(1, end))) {
+                return false;
+            }
+            remaining = remaining.slice(end + 1);
+            continue;
+        }
+        if (remaining.startsWith('—') || remaining.startsWith('-')) {
+            const description = remaining.slice(1).trim();
+            return description.length > 0 && SAFE_OWNERSHIP_ANNOTATION.test(description);
+        }
+        return false;
+    }
+    return true;
+}
+function ownershipBlocker(path, classifications) {
+    return `handoff_ownership_invalid path=${path} classifications=${classifications.join(',')}`;
+}
+function stripInertOwnershipMarkup(content) {
+    let fence = null;
+    let script = false;
+    return content
+        .split('\n')
+        .map((line) => {
+        const trimmed = line.trim();
+        const marker = /^[ \t]{0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+        if (marker) {
+            const type = marker[0];
+            if (fence === null) {
+                fence = { marker: type, length: marker.length };
+            }
+            else if (fence.marker === type && marker.length >= fence.length) {
+                fence = null;
+            }
+            return '';
+        }
+        if (fence !== null) {
+            return '';
+        }
+        if (/<script\b/iu.test(trimmed)) {
+            script = !/<\/script>/iu.test(trimmed);
+            return '';
+        }
+        if (script) {
+            if (/<\/script>/iu.test(trimmed)) {
+                script = false;
+            }
+            return '';
+        }
+        return /<\/?[A-Za-z][^>]*>/u.test(trimmed) ? '' : line;
+    })
+        .join('\n');
+}
+function normalizeStrictOwnedPath(rawValue) {
+    const normalized = normalizeOwnedPath(rawValue);
+    if (normalized.status !== 'valid') {
+        return null;
+    }
+    return /^[A-Za-z0-9._/-]+$/u.test(normalized.path) ? normalized.path : null;
+}
+function collectStrictOwnershipEntry(rawValue, classification, state) {
+    const rawPath = rawValue.trim();
+    const backtickedValues = [...rawPath.matchAll(/`([^`\n]+)`/gu)].map((match) => match[1] ?? '');
+    const backtickedPaths = backtickedValues.map(normalizeStrictOwnedPath);
+    const residual = rawPath.replaceAll(/`[^`\n]+`/gu, '').trim();
+    const residualIsSafe = isSafeOwnershipResidual(residual);
+    if (backtickedPaths.some((path) => path === null) ||
+        (backtickedValues.length > 0 && !residualIsSafe)) {
+        state.blockers.push(ownershipBlocker('<redacted>', [classification, 'InvalidPath']));
+        return;
+    }
+    const directPath = normalizeStrictOwnedPath(rawPath);
+    const paths = backtickedPaths.length > 0
+        ? backtickedPaths
+        : directPath === null
+            ? []
+            : [directPath];
+    if (paths.length === 0) {
+        const diagnosticPath = /^`[^`]+`$/u.test(rawPath) ? '<redacted>' : rawPath || '<empty>';
+        state.blockers.push(ownershipBlocker(diagnosticPath, [classification, 'InvalidPath']));
+        return;
+    }
+    for (const path of paths) {
+        collectStrictOwnershipPath(path, classification, state);
+    }
+}
+function collectStrictOwnershipPath(path, classification, state) {
+    const own = classification === 'Create' ? state.create : state.modify;
+    const other = classification === 'Create' ? state.modify : state.create;
+    if (own.has(path)) {
+        state.blockers.push(ownershipBlocker(path, [classification, classification]));
+        return;
+    }
+    if (other.has(path)) {
+        state.blockers.push(ownershipBlocker(path, ['Create', 'Modify']));
+        own.delete(path);
+        other.delete(path);
+        return;
+    }
+    own.add(path);
+}
+function extractStrictCanonicalOwnership(content) {
+    const filesSection = sectionContentAtLevel(content, 'Files', 2);
+    if (filesSection === null) {
+        return { present: false, toModify: [], toCreate: [], blockers: [] };
+    }
+    const state = { create: new Set(), modify: new Set(), blockers: [] };
+    const parseSection = (classification) => {
+        const subsection = sectionContentAtLevel(filesSection, classification, 3);
+        if (subsection === null) {
+            state.blockers.push(ownershipBlocker('<missing>', [classification, 'MissingSection']));
+            return;
+        }
+        const items = subsection
+            .split('\n')
+            .map((line) => /^\s*[-*]\s+(.+)$/u.exec(line)?.[1]?.trim())
+            .filter((item) => Boolean(item));
+        if (items.length === 0) {
+            state.blockers.push(ownershipBlocker('<empty>', [classification, 'Malformed']));
+            return;
+        }
+        let explicitNone = false;
+        for (const item of items) {
+            if (/^none\.?$/iu.test(item.trim())) {
+                if (explicitNone) {
+                    state.blockers.push(ownershipBlocker('<none>', [classification, classification]));
+                }
+                explicitNone = true;
+                continue;
+            }
+            collectStrictOwnershipEntry(item, classification, state);
+        }
+        const own = classification === 'Create' ? state.create : state.modify;
+        if (explicitNone && own.size > 0) {
+            state.blockers.push(ownershipBlocker('<none>', [classification, classification]));
+        }
+    };
+    parseSection('Create');
+    parseSection('Modify');
+    return {
+        present: true,
+        toCreate: [...state.create].sort(),
+        toModify: [...state.modify].sort(),
+        blockers: [...new Set(state.blockers)].sort(),
+    };
+}
+function extractFileLevelWorkPlanOwnership(content) {
+    const state = { create: new Set(), modify: new Set(), blockers: [] };
+    const section = sectionContentAtLevel(content, 'File-Level Work Plan', 3);
+    if (section === null) {
+        return { present: false, toModify: [], toCreate: [], blockers: [] };
+    }
+    for (const item of extractListItems(section)) {
+        const match = /^(Create|Modify)\s*:\s*(.+?)(?:\s+\([^)]*\))?\s*$/iu.exec(item);
+        if (!match?.[1] || !match[2]) {
+            continue;
+        }
+        const classification = match[1].toLowerCase() === 'create' ? 'Create' : 'Modify';
+        collectStrictOwnershipEntry(match[2], classification, state);
+    }
+    return {
+        present: state.create.size + state.modify.size + state.blockers.length > 0,
+        toCreate: [...state.create].sort(),
+        toModify: [...state.modify].sort(),
+        blockers: [...new Set(state.blockers)].sort(),
+    };
+}
+function validateOwnershipAgreement(canonical, workPlan) {
+    if (!canonical.present || !workPlan.present) {
+        return [];
+    }
+    const classification = (ownership, path) => ownership.toCreate.includes(path)
+        ? 'Create'
+        : ownership.toModify.includes(path)
+            ? 'Modify'
+            : 'Absent';
+    const paths = new Set([
+        ...canonical.toCreate,
+        ...canonical.toModify,
+        ...workPlan.toCreate,
+        ...workPlan.toModify,
+    ]);
+    return [...paths].sort().flatMap((path) => {
+        const canonicalClass = classification(canonical, path);
+        const workPlanClass = classification(workPlan, path);
+        return canonicalClass === workPlanClass
+            ? []
+            : [ownershipBlocker(path, [`Canonical:${canonicalClass}`, `WorkPlan:${workPlanClass}`])];
+    });
+}
 function extractBacktickedFiles(content) {
     const files = new Set();
-    const matches = content.matchAll(/`([^`\n]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yml|yaml|sh|css|scss|html))`/g);
-    for (const match of matches) {
-        const filePath = match[1]?.trim();
-        if (filePath && !filePath.includes(' ')) {
-            files.add(filePath);
+    for (const match of content.matchAll(/`([^`\n]+)`/gu)) {
+        const path = match[1] ? normalizeStrictOwnedPath(match[1]) : null;
+        if (path) {
+            files.add(path);
         }
     }
-    return [...files];
+    return [...files].sort();
 }
 function extractLinesByKeywords(content, keywords) {
     return content
@@ -95,11 +449,27 @@ function extractOperationalSections(content, spec) {
         risks: extractLinesByKeywords(content, /\b(risk|edge|failure|security|drift|migration|breaking|compatibility|rollback)\b/i),
         ownership: extractLinesByKeywords(content, /\b(owner|ownership|wave|agent|reviewer|arbiter|files?|responsible)\b/i),
         currentState: `Spec ${spec.id} is ${spec.status}; implementation must follow the approved spec artifact, not chat history.`,
-        nextAction: spec.status === 'approved'
-            ? 'Move to implementing with this handoff, then implement only the listed scope.'
-            : 'Review the current spec status and move through the required SDD gates before implementation.',
+        nextAction: lifecycleNextAction(spec.status),
     };
 }
+function lifecycleNextAction(status) {
+    switch (status) {
+        case 'draft':
+            return 'Complete the specification, discovery, challenge, and readiness evidence before review.';
+        case 'review':
+            return 'Resolve reviewer feedback and obtain independent spec approval before implementation.';
+        case 'approved':
+            return 'Move to implementing with this handoff, then implement only the listed scope.';
+        case 'implementing':
+            return 'Finish the remaining criteria, persist traceability, obtain independent implementation review, and run validation.';
+        case 'done':
+            return 'No implementation remains; preserve the validated done contract.';
+        case 'discarded':
+            return 'Do not implement this discarded specification.';
+        default:
+            return `Unsupported lifecycle status "${status}"; repair the canonical status before implementation.`;
+    }
+}
 function extractOutOfScope(huContent, spec) {
     if (!huContent) {
         return [
@@ -167,10 +537,35 @@ export async function packageHandoff(spec, knowledge) {
     }
     const objective = extractObjective(huContent, spec);
     const criteria = extractAcceptanceCriteriaTexts(rawSpecContent);
-    const parsedFiles = extractFilesFromFicha(fichaContent);
-    const discoveredFiles = extractBacktickedFiles(`${huContent}\n${fichaContent}`);
-    const toModify = parsedFiles.toModify.length > 0 ? parsedFiles.toModify : discoveredFiles;
-    const toCreate = parsedFiles.toCreate;
+    const ownershipContent = stripInertOwnershipMarkup(rawSpecContent);
+    const canonicalFiles = extractCanonicalFileOwnership(rawSpecContent);
+    const canonicalOwnership = extractStrictCanonicalOwnership(ownershipContent);
+    const workPlanOwnership = extractFileLevelWorkPlanOwnership(ownershipContent);
+    const testOwnedPaths = new Set(canonicalFiles.toTest);
+    const explicitOwnership = canonicalOwnership.present
+        ? {
+            ...canonicalOwnership,
+            toCreate: canonicalOwnership.toCreate.filter((path) => !testOwnedPaths.has(path)),
+            toModify: canonicalOwnership.toModify.filter((path) => !testOwnedPaths.has(path)),
+        }
+        : workPlanOwnership.present
+            ? workPlanOwnership
+            : null;
+    const legacyFiles = extractFilesFromFicha(ownershipContent);
+    const hasLegacyOwnership = legacyFiles.toModify.length + legacyFiles.toCreate.length > 0;
+    const toModify = explicitOwnership
+        ? explicitOwnership.toModify
+        : hasLegacyOwnership
+            ? legacyFiles.toModify
+            : extractBacktickedFiles(ownershipContent);
+    const toCreate = explicitOwnership
+        ? explicitOwnership.toCreate
+        : hasLegacyOwnership
+            ? legacyFiles.toCreate
+            : [];
+    if (!explicitOwnership && toModify.length + toCreate.length > 0) {
+        warnings.push('LEGACY_FILE_OWNERSHIP_FALLBACK');
+    }
     const outOfScope = extractOutOfScope(huContent, spec);
     const constraints = buildConstraints(knowledge);
     const operational = extractOperationalSections(`${huContent}\n${fichaContent}`, spec);
@@ -183,6 +578,13 @@ export async function packageHandoff(spec, knowledge) {
         ...(operational.testPlan.length === 0 ? ['Missing test plan'] : []),
         ...(operational.risks.length === 0 ? ['Missing risk analysis'] : []),
         ...(operational.ownership.length === 0 ? ['Missing ownership'] : []),
+        ...canonicalFiles.blockers,
+        ...canonicalOwnership.blockers,
+        ...workPlanOwnership.blockers,
+        ...validateOwnershipAgreement(canonicalOwnership, workPlanOwnership),
+        ...(!['draft', 'review', 'approved', 'implementing', 'done', 'discarded'].includes(spec.status)
+            ? [`UNSUPPORTED_LIFECYCLE_STATUS: ${spec.status}`]
+            : []),
     ];
     const pkg = {
         specId: spec.id,

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/effort-configurator.js

@@ -4,7 +4,7 @@
 // ---------------------------------------------------------------------------
 export const DEFAULT_EFFORT_RULES = [
     {
-        pattern: 'list_specs|usage_stats|license_status',
+        pattern: 'list_specs|usage_stats',
         effort: 'low',
         reason: 'read-only queries',
     },

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/impact-detector/test-break-predictor.js

@@ -19,9 +19,9 @@ const BREAK_PATTERNS = [
         remediation: 'Run scripts/sync-website-counts.sh --apply and commit website/',
     },
     {
-        pattern: /license-plans\.json/,
-        kind: 'license-plans-sync',
-        remediation: 'Add new tool name to src/config/license-plans.json',
+        pattern: /generate-host-tool-registry/,
+        kind: 'tool-registry-sync',
+        remediation: 'Run scripts/generate-host-tool-registry.mjs',
     },
 ];
 async function collectTestFiles(dir, results, budget, depth) {

package/dist/engine/impact-detector/tool-registration.js

@@ -21,7 +21,7 @@ export function detectsNewToolRegistration(specBody, technicalMd) {
 export function buildToolRegistrationCriteria() {
     return [
         {
-            text: 'license-plans.json must include the new tool name',
+            text: 'The generated host registry must match the canonical tool registry',
             source: 'impact-detector',
             autoResolvable: false,
         },