@getollie/cli 0.2.2 → 0.2.3

package/dist/cli.js

@@ -7,12 +7,8 @@ import { CommanderError } from "commander";
 import { Command } from "commander";
 
 // src/config.ts
-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";
+import { access, stat } from "fs/promises";
+import { resolve } from "path";
 
 // src/utils/errors.ts
 var CliError = class extends Error {
@@ -30,68 +26,6 @@ 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";
@@ -100,7 +34,9 @@ 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`);
@@ -117,82 +53,39 @@ function parseExecutor(value) {
   }
   return executor;
 }
-async function resolveHostDirectory(value, label) {
-  const absolute = resolve2(value);
-  const stats = await stat(absolute).catch(() => null);
-  if (!stats?.isDirectory()) {
-    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);
-  }
-  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 cwd = resolve(input.cwd ?? env.OLLIE_CWD ?? process.cwd());
+  const stats = await stat(cwd).catch(() => null);
+  if (!stats?.isDirectory()) {
+    throw new CliError(`Working directory does not exist or is not a directory: ${cwd}`);
   }
-  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;
+  await access(cwd);
   const executor = parseExecutor(input.executor ?? env.OLLIE_EXECUTOR);
   return {
-    cwd: workspace.hostPath,
-    workspaceMountPoint: workspace.mountPoint,
-    sandboxCwd,
-    workspaceRelativeCwd,
-    mounts,
-    usedImplicitCwd,
+    cwd,
     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
     ),
@@ -206,23 +99,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 as realpathSync2, statSync as statSync2 } from "fs";
+import { realpathSync, statSync } from "fs";
 import { Bash, InMemoryFs, MountableFs, ReadWriteFs } from "just-bash";
 
 // src/sandbox/git/index.ts
-import { posix as posix4 } from "path";
+import { posix as posix2 } 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 posix3 } from "path";
+import { posix } 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 = posix3.resolve(path);
+  const normalized = posix.resolve(path);
   if (normalized !== ROOT && !normalized.startsWith(`${ROOT}/`)) {
     throw Object.assign(new Error("Git path is outside /workspace"), { code: "EACCES" });
   }
@@ -242,7 +135,7 @@ function normalizeError(error) {
   throw Object.assign(new Error("Virtual filesystem operation failed"), { code: "EIO" });
 }
 async function ensureParent(fs, path) {
-  const parent = posix3.dirname(path);
+  const parent = posix.dirname(path);
   if (!await fs.exists(parent)) await fs.mkdir(parent, { recursive: true });
 }
 function statShape(stat4) {
@@ -477,9 +370,9 @@ function virtualPath(ctx, input = ".") {
 async function repositoryDir(ctx) {
   let current = virtualPath(ctx);
   while (current === WORKSPACE || current.startsWith(`${WORKSPACE}/`)) {
-    if (await ctx.fs.exists(posix4.join(current, ".git"))) return current;
+    if (await ctx.fs.exists(posix2.join(current, ".git"))) return current;
     if (current === WORKSPACE) break;
-    current = posix4.dirname(current);
+    current = posix2.dirname(current);
   }
   throw new Error("not a git repository (or any parent up to /workspace)");
 }
@@ -562,7 +455,7 @@ async function writeGlobalConfig(ctx, values) {
     ([section, entries]) => `[${section}]
 ${entries.map(([key, value]) => `	${key} = ${value}`).join("\n")}`
   ).join("\n");
-  await ctx.fs.mkdir(posix4.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
+  await ctx.fs.mkdir(posix2.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
   await ctx.fs.writeFile(GLOBAL_CONFIG_PATH, content ? `${content}
 ` : "");
 }
@@ -576,7 +469,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 ${posix4.join(dir, ".git")}/
+  return ok(`Initialized empty Git repository in ${posix2.join(dir, ".git")}/
 `);
 }
 async function handleStatus(context, args) {
@@ -729,7 +622,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(posix4.join(dir, filepath));
+    const newBytes = cachedFlag.enabled ? await readStage(filepath) : workdirStatus === 0 ? empty : await context.command.fs.readFileBuffer(posix2.join(dir, filepath));
     patches.push(patch(filepath, oldBytes, newBytes));
   }
   return ok(patches.join(""));
@@ -796,7 +689,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(posix4.join(dir, filepath), blob);
+      await context.command.fs.writeFile(posix2.join(dir, filepath), blob);
     }
     return ok();
   }
@@ -923,7 +816,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 = posix4.basename(new URL(url).pathname).replace(/\.git$/, "") || "repository";
+  const inferred = posix2.basename(new URL(url).pathname).replace(/\.git$/, "") || "repository";
   const dir = virtualPath(context.command, destination ?? inferred);
   const depth = positiveInteger(depthOpt.value, "--depth");
   await git.clone({
@@ -1087,49 +980,34 @@ Supported commands: ${COMMANDS.join(", ")}
 }
 
 // src/sandbox/just-bash.ts
-var SANDBOX_WORKSPACE_PATH2 = "/workspace";
+var SANDBOX_WORKSPACE_PATH = "/workspace";
 function canonicalizeWorkspaceRoot(workspaceRoot) {
-  const canonicalRoot = realpathSync2(workspaceRoot);
-  if (!statSync2(canonicalRoot).isDirectory()) {
+  const canonicalRoot = realpathSync(workspaceRoot);
+  if (!statSync(canonicalRoot).isDirectory()) {
     throw new Error("The sandbox workspace root must be a directory");
   }
   return canonicalRoot;
 }
-function createWorkspaceFs(workspaceRoot, options) {
+function createWorkspaceFs(workspaceRoot) {
   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: workspaceMountPoint,
+        mountPoint: SANDBOX_WORKSPACE_PATH,
         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, options),
-    cwd: sandboxCwd,
-    env: { HOME: "/home/user", TERM: "xterm-256color" },
+    fs: createWorkspaceFs(workspaceRoot),
+    cwd: SANDBOX_WORKSPACE_PATH,
+    env: {
+      HOME: "/home/user",
+      TERM: "xterm-256color"
+    },
     python: true,
     javascript: true,
     customCommands: options.git === false ? [] : [createGitCommand(options.git)],
@@ -1226,11 +1104,7 @@ 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, {
-      workspaceMountPoint: options.workspaceMountPoint,
-      sandboxCwd: options.sandboxCwd,
-      mounts: options.mounts
-    });
+    const bash = createJustBash(cwd);
     const result = await bash.exec(command, { env: options.env, signal: combinedSignal });
     return {
       ...result,
@@ -1479,7 +1353,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 resolve3, sep } from "path";
+import { dirname, isAbsolute, relative, resolve as resolve2, sep } from "path";
 import {
   Daytona,
   DaytonaProcessExecutionTimeoutError
@@ -1514,7 +1388,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 = resolve3(directory, entry.name);
+      const absolutePath = resolve2(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile()) {
@@ -1529,14 +1403,12 @@ 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;
   }
@@ -1553,7 +1425,7 @@ ${marker}
       const response = await abortable(
         this.#sandbox.process.executeCommand(
           wrapped,
-          this.#workingDirectory,
+          this.#workspacePath,
           void 0,
           timeoutSeconds(this.#commandTimeoutMs)
         ),
@@ -1600,7 +1472,7 @@ ${marker}
     this.#disposed = true;
   }
   #resolvePath(path) {
-    const target = isAbsolute(path) ? resolve3(path) : resolve3(this.#workingDirectory, path);
+    const target = isAbsolute(path) ? resolve2(path) : resolve2(this.#workspacePath, path);
     if (target !== this.#workspacePath && !target.startsWith(`${this.#workspacePath}/`)) {
       throw new Error(`Path is outside the Daytona workspace: ${path}`);
     }
@@ -1616,7 +1488,7 @@ var DaytonaWorkspaceSynchronizer = class {
   #sandbox;
   #knownFiles = /* @__PURE__ */ new Set();
   constructor(cwd, remoteWorkspacePath, sandbox) {
-    this.#cwd = resolve3(cwd);
+    this.#cwd = resolve2(cwd);
     this.#remoteWorkspacePath = remoteWorkspacePath;
     this.#sandbox = sandbox;
   }
@@ -1647,7 +1519,7 @@ var DaytonaWorkspaceSynchronizer = class {
     for (const [path, size] of localFiles) {
       signal?.throwIfAborted();
       await abortable(
-        this.#sandbox.fs.uploadFile(resolve3(this.#cwd, path), this.#remotePath(path)),
+        this.#sandbox.fs.uploadFile(resolve2(this.#cwd, path), this.#remotePath(path)),
         signal
       );
       if (this.#knownFiles.has(path)) filesUpdated++;
@@ -1679,7 +1551,7 @@ var DaytonaWorkspaceSynchronizer = class {
     let bytesTransferred = 0;
     for (const path of this.#knownFiles) {
       if (remoteFiles.has(path)) continue;
-      await rm(resolve3(this.#cwd, path), { force: true });
+      await rm(resolve2(this.#cwd, path), { force: true });
       filesDeleted++;
     }
     for (const path of remoteFiles) {
@@ -1709,7 +1581,7 @@ var DaytonaWorkspaceSynchronizer = class {
     return `${this.#remoteWorkspacePath}/${path}`;
   }
   #localPath(path) {
-    const target = resolve3(this.#cwd, path);
+    const target = resolve2(this.#cwd, path);
     if (target !== this.#cwd && !target.startsWith(`${this.#cwd}${sep}`)) {
       throw new Error(`Daytona returned a path outside the workspace: ${path}`);
     }
@@ -1734,24 +1606,16 @@ 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"
     };
@@ -1851,7 +1715,7 @@ Terminus-2 spirit:
 - Summarize final findings and important command results clearly.
 
 Runtime context:
-- Working directory: ${options.sandboxCwd ?? "/workspace"}
+- Working directory: ${SANDBOX_WORKSPACE_PATH}
 - Current time: ${options.now.toISOString()}
 - Maximum model/tool steps: ${options.maxSteps}
 - Per-command timeout: ${options.commandTimeoutMs} ms
@@ -1874,20 +1738,17 @@ 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 configured working directory and use relative paths for workspace files.
+- Start at the workspace root 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.
@@ -1909,12 +1770,8 @@ async function createWorkspaceTools(options) {
 }
 async function createTools(options) {
   return createWorkspaceTools({
-    sandbox: createJustBash(options.cwd, {
-      mounts: options.mounts,
-      workspaceMountPoint: options.workspaceMountPoint,
-      sandboxCwd: options.sandboxCwd
-    }),
-    destination: options.sandboxCwd ?? options.workspaceMountPoint ?? SANDBOX_WORKSPACE_PATH2,
+    sandbox: createJustBash(options.cwd),
+    destination: SANDBOX_WORKSPACE_PATH,
     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."
   });
@@ -1939,9 +1796,9 @@ var ModelTaskDelegator = class {
     });
     const tools = await createWorkspaceTools({
       sandbox: session.sandbox,
-      destination: session.context.workingDirectory ?? session.context.workspacePath,
+      destination: session.context.workspacePath,
       maxOutputBytes: this.options.maxOutputBytes,
-      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."
+      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."
     });
     const result = await generateText({
       model: this.options.model,
@@ -1989,7 +1846,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 resolve4 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
 var LocalSandbox = class {
   #cwd;
   #commandTimeoutMs;
@@ -1998,7 +1855,7 @@ var LocalSandbox = class {
   #processes = /* @__PURE__ */ new Set();
   #disposed = false;
   constructor(options, signal) {
-    this.#cwd = resolve4(options.cwd, options.relativeCwd ?? ".");
+    this.#cwd = resolve3(options.cwd);
     this.#commandTimeoutMs = options.commandTimeoutMs;
     this.#env = options.env ?? process.env;
     this.#signal = signal;
@@ -2111,7 +1968,7 @@ var LocalSandbox = class {
     this.#processes.clear();
   }
   #resolvePath(path) {
-    return isAbsolute2(path) ? path : resolve4(this.#cwd, path);
+    return isAbsolute2(path) ? path : resolve3(this.#cwd, path);
   }
   #assertActive() {
     if (this.#disposed) throw new Error("Local executor session has been disposed");
@@ -2122,17 +1979,11 @@ var LocalExecutorSession = class {
   context;
   #disposed = false;
   constructor(options, signal) {
-    const workspacePath = resolve4(options.cwd);
-    const workingDirectory = resolve4(workspacePath, options.relativeCwd ?? ".");
+    const workspacePath = resolve3(options.cwd);
     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"
     };
@@ -2215,7 +2066,7 @@ function createLanguageModel({
     throw new CliError("OPENAI_API_KEY is required when using the openai provider.");
   }
   const openai = createOpenAI({ apiKey: env.OPENAI_API_KEY });
-  return openai(model);
+  return openai.chat(model);
 }
 
 // src/runner.ts
@@ -2226,13 +2077,11 @@ 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
       });
@@ -2247,9 +2096,6 @@ 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);
@@ -2276,7 +2122,6 @@ async function runOneShot(options) {
         now: /* @__PURE__ */ new Date(),
         maxSteps: options.maxSteps,
         commandTimeoutMs: options.commandTimeoutMs,
-        sandboxCwd: options.sandboxCwd,
         executorInstructions: executorProvider?.systemPrompt
       }),
       prompt: options.prompt,
@@ -2328,7 +2173,7 @@ async function runOneShot(options) {
 
 // src/sandbox/runtime.ts
 import { once } from "events";
-import { posix as posix5 } from "path";
+import { posix as posix3 } from "path";
 import { createInterface } from "readline";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2366,7 +2211,7 @@ function requireString(params, name) {
   return value;
 }
 function validateVirtualPath(path) {
-  if (!posix5.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix5.normalize(path) !== path || path.split("/").some((component) => component === "." || component === "..")) {
+  if (!posix3.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix3.normalize(path) !== path || path.split("/").some((component) => component === "." || component === "..")) {
     throw new Error("Path must be a normalized absolute virtual path");
   }
   return path;
@@ -2427,11 +2272,7 @@ 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,
-    workspaceMountPoint: options.workspaceMountPoint,
-    sandboxCwd: options.sandboxCwd
-  });
+  const bash = createJustBash(workspaceRoot);
   const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
   const close = () => lines.close();
   if (options.signal?.aborted) {
@@ -2480,17 +2321,7 @@ function truncateText(input, maxBytes) {
 
 // src/cli-program.ts
 function addExecOptions(command, ndjsonDescription = "emit one JSON result record") {
-  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
-  );
+  return command.option("--cwd <path>", "working directory").option("--timeout <ms>", "command timeout in milliseconds").option("--max-output <bytes>", "maximum retained output").option("--ndjson", ndjsonDescription);
 }
 function addAgentOptions(command) {
   return addExecOptions(command, "emit newline-delimited JSON event records").option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option(
@@ -2499,20 +2330,12 @@ 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();
@@ -2535,7 +2358,6 @@ 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 = () => {
@@ -2554,10 +2376,7 @@ async function runExec(commandParts, options) {
       shellCommand,
       {
         timeoutMs: config.commandTimeoutMs,
-        env: process.env,
-        workspaceMountPoint: config.workspaceMountPoint,
-        sandboxCwd: config.sandboxCwd,
-        mounts: config.mounts
+        env: process.env
       },
       controller.signal
     );
@@ -2596,8 +2415,6 @@ 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 = () => {
@@ -2612,10 +2429,7 @@ async function runSandbox(options) {
   process.once("SIGTERM", onSigterm);
   try {
     await runWorker({
-      cwd: config.cwd,
-      workspaceMountPoint: config.workspaceMountPoint,
-      sandboxCwd: config.sandboxCwd,
-      mounts: config.mounts,
+      cwd: options.cwd,
       signal: controller.signal
     });
     if (signalExitCode !== void 0) {
@@ -2644,10 +2458,7 @@ function createProgram() {
   agent.action(async (prompt, options) => {
     await runAgent(prompt, 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) => {
+  program.command("sandbox").description("run the persistent sandbox NDJSON command interface").option("--cwd <path>", "working directory").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) => {
@@ -2657,13 +2468,7 @@ function createProgram() {
   return program;
 }
 var RESERVED_SUBCOMMANDS = /* @__PURE__ */ new Set(["agent", "sandbox", "doctor"]);
-var ROOT_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set([
-  "--cwd",
-  "--sandbox-cwd",
-  "--mount",
-  "--timeout",
-  "--max-output"
-]);
+var ROOT_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["--cwd", "--timeout", "--max-output"]);
 function rootBoundaryPrecedesCommand(args) {
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index] ?? "";