@getollie/cli 0.2.0 → 0.2.2

package/dist/cli.js

@@ -7,8 +7,12 @@ import { CommanderError } from "commander";
 import { Command } from "commander";
 
 // src/config.ts
-import { access, stat } from "fs/promises";
-import { resolve } from "path";
+import { access, realpath, stat } from "fs/promises";
+import { posix as posix2, resolve as resolve2 } from "path";
+
+// src/sandbox/mounts.ts
+import { realpathSync, statSync } from "fs";
+import { posix, resolve } from "path";
 
 // src/utils/errors.ts
 var CliError = class extends Error {
@@ -26,6 +30,68 @@ function getErrorMessage(error) {
   return String(error);
 }
 
+// src/sandbox/mounts.ts
+var SANDBOX_WORKSPACE_PATH = "/workspace";
+function sandboxPathsOverlap(left, right) {
+  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function sandboxPathContains(parent, child) {
+  return parent === child || child.startsWith(`${parent}/`);
+}
+function validateSandboxPath(path, label = "Sandbox path") {
+  if (!posix.isAbsolute(path) || path.includes("\\") || path.includes("\0") || path.split("/").includes("..") || posix.normalize(path) !== path) {
+    throw new CliError(`${label} must be a normalized absolute sandbox path: ${path}`);
+  }
+  return path;
+}
+function validateMountPoint(mountPoint) {
+  validateSandboxPath(mountPoint, "Mount point");
+  if (mountPoint === "/") {
+    throw new CliError(`Mount point must be a normalized absolute sandbox path other than /: ${mountPoint}`);
+  }
+}
+function validateSandboxMounts(mounts, options = {}) {
+  const reservedMountPoint = options.reservedMountPoint === void 0 ? SANDBOX_WORKSPACE_PATH : options.reservedMountPoint;
+  const validated = [];
+  for (const mount of mounts) {
+    validateMountPoint(mount.mountPoint);
+    if (reservedMountPoint && sandboxPathsOverlap(mount.mountPoint, reservedMountPoint)) {
+      throw new CliError(`Mount point must be outside ${reservedMountPoint}: ${mount.mountPoint}`);
+    }
+    let hostPath;
+    try {
+      hostPath = realpathSync(resolve(mount.hostPath));
+      if (!statSync(hostPath).isDirectory()) throw new Error("not a directory");
+    } catch {
+      throw new CliError(
+        `Mount source host path does not exist or is not a directory: ${resolve(mount.hostPath)}`
+      );
+    }
+    const conflict = validated.find(
+      (candidate) => sandboxPathsOverlap(candidate.mountPoint, mount.mountPoint)
+    );
+    if (conflict) {
+      throw new CliError(
+        `Mount points must not overlap: ${conflict.mountPoint} and ${mount.mountPoint}`
+      );
+    }
+    validated.push({ hostPath, mountPoint: mount.mountPoint });
+  }
+  return validated;
+}
+function parseSandboxMounts(specs = [], options) {
+  const mounts = specs.map((spec) => {
+    const separator = spec.lastIndexOf(":");
+    if (separator <= 0 || separator === spec.length - 1) {
+      throw new CliError(
+        `Invalid mount ${JSON.stringify(spec)}. Expected <host-path>:<sandbox-path>`
+      );
+    }
+    return { hostPath: spec.slice(0, separator), mountPoint: spec.slice(separator + 1) };
+  });
+  return validateSandboxMounts(mounts, options);
+}
+
 // src/config.ts
 var DEFAULT_PROVIDER = "openai";
 var DEFAULT_MODEL = "gpt-5.6";
@@ -34,9 +100,7 @@ var DEFAULT_COMMAND_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_OUTPUT_BYTES = 65536;
 var DEFAULT_EXECUTOR = "none";
 function parseNumber(name, value, fallback) {
-  if (value === void 0 || value === "") {
-    return fallback;
-  }
+  if (value === void 0 || value === "") return fallback;
   const parsed = typeof value === "number" ? value : Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed < 0) {
     throw new CliError(`${name} must be a non-negative integer`);
@@ -53,39 +117,82 @@ function parseExecutor(value) {
   }
   return executor;
 }
-async function resolveRunConfig(input = {}, env = process.env) {
-  const cwd = resolve(input.cwd ?? env.OLLIE_CWD ?? process.cwd());
-  const stats = await stat(cwd).catch(() => null);
+async function resolveHostDirectory(value, label) {
+  const absolute = resolve2(value);
+  const stats = await stat(absolute).catch(() => null);
   if (!stats?.isDirectory()) {
-    throw new CliError(`Working directory does not exist or is not a directory: ${cwd}`);
+    throw new CliError(`${label} host path does not exist or is not a directory: ${absolute}`);
   }
-  await access(cwd);
+  await access(absolute);
+  return realpath(absolute);
+}
+async function resolveRunConfig(input = {}, env = process.env) {
+  const configuredHostCwd = input.cwd ?? env.OLLIE_CWD;
+  const configuredSandboxCwd = input.sandboxCwd ?? env.OLLIE_SANDBOX_CWD;
+  const usedImplicitCwd = configuredHostCwd === void 0 && configuredSandboxCwd === void 0;
+  const hostCwdValue = configuredHostCwd ?? (usedImplicitCwd ? process.cwd() : void 0);
+  const explicitMounts = parseSandboxMounts(input.mount, {
+    reservedMountPoint: hostCwdValue ? "/workspace" : null
+  });
+  let workspace;
+  let mounts;
+  let sandboxCwd;
+  if (hostCwdValue) {
+    workspace = {
+      hostPath: await resolveHostDirectory(hostCwdValue, "Working directory"),
+      mountPoint: "/workspace"
+    };
+    mounts = explicitMounts;
+    sandboxCwd = configuredSandboxCwd ?? "/workspace";
+  } else {
+    if (!configuredSandboxCwd) {
+      throw new CliError("Either --cwd or --sandbox-cwd must be specified.");
+    }
+    sandboxCwd = configuredSandboxCwd;
+    validateSandboxPath(sandboxCwd, "Sandbox cwd");
+    const containing2 = explicitMounts.find(
+      (mount) => sandboxPathContains(mount.mountPoint, sandboxCwd)
+    );
+    if (!containing2) {
+      const destinations = explicitMounts.map((mount) => mount.mountPoint).join(", ") || "(none)";
+      throw new CliError(
+        `Sandbox cwd ${sandboxCwd} is not contained by the primary workspace or any configured mount. Configured mount destinations: ${destinations}`
+      );
+    }
+    workspace = containing2;
+    mounts = explicitMounts.filter((mount) => mount !== containing2);
+  }
+  validateSandboxPath(sandboxCwd, "Sandbox cwd");
+  const allMounts = [workspace, ...mounts];
+  const containing = allMounts.find((mount) => sandboxPathContains(mount.mountPoint, sandboxCwd));
+  if (!containing) {
+    const destinations = allMounts.map((mount) => mount.mountPoint).join(", ");
+    throw new CliError(
+      `Sandbox cwd ${sandboxCwd} is not contained by the primary workspace or any configured mount. Configured mount destinations: ${destinations}`
+    );
+  }
+  const mappedRelative = posix2.relative(containing.mountPoint, sandboxCwd);
+  await resolveHostDirectory(resolve2(containing.hostPath, mappedRelative), "Sandbox cwd mapped");
+  const workspaceRelativeCwd = sandboxPathContains(workspace.mountPoint, sandboxCwd) ? posix2.relative(workspace.mountPoint, sandboxCwd) || "." : null;
   const executor = parseExecutor(input.executor ?? env.OLLIE_EXECUTOR);
   return {
-    cwd,
+    cwd: workspace.hostPath,
+    workspaceMountPoint: workspace.mountPoint,
+    sandboxCwd,
+    workspaceRelativeCwd,
+    mounts,
+    usedImplicitCwd,
     provider: input.provider ?? env.OLLIE_PROVIDER ?? DEFAULT_PROVIDER,
     model: input.model ?? env.OLLIE_MODEL ?? DEFAULT_MODEL,
     executor,
-    maxSteps: clamp(
-      parseNumber("max steps", input.maxSteps ?? env.OLLIE_MAX_STEPS, DEFAULT_MAX_STEPS),
-      1,
-      100
-    ),
+    maxSteps: clamp(parseNumber("max steps", input.maxSteps ?? env.OLLIE_MAX_STEPS, DEFAULT_MAX_STEPS), 1, 100),
     commandTimeoutMs: clamp(
-      parseNumber(
-        "command timeout",
-        input.timeout ?? env.OLLIE_COMMAND_TIMEOUT_MS,
-        DEFAULT_COMMAND_TIMEOUT_MS
-      ),
+      parseNumber("command timeout", input.timeout ?? env.OLLIE_COMMAND_TIMEOUT_MS, DEFAULT_COMMAND_TIMEOUT_MS),
       1,
       3e5
     ),
     maxOutputBytes: clamp(
-      parseNumber(
-        "max output",
-        input.maxOutput ?? env.OLLIE_MAX_OUTPUT_BYTES,
-        DEFAULT_MAX_OUTPUT_BYTES
-      ),
+      parseNumber("max output", input.maxOutput ?? env.OLLIE_MAX_OUTPUT_BYTES, DEFAULT_MAX_OUTPUT_BYTES),
       1,
       2e6
     ),
@@ -99,23 +206,23 @@ async function resolveRunConfig(input = {}, env = process.env) {
 import { access as access2, stat as stat2 } from "fs/promises";
 
 // src/sandbox/just-bash.ts
-import { realpathSync, statSync } from "fs";
+import { realpathSync as realpathSync2, statSync as statSync2 } from "fs";
 import { Bash, InMemoryFs, MountableFs, ReadWriteFs } from "just-bash";
 
 // src/sandbox/git/index.ts
-import { posix as posix2 } from "path";
+import { posix as posix4 } from "path";
 import { createTwoFilesPatch } from "diff";
 import * as git from "isomorphic-git";
 import { defineCommand } from "just-bash";
 
 // src/sandbox/git/fs-adapter.ts
-import { posix } from "path";
+import { posix as posix3 } from "path";
 var ROOT = "/workspace";
 function safePath(path) {
   if (path.includes("\0") || path.includes("\\")) {
     throw Object.assign(new Error("Invalid virtual Git path"), { code: "EINVAL" });
   }
-  const normalized = posix.resolve(path);
+  const normalized = posix3.resolve(path);
   if (normalized !== ROOT && !normalized.startsWith(`${ROOT}/`)) {
     throw Object.assign(new Error("Git path is outside /workspace"), { code: "EACCES" });
   }
@@ -135,7 +242,7 @@ function normalizeError(error) {
   throw Object.assign(new Error("Virtual filesystem operation failed"), { code: "EIO" });
 }
 async function ensureParent(fs, path) {
-  const parent = posix.dirname(path);
+  const parent = posix3.dirname(path);
   if (!await fs.exists(parent)) await fs.mkdir(parent, { recursive: true });
 }
 function statShape(stat4) {
@@ -370,9 +477,9 @@ function virtualPath(ctx, input = ".") {
 async function repositoryDir(ctx) {
   let current = virtualPath(ctx);
   while (current === WORKSPACE || current.startsWith(`${WORKSPACE}/`)) {
-    if (await ctx.fs.exists(posix2.join(current, ".git"))) return current;
+    if (await ctx.fs.exists(posix4.join(current, ".git"))) return current;
     if (current === WORKSPACE) break;
-    current = posix2.dirname(current);
+    current = posix4.dirname(current);
   }
   throw new Error("not a git repository (or any parent up to /workspace)");
 }
@@ -455,7 +562,7 @@ async function writeGlobalConfig(ctx, values) {
     ([section, entries]) => `[${section}]
 ${entries.map(([key, value]) => `	${key} = ${value}`).join("\n")}`
   ).join("\n");
-  await ctx.fs.mkdir(posix2.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
+  await ctx.fs.mkdir(posix4.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
   await ctx.fs.writeFile(GLOBAL_CONFIG_PATH, content ? `${content}
 ` : "");
 }
@@ -469,7 +576,7 @@ async function handleInit(context, args) {
       throw new Error("cannot create repository directory");
   });
   await git.init({ fs: context.fs, dir, defaultBranch: branchOpt.value ?? "main" });
-  return ok(`Initialized empty Git repository in ${posix2.join(dir, ".git")}/
+  return ok(`Initialized empty Git repository in ${posix4.join(dir, ".git")}/
 `);
 }
 async function handleStatus(context, args) {
@@ -622,7 +729,7 @@ async function handleDiff(context, args) {
     const changed = cachedFlag.enabled ? headStatus !== stageStatus : workdirStatus !== stageStatus;
     if (!changed) continue;
     const oldBytes = cachedFlag.enabled ? head && headStatus !== 0 ? (await git.readBlob({ fs: context.fs, dir, oid: head, filepath })).blob : empty : await readStage(filepath);
-    const newBytes = cachedFlag.enabled ? await readStage(filepath) : workdirStatus === 0 ? empty : await context.command.fs.readFileBuffer(posix2.join(dir, filepath));
+    const newBytes = cachedFlag.enabled ? await readStage(filepath) : workdirStatus === 0 ? empty : await context.command.fs.readFileBuffer(posix4.join(dir, filepath));
     patches.push(patch(filepath, oldBytes, newBytes));
   }
   return ok(patches.join(""));
@@ -689,7 +796,7 @@ async function handleCheckout(context, args) {
     const oid = await git.resolveRef({ fs: context.fs, dir, ref });
     for (const filepath of filepaths) {
       const blob = await readCheckoutBlob(context, dir, oid, filepath);
-      await context.command.fs.writeFile(posix2.join(dir, filepath), blob);
+      await context.command.fs.writeFile(posix4.join(dir, filepath), blob);
     }
     return ok();
   }
@@ -816,7 +923,7 @@ async function handleClone(context, args) {
   const [rawUrl, destination, ...rest] = noCheckoutFlag.rest;
   if (!rawUrl || rest.length) usage("clone requires a URL and optional directory");
   const url = validateRemoteUrl(rawUrl);
-  const inferred = posix2.basename(new URL(url).pathname).replace(/\.git$/, "") || "repository";
+  const inferred = posix4.basename(new URL(url).pathname).replace(/\.git$/, "") || "repository";
   const dir = virtualPath(context.command, destination ?? inferred);
   const depth = positiveInteger(depthOpt.value, "--depth");
   await git.clone({
@@ -980,34 +1087,49 @@ Supported commands: ${COMMANDS.join(", ")}
 }
 
 // src/sandbox/just-bash.ts
-var SANDBOX_WORKSPACE_PATH = "/workspace";
+var SANDBOX_WORKSPACE_PATH2 = "/workspace";
 function canonicalizeWorkspaceRoot(workspaceRoot) {
-  const canonicalRoot = realpathSync(workspaceRoot);
-  if (!statSync(canonicalRoot).isDirectory()) {
+  const canonicalRoot = realpathSync2(workspaceRoot);
+  if (!statSync2(canonicalRoot).isDirectory()) {
     throw new Error("The sandbox workspace root must be a directory");
   }
   return canonicalRoot;
 }
-function createWorkspaceFs(workspaceRoot) {
+function createWorkspaceFs(workspaceRoot, options) {
   const root = canonicalizeWorkspaceRoot(workspaceRoot);
+  const workspaceMountPoint = options.workspaceMountPoint ?? SANDBOX_WORKSPACE_PATH2;
+  validateSandboxPath(workspaceMountPoint, "Workspace mount point");
+  const additionalMounts = validateSandboxMounts(options.mounts ?? [], {
+    reservedMountPoint: workspaceMountPoint
+  }).map((mount) => ({
+    mountPoint: mount.mountPoint,
+    filesystem: new ReadWriteFs({ root: mount.hostPath, allowSymlinks: false })
+  }));
   return new MountableFs({
     base: new InMemoryFs(),
     mounts: [
       {
-        mountPoint: SANDBOX_WORKSPACE_PATH,
+        mountPoint: workspaceMountPoint,
         filesystem: new ReadWriteFs({ root, allowSymlinks: false })
-      }
+      },
+      ...additionalMounts
     ]
   });
 }
 function createJustBash(workspaceRoot, options = {}) {
+  const workspaceMountPoint = options.workspaceMountPoint ?? SANDBOX_WORKSPACE_PATH2;
+  const sandboxCwd = options.sandboxCwd ?? workspaceMountPoint;
+  validateSandboxPath(sandboxCwd, "Sandbox cwd");
+  const configuredMountPoints = [workspaceMountPoint, ...(options.mounts ?? []).map((m) => m.mountPoint)];
+  if (!configuredMountPoints.some((mountPoint) => sandboxPathContains(mountPoint, sandboxCwd))) {
+    throw new CliError(
+      `Sandbox cwd ${sandboxCwd} is not contained by the primary workspace or any configured mount.`
+    );
+  }
   return new Bash({
-    fs: createWorkspaceFs(workspaceRoot),
-    cwd: SANDBOX_WORKSPACE_PATH,
-    env: {
-      HOME: "/home/user",
-      TERM: "xterm-256color"
-    },
+    fs: createWorkspaceFs(workspaceRoot, options),
+    cwd: sandboxCwd,
+    env: { HOME: "/home/user", TERM: "xterm-256color" },
     python: true,
     javascript: true,
     customCommands: options.git === false ? [] : [createGitCommand(options.git)],
@@ -1104,7 +1226,11 @@ async function runExecCommand(cwd, command, options, signal) {
   const combinedSignal = combineSignals([signal, timeout.signal]);
   const timedOut = () => timeout.signal.aborted && !signal?.aborted;
   try {
-    const bash = createJustBash(cwd);
+    const bash = createJustBash(cwd, {
+      workspaceMountPoint: options.workspaceMountPoint,
+      sandboxCwd: options.sandboxCwd,
+      mounts: options.mounts
+    });
     const result = await bash.exec(command, { env: options.env, signal: combinedSignal });
     return {
       ...result,
@@ -1353,7 +1479,7 @@ var ExecutorController = class {
 // src/executor/daytona.ts
 import { randomUUID } from "crypto";
 import { mkdir, readdir, readFile, rm, stat as stat3, writeFile } from "fs/promises";
-import { dirname, isAbsolute, relative, resolve as resolve2, sep } from "path";
+import { dirname, isAbsolute, relative, resolve as resolve3, sep } from "path";
 import {
   Daytona,
   DaytonaProcessExecutionTimeoutError
@@ -1388,7 +1514,7 @@ async function listLocalFiles(root) {
   const files = /* @__PURE__ */ new Map();
   async function visit(directory) {
     for (const entry of await readdir(directory, { withFileTypes: true })) {
-      const absolutePath = resolve2(directory, entry.name);
+      const absolutePath = resolve3(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile()) {
@@ -1403,12 +1529,14 @@ async function listLocalFiles(root) {
 var DaytonaSandbox = class {
   #sandbox;
   #workspacePath;
+  #workingDirectory;
   #commandTimeoutMs;
   #signal;
   #disposed = false;
   constructor(sandbox, options) {
     this.#sandbox = sandbox;
     this.#workspacePath = options.workspacePath;
+    this.#workingDirectory = options.workingDirectory ?? options.workspacePath;
     this.#commandTimeoutMs = options.commandTimeoutMs;
     this.#signal = options.signal;
   }
@@ -1425,7 +1553,7 @@ ${marker}
       const response = await abortable(
         this.#sandbox.process.executeCommand(
           wrapped,
-          this.#workspacePath,
+          this.#workingDirectory,
           void 0,
           timeoutSeconds(this.#commandTimeoutMs)
         ),
@@ -1472,7 +1600,7 @@ ${marker}
     this.#disposed = true;
   }
   #resolvePath(path) {
-    const target = isAbsolute(path) ? resolve2(path) : resolve2(this.#workspacePath, path);
+    const target = isAbsolute(path) ? resolve3(path) : resolve3(this.#workingDirectory, path);
     if (target !== this.#workspacePath && !target.startsWith(`${this.#workspacePath}/`)) {
       throw new Error(`Path is outside the Daytona workspace: ${path}`);
     }
@@ -1488,7 +1616,7 @@ var DaytonaWorkspaceSynchronizer = class {
   #sandbox;
   #knownFiles = /* @__PURE__ */ new Set();
   constructor(cwd, remoteWorkspacePath, sandbox) {
-    this.#cwd = resolve2(cwd);
+    this.#cwd = resolve3(cwd);
     this.#remoteWorkspacePath = remoteWorkspacePath;
     this.#sandbox = sandbox;
   }
@@ -1519,7 +1647,7 @@ var DaytonaWorkspaceSynchronizer = class {
     for (const [path, size] of localFiles) {
       signal?.throwIfAborted();
       await abortable(
-        this.#sandbox.fs.uploadFile(resolve2(this.#cwd, path), this.#remotePath(path)),
+        this.#sandbox.fs.uploadFile(resolve3(this.#cwd, path), this.#remotePath(path)),
         signal
       );
       if (this.#knownFiles.has(path)) filesUpdated++;
@@ -1551,7 +1679,7 @@ var DaytonaWorkspaceSynchronizer = class {
     let bytesTransferred = 0;
     for (const path of this.#knownFiles) {
       if (remoteFiles.has(path)) continue;
-      await rm(resolve2(this.#cwd, path), { force: true });
+      await rm(resolve3(this.#cwd, path), { force: true });
       filesDeleted++;
     }
     for (const path of remoteFiles) {
@@ -1581,7 +1709,7 @@ var DaytonaWorkspaceSynchronizer = class {
     return `${this.#remoteWorkspacePath}/${path}`;
   }
   #localPath(path) {
-    const target = resolve2(this.#cwd, path);
+    const target = resolve3(this.#cwd, path);
     if (target !== this.#cwd && !target.startsWith(`${this.#cwd}${sep}`)) {
       throw new Error(`Daytona returned a path outside the workspace: ${path}`);
     }
@@ -1606,16 +1734,24 @@ var DaytonaExecutorSession = class {
   #disposed = false;
   constructor(remote, options, signal) {
     const workspacePath = options.remoteWorkspacePath ?? DEFAULT_REMOTE_WORKSPACE;
+    const relativeCwd = options.relativeCwd ?? ".";
+    const workingDirectory = resolve3(workspacePath, relativeCwd);
     this.#remote = remote;
     this.#synchronizer = new DaytonaWorkspaceSynchronizer(options.cwd, workspacePath, remote);
     this.sandbox = new DaytonaSandbox(remote, {
       workspacePath,
+      workingDirectory,
       commandTimeoutMs: options.commandTimeoutMs,
       signal
     });
     this.context = {
       kind: "daytona",
       workspacePath,
+      ...options.relativeCwd !== void 0 ? {
+        workingDirectory,
+        cwdPreserved: options.relativeCwd !== null,
+        ...options.relativeCwd === null ? { cwdLimitation: "The selected sandbox cwd is on an additional mount; starting at the effective workspace root." } : {}
+      } : {},
       isolated: true,
       networkAccess: "full"
     };
@@ -1715,7 +1851,7 @@ Terminus-2 spirit:
 - Summarize final findings and important command results clearly.
 
 Runtime context:
-- Working directory: ${SANDBOX_WORKSPACE_PATH}
+- Working directory: ${options.sandboxCwd ?? "/workspace"}
 - Current time: ${options.now.toISOString()}
 - Maximum model/tool steps: ${options.maxSteps}
 - Per-command timeout: ${options.commandTimeoutMs} ms
@@ -1738,17 +1874,20 @@ Tool policy:
 }
 function buildDelegatedSystemPrompt(options) {
   const executionBoundary = options.context.isolated ? "Commands run natively inside an isolated remote environment." : "Commands run natively with the current user's permissions and are not isolated.";
+  const cwdNote = options.context.cwdLimitation ? `
+- Working-directory limitation: ${options.context.cwdLimitation}` : "";
   return `You are Ollie's delegated execution agent. Complete one bounded task using native workspace tools.
 
 Runtime context:
 - Workspace root: ${options.context.workspacePath}
+- Working directory: ${options.context.workingDirectory ?? options.context.workspacePath}${cwdNote}
 - Current time: ${options.now.toISOString()}
 - Maximum model/tool steps: ${options.maxSteps}
 - Per-command timeout: ${options.commandTimeoutMs} ms
 - ${executionBoundary}
 
 Operating rules:
-- Start at the workspace root and use relative paths for workspace files.
+- Start at the configured working directory and use relative paths for workspace files.
 - Inspect the relevant state before making changes.
 - Keep changes minimal and directly related to the delegated task.
 - Run appropriate native checks or tests and report their actual results.
@@ -1770,8 +1909,12 @@ async function createWorkspaceTools(options) {
 }
 async function createTools(options) {
   return createWorkspaceTools({
-    sandbox: createJustBash(options.cwd),
-    destination: SANDBOX_WORKSPACE_PATH,
+    sandbox: createJustBash(options.cwd, {
+      mounts: options.mounts,
+      workspaceMountPoint: options.workspaceMountPoint,
+      sandboxCwd: options.sandboxCwd
+    }),
+    destination: options.sandboxCwd ?? options.workspaceMountPoint ?? SANDBOX_WORKSPACE_PATH2,
     maxOutputBytes: options.maxOutputBytes,
     extraInstructions: "Use bash commands to inspect files, search, run tests, and gather terminal state. Sandbox-native git is available; local Git changes persist in the workspace, and git push has permanent remote effects, so destructive actions and pushes must only be used when explicitly requested. Keep commands bounded."
   });
@@ -1796,9 +1939,9 @@ var ModelTaskDelegator = class {
     });
     const tools = await createWorkspaceTools({
       sandbox: session.sandbox,
-      destination: session.context.workspacePath,
+      destination: session.context.workingDirectory ?? session.context.workspacePath,
       maxOutputBytes: this.options.maxOutputBytes,
-      extraInstructions: "Use the native workspace tools to complete the delegated task. Start at the workspace root, use relative paths, keep changes focused, and verify the result before reporting it."
+      extraInstructions: "Use the native workspace tools to complete the delegated task. Use relative paths from the configured working directory, keep changes focused, and verify the result before reporting it."
     });
     const result = await generateText({
       model: this.options.model,
@@ -1846,7 +1989,7 @@ var ModelTaskDelegator = class {
 // src/executor/local.ts
 import { spawn } from "child_process";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
 var LocalSandbox = class {
   #cwd;
   #commandTimeoutMs;
@@ -1855,7 +1998,7 @@ var LocalSandbox = class {
   #processes = /* @__PURE__ */ new Set();
   #disposed = false;
   constructor(options, signal) {
-    this.#cwd = resolve3(options.cwd);
+    this.#cwd = resolve4(options.cwd, options.relativeCwd ?? ".");
     this.#commandTimeoutMs = options.commandTimeoutMs;
     this.#env = options.env ?? process.env;
     this.#signal = signal;
@@ -1968,7 +2111,7 @@ var LocalSandbox = class {
     this.#processes.clear();
   }
   #resolvePath(path) {
-    return isAbsolute2(path) ? path : resolve3(this.#cwd, path);
+    return isAbsolute2(path) ? path : resolve4(this.#cwd, path);
   }
   #assertActive() {
     if (this.#disposed) throw new Error("Local executor session has been disposed");
@@ -1979,11 +2122,17 @@ var LocalExecutorSession = class {
   context;
   #disposed = false;
   constructor(options, signal) {
-    const workspacePath = resolve3(options.cwd);
+    const workspacePath = resolve4(options.cwd);
+    const workingDirectory = resolve4(workspacePath, options.relativeCwd ?? ".");
     this.sandbox = new LocalSandbox(options, signal);
     this.context = {
       kind: "local",
       workspacePath,
+      ...options.relativeCwd !== void 0 ? {
+        workingDirectory,
+        cwdPreserved: options.relativeCwd !== null,
+        ...options.relativeCwd === null ? { cwdLimitation: "The selected sandbox cwd is on an additional mount; starting at the effective workspace root." } : {}
+      } : {},
       isolated: false,
       networkAccess: "full"
     };
@@ -2077,11 +2226,13 @@ function createExecutorProvider(options) {
     case "local":
       return new LocalExecutorProvider({
         cwd: options.cwd,
+        relativeCwd: options.workspaceRelativeCwd,
         commandTimeoutMs: options.commandTimeoutMs
       });
     case "daytona":
       return new DaytonaExecutorProvider({
         cwd: options.cwd,
+        relativeCwd: options.workspaceRelativeCwd,
         commandTimeoutMs: options.commandTimeoutMs,
         snapshot: process.env.OLLIE_DAYTONA_SNAPSHOT
       });
@@ -2096,6 +2247,9 @@ async function runOneShot(options) {
     });
     const workspaceTools = await createTools({
       cwd: options.cwd,
+      workspaceMountPoint: options.workspaceMountPoint,
+      sandboxCwd: options.sandboxCwd,
+      mounts: options.mounts,
       maxOutputBytes: options.maxOutputBytes
     });
     const executorProvider = createExecutorProvider(options);
@@ -2122,6 +2276,7 @@ async function runOneShot(options) {
         now: /* @__PURE__ */ new Date(),
         maxSteps: options.maxSteps,
         commandTimeoutMs: options.commandTimeoutMs,
+        sandboxCwd: options.sandboxCwd,
         executorInstructions: executorProvider?.systemPrompt
       }),
       prompt: options.prompt,
@@ -2173,7 +2328,7 @@ async function runOneShot(options) {
 
 // src/sandbox/runtime.ts
 import { once } from "events";
-import { posix as posix3 } from "path";
+import { posix as posix5 } from "path";
 import { createInterface } from "readline";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2211,7 +2366,7 @@ function requireString(params, name) {
   return value;
 }
 function validateVirtualPath(path) {
-  if (!posix3.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix3.normalize(path) !== path || path.split("/").some((component) => component === "." || component === "..")) {
+  if (!posix5.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix5.normalize(path) !== path || path.split("/").some((component) => component === "." || component === "..")) {
     throw new Error("Path must be a normalized absolute virtual path");
   }
   return path;
@@ -2272,7 +2427,11 @@ async function runWorker(options = {}) {
   const workspaceRoot = options.cwd ?? process.cwd();
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
-  const bash = createJustBash(workspaceRoot);
+  const bash = createJustBash(workspaceRoot, {
+    mounts: options.mounts,
+    workspaceMountPoint: options.workspaceMountPoint,
+    sandboxCwd: options.sandboxCwd
+  });
   const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
   const close = () => lines.close();
   if (options.signal?.aborted) {
@@ -2321,7 +2480,17 @@ function truncateText(input, maxBytes) {
 
 // src/cli-program.ts
 function addExecOptions(command, ndjsonDescription = "emit one JSON result record") {
-  return command.option("--cwd <path>", "working directory").option("--timeout <ms>", "command timeout in milliseconds").option("--max-output <bytes>", "maximum retained output").option("--ndjson", ndjsonDescription);
+  return addMountOption(command.option("--cwd <host-path>", "host workspace mounted at /workspace").option("--sandbox-cwd <sandbox-path>", "initial working directory inside the sandbox")).option("--timeout <ms>", "command timeout in milliseconds").option("--max-output <bytes>", "maximum retained output").option("--ndjson", ndjsonDescription);
+}
+function collectOption(value, previous) {
+  return [...previous ?? [], value];
+}
+function addMountOption(command) {
+  return command.option(
+    "--mount <host-path:sandbox-path>",
+    "mount a host directory read-write (repeatable)",
+    collectOption
+  );
 }
 function addAgentOptions(command) {
   return addExecOptions(command, "emit newline-delimited JSON event records").option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option(
@@ -2330,12 +2499,20 @@ function addAgentOptions(command) {
     "none"
   ).option("--max-steps <number>", "maximum model/tool steps").option("--no-color", "disable color output");
 }
+function warnImplicitCwd(usedImplicitCwd) {
+  if (usedImplicitCwd) {
+    process.stderr.write(
+      "Warning: omitting --cwd and --sandbox-cwd is deprecated; currently using --cwd .\n"
+    );
+  }
+}
 async function runAgent(promptParts, options) {
   const prompt = promptParts.join(" ").trim();
   if (!prompt) {
     throw new CliError('A prompt is required. Example: ollie agent "summarize this repository"');
   }
   const config = await resolveRunConfig(options);
+  warnImplicitCwd(config.usedImplicitCwd);
   const renderer = createRenderer({ ndjson: config.ndjson, color: config.color });
   const controller = new AbortController();
   const onSigint = () => controller.abort();
@@ -2358,6 +2535,7 @@ async function runExec(commandParts, options) {
     throw new CliError('A command is required. Example: ollie "pwd && ls -la"');
   }
   const config = await resolveRunConfig(options);
+  warnImplicitCwd(config.usedImplicitCwd);
   const controller = new AbortController();
   let signalExitCode;
   const onSigint = () => {
@@ -2376,7 +2554,10 @@ async function runExec(commandParts, options) {
       shellCommand,
       {
         timeoutMs: config.commandTimeoutMs,
-        env: process.env
+        env: process.env,
+        workspaceMountPoint: config.workspaceMountPoint,
+        sandboxCwd: config.sandboxCwd,
+        mounts: config.mounts
       },
       controller.signal
     );
@@ -2415,6 +2596,8 @@ async function runExec(commandParts, options) {
   }
 }
 async function runSandbox(options) {
+  const config = await resolveRunConfig(options);
+  warnImplicitCwd(config.usedImplicitCwd);
   const controller = new AbortController();
   let signalExitCode;
   const onSigint = () => {
@@ -2429,7 +2612,10 @@ async function runSandbox(options) {
   process.once("SIGTERM", onSigterm);
   try {
     await runWorker({
-      cwd: options.cwd,
+      cwd: config.cwd,
+      workspaceMountPoint: config.workspaceMountPoint,
+      sandboxCwd: config.sandboxCwd,
+      mounts: config.mounts,
       signal: controller.signal
     });
     if (signalExitCode !== void 0) {
@@ -2458,7 +2644,10 @@ function createProgram() {
   agent.action(async (prompt, options) => {
     await runAgent(prompt, options);
   });
-  program.command("sandbox").description("run the persistent sandbox NDJSON command interface").option("--cwd <path>", "working directory").action(async (options) => {
+  const sandbox = addMountOption(
+    program.command("sandbox").description("run the persistent sandbox NDJSON command interface").option("--cwd <host-path>", "host workspace mounted at /workspace").option("--sandbox-cwd <sandbox-path>", "initial working directory inside the sandbox")
+  );
+  sandbox.action(async (options) => {
     await runSandbox(options);
   });
   program.command("doctor").description("validate the local Ollie setup without making model calls").option("--cwd <path>", "working directory").option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option("--json", "emit JSON report").action(async (options) => {
@@ -2468,7 +2657,13 @@ function createProgram() {
   return program;
 }
 var RESERVED_SUBCOMMANDS = /* @__PURE__ */ new Set(["agent", "sandbox", "doctor"]);
-var ROOT_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["--cwd", "--timeout", "--max-output"]);
+var ROOT_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set([
+  "--cwd",
+  "--sandbox-cwd",
+  "--mount",
+  "--timeout",
+  "--max-output"
+]);
 function rootBoundaryPrecedesCommand(args) {
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index] ?? "";