@merchantduo/code 0.2.0-beta.4 → 0.3.0-beta.0

package/README.md

@@ -6,17 +6,17 @@ MerchantDuo is a Pi coding agent for Magento 2.4 teams. It starts from the store
 
 - Works with local checkouts, Warden, and SSH environments.
 - Detects Magento edition, version, PHP version, deployment mode, cache types, and registered theme inheritance.
-- Ships Magento 2.4, Luma, Hyva, Mage2Gen, and testing skills.
+- Ships Magento 2.4, Luma, Hyva, Mage2Gen, testing, and persistent-goal skills.
 - Provides guided local/Warden store provisioning.
 - Keeps remote writes and Magento operations behind explicit execution boundaries.
 
-At session start, MerchantDuo produces a Magento snapshot from the selected environment. Frontend and admin URLs are discovered but remain unverified until an explicit test. The compact status line shows MerchantDuo and Magento versions, environment lifecycle, session permission mode, an explicit theme scope when one is selected, and the frontend URL when available.
+At session start, MerchantDuo produces a Magento snapshot from the selected environment. Frontend and admin URLs are discovered but remain unverified until an explicit test. The compact status line shows the Magento version, environment lifecycle, session permission mode, an explicit theme scope when one is selected, and the frontend URL when available.
 
 ## Commands and tools
 
 Extension slash commands are namespaced with `duo-` to avoid collisions with other Pi extensions.
 
-- [Command reference](docs/commands.md) covers session theme and permission switching, lifecycle, and navigation commands.
+- [Command reference](docs/commands.md) covers session theme and permission switching, lifecycle, navigation, and bundled persistent-goal commands.
 - [Tool reference](docs/tools.md) covers workspace, environment, Magento workflow, magerun2, testing, PHP-console, and optional knowledge tools, including parameters and confirmation boundaries.
 
 ## Environments
@@ -73,7 +73,7 @@ The interactive flow discovers available source, database, and service evidence,
 
 ## Install and start
 
-MerchantDuo requires Node.js 22.19 or later, Bash, and Python 3. HTTP/browser testing additionally needs curl and Chrome or Chromium; Warden and SSH environments need Warden and OpenSSH respectively.
+MerchantDuo requires Node.js 22.19 or later, Bash, and Python 3. HTTP/browser testing additionally needs curl and Chrome or Chromium. The bundled `fetch_content` internet-research tool runs over host HTTP and has no browser or Python-runner prerequisite. Warden and SSH environments need Warden and OpenSSH respectively.
 
 ```sh
 pnpm install --frozen-lockfile

package/dist/app/native-operations.d.ts

@@ -0,0 +1,19 @@
+import type { CommandResult, CommandSpec } from "#environments/executor";
+export type NativeLogContext = {
+    project: string;
+    session: string;
+    environment: string;
+};
+/** Append-only, fail-soft evidence for automatic native probes only. */
+export declare class NativeProbeLog {
+    #private;
+    readonly path: string;
+    constructor(path?: string);
+    get warning(): string | undefined;
+    start(context: NativeLogContext): Promise<void>;
+    record(spec: CommandSpec, result: CommandResult): Promise<void>;
+}
+export declare function runNativeProbe(log: NativeProbeLog, executor: {
+    command(argv: string[], target?: string): CommandSpec;
+    run(argv: string[], options?: Parameters<import("#environments/executor").CommandExecutor["run"]>[1]): Promise<CommandResult>;
+}, argv: string[], options?: Parameters<import("#environments/executor").CommandExecutor["run"]>[1]): Promise<CommandResult>;

package/dist/app/native-operations.js

@@ -0,0 +1,50 @@
+import { appendFile, chmod, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const MAX_STREAM = 8_000;
+/** Append-only, fail-soft evidence for automatic native probes only. */
+export class NativeProbeLog {
+    path;
+    #started = false;
+    #warning;
+    constructor(path = join(homedir(), ".merchantduo", "native-operations.log")) {
+        this.path = path;
+    }
+    get warning() { return this.#warning; }
+    async start(context) {
+        if (this.#started)
+            return;
+        this.#started = true;
+        await this.#append(`\n=== MerchantDuo native session ${new Date().toISOString()} ===\nsession: ${redact(context.session)}\nproject: ${redact(context.project)}\nenvironment: ${redact(context.environment)}\n`);
+    }
+    async record(spec, result) {
+        const stdout = stream(result.stdout);
+        const stderr = stream(result.stderr);
+        await this.#append(`\n[${new Date().toISOString()}]\ncommand: ${redact([spec.file, ...spec.args].join(" "))}\nexit_code: ${result.exitCode}\nstdout:\n${stdout.value}${result.truncated || stdout.truncated ? "\n[stdout truncated]" : ""}\nstderr:\n${stderr.value}${result.truncated || stderr.truncated ? "\n[stderr truncated]" : ""}\n`);
+    }
+    async #append(record) {
+        try {
+            const directory = dirname(this.path);
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await chmod(directory, 0o700);
+            await appendFile(this.path, record, { encoding: "utf8", mode: 0o600 });
+            await chmod(this.path, 0o600);
+        }
+        catch {
+            this.#warning = "Native operation logging is unavailable.";
+        }
+    }
+}
+export async function runNativeProbe(log, executor, argv, options) {
+    const spec = executor.command(argv, options?.target);
+    const result = await executor.run(argv, options);
+    await log.record(spec, result);
+    return result;
+}
+function stream(value) {
+    const redacted = redact(value);
+    return { value: redacted.slice(0, MAX_STREAM), truncated: redacted.length > MAX_STREAM };
+}
+function redact(value) {
+    return value.replace(/((?:password|passwd|secret|token|api[_-]?key)\s*(?:=|:|=>)\s*["']?)[^\s"']+/gi, "$1[redacted]");
+}

package/dist/app/runtime.d.ts

@@ -7,6 +7,7 @@ import { type MagentoInspector, type MagentoSnapshot } from "#magento/index";
 import { ChangeTracker } from "#workflows/change-tracker";
 import type { TestingSnapshot } from "#testing/model";
 import type { Magerun2Capability } from "#features/magerun2/index";
+import { NativeProbeLog } from "#app/native-operations";
 export type SessionState = {
     config: MerchantConfig;
     configPath?: string;
@@ -15,6 +16,7 @@ export type SessionState = {
         environment: Environment;
     };
     backend: EnvironmentBackend;
+    nativeLog: NativeProbeLog;
     environmentStatus: EnvironmentStatus;
     permissionMode: PermissionMode;
     magento: MagentoSnapshot;

package/dist/app/runtime.js

@@ -3,6 +3,8 @@ import { EnvironmentBackend } from "#environments/backend";
 import { resolvePermissionMode } from "#app/permission-mode";
 import { DefaultMagentoInspector, } from "#magento/index";
 import { ChangeTracker } from "#workflows/change-tracker";
+import { NativeProbeLog } from "#app/native-operations";
+import { wardenRunning } from "#environments/backend";
 export class MerchantDuoRuntime {
     inspector;
     #state;
@@ -20,14 +22,17 @@ export class MerchantDuoRuntime {
         });
         const selected = selectEnvironment(loaded.config, cwd, process.env.MERCHANTDUO_SELECTED_ENV);
         const backend = new EnvironmentBackend(selected.environment, cwd);
-        const environmentStatus = await backend.status();
+        const nativeLog = new NativeProbeLog();
+        await nativeLog.start({ project: cwd, session: `${process.pid}`, environment: selected.name });
+        const environmentStatus = await nativeStatus(backend, nativeLog);
         this.#state = {
             ...loaded,
             selected,
             backend,
+            nativeLog,
             environmentStatus,
             permissionMode: resolvePermissionMode(selected.environment, process.env.MERCHANTDUO_PERMISSION_MODE),
-            magento: environmentStatus === "running" ? await this.inspector.inspect(backend) : stoppedMagentoSnapshot(),
+            magento: environmentStatus === "running" ? await this.inspector.inspect(backend, (argv, result) => nativeLog.record(backend.command(argv), result)) : stoppedMagentoSnapshot(),
         };
         return this.#state;
     }
@@ -102,3 +107,15 @@ export class MerchantDuoRuntime {
 function stoppedMagentoSnapshot() {
     return { cacheTypes: [], warnings: ["Environment is stopped"], evidence: [], themes: [] };
 }
+async function nativeStatus(backend, log) {
+    if (backend.environment.type === "ssh")
+        return "running";
+    if (backend.environment.type === "local")
+        return "unknown";
+    const spec = backend.lifecycleCommand("status");
+    if (!spec)
+        return "stopped";
+    const result = await backend.runCommand(spec);
+    await log.record(spec, result);
+    return result.exitCode === 0 && wardenRunning(result.stdout) ? "running" : "stopped";
+}

package/dist/app/status.d.ts

@@ -1,3 +1,4 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SessionState } from "#app/runtime";
+export declare function setInitializingStatus(ctx: ExtensionContext): void;
 export declare function refreshStatus(ctx: ExtensionContext, state: SessionState): void;

package/dist/app/status.js

@@ -1,6 +1,8 @@
+export function setInitializingStatus(ctx) {
+    ctx.ui.setStatus("merchantduo", "Initializing Magento context…");
+}
 export function refreshStatus(ctx, state) {
     const parts = [
-        `MerchantDuo ${process.env.MERCHANTDUO_PACKAGE_VERSION ?? "?"}`,
         `M${state.magento.version ?? "?"}`,
         `${state.selected.name} (${state.environmentStatus})`,
         state.permissionMode === "read-only" ? "r-o" : state.permissionMode,

package/dist/app/system-prompt.js

@@ -5,6 +5,8 @@ export function mage2genRoot() {
 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.
 
+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.
 
 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.

package/dist/environments/backend.d.ts

@@ -11,8 +11,10 @@ export declare class EnvironmentBackend implements CommandExecutor {
     path(path: string): string;
     command(argv: string[], target?: string): CommandSpec;
     run(argv: string[], options?: RunOptions): Promise<CommandResult>;
+    /** Execute a pre-routed adapter command, used by automatic lifecycle probing. */
+    runCommand(spec: CommandSpec, options?: RunOptions): Promise<CommandResult>;
     lifecycleCommand(action: "status" | "start" | "stop"): CommandSpec | undefined;
-    status(): Promise<EnvironmentStatus>;
+    status(onCommand?: (spec: CommandSpec, result: CommandResult) => void): Promise<EnvironmentStatus>;
     start(): Promise<CommandResult | undefined>;
     stop(): Promise<CommandResult | undefined>;
 }

package/dist/environments/backend.js

@@ -22,12 +22,16 @@ export class EnvironmentBackend {
     }
     async run(argv, options = {}) {
         const spec = this.command(argv, options.target);
+        return this.runCommand(spec, options);
+    }
+    /** Execute a pre-routed adapter command, used by automatic lifecycle probing. */
+    runCommand(spec, options = {}) {
         return this.#runSpec(spec, options);
     }
     lifecycleCommand(action) {
         return this.#adapter.lifecycleCommand?.(action);
     }
-    async status() {
+    async status(onCommand) {
         if (this.environment.type === "ssh")
             return "running";
         if (this.environment.type === "local")
@@ -36,6 +40,7 @@ export class EnvironmentBackend {
         if (!spec)
             return "stopped";
         const output = await this.#runSpec(spec);
+        onCommand?.(spec, output);
         return output.exitCode === 0 && wardenRunning(output.stdout) ? "running" : "stopped";
     }
     async start() {

package/dist/features/magerun2/service.d.ts

@@ -1,9 +1,10 @@
 import type { EnvironmentBackend } from "#environments/backend";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { Environment } from "#environments/model";
 import { type HostProcessRunner } from "#testing/host";
 import type { Magerun2Capability, Magerun2Result } from "#features/magerun2/model";
 /** Resolve magerun once for the selected Magento environment without altering the project. */
-export declare function discoverMagerun2(environment: Environment, backend: EnvironmentBackend, cwd: string): Promise<Magerun2Capability>;
+export declare function discoverMagerun2(environment: Environment, backend: CommandExecutor, cwd: string, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<Magerun2Capability>;
 /** Run a structured argument vector. Local commands are host processes; Warden and SSH use their selected backend. */
 export declare function runMagerun2(capability: Magerun2Capability, environment: Environment, backend: EnvironmentBackend, cwd: string, args: string[], stdin?: string, signal?: AbortSignal, host?: HostProcessRunner): Promise<Magerun2Result>;
 /** Stable display only: this is never passed to a shell. */

package/dist/features/magerun2/service.js

@@ -6,14 +6,16 @@ import { NodeHostProcessRunner } from "#testing/host";
 const RELEASE_URL = "https://api.github.com/repos/netz98/n98-magerun2/releases/latest";
 const MAX_OUTPUT = 64 * 1024;
 /** Resolve magerun once for the selected Magento environment without altering the project. */
-export async function discoverMagerun2(environment, backend, cwd) {
+export async function discoverMagerun2(environment, backend, cwd, record) {
     if (environment.type === "warden")
         return { available: true, executable: "/usr/local/bin/mr" };
     const candidates = environment.type === "local"
         ? ["vendor/bin/n98-magerun2", "bin/n98-magerun2", "n98-magerun2", "magerun2"]
         : ["n98-magerun2", "magerun2"];
     for (const candidate of candidates) {
-        const result = await backend.run(["sh", "-lc", `command -v -- ${candidate} 2>/dev/null || { test -x ${candidate} && printf '%s' ${candidate}; }`]);
+        const argv = ["sh", "-lc", `command -v -- ${candidate} 2>/dev/null || { test -x ${candidate} && printf '%s' ${candidate}; }`];
+        const result = await backend.run(argv);
+        await record?.(argv, result);
         const executable = result.stdout.trim();
         if (executable)
             return { available: true, executable };

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

@@ -1,2 +1,4 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runtime } from "#integrations/pi/session";
 export default function context(pi: ExtensionAPI): void;
+export declare function statusMessage(state: Awaited<ReturnType<typeof runtime.boot>>): string;

package/dist/integrations/pi/context.js

@@ -1,12 +1,13 @@
-import { refreshStatus } from "#app/status";
+import { refreshStatus, setInitializingStatus } from "#app/status";
 import { merchantDuoSystemPrompt } from "#app/system-prompt";
 import { discoverTesting } from "#testing/index";
 import { discoverMagerun2 } from "#features/magerun2/index";
-import { discoverHostExecutable } from "#testing/host";
+import { discoverHostExecutable, NodeHostProcessRunner } from "#testing/host";
 import { runtime, sessionEvents } from "#integrations/pi/session";
 export default function context(pi) {
     pi.on("session_start", async (_event, ctx) => {
         runtime.resetInjection();
+        setInitializingStatus(ctx);
         const state = await runtime.boot(ctx.cwd);
         if (state.environmentStatus === "stopped") {
             refreshStatus(ctx, state);
@@ -14,23 +15,34 @@ export default function context(pi) {
             pi.appendEntry("merchantduo.context", { environment: state.selected.name, environmentStatus: state.environmentStatus, permissionMode: state.permissionMode });
             return;
         }
-        const magerun2 = await discoverMagerun2(state.selected.environment, state.backend, ctx.cwd);
+        const record = (argv, result) => state.nativeLog.record(state.backend.command(argv), result);
+        const magerun2 = await discoverMagerun2(state.selected.environment, state.backend, ctx.cwd, record);
         // HTTP and Chromium deliberately run on the host against Warden's routed URL.
         // Do not use EnvironmentBackend here: its Warden adapter would probe php-fpm.
         // Prefer non-Snap Chrome: Snap Chromium cannot write MerchantDuo artifacts
         // and its private /tmp makes generated output unavailable to the host.
+        const hostRunner = new NodeHostProcessRunner();
+        const nativeHost = { run: async (file, args, options) => {
+                const result = await hostRunner.run(file, args, options);
+                await state.nativeLog.record({ file, args, cwd: options.cwd }, { stdout: result.output, stderr: "", exitCode: result.code, truncated: result.truncated ?? false });
+                return result;
+            } };
         const [http, browser] = await Promise.all([
-            discoverHostExecutable(["curl"]),
-            discoverHostExecutable(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]),
+            discoverHostExecutable(["curl"], nativeHost),
+            discoverHostExecutable(["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"], nativeHost),
         ]);
         runtime.setMagerun2(magerun2);
-        runtime.setTesting(await discoverTesting(state.selected.environment, state.backend, ctx.cwd, { ...state.config.testing, ...state.selected.environment.testing, allowInsecureTls: state.selected.environment.testing?.allowInsecureTls ?? state.config.testing.allowInsecureTls }, { http, browser }));
+        runtime.setTesting(await discoverTesting(state.selected.environment, state.backend, ctx.cwd, { ...state.config.testing, ...state.selected.environment.testing, allowInsecureTls: state.selected.environment.testing?.allowInsecureTls ?? state.config.testing.allowInsecureTls }, { http, browser }, record));
         refreshStatus(ctx, state);
         sessionEvents.emit("merchantduo.context", state);
         pi.appendEntry("merchantduo.context", { environment: state.selected.name, environmentStatus: state.environmentStatus, permissionMode: state.permissionMode, testing: state.testing, magerun2: state.magerun2 });
     });
     pi.on("session_compact", () => runtime.resetInjection());
     pi.on("session_shutdown", () => sessionEvents.clear());
+    pi.registerCommand("duo-status", { description: "Show the current MerchantDuo session status.", handler: async (_args, ctx) => {
+            const state = await runtime.boot(ctx.cwd);
+            pi.sendMessage({ customType: "merchantduo.status", content: statusMessage(state), display: true, details: {} });
+        } });
     pi.on("tool_call", (event) => {
         if (event.toolName !== "write" && event.toolName !== "edit")
             return;
@@ -50,3 +62,21 @@ export default function context(pi) {
         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."}` };
     });
 }
+export function statusMessage(state) {
+    const lines = [
+        `Environment: ${state.selected.name} (${state.environmentStatus})`,
+        `Permission mode: ${state.permissionMode}`,
+        `Magento: ${state.magento.edition ?? "unknown"} ${state.magento.version ?? "version unavailable"}`,
+        `PHP: ${state.magento.phpVersion ?? "unavailable"}`,
+        `Deploy mode: ${state.magento.mode ?? "unavailable"}`,
+        `Active theme: ${state.config.activeTheme}`,
+        `Frontend URL: ${state.testing?.frontendUrl ?? "unavailable"}`,
+        `Admin URL: ${state.testing?.adminUrl ?? "unavailable"}`,
+        `Capabilities: HTTP ${state.testing?.http.available ? "available" : "unavailable"}; browser ${state.testing?.browser.available ? "available" : "unavailable"}; magerun2 ${state.magerun2?.available ? "available" : "unavailable"}`,
+        ...state.magento.warnings.map((warning) => `Warning: ${warning}`),
+        ...(state.testing?.diagnostics.map((warning) => `Warning: ${warning}`) ?? []),
+        ...(state.magerun2?.diagnostic ? [`Warning: ${state.magerun2.diagnostic}`] : []),
+        ...(state.nativeLog.warning ? [`Warning: ${state.nativeLog.warning}`] : []),
+    ];
+    return lines.join("\n");
+}

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

@@ -2,4 +2,20 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { EnvironmentBackend } from "#environments/backend";
 /** Replaces Pi's native workspace tools with selected-environment operations. */
 export default function workspace(pi: ExtensionAPI): void;
+type SearchParameters = {
+    pattern: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    literal?: boolean;
+    context?: number;
+    limit?: number;
+};
+/**
+ * Search the selected backend without making its runtime image depend on ripgrep:
+ * use rg when present, otherwise enumerate regular files and pass them to grep.
+ */
+export declare function searchCommand(params: SearchParameters, path: string): string;
 export declare function workspacePath(backend: EnvironmentBackend, cwd: string, candidate: string): string;
+/** Return only a declared MerchantDuo skill asset; project files remain environment-routed. */
+export declare function packagedSkillPath(candidate: string): string | undefined;
+export {};

package/dist/integrations/pi/workspace.js

@@ -1,16 +1,34 @@
+import { access as hostAccess, readFile as hostReadFile } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 import { Type } from "typebox";
 import { createEditToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
 import { runtime } from "#integrations/pi/session";
+import { packagePath } from "#shared/package-paths";
 const shell = (value) => `'${value.replace(/'/g, "'\\''")}'`;
 const result = (value) => ({ content: [{ type: "text", text: value }], details: {} });
+const packageSkillRoots = [
+    packagePath("skills"),
+    packagePath("vendor", "hyva-ai-tools", "skills"),
+];
 /** Replaces Pi's native workspace tools with selected-environment operations. */
 export default function workspace(pi) {
     registerFileTools(pi);
     pi.registerTool({ name: "bash", label: "bash", description: "Run a shell command in the selected MerchantDuo environment.", parameters: Type.Object({ command: Type.String(), timeout: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const output = await state.backend.run(["sh", "-lc", params.command], { signal, timeoutMs: params.timeout }); return result(`${output.stdout}${output.stderr}`); } });
     pi.registerTool({ name: "ls", label: "ls", description: "List a selected-environment directory.", parameters: Type.Object({ path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -mindepth 1 -maxdepth 1 -printf '%f\\n' | head -n ${Math.max(1, Math.min(params.limit ?? 200, 1000))}`], { signal }); return result(output.stdout || output.stderr); } });
     pi.registerTool({ name: "find", label: "find", description: "Find files in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 1000, 5000)); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -path '*/node_modules/*' -prune -o -path '*/.git/*' -prune -o -name ${shell(params.pattern)} -print | head -n ${limit}`], { signal }); return result(output.stdout || output.stderr); } });
-    pi.registerTool({ name: "grep", label: "grep", description: "Search text using ripgrep in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()), ignoreCase: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()), context: Type.Optional(Type.Number()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 100, 1000)); const flags = ["--line-number", "--color=never", `--max-count=${limit}`, params.ignoreCase ? "--ignore-case" : "", params.literal ? "--fixed-strings" : "", params.context ? `--context=${Math.min(params.context, 20)}` : "", params.glob ? `--glob ${shell(params.glob)}` : ""].filter(Boolean).join(" "); const output = await state.backend.run(["sh", "-lc", `rg ${flags} -- ${shell(params.pattern)} ${shell(path)}`], { signal }); return result(output.stdout || output.stderr); } });
+    pi.registerTool({ name: "grep", label: "grep", description: "Search text with ripgrep or a backend-local grep fallback in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()), ignoreCase: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()), context: Type.Optional(Type.Number()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const output = await state.backend.run(["sh", "-lc", searchCommand(params, path)], { signal }); return result(output.stdout || output.stderr); } });
+}
+/**
+ * Search the selected backend without making its runtime image depend on ripgrep:
+ * use rg when present, otherwise enumerate regular files and pass them to grep.
+ */
+export function searchCommand(params, path) {
+    const limit = Math.max(1, Math.min(params.limit ?? 100, 1000));
+    const context = params.context ? Math.min(params.context, 20) : undefined;
+    const rgFlags = ["--line-number", "--color=never", `--max-count=${limit}`, params.ignoreCase ? "--ignore-case" : "", params.literal ? "--fixed-strings" : "", context ? `--context=${context}` : "", params.glob ? `--glob ${shell(params.glob)}` : ""].filter(Boolean).join(" ");
+    const grepFlags = ["-n", params.ignoreCase ? "-i" : "", params.literal ? "-F" : "", context ? `-C ${context}` : ""].filter(Boolean).join(" ");
+    const glob = params.glob ? `-name ${shell(params.glob)} ` : "";
+    return `if command -v rg >/dev/null 2>&1; then rg ${rgFlags} -- ${shell(params.pattern)} ${shell(path)}; else find ${shell(path)} \\( -path '*/node_modules/*' -o -path '*/.git/*' \\) -prune -o -type f ${glob}-exec grep ${grepFlags} -- ${shell(params.pattern)} {} + 2>/dev/null | head -n ${limit}; fi`;
 }
 function registerFileTools(pi) {
     const localRead = createReadToolDefinition(process.cwd());
@@ -21,13 +39,33 @@ function registerFileTools(pi) {
     pi.registerTool({ ...localEdit, async execute(id, params, signal, update, ctx) { const state = await runtime.boot(ctx.cwd); return createEditToolDefinition(ctx.cwd, { operations: fileOps(state.backend, ctx.cwd) }).execute(id, params, signal, update, ctx); } });
 }
 function fileOps(backend, cwd) {
-    const readFile = async (path) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 < ${shell(target)}`]); if (response.exitCode)
-        throw new Error(response.stderr || "Cannot read file"); return Buffer.from(response.stdout.replace(/\s/g, ""), "base64"); };
+    const readFile = async (path) => {
+        const skillPath = packagedSkillPath(path);
+        if (skillPath)
+            return hostReadFile(skillPath);
+        const target = workspacePath(backend, cwd, path);
+        const response = await backend.run(["sh", "-lc", `base64 < ${shell(target)}`]);
+        if (response.exitCode)
+            throw new Error(response.stderr || "Cannot read file");
+        return Buffer.from(response.stdout.replace(/\s/g, ""), "base64");
+    };
     const writeFile = async (path, content) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 -d > ${shell(target)}`], { input: Buffer.from(content).toString("base64") }); if (response.exitCode)
         throw new Error(response.stderr || "Cannot write file"); };
-    return { readFile, writeFile, access: async (path) => { const response = await backend.run(["sh", "-lc", `test -r ${shell(workspacePath(backend, cwd, path))}`]); if (response.exitCode)
+    return { readFile, writeFile, access: async (path) => { const skillPath = packagedSkillPath(path); if (skillPath) {
+            await hostAccess(skillPath);
+            return;
+        } const response = await backend.run(["sh", "-lc", `test -r ${shell(workspacePath(backend, cwd, path))}`]); if (response.exitCode)
             throw new Error("Path is inaccessible"); }, mkdir: async (path) => { const response = await backend.run(["mkdir", "-p", workspacePath(backend, cwd, path)]); if (response.exitCode)
             throw new Error(response.stderr || "Cannot create directory"); } };
 }
 export function workspacePath(backend, cwd, candidate) { const full = resolve(cwd, candidate); const value = relative(resolve(cwd), full); if (value === ".." || value.startsWith("../"))
     throw new Error(`Path escapes workspace: ${candidate}`); return backend.path(value); }
+/** Return only a declared MerchantDuo skill asset; project files remain environment-routed. */
+export function packagedSkillPath(candidate) {
+    const full = resolve(candidate);
+    return packageSkillRoots.some((root) => contains(root, full)) ? full : undefined;
+}
+function contains(root, candidate) {
+    const value = relative(root, candidate);
+    return value === "" || (value !== ".." && !value.startsWith("../"));
+}

package/dist/magento/inspector.d.ts

@@ -1,9 +1,9 @@
-import type { CommandExecutor } from "#environments/executor";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { MagentoSnapshot } from "#magento/model";
 export interface MagentoInspector {
-    inspect(executor: CommandExecutor): Promise<MagentoSnapshot>;
+    inspect(executor: CommandExecutor, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<MagentoSnapshot>;
 }
 /** Ordered, fail-soft Magento inspection. New probes can be extracted without changing consumers. */
 export declare class DefaultMagentoInspector implements MagentoInspector {
-    inspect(executor: CommandExecutor): Promise<MagentoSnapshot>;
+    inspect(executor: CommandExecutor, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<MagentoSnapshot>;
 }

package/dist/magento/inspector.js

@@ -2,13 +2,18 @@ import { parseDeployMode } from "#magento/deploy-mode";
 import { parseRegisteredThemes, resolveThemes } from "#magento/themes";
 /** Ordered, fail-soft Magento inspection. New probes can be extracted without changing consumers. */
 export class DefaultMagentoInspector {
-    async inspect(executor) {
+    async inspect(executor, record) {
         const warnings = [];
         const evidence = [];
-        const composer = await executor.run([
+        const run = async (argv) => {
+            const result = await executor.run(argv);
+            await record?.(argv, result);
+            return result;
+        };
+        const composer = await run([
             "sh",
             "-lc",
-            "test -f composer.lock && node -e \"const x=require('./composer.lock'); console.log(JSON.stringify(x.packages||[]))\" || true",
+            `test -f composer.lock && php -r '$x=json_decode(file_get_contents("composer.lock"), true, flags: JSON_THROW_ON_ERROR); echo json_encode($x["packages"] ?? []);'`,
         ]);
         const match = composer.stdout.match(/magento\/(product-community-edition|product-enterprise-edition).*?"version":"([^"]+)/s);
         const edition = match?.[1] === "product-enterprise-edition"
@@ -19,20 +24,21 @@ export class DefaultMagentoInspector {
         const composerVersion = match?.[2];
         if (composerVersion)
             evidence.push("composer.lock");
-        const cli = await executor.run(["bin/magento", "--version"]);
+        const cli = await run(["bin/magento", "--version"]);
         const cliVersion = cli.stdout.match(/(?:Magento|Adobe Commerce)[^0-9]*(\d+\.\d+\.\d+(?:-[^\s]+)?)/)?.[1];
         if (cliVersion)
             evidence.push("bin/magento --version");
+        if (!composerVersion && !cliVersion)
+            warnings.push("Magento version unavailable");
         if (composerVersion &&
             cliVersion &&
             !cliVersion.startsWith(composerVersion))
             warnings.push(`Composer (${composerVersion}) and CLI (${cliVersion}) disagree`);
-        const [php, mode, cache, modules, registeredThemes] = await Promise.all([
-            executor.run(["php", "-r", "echo PHP_VERSION;"]),
-            executor.run(["bin/magento", "deploy:mode:show"]),
-            executor.run(["bin/magento", "cache:status", "--no-ansi"]),
-            executor.run(["bin/magento", "module:status", "--enabled", "--no-ansi"]),
-            executor.run(["sh", "-lc", themeDiscoveryScript]),
+        const [php, mode, cache, registeredThemes] = await Promise.all([
+            run(["php", "-r", "echo PHP_VERSION;"]),
+            run(["bin/magento", "deploy:mode:show"]),
+            run(["bin/magento", "cache:status", "--no-ansi"]),
+            run(["sh", "-lc", themeDiscoveryScript]),
         ]);
         return {
             version: composerVersion ?? cliVersion,
@@ -43,7 +49,6 @@ export class DefaultMagentoInspector {
                 .split("\n")
                 .map((line) => line.match(/^([^:]+):/)?.[1])
                 .filter((value) => Boolean(value)),
-            modulesEnabled: modules.stdout.split("\n").filter(Boolean).length || undefined,
             warnings,
             evidence,
             themes: resolveThemes(parseRegisteredThemes(registeredThemes.stdout)),

package/dist/magento/model.d.ts

@@ -18,7 +18,6 @@ export type MagentoSnapshot = {
     phpVersion?: string;
     mode?: MagentoDeployMode;
     cacheTypes: string[];
-    modulesEnabled?: number;
     warnings: string[];
     evidence: string[];
     themes: MagentoTheme[];

package/dist/testing/discovery.d.ts

@@ -1,9 +1,9 @@
-import type { EnvironmentBackend } from "#environments/backend";
+import type { CommandExecutor, CommandResult } from "#environments/executor";
 import type { Environment } from "#environments/model";
 import type { TestingOptions, TestingSnapshot } from "#testing/model";
-export declare function discoverTesting(environment: Environment, backend: EnvironmentBackend, cwd: string, options: TestingOptions, tools?: {
+export declare function discoverTesting(environment: Environment, backend: CommandExecutor, cwd: string, options: TestingOptions, tools?: {
     http?: string;
     browser?: string;
-}): Promise<TestingSnapshot>;
+}, record?: (argv: string[], result: CommandResult) => Promise<void>): Promise<TestingSnapshot>;
 export declare function wardenRouting(projectRoot: string): Promise<string | undefined>;
 export declare function findExecutable(candidates: string[]): Promise<string | undefined>;

package/dist/testing/discovery.js

@@ -1,7 +1,7 @@
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { canonicalUrl, joinedUrl } from "#testing/url";
-export async function discoverTesting(environment, backend, cwd, options, tools = {}) {
+export async function discoverTesting(environment, backend, cwd, options, tools = {}, record) {
     const diagnostics = [];
     let frontendUrl = canonicalUrl(options.frontendUrl ?? "");
     let adminUrl = canonicalUrl(options.adminUrl ?? "");
@@ -17,15 +17,21 @@ export async function discoverTesting(environment, backend, cwd, options, tools
             diagnostics.push("Warden routing was not found in .env.");
     }
     if (!frontendUrl && environment.type !== "warden") {
-        const result = await backend.run(["bin/magento", "config:show", "web/secure/base_url"]);
+        const secure = ["bin/magento", "config:show", "web/secure/base_url"];
+        const result = await backend.run(secure);
+        await record?.(secure, result);
         frontendUrl = canonicalUrl(result.stdout.trim());
         if (!frontendUrl) {
-            const fallback = await backend.run(["bin/magento", "config:show", "web/unsecure/base_url"]);
+            const unsecure = ["bin/magento", "config:show", "web/unsecure/base_url"];
+            const fallback = await backend.run(unsecure);
+            await record?.(unsecure, fallback);
             frontendUrl = canonicalUrl(fallback.stdout.trim());
         }
     }
     if (!adminUrl) {
-        const result = await backend.run(["bin/magento", "info:adminuri"]);
+        const argv = ["bin/magento", "info:adminuri"];
+        const result = await backend.run(argv);
+        await record?.(argv, result);
         const path = result.stdout.trim().split(/\s+/).pop();
         adminUrl = joinedUrl(frontendUrl, path?.startsWith("/") ? path : `/${path ?? ""}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchantduo/code",
-  "version": "0.2.0-beta.4",
+  "version": "0.3.0-beta.0",
   "private": false,
   "description": "Magento-native Pi-based Coding Agent",
   "type": "module",
@@ -48,7 +48,9 @@
       "./dist/integrations/pi/mage2gen.js",
       "./dist/integrations/pi/workflows.js",
       "./dist/integrations/pi/magerun2.js",
-      "./dist/integrations/pi/testing.js"
+      "./dist/integrations/pi/testing.js",
+      "./node_modules/pi-web-access",
+      "./node_modules/pi-goal"
     ],
     "skills": [
       "./skills",
@@ -58,6 +60,8 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@modelcontextprotocol/client": "2.0.0",
+    "pi-goal": "0.1.7",
+    "pi-web-access": "0.22.0",
     "typebox": "1.3.7",
     "yaml": "^2.8.1",
     "zod": "^3.24.4"