@planu/cli 4.12.3 → 4.14.1

package/dist/engine/skill-bootstrap/stack-matcher.js

@@ -1,25 +1,24 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/skill-bootstrap/stack-matcher.ts — SPEC-439: Detect project stack and match to skills
-// SPEC-597-EXEMPT: npm-package→canonical-name mapping. Lookup table consumed
-// at runtime; JSON externalization adds I/O without payoff.
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 const DEP_TO_TECH = {
     // Frontend frameworks
-    next: 'nextjs',
-    react: 'react',
+    next: technologyValue('technology-nextjs-c93379'),
+    react: technologyValue('technology-react-275976'),
     vue: 'vuejs',
-    '@angular/core': 'angular',
-    svelte: 'svelte',
-    '@sveltejs/kit': 'sveltekit',
+    '@angular/core': technologyValue('technology-angular-a39f89'),
+    svelte: technologyValue('technology-svelte-c190ac'),
+    '@sveltejs/kit': technologyValue('technology-sveltekit-eefb03'),
     'solid-js': 'solidjs',
     '@solidjs/start': 'solidstart',
-    nuxt: 'nuxt',
-    astro: 'astro',
-    remix: 'remix',
+    nuxt: technologyValue('technology-nuxt-22c407'),
+    astro: technologyValue('technology-astro-23661e'),
+    remix: technologyValue('technology-remix-0c5d96'),
     gatsby: 'gatsby',
     qwik: 'qwik',
     // Styling
-    tailwindcss: 'tailwind',
+    tailwindcss: technologyValue('technology-tailwind-44c8cf'),
     'styled-components': 'styled-components',
     '@emotion/react': 'emotion',
     sass: 'sass',
@@ -38,25 +37,25 @@ const DEP_TO_TECH = {
     mobx: 'mobx',
     nanostores: 'nanostores',
     // Backend / Node
-    express: 'express',
-    fastify: 'fastify',
+    express: technologyValue('technology-express-008231'),
+    fastify: technologyValue('technology-fastify-cbe57e'),
     hono: 'hono',
     koa: 'koa',
-    nestjs: 'nestjs',
-    '@nestjs/core': 'nestjs',
+    nestjs: technologyValue('technology-nestjs-2d0087'),
+    '@nestjs/core': technologyValue('technology-nestjs-2d0087'),
     elysia: 'elysia',
     // ORMs / DB
-    prisma: 'prisma',
-    '@prisma/client': 'prisma',
-    'drizzle-orm': 'drizzle',
-    typeorm: 'typeorm',
-    sequelize: 'sequelize',
-    mongoose: 'mongoose',
+    prisma: technologyValue('technology-prisma-99497c'),
+    '@prisma/client': technologyValue('technology-prisma-99497c'),
+    'drizzle-orm': technologyValue('technology-drizzle-424f22'),
+    typeorm: technologyValue('technology-typeorm-527d4d'),
+    sequelize: technologyValue('technology-sequelize-d18291'),
+    mongoose: technologyValue('technology-mongoose-4e1812'),
     '@planetscale/database': 'planetscale',
     '@vercel/postgres': 'vercel-postgres',
     'better-sqlite3': 'sqlite',
     // BaaS / Cloud
-    '@supabase/supabase-js': 'supabase',
+    '@supabase/supabase-js': technologyValue('technology-supabase-4d7594'),
     firebase: 'firebase',
     'firebase-admin': 'firebase',
     '@aws-sdk/client-s3': 'aws',
@@ -73,15 +72,15 @@ const DEP_TO_TECH = {
     '@clerk/remix': 'clerk',
     'better-auth': 'better-auth',
     // Testing
-    vitest: 'vitest',
-    jest: 'jest',
-    playwright: 'playwright',
+    vitest: technologyValue('technology-vitest-a9127f'),
+    jest: technologyValue('technology-jest-35e99f'),
+    playwright: technologyValue('technology-playwright-7827e8'),
     cypress: 'cypress',
     '@testing-library/react': 'testing-library',
     storybook: 'storybook',
     '@storybook/react': 'storybook',
     // Build / Meta
-    typescript: 'typescript',
+    typescript: technologyValue('technology-typescript-969545'),
     vite: 'vite',
     turbo: 'turborepo',
     nx: 'nx',
@@ -97,23 +96,23 @@ const DEP_TO_TECH = {
     '@langchain/core': 'langchain',
     ollama: 'ollama',
     // Payments
-    stripe: 'stripe',
-    '@stripe/stripe-js': 'stripe',
+    stripe: technologyValue('technology-stripe-2bed20'),
+    '@stripe/stripe-js': technologyValue('technology-stripe-2bed20'),
     // APIs / GraphQL
-    graphql: 'graphql',
+    graphql: technologyValue('technology-graphql-aed31c'),
     'apollo-server': 'apollo',
     '@apollo/client': 'apollo',
-    trpc: 'trpc',
-    '@trpc/server': 'trpc',
+    trpc: technologyValue('technology-trpc-7a75ed'),
+    '@trpc/server': technologyValue('technology-trpc-7a75ed'),
     // Mobile
     'react-native': 'react-native',
     expo: 'expo',
     // Python (detectados en requirements.txt)
-    fastapi: 'fastapi',
-    django: 'django',
-    flask: 'flask',
-    sqlalchemy: 'sqlalchemy',
-    pydantic: 'pydantic',
+    fastapi: technologyValue('technology-fastapi-6aee0e'),
+    django: technologyValue('technology-django-7d8a08'),
+    flask: technologyValue('technology-flask-b87aa5'),
+    sqlalchemy: technologyValue('technology-sqlalchemy-37f268'),
+    pydantic: technologyValue('technology-pydantic-636623'),
 };
 async function readFileSafe(filePath) {
     try {
@@ -150,16 +149,16 @@ async function detectFromPackageJson(projectPath) {
     return techs;
 }
 const PYTHON_DEP_TO_TECH = {
-    fastapi: 'fastapi',
-    django: 'django',
-    flask: 'flask',
-    sqlalchemy: 'sqlalchemy',
-    pydantic: 'pydantic',
-    celery: 'celery',
-    pytest: 'pytest',
-    uvicorn: 'fastapi',
-    starlette: 'fastapi',
-    alembic: 'sqlalchemy',
+    fastapi: technologyValue('technology-fastapi-6aee0e'),
+    django: technologyValue('technology-django-7d8a08'),
+    flask: technologyValue('technology-flask-b87aa5'),
+    sqlalchemy: technologyValue('technology-sqlalchemy-37f268'),
+    pydantic: technologyValue('technology-pydantic-636623'),
+    celery: technologyValue('technology-celery-ddc517'),
+    pytest: technologyValue('technology-pytest-2b0121'),
+    uvicorn: technologyValue('technology-fastapi-6aee0e'),
+    starlette: technologyValue('technology-fastapi-6aee0e'),
+    alembic: technologyValue('technology-sqlalchemy-37f268'),
     torch: 'pytorch',
     tensorflow: 'tensorflow',
     pandas: 'pandas',
@@ -190,8 +189,8 @@ async function detectFromGemfile(projectPath) {
         return [];
     }
     const techs = [];
-    if (content.includes('rails')) {
-        techs.push('rails');
+    if (content.includes(technologyValue('technology-rails-2e1d59'))) {
+        techs.push(technologyValue('technology-rails-2e1d59'));
     }
     return techs;
 }

package/dist/engine/skill-generation/stack-content-generator.js

@@ -1,6 +1,4 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // engine/skill-generation/stack-content-generator.ts — SPEC-607
 // Generates rich, stack-aware skill content from JSON templates and detected project stack.
 import { readFile } from 'node:fs/promises';

package/dist/engine/skill-generator/workflow-skill-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685
 // Generates all 22 workflow skill files for a project.
 // Delegates placeholder substitution to adaptSkillContent (SPEC-682 — DRY).
@@ -48,7 +49,7 @@ function applyFallbacks(knowledge) {
         buildCommand: knowledge.buildCommand ?? 'npm run build',
         lintCommand: knowledge.lintCommand ?? 'npm run lint',
         // language is typed as string (non-null) — no fallback needed
-        language: knowledge.language || 'typescript',
+        language: knowledge.language || technologyValue('technology-typescript-969545'),
     };
 }
 // ---------------------------------------------------------------------------

package/dist/engine/skill-registry/ttl-refresh.js

@@ -3,6 +3,8 @@
 import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fetchAnthropicSkillContent } from './anthropic-adapter.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
 const TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const SKILLS_DIR = '.claude/skills';
 const MANIFEST_FILE = 'manifest.json';
@@ -37,7 +39,7 @@ function isStale(entry) {
 // Backup
 // ---------------------------------------------------------------------------
 async function backupSkill(projectPath, skillName, content) {
-    const cacheDir = join(projectPath, '.planu', 'skill-cache');
+    const cacheDir = join(resolveStorageLayout().cache, 'skills', hashProjectPath(projectPath));
     await mkdir(cacheDir, { recursive: true });
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     const fileName = `${skillName}-${ts}.md`;

package/dist/engine/skills/skills-fetcher.js

@@ -1,7 +1,4 @@
-// engine/skills/skills-fetcher.ts — SPEC-022: skills.sh catalog fetcher
-// Business logic for fetching and recommending AI agent skills.
-// Lives in engine/ so engine/ modules can import it without violating architecture.
-// SPEC-198: design/marketing skill detection added.
+import { technologyValue } from '../technology-registry.js';
 import { fetchUrl } from '../web-fetcher/http-client.js';
 const MARKETING_DIR_KEYWORDS = ['landing', 'marketing', 'brand', 'assets/brand', 'brand-assets'];
 const MARKETING_STACK_KEYWORDS = ['landing', 'saas', 'startup', 'website', 'brand', 'marketing'];
@@ -93,7 +90,7 @@ function buildFallbackSkills(knowledge) {
     const skills = [];
     const stackLower = knowledge.stack.map((s) => s.toLowerCase());
     const lang = knowledge.language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         skills.push({
             name: 'typescript-patterns',
             description: 'TypeScript best practices, strict mode patterns, and type safety conventions',
@@ -101,7 +98,7 @@ function buildFallbackSkills(knowledge) {
             justification: `Project uses ${knowledge.language}`,
         });
     }
-    if (stackLower.some((s) => s.includes('react'))) {
+    if (stackLower.some((s) => s.includes(technologyValue('technology-react-275976')))) {
         skills.push({
             name: 'react-patterns',
             description: 'React component patterns, hooks best practices, and performance optimization',

package/dist/engine/skills-reconciler.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/skills-reconciler.ts — SPEC-189: Detect stack changes and reconcile skills
 // SPEC-395: autoFixSkills — install missing, remove stale, repair corrupt paths.
 // SPEC-607: Detect old-format skills and new agents, trigger regeneration.
@@ -113,11 +114,9 @@ async function detectOldFormatSkills(projectPath) {
     }
     return oldFormat;
 }
-/** Agent presence signals (directory or file that indicates an agent is used). */
+/** Supported host presence signals handled by the canonical host asset writer. */
 const AGENT_PRESENCE_SIGNALS = {
-    cursor: '.cursor',
-    copilot: '.github',
-    gemini: 'GEMINI.md',
+    gemini: '.gemini',
 };
 /**
  * Detect AI agents that are present in the project but don't yet have skills
@@ -130,7 +129,7 @@ async function detectNewAgentTargets(projectPath) {
         try {
             await fs.access(signalPath);
             // Agent is present — check if it has any Planu skills
-            const hasSkills = await agentHasPlanuSkills(projectPath, agentName);
+            const hasSkills = await agentHasPlanuSkills(projectPath);
             if (!hasSkills) {
                 newTargets.push(agentName);
             }
@@ -141,40 +140,20 @@ async function detectNewAgentTargets(projectPath) {
     }));
     return newTargets;
 }
-/** Check if a specific agent already has Planu-generated skills. */
-async function agentHasPlanuSkills(projectPath, agentName) {
-    const checkPaths = [];
-    if (agentName === 'cursor') {
-        checkPaths.push(path.join(projectPath, '.cursor', 'rules'));
-    }
-    else if (agentName === 'copilot') {
-        checkPaths.push(path.join(projectPath, '.github', 'copilot-instructions.md'));
-    }
-    else if (agentName === 'gemini') {
-        checkPaths.push(path.join(projectPath, 'GEMINI.md'));
-    }
-    for (const p of checkPaths) {
-        try {
-            const stat = await fs.stat(p);
-            if (stat.isDirectory()) {
-                const entries = await fs.readdir(p);
-                if (entries.some((e) => e.endsWith('.mdc') || e.endsWith('.md'))) {
-                    return true;
-                }
-            }
-            else if (stat.isFile()) {
-                const content = await fs.readFile(p, 'utf-8');
-                // Check if Planu has appended content
-                if (content.includes('project-testing') || content.includes('project-deployment')) {
-                    return true;
-                }
-            }
-        }
-        catch {
-            /* not found */
+/** Check the canonical Gemini skills directory for Planu-generated skills. */
+async function agentHasPlanuSkills(projectPath) {
+    try {
+        const skillsPath = path.join(projectPath, '.gemini', 'skills');
+        const stat = await fs.stat(skillsPath);
+        if (!stat.isDirectory()) {
+            return false;
         }
+        const entries = await fs.readdir(skillsPath);
+        return entries.some((entry) => entry.startsWith('planu-') && entry.endsWith('.md'));
+    }
+    catch {
+        return false;
     }
-    return false;
 }
 /**
  * Compute a 0–100 health score.
@@ -194,9 +173,10 @@ function isProtectedBuiltInSkill(name, knowledge) {
     }
     const language = knowledge.language.toLowerCase();
     const stack = knowledge.stack.map((item) => item.toLowerCase());
-    return (language === 'typescript' ||
+    return (language === technologyValue('technology-typescript-969545') ||
         language === 'javascript' ||
-        stack.some((item) => item.includes('typescript') || item.includes('javascript')));
+        stack.some((item) => item.includes(technologyValue('technology-typescript-969545')) ||
+            item.includes('javascript')));
 }
 /** Return a neutral reconciliation when prerequisites are missing. */
 function buildEmptyReconciliation(_reason) {

package/dist/engine/spec-coverage/test-finder.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/spec-coverage/test-finder.ts — Finds test files in a project using
 // multi-ecosystem naming conventions. Pure I/O, no analysis logic.
 import { readFile } from 'node:fs/promises';
@@ -8,7 +9,7 @@ import { glob } from 'glob';
 // ---------------------------------------------------------------------------
 const ECOSYSTEM_PATTERNS = [
     {
-        ecosystem: 'typescript',
+        ecosystem: technologyValue('technology-typescript-969545'),
         patterns: ['**/*.test.ts', '**/*.spec.ts', '**/*.test.js', '**/*.spec.js'],
     },
     { ecosystem: 'python', patterns: ['**/*_test.py', '**/test_*.py'] },
@@ -61,17 +62,17 @@ const SUPERFICIAL_PATTERNS = [
 // ---------------------------------------------------------------------------
 const RUNNER_DETECTORS = [
     {
-        name: 'vitest',
-        ecosystem: 'typescript',
+        name: technologyValue('technology-vitest-a9127f'),
+        ecosystem: technologyValue('technology-typescript-969545'),
         configFiles: ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mts'],
     },
     {
-        name: 'jest',
-        ecosystem: 'typescript',
+        name: technologyValue('technology-jest-35e99f'),
+        ecosystem: technologyValue('technology-typescript-969545'),
         configFiles: ['jest.config.ts', 'jest.config.js', 'jest.config.cjs'],
     },
     {
-        name: 'pytest',
+        name: technologyValue('technology-pytest-2b0121'),
         ecosystem: 'python',
         configFiles: ['pytest.ini', 'pyproject.toml', 'setup.cfg'],
     },

package/dist/engine/spec-diff-engine.js

@@ -90,12 +90,12 @@ function computeLineDiffIterative(linesA, linesB) {
     while (ia < linesA.length || ib < linesB.length) {
         const lineA = linesA[ia];
         const lineB = linesB[ib];
-        if (ia >= linesA.length || lineB === undefined) {
+        if (ia >= linesA.length || lineA === undefined) {
             result.push({ type: 'added', content: lineB ?? '', lineNumberB: ib + 1 });
             ib++;
         }
-        else if (ib >= linesB.length || lineA === undefined) {
-            result.push({ type: 'removed', content: lineA ?? '', lineNumberA: ia + 1 });
+        else if (ib >= linesB.length || lineB === undefined) {
+            result.push({ type: 'removed', content: lineA, lineNumberA: ia + 1 });
             ia++;
         }
         else if (lineA === lineB) {

package/dist/engine/spec-generator/api-key-resolver.d.ts

@@ -1,4 +1,4 @@
 export declare class ApiKeyResolver {
-    resolveAnthropicKey(projectPath: string): Promise<string | undefined>;
+    resolveAnthropicKey(_projectPath: string): Promise<string | undefined>;
 }
 //# sourceMappingURL=api-key-resolver.d.ts.map

package/dist/engine/spec-generator/api-key-resolver.js

@@ -1,31 +1,10 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
 export class ApiKeyResolver {
-    async resolveAnthropicKey(projectPath) {
+    resolveAnthropicKey(_projectPath) {
         const envKey = process.env.PLANU_ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY;
         if (envKey?.trim()) {
-            return envKey.trim();
+            return Promise.resolve(envKey.trim());
         }
-        for (const file of [
-            join(projectPath, 'src/config/api-keys.json'),
-            join(projectPath, '.planu/api-keys.json'),
-        ]) {
-            const key = await readKeyFile(file);
-            if (key) {
-                return key;
-            }
-        }
-        return undefined;
-    }
-}
-async function readKeyFile(path) {
-    try {
-        const parsed = JSON.parse(await readFile(path, 'utf-8'));
-        const key = parsed.anthropic?.apiKey;
-        return key?.trim() ? key.trim() : undefined;
-    }
-    catch {
-        return undefined;
+        return Promise.resolve(undefined);
     }
 }
 //# sourceMappingURL=api-key-resolver.js.map

package/dist/engine/spec-generators/issue-extractor.js

@@ -1,8 +1,14 @@
-// engine/spec-generators/issue-extractor.ts — SPEC-472: Convert ExtractedIssue to spec draft
-// Per-source extractors live in subdirectory but are loaded dynamically when needed.
+import { technologyValue } from '../technology-registry.js';
 const FRONTEND_LABELS = new Set(['ui', 'ux', 'frontend', 'design', 'css', 'component']);
 const BACKEND_LABELS = new Set(['api', 'backend', 'database', 'sql', 'server', 'rpc']);
-const INFRA_LABELS = new Set(['infra', 'ci', 'cd', 'deploy', 'docker', 'kubernetes']);
+const INFRA_LABELS = new Set([
+    'infra',
+    'ci',
+    'cd',
+    'deploy',
+    technologyValue('technology-docker-d548c5'),
+    technologyValue('technology-kubernetes-94abcb'),
+]);
 const BUGFIX_LABELS = new Set(['bug', 'bugfix', 'fix', 'defect', 'broken']);
 const DOCS_LABELS = new Set(['docs', 'documentation', 'readme']);
 const REFACTOR_LABELS = new Set(['refactor', 'cleanup', 'tech-debt', 'rewrite']);

package/dist/engine/spec-migrator/drift-detector.js

@@ -3,15 +3,7 @@ import { readdir, stat, access, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isOldFormat } from './lean-migration.js';
 import { isNativeActive, fastScanSpecs } from '../core-bridge.js';
-/** Files considered non-canonical in planu/ root (mirrors planu-root-cleaner.ts logic). */
-const CANONICAL_ROOT_FILES = new Set([
-    'status.json',
-    'conventions.json',
-    'index.html',
-    'roadmap.html',
-]);
-const CANONICAL_ROOT_DIRS = new Set(['specs']);
-const CANONICAL_SPEC_FILES = new Set(['spec.md']);
+import { isCanonicalPlanuRootDir, isCanonicalPlanuRootFile, isCanonicalSpecFile, } from './planu-canonical-policy.js';
 async function scanPlanuRoot(projectPath) {
     const rootFiles = [];
     const planuDir = join(projectPath, 'planu');
@@ -22,11 +14,11 @@ async function scanPlanuRoot(projectPath) {
             try {
                 const info = await stat(fullPath);
                 if (info.isDirectory()) {
-                    if (!CANONICAL_ROOT_DIRS.has(entry)) {
+                    if (!isCanonicalPlanuRootDir(entry)) {
                         rootFiles.push(entry);
                     }
                 }
-                else if (!CANONICAL_ROOT_FILES.has(entry)) {
+                else if (!isCanonicalPlanuRootFile(entry)) {
                     rootFiles.push(entry);
                 }
             }
@@ -56,7 +48,7 @@ async function scanSpecDirs(specsDir, specDirEntries, unifiedSpecs, leanSpecs) {
             const specId = idMatch?.[1]?.toUpperCase() ?? entry;
             const specFiles = await readdir(specPath);
             for (const file of specFiles) {
-                if (!CANONICAL_SPEC_FILES.has(file)) {
+                if (!isCanonicalSpecFile(file)) {
                     rootFiles.push(`${entry}/${file}`);
                 }
             }
@@ -115,7 +107,7 @@ export async function detectDrift(projectPath) {
                 }
                 const specFiles = await readdir(specPath);
                 for (const file of specFiles) {
-                    if (!CANONICAL_SPEC_FILES.has(file)) {
+                    if (!isCanonicalSpecFile(file)) {
                         rootFiles.push(`${entry}/${file}`);
                     }
                 }

package/dist/engine/spec-migrator/filesystem-import.js

@@ -3,10 +3,12 @@ import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseFrontmatterLocal, validSpecType, validSpecScope, validSpecStatus, validRiskLevel, validSpecTarget, validDifficulty, } from './frontmatter-parser.js';
 const SPEC_FOLDER_ID_RE = /^(SPEC-\d{3,})/;
-function buildSpecFromMetadata(specId, entryName, projectId, metadata) {
+function buildSpecFromMetadata(specId, entryName, projectPath, projectId, metadata) {
     const now = new Date().toISOString();
-    const folder = `planu/specs/${entryName}`;
+    const folder = join(projectPath, 'planu', 'specs', entryName);
+    const specPath = join(folder, 'spec.md');
     const slug = entryName.replace(/^SPEC-\d{3,}-/, '');
+    const stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
     return {
         id: specId,
         title: typeof metadata.title === 'string' ? metadata.title : specId,
@@ -20,9 +22,9 @@ function buildSpecFromMetadata(specId, entryName, projectId, metadata) {
         projectId,
         createdAt: typeof metadata.created === 'string' ? new Date(metadata.created).toISOString() : now,
         updatedAt: now,
-        specPath: `${folder}/spec.md`,
-        technicalPath: `${folder}/technical.md`,
-        progressPath: `${folder}/progress.md`,
+        specPath,
+        technicalPath: specPath,
+        progressPath: '',
         estimation: {
             devHours: 0,
             reviewHours: 0,
@@ -41,10 +43,12 @@ function buildSpecFromMetadata(specId, entryName, projectId, metadata) {
             },
         },
         actuals: null,
-        tags: Array.isArray(metadata.tags) ? metadata.tags : [],
-        dependencies: [],
-        blockedBy: [],
-        gitBranch: `feat/${specId.toLowerCase()}-${slug}`,
+        tags: stringList(metadata.tags),
+        dependencies: stringList(metadata.dependencies),
+        blockedBy: stringList(metadata.blockedBy),
+        gitBranch: typeof metadata.branch === 'string'
+            ? metadata.branch
+            : `feat/${specId.toLowerCase()}-${slug}`,
         impactAnalysis: null,
     };
 }
@@ -82,7 +86,7 @@ export async function importFilesystemSpecs(projectPath, deps, projectId) {
         try {
             const content = await readFile(specMdPath, 'utf-8');
             const { metadata } = parseFrontmatterLocal(content);
-            const spec = buildSpecFromMetadata(specId, entry.name, projectId, metadata);
+            const spec = buildSpecFromMetadata(specId, entry.name, projectPath, projectId, metadata);
             await deps.createSpec(projectId, spec);
             storeIds.add(specId);
             importedCount++;

package/dist/engine/spec-migrator/planu-canonical-policy.js

@@ -1,7 +1,14 @@
 // engine/spec-migrator/planu-canonical-policy.ts — SPEC-1017
 // Single source of truth for the strict Planu managed directory contract.
 export const PLANU_CANONICAL_POLICY = {
-    canonicalRootFiles: ['conventions.json', 'context.md', 'session-context.md', 'session.json'],
+    canonicalRootFiles: [
+        'conventions.json',
+        'context.md',
+        'project.json',
+        'session-context.md',
+        'session.json',
+        'technology-selection.json',
+    ],
     canonicalRootDirs: ['releases', 'specs'],
     canonicalSpecFiles: ['spec.md'],
     canonicalSpecDirs: [],
@@ -64,8 +71,10 @@ export function canonicalContractText() {
         'planu/',
         '  conventions.json',
         '  context.md',
+        '  project.json',
         '  session-context.md',
         '  session.json',
+        '  technology-selection.json',
         '  releases/',
         '    pending.json',
         '  specs/',