@planu/cli 4.1.3 → 4.2.0

package/dist/tools/create-spec.js

@@ -2,6 +2,7 @@ import { checkGate } from '../engine/clarification-gate/gate.js';
 import { upsertToken, hashQuestions } from '../engine/clarification-gate/token-store.js';
 import { ti } from '../i18n/index.js';
 import { knowledgeStore, specStore } from '../storage/index.js';
+import { readTechnologySelectionContract } from '../storage/technology-selection-store.js';
 import { formatSuccess, addNextSteps, toolResult, interactiveResult } from './response-helpers.js';
 import { writeFile, mkdir, rm, readFile, stat } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
@@ -515,17 +516,36 @@ export async function handleCreateSpec(inputParams, server) {
                 await measureStep('mkdir-specDir', () => mkdir(specDir, { recursive: true }));
                 // SPEC-586: Filter suggested criteria by spec tags/target/scope before injection
                 const filteredCriteria = await filterCriteriaByTags(autopilot.suggestedCriteria, spec.tags, spec.target, spec.scope).catch(() => autopilot.suggestedCriteria);
+                const technologyContract = await readTechnologySelectionContract(params.projectPath ?? '');
+                const contractNote = technologyContract
+                    ? [
+                        '',
+                        'Technology Contract:',
+                        `- Mode: ${technologyContract.mode}`,
+                        technologyContract.language ? `- Language: ${technologyContract.language}` : '',
+                        technologyContract.framework
+                            ? `- Framework: ${technologyContract.framework}`
+                            : '- Framework: none or not selected',
+                        technologyContract.platform ? `- Platform: ${technologyContract.platform}` : '',
+                        technologyContract.projectType
+                            ? `- Project type: ${technologyContract.projectType}`
+                            : '',
+                        '- Agents must not choose a different stack unless the user approves a new contract.',
+                    ]
+                        .filter(Boolean)
+                        .join('\n')
+                    : '';
                 const specGenerator = new FallbackGenerator();
                 const generatedSpec = await measureStep('generateSpecBody', () => specGenerator.generate({
                     title: spec.title,
-                    description,
+                    description: `${description}${contractNote}`,
                     type: spec.type,
                     scope: spec.scope,
                     target: spec.target,
                     acFormat: params.acFormat,
                     projectContext: {
-                        language: knowledge?.language ?? undefined,
-                        framework: knowledge?.framework ?? undefined,
+                        language: technologyContract?.language ?? knowledge?.language ?? undefined,
+                        framework: technologyContract?.framework ?? knowledge?.framework ?? undefined,
                         architecture: knowledge?.architecture.primary ?? undefined,
                     },
                 }));

package/dist/tools/facilitate.js

@@ -7,6 +7,8 @@ import { loadContext } from '../engine/facilitate/context-loader.js';
 import { route } from '../engine/facilitate/router.js';
 import { parsePlanContent } from '../engine/facilitate/plan-parser.js';
 import { compactJson, compactResult, compactError } from './output-formatter.js';
+import { interactiveResult } from './response-helpers.js';
+import { resolveNewProjectOnboarding } from '../engine/onboarding/new-project-resolver.js';
 // ---------------------------------------------------------------------------
 // Scenario detection (SPEC-037 legacy — kept for backward compatibility)
 // ---------------------------------------------------------------------------
@@ -31,29 +33,6 @@ function detectScenario(description) {
     return 'new_project';
 }
 // ---------------------------------------------------------------------------
-// Step questions for new_project scenario
-// ---------------------------------------------------------------------------
-const NEW_PROJECT_STEPS = [
-    'What is the main purpose of your app? What problem does it solve and for whom?',
-    'What platform will it run on? (web app, mobile iOS/Android, REST API, desktop app, CLI tool)',
-    'Do you have a preferred tech stack? (language, framework, database — skip if unsure)',
-];
-function buildNewProjectResponse(step, collectedInfo) {
-    if (step < NEW_PROJECT_STEPS.length) {
-        const question = NEW_PROJECT_STEPS[step] ?? NEW_PROJECT_STEPS[0];
-        const intro = step === 0
-            ? "Welcome to Planu! I'll guide you with a few questions to generate a precise spec.\n\n"
-            : `Got it! ${Object.values(collectedInfo).join(', ')}\n\n`;
-        return `${intro}Step ${step + 1}/3: ${question}`;
-    }
-    const info = Object.values(collectedInfo).join(' | ');
-    return (`Great — I have enough context to generate your spec.\n\n` +
-        `Summary: ${info}\n\n` +
-        `Next step: Call \`create_spec\` with this description:\n` +
-        `"${Object.values(collectedInfo).join('. ')}."\n\n` +
-        `Or call \`clarify_requirements\` first for deeper requirement analysis.`);
-}
-// ---------------------------------------------------------------------------
 // Existing project scenario
 // ---------------------------------------------------------------------------
 function buildExistingProjectResponse(description) {
@@ -206,7 +185,7 @@ async function runSmartOrchestrator(description, projectId, planContent) {
 // Main handler
 // ---------------------------------------------------------------------------
 export async function handleFacilitate(params, server) {
-    const { description, projectId, sessionId, scenario: explicitScenario, collectedInfo = {}, step = 0, targetTool, checkFocus = false, changeFocus, paradigmReport, planContent, } = params;
+    const { description, projectId, sessionId, scenario: explicitScenario, step = 0, targetTool, checkFocus = false, changeFocus, paradigmReport, planContent, } = params;
     const sessionKey = sessionId ?? projectId ?? 'default';
     // SPEC-264: When planContent provided OR no explicit scenario/control params given,
     // use the smart orchestrator path.
@@ -355,11 +334,42 @@ export async function handleFacilitate(params, server) {
         let guidance;
         switch (scenario) {
             case 'new_project': {
-                const updatedInfo = step === 0
-                    ? { ...collectedInfo, step0: description }
-                    : { ...collectedInfo, [`step${step}`]: description };
-                guidance = buildNewProjectResponse(step, updatedInfo);
-                break;
+                const resolution = await resolveNewProjectOnboarding({
+                    description,
+                    parentWorkspacePath: params.parentWorkspacePath,
+                    projectPath: params.projectId,
+                    appName: params.appName,
+                    appSlug: params.appSlug,
+                    projectType: params.projectType,
+                    platform: params.platform,
+                    language: params.language,
+                    framework: params.framework,
+                    database: params.database,
+                    createDirectory: params.createDirectory,
+                    clarificationAnswers: params.clarificationAnswers,
+                });
+                if (!resolution.ready) {
+                    const response = interactiveResult(resolution.questions, 'New project onboarding needs a target app folder and technology choices before Planu can initialize anything. Do not call init_project on the parent workspace yet.', 'universal');
+                    response.structuredContent = {
+                        ...response.structuredContent,
+                        mode: 'new_project',
+                        parentWorkspacePath: resolution.parentWorkspacePath,
+                        resolvedProjectPath: resolution.resolvedProjectPath,
+                        appSlug: resolution.appSlug,
+                        errors: resolution.errors,
+                        nextAction: 'Ask the user these questions, then call facilitate again with clarificationAnswers or explicit fields. Only call init_project with the resolved child projectPath.',
+                    };
+                    return response;
+                }
+                return ok({
+                    action: 'facilitate',
+                    scenario,
+                    mode: 'new_project',
+                    readyToInitialize: true,
+                    resolvedProjectPath: resolution.resolvedProjectPath,
+                    technologySelectionContract: resolution.contract,
+                    nextAction: 'Call init_project with mode="new_project", projectPath set to resolvedProjectPath, createDirectory=true, and technologySelectionContract from this response.',
+                });
             }
             case 'existing_project':
                 guidance = buildExistingProjectResponse(description);

package/dist/tools/init-project/handler.js

@@ -1,7 +1,7 @@
 import { elicitOrFallback, questionsToFormSchema } from '../../engine/elicitation/elicit-helper.js';
 import { ti } from '../../i18n/index.js';
 import { AutopilotSummaryCollector } from '../../engine/autopilot/summary-collector.js';
-import { hashProjectPath, knowledgeStore, globalStore, licenseStore } from '../../storage/index.js';
+import { hashProjectPath, knowledgeStore, globalStore, licenseStore, technologySelectionStore, } from '../../storage/index.js';
 import { addProject } from '../../storage/global-projects-store.js';
 import { getCurrentTier } from '../license-gate.js';
 import { checkLimits } from '../../engine/license-validator.js';
@@ -24,7 +24,7 @@ import { readAutoInstallFlag, orchestrateSkillInstalls, runHealthCheckWithBaseli
 import { injectProactiveRules } from '../../engine/claude-md-injector/index.js';
 import { discoverSkillsForInit } from '../../engine/skill-bootstrap/registry-fetcher.js';
 import { join } from 'node:path';
-import { stat } from 'node:fs/promises';
+import { mkdir, stat } from 'node:fs/promises';
 import { generateAgentTeamsRulesIfMissing, generateWorkflowRulesIfMissing, } from './rules-generator.js';
 import { installUniversalRules } from '../../engine/universal-rules/installer.js';
 import { detectHost } from '../../engine/host-detection/detect-host.js';
@@ -37,6 +37,8 @@ import { applyStackBasedGroupActivations } from './tool-group-activator.js';
 import { checkGate } from '../../engine/clarification-gate/gate.js';
 import { upsertToken, hashQuestions } from '../../engine/clarification-gate/token-store.js';
 import { reconcileInteractiveQuestionHooks } from '../reconcile-interactive-question-hooks.js';
+import { resolveNewProjectOnboarding } from '../../engine/onboarding/new-project-resolver.js';
+import { interactiveResult } from '../response-helpers.js';
 /** Frontend framework groups — mutually exclusive. Two or more detected → multi-stack conflict. */
 const FRONTEND_FRAMEWORK_GROUPS = [
     ['react', 'next', 'next.js', 'nextjs', 'remix', 'preact'],
@@ -81,8 +83,29 @@ export async function handleInitProject(params, server) {
     }
     // eslint-disable-next-line max-lines-per-function, complexity
     return trackCost(params.projectPath, 'init_project', async () => {
-        const { projectPath, locale, hourlyRate, experienceLevel, userProfile, autoInstallSkills, workMode, } = params;
+        const { projectPath, mode, locale, hourlyRate, experienceLevel, userProfile, autoInstallSkills, workMode, } = params;
         try {
+            let approvedTechnologyContract = params.technologySelectionContract ?? null;
+            if (mode === 'new_project' && approvedTechnologyContract === null) {
+                const resolution = await resolveNewProjectOnboarding({
+                    description: params.appName ?? params.projectType ?? 'New project',
+                    parentWorkspacePath: params.parentWorkspacePath,
+                    projectPath,
+                    appName: params.appName,
+                    appSlug: params.appSlug,
+                    projectType: params.projectType,
+                    platform: params.platform,
+                    language: params.language,
+                    framework: params.framework,
+                    database: params.database,
+                    createDirectory: params.createDirectory,
+                    clarificationAnswers: params.clarificationAnswers,
+                });
+                if (!resolution.ready) {
+                    return interactiveResult(resolution.questions, 'init_project new_project mode needs a confirmed child app folder and technology choices before writing project files.', 'universal');
+                }
+                approvedTechnologyContract = resolution.contract ?? null;
+            }
             // Validate projectPath exists and is a directory before any I/O
             try {
                 const pathStat = await stat(projectPath);
@@ -99,15 +122,20 @@ export async function handleInitProject(params, server) {
                 }
             }
             catch {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Project directory does not exist: "${projectPath}". Create the directory first and try again.`,
-                        },
-                    ],
-                    isError: true,
-                };
+                if (mode === 'new_project' && params.createDirectory === true) {
+                    await mkdir(projectPath, { recursive: true });
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Project directory does not exist: "${projectPath}". Create the directory first and try again.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
             }
             const projectId = hashProjectPath(projectPath);
             // SPEC-1007: migrate legacy <cwd>/data/projects/{id} into ~/.planu/data/
@@ -147,6 +175,19 @@ export async function handleInitProject(params, server) {
             const effectiveExperience = experienceLevel ?? existing?.experienceLevel ?? globalConfig.defaultExperienceLevel;
             // Run full project analysis
             const knowledge = await analyzeProject(projectPath, projectId, effectiveLocale, effectiveExperience);
+            if (approvedTechnologyContract !== null) {
+                knowledge.language = approvedTechnologyContract.language ?? knowledge.language;
+                knowledge.framework =
+                    approvedTechnologyContract.framework !== undefined
+                        ? approvedTechnologyContract.framework
+                        : knowledge.framework;
+                const stackAdditions = [
+                    approvedTechnologyContract.language,
+                    approvedTechnologyContract.framework ?? undefined,
+                    approvedTechnologyContract.database ?? undefined,
+                ].filter((item) => typeof item === 'string' && item.length > 0);
+                knowledge.stack = Array.from(new Set([...knowledge.stack, ...stackAdditions]));
+            }
             // Apply overrides
             if (userProfile) {
                 knowledge.userProfile = userProfile;
@@ -214,6 +255,12 @@ export async function handleInitProject(params, server) {
             }
             // Save initial project knowledge
             await knowledgeStore.saveKnowledge(projectId, knowledge);
+            if (approvedTechnologyContract !== null) {
+                await technologySelectionStore.writeTechnologySelectionContract(projectPath, {
+                    ...approvedTechnologyContract,
+                    projectPath,
+                });
+            }
             // SPEC-789: Register project in global workspace registry so workspace_health
             // and list_registered_projects can discover it without manual registration.
             addProject(projectPath).catch(() => {

package/dist/tools/register-spec-tools/core-spec-tools.js

@@ -18,6 +18,34 @@ import { handleTypeSafetyGate } from '../type-safety-gate.js';
 /** init_project inputSchema — extracted to keep registerCoreSpecTools within line budget. */
 const INIT_PROJECT_INPUT_SCHEMA = {
     projectPath: z.string().max(4096).describe('Absolute path to the project root'),
+    mode: z
+        .enum(['existing_project', 'new_project'])
+        .optional()
+        .describe('Onboarding mode. Defaults to existing_project for backwards compatibility.'),
+    parentWorkspacePath: z
+        .string()
+        .max(4096)
+        .optional()
+        .describe('Parent workspace path for explicit new_project onboarding'),
+    appName: z.string().max(500).optional().describe('Human-readable app name for new_project'),
+    appSlug: z
+        .string()
+        .max(200)
+        .optional()
+        .describe('Safe folder slug for new_project; must not contain path separators'),
+    projectType: z.string().max(500).optional().describe('Type of project being initialized'),
+    platform: z.string().max(500).optional().describe('Runtime/deployment platform'),
+    language: z.string().max(500).optional().describe('User-confirmed language'),
+    framework: z.string().max(500).nullable().optional().describe('User-confirmed framework'),
+    database: z.string().max(500).nullable().optional().describe('User-confirmed database'),
+    createDirectory: z
+        .boolean()
+        .optional()
+        .describe('When true with mode=new_project, create only the resolved projectPath directory'),
+    technologySelectionContract: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Approved TechnologySelectionContract returned by facilitate new_project flow'),
     locale: SupportedLocaleEnum.optional().describe('Preferred locale for this project'),
     hourlyRate: z.number().optional().describe('Developer hourly rate in USD for cost estimation'),
     experienceLevel: ExperienceLevelEnum.optional().describe('Developer experience level: beginner, intermediate, or expert'),
@@ -317,7 +345,11 @@ export function registerCoreSpecTools(server) {
                 .describe('Absolute project root. Preferred when projectId is unknown.'),
             status: SpecStatusEnum.describe('New status for all specs'),
             dryRun: z.boolean().optional().describe('Preview the batch without mutating any spec.'),
-            reviewNotes: z.string().max(10_000).optional().describe('Optional notes for each transition.'),
+            reviewNotes: z
+                .string()
+                .max(10_000)
+                .optional()
+                .describe('Optional notes for each transition.'),
         },
     }, safeTracked('update_status_batch', async (args) => handleUpdateStatusBatch(args)));
     // 8. estimate

package/dist/tools/tool-registry/core-tools.js

@@ -456,11 +456,45 @@ const coreToolsRegistry = [
                 .record(z.string().max(500), z.string().max(10_000))
                 .optional()
                 .describe('Answers collected in previous steps'),
+            parentWorkspacePath: z
+                .string()
+                .max(4096)
+                .optional()
+                .describe('Parent workspace path that should contain a new project folder'),
+            appName: z.string().max(500).optional().describe('Human-readable new app name'),
+            appSlug: z
+                .string()
+                .max(200)
+                .optional()
+                .describe('Safe folder name for the new app; must not contain path separators'),
+            projectType: z.string().max(500).optional().describe('Kind of project to create'),
+            platform: z.string().max(500).optional().describe('Runtime or deployment platform'),
+            language: z.string().max(500).optional().describe('User-confirmed programming language'),
+            framework: z
+                .string()
+                .max(500)
+                .nullable()
+                .optional()
+                .describe('User-confirmed framework, null for no framework'),
+            database: z
+                .string()
+                .max(500)
+                .nullable()
+                .optional()
+                .describe('User-confirmed database, null for no database'),
+            createDirectory: z
+                .boolean()
+                .optional()
+                .describe('When true in new_project flow, create only the resolved child project folder'),
+            clarificationAnswers: z
+                .record(z.string().max(500), z.string().max(10_000))
+                .optional()
+                .describe('Answers to interactiveQuestions emitted by facilitate'),
             step: z
                 .number()
                 .int()
                 .min(0)
-                .max(2)
+                .max(10)
                 .optional()
                 .describe('Current step index for new_project flow (0–2)'),
             targetTool: z

package/dist/tools/update-status/batch.js

@@ -8,7 +8,10 @@ function firstText(result) {
 export async function handleUpdateStatusBatch(input) {
     const uniqueSpecIds = [...new Set(input.specIds)].sort();
     if (uniqueSpecIds.length === 0) {
-        return { content: [{ type: 'text', text: 'update_status_batch requires at least one specId.' }], isError: true };
+        return {
+            content: [{ type: 'text', text: 'update_status_batch requires at least one specId.' }],
+            isError: true,
+        };
     }
     const resolved = await resolveProjectIdOrAutoDetect({
         projectId: input.projectId,

package/dist/types/facilitator.d.ts

@@ -1,4 +1,5 @@
 import type { ParadigmReport } from './paradigm.js';
+import type { TechnologySelectionContract } from './technology-selection.js';
 /** Ambiguity level for a tool request. */
 export type AmbiguityLevel = 'none' | 'low' | 'medium' | 'critical';
 /** Dimensions evaluated during ambiguity scoring. */
@@ -68,6 +69,18 @@ export interface FacilitateInput {
     scenario?: FacilitateScenario;
     /** Cumulative answers from previous steps. */
     collectedInfo?: Record<string, string>;
+    /** Parent workspace path for new-project onboarding. */
+    parentWorkspacePath?: string;
+    appName?: string;
+    appSlug?: string;
+    projectType?: string;
+    platform?: string;
+    language?: string;
+    framework?: string | null;
+    database?: string | null;
+    createDirectory?: boolean;
+    clarificationAnswers?: Record<string, string>;
+    technologySelectionContract?: TechnologySelectionContract;
     /** Step index (0-based). Incremented by the caller. */
     step?: number;
     /** Target tool for ambiguity check (optional). */

package/dist/types/index.d.ts

@@ -212,6 +212,7 @@ export * from './steering.js';
 export * from './sentry.js';
 export * from './supabase.js';
 export * from './skill-bootstrap.js';
+export * from './technology-selection.js';
 export * from './compliance-gate.js';
 export * from './schema-parity.js';
 export * from './auto-update.js';

package/dist/types/index.js

@@ -209,6 +209,7 @@ export * from './steering.js';
 export * from './sentry.js';
 export * from './supabase.js';
 export * from './skill-bootstrap.js';
+export * from './technology-selection.js';
 export * from './compliance-gate.js';
 export * from './schema-parity.js';
 export * from './auto-update.js';

package/dist/types/project/inputs.d.ts

@@ -2,12 +2,24 @@ import type { SupportedLocale, ExperienceLevel, WorkMode } from '../common/index
 import type { ConstitutionPrinciple } from './core.js';
 import type { PermissionsMode } from '../permissions-config.js';
 import type { PluginInstallMode } from '../plugin-install.js';
+import type { ProjectOnboardingMode, TechnologySelectionContract } from '../technology-selection.js';
 export interface SetLocaleInput {
     projectId?: string;
     locale: SupportedLocale;
 }
 export interface InitProjectInput {
     projectPath: string;
+    mode?: ProjectOnboardingMode;
+    parentWorkspacePath?: string;
+    appName?: string;
+    appSlug?: string;
+    projectType?: string;
+    platform?: string;
+    language?: string;
+    framework?: string | null;
+    database?: string | null;
+    createDirectory?: boolean;
+    technologySelectionContract?: TechnologySelectionContract;
     locale?: SupportedLocale;
     hourlyRate?: number;
     experienceLevel?: ExperienceLevel;

package/dist/types/technology-selection.d.ts

@@ -0,0 +1,77 @@
+import type { InteractiveQuestion } from './clarification.js';
+export type ProjectOnboardingMode = 'existing_project' | 'new_project';
+export type TechnologyDecisionSource = 'detected' | 'user-confirmed' | 'suggested-confirmed';
+export type TechnologyVerificationStatus = 'verified' | 'unverified';
+export interface TechnologyDocsVerification {
+    name: string;
+    url: string;
+    status: TechnologyVerificationStatus;
+    reason?: string;
+}
+export interface TechnologySelectionContract {
+    mode: ProjectOnboardingMode;
+    projectPath: string;
+    parentWorkspacePath?: string;
+    appName?: string;
+    appSlug?: string;
+    projectType?: string;
+    platform?: string;
+    language?: string;
+    framework?: string | null;
+    database?: string | null;
+    source: TechnologyDecisionSource;
+    evidence: string[];
+    officialDocs: TechnologyDocsVerification[];
+    verifiedAt?: string;
+}
+export interface NewProjectOnboardingInput {
+    description: string;
+    parentWorkspacePath?: string;
+    projectPath?: string;
+    appName?: string;
+    appSlug?: string;
+    projectType?: string;
+    platform?: string;
+    language?: string;
+    framework?: string | null;
+    database?: string | null;
+    createDirectory?: boolean;
+    clarificationAnswers?: Record<string, string>;
+}
+export interface NewProjectResolution {
+    ready: boolean;
+    parentWorkspacePath?: string;
+    resolvedProjectPath?: string;
+    appSlug?: string;
+    questions: InteractiveQuestion[];
+    contract?: TechnologySelectionContract;
+    errors: string[];
+}
+export type NewProjectQuestionState = Partial<{
+    parentWorkspacePath: string;
+    appSlug: string;
+    projectType: string;
+    platform: string;
+    language: string;
+    framework: string | null;
+    languageAnswered: boolean;
+    frameworkAnswered: boolean;
+    createDirectoryAnswered: boolean;
+}>;
+export interface NewProjectResolvedFields {
+    parentWorkspacePath?: string;
+    appName?: string;
+    appSlug?: string;
+    projectType?: string;
+    platform?: string;
+    language?: string;
+    framework?: string | null;
+    database?: string | null;
+    languageAnswered: boolean;
+    frameworkAnswered: boolean;
+    createDirectoryAnswered: boolean;
+    createDirectory: boolean;
+    resolvedProjectPath?: string;
+    errors: string[];
+}
+//# sourceMappingURL=technology-selection.d.ts.map

package/dist/types/technology-selection.js

@@ -0,0 +1,3 @@
+// types/technology-selection.ts — SPEC-1021 runtime onboarding contract
+export {};
+//# sourceMappingURL=technology-selection.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -32,12 +32,12 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.1.3",
-    "@planu/core-darwin-x64": "4.1.3",
-    "@planu/core-linux-arm64-gnu": "4.1.3",
-    "@planu/core-linux-arm64-musl": "4.1.3",
-    "@planu/core-linux-x64-gnu": "4.1.3",
-    "@planu/core-linux-x64-musl": "4.1.3"
+    "@planu/core-darwin-arm64": "4.2.0",
+    "@planu/core-darwin-x64": "4.2.0",
+    "@planu/core-linux-arm64-gnu": "4.2.0",
+    "@planu/core-linux-arm64-musl": "4.2.0",
+    "@planu/core-linux-x64-gnu": "4.2.0",
+    "@planu/core-linux-x64-musl": "4.2.0"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -143,6 +143,20 @@
       "hono": ">=4.12.14",
       "postcss": ">=8.5.10",
       "fast-uri": ">=3.1.2"
+    },
+    "supportedArchitectures": {
+      "os": [
+        "darwin",
+        "linux"
+      ],
+      "cpu": [
+        "arm64",
+        "x64"
+      ],
+      "libc": [
+        "glibc",
+        "musl"
+      ]
     }
   },
   "devDependencies": {
@@ -171,7 +185,7 @@
     "eslint-plugin-import": "^2.32.0",
     "happy-dom": "^20.9.0",
     "husky": "^9.1.7",
-    "javascript-obfuscator": "^5.4.2",
+    "javascript-obfuscator": "^5.4.3",
     "knip": "^6.14.1",
     "lint-staged": "^17.0.5",
     "madge": "^8.0.0",