@planu/cli 4.13.0 → 5.0.0

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

@@ -24,7 +24,7 @@ export const validateCommand = {
             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/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 }, { specCommand }, { healthCommand }, { releaseCommand }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = await Promise.all([
         import('./commands/init.js'),
         import('./commands/create.js'),
         import('./commands/list.js'),
@@ -19,10 +19,13 @@ async function loadCommands() {
         import('./commands/install.js'),
         import('./commands/doctor.js'),
         import('./commands/uninstall.js'),
-        import('./commands/activate.js'),
         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,
@@ -39,10 +42,13 @@ async function loadCommands() {
         installCommand,
         doctorCommand,
         uninstallCommand,
-        activateCommand,
         specCommand,
         healthCommand,
         releaseCommand,
+        storageCommand,
+        inspectCommand,
+        offlineCommand,
+        jobCommand,
     ];
     const map = new Map();
     for (const cmd of cmds) {

package/dist/config/crash-shield-framework-rules.json

@@ -0,0 +1,93 @@
+{
+  "schemaVersion": 1,
+  "rules": [
+    {
+      "id": "nextjs-gsp-no-try",
+      "framework": "Next.js",
+      "fileExtensions": [".tsx", ".jsx"],
+      "contentAny": ["next/", "from ['\"]next"],
+      "activationMode": "file-or-content",
+      "finding": "export\\s+(?:const|async\\s+function|function)\\s+getServerSideProps",
+      "guard": { "scope": "file", "patterns": ["\\btry\\s*\\{"] },
+      "pattern": "NEXTJS_GSP_NO_TRY",
+      "severity": "HIGH",
+      "description": "getServerSideProps without try/catch. Any uncaught error will crash the entire page render.",
+      "suggestedFix": "Wrap the body of getServerSideProps in try/catch and return { notFound: true } or redirect on error."
+    },
+    {
+      "id": "express-async-route-no-error-handler",
+      "framework": "Express",
+      "fileExtensions": [".ts", ".js"],
+      "contentAny": ["from ['\"]express['\"]", "require\\(['\"]express['\"]\\)"],
+      "activationMode": "content",
+      "finding": "(?:app|router)\\.\\w+\\s*\\([^,)]+,\\s*async\\s*(?:\\([^)]*\\)|[a-z]+)\\s*=>",
+      "guard": { "scope": "file", "patterns": ["\\.catch\\s*\\(", "next\\s*\\(\\s*(?:err|error)", "\\btry\\s*\\{"] },
+      "pattern": "EXPRESS_ASYNC_ROUTE_NO_ERROR_HANDLER",
+      "severity": "HIGH",
+      "description": "Async Express route handler without .catch() or next(err). Unhandled promise rejections crash the server in Node.js.",
+      "suggestedFix": "Add .catch(next), wrap in try/catch and call next(err), or use a verified async wrapper."
+    },
+    {
+      "id": "prisma-find-no-null-check",
+      "framework": "Prisma",
+      "fileExtensions": [".ts", ".js"],
+      "contentAny": ["@prisma/client", "PrismaClient"],
+      "activationMode": "content",
+      "finding": "await\\s+\\w+\\.\\w+\\.(?:findUnique|findFirst)\\s*\\(",
+      "guard": {
+        "scope": "window",
+        "before": 1,
+        "after": 5,
+        "patterns": ["if\\s*\\(\\s*!\\s*\\w+", "if\\s*\\(\\s*\\w+\\s*(?:===|!==)\\s*null", "\\?\\?"]
+      },
+      "pattern": "PRISMA_FIND_NO_NULL_CHECK",
+      "severity": "HIGH",
+      "description": "A nullable Prisma lookup is used without a nearby null check.",
+      "suggestedFix": "Check for null or use the provider's verified throwing lookup."
+    },
+    {
+      "id": "django-get-no-does-not-exist",
+      "framework": "Django",
+      "fileExtensions": [".py"],
+      "contentAny": ["from django", "import django"],
+      "activationMode": "file-and-content",
+      "finding": "\\w+\\.objects\\.get\\s*\\(",
+      "guard": { "scope": "file", "patterns": ["DoesNotExist"] },
+      "pattern": "DJANGO_GET_NO_DOES_NOT_EXIST",
+      "severity": "HIGH",
+      "description": "Model.objects.get() can raise DoesNotExist without a handler.",
+      "suggestedFix": "Handle DoesNotExist or use a verified not-found helper."
+    },
+    {
+      "id": "gin-bind-error-ignored",
+      "framework": "Gin",
+      "fileExtensions": [".go"],
+      "contentAny": ["github.com/gin-gonic/gin"],
+      "activationMode": "content",
+      "finding": "\\.ShouldBindJSON\\s*\\(&?\\w+\\)",
+      "guard": {
+        "scope": "window",
+        "before": 1,
+        "after": 3,
+        "patterns": ["if\\s+err\\s*!=\\s*nil", "if\\s+\\w+\\s*:?=\\s*.*ShouldBind"]
+      },
+      "pattern": "GIN_BIND_ERROR_IGNORED",
+      "severity": "HIGH",
+      "description": "A request-binding error is ignored and can leave an invalid zero-value input.",
+      "suggestedFix": "Check the binding error and return a typed client error."
+    },
+    {
+      "id": "actix-unwrap-in-handler",
+      "framework": "Actix",
+      "fileExtensions": [".rs"],
+      "contentAny": ["actix_web", "use actix_web"],
+      "contentAll": ["async\\s+fn\\s+\\w+\\s*\\([^)]*(?:HttpRequest|web::Data|web::Json|web::Path)[^)]*\\)"],
+      "activationMode": "file-and-content",
+      "finding": "\\.unwrap\\(\\)",
+      "pattern": "ACTIX_UNWRAP_IN_HANDLER",
+      "severity": "CRITICAL",
+      "description": "unwrap() in a request handler can panic the worker thread.",
+      "suggestedFix": "Propagate a typed response error instead of unwrapping."
+    }
+  ]
+}

package/dist/config/environment-schema.json

@@ -0,0 +1,147 @@
+{
+  "schemaVersion": 1,
+  "variables": [
+    {
+      "name": "PLANU_ANTHROPIC_API_KEY",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "secret",
+      "default": null
+    },
+    { "name": "PLANU_AUTO_DRIFT", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_COMMENT", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_DISABLE_HOOKS", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_DRIFT_THRESHOLD", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_ENABLE_AUTOCOMMIT",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_FEEDBACK_ENDPOINT",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_FIGMA_CLIENT_ID", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_FIGMA_CLIENT_SECRET",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "secret",
+      "default": null
+    },
+    {
+      "name": "PLANU_GITHUB_CLIENT_ID",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    {
+      "name": "PLANU_GITHUB_CLIENT_SECRET",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "secret",
+      "default": null
+    },
+    {
+      "name": "PLANU_GLOBAL_DATA_DIR",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    { "name": "PLANU_HOST", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_MAX_PARALLEL_AGENTS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_MAX_TS_WATCHERS", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_MONTHLY_BUDGET_USD",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    { "name": "PLANU_NATIVE_PATH", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_NETWORK_CONSENT",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    { "name": "PLANU_OFFLINE", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_PLUGINS_DIR", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_PROJECT_DATA_DIR",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    { "name": "PLANU_PROJECT_PATH", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_QA_CHECK_TIMEOUT_MS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_RECORD_CASSETTES", "type": "boolean", "scope": "test", "sensitivity": "public", "default": null },
+    { "name": "PLANU_REGISTRY_URL", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_SAGA_CHAOS", "type": "string", "scope": "test", "sensitivity": "public", "default": null },
+    { "name": "PLANU_SESSION_BUDGET", "type": "number", "scope": "runtime", "sensitivity": "private", "default": null },
+    { "name": "PLANU_SESSION_ID", "type": "string", "scope": "runtime", "sensitivity": "private", "default": null },
+    {
+      "name": "PLANU_SUPPRESS_AUTOCOMMIT",
+      "type": "boolean",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_TELEMETRY", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_TELEMETRY_CONSENT_VERSION",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "private",
+      "default": null
+    },
+    {
+      "name": "PLANU_TELEMETRY_ENDPOINT",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_TELEMETRY_TOKEN", "type": "string", "scope": "runtime", "sensitivity": "secret", "default": null },
+    { "name": "PLANU_TIMING", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
+    { "name": "PLANU_TOOL_TIMEOUT_MS", "type": "number", "scope": "runtime", "sensitivity": "public", "default": null },
+    {
+      "name": "PLANU_VALIDATE_LINT_TIMEOUT_MS",
+      "type": "number",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "default": null
+    },
+    { "name": "PLANU_VERBOSE_OUTPUT", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null }
+  ],
+  "dynamicPatterns": [
+    {
+      "pattern": "^PLANU_WORKER_[A-Z0-9_]+_(ENABLED|COOLDOWNMS|PRIORITY|TIER)$",
+      "type": "string",
+      "scope": "runtime",
+      "sensitivity": "public",
+      "owner": "worker-config-loader"
+    }
+  ]
+}

package/dist/config/hardcode-exceptions.json

@@ -0,0 +1,4 @@
+{
+  "schemaVersion": 1,
+  "exceptions": []
+}

package/dist/config/native-release-public-key.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAxEphEcoGPysItgE7nFfqo8pDvXOlNcKKt0KkJ3wiqz4=
+-----END PUBLIC KEY-----