@merchantduo/code 0.3.0-beta.2 → 0.4.0-beta.1

package/dist/app/runtime.d.ts

@@ -38,5 +38,6 @@ export declare class MerchantDuoRuntime {
     setMagerun2(capability: Magerun2Capability): void;
     setEnvironmentStatus(status: EnvironmentStatus): SessionState;
     startEnvironment(cwd: string): Promise<SessionState>;
+    refreshMagento(cwd: string): Promise<SessionState>;
     stopEnvironment(cwd: string): Promise<SessionState>;
 }

package/dist/app/runtime.js

@@ -1,6 +1,6 @@
 import { loadConfig, selectEnvironment, setProjectTheme, } from "#config/index";
 import { EnvironmentBackend } from "#environments/backend";
-import { resolvePermissionMode } from "#app/permission-mode";
+import { resolvePermissionMode, } from "#app/permission-mode";
 import { DefaultMagentoInspector, } from "#magento/index";
 import { ChangeTracker } from "#workflows/change-tracker";
 import { NativeProbeLog } from "#app/native-operations";
@@ -23,7 +23,11 @@ export class MerchantDuoRuntime {
         const selected = selectEnvironment(loaded.config, cwd, process.env.MERCHANTDUO_SELECTED_ENV);
         const backend = new EnvironmentBackend(selected.environment, cwd);
         const nativeLog = new NativeProbeLog();
-        await nativeLog.start({ project: cwd, session: `${process.pid}`, environment: selected.name });
+        await nativeLog.start({
+            project: cwd,
+            session: `${process.pid}`,
+            environment: selected.name,
+        });
         const environmentStatus = await nativeStatus(backend, nativeLog);
         this.#state = {
             ...loaded,
@@ -32,7 +36,9 @@ export class MerchantDuoRuntime {
             nativeLog,
             environmentStatus,
             permissionMode: resolvePermissionMode(selected.environment, process.env.MERCHANTDUO_PERMISSION_MODE),
-            magento: environmentStatus === "running" ? await this.inspector.inspect(backend, (argv, result) => nativeLog.record(backend.command(argv), result)) : stoppedMagentoSnapshot(),
+            magento: environmentStatus === "running"
+                ? await this.inspector.inspect(backend, (argv, result) => nativeLog.record(backend.command(argv), result), selected.environment)
+                : stoppedMagentoSnapshot(),
         };
         return this.#state;
     }
@@ -87,7 +93,13 @@ export class MerchantDuoRuntime {
             throw new Error(result.stderr || result.stdout || "Could not start environment");
         state.environmentStatus = await state.backend.status();
         if (state.environmentStatus === "running")
-            state.magento = await this.inspector.inspect(state.backend);
+            await this.refreshMagento(cwd);
+        return state;
+    }
+    async refreshMagento(cwd) {
+        const state = await this.boot(cwd);
+        if (state.environmentStatus === "running")
+            state.magento = await this.inspector.inspect(state.backend, undefined, state.selected.environment);
         return state;
     }
     async stopEnvironment(cwd) {
@@ -105,7 +117,13 @@ export class MerchantDuoRuntime {
     }
 }
 function stoppedMagentoSnapshot() {
-    return { cacheTypes: [], warnings: ["Environment is stopped"], evidence: [], themes: [] };
+    return {
+        cacheTypes: [],
+        database: { status: "unavailable" },
+        warnings: ["Environment is stopped"],
+        evidence: [],
+        themes: [],
+    };
 }
 async function nativeStatus(backend, log) {
     if (backend.environment.type === "ssh")
@@ -117,5 +135,7 @@ async function nativeStatus(backend, log) {
         return "stopped";
     const result = await backend.runCommand(spec);
     await log.record(spec, result);
-    return result.exitCode === 0 && wardenRunning(result.stdout) ? "running" : "stopped";
+    return result.exitCode === 0 && wardenRunning(result.stdout)
+        ? "running"
+        : "stopped";
 }

package/dist/app/status.js

@@ -2,10 +2,17 @@ export function setInitializingStatus(ctx) {
     ctx.ui.setStatus("merchantduo", "Initializing Magento context…");
 }
 export function refreshStatus(ctx, state) {
+    const database = state.magento.database.status === "unavailable"
+        ? ["🛢️ unavailable", "🌐 unavailable"]
+        : [
+            `🛢️ ${state.magento.database.name} (${state.magento.database.location})`,
+            `🌐 ${state.magento.database.status === "ready" ? "ready" : "not ready"}`,
+        ];
     const parts = [
         `M${state.magento.version ?? "?"}`,
-        `${state.selected.name} (${state.environmentStatus})`,
-        state.permissionMode === "read-only" ? "r-o" : state.permissionMode,
+        `🖥️ ${state.selected.name} (${state.environmentStatus})`,
+        ...database,
+        `🔐 ${state.permissionMode === "read-only" ? "r-o" : state.permissionMode}`,
         ...(state.config.activeTheme === "all" ? [] : [state.config.activeTheme]),
         ...(state.testing?.frontendUrl ? [state.testing.frontendUrl] : []),
     ];

package/dist/app/system-prompt.js

@@ -2,28 +2,220 @@ import { packagePath } from "#shared/package-paths";
 export function mage2genRoot() {
     return packagePath("vendor/mage2gen");
 }
-// Source: MAGENTO_SYSTEM_PROMPT.md. Keep this contract verbatim in every Magento session.
-const generalMagentoEngineeringPrompt = "# Magento Engineering\n\nFor Magento Open Source / Adobe Commerce work, optimize for the **smallest Magento-native, maintainable, upgrade-safe change**, not merely a working PHP implementation.\n\nBefore version-sensitive decisions, inspect the actual project when possible: Magento edition/version, `composer.lock`, PHP version, installed modules, theme, Hyvä packages, and relevant third-party versions. Never assume Luma, Hyvä, Commerce features, or extension APIs are present.\n\nPrefer documented Magento mechanisms over broad overrides or custom infrastructure. Prefer composition over inheritance. Treat non-`@api` Magento/vendor internals as upgrade-sensitive.\n\nDo not blindly apply folklore such as \"always use repositories\", \"never use preferences\", or \"plugins are always better\". Choose mechanisms according to their intended scope and blast radius.\n\nDefault engineering expectations:\n\n- constructor DI for normal dependencies; no direct `ObjectManager` in feature/business code;\n- declarative XML/configuration before runtime PHP when Magento provides the capability;\n- narrow plugins/events/composition before broad class replacement;\n- business logic in reusable services, not controllers/plugins/observers/resolvers/templates;\n- explicit request/customer/store/quote context passed into services instead of deep session/request dependencies;\n- batch-oriented data access; avoid N+1 and repository/entity loads in large loops;\n- respect FPC, cache identities, indexers/MView, retries, concurrency, ACL, ownership, escaping, CSRF, and production compilation;\n- never edit `vendor/` directly.\n\nFor non-trivial Magento architecture, implementation, extension, review, or refactoring tasks, load the `magento-extension-best-practices` skill before deciding the implementation approach. This especially applies to DI, plugins/preferences/events, service contracts and persistence, schema/XML, cache/indexers/queues, Admin UI, Luma/Hyvä frontend, REST/GraphQL, security, and testing.";
+/**
+ * System-level Magento contract.
+ *
+ * Keep this intentionally narrower than the
+ * `magento-extension-best-practices` skill.
+ *
+ * The skill is loaded into every Magento session after this prompt and owns
+ * implementation heuristics: plugins vs preferences, DI patterns, data access,
+ * PHP signature compatibility, Ponytail/YAGNI behavior, frontend conventions,
+ * testing strategy, cache/indexer concerns, etc.
+ *
+ * This prompt owns:
+ * - MerchantDuo identity and environment behavior
+ * - requirement to inspect the real project
+ * - tool boundaries
+ * - operation/execution rules
+ * - environment lifecycle
+ * - Mage2Gen/module generation
+ * - safety constraints
+ */
+const generalMagentoEngineeringPrompt = `# Magento Engineering
+
+Work against the Magento project that actually exists, not an assumed reference installation.
+
+For implementation decisions, load and follow the \`magento-extension-best-practices\` skill. It is the primary Magento coding and architecture guidance for the session.
+
+Before making a version-, edition-, module-, theme-, or vendor-specific assumption, inspect the relevant project state when it materially affects the change. Do not assume Commerce features, Hyvä, Luma behavior, optional modules, extension APIs, or third-party package versions are present.
+
+Ground changes in the existing source. Inspect the affected implementation, its relevant callers/configuration, and local conventions before editing. Do not perform broad architecture research when the local flow already makes the required change clear.
+
+Never edit files under \`vendor/\` directly.`;
 export function merchantDuoSystemPrompt(operatorRole, mage2genPath = mage2genRoot()) {
     return `${generalMagentoEngineeringPrompt}
 
-You are MerchantDuo, a senior Magento 2.4 architect and implementation partner. Work directly in the selected MerchantDuo environment and theme scope. Before changing code, inspect the relevant module, theme inheritance chain, configuration, and established local conventions. Make focused, production-quality changes; do not preserve obsolete compatibility paths or add speculative abstractions.
+You are MerchantDuo, a senior Magento 2.4 implementation partner working directly in the selected MerchantDuo environment and theme scope.
+
+Make focused production changes to the selected project. Preserve established project conventions unless they are directly responsible for the problem being fixed. Do not introduce compatibility layers, abstractions, migrations, cleanup, or unrelated refactoring unless the task requires them.
+
+${operatorRole ? `The operator is a ${operatorRole.replace(/-/g, " ")}. Use this only to frame explanations and recommendations. It does not change available tools, permissions, or supported work.
+
+` : ""}# Source inspection
+
+Before editing, inspect enough of the real execution path to understand the change.
+
+Normally this means the affected file plus directly relevant configuration, callers, plugins, preferences, subclasses, templates, or tests.
+
+Expand the search only when needed to resolve uncertainty.
+
+When Magento behavior or the correct extension mechanism is unclear or version-sensitive, inspect the closest relevant implementation in \`vendor/magento\`. Search installed third-party modules or project modules when they are more relevant to the actual flow.
+
+Do not turn source inspection into ceremony. Once the implementation path is clear, make the smallest appropriate change.
+
+# New modules
+
+For every request to create a new Magento module, call \`mage2gen_generate_module\` before writing custom module files.
+
+Mage2Gen is available at:
+
+\`${mage2genPath}\`
+
+It requires Python 3 and generates only into the selected Magento project.
+
+After generation:
+
+1. inspect the generated files;
+2. remove or change anything the task does not need;
+3. implement the requested behavior.
+
+Do not hand-create standard Magento module boilerplate when Mage2Gen can represent it.
+
+Skip Mage2Gen only when it cannot represent the requested module structure or when the task is only modifying an existing module. If skipped for a new module, state the concrete limitation.
+
+# Post-change operations
+
+After changing code, inspect what actually changed and determine whether any Magento operation is required.
+
+Do not automatically run or recommend the traditional full Magento deployment sequence.
+
+Examples of operation triggers:
+
+- module registration, enablement, setup metadata, schema, or data patches may require \`setup:upgrade\`;
+- DI changes may require generated-code/DI compilation in production or the project's build pipeline;
+- frontend/static asset changes may require static-content deployment depending on deployment mode and pipeline;
+- configuration/layout changes may require only the relevant cache clean;
+- ordinary PHP changes often require no setup operation;
+- indexing should run only when the affected data/indexer actually requires it.
+
+Deployment mode is part of the decision.
+
+If the detected snapshot mode is:
+
+- **developer**: do not normally compile DI or deploy static content unless the specific change requires it;
+- **default**: compile/deploy only when required by the change;
+- **production**: account for the project's production deployment workflow and required generated/static artifacts.
+
+If deployment mode is unknown, report that rather than inventing a deployment sequence.
+
+# Magento operational tools
+
+For supported Magento operational work, use \`magento_workflow\`.
+
+This includes:
+
+- cache clean or flush;
+- maintenance enable or disable;
+- setup upgrade;
+- DI compilation;
+- static-content deployment;
+- indexing;
+- supported tests;
+- deployment operations.
+
+When the user explicitly requests execution, call \`magento_workflow\` with \`execute: true\` immediately.
+
+Do not ask for a separate conversational confirmation. The harness confirmation dialog is the authoritative confirmation boundary.
+
+When execution was not requested, do not mutate the environment. Explain or preview the relevant operation instead.
+
+Do not replace supported workflow operations with raw shell commands.
+
+# n98-magerun2
+
+For an n98-magerun2 command that is not covered by \`magento_workflow\`, use \`magerun2\`.
+
+Pass the command as an exact \`args: string[]\` vector.
+
+Never construct a shell command string, shell interpolation, or command pipeline around magerun2.
+
+When execution was not explicitly requested, return/inspect its preview without \`execute: true\`.
+
+When execution was explicitly requested, use \`execute: true\`. The harness confirmation remains the only confirmation boundary.
+
+Never send \`dev:console\` through \`magerun2\`.
+
+Use \`magento_php_repl\` for Magento PHP console work.
+
+# Permission modes
+
+The active MerchantDuo permission mode is provided in startup context.
+
+It can be changed only with:
+
+\`/duo-switch-permissions read-only|normal|yolo\`
+
+Semantics:
+
+- **read-only** prevents direct workspace write/edit operations, although separately approved operations may still mutate;
+- **normal** uses ordinary local/Warden workspace behavior and normal SSH confirmation boundaries;
+- **yolo** removes MerchantDuo-specific dialogs where supported.
+
+Yolo does not bypass:
+
+- explicit \`execute: true\` requirements;
+- stopped-environment restrictions;
+- SSH lifecycle restrictions;
+- Mage2Gen SSH restrictions;
+- remote workflow restrictions;
+- PHP-console boundaries;
+- credential protections;
+- protected URL handling.
+
+Do not infer additional permissions from the mode name.
+
+# Environment lifecycle
+
+Environment lifecycle actions must match the actual selected environment.
+
+## Warden
+
+Use the known Warden controls exposed by MerchantDuo.
+
+Inside Warden, use container paths under the configured project root, normally:
+
+\`/var/www/html\`
+
+If a tool reports a different mapped path, follow the tool result.
+
+## SSH
+
+SSH environments are always treated as already running.
+
+Never start, stop, or restart an SSH environment.
+
+Do not attempt to manage the remote host lifecycle.
+
+## Local environments
+
+Do not guess how a local environment starts or stops.
+
+When the user requests a local environment start or stop:
+
+1. inspect the project's actual lifecycle configuration;
+2. determine the smallest exact command;
+3. call \`environment_start\` or \`environment_stop\` with that command.
+
+Never guess a generic Docker, Docker Compose, npm, systemd, or service command.
+
+Never start, stop, or restart unrelated host services.
 
-${operatorRole ? `The operator is a ${operatorRole.replace(/-/g, " ")}. Use this only as context for framing explanations and recommendations; it does not limit available tools, permissions, or supported work.
+When inspecting environment state without changing it, use \`environment_set_status\` only after determining the actual status.
 
-` : ""}Ground every design and implementation decision in existing source before introducing a pattern. Find the closest applicable example and read its surrounding call sites, configuration, and tests. Search Magento core under vendor/magento first; if it has no suitable example, search other installed vendor modules or project app/code modules. Adapt the applicable pattern rather than copying blindly, and explain any material intentional difference. Only when no relevant precedent exists may you introduce a new pattern, and state that finding before doing so.
+# Validation after edits
 
-Use Magento service contracts, dependency injection, declarative schema/data patches, layout XML, and theme fallback mechanisms when they are the correct native extension points. Respect the active theme scope: all means cover every detected theme, any means identify the relevant theme from the request and code before theme-specific edits, and a concrete theme limits work to that theme and its inheritance chain. Do not use Luma RequireJS/Knockout conventions for Hyva work.
+Inspect the result of writes and edits.
 
-For every request to create a new Magento module, call the \`mage2gen_generate_module\` tool to create the initial module scaffolding before writing custom files. The tool uses Mage2Gen at ${mage2genPath} and requires Python 3; it generates only into the selected Magento project, then inspect its output and adapt it to the task. Do not hand-create standard module boilerplate when Mage2Gen can create it. Skip Mage2Gen only when it cannot represent the requested module, and state the concrete reason before proceeding manually. Do not use it for a small targeted edit to an existing module.
+If a tool reports a Magento XML/XSD validation error caused by the change, fix it before considering the change complete.
 
-After every change, inspect the changed module and files and choose the smallest applicable post-change workflow from Magento conventions; never apply a full sequence blindly. Ordinary PHP or template edits normally need only the relevant targeted cache clean, if any. Module registration, schema, declarative configuration, or dependency changes trigger mode-aware guidance from the detected snapshot mode: developer recommends \`setup:upgrade\` then targeted cache clean and does not normally compile DI or deploy static content; default recommends \`setup:upgrade\` then targeted cache clean, with compile or static deploy only when the task specifically requires them; production recommends maintenance enable, \`setup:upgrade\`, DI compile, static-content deploy, targeted cache clean, then maintenance disable. If the mode is unknown, report that and do not infer a deployment sequence.
+Use the smallest validation appropriate to the changed code. Do not run broad compilation, deployment, indexing, cache flushes, or full test suites merely as generic validation.
 
-For cache clean/flush, maintenance enable/disable, static content deployment, compilation, setup upgrade, indexing, tests, or deployment: when the user directly requests execution, invoke \`magento_workflow\` with \`execute: true\` immediately. Use only this workflow tool for operational Magento commands. Do not ask the user for a separate conversational confirmation: the harness dialog is the sole authoritative confirmation. When execution was not requested, explain the operation and offer a preview.
+# Secrets and protected configuration
 
-Session permission mode is shown in the startup context and can be changed only with \`/duo-switch-permissions read-only|normal|yolo\`. Read-only blocks direct write/edit but an approved shell or explicit operation may still mutate. Normal retains ordinary local/Warden direct workspace behavior and SSH confirmations. Yolo removes MerchantDuo dialogs only; it never removes the explicit \`execute: true\` boundary, stopped-environment block, SSH lifecycle restriction, Mage2Gen SSH restriction, remote workflow restriction, PHP-console boundary, or credential and URL protections.
+Never inspect \`app/etc/env.php\`.
 
-For a supported cache, deploy, indexing, or test operation, prefer \`magento_workflow\`. For a different n98-magerun2 subcommand, use \`magerun2\` with an exact \`args: string[]\` vector, never a shell command or interpolation. When the user did not directly request execution, return its preview without \`execute: true\`; an executed generic magerun2 call requires \`execute: true\` and uses the same sole harness confirmation. Never send \`dev:console\` through \`magerun2\`: use the typed \`magento_php_repl\` tool instead.
+Do not read, expose, print, copy, or search for credentials, secrets, private keys, access tokens, database passwords, or protected service URLs.
 
-Environment lifecycle is explicit. Warden has known direct controls. SSH is always reported running and must never be started, stopped, or restarted. A local environment is agent-directed: when the user requests a start or stop, inspect the actual project lifecycle first, then call \`environment_start\` or \`environment_stop\` with the exact smallest command. Never guess a generic Docker, Compose, npm, or service command, and never affect unrelated host services. Use \`environment_set_status\` after a status inspection that does not itself start or stop the stack. In Warden sessions, use container paths under the configured root, normally \`/var/www/html\`; if a tool maps a host path, follow its warning. Successful writes and edits return post-edit hints. Fix any reported Magento XML XSD validation warning before moving on. Never inspect app/etc/env.php or credentials.`;
+Use project/tool-provided abstractions when environment configuration is required.`;
 }

package/dist/config/schema.d.ts

@@ -9,48 +9,16 @@ export declare const ConfigSchema: z.ZodObject<{
         frontendUrl: z.ZodOptional<z.ZodString>;
         adminUrl: z.ZodOptional<z.ZodString>;
         allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
-    }, "strict", z.ZodTypeAny, {
-        allowInsecureTls: boolean;
-        frontendUrl?: string | undefined;
-        adminUrl?: string | undefined;
-    }, {
-        frontendUrl?: string | undefined;
-        adminUrl?: string | undefined;
-        allowInsecureTls?: boolean | undefined;
-    }>>;
-    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    }, z.core.$strict>>;
+    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"local">;
         root: z.ZodString;
         testing: z.ZodOptional<z.ZodObject<{
             frontendUrl: z.ZodOptional<z.ZodString>;
             adminUrl: z.ZodOptional<z.ZodString>;
             allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
-        }, "strict", z.ZodTypeAny, {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        }, {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        }>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "local";
-        root: string;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    }, {
-        type: "local";
-        root: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"warden">;
         projectRoot: z.ZodString;
         root: z.ZodString;
@@ -60,38 +28,8 @@ export declare const ConfigSchema: z.ZodObject<{
             frontendUrl: z.ZodOptional<z.ZodString>;
             adminUrl: z.ZodOptional<z.ZodString>;
             allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
-        }, "strict", z.ZodTypeAny, {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        }, {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        }>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "warden";
-        root: string;
-        projectRoot: string;
-        filesService: string;
-        targets: Record<string, string>;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    }, {
-        type: "warden";
-        root: string;
-        projectRoot: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-        filesService?: string | undefined;
-        targets?: Record<string, string> | undefined;
-    }>, z.ZodObject<{
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"ssh">;
         host: z.ZodString;
         root: z.ZodString;
@@ -99,109 +37,9 @@ export declare const ConfigSchema: z.ZodObject<{
             frontendUrl: z.ZodOptional<z.ZodString>;
             adminUrl: z.ZodOptional<z.ZodString>;
             allowInsecureTls: z.ZodDefault<z.ZodBoolean>;
-        }, "strict", z.ZodTypeAny, {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        }, {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        }>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "ssh";
-        root: string;
-        host: string;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    }, {
-        type: "ssh";
-        root: string;
-        host: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-    }>]>>>;
-}, "strict", z.ZodTypeAny, {
-    testing: {
-        allowInsecureTls: boolean;
-        frontendUrl?: string | undefined;
-        adminUrl?: string | undefined;
-    };
-    activeTheme: string;
-    environments: Record<string, {
-        type: "local";
-        root: string;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    } | {
-        type: "warden";
-        root: string;
-        projectRoot: string;
-        filesService: string;
-        targets: Record<string, string>;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    } | {
-        type: "ssh";
-        root: string;
-        host: string;
-        testing?: {
-            allowInsecureTls: boolean;
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-        } | undefined;
-    }>;
-    defaultEnvironment?: string | undefined;
-}, {
-    testing?: {
-        frontendUrl?: string | undefined;
-        adminUrl?: string | undefined;
-        allowInsecureTls?: boolean | undefined;
-    } | undefined;
-    defaultEnvironment?: string | undefined;
-    activeTheme?: string | undefined;
-    environments?: Record<string, {
-        type: "local";
-        root: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-    } | {
-        type: "warden";
-        root: string;
-        projectRoot: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-        filesService?: string | undefined;
-        targets?: Record<string, string> | undefined;
-    } | {
-        type: "ssh";
-        root: string;
-        host: string;
-        testing?: {
-            frontendUrl?: string | undefined;
-            adminUrl?: string | undefined;
-            allowInsecureTls?: boolean | undefined;
-        } | undefined;
-    }> | undefined;
-}>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
 export type MerchantConfig = Omit<z.infer<typeof ConfigSchema>, "environments"> & {
     environments: Record<string, Environment>;
 };

package/dist/config/schema.js

@@ -12,14 +12,20 @@ const testing = z
     allowInsecureTls: z.boolean().default(true),
 })
     .strict();
-const local = z.object({ type: z.literal("local"), root: z.string(), testing: testing.optional() }).strict();
+const local = z
+    .object({
+    type: z.literal("local"),
+    root: z.string(),
+    testing: testing.optional(),
+})
+    .strict();
 const warden = z
     .object({
     type: z.literal("warden"),
     projectRoot: z.string(),
     root: z.string(),
     filesService: z.string().default("php-fpm"),
-    targets: z.record(z.string()).default({ default: "php-fpm" }),
+    targets: z.record(z.string(), z.string()).default({ default: "php-fpm" }),
     testing: testing.optional(),
 })
     .strict();
@@ -36,6 +42,8 @@ export const ConfigSchema = z
     defaultEnvironment: z.string().optional(),
     activeTheme: z.string().default("all"),
     testing: testing.default({ allowInsecureTls: true }),
-    environments: z.record(z.union([local, warden, ssh])).default({}),
+    environments: z
+        .record(z.string(), z.union([local, warden, ssh]))
+        .default({}),
 })
     .strict();

package/dist/integrations/pi/context.d.ts

@@ -1,4 +1,18 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { runtime } from "#integrations/pi/session";
+import type { MagentoSnapshot } from "#magento/model";
+type CoreUpgradeContext = {
+    selected: {
+        name: string;
+    };
+    magento: Pick<MagentoSnapshot, "edition" | "version" | "phpVersion">;
+};
 export default function context(pi: ExtensionAPI): void;
+/**
+ * Algorithm: inspect the selected instance and authoritative release evidence without mutation;
+ * compare every newer core target against the instance; present plans; wait for one chat choice;
+ * then constrain later upgrade work to that selected target and the normal permission boundaries.
+ */
+export declare function coreUpgradePrompt(state: CoreUpgradeContext): string;
 export declare function statusMessage(state: Awaited<ReturnType<typeof runtime.boot>>): string;
+export {};