@planu/cli 4.13.0 → 4.14.1

package/dist/storage/storage-bundle.js

@@ -0,0 +1,117 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { RuntimeDatabase } from './runtime-db.js';
+import { resolveStorageLayout } from './storage-layout.js';
+const STORAGE_BUNDLE_SCHEMA = 1;
+const REDACTED = '[redacted]';
+const SENSITIVE_KEY = /(?:api[-_]?key|auth|bearer|credential|password|secret|token|private[-_]?key)/i;
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, canonicalize(item)]));
+    }
+    return value;
+}
+function checksum(value) {
+    return createHash('sha256')
+        .update(JSON.stringify(canonicalize(value)))
+        .digest('hex');
+}
+function redact(value) {
+    if (Array.isArray(value)) {
+        return value.map(redact);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            SENSITIVE_KEY.test(key) ? REDACTED : redact(item),
+        ]));
+    }
+    return value;
+}
+function requireAbsolute(path, label) {
+    if (!isAbsolute(path)) {
+        throw new Error(`[Planu] ${label} path must be absolute`);
+    }
+    return resolve(path);
+}
+async function writePrivateJson(path, value) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp.${String(process.pid)}.${randomBytes(6).toString('hex')}`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    catch (error) {
+        try {
+            await unlink(temporary);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw cleanupError;
+            }
+        }
+        throw error;
+    }
+}
+function openRuntimeDatabase(options) {
+    if (options?.database) {
+        return { database: options.database, owned: false };
+    }
+    return {
+        database: new RuntimeDatabase({ path: resolveStorageLayout().runtimeDatabase }),
+        owned: true,
+    };
+}
+export async function exportStorageBundle(projectId, outputPath, options) {
+    const destination = requireAbsolute(outputPath, 'Storage export');
+    const opened = openRuntimeDatabase(options);
+    try {
+        const payload = redact(opened.database.exportProject(projectId));
+        const bundle = {
+            schemaVersion: STORAGE_BUNDLE_SCHEMA,
+            createdAt: new Date().toISOString(),
+            runtimeSchemaVersion: opened.database.schemaVersion,
+            projectId,
+            payload,
+            checksum: checksum(payload),
+        };
+        await writePrivateJson(destination, bundle);
+        return bundle;
+    }
+    finally {
+        if (opened.owned) {
+            opened.database.close();
+        }
+    }
+}
+export async function importStorageBundle(inputPath, options) {
+    const source = requireAbsolute(inputPath, 'Storage import');
+    const parsed = JSON.parse(await readFile(source, 'utf8'));
+    if (parsed.schemaVersion !== STORAGE_BUNDLE_SCHEMA || !parsed.payload) {
+        throw new Error('[Planu] Unsupported storage bundle schema');
+    }
+    if (typeof parsed.projectId !== 'string' || parsed.payload.projectId !== parsed.projectId) {
+        throw new Error('[Planu] Storage bundle project identity mismatch');
+    }
+    if (typeof parsed.checksum !== 'string' || checksum(parsed.payload) !== parsed.checksum) {
+        throw new Error('[Planu] Storage bundle checksum mismatch');
+    }
+    const opened = openRuntimeDatabase(options);
+    try {
+        opened.database.importProject(parsed.payload);
+        return parsed;
+    }
+    finally {
+        if (opened.owned) {
+            opened.database.close();
+        }
+    }
+}
+//# sourceMappingURL=storage-bundle.js.map

package/dist/storage/storage-catalog-validation.d.ts

@@ -0,0 +1,3 @@
+export declare function validStorageIdentifier(value: string | undefined, label: string): string | undefined;
+export declare function absoluteProjectPath(value: string | undefined): string | undefined;
+//# sourceMappingURL=storage-catalog-validation.d.ts.map

package/dist/storage/storage-catalog-validation.js

@@ -0,0 +1,20 @@
+import { isAbsolute, resolve } from 'node:path';
+export function validStorageIdentifier(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)) {
+        throw new Error(`[Planu] Invalid ${label}`);
+    }
+    return value;
+}
+export function absoluteProjectPath(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isAbsolute(value)) {
+        throw new Error('[Planu] projectPath must be absolute');
+    }
+    return resolve(value);
+}
+//# sourceMappingURL=storage-catalog-validation.js.map

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

@@ -0,0 +1,25 @@
+import { type StorageLayout } from './storage-layout.js';
+import type { StorageCatalogEntry } from '../types/storage-catalog.js';
+export type { ArtifactLifecycle, ArtifactOwner, ArtifactPortability, ArtifactSensitivity, StorageCatalogEntry, } from '../types/storage-catalog.js';
+export interface StorageCatalogContext {
+    readonly layout?: StorageLayout;
+    readonly projectPath?: string;
+    readonly logicalProjectId?: string;
+    readonly workspaceKeyHash?: string;
+    readonly additionalEntries?: readonly StorageCatalogEntry[];
+}
+/**
+ * Machine-readable authority for Planu artifact ownership and paths.
+ * Portable paths deliberately use templates when no project context is supplied.
+ */
+export declare function createStorageCatalog(context?: StorageCatalogContext): readonly StorageCatalogEntry[];
+/** Per-process extensible catalog without global mutable registration. */
+export declare class StorageCatalog {
+    private readonly entriesById;
+    constructor(context?: StorageCatalogContext);
+    list(): readonly StorageCatalogEntry[];
+    get(id: string): StorageCatalogEntry;
+}
+export declare function storageCatalogById(id: string, context?: StorageCatalogContext): StorageCatalogEntry;
+export declare function resolvedStorageArtifactPath(id: string, context?: StorageCatalogContext): string;
+//# sourceMappingURL=storage-catalog.d.ts.map

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