@planu/cli 4.12.3 → 4.14.1

package/dist/cli/commands/job.js

@@ -0,0 +1,119 @@
+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 { durableJobCursor, 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 job = action === 'cancel'
+                ? runtime.cancel(identity)
+                : action === 'watch'
+                    ? await runtime.watch({
+                        ...identity,
+                        afterCursor: values['after-cursor'],
+                        timeoutMs: parseTimeout(values['timeout-ms']),
+                    })
+                    : runtime.get(identity);
+            process.stdout.write(`${JSON.stringify({ job, cursor: durableJobCursor(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

@@ -12,7 +12,7 @@ import { handleCreateSpec } from '../../tools/create-spec.js';
 import { handleListSpecs } from '../../tools/list-specs.js';
 import { handleUpdateStatus } from '../../tools/update-status.js';
 import { handleUpdateStatusBatch } from '../../tools/update-status/batch.js';
-import { handleValidate } from '../../tools/validate.js';
+import { executeValidate as handleValidate } from '../../tools/validate.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { bold, cyan, green, red, dim } from '../colors.js';

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

package/dist/cli/commands/storage.js

@@ -0,0 +1,102 @@
+import { parseArgs } from 'node:util';
+import { handleStoragePaths } from '../../tools/storage-paths-handler.js';
+import { exportStorageBundle, importStorageBundle } from '../../storage/storage-bundle.js';
+import { handleGcDataProjects } from '../../tools/gc-data-projects.js';
+import { restoreGcTrash } from '../../engine/data-projects-gc/gc-runner.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const USAGE = 'planu storage <paths|export|import|gc|restore> [--project-path PATH] [--project-id ID] [--workspace-key-hash HASH] [--output PATH] [--input PATH] [--trash-path PATH] [--inactive-days N] [--apply] [--include-orphans] [--json]';
+function print(payload, json) {
+    process.stdout.write(`${JSON.stringify(payload, null, json ? undefined : 2)}\n`);
+}
+export const storageCommand = {
+    name: 'storage',
+    description: 'Inspect, export or import canonical Planu storage',
+    usage: USAGE,
+    // eslint-disable-next-line complexity -- command dispatcher validates five explicit storage actions
+    async run(args, flags) {
+        const action = args[0];
+        const { values } = parseArgs({
+            args: args.slice(1),
+            options: {
+                'project-path': { type: 'string' },
+                'project-id': { type: 'string' },
+                'workspace-key-hash': { type: 'string' },
+                output: { type: 'string' },
+                input: { type: 'string' },
+                'trash-path': { type: 'string' },
+                'inactive-days': { type: 'string' },
+                apply: { type: 'boolean' },
+                'include-orphans': { type: 'boolean' },
+                json: { type: 'boolean' },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+        const json = flags?.json === true || values.json === true;
+        if (action === 'export') {
+            if (!values['project-id'] || !values.output) {
+                throw new Error('Usage: planu storage export --project-id ID --output ABSOLUTE_PATH');
+            }
+            const bundle = await exportStorageBundle(values['project-id'], values.output);
+            print({
+                exported: true,
+                projectId: bundle.projectId,
+                output: values.output,
+                checksum: bundle.checksum,
+            }, json);
+            return;
+        }
+        if (action === 'import') {
+            if (!values.input) {
+                throw new Error('Usage: planu storage import --input ABSOLUTE_PATH');
+            }
+            const bundle = await importStorageBundle(values.input);
+            print({ imported: true, projectId: bundle.projectId, input: values.input }, json);
+            return;
+        }
+        if (action === 'gc') {
+            const inactiveDays = values['inactive-days']
+                ? Number.parseInt(values['inactive-days'], 10)
+                : undefined;
+            if (inactiveDays !== undefined && (!Number.isSafeInteger(inactiveDays) || inactiveDays < 1)) {
+                throw new Error('[Planu] --inactive-days must be a positive integer');
+            }
+            const result = await handleGcDataProjects({
+                inactiveDays,
+                apply: values.apply,
+                includeOrphans: values['include-orphans'],
+            });
+            process.stdout.write(`${result.content[0]?.text ?? ''}\n`);
+            return;
+        }
+        if (action === 'restore') {
+            if (!values['trash-path']) {
+                throw new Error('Usage: planu storage restore --trash-path ABSOLUTE_PATH');
+            }
+            const destination = await restoreGcTrash(values['trash-path'], resolveStorageLayout().projects);
+            print({ restored: true, destination }, json);
+            return;
+        }
+        if (action !== 'paths') {
+            throw new Error(`Usage: ${USAGE}`);
+        }
+        const result = handleStoragePaths({
+            projectPath: values['project-path'],
+            logicalProjectId: values['project-id'],
+            workspaceKeyHash: values['workspace-key-hash'],
+        });
+        const payload = result.structuredContent ?? {};
+        if (json) {
+            process.stdout.write(`${JSON.stringify(payload)}\n`);
+        }
+        else {
+            const artifacts = payload.artifacts;
+            const lines = artifacts.flatMap((artifact) => [
+                `${artifact.id}: ${artifact.resolvedPath ?? artifact.templatePath}`,
+                `  ${artifact.purpose}`,
+            ]);
+            process.stdout.write(`${lines.join('\n')}\n`);
+        }
+    },
+};
+//# sourceMappingURL=storage.js.map

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

@@ -6,5 +6,15 @@ interface ToolLocation {
 }
 declare function findInstalledLocations(): ToolLocation[];
 export { findInstalledLocations };
+export declare function buildUninstallCategories(purge: {
+    runtime: boolean;
+    cache: boolean;
+    data: boolean;
+    secrets: boolean;
+}, layout?: import("../../storage/storage-layout.js").StorageLayout): {
+    name: string;
+    paths: string[];
+    selected: boolean;
+}[];
 export declare const uninstallCommand: CliCommand;
 //# sourceMappingURL=uninstall.d.ts.map

package/dist/cli/commands/uninstall.js

@@ -1,10 +1,13 @@
 // cli/commands/uninstall.ts — planu uninstall: remove Planu MCP from AI tools (SPEC-236)
 import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { bold, green, yellow, dim, red } from '../colors.js';
 import { confirm } from '../interactive.js';
-import { readJsonFile, hasPlanuEntry, removeEntry } from './install.js';
+import { readJsonFile, hasPlanuEntry, removeEntry, readInstallationManifest, removeInstallationRecords, } from './install.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { createStorageCatalog } from '../../storage/storage-catalog.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -69,7 +72,16 @@ const ALL_PATHS = [
 // Helpers
 // ---------------------------------------------------------------------------
 function findInstalledLocations() {
-    return ALL_PATHS.filter((loc) => {
+    const manifestPath = resolveStorageLayout().installationManifest;
+    const candidates = existsSync(manifestPath)
+        ? readInstallationManifest(manifestPath).installations.map((item) => ({
+            name: item.host,
+            configPath: item.configPath,
+            format: item.format,
+        }))
+        : ALL_PATHS;
+    const uniqueCandidates = candidates.filter((location, index, all) => all.findIndex((candidate) => candidate.configPath === location.configPath) === index);
+    return uniqueCandidates.filter((loc) => {
         if (!existsSync(loc.configPath)) {
             return false;
         }
@@ -84,38 +96,88 @@ function findInstalledLocations() {
 }
 // Exported for tests
 export { findInstalledLocations };
+export function buildUninstallCategories(purge, layout = resolveStorageLayout()) {
+    const catalog = createStorageCatalog({ layout });
+    const pathsFor = (ids) => [
+        ...new Set(catalog
+            .filter((entry) => ids.includes(entry.id))
+            .map((entry) => entry.resolvedPath)
+            .filter((path) => path !== undefined)),
+    ];
+    return [
+        {
+            name: 'runtime',
+            paths: [
+                ...pathsFor(['runtime-database']),
+                ...pathsFor(['runtime-locks']).map((path) => dirname(path)),
+            ],
+            selected: purge.runtime,
+        },
+        {
+            name: 'cache',
+            paths: pathsFor(['native-cache', 'runtime-logs']),
+            selected: purge.cache,
+        },
+        {
+            name: 'data',
+            paths: pathsFor(['runtime-project-files', 'portable-exports', 'migration-journals']),
+            selected: purge.data,
+        },
+        { name: 'secrets', paths: pathsFor(['secret-references']), selected: purge.secrets },
+    ];
+}
 // ---------------------------------------------------------------------------
 // Command
 // ---------------------------------------------------------------------------
 export const uninstallCommand = {
     name: 'uninstall',
     description: 'Remove Planu MCP from AI tool configs',
-    usage: 'planu uninstall [--yes]',
+    usage: 'planu uninstall [--yes] [--purge-runtime] [--purge-cache] [--purge-data] [--purge-secrets] [--all-data]',
+    // eslint-disable-next-line complexity -- uninstall reports and applies independent storage categories
     async run(args, _flags) {
         const forceYes = args.includes('--yes') || args.includes('-y');
+        const allData = args.includes('--all-data');
+        const purge = {
+            runtime: allData || args.includes('--purge-runtime'),
+            cache: allData || args.includes('--purge-cache'),
+            data: allData || args.includes('--purge-data'),
+            secrets: allData || args.includes('--purge-secrets'),
+        };
+        const layout = resolveStorageLayout();
         process.stdout.write(`\n${bold('Planu MCP Uninstaller')}\n\n`);
         const locations = findInstalledLocations();
         if (locations.length === 0) {
-            process.stdout.write(`${dim('Planu is not installed in any detected AI tool configs.')}\n\n`);
-            return;
+            process.stdout.write(`${dim('Planu is not installed in any detected AI tool configs.')}\n`);
         }
         process.stdout.write(`Found Planu installed in ${String(locations.length)} location(s):\n\n`);
         for (const loc of locations) {
             process.stdout.write(`  ${yellow('-')} ${loc.name} ${dim(loc.configPath)}\n`);
         }
+        const categories = buildUninstallCategories(purge, layout);
+        for (const category of categories) {
+            const status = category.selected ? 'purge requested' : 'preserved';
+            process.stdout.write(`  ${yellow('-')} ${category.name}: ${status}; ${category.paths.some((path) => existsSync(path)) ? 'present' : 'absent'}\n`);
+        }
         process.stdout.write('\n');
-        const proceed = forceYes || (await confirm('Remove Planu from all listed locations?', false));
+        const hasMutation = locations.length > 0 || categories.some((category) => category.selected);
+        if (!hasMutation) {
+            process.stdout.write(`${dim('Nothing selected for removal. Local data remains preserved.')}\n\n`);
+            return;
+        }
+        const proceed = forceYes || (await confirm('Remove selected Planu hosts and storage categories?', false));
         if (!proceed) {
             process.stdout.write(`${dim('Cancelled.')}\n\n`);
             return;
         }
         let removed = 0;
         let failed = 0;
+        const removedPaths = new Set();
         for (const loc of locations) {
             try {
                 removeEntry(loc.configPath, loc.format);
                 process.stdout.write(`  ${green('-')} Removed from ${bold(loc.name)}\n`);
                 removed++;
+                removedPaths.add(loc.configPath);
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -123,6 +185,30 @@ export const uninstallCommand = {
                 failed++;
             }
         }
+        for (const category of categories.filter((item) => item.selected)) {
+            for (const path of category.paths) {
+                try {
+                    await rm(path, { recursive: true, force: true });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    process.stdout.write(`  ${red('!')} Failed to remove ${category.name}: ${msg}\n`);
+                    failed++;
+                }
+            }
+            process.stdout.write(`  ${green('-')} Removed ${bold(category.name)} storage\n`);
+        }
+        const manifestPath = resolveStorageLayout().installationManifest;
+        if (existsSync(manifestPath) && removedPaths.size > 0) {
+            try {
+                removeInstallationRecords(manifestPath, removedPaths);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stdout.write(`  ${yellow('!')} Failed to update installation inventory: ${msg}\n`);
+                failed++;
+            }
+        }
         process.stdout.write(`\n${bold('Done.')} Removed from ${String(removed)} location(s).`);
         if (failed > 0) {
             process.stdout.write(` ${yellow(String(failed) + ' failed.')}`);

package/dist/cli/commands/validate.js

@@ -1,6 +1,6 @@
 // cli/commands/validate.ts — planu validate <specId> (SPEC-124)
 import { parseArgs } from 'node:util';
-import { handleValidate } from '../../tools/validate.js';
+import { executeValidate as handleValidate } from '../../tools/validate.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { red } from '../colors.js';

package/dist/cli/index.js

@@ -5,6 +5,8 @@
 // When invoked with no arguments and stdin is piped (MCP host context),
 // we act as the MCP server. Otherwise we run the CLI router.
 import { route } from './router.js';
+import { installNetworkPolicy } from '../engine/network-policy.js';
+installNetworkPolicy();
 const args = process.argv.slice(2);
 // stdin.isTTY is undefined/false when piped (MCP host); true in a terminal.
 if (args.length === 0 && !process.stdin.isTTY) {

package/dist/cli/router.js

@@ -4,7 +4,7 @@ import { PLANU_VERSION } from '../config/version.js';
 import { red, bold, cyan, dim } from './colors.js';
 // Lazy-load commands to avoid importing tool handlers when not needed
 async function loadCommands() {
-    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { activateCommand }, { specCommand }, { healthCommand }, { releaseCommand },] = await Promise.all([
+    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { activateCommand }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = await Promise.all([
         import('./commands/init.js'),
         import('./commands/create.js'),
         import('./commands/list.js'),
@@ -23,6 +23,10 @@ async function loadCommands() {
         import('./commands/spec.js'),
         import('./commands/health.js'),
         import('./commands/release.js'),
+        import('./commands/storage.js'),
+        import('./commands/inspect.js'),
+        import('./commands/offline.js'),
+        import('./commands/job.js'),
     ]);
     const cmds = [
         initCommand,
@@ -43,6 +47,10 @@ async function loadCommands() {
         specCommand,
         healthCommand,
         releaseCommand,
+        storageCommand,
+        inspectCommand,
+        offlineCommand,
+        jobCommand,
     ];
     const map = new Map();
     for (const cmd of cmds) {