Let a bot have a working folder

electron/capabilities.cjs

@@ -32,6 +32,7 @@ function desktopCapabilities({
   env = process.env,
   packaged = false,
   localConnection = null,
+  homeDir = require("node:os").homedir(),
 } = {}) {
   const hostPlatform = normalizedPlatform(platform);
   const isMac = hostPlatform === "darwin";
@@ -69,6 +70,9 @@ function desktopCapabilities({
               : "Desktop",
       session: linuxSession(hostPlatform, env),
       packaged: Boolean(packaged),
+      // so the renderer can show paths as ~/… without a Node builtin in
+      // the sandboxed preload
+      homeDir,
     },
     windowChrome: isMac ? "mac-inset" : "native",
     screenPreview,

electron/main.mjs

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, clipboard, desktopCapturer, ipcMain, safeStorage, session, shell, systemPreferences, utilityProcess } from "electron";
+import { app, BrowserWindow, clipboard, desktopCapturer, dialog, ipcMain, safeStorage, session, shell, systemPreferences, utilityProcess } from "electron";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -299,6 +299,18 @@ ipcMain.handle("engine:open-terminal", async (_event, command) => {
 // click gesture has ended. Opening them through window.open can therefore be
 // rejected as a popup before setWindowOpenHandler ever sees the URL. Keep the
 // renderer sandboxed and let the main process open only ordinary web links.
+// A bot's working folder: the native picker, so the path is real and the
+// user never types one. Returns null when they cancel.
+ipcMain.handle("desktop:pick-folder", async (event, current) => {
+  const win = BrowserWindow.fromWebContents(event.sender) ?? undefined;
+  const result = await dialog.showOpenDialog(win, {
+    title: "Choose a working folder",
+    properties: ["openDirectory", "createDirectory"],
+    ...(typeof current === "string" && current ? { defaultPath: current } : {}),
+  });
+  return result.canceled ? null : (result.filePaths[0] ?? null);
+});
+
 ipcMain.handle("desktop:open-external", async (_event, rawUrl) => {
   if (typeof rawUrl !== "string") throw new Error("A web address is required");
   let url;

electron/preload.cjs

@@ -45,6 +45,8 @@ contextBridge.exposeInMainWorld("ogb", {
   /** Open a web link in the default browser. Unlike renderer window.open,
    * this remains reliable after an asynchronous API request. */
   openExternal: (url) => ipcRenderer.invoke("desktop:open-external", url),
+  /** Native folder picker for a bot's working folder; null when cancelled. */
+  pickFolder: (current) => ipcRenderer.invoke("desktop:pick-folder", current),
   /** Store a provider credential with OS-backed encryption. */
   setCredential: (name, value) => ipcRenderer.invoke("credential:set", name, value),
 

server/bot-cwd.test.ts

@@ -0,0 +1,36 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterAll, describe, expect, it } from "vitest";
+
+import { validateBotCwd } from "./bot-cwd.ts";
+
+const dir = mkdtempSync(join(tmpdir(), "omb-cwd-"));
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+describe("validateBotCwd", () => {
+  it("accepts an existing absolute directory", () => {
+    expect(validateBotCwd(dir)).toEqual({ ok: true, cwd: dir });
+  });
+
+  it("treats null and empty as clearing the folder", () => {
+    expect(validateBotCwd(null)).toEqual({ ok: true, cwd: null });
+    expect(validateBotCwd("")).toEqual({ ok: true, cwd: null });
+    expect(validateBotCwd("   ")).toEqual({ ok: true, cwd: null });
+  });
+
+  it("expands a leading ~ to the home folder", () => {
+    // compare against homedir() itself: a Windows home like C:\Users\RUNNER~1
+    // legitimately contains "~", so "no ~ in the output" is not a valid check
+    expect(validateBotCwd("~")).toEqual({ ok: true, cwd: resolve(homedir()) });
+  });
+
+  it("rejects relative paths, files, and missing folders with a reason", () => {
+    expect(validateBotCwd("relative/path")).toEqual({ ok: false, error: expect.stringMatching(/absolute/) });
+    const file = join(dir, "a-file.txt");
+    writeFileSync(file, "x");
+    expect(validateBotCwd(file)).toEqual({ ok: false, error: expect.stringMatching(/not a folder/) });
+    expect(validateBotCwd(join(dir, "nope"))).toEqual({ ok: false, error: expect.stringMatching(/doesn't exist/) });
+    expect(validateBotCwd(42)).toEqual({ ok: false, error: expect.stringMatching(/path/) });
+  });
+});

server/bot-cwd.ts

@@ -0,0 +1,26 @@
+// A bot's working folder — where its shell tools run. Validated here, once,
+// so a bad path is refused at PATCH time with a reason the settings panel
+// can show, rather than surfacing later as a driver spawn failure.
+import { statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+
+export type CwdValidation = { ok: true; cwd: string | null } | { ok: false; error: string };
+
+export function validateBotCwd(input: unknown): CwdValidation {
+  if (input === null) return { ok: true, cwd: null };
+  if (typeof input !== "string") return { ok: false, error: "working folder must be a path" };
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: true, cwd: null };
+  const expanded = trimmed === "~" || trimmed.startsWith("~/") ? homedir() + trimmed.slice(1) : trimmed;
+  if (!isAbsolute(expanded)) return { ok: false, error: "working folder must be an absolute path" };
+  const cwd = resolve(expanded);
+  let stat;
+  try {
+    stat = statSync(cwd);
+  } catch {
+    return { ok: false, error: `that folder doesn't exist: ${cwd}` };
+  }
+  if (!stat.isDirectory()) return { ok: false, error: `that path is not a folder: ${cwd}` };
+  return { ok: true, cwd };
+}

server/index.ts

@@ -9,6 +9,7 @@ import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { approvalKey, autoDecision } from "./auto-approve.ts";
+import { validateBotCwd } from "./bot-cwd.ts";
 import * as box from "./box.ts";
 import * as composio from "./composio.ts";
 import { chiefOfStaffSystemPrompt } from "./chief-of-staff.ts";
@@ -1006,6 +1007,9 @@ async function startTurn(
                 .join(" and ")} in their message — bring them in with ask_bot and fold their reply into your answer.`
             : ""),
         integrations,
+        // pinned per task on its first turn — see TaskRecord.cwd. A cloud
+        // run happens on the box, where a host folder means nothing.
+        cwd: opts?.runOn === "cloud" ? undefined : (store.pinTaskCwd(bot.id, threadId) ?? undefined),
       });
       // dispatched: the rewind is spent, and the old cursors are dead
       if (rewound) store.patchBot(bot.id, { rewound: false, resumeCursors: {} });
@@ -2023,6 +2027,11 @@ const server = createServer(async (req, res) => {
       if (body.chiefOfStaff !== undefined && typeof body.chiefOfStaff !== "boolean") {
         return json(res, 400, { error: "chiefOfStaff must be true or false" });
       }
+      if (body.cwd !== undefined) {
+        const checked = validateBotCwd(body.cwd);
+        if (!checked.ok) return json(res, 400, { error: checked.error });
+        patch.cwd = checked.cwd ?? undefined;
+      }
       if (body.hidden === true && existing?.chiefOfStaff && body.chiefOfStaff !== false) {
         return json(res, 400, { error: "choose another Chief of Staff before hiding this bot" });
       }

server/store.test.ts

@@ -273,3 +273,45 @@ describe("Store", () => {
     expect(reloaded.bot(bot.id)?.busy).toBe(false);
   });
 });
+
+describe("Store task working folder", () => {
+  beforeEach(() => {
+    rmSync(DATA_DIR, { recursive: true, force: true });
+  });
+
+  it("pins the bot's folder onto a task on its first turn, and never again", () => {
+    const store = new Store(selection);
+    const bot = store.createBot();
+    store.patchBot(bot.id, { cwd: "/tmp/project-a" });
+
+    // first turn: nothing pinned yet → takes the bot's folder
+    expect(store.pinTaskCwd(bot.id, bot.threadId)).toBe("/tmp/project-a");
+    expect(store.taskByThread(bot.id, bot.threadId)?.cwd).toBe("/tmp/project-a");
+
+    // the bot's folder moves on; this task stays where its session started
+    store.patchBot(bot.id, { cwd: "/tmp/project-b" });
+    expect(store.pinTaskCwd(bot.id, bot.threadId)).toBe("/tmp/project-a");
+
+    // a new task starts in the bot's current folder
+    const next = store.createTask(bot.id, "second")!;
+    expect(store.pinTaskCwd(bot.id, next.threadId)).toBe("/tmp/project-b");
+  });
+
+  it("pins the default (null) when the bot has no folder, so a later folder can't move a live session", () => {
+    const store = new Store(selection);
+    const bot = store.createBot();
+    expect(store.pinTaskCwd(bot.id, bot.threadId)).toBeNull();
+    store.patchBot(bot.id, { cwd: "/tmp/project-a" });
+    expect(store.pinTaskCwd(bot.id, bot.threadId)).toBeNull();
+    expect(store.taskByThread(bot.id, bot.threadId)?.cwd).toBeNull();
+  });
+
+  it("a legacy task that already has a session pins to the default, not the bot's new folder", () => {
+    const store = new Store(selection);
+    const bot = store.createBot();
+    // an older build ran turns here before folders existed
+    store.setResumeCursor(bot.id, "claude", "sess-1", bot.threadId);
+    store.patchBot(bot.id, { cwd: "/tmp/project-a" });
+    expect(store.pinTaskCwd(bot.id, bot.threadId)).toBeNull();
+  });
+});

server/store.ts

@@ -115,6 +115,12 @@ export interface TaskRecord {
   createdAt: number;
   /** provider-native continuation per instance, for THIS task only */
   resumeCursors: Record<string, unknown>;
+  /** the folder this task's turns run in, pinned on its first turn from
+   * the bot's `cwd` at that moment. Pinned, not read live: Claude keeps
+   * sessions per project directory and Codex threads carry their cwd, so
+   * a folder that moved under a live session would break resume. `null`
+   * = pinned to the default (home); absent = not pinned yet. */
+  cwd?: string | null;
 }
 
 /** What a task is called before its first message names it. */
@@ -145,6 +151,9 @@ export interface BotRecord {
   /** which computer the bot acts on: its cloud box, this Mac (local CUA),
    * or none. Unset = auto (box when it exists, else local when available). */
   computer?: "cloud" | "vm" | "local" | "off";
+  /** where NEW tasks run their shell tools; each task pins its own copy
+   * on its first turn (TaskRecord.cwd). Absent = the home folder. */
+  cwd?: string;
   /** Auto mode: the bot approves its own tool permissions and keeps
    * working instead of stopping to ask. Questions it asks YOU still come
    * through, and a short list of destructive commands still stops it. */
@@ -656,6 +665,21 @@ export class Store {
     this.saveBots();
   }
 
+  /** The folder a task's turn runs in. Pins on first call from the bot's
+   * current folder — unless the task already has a session (a thread from
+   * before folders existed), which pins to the default so the folder can't
+   * move under it. Returns the pinned value: a path, or null for default. */
+  pinTaskCwd(botId: string, threadId: string): string | null {
+    const bot = this.bot(botId);
+    const task = bot ? this.taskByThread(botId, threadId) : undefined;
+    if (!bot || !task) return null;
+    if (task.cwd === undefined) {
+      task.cwd = Object.keys(task.resumeCursors).length === 0 ? (bot.cwd ?? null) : null;
+      this.saveBots();
+    }
+    return task.cwd;
+  }
+
   // ── tasks ─────────────────────────────────────────────────────────────
   /** The first thing the human asked in a thread — a task's natural name. */
   private firstUserLine(threadId: string): string | null {

src/components/ChatView.tsx

@@ -9,6 +9,7 @@ import {
   ChevronRight,
   Copy,
   Crown,
+  Folder,
   Loader2,
   Monitor,
   Pencil,
@@ -720,6 +721,7 @@ export function ChatView({ bot }: { bot: Bot }) {
             </button>
           )}
           <TaskPicker bot={bot} />
+          <WorkingFolderChip bot={bot} />
           <ModelPicker bot={bot} />
           <CallButton bot={bot} />
           <button
@@ -833,3 +835,24 @@ export function ChatView({ bot }: { bot: Bot }) {
     </main>
   );
 }
+
+/** The folder this task's tools run in — quiet unless it's somewhere other
+ * than home. Shows the pinned task folder when there is one, else the bot's
+ * folder a first turn would pin. Click opens bot settings to change it. */
+function WorkingFolderChip({ bot }: { bot: Bot }) {
+  const { dispatch } = useStore();
+  const task = bot.tasks?.find((t) => t.threadId === bot.threadId);
+  const folder = task?.cwd === undefined ? bot.cwd : (task.cwd ?? undefined);
+  if (!folder) return null;
+  const name = folder.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || folder;
+  return (
+    <button
+      onClick={() => dispatch({ type: "toggleSettings", open: true })}
+      className="flex max-w-[180px] items-center gap-1.5 rounded-full border border-hairline/40 bg-raised/60 px-2.5 py-1 text-[12.5px] text-ink-secondary hover:bg-raised hover:text-ink"
+      title={`Working folder: ${folder}`}
+    >
+      <Folder size={12} />
+      <span className="truncate font-mono">{name}</span>
+    </button>
+  );
+}

src/components/SettingsPanel.tsx

@@ -1,4 +1,4 @@
-import { ChevronLeft, Crown, X } from "lucide-react";
+import { ChevronLeft, Crown, FolderOpen, X } from "lucide-react";
 import { useEffect, useState } from "react";
 import { api, useStore, type Bot } from "@/state/store";
 import { MausAvatar } from "./Avatar";
@@ -9,8 +9,10 @@ import {
   MAUS_COLOR_NAMES,
 } from "@/lib/mascot";
 import { ModelPicker } from "./ModelPicker";
+import { useDesktopCapabilities } from "./DesktopCapabilities";
 import { cn } from "@/lib/cn";
 import { requestNotificationPermission } from "@/lib/notify";
+import { shortPath } from "@/lib/short-path";
 
 function Field({
   label,
@@ -30,6 +32,86 @@ function Field({
 const inputCls =
   "w-full rounded-lg border border-hairline/40 bg-inset px-3 py-2.5 text-[15px] text-ink placeholder:text-ink-secondary focus:outline-none focus:border-hairline";
 
+/** Where a bot's shell tools run. Set per bot; each task pins its own copy
+ * on its first turn (the server does the pinning — Claude keeps sessions
+ * per project folder, so a folder must not move under a live task). The
+ * PATCH is made directly rather than through updateBot: the server
+ * validates the path and a rejected folder must not stick in local state. */
+function WorkingFolder({ bot }: { bot: Bot }) {
+  const { capabilities } = useDesktopCapabilities();
+  const home = capabilities.host.homeDir;
+  const [draft, setDraft] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+  const canPick = Boolean(window.ogb?.pickFolder);
+  const task = bot.tasks?.find((t) => t.threadId === bot.threadId);
+  const pinned = task?.cwd; // undefined = not yet, null = default, string = folder
+  const pinnedElsewhere = pinned !== undefined && (pinned ?? undefined) !== bot.cwd;
+
+  const save = async (cwd: string | null) => {
+    setSaving(true);
+    setError(null);
+    try {
+      await api(`/api/bots/${bot.id}`, { method: "PATCH", body: JSON.stringify({ cwd }) });
+      setDraft(null);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setSaving(false);
+    }
+  };
+  const pick = async () => {
+    const chosen = await window.ogb?.pickFolder?.(bot.cwd);
+    if (chosen) void save(chosen);
+  };
+
+  return (
+    <div className="rounded-xl bg-card p-4">
+      <div className="text-[15px] font-medium text-ink">Working folder</div>
+      <div className="mt-0.5 text-[13px] text-ink-secondary">Where this bot runs its shell and file tools.</div>
+      {canPick ? (
+        <div className="mt-3 flex items-center gap-2">
+          <div className="min-w-0 flex-1 truncate rounded-lg border border-hairline/40 bg-inset px-3 py-2 font-mono text-[12.5px] text-ink" title={bot.cwd}>
+            {bot.cwd ? shortPath(bot.cwd, home) : <span className="text-ink-secondary">Home folder</span>}
+          </div>
+          <button onClick={() => void pick()} disabled={saving} className="flex shrink-0 items-center gap-1.5 rounded-lg bg-raised px-3 py-2 text-[13px] text-ink hover:bg-raised-hover disabled:opacity-50">
+            <FolderOpen size={14} /> Choose…
+          </button>
+          {bot.cwd && (
+            <button onClick={() => void save(null)} disabled={saving} className="shrink-0 rounded-lg px-2 py-2 text-[13px] text-ink-secondary hover:text-ink disabled:opacity-50">
+              Clear
+            </button>
+          )}
+        </div>
+      ) : (
+        <form
+          className="mt-3 flex items-center gap-2"
+          onSubmit={(e) => {
+            e.preventDefault();
+            void save(draft ?? bot.cwd ?? "");
+          }}
+        >
+          <input
+            className={cn(inputCls, "font-mono text-[12.5px]")}
+            placeholder="Home folder — or an absolute path"
+            value={draft ?? bot.cwd ?? ""}
+            onChange={(e) => setDraft(e.target.value)}
+          />
+          <button type="submit" disabled={saving || draft === null} className="shrink-0 rounded-lg bg-raised px-3 py-2 text-[13px] text-ink hover:bg-raised-hover disabled:opacity-50">
+            Save
+          </button>
+        </form>
+      )}
+      {error && <div className="mt-2 text-[12px] text-danger">{error}</div>}
+      {pinnedElsewhere && (
+        <div className="mt-2 text-[12px] text-ink-secondary">
+          New tasks start here. This task is pinned to {pinned ? <span className="font-mono">{shortPath(pinned, home)}</span> : "the home folder"} — start a new task to use the new folder.
+        </div>
+      )}
+    </div>
+  );
+}
+
 export function SettingsPanel({ bot }: { bot: Bot }) {
   const { state, dispatch } = useStore();
   const [voices, setVoices] = useState<Array<{ id: string; label: string; description?: string }>>([]);
@@ -333,6 +415,8 @@ export function SettingsPanel({ bot }: { bot: Bot }) {
             </div>
           </div>
 
+          <WorkingFolder bot={bot} />
+
           <div className="flex items-center justify-between gap-4 rounded-xl bg-card p-4">
             <div>
               <div className="text-[15px] font-medium text-ink">Auto mode</div>