@planu/cli 4.14.1 → 5.0.0

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [5.0.0] - 2026-07-31
+
+### Breaking Changes
+
+- Removed Planu commercial plans, license activation, trials, project/spec
+  limits, daily commercial quotas, and the Lemon Squeezy entitlement surface.
+- All local tools are available without payment under the Planu Proprietary
+  Free-Use License. The official unmodified package may be used commercially or
+  non-commercially with unlimited users and instances; the repository and
+  TypeScript implementation remain private and proprietary.
+- Removed the public license commands, entitlement fields, environment
+  variables, and tier-based tool metadata. Consumers must remove those obsolete
+  fields instead of relying on compatibility aliases.
+- Removed the orphaned `product-intelligence` public types and embedded
+  telemetry/feedback project endpoints and credentials. Telemetry delivery now
+  requires explicit `PLANU_TELEMETRY_ENDPOINT` and `PLANU_TELEMETRY_TOKEN`
+  configuration; remote feedback requires `PLANU_FEEDBACK_ENDPOINT`.
+
+### Security and Distribution
+
+- Preserved engineering budgets, hosted authentication and authorization,
+  transport abuse controls, dependency-license auditing, model pricing, runtime
+  timeouts, local usage health, and generic outbound webhooks.
+- Added narrow, idempotent cleanup for obsolete commercial state and a forward
+  Supabase migration that removes trial data without rewriting migration history.
+- Hardened npm packaging to allow public `.d.ts` declarations while rejecting
+  implementation `.ts`, source maps, embedded sources, personal paths, and
+  personal identity metadata.
+
+### Community
+
+- Kept direct BTC, ETH, and SOL donations, sponsorship channels, testimonials,
+  and the disabled-until-configured newsletter contract.
+
 ## [4.14.1] - 2026-07-29
 
 ### Bug Fixes
@@ -4474,4 +4508,4 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · Versioning:
 - Mermaid diagram generation (architecture, sequence, state machine, ER, data flow)
 - Multi-language i18n (EN/ES/PT) for generated specs
 - Clean Architecture (hexagonal) — engine, tools, storage, types layers
-- 10,857 tests with ≥95% coverage
+- 10,857 tests with ≥95% coverage

package/LICENSE

@@ -1,16 +1,59 @@
+Planu Proprietary Free-Use License 1.0
+
 Copyright (c) 2026 Planu. All rights reserved.
 
-This software and associated documentation files (the "Software") are the
-proprietary property of Planu. Unauthorized copying, modification, distribution,
-or use of this Software, in whole or in part, is strictly prohibited without
-prior written permission from the copyright holder.
+1. Definitions
+
+"Official Package" means an unmodified Planu executable package made available
+by Planu through an authorized package registry or distribution channel. It
+includes the JavaScript runtime, native binaries, public type declarations,
+documentation, and other files intentionally included in that package.
+
+2. Free-use grant
+
+Subject to this license, Planu grants you a worldwide, royalty-free,
+non-exclusive, non-transferable license to install and execute Official
+Packages for commercial and non-commercial purposes, with no limit on users,
+projects, installations, or instances. You may make the internal copies
+reasonably necessary for npm installation, package caches, CI, containers,
+deployment, disaster recovery, and backups. Those copies must remain
+unmodified, be used only by you or your organization, and retain this license
+and all proprietary notices.
+
+3. Proprietary ownership and restrictions
+
+Planu and its licensors retain all right, title, and interest in the software,
+repository, implementation source code, and derivative works. This license
+does not grant source-code access or any open-source rights. Except where
+applicable law expressly prevents the restriction, you may not:
+
+- publish, disclose, sell, sublicense, or provide Planu implementation source;
+- modify, adapt, translate, reverse engineer, decompile, or create derivative
+  builds from an Official Package;
+- remove or alter copyright, license, attribution, or proprietary notices;
+- repackage, mirror, resell, sublicense, or publicly redistribute an Official
+  Package or a derived build; or
+- use Planu trademarks to imply endorsement or authorship of another product.
+
+Planu may separately authorize redistribution or modification in writing.
+
+4. Third-party components
+
+Third-party components remain subject to their own license terms. Those terms
+do not change the proprietary status of Planu's original implementation.
+
+5. Termination
+
+This license terminates automatically if you breach it. On termination, you
+must stop using Planu and delete copies under your control, except archival
+copies that applicable law requires you to retain.
+
+6. Disclaimer and limitation of liability
 
-The Software is provided "as is", without warranty of any kind, express or
-implied, including but not limited to the warranties of merchantability,
-fitness for a particular purpose, and noninfringement. In no event shall the
-authors or copyright holders be liable for any claim, damages, or other
-liability, whether in an action of contract, tort, or otherwise, arising from,
-out of, or in connection with the Software or the use or other dealings in the
-Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NONINFRINGEMENT. TO THE MAXIMUM EXTENT PERMITTED BY LAW, PLANU AND ITS AUTHORS
+OR COPYRIGHT HOLDERS ARE NOT LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY
+ARISING FROM OR RELATED TO THE SOFTWARE OR ITS USE.
 
-For licensing inquiries, contact: hello@planu.dev
+For permissions beyond this license, contact hello@planu.dev.

package/README.md

@@ -21,7 +21,7 @@ Planu is a Spec Driven Development stack for AI coding agents: an MCP server and
 - **Local change detection** — observes project changes without requiring a hosted configuration service.
 - **Unified Spec Format** — Requirements and technical details in a single, context-efficient `spec.md`.
 - **Atomic Integrity** — Indestructible writes and **Freeze-on-done** immutability (P0).
-- **27 official MCP tools** for the public SDD surface, with advanced workflows kept in skills, CLI commands, and internal pipelines.
+- **28 official MCP tools** for the public SDD surface, with advanced workflows kept in skills, CLI commands, and internal pipelines.
 - **Multi-agent compatible** — Optimized for Claude Code, Cursor, Windsurf, and Gemini CLI.
 
 ---
@@ -126,4 +126,12 @@ pnpm release:local # Local-first release flow when shipping
 
 ## License
 
-Planu is proprietary software. See the [license terms](LICENSE) for permitted use and distribution restrictions.
+Planu is proprietary, free-use software. The official unmodified package may be
+installed and executed without payment for commercial and non-commercial work,
+with unlimited users and instances. Internal copies needed for npm caches, CI,
+containers, deployment, and backups are permitted. The repository and
+TypeScript implementation sources remain private; modification, repackaging,
+derived builds, and public redistribution are restricted. Distributed
+JavaScript remains readable and is not represented as secret.
+
+See the [Planu Proprietary Free-Use License](LICENSE) for the complete terms.

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

@@ -1,9 +1,4 @@
 import type { CliCommand } from '../../types/cli.js';
-export interface LicenseActivationResult {
-    key: string;
-    customerEmail: string;
-    variantName: string;
-}
 interface McpEntry {
     command: string;
     args: string[];
@@ -46,7 +41,7 @@ export interface InstallationManifest {
     updatedAt: string;
     installations: InstallationRecord[];
 }
-declare function buildMcpEntry(_licenseKey?: string): McpEntry;
+declare function buildMcpEntry(): McpEntry;
 declare function readJsonFile(filePath: string): ToolConfig;
 declare function hasPlanuEntry(config: ToolConfig, format: ToolDefinition['format']): boolean;
 export declare function readInstallationManifest(manifestPath: string): InstallationManifest;
@@ -55,12 +50,6 @@ export declare function removeInstallationRecords(manifestPath: string, removedC
 declare function writeStandardEntry(filePath: string, entry: McpEntry): void;
 declare function writeZedEntry(filePath: string, entry: McpEntry): void;
 declare function removeEntry(filePath: string, format: ToolDefinition['format']): void;
-/**
- * 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 declare function promptLicense(): Promise<LicenseActivationResult | null>;
 export { buildMcpEntry, readJsonFile, hasPlanuEntry, writeStandardEntry, writeZedEntry, removeEntry, };
 export declare const installCommand: CliCommand;
 //# sourceMappingURL=install.d.ts.map

package/dist/cli/commands/install.js

@@ -5,9 +5,9 @@ import { homedir } from 'node:os';
 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
 // ---------------------------------------------------------------------------
@@ -66,7 +66,7 @@ const TOOLS = [
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function buildMcpEntry(_licenseKey) {
+function buildMcpEntry() {
     const offline = process.env.PLANU_OFFLINE === '1';
     return {
         command: 'npx',
@@ -243,61 +243,6 @@ function removeEntry(filePath, format) {
         : removePlanuFromStandard(config);
     writeJsonAtomically(filePath, updated);
 }
-// ---------------------------------------------------------------------------
-// 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' };
-    }
-    if (process.env.PLANU_OFFLINE === '1') {
-        return null;
-    }
-    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;
-    }
-}
 // Exported so tests can use them without going through the interactive CLI
 export { buildMcpEntry, readJsonFile, hasPlanuEntry, writeStandardEntry, writeZedEntry, removeEntry, };
 // ---------------------------------------------------------------------------
@@ -372,8 +317,8 @@ async function resolveTargets(detected, installAll) {
     }
     return detected.filter((t) => t.name === choice);
 }
-async function installToPath(tool, targetPath, scope, 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 = {};
@@ -455,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 = [];
@@ -486,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) {
@@ -504,7 +448,7 @@ export const installCommand = {
             else {
                 targetPath = tool.userScopePath;
             }
-            const ok = await installToPath(tool, targetPath, scope, quiet, licenseKey);
+            const ok = await installToPath(tool, targetPath, scope, quiet);
             if (ok) {
                 installed++;
             }

package/dist/cli/commands/job.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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';
+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',
@@ -86,7 +86,7 @@ export const jobCommand = {
                 workspaceId: values['workspace-id'],
             };
             const runtime = __addDisposableResource(env_1, new DurableJobRuntime(), false);
-            const job = action === 'cancel'
+            const internalJob = action === 'cancel'
                 ? runtime.cancel(identity)
                 : action === 'watch'
                     ? await runtime.watch({
@@ -95,7 +95,8 @@ export const jobCommand = {
                         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`);
+            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;

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 { executeValidate as handleValidate } from '../../tools/validate.js';
+import { 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';
@@ -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/validate.js

@@ -1,6 +1,6 @@
 // cli/commands/validate.ts — planu validate <specId> (SPEC-124)
 import { parseArgs } from 'node:util';
-import { executeValidate as handleValidate } from '../../tools/validate.js';
+import { handleValidate } from '../../tools/validate.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { red } from '../colors.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/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 }, { storageCommand }, { inspectCommand }, { offlineCommand }, { jobCommand },] = 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,7 +19,6 @@ 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'),
@@ -43,7 +42,6 @@ async function loadCommands() {
         installCommand,
         doctorCommand,
         uninstallCommand,
-        activateCommand,
         specCommand,
         healthCommand,
         releaseCommand,

package/dist/config/environment-schema.json

@@ -101,9 +101,6 @@
     { "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_SKIP_TRIAL", "type": "boolean", "scope": "runtime", "sensitivity": "public", "default": null },
-    { "name": "PLANU_SUPABASE_KEY", "type": "string", "scope": "runtime", "sensitivity": "secret", "default": null },
-    { "name": "PLANU_SUPABASE_URL", "type": "string", "scope": "runtime", "sensitivity": "public", "default": null },
     {
       "name": "PLANU_SUPPRESS_AUTOCOMMIT",
       "type": "boolean",
@@ -126,6 +123,7 @@
       "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 },
     {

package/dist/config/official-sdd-tools.d.ts

@@ -0,0 +1,4 @@
+/** Single editable authority for the official local SDD tool surface. */
+export declare const OFFICIAL_SDD_TOOL_NAMES: readonly ['planu_status', 'session_checkpoint', 'facilitate', 'init_project', 'clarify_requirements', 'create_spec', 'list_specs', 'challenge_spec', 'check_readiness', 'update_status', 'update_status_batch', 'package_handoff', 'validate', 'get_job', 'watch_job', 'cancel_job', 'restart_job', 'reconcile_spec', 'create_rule', 'create_skill', 'skill_search', 'configure_code_graph', 'code_graph_status', 'submit_feedback', 'triage_feedback', 'resolve_feedback', 'sync_feedback', 'feedback_status'];
+export declare function readCanonicalToolNames(): string[];
+//# sourceMappingURL=official-sdd-tools.d.ts.map

package/dist/config/official-sdd-tools.js

@@ -0,0 +1,35 @@
+/** Single editable authority for the official local SDD tool surface. */
+export const OFFICIAL_SDD_TOOL_NAMES = [
+    'planu_status',
+    'session_checkpoint',
+    'facilitate',
+    'init_project',
+    'clarify_requirements',
+    'create_spec',
+    'list_specs',
+    'challenge_spec',
+    'check_readiness',
+    'update_status',
+    'update_status_batch',
+    'package_handoff',
+    'validate',
+    'get_job',
+    'watch_job',
+    'cancel_job',
+    'restart_job',
+    'reconcile_spec',
+    'create_rule',
+    'create_skill',
+    'skill_search',
+    'configure_code_graph',
+    'code_graph_status',
+    'submit_feedback',
+    'triage_feedback',
+    'resolve_feedback',
+    'sync_feedback',
+    'feedback_status',
+];
+export function readCanonicalToolNames() {
+    return [...OFFICIAL_SDD_TOOL_NAMES];
+}
+//# sourceMappingURL=official-sdd-tools.js.map

package/dist/config/product-public.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ProductPublicManifest } from '../types/product-public.js';
-export declare const productPublicSchema: z.ZodObject<{
+export declare const productPublicSchema: z.ZodPipe<z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     website: z.ZodObject<{
         baseUrl: z.ZodURL;
@@ -75,14 +75,150 @@ export declare const productPublicSchema: z.ZodObject<{
     }, z.core.$strict>>;
     claims: z.ZodObject<{
         installCommand: z.ZodString;
-        publicToolInventory: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>>;
         registryReadmeBaseline: z.ZodObject<{
             package: z.ZodLiteral<"@planu/cli">;
             version: z.ZodString;
             sha256: z.ZodString;
         }, z.core.$strict>;
     }, z.core.$strict>;
-}, z.core.$strict>;
+}, z.core.$strict>, z.ZodTransform<{
+    schemaVersion: 1;
+    website: {
+        baseUrl: string;
+        defaultLocale: string;
+        theme: {
+            defaultAppearance: "system";
+            allowUserToggle: boolean;
+        };
+        disabledRouteSegments: string[];
+        locales: {
+            id: string;
+            contentLocale: "de" | "en" | "es" | "fr" | "pt" | "zh";
+            label: string;
+            lang: string;
+            hreflang: string;
+            ogLocale: string;
+            nav: {
+                text: string;
+                path: string;
+            }[];
+            chrome: {
+                footerLead: string;
+                support: string;
+                changelog: string;
+                reportBug: string;
+                appearance: string;
+                lightTheme: string;
+                darkTheme: string;
+                sidebar: string;
+                top: string;
+                language: string;
+                skip: string;
+                outline: string;
+                previous: string;
+                next: string;
+                search: string;
+                noResults: string;
+            };
+        }[];
+        newsletter: {
+            enabled: boolean;
+            provider: "none";
+            signupUrl: string | null;
+        };
+        sponsors: {
+            enabled: boolean;
+            pagePath: string;
+            githubUrl: string;
+            contactEmail: string;
+        };
+    };
+    donations: {
+        id: "btc" | "eth" | "sol";
+        symbol: string;
+        network: string;
+        address: string;
+        qrPath: string;
+        walletUri: string | null;
+    }[];
+    claims: {
+        installCommand: string;
+        registryReadmeBaseline: {
+            package: "@planu/cli";
+            version: string;
+            sha256: string;
+        };
+        publicToolInventory: string[];
+    };
+}, {
+    schemaVersion: 1;
+    website: {
+        baseUrl: string;
+        defaultLocale: string;
+        theme: {
+            defaultAppearance: "system";
+            allowUserToggle: boolean;
+        };
+        disabledRouteSegments: string[];
+        locales: {
+            id: string;
+            contentLocale: "de" | "en" | "es" | "fr" | "pt" | "zh";
+            label: string;
+            lang: string;
+            hreflang: string;
+            ogLocale: string;
+            nav: {
+                text: string;
+                path: string;
+            }[];
+            chrome: {
+                footerLead: string;
+                support: string;
+                changelog: string;
+                reportBug: string;
+                appearance: string;
+                lightTheme: string;
+                darkTheme: string;
+                sidebar: string;
+                top: string;
+                language: string;
+                skip: string;
+                outline: string;
+                previous: string;
+                next: string;
+                search: string;
+                noResults: string;
+            };
+        }[];
+        newsletter: {
+            enabled: boolean;
+            provider: "none";
+            signupUrl: string | null;
+        };
+        sponsors: {
+            enabled: boolean;
+            pagePath: string;
+            githubUrl: string;
+            contactEmail: string;
+        };
+    };
+    donations: {
+        id: "btc" | "eth" | "sol";
+        symbol: string;
+        network: string;
+        address: string;
+        qrPath: string;
+        walletUri: string | null;
+    }[];
+    claims: {
+        installCommand: string;
+        registryReadmeBaseline: {
+            package: "@planu/cli";
+            version: string;
+            sha256: string;
+        };
+    };
+}>>;
 export declare function parseProductPublicManifest(input: unknown): ProductPublicManifest;
 export declare function getProductPublicManifest(): ProductPublicManifest;
 export declare const productPublic: ProductPublicManifest;

package/dist/config/product-public.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import rawProductPublic from './product-public.json' with { type: 'json' };
+import { readCanonicalToolNames } from './official-sdd-tools.js';
 const nonBlank = z.string().trim().min(1).max(512);
 const pathSegment = z.string().regex(/^[A-Za-z0-9-]+$/u);
 const navItemSchema = z.object({ text: nonBlank, path: nonBlank }).strict();
@@ -81,7 +82,6 @@ export const productPublicSchema = z
     claims: z
         .object({
         installCommand: nonBlank,
-        publicToolInventory: z.array(pathSegment.or(z.string().regex(/^[a-z][a-z0-9_]+$/u))).min(1),
         registryReadmeBaseline: z
             .object({
             package: z.literal('@planu/cli'),
@@ -93,6 +93,13 @@ export const productPublicSchema = z
         .strict(),
 })
     .strict()
+    .transform((value) => ({
+    ...value,
+    claims: {
+        ...value.claims,
+        publicToolInventory: readCanonicalToolNames(),
+    },
+}))
     .superRefine((value, context) => {
     const localeIds = value.website.locales.map(({ id }) => id);
     const donationIds = value.donations.map(({ id }) => id);