@merchantduo/code 0.3.0-beta.0 → 0.3.0-beta.2

package/README.md

@@ -48,7 +48,7 @@ environments:
     root: /var/www/html
 ```
 
-Local uses the checkout directly. Warden routes project and Magento execution through its configured service. Local and Warden sessions start in `normal`; SSH starts in `read-only`. Use `/duo-switch-permissions <read-only|normal|yolo>` to change only the current session, or `merchantduo --yolo` to start in `yolo`. Configure SSH user, port, and key through an OpenSSH host alias:
+Local uses the checkout directly. Warden routes project and Magento execution through its configured service. Local and Warden sessions start in `normal`; SSH starts in `read-only`. Run `/duo-switch-permissions` to choose a mode interactively, or provide `<read-only|normal|yolo>` directly to change only the current session; `merchantduo --yolo` starts in `yolo`. Configure SSH user, port, and key through an OpenSSH host alias:
 
 ```sshconfig
 Host shop-stage
@@ -58,7 +58,7 @@ Host shop-stage
   IdentityFile ~/.ssh/id_ed25519
 ```
 
-Use that alias as `host: shop-stage`. `merchantduo init` offers local first and Warden when its project `.env` is detected; it prints an SSH example instead of writing an unused remote environment.
+Use that alias as `host: shop-stage`. Every `merchantduo init` asks “Choose what fits you most” and saves the selected role under the current user's `~/.merchantduo/operator-profile.yaml`: store admin, backend developer, frontend developer, or full-stack developer. It then offers local first and Warden when its project `.env` is detected; it prints an SSH example instead of writing an unused remote environment. The role is optional to load and gives the agent context for explanations and recommendations only; it does not change tools or permissions. Project configuration contains no user identity and is safe to share in a repository.
 
 ## Provisioning
 
@@ -66,10 +66,10 @@ Provision a local or Warden developer store from an empty directory or an existi
 
 ```sh
 merchantduo provision
-merchantduo provision --env warden --source https://git.example.test/store.git --database ./backup.sql.gz --yes
+merchantduo provision --env warden
 ```
 
-The interactive flow discovers available source, database, and service evidence, shows an ordered plan, and asks once before mutations. `--yes` requires all decisions to be explicit or unambiguous.
+This opens plain Pi in the host shell, even when the project defaults to Warden. It shares MerchantDuo’s configured Pi authentication, models, and user settings, but does not load the MerchantDuo package or initialize Magento context. The agent first inspects the real project, Warden/local runtime, Composer platform requirements, Magento state, and source/database evidence. It does not run a fixed Composer, database, Magento, lifecycle, or web-server sequence. Before a material mutation, it explains the evidence and intended effect and waits for confirmation. In particular, lock-file PHP incompatibility is diagnosed rather than bypassed with `composer update`. Unlike normal MerchantDuo sessions, provisioning may inspect and configure Magento deployment configuration such as `app/etc/env.php` and `app/etc/config.php` when needed; it must not reveal credentials or tokens in chat, commands, logs, or generated files.
 
 ## Install and start
 
@@ -86,7 +86,7 @@ Review the generated `.merchantduo.yaml` before the first session. MerchantDuo r
 
 ## Safety and optional services
 
-MerchantDuo does not load `app/etc/env.php`, credentials, or tokens into agent context. It does not run background tests, cache commands, deployment actions, browser operations, or PHP code. Explicit operations use the confirmation rules described in the [tool reference](docs/tools.md).
+Normal MerchantDuo sessions do not load `app/etc/env.php`, credentials, or tokens into agent context. The separate provisioning session may configure Magento deployment files, but never reveals their secret values. MerchantDuo does not run background tests, cache commands, deployment actions, browser operations, or PHP code. Explicit operations use the confirmation rules described in the [tool reference](docs/tools.md).
 
 Set `MERCHANTDUO_MCP_TOKEN` to enable the built-in read-only knowledge tool. Set `MERCHANTDUO_LLM_TOKEN` to enable the built-in MerchantDuo provider. Neither endpoint is project configuration.
 

package/dist/app/system-prompt.d.ts

@@ -1,2 +1,3 @@
+import type { OperatorRole } from "#config/index";
 export declare function mage2genRoot(): string;
-export declare function merchantDuoSystemPrompt(mage2genPath?: string): string;
+export declare function merchantDuoSystemPrompt(operatorRole: OperatorRole | undefined, mage2genPath?: string): string;

package/dist/app/system-prompt.js

@@ -2,10 +2,16 @@ import { packagePath } from "#shared/package-paths";
 export function mage2genRoot() {
     return packagePath("vendor/mage2gen");
 }
-export function merchantDuoSystemPrompt(mage2genPath = mage2genRoot()) {
-    return `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.
+// 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.";
+export function merchantDuoSystemPrompt(operatorRole, mage2genPath = mage2genRoot()) {
+    return `${generalMagentoEngineeringPrompt}
 
-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.
+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.
+
+${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.
+
+` : ""}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.
 
 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.
 
@@ -19,5 +25,5 @@ Session permission mode is shown in the startup context and can be changed only
 
 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.
 
-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. Never inspect app/etc/env.php or credentials.`;
+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.`;
 }

package/dist/cli/arguments.d.ts

@@ -2,9 +2,6 @@ export type CliArguments = {
     command?: "init" | "doctor" | "provision";
     environment?: string;
     configPath?: string;
-    source?: string;
-    database?: string;
-    yes: boolean;
     yolo: boolean;
     piArguments: string[];
 };

package/dist/cli/arguments.js

@@ -4,29 +4,19 @@ export function parseArguments(args) {
     const piArguments = [];
     let environment;
     let configPath;
-    let source;
-    let database;
-    let yes = false;
     let yolo = false;
     for (let index = 0; index < input.length; index += 1) {
         const value = input[index];
-        if (value === "--env" || value === "--config" || value === "--source" || value === "--database") {
+        if (value === "--env" || value === "--config") {
             const argument = input[index + 1];
             if (!argument)
                 throw new Error(`${value} requires a value`);
             if (value === "--env")
                 environment = argument;
-            else if (value === "--config")
-                configPath = argument;
-            else if (value === "--source")
-                source = argument;
             else
-                database = argument;
+                configPath = argument;
             index += 1;
         }
-        else if (value === "--yes") {
-            yes = true;
-        }
         else if (value === "--yolo") {
             yolo = true;
         }
@@ -36,5 +26,7 @@ export function parseArguments(args) {
     }
     if (command && yolo)
         throw new Error("--yolo is only available when starting an agent session");
-    return { command, environment, configPath, source, database, yes, yolo, piArguments };
+    if (command === "provision" && (configPath || piArguments.length))
+        throw new Error("merchantduo provision supports only --env local or --env warden");
+    return { command, environment, configPath, yolo, piArguments };
 }

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

@@ -1,3 +1,10 @@
 import type { PermissionMode } from "#app/permission-mode";
+type ProvisionEnvironment = "local" | "warden";
+export declare function provisioningPrompt(environment: ProvisionEnvironment): string;
 export declare function launchAgent(piArguments: string[], selectedEnvironment: string, configPath?: string, permissionMode?: PermissionMode): Promise<number>;
+/** Launch a non-persistent provisioning session with exactly the requested environment. */
+export declare function launchProvisioningAgent(environment: ProvisionEnvironment): Promise<number>;
+/** Preserve Pi connection preferences but never load environment-bound MerchantDuo packages. */
+export declare function provisioningSettings(settings: Record<string, unknown>): Record<string, unknown>;
 export declare function agentEnvironment(base: NodeJS.ProcessEnv, piDirectory: string, selectedEnvironment: string, configPath: string | undefined, version: string, permissionMode?: PermissionMode): NodeJS.ProcessEnv;
+export {};

package/dist/cli/commands/agent.js

@@ -1,9 +1,14 @@
 import { spawn } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, symlink, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { merchantHome } from "#config/paths";
 import { packagePath } from "#shared/package-paths";
+export function provisioningPrompt(environment) {
+    return `Start an agentic Magento provisioning investigation for the selected ${environment} environment. You are running plain Pi in the host shell, not inside a MerchantDuo selected-environment shell. Use host tools to inspect Warden/local project evidence and explicitly route any environment-specific command only after identifying its correct runtime. Do not follow a predetermined command sequence. First inspect the project, its documentation and scripts, the selected environment configuration and status, Composer metadata and lock-file platform requirements, actual runtime versions, Magento state, and available database/source evidence. Search for the smallest project-specific path to a runnable store.
+
+Before any material mutation, explain the evidence, the precise intended effect, risks, and the smallest proposed action, then wait for the user's confirmation. Do not run Composer, import a database, run Magento setup commands, start or stop services, create a virtual host, or modify dependencies merely because they are customary. Never use composer update to bypass a lock-file or PHP-platform mismatch. If compatibility fails, identify the exact incompatible packages and recommend the required environment or dependency decision instead. When project evidence requires it, inspect and configure Magento deployment configuration including app/etc/env.php, app/etc/config.php, and related files. Treat their values as sensitive: never disclose, echo, log, or copy credentials or tokens into chat, commands, or persisted artifacts.`;
+}
 export async function launchAgent(piArguments, selectedEnvironment, configPath, permissionMode) {
     const state = merchantHome();
     await mkdir(state, { recursive: true, mode: 0o700 });
@@ -25,6 +30,46 @@ export async function launchAgent(piArguments, selectedEnvironment, configPath,
         child.on("exit", (code) => resolveExit(code ?? 1));
     });
 }
+/** Launch a non-persistent provisioning session with exactly the requested environment. */
+export async function launchProvisioningAgent(environment) {
+    const state = merchantHome();
+    const merchantPi = resolve(state, "pi");
+    const provisionPi = resolve(state, "provision", "pi");
+    await mkdir(provisionPi, { recursive: true, mode: 0o700 });
+    await linkConnectionFile(merchantPi, provisionPi, "auth.json");
+    await linkConnectionFile(merchantPi, provisionPi, "models.json");
+    await linkConnectionFile(merchantPi, provisionPi, "models-store.json");
+    await writeFile(resolve(provisionPi, "settings.json"), `${JSON.stringify(provisioningSettings(JSON.parse(await readFile(resolve(merchantPi, "settings.json"), "utf8"))), null, 2)}\n`, { mode: 0o600 });
+    return launchPlainPi(["--no-extensions", provisioningPrompt(environment)], provisionPi);
+}
+/** Preserve Pi connection preferences but never load environment-bound MerchantDuo packages. */
+export function provisioningSettings(settings) {
+    const { packages: _packages, ...connectionSettings } = settings;
+    return connectionSettings;
+}
+async function linkConnectionFile(sourceDirectory, targetDirectory, name) {
+    const source = resolve(sourceDirectory, name);
+    const target = resolve(targetDirectory, name);
+    try {
+        await symlink(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+async function launchPlainPi(piArguments, piDirectory) {
+    const piEntry = fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const piCli = resolve(dirname(piEntry), "cli.js");
+    return new Promise((resolveExit, reject) => {
+        const child = spawn(process.execPath, [piCli, ...piArguments], {
+            stdio: "inherit",
+            env: { ...process.env, PI_CODING_AGENT_DIR: piDirectory },
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => resolveExit(code ?? 1));
+    });
+}
 export function agentEnvironment(base, piDirectory, selectedEnvironment, configPath, version, permissionMode) {
     return { ...base, PI_CODING_AGENT_DIR: piDirectory, MERCHANTDUO_SELECTED_ENV: selectedEnvironment, MERCHANTDUO_CONFIG_PATH: configPath ?? "", MERCHANTDUO_PACKAGE_VERSION: version, ...(permissionMode ? { MERCHANTDUO_PERMISSION_MODE: permissionMode } : {}) };
 }

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

@@ -1,9 +1,22 @@
+import { type OperatorRole } from "#config/index";
+export declare const operatorRoleChoices: ReadonlyArray<{
+    value: OperatorRole;
+    label: string;
+}>;
 export interface InitInterview {
     confirm(question: string): Promise<boolean>;
+    choose(question: string, choices: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>): Promise<string>;
 }
 export declare class TerminalInitInterview implements InitInterview {
     confirm(question: string): Promise<boolean>;
+    choose(question: string, choices: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>): Promise<string>;
 }
 export declare function hasWardenEnvironment(cwd: string): Promise<boolean>;
-export declare function initProject(cwd: string, interview?: InitInterview, output?: (message: string) => void): Promise<void>;
+export declare function initProject(cwd: string, interview?: InitInterview, output?: (message: string) => void, env?: NodeJS.ProcessEnv): Promise<void>;
 export declare const remoteEnvironmentExample = "\nTo add a remote environment later, add this under environments:\n\n  stage:\n    type: ssh\n    host: shop-stage\n    root: /var/www/html\n\nSSH sessions start read-only. Use /duo-switch-permissions normal or yolo only for the current session. Configure its user, port, and identity through ~/.ssh/config:\n\n  Host shop-stage\n    HostName stage.example.com\n    User deploy\n    Port 22\n    IdentityFile ~/.ssh/id_ed25519";

package/dist/cli/commands/init.js

@@ -3,6 +3,13 @@ import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { stringify } from "yaml";
+import { operatorRoles, saveOperatorRole } from "#config/index";
+export const operatorRoleChoices = [
+    { value: "store-admin", label: "I am STORE ADMIN" },
+    { value: "backend-developer", label: "I am BACKEND developer" },
+    { value: "frontend-developer", label: "I am FRONTEND developer" },
+    { value: "full-stack-developer", label: "I am FULL STACK developer" },
+];
 export class TerminalInitInterview {
     async confirm(question) {
         const terminal = createInterface({ input: stdin, output: stdout });
@@ -14,6 +21,20 @@ export class TerminalInitInterview {
             terminal.close();
         }
     }
+    async choose(question, choices) {
+        const terminal = createInterface({ input: stdin, output: stdout });
+        try {
+            stdout.write(`${question}\n${choices.map((choice, index) => `  ${index + 1}. ${choice.label}`).join("\n")}\n`);
+            const answer = (await terminal.question(`Choose [1-${choices.length}] `)).trim();
+            const selected = choices[Number(answer) - 1];
+            if (!selected)
+                throw new Error(`Choose a number from 1 to ${choices.length}`);
+            return selected.value;
+        }
+        finally {
+            terminal.close();
+        }
+    }
 }
 export async function hasWardenEnvironment(cwd) {
     try {
@@ -26,16 +47,23 @@ export async function hasWardenEnvironment(cwd) {
         throw error;
     }
 }
-export async function initProject(cwd, interview = new TerminalInitInterview(), output = console.log) {
+export async function initProject(cwd, interview = new TerminalInitInterview(), output = console.log, env = process.env) {
     const path = resolve(cwd, ".merchantduo.yaml");
+    let exists = false;
     try {
         await access(path);
-        throw new Error(`${path} already exists`);
+        exists = true;
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
+    // Always refresh the caller's optional identity context, even for an existing project.
+    await saveOperatorRole(await chooseOperatorRole(interview), env);
+    if (exists) {
+        output("Updated the current user's operator role");
+        return;
+    }
     const environments = {};
     if (await interview.confirm("Add the local Magento checkout environment?")) {
         environments.local = { type: "local", root: "." };
@@ -65,4 +93,10 @@ export async function initProject(cwd, interview = new TerminalInitInterview(),
     output(`Created ${path}`);
     output(remoteEnvironmentExample);
 }
+async function chooseOperatorRole(interview) {
+    const selected = await interview.choose("Choose what fits you most", operatorRoleChoices);
+    if (!operatorRoles.includes(selected))
+        throw new Error("Choose a listed operator role");
+    return selected;
+}
 export const remoteEnvironmentExample = `\nTo add a remote environment later, add this under environments:\n\n  stage:\n    type: ssh\n    host: shop-stage\n    root: /var/www/html\n\nSSH sessions start read-only. Use /duo-switch-permissions normal or yolo only for the current session. Configure its user, port, and identity through ~/.ssh/config:\n\n  Host shop-stage\n    HostName stage.example.com\n    User deploy\n    Port 22\n    IdentityFile ~/.ssh/id_ed25519`;

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

@@ -1,6 +1,11 @@
-export declare function provision(cwd: string, options: {
+export type ProvisionEnvironment = "local" | "warden";
+export interface ProvisionEnvironmentInterview {
+    choose(): Promise<ProvisionEnvironment>;
+}
+export declare class TerminalProvisionEnvironmentInterview implements ProvisionEnvironmentInterview {
+    choose(): Promise<ProvisionEnvironment>;
+}
+/** Starts a Pi investigation session; provisioning actions remain agent- and user-directed. */
+export declare function provision(options: {
     environment?: string;
-    source?: string;
-    database?: string;
-    yes: boolean;
-}): Promise<void>;
+}, interview?: ProvisionEnvironmentInterview, launch?: (environment: ProvisionEnvironment) => Promise<number>): Promise<void>;

package/dist/cli/commands/provision.js

@@ -1,35 +1,24 @@
-import { EnvironmentBackend } from "#environments/backend";
-import { ProvisionAdvisor } from "#provision/advisor";
-import { discoverProvision } from "#provision/discovery";
-import { TerminalProvisionInterview } from "#provision/interview";
-import { createProvisionPlan } from "#provision/planner";
-import { BackendProvisionRunner, DefaultProvisionExecutor } from "#provision/runner";
-function source(value) { if (!value)
-    return undefined; if (value === "existing")
-    return value; return /^https?:\/\//.test(value) ? (value.endsWith(".git") ? `git:${value}` : `https:${value}`) : `archive:${value}`; }
-function database(value) { if (!value)
-    return undefined; if (value === "current")
-    return value; return /^https?:\/\//.test(value) ? `https:${value}` : `dump:${value}`; }
-export async function provision(cwd, options) {
-    if (options.environment && options.environment !== "local" && options.environment !== "warden")
-        throw new Error("--env must be local or warden");
-    const snapshot = await discoverProvision(cwd);
-    const initial = { environment: options.environment, source: source(options.source), database: database(options.database) };
-    const interview = new TerminalProvisionInterview();
-    const input = options.yes ? initial : await interview.resolve(snapshot, initial);
-    const advised = await new ProvisionAdvisor().advise(snapshot, createProvisionPlan(snapshot, input));
-    if (advised.diagnostic)
-        console.error(`merchantduo: ${advised.diagnostic}`);
-    if (advised.plan.blocked.length)
-        throw new Error(`Provision requires input:\n- ${advised.plan.blocked.join("\n- ")}`);
-    if (!options.yes && !(await interview.approve(advised.plan))) {
-        console.log("Provision cancelled.");
-        return;
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { launchProvisioningAgent } from "#cli/commands/agent";
+export class TerminalProvisionEnvironmentInterview {
+    async choose() {
+        const terminal = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = (await terminal.question("Environment (warden/local): ")).trim();
+            if (answer === "warden" || answer === "local")
+                return answer;
+            throw new Error("Choose environment warden or local");
+        }
+        finally {
+            terminal.close();
+        }
     }
-    const hostBackend = new EnvironmentBackend({ type: "local", root: "." }, cwd);
-    const magentoBackend = new EnvironmentBackend(input.environment === "warden" ? { type: "warden", projectRoot: ".", root: "/var/www/html", filesService: "php-fpm", targets: { default: "php-fpm" } } : { type: "local", root: "." }, cwd);
-    const executor = new DefaultProvisionExecutor(new BackendProvisionRunner(hostBackend), cwd, input.environment, new BackendProvisionRunner(magentoBackend));
-    for (const action of advised.plan.actions)
-        await executor.execute(action, input);
-    console.log("Provision completed.");
+}
+/** Starts a Pi investigation session; provisioning actions remain agent- and user-directed. */
+export async function provision(options, interview = new TerminalProvisionEnvironmentInterview(), launch = launchProvisioningAgent) {
+    const environment = options.environment ?? await interview.choose();
+    if (environment !== "local" && environment !== "warden")
+        throw new Error("--env must be local or warden");
+    process.exitCode = await launch(environment);
 }

package/dist/cli/main.js

@@ -12,7 +12,7 @@ async function main() {
     if (args.command === "init")
         return initProject(cwd);
     if (args.command === "provision")
-        return provision(cwd, args);
+        return provision(args);
     const loaded = await loadConfig(cwd, { config: args.configPath });
     const selected = selectEnvironment(loaded.config, cwd, args.environment);
     if (loaded.configPath && !(await isTrusted(loaded.configPath))) {

package/dist/config/index.d.ts

@@ -2,8 +2,9 @@ import type { Environment } from "#environments/model";
 import type { MerchantConfig } from "#config/schema";
 export { loadConfig, interpolate, type LoadedConfig } from "#config/loader";
 export { merchantHome } from "#config/paths";
+export { loadOperatorRole, saveOperatorRole } from "#config/operator-profile";
 export { setProjectTheme } from "#config/project-store";
-export { ConfigSchema, type MerchantConfig, } from "#config/schema";
+export { ConfigSchema, type MerchantConfig, operatorRoles, type OperatorRole, } from "#config/schema";
 export { configDigest, isTrusted, trustProject } from "#config/trust-store";
 export declare function selectEnvironment(config: MerchantConfig, cwd: string, requested?: string, env?: NodeJS.ProcessEnv): {
     name: string;

package/dist/config/index.js

@@ -1,7 +1,8 @@
 export { loadConfig, interpolate } from "#config/loader";
 export { merchantHome } from "#config/paths";
+export { loadOperatorRole, saveOperatorRole } from "#config/operator-profile";
 export { setProjectTheme } from "#config/project-store";
-export { ConfigSchema, } from "#config/schema";
+export { ConfigSchema, operatorRoles, } from "#config/schema";
 export { configDigest, isTrusted, trustProject } from "#config/trust-store";
 export function selectEnvironment(config, cwd, requested, env = process.env) {
     const name = requested ?? env.MERCHANTDUO_ENV ?? config.defaultEnvironment;

package/dist/config/loader.js

@@ -49,11 +49,7 @@ export async function loadConfig(cwd, options = {}) {
         },
     };
     if (!globalConfig && !projectConfig)
-        return {
-            config: ConfigSchema.parse({
-                environments: { local: { type: "local", root: "." } },
-            }),
-        };
+        throw new Error("No MerchantDuo configuration found; run merchantduo init first");
     return {
         config: ConfigSchema.parse(expand(raw, env)),
         configPath: projectConfig ? resolve(projectPath) : undefined,

package/dist/config/operator-profile.d.ts

@@ -0,0 +1,5 @@
+import { type OperatorRole } from "#config/schema";
+/** Read optional user-only agent context without involving repository configuration. */
+export declare function loadOperatorRole(env?: NodeJS.ProcessEnv): Promise<OperatorRole | undefined>;
+/** Persist the explicitly chosen role in the current user's MerchantDuo state. */
+export declare function saveOperatorRole(role: OperatorRole, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/config/operator-profile.js

@@ -0,0 +1,28 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parse, stringify } from "yaml";
+import { merchantHome } from "#config/paths";
+import { operatorRoles } from "#config/schema";
+const profileFile = "operator-profile.yaml";
+/** Read optional user-only agent context without involving repository configuration. */
+export async function loadOperatorRole(env = process.env) {
+    const path = resolve(merchantHome(env), profileFile);
+    try {
+        const profile = parse(await readFile(path, "utf8"));
+        const role = profile?.operatorRole;
+        if (!operatorRoles.includes(role))
+            throw new Error(`Invalid operator role in ${path}`);
+        return role;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/** Persist the explicitly chosen role in the current user's MerchantDuo state. */
+export async function saveOperatorRole(role, env = process.env) {
+    const directory = merchantHome(env);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await writeFile(resolve(directory, profileFile), stringify({ operatorRole: role }), { mode: 0o600 });
+}

package/dist/config/schema.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import type { Environment } from "#environments/model";
+export declare const operatorRoles: readonly ["store-admin", "backend-developer", "frontend-developer", "full-stack-developer"];
+export type OperatorRole = (typeof operatorRoles)[number];
 export declare const ConfigSchema: z.ZodObject<{
     defaultEnvironment: z.ZodOptional<z.ZodString>;
     activeTheme: z.ZodDefault<z.ZodString>;

package/dist/config/schema.js

@@ -1,4 +1,10 @@
 import { z } from "zod";
+export const operatorRoles = [
+    "store-admin",
+    "backend-developer",
+    "frontend-developer",
+    "full-stack-developer",
+];
 const testing = z
     .object({
     frontendUrl: z.string().url().optional(),

package/dist/environments/adapters/warden.d.ts

@@ -1,10 +1,16 @@
 import type { EnvironmentAdapter } from "#environments/adapter";
 import type { WardenEnvironment } from "#environments/model";
 export declare class WardenAdapter implements EnvironmentAdapter {
+    #private;
     readonly environment: WardenEnvironment;
     readonly cwd: string;
     constructor(environment: WardenEnvironment, cwd: string);
-    path(path: string): string;
+    /**
+     * Resolve a path into the Warden container before a routed command runs.
+     * Relative paths are container-relative; absolute paths may be either
+     * canonical container paths or host paths below the Warden project root.
+     */
+    path(candidate: string): string;
     command(argv: string[], target?: string): {
         file: string;
         args: string[];

package/dist/environments/adapters/warden.js

@@ -1,13 +1,30 @@
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { contain } from "#environments/path-policy";
 export class WardenAdapter {
     environment;
     cwd;
+    #hostRoot;
+    #containerRoot;
     constructor(environment, cwd) {
         this.environment = environment;
         this.cwd = cwd;
+        this.#hostRoot = resolve(cwd, environment.projectRoot);
+        this.#containerRoot = resolve(environment.root);
     }
-    path(path) {
-        return path.startsWith("/") ? path : `${this.environment.root}/${path}`;
+    /**
+     * Resolve a path into the Warden container before a routed command runs.
+     * Relative paths are container-relative; absolute paths may be either
+     * canonical container paths or host paths below the Warden project root.
+     */
+    path(candidate) {
+        if (!isAbsolute(candidate))
+            return contain(this.#containerRoot, candidate);
+        const absolute = resolve(candidate);
+        if (within(this.#containerRoot, absolute))
+            return absolute;
+        if (within(this.#hostRoot, absolute))
+            return contain(this.#containerRoot, relative(this.#hostRoot, absolute));
+        throw new Error(`Path is outside the Warden project and container roots: ${candidate}`);
     }
     command(argv, target) {
         const service = target
@@ -29,3 +46,7 @@ export class WardenAdapter {
         return { file: "warden", args: actionArgs, cwd: resolve(this.cwd, this.environment.projectRoot) };
     }
 }
+function within(root, candidate) {
+    const value = relative(root, candidate);
+    return value === "" || (value !== ".." && !value.startsWith(`..${sep}`));
+}

package/dist/integrations/pi/context.js

@@ -1,5 +1,6 @@
 import { refreshStatus, setInitializingStatus } from "#app/status";
 import { merchantDuoSystemPrompt } from "#app/system-prompt";
+import { loadOperatorRole } from "#config/index";
 import { discoverTesting } from "#testing/index";
 import { discoverMagerun2 } from "#features/magerun2/index";
 import { discoverHostExecutable, NodeHostProcessRunner } from "#testing/host";
@@ -58,8 +59,9 @@ export default function context(pi) {
     });
     pi.on("before_agent_start", async (event, ctx) => {
         const state = await runtime.boot(ctx.cwd);
+        const operatorRole = await loadOperatorRole();
         const testing = state.testing;
-        return { systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt()}\nEnvironment: ${state.selected.name} is ${state.environmentStatus}; permission mode=${state.permissionMode}. ${state.environmentStatus === "stopped" ? "Use environment_start only after the user directly asks to start it; do not use project tools until it is running." : "Testing URLs are discovered but unverified. Frontend: " + (testing?.frontendUrl ?? "unavailable") + "; Admin: " + (testing?.adminUrl ?? "unavailable") + ". HTTP, browser, navigation, and test artifacts are host-only; never use environment bash to locate or repair their host paths. Use explicit test tools only when relevant."}` };
+        return { systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt(operatorRole)}\nEnvironment: ${state.selected.name} is ${state.environmentStatus}; permission mode=${state.permissionMode}. ${state.environmentStatus === "stopped" ? "Use environment_start only after the user directly asks to start it; do not use project tools until it is running." : "Testing URLs are discovered but unverified. Frontend: " + (testing?.frontendUrl ?? "unavailable") + "; Admin: " + (testing?.adminUrl ?? "unavailable") + ". HTTP, browser, navigation, and test artifacts are host-only; never use environment bash to locate or repair their host paths. Use explicit test tools only when relevant."}` };
     });
 }
 export function statusMessage(state) {

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

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type PermissionMode } from "#app/permission-mode";
 import type { Environment } from "#environments/model";
+export declare function permissionChoices(): PermissionMode[];
 export declare function requiresExecuteConfirmation(toolName: string, input: Record<string, unknown>): boolean;
 /** Return block/confirmation behavior; callers retain all hard capability constraints. */
 export declare function permissionDecision(mode: PermissionMode, environment: Environment, toolName: string, input: Record<string, unknown>): "allow" | "block" | "confirm";

package/dist/integrations/pi/permissions.js

@@ -3,6 +3,9 @@ import { refreshStatus } from "#app/status";
 import { runtime } from "#integrations/pi/session";
 const workspaceMutations = new Set(["write", "edit"]);
 const stoppedAllowed = new Set(["environment_status", "environment_start", "environment_stop", "environment_set_status"]);
+export function permissionChoices() {
+    return [...permissionModes];
+}
 export function requiresExecuteConfirmation(toolName, input) {
     return ["environment_start", "environment_stop"].includes(toolName) || ((toolName === "mage2gen_generate_module" || toolName === "magento_workflow" || toolName === "magerun2") && input.execute === true);
 }
@@ -26,9 +29,13 @@ async function confirm(ctx, title, message) {
 /** The sole MerchantDuo confirmation gate. YOLO removes dialogs, never hard constraints. */
 export default function permissions(pi) {
     pi.registerCommand("duo-switch-permissions", { description: "Set this session's permission mode: read-only, normal, or yolo.", handler: async (args, ctx) => {
-            const mode = args.trim();
-            if (!permissionModes.includes(mode)) {
-                ctx.ui.notify("Choose one of: read-only, normal, yolo", "error");
+            const choices = permissionChoices();
+            const typed = args.trim();
+            const mode = typed || (ctx.hasUI ? await ctx.ui.select("Select session permission mode", choices) : undefined);
+            if (!mode)
+                return;
+            if (!choices.includes(mode)) {
+                ctx.ui.notify(`Choose one of: ${choices.join(", ")}`, "error");
                 return;
             }
             await runtime.boot(ctx.cwd);