fix: run inline commands in invocation directory, add _cwd override

Inline commands (!`cmd`) now run in the user's working directory instead
of the agent file's directory. This fixes the issue where agents in ~/.ma
would execute commands in ~/.ma rather than the project directory.

Added _cwd frontmatter key and --_cwd CLI flag to override the command
working directory. Priority: CLI --_cwd > frontmatter _cwd > process.cwd()

Author: johnlindquist

CLAUDE.md

@@ -96,6 +96,7 @@ Commands are resolved in priority order:
 - `$1`, `$2`, etc.: Map positional args to flags
 - `_interactive`: Enable interactive mode (overrides print-mode defaults)
 - `_subcommand`: Prepend subcommand(s) to CLI args (e.g., `_subcommand: exec`)
+- `_cwd`: Override working directory for inline commands (`` !`cmd` ``)
 
 **All other keys** are passed directly as CLI flags:
 

src/imports.test.ts

@@ -354,3 +354,71 @@ test("expandImports allows same content via different files (not symlinks)", asy
   // Should work fine - not a cycle
   expect(result).toBe("Same content Same content");
 });
+
+// Command cwd tests
+test("expandImports runs commands in invocationCwd, not file directory", async () => {
+  // Create a separate directory to simulate the agent file location
+  const agentDir = join(testDir, "agent-dir");
+  await Bun.write(join(agentDir, "dummy.md"), ""); // ensure dir exists
+
+  // Create another directory to simulate the invocation directory
+  const invocationDir = join(testDir, "invocation-dir");
+  await Bun.write(join(invocationDir, "dummy.md"), ""); // ensure dir exists
+
+  // Command that outputs the current working directory
+  const content = "!`pwd`";
+
+  // When invocationCwd is set, commands should run in that directory
+  const result = await expandImports(content, agentDir, new Set(), false, {
+    invocationCwd: invocationDir,
+  });
+
+  // The pwd output should be the invocation directory, not the agent directory
+  expect(result).toContain(invocationDir);
+  expect(result).not.toContain("agent-dir");
+});
+
+test("expandImports uses file directory for commands when invocationCwd not set", async () => {
+  // This tests backward compatibility - when invocationCwd is not provided,
+  // commands should still run in the file's directory (current behavior)
+  const content = "!`pwd`";
+  const result = await expandImports(content, testDir);
+
+  // Should contain the testDir path
+  expect(result).toContain(testDir.split("/").pop());
+});
+
+test("expandImports allows _cwd override via ImportContext", async () => {
+  // Test that invocationCwd can be explicitly set to override where commands run
+  const customDir = join(testDir, "custom-cwd");
+  await Bun.write(join(customDir, "dummy.md"), ""); // ensure dir exists
+
+  const content = "!`pwd`";
+  const result = await expandImports(content, testDir, new Set(), false, {
+    invocationCwd: customDir,
+  });
+
+  // The command should run in customDir, not testDir
+  expect(result).toContain("custom-cwd");
+});
+
+test("expandImports runs bun commands in invocationCwd", async () => {
+  // Test using bun's process.cwd() to verify the working directory
+  // This ensures the cwd is properly passed to spawned processes
+  const agentDir = join(testDir, "bun-agent-dir");
+  await Bun.write(join(agentDir, "dummy.md"), ""); // ensure dir exists
+
+  const invocationDir = join(testDir, "bun-invocation-dir");
+  await Bun.write(join(invocationDir, "dummy.md"), ""); // ensure dir exists
+
+  // Use bun to check process.cwd()
+  const content = '!`bun -e "console.log(process.cwd())"`';
+
+  const result = await expandImports(content, agentDir, new Set(), false, {
+    invocationCwd: invocationDir,
+  });
+
+  // The bun process should report the invocation directory as cwd
+  expect(result).toContain("bun-invocation-dir");
+  expect(result).not.toContain("bun-agent-dir");
+});

src/imports.ts

@@ -52,6 +52,12 @@ export interface ImportContext {
   env?: Record<string, string | undefined>;
   /** Track resolved imports for ExecutionPlan */
   resolvedImports?: ResolvedImportsTracker;
+  /**
+   * Working directory for command execution (!`cmd` inlines).
+   * When set, commands run in this directory instead of the agent file's directory.
+   * This allows agents in ~/.ma to execute commands in the user's invocation directory.
+   */
+  invocationCwd?: string;
 }
 
 /**
@@ -749,9 +755,13 @@ async function processCommandInline(
   // Use importCtx.env if provided, otherwise fall back to process.env
   const env = importCtx?.env ?? process.env;
 
+  // Use invocationCwd for command execution if provided (allows agents in ~/.ma
+  // to run commands in the user's current directory), fall back to file directory
+  const commandCwd = importCtx?.invocationCwd ?? currentFileDir;
+
   try {
     const result = Bun.spawnSync(["sh", "-c", command], {
-      cwd: currentFileDir,
+      cwd: commandCwd,
       stdout: "pipe",
       stderr: "pipe",
       env: env as Record<string, string>,

src/index.ts

@@ -226,6 +226,14 @@ async function main() {
       remainingArgs.splice(interactiveIndex, 1); // Consume it
     }
 
+    // Check for --_cwd flag (consumed by ma, overrides working directory for !`cmd` inlines)
+    let cwdFromCli: string | undefined;
+    const cwdFlagIndex = remainingArgs.findIndex(arg => arg === "--_cwd");
+    if (cwdFlagIndex !== -1 && cwdFlagIndex + 1 < remainingArgs.length) {
+      cwdFromCli = remainingArgs[cwdFlagIndex + 1];
+      remainingArgs.splice(cwdFlagIndex, 2); // Consume --_cwd and its value
+    }
+
     // Resolve command: CLI --command > MA_COMMAND env > filename
     let command: string;
     try {
@@ -319,8 +327,16 @@ async function main() {
 
     if (hasImports(rawBody)) {
       try {
-        getImportLogger().debug({ fileDir }, "Expanding imports");
-        expandedBody = await expandImports(rawBody, fileDir, new Set());
+        // Determine working directory for !`cmd` inlines:
+        // Priority: CLI --_cwd > frontmatter _cwd > process.cwd()
+        const commandCwd = cwdFromCli
+          ?? (frontmatter._cwd as string | undefined)
+          ?? process.cwd();
+
+        getImportLogger().debug({ fileDir, commandCwd }, "Expanding imports");
+        expandedBody = await expandImports(rawBody, fileDir, new Set(), false, {
+          invocationCwd: commandCwd,
+        });
         getImportLogger().debug({ originalLength: rawBody.length, expandedLength: expandedBody.length }, "Imports expanded");
       } catch (err) {
         getImportLogger().error({ error: (err as Error).message }, "Import expansion failed");