@planu/cli 4.13.0 → 5.0.0

package/dist/cli/commands/install.js

@@ -1,16 +1,18 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // cli/commands/install.ts — planu install: detect AI tools and install MCP entry (SPEC-236)
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, isAbsolute, join } from 'node:path';
 import { bold, cyan, green, yellow, dim } from '../colors.js';
 import { PLANU_VERSION } from '../../config/version.js';
-import { confirm, select, ask } from '../interactive.js';
-import { activateLicense } from '../../engine/license-validator.js';
+import { confirm, select } from '../interactive.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { removeCommercialState } from '../../engine/migrations/remove-commercial-state.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 const PLANU_KEY = 'planu';
+const SENSITIVE_ENV_KEY = /(?:token|secret|password|api[_-]?key|license|credential)/iu;
 // ---------------------------------------------------------------------------
 // Locale helpers
 // ---------------------------------------------------------------------------
@@ -64,16 +66,16 @@ const TOOLS = [
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function buildMcpEntry(licenseKey) {
-    const entry = {
+function buildMcpEntry() {
+    const offline = process.env.PLANU_OFFLINE === '1';
+    return {
         command: 'npx',
-        args: ['--prefer-online', '-y', '@planu/cli@latest'],
+        args: [
+            ...(offline ? ['--offline'] : ['--prefer-offline']),
+            '-y',
+            `@planu/cli@${PLANU_VERSION}`,
+        ],
     };
-    const ownerToken = licenseKey ?? process.env.SDD_OWNER_TOKEN;
-    if (ownerToken) {
-        entry.env = { SDD_OWNER_TOKEN: ownerToken };
-    }
-    return entry;
 }
 function readJsonFile(filePath) {
     if (!existsSync(filePath)) {
@@ -81,7 +83,7 @@ function readJsonFile(filePath) {
     }
     const raw = readFileSync(filePath, 'utf-8').trim();
     if (!raw) {
-        return {};
+        throw new Error(`Refusing to overwrite empty or whitespace-only JSON: ${filePath}`);
     }
     return JSON.parse(raw);
 }
@@ -99,27 +101,107 @@ function ensureParentDir(filePath) {
         mkdirSync(dir, { recursive: true });
     }
 }
-function writeStandardEntry(filePath, entry) {
-    let config = {};
+function emptyInstallationManifest(now = new Date().toISOString()) {
+    return { schemaVersion: 1, updatedAt: now, installations: [] };
+}
+export function readInstallationManifest(manifestPath) {
+    if (!existsSync(manifestPath)) {
+        return emptyInstallationManifest();
+    }
+    const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        !('schemaVersion' in parsed) ||
+        parsed.schemaVersion !== 1 ||
+        !('installations' in parsed) ||
+        !Array.isArray(parsed.installations)) {
+        throw new Error(`Unsupported or invalid installation manifest at ${manifestPath}`);
+    }
+    const manifest = parsed;
+    const recordsValid = manifest.installations.every((record) => {
+        return (isAbsolute(record.configPath) &&
+            typeof record.host === 'string' &&
+            record.host.trim().length > 0 &&
+            record.package === '@planu/cli' &&
+            /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/.test(record.version) &&
+            typeof record.offline === 'boolean' &&
+            typeof record.installedAt === 'string' &&
+            Number.isFinite(Date.parse(record.installedAt)));
+    });
+    if (!recordsValid) {
+        throw new Error(`Unsafe installation manifest at ${manifestPath}`);
+    }
+    return manifest;
+}
+function writeInstallationManifest(manifestPath, manifest) {
+    ensureParentDir(manifestPath);
+    const temporaryPath = `${manifestPath}.${String(process.pid)}.${String(Date.now())}.tmp`;
     try {
-        config = readJsonFile(filePath);
+        writeFileSync(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        renameSync(temporaryPath, manifestPath);
     }
-    catch {
-        // invalid JSON — start fresh
+    catch (err) {
+        rmSync(temporaryPath, { force: true });
+        throw err;
     }
-    config.mcpServers ??= {};
-    config.mcpServers[PLANU_KEY] = entry;
-    ensureParentDir(filePath);
-    writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
-function writeZedEntry(filePath, entry) {
-    let config = {};
+function writeJsonAtomically(filePath, value) {
+    ensureParentDir(filePath);
+    const temporaryPath = `${filePath}.${String(process.pid)}.${String(Date.now())}.tmp`;
+    const mode = existsSync(filePath) ? statSync(filePath).mode & 0o777 : 0o600;
     try {
-        config = readJsonFile(filePath);
+        writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode,
+        });
+        renameSync(temporaryPath, filePath);
+        chmodSync(filePath, mode);
+    }
+    catch (err) {
+        rmSync(temporaryPath, { force: true });
+        throw err;
     }
-    catch {
-        // invalid JSON — start fresh
+}
+function assertCredentialFree(entry) {
+    if (Object.keys(entry.env ?? {}).some((key) => SENSITIVE_ENV_KEY.test(key))) {
+        throw new Error('[Planu] Refusing to embed credentials in an MCP host configuration');
     }
+}
+export function recordInstallation(manifestPath, record) {
+    const manifest = readInstallationManifest(manifestPath);
+    const installations = manifest.installations.filter((item) => !(item.host === record.host && item.configPath === record.configPath));
+    installations.push(record);
+    const updated = {
+        schemaVersion: 1,
+        updatedAt: record.installedAt,
+        installations,
+    };
+    writeInstallationManifest(manifestPath, updated);
+    return updated;
+}
+export function removeInstallationRecords(manifestPath, removedConfigPaths) {
+    const manifest = readInstallationManifest(manifestPath);
+    const updated = {
+        ...manifest,
+        updatedAt: new Date().toISOString(),
+        installations: manifest.installations.filter((item) => !removedConfigPaths.has(item.configPath)),
+    };
+    writeInstallationManifest(manifestPath, updated);
+    return updated;
+}
+function writeStandardEntry(filePath, entry) {
+    assertCredentialFree(entry);
+    const config = readJsonFile(filePath);
+    config.mcpServers ??= {};
+    config.mcpServers[PLANU_KEY] = entry;
+    writeJsonAtomically(filePath, config);
+}
+function writeZedEntry(filePath, entry) {
+    assertCredentialFree(entry);
+    const config = readJsonFile(filePath);
     config.context_servers ??= {};
     const zedEntry = {
         command: { path: entry.command, args: entry.args },
@@ -128,8 +210,7 @@ function writeZedEntry(filePath, entry) {
         zedEntry.env = entry.env;
     }
     config.context_servers[PLANU_KEY] = zedEntry;
-    ensureParentDir(filePath);
-    writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    writeJsonAtomically(filePath, config);
 }
 function removePlanuFromStandard(config) {
     if (!config.mcpServers) {
@@ -156,69 +237,11 @@ function removePlanuFromZed(config) {
     return { ...config, context_servers: filtered };
 }
 function removeEntry(filePath, format) {
-    let config;
-    try {
-        config = readJsonFile(filePath);
-    }
-    catch {
-        return; // nothing to do
-    }
+    const config = readJsonFile(filePath);
     const updated = format === 'zed'
         ? removePlanuFromZed(config)
         : removePlanuFromStandard(config);
-    writeFileSync(filePath, JSON.stringify(updated, null, 2) + '\n', 'utf-8');
-}
-// ---------------------------------------------------------------------------
-// License step helper (exported for tests)
-// ---------------------------------------------------------------------------
-/**
- * Prompt the user for a license key and activate it.
- * Returns the activation result or null if the user skips.
- * In CI/headless mode (SDD_OWNER_TOKEN already set), returns a synthetic result immediately.
- */
-export async function promptLicense() {
-    // Headless / CI mode: use token from environment directly
-    const envToken = process.env.SDD_OWNER_TOKEN;
-    if (envToken) {
-        return { key: envToken, customerEmail: '', variantName: 'Pro' };
-    }
-    const wantsLicense = await confirm('Do you have a Pro license key?', false);
-    if (!wantsLicense) {
-        return null;
-    }
-    const key = await ask('Enter your license key:');
-    if (!key) {
-        return null;
-    }
-    process.stdout.write(`${dim('Validating license key...')}\n`);
-    try {
-        const result = await activateLicense(key, 'planu-cli');
-        if (!result.activated) {
-            const errMsg = result.error ?? 'Invalid license key';
-            process.stdout.write(`${yellow('!')} License validation failed: ${errMsg}\n`);
-            const continueWithout = await confirm('Continue without license?', true);
-            if (!continueWithout) {
-                throw new Error('Aborted by user after license validation failure');
-            }
-            return null;
-        }
-        const email = result.meta.customer_email;
-        const variant = result.meta.variant_name;
-        process.stdout.write(`${green('+')} Pro license — ${email}\n`);
-        return { key, customerEmail: email, variantName: variant };
-    }
-    catch (err) {
-        if (err instanceof Error && err.message.startsWith('Aborted')) {
-            throw err;
-        }
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stdout.write(`${yellow('!')} License API error: ${msg}\n`);
-        const continueWithout = await confirm('Continue without license?', true);
-        if (!continueWithout) {
-            throw new Error('Aborted by user after license API error', { cause: err });
-        }
-        return null;
-    }
+    writeJsonAtomically(filePath, updated);
 }
 // Exported so tests can use them without going through the interactive CLI
 export { buildMcpEntry, readJsonFile, hasPlanuEntry, writeStandardEntry, writeZedEntry, removeEntry, };
@@ -294,20 +317,22 @@ async function resolveTargets(detected, installAll) {
     }
     return detected.filter((t) => t.name === choice);
 }
-async function installToPath(tool, targetPath, quiet, licenseKey) {
-    const entry = buildMcpEntry(licenseKey);
+async function installToPath(tool, targetPath, scope, quiet) {
+    const entry = buildMcpEntry();
+    const targetExisted = existsSync(targetPath);
+    const previousContent = targetExisted ? readFileSync(targetPath, 'utf8') : null;
     let existingConfig = {};
-    let jsonError = false;
     try {
         if (existsSync(targetPath)) {
             existingConfig = readJsonFile(targetPath);
         }
     }
-    catch {
-        jsonError = true;
-        process.stdout.write(`  ${yellow('!')} ${tool.name}: config file has invalid JSON — will create a new one\n`);
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.stdout.write(`  ${yellow('!')} ${tool.name}: config file has invalid JSON — no changes made (${detail})\n`);
+        return false;
     }
-    if (!jsonError && hasPlanuEntry(existingConfig, tool.format)) {
+    if (hasPlanuEntry(existingConfig, tool.format)) {
         if (quiet) {
             return false;
         }
@@ -324,12 +349,34 @@ async function installToPath(tool, targetPath, quiet, licenseKey) {
         else {
             writeStandardEntry(targetPath, entry);
         }
+        recordInstallation(resolveStorageLayout().installationManifest, {
+            host: tool.name,
+            configPath: targetPath,
+            format: tool.format,
+            scope,
+            package: '@planu/cli',
+            version: PLANU_VERSION,
+            offline: process.env.PLANU_OFFLINE === '1',
+            installedAt: new Date().toISOString(),
+        });
         process.stdout.write(`  ${green('+')} Installed in ${bold(tool.name)} → ${dim(targetPath)}\n`);
         return true;
     }
     catch (err) {
+        try {
+            if (previousContent === null) {
+                rmSync(targetPath, { force: true });
+            }
+            else {
+                writeFileSync(targetPath, previousContent, 'utf8');
+            }
+        }
+        catch (rollbackError) {
+            const rollbackDetail = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+            process.stdout.write(`  ${yellow('!')} ${tool.name}: rollback failed — ${rollbackDetail}\n`);
+        }
         const msg = err instanceof Error ? err.message : String(err);
-        process.stdout.write(`  ${yellow('!')} ${tool.name}: failed to write — ${msg}\n`);
+        process.stdout.write(`  ${yellow('!')} ${tool.name}: installation rolled back — ${msg}\n`);
         return false;
     }
 }
@@ -353,6 +400,9 @@ export const installCommand = {
                 installAll = true;
             }
         }
+        await removeCommercialState({
+            hostConfigPaths: TOOLS.flatMap((tool) => tool.projectScopePath ? [tool.userScopePath, tool.projectScopePath] : [tool.userScopePath]),
+        });
         printBanner();
         // Detect installed tools (user-scope paths)
         const detected = [];
@@ -384,10 +434,6 @@ export const installCommand = {
         }
         const scope = await resolveScope(scopeArg);
         const targets = await resolveTargets(detected, installAll);
-        // License step — prompt or read from env
-        process.stdout.write('\n');
-        const license = await promptLicense();
-        const licenseKey = license?.key;
         process.stdout.write(`\n${cyan('Installing...')}\n`);
         let installed = 0;
         for (const tool of targets) {
@@ -402,7 +448,7 @@ export const installCommand = {
             else {
                 targetPath = tool.userScopePath;
             }
-            const ok = await installToPath(tool, targetPath, quiet, licenseKey);
+            const ok = await installToPath(tool, targetPath, scope, quiet);
             if (ok) {
                 installed++;
             }

package/dist/cli/commands/job.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from '../../types/cli.js';
+export declare const jobCommand: CliCommand;
+//# sourceMappingURL=job.d.ts.map

package/dist/cli/commands/job.js

@@ -0,0 +1,120 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { parseArgs } from 'node:util';
+import { publicJobCursor, DurableJobRuntime } from '../../engine/execution/job-runtime.js';
+const USAGE = 'planu job <get|watch|cancel> --operation-id ID --project-id ID [--workspace-id ID] [--after-cursor CURSOR] [--timeout-ms N] [--json]';
+export const jobCommand = {
+    name: 'job',
+    description: 'Get, watch or cancel a durable Planu job',
+    usage: USAGE,
+    async run(args, flags) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const action = args[0];
+            const { values } = parseArgs({
+                args: args.slice(1),
+                options: {
+                    'operation-id': { type: 'string' },
+                    'project-id': { type: 'string' },
+                    'workspace-id': { type: 'string' },
+                    'after-cursor': { type: 'string' },
+                    'timeout-ms': { type: 'string' },
+                    json: { type: 'boolean' },
+                },
+                strict: true,
+                allowPositionals: false,
+            });
+            if (!['get', 'watch', 'cancel'].includes(action ?? '')) {
+                throw new Error(`Usage: ${USAGE}`);
+            }
+            if (!values['operation-id'] || !values['project-id']) {
+                throw new Error('[Planu] --operation-id and --project-id are required');
+            }
+            const identity = {
+                operationId: values['operation-id'],
+                projectId: values['project-id'],
+                workspaceId: values['workspace-id'],
+            };
+            const runtime = __addDisposableResource(env_1, new DurableJobRuntime(), false);
+            const internalJob = action === 'cancel'
+                ? runtime.cancel(identity)
+                : action === 'watch'
+                    ? await runtime.watch({
+                        ...identity,
+                        afterCursor: values['after-cursor'],
+                        timeoutMs: parseTimeout(values['timeout-ms']),
+                    })
+                    : runtime.get(identity);
+            const job = runtime.observe(internalJob);
+            process.stdout.write(`${JSON.stringify({ job, cursor: publicJobCursor(job) }, null, flags?.json === true || values.json === true ? undefined : 2)}\n`);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    },
+};
+function parseTimeout(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 30_000) {
+        throw new Error('[Planu] --timeout-ms must be an integer between 0 and 30000');
+    }
+    return parsed;
+}
+//# sourceMappingURL=job.js.map

package/dist/cli/commands/offline.d.ts

@@ -0,0 +1,15 @@
+import type { CliCommand } from '../../types/cli.js';
+interface OfflinePrepareReport {
+    schemaVersion: 1;
+    cli: string;
+    native: string | null;
+    cacheReady: boolean;
+    nativeCompatible: boolean;
+    mcpStartupReady: boolean;
+    smokeReady: boolean;
+    errors: string[];
+}
+export declare function prepareOfflineRuntime(): OfflinePrepareReport;
+export declare const offlineCommand: CliCommand;
+export {};
+//# sourceMappingURL=offline.d.ts.map

package/dist/cli/commands/offline.js

@@ -0,0 +1,132 @@
+import { spawnSync } from 'node:child_process';
+import { PLANU_VERSION } from '../../config/version.js';
+import { currentNativePackageName, RUNTIME_STORAGE_SCHEMA } from '../../engine/core-bridge.js';
+const MCP_INITIALIZE_REQUEST = `${JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+        protocolVersion: '2025-06-18',
+        capabilities: {},
+        clientInfo: { name: 'planu-offline-smoke', version: '1.0.0' },
+    },
+})}\n`;
+function errorText(result, fallback) {
+    if (result.error) {
+        return result.error.message;
+    }
+    return String(result.stderr || result.stdout || fallback).trim();
+}
+function provesMcpStartup(stdout) {
+    return stdout
+        .split(/\r?\n/u)
+        .filter(Boolean)
+        .some((line) => {
+        try {
+            const message = JSON.parse(line);
+            const result = message.result;
+            if (message.id !== 1 || result === null || typeof result !== 'object') {
+                return false;
+            }
+            const serverInfo = result.serverInfo;
+            return (serverInfo !== null &&
+                typeof serverInfo === 'object' &&
+                serverInfo.name === 'planu');
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function provesNativeAsset(stdout) {
+    try {
+        const report = JSON.parse(stdout);
+        const handshake = report.native?.compatibility?.handshake;
+        const storageSchemaMin = handshake?.storageSchemaMin;
+        const storageSchemaMax = handshake?.storageSchemaMax;
+        return (typeof report.native?.loaded === 'string' &&
+            report.native.loaded.length > 0 &&
+            report.native.compatibility?.compatible === true &&
+            typeof storageSchemaMin === 'number' &&
+            typeof storageSchemaMax === 'number' &&
+            storageSchemaMin <= RUNTIME_STORAGE_SCHEMA &&
+            storageSchemaMax >= RUNTIME_STORAGE_SCHEMA);
+    }
+    catch {
+        return false;
+    }
+}
+// eslint-disable-next-line complexity -- report aggregates cache, native and smoke diagnostics
+export function prepareOfflineRuntime() {
+    const nativeName = currentNativePackageName();
+    const packages = [`@planu/cli@${PLANU_VERSION}`];
+    if (nativeName) {
+        packages.push(`${nativeName}@${PLANU_VERSION}`);
+    }
+    const npmExecutable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const errors = [];
+    let cacheReady = true;
+    for (const packageSpec of packages) {
+        const cache = spawnSync(npmExecutable, ['cache', 'add', ...(process.env.PLANU_OFFLINE === '1' ? ['--offline'] : []), packageSpec], {
+            encoding: 'utf8',
+            timeout: 120_000,
+            env: { ...process.env },
+        });
+        if (cache.error) {
+            errors.push(cache.error.message);
+        }
+        if (cache.status !== 0) {
+            cacheReady = false;
+            errors.push((cache.stderr || cache.stdout || `npm cache add failed: ${packageSpec}`).trim());
+        }
+    }
+    const npxExecutable = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const smokeEnvironment = { ...process.env, PLANU_OFFLINE: '1' };
+    const mcpSmoke = spawnSync(npxExecutable, ['--offline', '-y', `@planu/cli@${PLANU_VERSION}`], {
+        encoding: 'utf8',
+        timeout: 30_000,
+        env: smokeEnvironment,
+        input: MCP_INITIALIZE_REQUEST,
+    });
+    const mcpStartupReady = mcpSmoke.status === 0 && provesMcpStartup(mcpSmoke.stdout);
+    if (!mcpStartupReady) {
+        errors.push(errorText(mcpSmoke, 'offline MCP startup handshake failed'));
+    }
+    const nativeSmoke = spawnSync(npxExecutable, ['--offline', '-y', `@planu/cli@${PLANU_VERSION}`, 'inspect', '--json'], {
+        encoding: 'utf8',
+        timeout: 30_000,
+        env: smokeEnvironment,
+    });
+    const nativeCompatible = nativeSmoke.status === 0 && provesNativeAsset(nativeSmoke.stdout);
+    if (!nativeCompatible) {
+        errors.push(errorText(nativeSmoke, 'cached native asset failed isolated compatibility check'));
+    }
+    const smokeReady = mcpStartupReady && nativeCompatible;
+    return {
+        schemaVersion: 1,
+        cli: `@planu/cli@${PLANU_VERSION}`,
+        native: nativeName ? `${nativeName}@${PLANU_VERSION}` : null,
+        cacheReady,
+        nativeCompatible,
+        mcpStartupReady,
+        smokeReady,
+        errors: errors.filter(Boolean),
+    };
+}
+export const offlineCommand = {
+    name: 'offline',
+    description: 'Preload and verify exact CLI/native assets for offline startup',
+    usage: 'planu offline prepare [--json]',
+    run(args, flags) {
+        if (args[0] !== 'prepare') {
+            throw new Error('Usage: planu offline prepare [--json]');
+        }
+        const report = prepareOfflineRuntime();
+        process.stdout.write(`${JSON.stringify(report, null, flags?.json ? 0 : 2)}\n`);
+        if (!report.cacheReady || !report.nativeCompatible || !report.smokeReady) {
+            process.exitCode = 1;
+        }
+        return Promise.resolve();
+    },
+};
+//# sourceMappingURL=offline.js.map

package/dist/cli/commands/serve.js

@@ -30,9 +30,13 @@ export const serveCommand = {
         registerPlatformTools(server);
         await selectTransport(server, ['--transport', 'http', '--port', port], () => server);
         const { recoverPendingPostCommitTasksAtStartup } = await import('../../tools/update-status/index.js');
+        const { startSpecCreatedOutboxConsumer } = await import('../../tools/create-spec/spec-created-outbox-consumer.js');
         void recoverPendingPostCommitTasksAtStartup().catch((error) => {
             process.stderr.write(`Planu post-commit recovery failed: ${error instanceof Error ? error.message : String(error)}\n`);
         });
+        void startSpecCreatedOutboxConsumer().catch((error) => {
+            process.stderr.write(`Planu spec.created recovery failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        });
     },
 };
 //# sourceMappingURL=serve.js.map

package/dist/cli/commands/spec.js

@@ -60,7 +60,7 @@ async function runValidate(args, flags) {
         return;
     }
     const projectId = values['project-id'] ?? detectProjectId();
-    const result = await handleValidate({ specId, projectId });
+    const result = await handleValidate({ specId, projectId, projectPath: process.cwd() });
     if (result.isError) {
         process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
         process.exitCode = 1;

package/dist/cli/commands/storage.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from '../../types/cli.js';
+export declare const storageCommand: CliCommand;
+//# sourceMappingURL=storage.d.ts.map