@planu/cli 4.13.0 → 5.0.0

package/dist/storage/storage-catalog.js

@@ -0,0 +1,390 @@
+/* eslint-disable max-lines -- catalog families remain co-located for machine-readable ownership auditing */
+import { isAbsolute, join } from 'node:path';
+import { resolveStorageLayout } from './storage-layout.js';
+import { absoluteProjectPath, validStorageIdentifier } from './storage-catalog-validation.js';
+/**
+ * Machine-readable authority for Planu artifact ownership and paths.
+ * Portable paths deliberately use templates when no project context is supplied.
+ */
+// eslint-disable-next-line max-lines-per-function, complexity -- declarative entries remain auditable together
+export function createStorageCatalog(context = {}) {
+    const layout = context.layout ?? resolveStorageLayout();
+    const projectId = validStorageIdentifier(context.logicalProjectId, 'logicalProjectId');
+    const workspaceKeyHash = validStorageIdentifier(context.workspaceKeyHash, 'workspaceKeyHash');
+    const projectPath = absoluteProjectPath(context.projectPath);
+    const portableRoot = projectPath ? join(projectPath, 'planu') : undefined;
+    const runtimeProjectRoot = projectId ? join(layout.projects, projectId) : layout.projects;
+    const entries = [
+        {
+            id: 'portable-project-identity',
+            templatePath: '<project>/planu/project.json',
+            resolvedPath: portableRoot ? join(portableRoot, 'project.json') : undefined,
+            purpose: 'Stable logical project identity and schema version.',
+            owner: 'project',
+            sourceOfTruth: true,
+            lifecycle: 'portable',
+            sensitivity: 'internal',
+            portability: 'portable',
+            retention: 'project lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'portable-specifications',
+            templatePath: '<project>/planu/specs/<spec-id>/spec.md',
+            resolvedPath: portableRoot ? join(portableRoot, 'specs') : undefined,
+            purpose: 'Approved human-readable specification contract.',
+            owner: 'project',
+            sourceOfTruth: true,
+            lifecycle: 'portable',
+            sensitivity: 'internal',
+            portability: 'portable',
+            retention: 'project lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'portable-conventions',
+            templatePath: '<project>/planu/conventions.json',
+            resolvedPath: portableRoot ? join(portableRoot, 'conventions.json') : undefined,
+            purpose: 'Versioned project conventions consumed by every agent host.',
+            owner: 'project',
+            sourceOfTruth: true,
+            lifecycle: 'portable',
+            sensitivity: 'internal',
+            portability: 'portable',
+            retention: 'project lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'portable-context',
+            templatePath: '<project>/planu/{context.md,session-context.md}',
+            resolvedPath: portableRoot,
+            purpose: 'Portable project and handoff context without machine home paths.',
+            owner: 'project',
+            sourceOfTruth: true,
+            lifecycle: 'portable',
+            sensitivity: 'internal',
+            portability: 'portable',
+            retention: 'project lifetime with explicit compaction',
+            rebuildable: false,
+        },
+        {
+            id: 'portable-release-evidence',
+            templatePath: '<project>/planu/releases/',
+            resolvedPath: portableRoot ? join(portableRoot, 'releases') : undefined,
+            purpose: 'Versioned release declarations and portable verification evidence.',
+            owner: 'project',
+            sourceOfTruth: true,
+            lifecycle: 'portable',
+            sensitivity: 'internal',
+            portability: 'portable',
+            retention: 'release history',
+            rebuildable: false,
+        },
+        {
+            id: 'runtime-database',
+            templatePath: '<data>/runtime/planu.sqlite3',
+            resolvedPath: layout.runtimeDatabase,
+            purpose: 'Transactional runtime, job, outbox, index and audit state.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'export-redacted',
+            retention: 'until explicit project deletion',
+            rebuildable: false,
+        },
+        {
+            id: 'validation-receipts',
+            templatePath: '<data>/runtime/planu.sqlite3#runtime_records(validation-receipt:*)',
+            resolvedPath: layout.runtimeDatabase,
+            purpose: 'Authentic validation receipts indexed by current spec and immutable receipt digest.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'export-redacted',
+            retention: 'validation evidence lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'validation-logs',
+            templatePath: '<logs>/validation/<sha256>.log',
+            resolvedPath: join(layout.logs, 'validation'),
+            purpose: 'Content-addressed validation logs referenced by authentic receipts.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'export-redacted',
+            retention: 'validation evidence lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'runtime-project-files',
+            templatePath: '<data>/projects/<logical-project-id>/',
+            resolvedPath: runtimeProjectRoot,
+            purpose: 'Catalog-owned project projections and migration checkpoints.',
+            owner: 'runtime',
+            sourceOfTruth: false,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'export-redacted',
+            retention: 'until explicit project deletion',
+            rebuildable: true,
+        },
+        {
+            id: 'workspace-state',
+            templatePath: '<state>/workspaces/identities/<workspace-key-hash>/<logical-project-id>.json',
+            resolvedPath: workspaceKeyHash && projectId
+                ? join(layout.state, 'workspaces', 'identities', workspaceKeyHash, `${projectId}.json`)
+                : undefined,
+            purpose: 'Machine-local state isolated between concurrent clones.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'workspace lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'installation-manifest',
+            templatePath: '<config>/installation.json',
+            resolvedPath: layout.installationManifest,
+            purpose: 'Verified CLI, native and host-adapter installation inventory.',
+            owner: 'installer',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'installation lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'runtime-configuration',
+            templatePath: '<config>/',
+            resolvedPath: layout.config,
+            purpose: 'Machine-local product configuration containing no secret values.',
+            owner: 'operator',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'export-redacted',
+            retention: 'installation lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'plugin-state',
+            templatePath: '<data>/global/plugins-state.json',
+            resolvedPath: join(layout.data, 'global', 'plugins-state.json'),
+            purpose: 'Machine-local registry of installed plugins and their activation state.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'installation lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'custom-framework-registry',
+            templatePath: '<data>/global/registry-custom.json',
+            resolvedPath: join(layout.data, 'global', 'registry-custom.json'),
+            purpose: 'User-defined framework registry extensions.',
+            owner: 'operator',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'export-redacted',
+            retention: 'until explicit user deletion',
+            rebuildable: false,
+        },
+        {
+            id: 'custom-spec-templates',
+            templatePath: '<data>/global/spec-templates/custom/',
+            resolvedPath: join(layout.data, 'global', 'spec-templates', 'custom'),
+            purpose: 'User-authored specification templates.',
+            owner: 'operator',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'export-redacted',
+            retention: 'until explicit user deletion',
+            rebuildable: false,
+        },
+        {
+            id: 'tool-group-state',
+            templatePath: '<data>/global/tool-group-state.json',
+            resolvedPath: join(layout.data, 'global', 'tool-group-state.json'),
+            purpose: 'Persisted activation state for Planu tool groups.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'installation lifetime',
+            rebuildable: false,
+        },
+        {
+            id: 'dynamic-knowledge-cache',
+            templatePath: '<cache>/knowledge/cache.json',
+            resolvedPath: join(layout.cache, 'knowledge', 'cache.json'),
+            purpose: 'TTL-bounded cache for dynamic knowledge queries.',
+            owner: 'runtime',
+            sourceOfTruth: false,
+            lifecycle: 'ephemeral',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'TTL and entry-count bounded',
+            rebuildable: true,
+        },
+        {
+            id: 'tool-discovery-cache',
+            templatePath: '<cache>/discovery/discovery-cache.json',
+            resolvedPath: join(layout.cache, 'discovery', 'discovery-cache.json'),
+            purpose: 'Rebuildable cache of external tooling discovery results.',
+            owner: 'runtime',
+            sourceOfTruth: false,
+            lifecycle: 'ephemeral',
+            sensitivity: 'public',
+            portability: 'machine-local',
+            retention: 'TTL bounded',
+            rebuildable: true,
+        },
+        {
+            id: 'runtime-locks',
+            templatePath: '<state>/locks/planu-locks.sqlite3',
+            resolvedPath: layout.lockDatabase,
+            purpose: 'Transactional cross-process leases with compare-and-swap fencing.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'ephemeral',
+            sensitivity: 'internal',
+            portability: 'machine-local',
+            retention: 'active leases plus monotonic fencing tombstones',
+            rebuildable: true,
+        },
+        {
+            id: 'native-cache',
+            templatePath: '<cache>/native/<version>/<target>/',
+            resolvedPath: layout.nativeCache,
+            purpose: 'Verified native artifacts that can be downloaded or rebuilt again.',
+            owner: 'native',
+            sourceOfTruth: false,
+            lifecycle: 'ephemeral',
+            sensitivity: 'public',
+            portability: 'machine-local',
+            retention: 'bounded by installed and last-known-good versions',
+            rebuildable: true,
+        },
+        {
+            id: 'runtime-logs',
+            templatePath: '<logs>/',
+            resolvedPath: layout.logs,
+            purpose: 'Redacted operational diagnostics.',
+            owner: 'operator',
+            sourceOfTruth: false,
+            lifecycle: 'ephemeral',
+            sensitivity: 'sensitive',
+            portability: 'machine-local',
+            retention: 'bounded rolling retention',
+            rebuildable: true,
+        },
+        {
+            id: 'portable-exports',
+            templatePath: '<data>/exports/<bundle-id>.planu-bundle',
+            resolvedPath: join(layout.data, 'exports'),
+            purpose: 'Versioned, checksummed and redacted user-requested execution bundles.',
+            owner: 'operator',
+            sourceOfTruth: false,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'portable',
+            retention: 'until explicit user deletion',
+            rebuildable: true,
+        },
+        {
+            id: 'migration-journals',
+            templatePath: '<state>/migrations/<migration-id>/',
+            resolvedPath: join(layout.state, 'migrations'),
+            purpose: 'Resumable migration journal, checksums and rollback checkpoints.',
+            owner: 'runtime',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'sensitive',
+            portability: 'machine-local',
+            retention: 'through verified migration and rollback TTL',
+            rebuildable: false,
+        },
+        {
+            id: 'secret-references',
+            templatePath: '<secrets>/references.json',
+            resolvedPath: layout.secrets,
+            purpose: 'References to OS-protected secrets; never plaintext secret values.',
+            owner: 'operator',
+            sourceOfTruth: true,
+            lifecycle: 'persistent',
+            sensitivity: 'secret-reference',
+            portability: 'machine-local',
+            retention: 'until explicit credential removal',
+            rebuildable: false,
+        },
+        {
+            id: 'recoverable-trash',
+            templatePath: '<state>/trash/',
+            resolvedPath: layout.trash,
+            purpose: 'Recoverable quarantine for catalog-driven garbage collection.',
+            owner: 'operator',
+            sourceOfTruth: false,
+            lifecycle: 'recoverable-trash',
+            sensitivity: 'sensitive',
+            portability: 'machine-local',
+            retention: 'configured trash TTL',
+            rebuildable: false,
+        },
+    ];
+    const combined = [...entries, ...(context.additionalEntries ?? [])];
+    const ids = new Set();
+    for (const entry of combined) {
+        if (!validStorageIdentifier(entry.id, 'artifact family id') || ids.has(entry.id)) {
+            throw new Error(`[Planu] Duplicate or invalid storage artifact family: ${entry.id}`);
+        }
+        if (entry.resolvedPath !== undefined && !isAbsolute(entry.resolvedPath)) {
+            throw new Error(`[Planu] Resolved catalog path must be absolute: ${entry.id}`);
+        }
+        ids.add(entry.id);
+    }
+    return combined;
+}
+/** Per-process extensible catalog without global mutable registration. */
+export class StorageCatalog {
+    entriesById;
+    constructor(context = {}) {
+        this.entriesById = new Map(createStorageCatalog(context).map((entry) => [entry.id, entry]));
+    }
+    list() {
+        return [...this.entriesById.values()];
+    }
+    get(id) {
+        const entry = this.entriesById.get(id);
+        if (!entry) {
+            throw new Error(`[Planu] Unknown storage artifact family: ${id}`);
+        }
+        return entry;
+    }
+}
+export function storageCatalogById(id, context = {}) {
+    const entry = createStorageCatalog(context).find((candidate) => candidate.id === id);
+    if (!entry) {
+        throw new Error(`[Planu] Unknown storage artifact family: ${id}`);
+    }
+    return entry;
+}
+export function resolvedStorageArtifactPath(id, context = {}) {
+    const entry = storageCatalogById(id, context);
+    if (entry.resolvedPath === undefined) {
+        throw new Error(`[Planu] Storage artifact family has no resolved path: ${id}`);
+    }
+    return entry.resolvedPath;
+}
+//# sourceMappingURL=storage-catalog.js.map

package/dist/storage/storage-layout.d.ts

@@ -0,0 +1,24 @@
+export interface StorageRoots {
+    readonly config: string;
+    readonly data: string;
+    readonly cache: string;
+    readonly state: string;
+    readonly logs: string;
+    readonly secrets: string;
+}
+export interface StorageLayout extends StorageRoots {
+    readonly runtimeDatabase: string;
+    readonly lockDatabase: string;
+    readonly projects: string;
+    readonly installationManifest: string;
+    readonly nativeCache: string;
+    readonly trash: string;
+}
+export interface StorageLayoutOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly homeDirectory?: string;
+    readonly platform?: NodeJS.Platform;
+}
+/** Resolve every machine-local Planu path independently from the current directory. */
+export declare function resolveStorageLayout(options?: StorageLayoutOptions): StorageLayout;
+//# sourceMappingURL=storage-layout.d.ts.map

package/dist/storage/storage-layout.js

@@ -0,0 +1,101 @@
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+function absoluteHome(value) {
+    const candidate = value ?? homedir();
+    if (!isAbsolute(candidate)) {
+        throw new Error('[Planu] homeDirectory must be an absolute path');
+    }
+    return resolve(candidate);
+}
+function absoluteOverride(value) {
+    const candidate = value?.trim();
+    if (!candidate) {
+        return undefined;
+    }
+    if (!isAbsolute(candidate)) {
+        throw new Error('[Planu] PLANU_HOME must be an absolute path');
+    }
+    return resolve(candidate);
+}
+function environmentRoot(value, label, fallback) {
+    const candidate = value?.trim();
+    if (!candidate) {
+        return fallback;
+    }
+    if (!isAbsolute(candidate)) {
+        throw new Error(`[Planu] ${label} must be an absolute path`);
+    }
+    return resolve(candidate);
+}
+function windowsRoots(home, env) {
+    const roaming = environmentRoot(env.APPDATA, 'APPDATA', join(home, 'AppData', 'Roaming'));
+    const local = environmentRoot(env.LOCALAPPDATA, 'LOCALAPPDATA', join(home, 'AppData', 'Local'));
+    return {
+        config: join(roaming, 'Planu', 'config'),
+        data: join(local, 'Planu', 'data'),
+        cache: join(local, 'Planu', 'cache'),
+        state: join(local, 'Planu', 'state'),
+        logs: join(local, 'Planu', 'logs'),
+        secrets: join(roaming, 'Planu', 'secrets'),
+    };
+}
+function macosRoots(home) {
+    const applicationSupport = join(home, 'Library', 'Application Support', 'Planu');
+    return {
+        config: join(applicationSupport, 'config'),
+        data: join(applicationSupport, 'data'),
+        cache: join(home, 'Library', 'Caches', 'Planu'),
+        state: join(applicationSupport, 'state'),
+        logs: join(home, 'Library', 'Logs', 'Planu'),
+        secrets: join(applicationSupport, 'secrets'),
+    };
+}
+function xdgRoots(home, env) {
+    const config = environmentRoot(env.XDG_CONFIG_HOME, 'XDG_CONFIG_HOME', join(home, '.config'));
+    const data = environmentRoot(env.XDG_DATA_HOME, 'XDG_DATA_HOME', join(home, '.local', 'share'));
+    const cache = environmentRoot(env.XDG_CACHE_HOME, 'XDG_CACHE_HOME', join(home, '.cache'));
+    const state = environmentRoot(env.XDG_STATE_HOME, 'XDG_STATE_HOME', join(home, '.local', 'state'));
+    return {
+        config: join(config, 'planu'),
+        data: join(data, 'planu'),
+        cache: join(cache, 'planu'),
+        state: join(state, 'planu'),
+        logs: join(state, 'planu', 'logs'),
+        secrets: join(config, 'planu', 'secrets'),
+    };
+}
+function resolvePlatformRoots(platform, home, env) {
+    if (platform === 'win32') {
+        return windowsRoots(home, env);
+    }
+    if (platform === 'darwin') {
+        return macosRoots(home);
+    }
+    return xdgRoots(home, env);
+}
+/** Resolve every machine-local Planu path independently from the current directory. */
+export function resolveStorageLayout(options = {}) {
+    const env = options.env ?? process.env;
+    const home = absoluteHome(options.homeDirectory);
+    const override = absoluteOverride(env.PLANU_HOME);
+    const roots = override
+        ? {
+            config: join(override, 'config'),
+            data: join(override, 'data'),
+            cache: join(override, 'cache'),
+            state: join(override, 'state'),
+            logs: join(override, 'logs'),
+            secrets: join(override, 'secrets'),
+        }
+        : resolvePlatformRoots(options.platform ?? process.platform, home, env);
+    return {
+        ...roots,
+        runtimeDatabase: join(roots.data, 'runtime', 'planu.sqlite3'),
+        lockDatabase: join(roots.state, 'locks', 'planu-locks.sqlite3'),
+        projects: join(roots.data, 'projects'),
+        installationManifest: join(roots.config, 'installation.json'),
+        nativeCache: join(roots.cache, 'native'),
+        trash: join(roots.state, 'trash'),
+    };
+}
+//# sourceMappingURL=storage-layout.js.map

package/dist/storage/storybook-store.js

@@ -1,9 +1,9 @@
 // storage/storybook-store.ts — Persistence for Storybook component catalog (SPEC-432)
 import { join } from 'node:path';
-import { hashProjectPath, readJson, writeJson } from './base-store.js';
+import { hashProjectPath, projectDataDir, readJson, writeJson } from './base-store.js';
 function storybookPath(projectPath) {
     const id = hashProjectPath(projectPath);
-    return join('data', 'projects', id, 'storybook-components.json');
+    return join(projectDataDir(id), 'storybook-components.json');
 }
 export async function getStorybookComponents(projectPath) {
     const filePath = storybookPath(projectPath);

package/dist/storage/supabase-store.js

@@ -1,11 +1,12 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../engine/technology-registry.js';
 // storage/supabase-store.ts — Supabase integration persistence (SPEC-437)
 import { join } from 'node:path';
-import { hashProjectPath, readJson, writeJson } from './base-store.js';
+import { hashProjectPath, projectDataDir, readJson, writeJson } from './base-store.js';
+import { resolveSecretField, storeSecretField } from '../security/secret-field.js';
+import { writeSecureJson } from '../security/secure-json.js';
 function projectDir(projectPath) {
     const id = hashProjectPath(projectPath);
-    return join('data', 'projects', id, 'supabase');
+    return join(projectDataDir(id), technologyValue('technology-supabase-4d7594'));
 }
 function configPath(projectPath) {
     return join(projectDir(projectPath), 'config.json');
@@ -14,10 +15,27 @@ function syncPath(projectPath) {
     return join(projectDir(projectPath), 'sync.json');
 }
 export async function getSupabaseConfig(projectPath) {
-    return readJson(configPath(projectPath), null);
+    const config = await readJson(configPath(projectPath), null);
+    if (!config) {
+        return null;
+    }
+    return {
+        ...config,
+        serviceRoleKey: await resolveSecretField(config.serviceRoleKey),
+        ...(config.anonKey ? { anonKey: await resolveSecretField(config.anonKey) } : {}),
+    };
 }
 export async function saveSupabaseConfig(projectPath, config) {
-    await writeJson(configPath(projectPath), config);
+    const id = hashProjectPath(projectPath);
+    const serviceRoleKey = await storeSecretField(`${id}/supabase/service-role`, 'supabase-service-role', config.serviceRoleKey);
+    const anonKey = config.anonKey
+        ? await storeSecretField(`${id}/supabase/anon`, 'supabase-anon', config.anonKey)
+        : undefined;
+    await writeSecureJson(configPath(projectPath), {
+        ...config,
+        serviceRoleKey,
+        ...(anonKey ? { anonKey } : {}),
+    });
 }
 export async function getSupabaseSyncResult(projectPath) {
     return readJson(syncPath(projectPath), null);

package/dist/storage/tdd-policy-store.js

@@ -1,8 +1,7 @@
 // SPEC-452 — TDD Policy persistence
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { safeJsonParse } from './base-store.js';
-const DATA_DIR = 'data/projects';
+import { projectDataDir, safeJsonParse } from './base-store.js';
 const FILE_NAME = 'tdd-policy.json';
 const DEFAULT_POLICY = {
     mode: 'soft',
@@ -10,17 +9,20 @@ const DEFAULT_POLICY = {
     requireEdgeTests: false,
 };
 export async function getTddPolicy(projectId) {
-    const filePath = join(DATA_DIR, projectId, FILE_NAME);
+    const filePath = join(projectDataDir(projectId), FILE_NAME);
     try {
         const raw = await readFile(filePath, 'utf-8');
         return { ...DEFAULT_POLICY, ...safeJsonParse(raw, {}) };
     }
-    catch {
-        return { ...DEFAULT_POLICY };
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { ...DEFAULT_POLICY };
+        }
+        throw error;
     }
 }
 export async function saveTddPolicy(projectId, policy) {
-    const dir = join(DATA_DIR, projectId);
+    const dir = projectDataDir(projectId);
     await mkdir(dir, { recursive: true });
     await writeFile(join(dir, FILE_NAME), JSON.stringify(policy, null, 2), 'utf-8');
 }

package/dist/storage/tech-debt-store.js

@@ -1,12 +1,12 @@
-import { readJson, writeJson, hashProjectPath } from './base-store.js';
+import { readJson, writeJson, hashProjectPath, projectDataDir } from './base-store.js';
 import { withFileLock } from './file-mutex.js';
 function debtFile(projectPath) {
     const hash = hashProjectPath(projectPath);
-    return `data/projects/${hash}/tech-debt.json`;
+    return `${projectDataDir(hash)}/tech-debt.json`;
 }
 function configFile(projectPath) {
     const hash = hashProjectPath(projectPath);
-    return `data/projects/${hash}/tech-debt-config.json`;
+    return `${projectDataDir(hash)}/tech-debt-config.json`;
 }
 /** Load all tech debt items for a project. */
 export async function loadTechDebt(projectPath) {

package/dist/storage/technology-selection-store.d.ts

@@ -1,5 +1,5 @@
 import type { TechnologySelectionContract } from '../types/index.js';
-export declare const TECHNOLOGY_SELECTION_RELATIVE_PATH = ".planu/technology-selection.json";
+export declare const TECHNOLOGY_SELECTION_RELATIVE_PATH = "planu/technology-selection.json";
 export declare function readTechnologySelectionContract(projectPath: string): Promise<TechnologySelectionContract | null>;
 export declare function writeTechnologySelectionContract(projectPath: string, contract: TechnologySelectionContract): Promise<void>;
 //# sourceMappingURL=technology-selection-store.d.ts.map

package/dist/storage/technology-selection-store.js

@@ -4,7 +4,7 @@ import { dirname, join } from 'node:path';
 import { writeJsonSafe } from '../engine/safety/atomic-writer.js';
 import { safeJsonParse } from './base-store.js';
 import { withFileLock } from './file-mutex.js';
-export const TECHNOLOGY_SELECTION_RELATIVE_PATH = '.planu/technology-selection.json';
+export const TECHNOLOGY_SELECTION_RELATIVE_PATH = 'planu/technology-selection.json';
 function contractPath(projectPath) {
     return join(projectPath, TECHNOLOGY_SELECTION_RELATIVE_PATH);
 }
@@ -30,8 +30,11 @@ export async function readTechnologySelectionContract(projectPath) {
         const parsed = safeJsonParse(raw, null);
         return isTechnologySelectionContract(parsed) ? parsed : null;
     }
-    catch {
-        return null;
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
     }
 }
 export async function writeTechnologySelectionContract(projectPath, contract) {