@getollie/cli 0.2.1 → 0.2.2

package/dist/cli.js

@@ -7,8 +7,8 @@ import { CommanderError } from "commander";
 import { Command } from "commander";
 
 // src/config.ts
-import { access, stat } from "fs/promises";
-import { resolve as resolve2 } 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";
@@ -32,36 +32,43 @@ function getErrorMessage(error) {
 
 // src/sandbox/mounts.ts
 var SANDBOX_WORKSPACE_PATH = "/workspace";
-function pathsOverlap(left, right) {
+function sandboxPathsOverlap(left, right) {
   return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
 }
-function validateMountPoint(mountPoint) {
-  if (!posix.isAbsolute(mountPoint) || mountPoint === "/" || mountPoint.includes("\\") || mountPoint.includes("\0") || posix.normalize(mountPoint) !== mountPoint) {
-    throw new CliError(
-      `Mount point must be a normalized absolute sandbox path other than /: ${mountPoint}`
-    );
+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}`);
   }
-  if (pathsOverlap(mountPoint, SANDBOX_WORKSPACE_PATH)) {
-    throw new CliError(`Mount point must be outside ${SANDBOX_WORKSPACE_PATH}: ${mountPoint}`);
+  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) {
+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");
-      }
+      if (!statSync(hostPath).isDirectory()) throw new Error("not a directory");
     } catch {
       throw new CliError(
-        `Mount source does not exist or is not a directory: ${resolve(mount.hostPath)}`
+        `Mount source host path does not exist or is not a directory: ${resolve(mount.hostPath)}`
       );
     }
     const conflict = validated.find(
-      (candidate) => pathsOverlap(candidate.mountPoint, mount.mountPoint)
+      (candidate) => sandboxPathsOverlap(candidate.mountPoint, mount.mountPoint)
     );
     if (conflict) {
       throw new CliError(
@@ -72,7 +79,7 @@ function validateSandboxMounts(mounts) {
   }
   return validated;
 }
-function parseSandboxMounts(specs = []) {
+function parseSandboxMounts(specs = [], options) {
   const mounts = specs.map((spec) => {
     const separator = spec.lastIndexOf(":");
     if (separator <= 0 || separator === spec.length - 1) {
@@ -80,12 +87,9 @@ function parseSandboxMounts(specs = []) {
         `Invalid mount ${JSON.stringify(spec)}. Expected <host-path>:<sandbox-path>`
       );
     }
-    return {
-      hostPath: spec.slice(0, separator),
-      mountPoint: spec.slice(separator + 1)
-    };
+    return { hostPath: spec.slice(0, separator), mountPoint: spec.slice(separator + 1) };
   });
-  return validateSandboxMounts(mounts);
+  return validateSandboxMounts(mounts, options);
 }
 
 // src/config.ts
@@ -96,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`);
@@ -115,40 +117,82 @@ function parseExecutor(value) {
   }
   return executor;
 }
-async function resolveRunConfig(input = {}, env = process.env) {
-  const cwd = resolve2(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(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);
   }
-  await access(cwd);
+  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,
-    mounts: parseSandboxMounts(input.mount),
+    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
     ),
@@ -166,19 +210,19 @@ 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 posix3 } 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 as posix2 } 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 = posix2.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" });
   }
@@ -198,7 +242,7 @@ function normalizeError(error) {
   throw Object.assign(new Error("Virtual filesystem operation failed"), { code: "EIO" });
 }
 async function ensureParent(fs, path) {
-  const parent = posix2.dirname(path);
+  const parent = posix3.dirname(path);
   if (!await fs.exists(parent)) await fs.mkdir(parent, { recursive: true });
 }
 function statShape(stat4) {
@@ -433,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(posix3.join(current, ".git"))) return current;
+    if (await ctx.fs.exists(posix4.join(current, ".git"))) return current;
     if (current === WORKSPACE) break;
-    current = posix3.dirname(current);
+    current = posix4.dirname(current);
   }
   throw new Error("not a git repository (or any parent up to /workspace)");
 }
@@ -518,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(posix3.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}
 ` : "");
 }
@@ -532,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 ${posix3.join(dir, ".git")}/
+  return ok(`Initialized empty Git repository in ${posix4.join(dir, ".git")}/
 `);
 }
 async function handleStatus(context, args) {
@@ -685,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(posix3.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(""));
@@ -752,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(posix3.join(dir, filepath), blob);
+      await context.command.fs.writeFile(posix4.join(dir, filepath), blob);
     }
     return ok();
   }
@@ -879,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 = posix3.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({
@@ -1053,7 +1097,11 @@ function canonicalizeWorkspaceRoot(workspaceRoot) {
 }
 function createWorkspaceFs(workspaceRoot, options) {
   const root = canonicalizeWorkspaceRoot(workspaceRoot);
-  const additionalMounts = validateSandboxMounts(options.mounts ?? []).map((mount) => ({
+  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 })
   }));
@@ -1061,7 +1109,7 @@ function createWorkspaceFs(workspaceRoot, options) {
     base: new InMemoryFs(),
     mounts: [
       {
-        mountPoint: SANDBOX_WORKSPACE_PATH2,
+        mountPoint: workspaceMountPoint,
         filesystem: new ReadWriteFs({ root, allowSymlinks: false })
       },
       ...additionalMounts
@@ -1069,13 +1117,19 @@ function createWorkspaceFs(workspaceRoot, options) {
   });
 }
 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, options),
-    cwd: SANDBOX_WORKSPACE_PATH2,
-    env: {
-      HOME: "/home/user",
-      TERM: "xterm-256color"
-    },
+    cwd: sandboxCwd,
+    env: { HOME: "/home/user", TERM: "xterm-256color" },
     python: true,
     javascript: true,
     customCommands: options.git === false ? [] : [createGitCommand(options.git)],
@@ -1172,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,
@@ -1471,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;
   }
@@ -1493,7 +1553,7 @@ ${marker}
       const response = await abortable(
         this.#sandbox.process.executeCommand(
           wrapped,
-          this.#workspacePath,
+          this.#workingDirectory,
           void 0,
           timeoutSeconds(this.#commandTimeoutMs)
         ),
@@ -1540,7 +1600,7 @@ ${marker}
     this.#disposed = true;
   }
   #resolvePath(path) {
-    const target = isAbsolute(path) ? resolve3(path) : resolve3(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}`);
     }
@@ -1674,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"
     };
@@ -1783,7 +1851,7 @@ Terminus-2 spirit:
 - Summarize final findings and important command results clearly.
 
 Runtime context:
-- Working directory: ${SANDBOX_WORKSPACE_PATH2}
+- Working directory: ${options.sandboxCwd ?? "/workspace"}
 - Current time: ${options.now.toISOString()}
 - Maximum model/tool steps: ${options.maxSteps}
 - Per-command timeout: ${options.commandTimeoutMs} ms
@@ -1806,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.
@@ -1838,8 +1909,12 @@ async function createWorkspaceTools(options) {
 }
 async function createTools(options) {
   return createWorkspaceTools({
-    sandbox: createJustBash(options.cwd, { mounts: options.mounts }),
-    destination: SANDBOX_WORKSPACE_PATH2,
+    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."
   });
@@ -1864,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,
@@ -1923,7 +1998,7 @@ var LocalSandbox = class {
   #processes = /* @__PURE__ */ new Set();
   #disposed = false;
   constructor(options, signal) {
-    this.#cwd = resolve4(options.cwd);
+    this.#cwd = resolve4(options.cwd, options.relativeCwd ?? ".");
     this.#commandTimeoutMs = options.commandTimeoutMs;
     this.#env = options.env ?? process.env;
     this.#signal = signal;
@@ -2048,10 +2123,16 @@ var LocalExecutorSession = class {
   #disposed = false;
   constructor(options, signal) {
     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"
     };
@@ -2145,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
       });
@@ -2164,6 +2247,8 @@ async function runOneShot(options) {
     });
     const workspaceTools = await createTools({
       cwd: options.cwd,
+      workspaceMountPoint: options.workspaceMountPoint,
+      sandboxCwd: options.sandboxCwd,
       mounts: options.mounts,
       maxOutputBytes: options.maxOutputBytes
     });
@@ -2191,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,
@@ -2242,7 +2328,7 @@ async function runOneShot(options) {
 
 // src/sandbox/runtime.ts
 import { once } from "events";
-import { posix as posix4 } from "path";
+import { posix as posix5 } from "path";
 import { createInterface } from "readline";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2280,7 +2366,7 @@ function requireString(params, name) {
   return value;
 }
 function validateVirtualPath(path) {
-  if (!posix4.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix4.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;
@@ -2341,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, { mounts: options.mounts });
+  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) {
@@ -2390,7 +2480,7 @@ 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];
@@ -2403,18 +2493,26 @@ function addMountOption(command) {
   );
 }
 function addAgentOptions(command) {
-  return addMountOption(addExecOptions(command, "emit newline-delimited JSON event records")).option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option(
+  return addExecOptions(command, "emit newline-delimited JSON event records").option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option(
     "--executor <executor>",
     "delegated executor: none, local, or daytona (local is unisolated; daytona requires DAYTONA_API_KEY)",
     "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();
@@ -2437,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 = () => {
@@ -2455,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
     );
@@ -2494,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 = () => {
@@ -2508,8 +2612,10 @@ async function runSandbox(options) {
   process.once("SIGTERM", onSigterm);
   try {
     await runWorker({
-      cwd: options.cwd,
-      mounts: parseSandboxMounts(options.mount),
+      cwd: config.cwd,
+      workspaceMountPoint: config.workspaceMountPoint,
+      sandboxCwd: config.sandboxCwd,
+      mounts: config.mounts,
       signal: controller.signal
     });
     if (signalExitCode !== void 0) {
@@ -2539,7 +2645,7 @@ function createProgram() {
     await runAgent(prompt, options);
   });
   const sandbox = addMountOption(
-    program.command("sandbox").description("run the persistent sandbox NDJSON command interface").option("--cwd <path>", "working directory")
+    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);
@@ -2551,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] ?? "";