@buildautomaton/cli 0.1.19 → 0.1.21

package/dist/cli.js

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
     var path36 = __require("node:path");
-    var fs32 = __require("node:fs");
+    var fs34 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1907,10 +1907,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path36.resolve(baseDir, baseName);
-          if (fs32.existsSync(localBin)) return localBin;
+          if (fs34.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path36.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs32.existsSync(`${localBin}${ext}`)
+            (ext) => fs34.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,7 +1922,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs32.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs34.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -5236,7 +5236,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash3 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -5896,7 +5896,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash3("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -6263,7 +6263,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash3 } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -6564,7 +6564,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash3("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -7129,7 +7129,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os6 = __require("os");
+    var os7 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -7177,7 +7177,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os7.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -24800,8 +24800,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve19) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve19());
+        this.#closedPromise = new Promise((resolve18) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve18());
         });
         this.#receive();
       }
@@ -24950,8 +24950,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve19, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve19, reject });
+        const responsePromise = new Promise((resolve18, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve18, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -25064,14 +25064,14 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.19".length > 0 ? "0.1.19" : "0.0.0-dev";
+var CLI_VERSION = "0.1.21".length > 0 ? "0.1.21" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs31 from "node:fs";
+import * as fs33 from "node:fs";
 import * as path35 from "node:path";
 
 // src/config.ts
@@ -25428,17 +25428,17 @@ async function loadOrCreateE2eCertificates(directory) {
   };
 }
 
-// src/files/cwd/bridge-workspace-directory.ts
+// src/files/cwd/bridge-root.ts
 import * as path3 from "node:path";
-var bridgeWorkspaceDirectory = null;
-function initBridgeWorkspaceDirectory() {
-  bridgeWorkspaceDirectory = path3.resolve(process.cwd());
+var bridgeRootPath = null;
+function initBridgeRoot() {
+  bridgeRootPath = path3.resolve(process.cwd());
 }
-function getBridgeWorkspaceDirectory() {
-  if (bridgeWorkspaceDirectory == null) {
-    bridgeWorkspaceDirectory = path3.resolve(process.cwd());
+function getBridgeRoot() {
+  if (bridgeRootPath == null) {
+    bridgeRootPath = path3.resolve(process.cwd());
   }
-  return bridgeWorkspaceDirectory;
+  return bridgeRootPath;
 }
 
 // src/log.ts
@@ -26037,14 +26037,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve19, reject) => {
+    return new Promise((resolve18, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve19(subprocess);
+        resolve18(subprocess);
       });
     });
   }
@@ -26340,8 +26340,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve19) => {
-    resolveAuth = resolve19;
+  const authPromise = new Promise((resolve18) => {
+    resolveAuth = resolve18;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -26463,7 +26463,7 @@ function runPendingAuth(options) {
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
-  await new Promise((resolve19) => setImmediate(resolve19));
+  await new Promise((resolve18) => setImmediate(resolve18));
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
@@ -26505,6 +26505,21 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
   say("Shutdown complete.");
 }
 
+// src/paths/session-layout-paths.ts
+import * as path5 from "node:path";
+function resolveIsolatedSessionParentPathFromCheckouts(worktreePaths) {
+  const resolved = worktreePaths.map((p) => path5.resolve(p)).filter(Boolean);
+  if (resolved.length === 0) return null;
+  resolved.sort();
+  return resolved[0];
+}
+function resolveSessionParentPathForAgentProcess(resolvedSessionParentPath) {
+  if (resolvedSessionParentPath != null && String(resolvedSessionParentPath).trim() !== "") {
+    return path5.resolve(String(resolvedSessionParentPath).trim());
+  }
+  return getBridgeRoot();
+}
+
 // src/lib/local-agent-auth.ts
 var LOCAL_AGENT_AUTH_ERROR_HINTS = {
   "kiro-acp": [/not logged in/i, /kiro-cli\s+login/i, /log in with kiro-cli/i],
@@ -26536,17 +26551,17 @@ function localAgentErrorSuggestsAuth(agentType, errorText) {
 import { execFile as execFile7 } from "node:child_process";
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import { promisify as promisify7 } from "node:util";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // src/git/pre-turn-snapshot.ts
 import * as fs9 from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 
 // src/git/discover-repos.ts
 import * as fs8 from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
 // ../../node_modules/.pnpm/simple-git@3.32.3/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -31131,9 +31146,9 @@ async function isGitRepoDirectory(dirPath) {
 }
 
 // src/git/discover-repos.ts
-async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
+async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path5.resolve(cwd);
+  const cwdResolved = path6.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -31146,7 +31161,7 @@ async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path5.join(cwdResolved, ent.name);
+    const childPath = path6.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -31154,12 +31169,12 @@ async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   }
   return result;
 }
-async function discoverGitReposUnderRoot(rootAbs) {
-  const root = path5.resolve(rootAbs);
+async function discoverGitReposUnderRoot(rootPath) {
+  const root = path6.resolve(rootPath);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path5.resolve(dir));
+      roots.push(path6.resolve(dir));
       return;
     }
     let entries;
@@ -31170,7 +31185,7 @@ async function discoverGitReposUnderRoot(rootAbs) {
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path5.join(dir, ent.name));
+      await walk(path6.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -31186,7 +31201,7 @@ async function discoverGitReposUnderRoot(rootAbs) {
 // src/git/pre-turn-snapshot.ts
 var execFileAsync5 = promisify6(execFile6);
 function snapshotsDirForCwd(agentCwd) {
-  return path6.join(agentCwd, ".buildautomaton", "snapshots");
+  return path7.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate(repoRoot, log2) {
   try {
@@ -31213,14 +31228,20 @@ async function gitRun(repoRoot, args, log2, label) {
   }
 }
 async function resolveSnapshotRepoRoots(options) {
-  const { worktreePaths, fallbackCwd, log: log2 } = options;
+  const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path6.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path7.resolve(p)))];
     return uniq;
   }
   try {
     const repos = await discoverGitReposUnderRoot(fallbackCwd);
-    return repos.map((r) => r.absolutePath);
+    const mapped = repos.map((r) => r.absolutePath);
+    const sid = sessionId?.trim();
+    if (sid) {
+      const filtered = mapped.filter((root) => path7.basename(root) === sid);
+      if (filtered.length > 0) return filtered;
+    }
+    return mapped;
   } catch (e) {
     log2(`[snapshot] Discover repositories failed: ${e instanceof Error ? e.message : String(e)}`);
     return [];
@@ -31247,7 +31268,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path6.join(dir, `${runId}.json`);
+  const filePath = path7.join(dir, `${runId}.json`);
   try {
     fs9.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -31285,7 +31306,7 @@ async function applyPreTurnSnapshot(filePath, log2) {
   return { ok: true };
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path6.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path7.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/git/session-git-queue.ts
@@ -31334,7 +31355,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
       continue;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
-    const slug = path7.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
+    const slug = path8.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
@@ -31348,8 +31369,8 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
         );
         if (!patchContent.trim()) continue;
         const displayPath = multiRepo ? `${slug}/${rel}` : rel;
-        const absFile = path7.join(repo.path, rel);
-        const newText = await readWorkspaceFileAsUtf8(absFile);
+        const workspaceFilePath = path8.join(repo.path, rel);
+        const newText = await readWorkspaceFileAsUtf8(workspaceFilePath);
         sendSessionUpdate({
           type: "session_file_change",
           sessionId,
@@ -31367,18 +31388,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
   }
 }
 
-// ../types/dist/index.js
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
-init_zod();
+// ../types/src/work-items.ts
 init_zod();
 var WorkItemStatusSchema = external_exports.enum(["backlog", "in-progress", "completed"]);
 var WorkItemProgressSchema = external_exports.object({
@@ -31419,6 +31429,9 @@ var WorkItemSchema = external_exports.object({
   dependencies: external_exports.array(WorkItemDependencySchema).default([]),
   assignedToUserId: external_exports.string().optional()
 });
+
+// ../types/src/user-profiles.ts
+init_zod();
 var UserWorkspaceProfileSchema = external_exports.object({
   id: external_exports.string(),
   workspaceId: external_exports.string(),
@@ -31428,6 +31441,9 @@ var UserWorkspaceProfileSchema = external_exports.object({
   preferences: external_exports.record(external_exports.unknown()).optional(),
   learnings: external_exports.array(external_exports.string())
 });
+
+// ../types/src/runtime.ts
+init_zod();
 var WorkspaceOwnerInfoSchema = external_exports.object({
   ownerId: external_exports.string(),
   ownerName: external_exports.string().optional(),
@@ -31441,6 +31457,9 @@ var WorkspaceRuntimeEntrySchema = external_exports.object({
   owner: WorkspaceOwnerInfoSchema.optional(),
   isOwner: external_exports.boolean().optional()
 });
+
+// ../types/src/agent.ts
+init_zod();
 var ProjectContextSchema = external_exports.object({
   projectId: external_exports.string(),
   context: external_exports.record(external_exports.unknown()).default({}),
@@ -31465,6 +31484,9 @@ var WebSocketMessageSchema = external_exports.object({
   data: external_exports.any().optional(),
   error: external_exports.string().optional()
 });
+
+// ../types/src/checkpoints.ts
+init_zod();
 var CheckpointKindSchema = external_exports.enum(["daily", "weekly", "overall"]);
 var CheckpointSummarySchema = external_exports.object({
   id: external_exports.string(),
@@ -31475,6 +31497,9 @@ var CheckpointSummarySchema = external_exports.object({
   createdAt: external_exports.string(),
   updatedAt: external_exports.string()
 });
+
+// ../types/src/threads.ts
+init_zod();
 var ThreadMetaSchema = external_exports.object({
   threadId: external_exports.string(),
   workspaceId: external_exports.string(),
@@ -31502,6 +31527,9 @@ var ThreadMessageSchema = external_exports.object({
 var ThreadCheckpointSummarySchema = CheckpointSummarySchema.extend({
   threadId: external_exports.string()
 });
+
+// ../types/src/content-items.ts
+init_zod();
 var ContentSourceSchema = external_exports.enum(["notion", "doc", "slack_thread", "other"]);
 var ContentItemMetaSchema = external_exports.object({
   contentId: external_exports.string(),
@@ -31523,6 +31551,9 @@ var ContentStorageRefSchema = external_exports.object({
 var ContentCheckpointSummarySchema = CheckpointSummarySchema.extend({
   contentId: external_exports.string()
 });
+
+// ../types/src/stories.ts
+init_zod();
 var StoryMetaSchema = external_exports.object({
   storyId: external_exports.string(),
   workspaceId: external_exports.string(),
@@ -31545,6 +31576,9 @@ var StoryContentItemRefSchema = external_exports.object({
 var StoryCheckpointSummarySchema = CheckpointSummarySchema.extend({
   storyId: external_exports.string()
 });
+
+// ../types/src/sessions.ts
+init_zod();
 var BUILTIN_SESSION_CHANGE_SUMMARY_FOLLOW_UP_CATALOG_PROMPT_ID = "__builtin_change_summary__";
 var SessionMetaSchema = external_exports.object({
   sessionId: external_exports.string(),
@@ -31587,6 +31621,8 @@ var SessionThreadRefSchema = external_exports.object({
   threadId: external_exports.string(),
   addedAt: external_exports.string()
 });
+
+// ../types/src/change-summary-path.ts
 function normalizeRepoRelativePath(p) {
   let t = p.trim().replace(/\\/g, "/");
   while (t.startsWith("./")) t = t.slice(2);
@@ -31603,6 +31639,8 @@ function resolveChangeSummaryPathAgainstAllowed(rawPath, allowed) {
   }
   return null;
 }
+
+// ../types/src/parse-change-summary-json.ts
 function clampSummaryToAtMostTwoLines(summary) {
   const lines = summary.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
   return lines.slice(0, 2).join("\n");
@@ -31645,6 +31683,8 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
   }
   return rows;
 }
+
+// ../types/src/build-change-summary-prompt.ts
 var PATCH_PREVIEW_MAX = 12e3;
 function clip(s, max) {
   if (s.length <= max) return s;
@@ -31702,6 +31742,8 @@ function buildSessionChangeSummaryPrompt(files) {
   }
   return lines.join("\n");
 }
+
+// ../types/src/dedupe-session-file-changes-by-path.ts
 function defaultRichness(c) {
   const patch = typeof c.patchContent === "string" ? c.patchContent.length : 0;
   const nt = typeof c.newText === "string" ? c.newText.length : 0;
@@ -31719,6 +31761,9 @@ function dedupeSessionFileChangesByPath(items, richness = (item) => defaultRichn
   }
   return Array.from(byPath.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([, v]) => v);
 }
+
+// ../types/src/artifacts.ts
+init_zod();
 var ArtifactMetaSchema = external_exports.object({
   artifactId: external_exports.string(),
   workspaceId: external_exports.string(),
@@ -31732,6 +31777,9 @@ var ArtifactMetaSchema = external_exports.object({
   createdAt: external_exports.string(),
   updatedAt: external_exports.string()
 });
+
+// ../types/src/templates.ts
+init_zod();
 var TemplateMetaSchema = external_exports.object({
   templateId: external_exports.string(),
   workspaceId: external_exports.string(),
@@ -31741,6 +31789,9 @@ var TemplateMetaSchema = external_exports.object({
   createdAt: external_exports.string(),
   updatedAt: external_exports.string()
 });
+
+// ../types/src/git-repos.ts
+init_zod();
 var GitRepoMetaSchema = external_exports.object({
   /** Stable id for the repo (e.g. hash of normalized canonical URL). Used for DO idFromName. */
   repoId: external_exports.string(),
@@ -31934,7 +31985,7 @@ async function sendPromptToAgent(options) {
 
 // src/agents/acp/ensure-acp-client.ts
 import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -31973,7 +32024,7 @@ async function isCommandOnPath(command, timeoutMs = 4e3) {
 // src/agents/acp/clients/sdk-stdio-acp-client.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // src/files/diff/unified-diff.ts
@@ -32023,21 +32074,21 @@ function editSnippetToUnifiedDiff(filePath, oldText, newText) {
 }
 
 // src/agents/acp/safe-fs-path.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 function resolveSafePathUnderCwd(cwd, filePath) {
   const trimmed2 = filePath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path8.resolve(cwd);
-  const resolved = path8.isAbsolute(trimmed2) ? path8.normalize(trimmed2) : path8.resolve(normalizedCwd, trimmed2);
-  const rel = path8.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path8.isAbsolute(rel)) return null;
+  const normalizedCwd = path9.resolve(cwd);
+  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
+  const rel = path9.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
   return resolved;
 }
 function toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path8.resolve(cwd);
-  const rel = path8.relative(normalizedCwd, path8.resolve(absolutePath));
-  if (!rel || rel === "") return path8.basename(absolutePath);
-  return rel.split(path8.sep).join("/");
+  const normalizedCwd = path9.resolve(cwd);
+  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
+  if (!rel || rel === "") return path9.basename(absolutePath);
+  return rel.split(path9.sep).join("/");
 }
 
 // src/agents/acp/clients/agent-stderr-capture.ts
@@ -32117,6 +32168,52 @@ function createSdkStdioExtNotificationHandler(options) {
   }
 }
 
+// src/agents/acp/enrich-acp-permission-rpc-result.ts
+var META_KEY = "permissionOptionKind";
+function optionRecordId(rec) {
+  const raw = rec.optionId ?? rec.id;
+  if (typeof raw === "string" && raw.trim() !== "") return raw.trim();
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  return "";
+}
+function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
+  if (params == null || result == null || typeof result !== "object" || Array.isArray(result)) {
+    return result;
+  }
+  const root = result;
+  const outcome = root.outcome;
+  if (outcome == null || typeof outcome !== "object" || Array.isArray(outcome)) return result;
+  const o = outcome;
+  if (o.outcome !== "selected" || typeof o.optionId !== "string" || o.optionId.trim() === "") {
+    return result;
+  }
+  const selectedId = o.optionId.trim();
+  const prevMeta = o._meta != null && typeof o._meta === "object" && !Array.isArray(o._meta) ? o._meta : {};
+  if (typeof prevMeta[META_KEY] === "string" && prevMeta[META_KEY].trim() !== "") {
+    return result;
+  }
+  const rawOpts = Array.isArray(params.options) ? params.options : [];
+  let matchedKind;
+  for (const item of rawOpts) {
+    if (item == null || typeof item !== "object" || Array.isArray(item)) continue;
+    const rec = item;
+    const id = optionRecordId(rec);
+    if (!id || id !== selectedId) continue;
+    if (typeof rec.kind === "string" && rec.kind.trim() !== "") {
+      matchedKind = rec.kind.trim();
+      break;
+    }
+  }
+  if (!matchedKind) return result;
+  return {
+    ...root,
+    outcome: {
+      ...o,
+      _meta: { ...prevMeta, [META_KEY]: matchedKind }
+    }
+  };
+}
+
 // src/agents/acp/clients/sdk-stdio-acp-client.ts
 function formatSpawnError(err, command) {
   if (err.code === "ENOENT") {
@@ -32138,7 +32235,7 @@ async function createSdkStdioAcpClient(options) {
   const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const {
     command,
-    cwd = getBridgeWorkspaceDirectory(),
+    cwd = getBridgeRoot(),
     backendAgentType,
     onSessionUpdate,
     onRequest,
@@ -32157,7 +32254,7 @@ async function createSdkStdioAcpClient(options) {
   child.once("close", (code, signal) => {
     onAgentSubprocessExit?.({ code, signal });
   });
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve18, reject) => {
     let initSettled = false;
     const settleReject = (err) => {
       if (initSettled) return;
@@ -32171,7 +32268,7 @@ async function createSdkStdioAcpClient(options) {
     const settleResolve = (handle) => {
       if (initSettled) return;
       initSettled = true;
-      resolve19(handle);
+      resolve18(handle);
     };
     child.on("error", (err) => {
       settleReject(new Error(formatSpawnError(err, command[0])));
@@ -32194,7 +32291,7 @@ async function createSdkStdioAcpClient(options) {
           onSessionUpdate
         });
         let permissionSeq = 0;
-        const pendingPermissionResolvers = /* @__PURE__ */ new Map();
+        const pendingPermissionReplies = /* @__PURE__ */ new Map();
         const client = (_agent) => ({
           async requestPermission(params) {
             const requestId = `perm-${++permissionSeq}`;
@@ -32207,15 +32304,15 @@ async function createSdkStdioAcpClient(options) {
               });
             } catch {
             }
-            return await new Promise((resolve20) => {
-              pendingPermissionResolvers.set(requestId, resolve20);
+            return await new Promise((resolve19) => {
+              pendingPermissionReplies.set(requestId, { resolve: resolve19, params: paramsRecord });
             });
           },
           async readTextFile(params) {
-            const abs = resolveSafePathUnderCwd(cwd, params.path);
-            if (!abs) throw new Error("Invalid or disallowed path");
+            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
+            if (!resolvedPath) throw new Error("Invalid or disallowed path");
             try {
-              let content = readFileSync2(abs, "utf8");
+              let content = readFileSync2(resolvedPath, "utf8");
               content = sliceFileContentRange(content, params.line, params.limit);
               return { content };
             } catch (e) {
@@ -32224,17 +32321,17 @@ async function createSdkStdioAcpClient(options) {
             }
           },
           async writeTextFile(params) {
-            const abs = resolveSafePathUnderCwd(cwd, params.path);
-            if (!abs) throw new Error("Invalid or disallowed path");
+            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
+            if (!resolvedPath) throw new Error("Invalid or disallowed path");
             let oldText = "";
             try {
-              oldText = readFileSync2(abs, "utf8");
+              oldText = readFileSync2(resolvedPath, "utf8");
             } catch (e) {
               if (e.code !== "ENOENT") throw e;
             }
-            mkdirSync2(dirname(abs), { recursive: true });
-            writeFileSync2(abs, params.content, "utf8");
-            const displayPath = toDisplayPathRelativeToCwd(cwd, abs);
+            mkdirSync2(dirname2(resolvedPath), { recursive: true });
+            writeFileSync2(resolvedPath, params.content, "utf8");
+            const displayPath = toDisplayPathRelativeToCwd(cwd, resolvedPath);
             const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, params.content);
             onFileChange?.({ path: displayPath, oldText, newText: params.content, patchContent });
             return {};
@@ -32316,9 +32413,9 @@ async function createSdkStdioAcpClient(options) {
             }
           },
           async cancel() {
-            for (const [id, resolve20] of [...pendingPermissionResolvers.entries()]) {
-              pendingPermissionResolvers.delete(id);
-              resolve20({ outcome: { outcome: "cancelled" } });
+            for (const [id, entry] of [...pendingPermissionReplies.entries()]) {
+              pendingPermissionReplies.delete(id);
+              entry.resolve({ outcome: { outcome: "cancelled" } });
             }
             try {
               await connection.cancel({ sessionId });
@@ -32334,10 +32431,11 @@ async function createSdkStdioAcpClient(options) {
             }
           },
           resolveRequest(requestId, result) {
-            const resolve20 = pendingPermissionResolvers.get(requestId);
-            if (!resolve20) return;
-            pendingPermissionResolvers.delete(requestId);
-            resolve20(result);
+            const entry = pendingPermissionReplies.get(requestId);
+            if (!entry) return;
+            pendingPermissionReplies.delete(requestId);
+            const enriched = enrichAcpPermissionRpcResultFromRequestParams(result, entry.params);
+            entry.resolve(enriched);
           },
           disconnect() {
             child.kill();
@@ -32422,7 +32520,7 @@ __export(cursor_acp_client_exports, {
   detectLocalAgentPresence: () => detectLocalAgentPresence3
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 import * as readline from "node:readline";
 
@@ -32472,7 +32570,7 @@ function buildCursorAcpSpawnCommand(base, sessionMode) {
 async function createCursorAcpClient(options) {
   const command = buildCursorAcpSpawnCommand(options.command, options.sessionMode);
   const {
-    cwd = getBridgeWorkspaceDirectory(),
+    cwd = getBridgeRoot(),
     backendAgentType,
     onSessionUpdate,
     onRequest,
@@ -32488,7 +32586,7 @@ async function createCursorAcpClient(options) {
   });
   const stderrCapture = createStderrCapture(child);
   child.stderr?.on("data", (chunk) => stderrCapture.append(chunk));
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve18, reject) => {
     child.on("error", (err) => {
       child.kill();
       reject(new Error(formatSpawnError2(err, command[0])));
@@ -32514,7 +32612,9 @@ async function createCursorAcpClient(options) {
       child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
     }
     function resolveRequest(requestId, result) {
-      respond(requestId, result);
+      const pending2 = pendingRequests.get(requestId);
+      const payload = pending2?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending2.params) : result;
+      respond(requestId, payload);
       pendingRequests.delete(requestId);
     }
     let promptOutputBuffer = "";
@@ -32570,14 +32670,14 @@ async function createCursorAcpClient(options) {
           if (dbgFs) {
             console.error(`[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""}`);
           }
-          const abs = resolveSafePathUnderCwd(cwd, filePath);
-          if (!abs) {
+          const resolvedPath = resolveSafePathUnderCwd(cwd, filePath);
+          if (!resolvedPath) {
             if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty)`);
             respondJsonRpcError(id, -32602, "Invalid or disallowed path");
             return;
           }
           try {
-            let content = readFileSync3(abs, "utf8");
+            let content = readFileSync3(resolvedPath, "utf8");
             const line2 = typeof params.line === "number" ? params.line : void 0;
             const limit = typeof params.limit === "number" ? params.limit : void 0;
             content = sliceLinesByRange(content, line2, limit);
@@ -32601,15 +32701,15 @@ async function createCursorAcpClient(options) {
               `[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""} newBytes=${newText.length}`
             );
           }
-          const abs = resolveSafePathUnderCwd(cwd, filePath);
-          if (!abs) {
+          const resolvedPath = resolveSafePathUnderCwd(cwd, filePath);
+          if (!resolvedPath) {
             if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty): ${filePath.slice(0, 120)}`);
             respondJsonRpcError(id, -32602, "Invalid or disallowed path");
             return;
           }
           let oldText = "";
           try {
-            oldText = readFileSync3(abs, "utf8");
+            oldText = readFileSync3(resolvedPath, "utf8");
           } catch (e) {
             if (e.code !== "ENOENT") {
               respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
@@ -32617,13 +32717,13 @@ async function createCursorAcpClient(options) {
             }
           }
           try {
-            mkdirSync3(dirname2(abs), { recursive: true });
-            writeFileSync3(abs, newText, "utf8");
+            mkdirSync3(dirname3(resolvedPath), { recursive: true });
+            writeFileSync3(resolvedPath, newText, "utf8");
           } catch (e) {
             respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
             return;
           }
-          const displayPath = toDisplayPathRelativeToCwd(cwd, abs);
+          const displayPath = toDisplayPathRelativeToCwd(cwd, resolvedPath);
           const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
           onFileChange?.({ path: displayPath, oldText, newText, patchContent });
           respond(id, null);
@@ -32675,7 +32775,7 @@ async function createCursorAcpClient(options) {
         const newResult = await send("session/new", { cwd, mcpServers: [] });
         const sessionId = newResult?.sessionId ?? "";
         if (!sessionId) throw new Error("Cursor ACP session/new did not return sessionId");
-        resolve19({
+        resolve18({
           sessionId,
           async sendPrompt(prompt, _options) {
             promptOutputBuffer = "";
@@ -32739,8 +32839,7 @@ async function createCursorAcpClient(options) {
           resolveRequest(requestId, result) {
             const numericId = Number(requestId);
             if (!Number.isFinite(numericId)) return;
-            const pendingRequest = pendingRequests.get(numericId);
-            if (!pendingRequest) return;
+            if (!pendingRequests.get(numericId)) return;
             resolveRequest(numericId, result);
           },
           disconnect() {
@@ -32866,16 +32965,16 @@ import { existsSync, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path9.resolve(startDir),
+      cwd: path10.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path9.resolve(out) : null;
+    return out ? path10.resolve(out) : null;
   } catch {
     return null;
   }
@@ -32884,64 +32983,64 @@ function getGitRepoRootSync(startDir) {
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
-import * as path10 from "node:path";
-function resolveWorkspaceFilePath(cwd, rawPath) {
+import * as path11 from "node:path";
+function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path10.resolve(cwd);
-  let abs = resolveSafePathUnderCwd(cwd, trimmed2);
-  if (!abs) {
-    const candidate = path10.isAbsolute(trimmed2) ? path10.normalize(trimmed2) : path10.normalize(path10.resolve(normalizedCwd, trimmed2));
-    const gitRoot2 = getGitRepoRootSync(cwd);
+  const normalizedSessionParent = path11.resolve(sessionParentPath);
+  let resolvedPath = resolveSafePathUnderCwd(sessionParentPath, trimmed2);
+  if (!resolvedPath) {
+    const candidate = path11.isAbsolute(trimmed2) ? path11.normalize(trimmed2) : path11.normalize(path11.resolve(normalizedSessionParent, trimmed2));
+    const gitRoot2 = getGitRepoRootSync(sessionParentPath);
     if (!gitRoot2) return null;
-    const rel = path10.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path10.isAbsolute(rel)) return null;
-    abs = candidate;
+    const rel = path11.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path11.isAbsolute(rel)) return null;
+    resolvedPath = candidate;
   }
-  const gitRoot = getGitRepoRootSync(cwd);
+  const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const relFromRoot = path10.relative(gitRoot, abs);
-    if (!relFromRoot.startsWith("..") && !path10.isAbsolute(relFromRoot)) {
-      return { abs, display: relFromRoot.split(path10.sep).join("/") };
+    const relFromRoot = path11.relative(gitRoot, resolvedPath);
+    if (!relFromRoot.startsWith("..") && !path11.isAbsolute(relFromRoot)) {
+      return { resolvedPath, display: relFromRoot.split(path11.sep).join("/") };
     }
   }
-  return { abs, display: toDisplayPathRelativeToCwd(cwd, abs) };
+  return { resolvedPath, display: toDisplayPathRelativeToCwd(sessionParentPath, resolvedPath) };
 }
-function readUtf8WorkspaceFile(cwd, displayPath) {
+function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
-  const gitRoot = getGitRepoRootSync(cwd);
+  const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const abs2 = path10.resolve(gitRoot, displayPath);
-    const rel = path10.relative(gitRoot, abs2);
-    if (!rel.startsWith("..") && !path10.isAbsolute(rel)) {
+    const resolvedPath2 = path11.resolve(gitRoot, displayPath);
+    const rel = path11.relative(gitRoot, resolvedPath2);
+    if (!rel.startsWith("..") && !path11.isAbsolute(rel)) {
       try {
-        return readFileSync4(abs2, "utf8");
+        return readFileSync4(resolvedPath2, "utf8");
       } catch {
       }
     }
   }
-  const abs = resolveSafePathUnderCwd(cwd, displayPath);
-  if (!abs) return "";
+  const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
+  if (!resolvedPath) return "";
   try {
-    return readFileSync4(abs, "utf8");
+    return readFileSync4(resolvedPath, "utf8");
   } catch {
     return "";
   }
 }
-function tryWorkspaceDisplayToAbs(cwd, displayPath) {
+function tryWorkspaceDisplayToPath(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
-  const gitRoot = getGitRepoRootSync(cwd);
+  const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const abs = path10.resolve(gitRoot, displayPath);
-    const rel = path10.relative(gitRoot, abs);
-    if (!rel.startsWith("..") && !path10.isAbsolute(rel)) return abs;
+    const resolvedPath = path11.resolve(gitRoot, displayPath);
+    const rel = path11.relative(gitRoot, resolvedPath);
+    if (!rel.startsWith("..") && !path11.isAbsolute(rel)) return resolvedPath;
   }
-  return resolveSafePathUnderCwd(cwd, displayPath);
+  return resolveSafePathUnderCwd(sessionParentPath, displayPath);
 }
-function readGitHeadBlob(cwd, displayPath) {
+function readGitHeadBlob(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
-  const gitRoot = getGitRepoRootSync(cwd);
-  const execCwd = gitRoot ?? cwd;
+  const gitRoot = getGitRepoRootSync(sessionParentPath);
+  const execCwd = gitRoot ?? sessionParentPath;
   try {
     return execFileSync3("git", ["show", `HEAD:${displayPath}`], {
       cwd: execCwd,
@@ -32954,9 +33053,9 @@ function readGitHeadBlob(cwd, displayPath) {
 }
 
 // src/agents/acp/session-file-change-path-kind.ts
-function gitHeadPathObjectType(cwd, displayPath) {
+function gitHeadPathObjectType(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
-  const gitRoot = getGitRepoRootSync(cwd);
+  const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (!gitRoot) return null;
   try {
     return execFileSync4("git", ["cat-file", "-t", `HEAD:${displayPath}`], {
@@ -32967,11 +33066,11 @@ function gitHeadPathObjectType(cwd, displayPath) {
     return null;
   }
 }
-function getSessionFileChangeDirectoryFlags(cwd, displayPath) {
-  const abs = tryWorkspaceDisplayToAbs(cwd, displayPath);
-  if (abs && existsSync(abs)) {
+function getSessionFileChangeDirectoryFlags(sessionParentPath, displayPath) {
+  const resolvedPath = tryWorkspaceDisplayToPath(sessionParentPath, displayPath);
+  if (resolvedPath && existsSync(resolvedPath)) {
     try {
-      if (statSync(abs).isDirectory()) {
+      if (statSync(resolvedPath).isDirectory()) {
         return { isDirectory: true, directoryRemoved: false };
       }
       return { isDirectory: false, directoryRemoved: false };
@@ -32979,7 +33078,7 @@ function getSessionFileChangeDirectoryFlags(cwd, displayPath) {
       return { isDirectory: false, directoryRemoved: false };
     }
   }
-  if (gitHeadPathObjectType(cwd, displayPath) === "tree") {
+  if (gitHeadPathObjectType(sessionParentPath, displayPath) === "tree") {
     return { isDirectory: true, directoryRemoved: true };
   }
   return { isDirectory: false, directoryRemoved: false };
@@ -32987,7 +33086,7 @@ function getSessionFileChangeDirectoryFlags(cwd, displayPath) {
 
 // src/agents/acp/hooks/bridge-on-file-change.ts
 function createBridgeOnFileChange(opts) {
-  const { routing, getSendSessionUpdate, log: log2 } = opts;
+  const { routing, getSendSessionUpdate, log: log2, sessionParentPath } = opts;
   return (evt) => {
     const runId = routing.runId;
     const sessionId = routing.sessionId;
@@ -32998,8 +33097,7 @@ function createBridgeOnFileChange(opts) {
       );
       return;
     }
-    const cwd = getBridgeWorkspaceDirectory();
-    const dirFlags = getSessionFileChangeDirectoryFlags(cwd, evt.path);
+    const dirFlags = getSessionFileChangeDirectoryFlags(sessionParentPath, evt.path);
     try {
       send({
         type: "session_file_change",
@@ -33076,12 +33174,12 @@ function extractDiffPath(o) {
 }
 
 // src/agents/acp/hooks/extract-acp-file-diffs-from-update/push-diff.ts
-function pushDiffIfComplete(o, cwd, out) {
+function pushDiffIfComplete(o, sessionParentPath, out) {
   const t = o.type;
   if (typeof t !== "string" || t.toLowerCase() !== "diff") return;
   const rawPath = extractDiffPath(o);
   if (!rawPath) return;
-  const resolved = resolveWorkspaceFilePath(cwd, rawPath);
+  const resolved = resolveWorkspaceFilePath(sessionParentPath, rawPath);
   if (!resolved) return;
   const oldText = readOptionalTextField(o.oldText ?? o.old_text ?? o.before ?? o.oldContent);
   const newText = readOptionalTextField(o.newText ?? o.new_text ?? o.after ?? o.newContent);
@@ -33100,17 +33198,17 @@ var NEST_KEYS = [
   "data",
   "arguments"
 ];
-function walkValue(value, cwd, depth, out) {
+function walkValue(value, sessionParentPath, depth, out) {
   if (depth > 12 || value == null) return;
   if (Array.isArray(value)) {
-    for (const x of value) walkValue(x, cwd, depth + 1, out);
+    for (const x of value) walkValue(x, sessionParentPath, depth + 1, out);
     return;
   }
   if (typeof value !== "object") return;
   const o = value;
-  pushDiffIfComplete(o, cwd, out);
+  pushDiffIfComplete(o, sessionParentPath, out);
   if (o.type === "content" && o.content != null && typeof o.content === "object") {
-    walkValue(o.content, cwd, depth + 1, out);
+    walkValue(o.content, sessionParentPath, depth + 1, out);
   }
   for (const k of NEST_KEYS) {
     if (o.type === "content" && k === "content") continue;
@@ -33118,23 +33216,23 @@ function walkValue(value, cwd, depth, out) {
     if (v == null) continue;
     if (k === "arguments" && typeof v === "string") {
       try {
-        walkValue(JSON.parse(v), cwd, depth + 1, out);
+        walkValue(JSON.parse(v), sessionParentPath, depth + 1, out);
       } catch {
       }
       continue;
     }
-    walkValue(v, cwd, depth + 1, out);
+    walkValue(v, sessionParentPath, depth + 1, out);
   }
 }
 
 // src/agents/acp/hooks/extract-acp-file-diffs-from-update/extract.ts
-function extractAcpFileDiffsFromUpdate(update, cwd) {
+function extractAcpFileDiffsFromUpdate(update, sessionParentPath) {
   if (!update || typeof update !== "object") return [];
   const u = update;
   const out = [];
   const content = u.content;
   if (Array.isArray(content)) {
-    for (const x of content) walkValue(x, cwd, 0, out);
+    for (const x of content) walkValue(x, sessionParentPath, 0, out);
   }
   const byPath = /* @__PURE__ */ new Map();
   for (const d of out) byPath.set(d.path, d);
@@ -33142,18 +33240,18 @@ function extractAcpFileDiffsFromUpdate(update, cwd) {
 }
 
 // src/agents/acp/hooks/extract-tool-target-paths.ts
-function addPath(cwd, raw, out) {
+function addPath(sessionParentPath, raw, out) {
   if (typeof raw !== "string") return;
   const trimmed2 = raw.trim();
   if (!trimmed2) return;
-  const resolved = resolveWorkspaceFilePath(cwd, trimmed2);
+  const resolved = resolveWorkspaceFilePath(sessionParentPath, trimmed2);
   if (!resolved) return;
   out.add(resolved.display);
 }
-function walkLocations(cwd, loc, out) {
+function walkLocations(sessionParentPath, loc, out) {
   if (!Array.isArray(loc)) return;
   for (const item of loc) {
-    if (item && typeof item === "object") addPath(cwd, item.path, out);
+    if (item && typeof item === "object") addPath(sessionParentPath, item.path, out);
   }
 }
 var PATH_KEYS = [
@@ -33166,56 +33264,56 @@ var PATH_KEYS = [
   "file_path",
   "target_file"
 ];
-function collectFromObject(cwd, obj, out, depth) {
+function collectFromObject(sessionParentPath, obj, out, depth) {
   if (depth > 10) return;
   for (const k of PATH_KEYS) {
-    if (k in obj) addPath(cwd, obj[k], out);
+    if (k in obj) addPath(sessionParentPath, obj[k], out);
   }
   for (const v of Object.values(obj)) {
-    if (v != null && typeof v === "object") collectUnknown(cwd, v, out, depth + 1);
+    if (v != null && typeof v === "object") collectUnknown(sessionParentPath, v, out, depth + 1);
   }
 }
-function collectUnknown(cwd, v, out, depth) {
+function collectUnknown(sessionParentPath, v, out, depth) {
   if (depth > 10 || v == null) return;
   if (Array.isArray(v)) {
-    for (const x of v) collectUnknown(cwd, x, out, depth + 1);
+    for (const x of v) collectUnknown(sessionParentPath, x, out, depth + 1);
     return;
   }
-  if (typeof v === "object") collectFromObject(cwd, v, out, depth);
+  if (typeof v === "object") collectFromObject(sessionParentPath, v, out, depth);
 }
-function walkContentArray(cwd, content, out) {
+function walkContentArray(sessionParentPath, content, out) {
   if (!Array.isArray(content)) return;
   for (const item of content) {
     if (!item || typeof item !== "object") continue;
     const o = item;
     if (typeof o.type === "string" && o.type.toLowerCase() === "diff") {
-      for (const k of PATH_KEYS) if (k in o) addPath(cwd, o[k], out);
+      for (const k of PATH_KEYS) if (k in o) addPath(sessionParentPath, o[k], out);
     }
     if (o.type === "content" && o.content != null && typeof o.content === "object") {
       const inner = o.content;
       if (typeof inner.type === "string" && inner.type.toLowerCase() === "diff") {
-        for (const k of PATH_KEYS) if (k in inner) addPath(cwd, inner[k], out);
+        for (const k of PATH_KEYS) if (k in inner) addPath(sessionParentPath, inner[k], out);
       }
     }
   }
 }
-function extractToolTargetDisplayPaths(update, cwd) {
+function extractToolTargetDisplayPaths(update, sessionParentPath) {
   const out = /* @__PURE__ */ new Set();
   if (!update || typeof update !== "object") return [];
   const u = update;
-  walkLocations(cwd, u.locations, out);
-  walkLocations(cwd, u.fileLocations, out);
-  walkLocations(cwd, u.file_locations, out);
+  walkLocations(sessionParentPath, u.locations, out);
+  walkLocations(sessionParentPath, u.fileLocations, out);
+  walkLocations(sessionParentPath, u.file_locations, out);
   const tc = u.toolCall ?? u.tool_call;
   if (tc && typeof tc.arguments === "string") {
     try {
       const parsed = JSON.parse(tc.arguments);
-      collectUnknown(cwd, parsed, out, 0);
+      collectUnknown(sessionParentPath, parsed, out, 0);
     } catch {
     }
   }
-  walkContentArray(cwd, u.content, out);
-  collectFromObject(cwd, u, out, 0);
+  walkContentArray(sessionParentPath, u.content, out);
+  collectFromObject(sessionParentPath, u, out, 0);
   return [...out];
 }
 
@@ -33281,7 +33379,7 @@ var PathSnapshotTracker = class {
     this.beforeByToolKey.delete(toolKey);
     this.accumulatedPathsByToolKey.delete(toolKey);
   }
-  captureBeforeFromDisk(toolKey, paths, cwd) {
+  captureBeforeFromDisk(toolKey, paths, sessionParentPath) {
     if (paths.length === 0) return;
     let m = this.beforeByToolKey.get(toolKey);
     if (!m) {
@@ -33290,10 +33388,10 @@ var PathSnapshotTracker = class {
     }
     for (const p of paths) {
       if (m.has(p)) continue;
-      m.set(p, readUtf8WorkspaceFile(cwd, p));
+      m.set(p, readUtf8WorkspaceFile(sessionParentPath, p));
     }
   }
-  ensureBeforeFromHeadForMissing(toolKey, paths, cwd) {
+  ensureBeforeFromHeadForMissing(toolKey, paths, sessionParentPath) {
     let m = this.beforeByToolKey.get(toolKey);
     if (!m) {
       m = /* @__PURE__ */ new Map();
@@ -33301,10 +33399,10 @@ var PathSnapshotTracker = class {
     }
     for (const p of paths) {
       if (m.has(p)) continue;
-      m.set(p, readGitHeadBlob(cwd, p));
+      m.set(p, readGitHeadBlob(sessionParentPath, p));
     }
   }
-  flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2) {
+  flushPathSnapshots(toolKey, sessionParentPath, sentPaths, send, runId, sessionId, log2) {
     const t = this.debouncers.get(toolKey);
     if (t) clearTimeout(t);
     this.debouncers.delete(toolKey);
@@ -33313,10 +33411,10 @@ var PathSnapshotTracker = class {
     this.beforeByToolKey.delete(toolKey);
     if (!send || !runId || !sessionId) return;
     for (const [displayPath, oldText] of beforeMap) {
-      const newText = readUtf8WorkspaceFile(cwd, displayPath);
+      const newText = readUtf8WorkspaceFile(sessionParentPath, displayPath);
       if (oldText === newText) continue;
       const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, displayPath);
+      const dirFlags = getSessionFileChangeDirectoryFlags(sessionParentPath, displayPath);
       try {
         send({
           type: "session_file_change",
@@ -33335,31 +33433,31 @@ var PathSnapshotTracker = class {
       }
     }
   }
-  scheduleDebouncedFlush(toolKey, cwd, sentPaths, send, runId, sessionId, log2) {
+  scheduleDebouncedFlush(toolKey, sessionParentPath, sentPaths, send, runId, sessionId, log2) {
     const prev = this.debouncers.get(toolKey);
     if (prev) clearTimeout(prev);
     this.debouncers.set(
       toolKey,
       setTimeout(() => {
         this.debouncers.delete(toolKey);
-        this.flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
+        this.flushPathSnapshots(toolKey, sessionParentPath, sentPaths, send, runId, sessionId, log2);
       }, PATH_SNAPSHOT_DEBOUNCE_MS)
     );
   }
-  handleToolCallLifecycle(updateKind, toolKey, toolPaths, status, cwd, sentPaths, send, runId, sessionId, log2) {
+  handleToolCallLifecycle(updateKind, toolKey, toolPaths, status, sessionParentPath, sentPaths, send, runId, sessionId, log2) {
     if (updateKind === "tool_call") {
       this.resetToolSnapshots(toolKey);
     }
     if (updateKind === "tool_call") {
-      this.captureBeforeFromDisk(toolKey, toolPaths, cwd);
+      this.captureBeforeFromDisk(toolKey, toolPaths, sessionParentPath);
     } else if (updateKind === "tool_call_update") {
       if (isCompletedToolStatus(status)) {
-        this.ensureBeforeFromHeadForMissing(toolKey, toolPaths, cwd);
-        this.flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
+        this.ensureBeforeFromHeadForMissing(toolKey, toolPaths, sessionParentPath);
+        this.flushPathSnapshots(toolKey, sessionParentPath, sentPaths, send, runId, sessionId, log2);
       } else {
-        this.captureBeforeFromDisk(toolKey, toolPaths, cwd);
+        this.captureBeforeFromDisk(toolKey, toolPaths, sessionParentPath);
         if (this.beforeByToolKey.has(toolKey)) {
-          this.scheduleDebouncedFlush(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
+          this.scheduleDebouncedFlush(toolKey, sessionParentPath, sentPaths, send, runId, sessionId, log2);
         }
       }
     }
@@ -33367,11 +33465,11 @@ var PathSnapshotTracker = class {
 };
 
 // src/agents/acp/hooks/bridge-on-session-update/send-structured-file-changes.ts
-function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd, sessionId, runId, sentPaths, log2) {
+function sendExtractedDiffsAsSessionFileChanges(diffs, send, sessionParentPath, sessionId, runId, sentPaths, log2) {
   for (const d of diffs) {
     try {
       const patchContent = editSnippetToUnifiedDiff(d.path, d.oldText, d.newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, d.path);
+      const dirFlags = getSessionFileChangeDirectoryFlags(sessionParentPath, d.path);
       send({
         type: "session_file_change",
         sessionId,
@@ -33389,15 +33487,15 @@ function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd, sessionId, run
     }
   }
 }
-function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd, sessionId, runId, log2) {
+function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, sessionParentPath, sessionId, runId, log2) {
   for (const displayPath of mergedPaths) {
     if (sentPaths.has(displayPath)) continue;
-    const oldText = readGitHeadBlob(cwd, displayPath);
-    const newText = readUtf8WorkspaceFile(cwd, displayPath);
+    const oldText = readGitHeadBlob(sessionParentPath, displayPath);
+    const newText = readUtf8WorkspaceFile(sessionParentPath, displayPath);
     if (oldText === newText) continue;
     try {
       const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, displayPath);
+      const dirFlags = getSessionFileChangeDirectoryFlags(sessionParentPath, displayPath);
       send({
         type: "session_file_change",
         sessionId,
@@ -33418,13 +33516,12 @@ function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd, s
 
 // src/agents/acp/hooks/bridge-on-session-update/create-bridge-on-session-update.ts
 function createBridgeOnSessionUpdate(opts) {
-  const { routing, getSendSessionUpdate, log: log2 } = opts;
+  const { routing, getSendSessionUpdate, log: log2, sessionParentPath } = opts;
   const pathTracker = new PathSnapshotTracker();
   return (params) => {
     const runId = routing.runId;
     const sessionId = routing.sessionId;
     pathTracker.onRunIdChanged(runId);
-    const cwd = getBridgeWorkspaceDirectory();
     const send = getSendSessionUpdate();
     const sentFileChangePaths = /* @__PURE__ */ new Set();
     const p = params;
@@ -33432,7 +33529,7 @@ function createBridgeOnSessionUpdate(opts) {
     const isCompletedToolCallUpdate = updateKind === "tool_call_update" && isCompletedToolStatus(p.status);
     const toolName = p.toolCall?.name ?? p.tool_call?.name ?? "";
     const isToolUpdate = updateKind === "tool_call" || updateKind === "tool_call_update" || typeof toolName === "string" && toolName.length > 0;
-    const toolPaths = isToolUpdate ? extractToolTargetDisplayPaths(params, cwd) : [];
+    const toolPaths = isToolUpdate ? extractToolTargetDisplayPaths(params, sessionParentPath) : [];
     const toolKey = isToolUpdate ? pathTracker.resolveToolKey(params, updateKind) : "";
     if (updateKind === "tool_call") {
       pathTracker.resetToolSnapshots(toolKey);
@@ -33447,7 +33544,7 @@ function createBridgeOnSessionUpdate(opts) {
         toolKey,
         toolPaths,
         p.status,
-        cwd,
+        sessionParentPath,
         sentFileChangePaths,
         deliver,
         runId ?? "",
@@ -33455,9 +33552,17 @@ function createBridgeOnSessionUpdate(opts) {
         log2
       );
     }
-    const diffs = extractAcpFileDiffsFromUpdate(params, cwd);
+    const diffs = extractAcpFileDiffsFromUpdate(params, sessionParentPath);
     if (diffs.length > 0 && send && runId && sessionId) {
-      sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd, sessionId, runId, sentFileChangePaths, log2);
+      sendExtractedDiffsAsSessionFileChanges(
+        diffs,
+        send,
+        sessionParentPath,
+        sessionId,
+        runId,
+        sentFileChangePaths,
+        log2
+      );
     } else if (diffs.length > 0) {
       log2(
         `[Bridge service] Agent file diff(s) not forwarded (${diffs.length}): session or run not wired to the bridge.`
@@ -33466,7 +33571,15 @@ function createBridgeOnSessionUpdate(opts) {
     if (isCompletedToolCallUpdate && send && runId && sessionId) {
       const acc = pathTracker.accumulatedPathsByToolKey.get(toolKey);
       const merged = [.../* @__PURE__ */ new Set([...acc ? [...acc] : [], ...toolPaths])];
-      sendGitHeadVsWorkspaceForToolPaths(merged, sentFileChangePaths, send, cwd, sessionId, runId, log2);
+      sendGitHeadVsWorkspaceForToolPaths(
+        merged,
+        sentFileChangePaths,
+        send,
+        sessionParentPath,
+        sessionId,
+        runId,
+        log2
+      );
       pathTracker.accumulatedPathsByToolKey.delete(toolKey);
     }
     if (runId && send) {
@@ -33501,11 +33614,12 @@ function buildAcpSessionBridgeHooks(opts) {
 
 // src/agents/acp/ensure-acp-client.ts
 async function ensureAcpClient(options) {
-  const { state, preferredAgentType, mode, cwd, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
-  const targetCwd = path11.resolve(
-    cwd != null && String(cwd).trim() !== "" ? String(cwd).trim() : getBridgeWorkspaceDirectory()
-  );
-  if (state.acpHandle && state.lastAcpCwd != null && path11.resolve(state.lastAcpCwd) !== path11.resolve(targetCwd)) {
+  const { state, preferredAgentType, mode, sessionParentPath, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
+  const targetSessionParentPath = resolveSessionParentPathForAgentProcess(sessionParentPath);
+  if (state.acpStartPromise && !state.acpHandle) {
+    await state.acpStartPromise;
+  }
+  if (state.acpHandle && state.lastAcpCwd != null && path12.resolve(state.lastAcpCwd) !== path12.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -33537,14 +33651,14 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs10.statSync(targetCwd);
+      const st = fs10.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
-        state.lastAcpStartError = `Agent cwd is not a directory: ${targetCwd}`;
+        state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
         log2(`[Agent] ${state.lastAcpStartError}`);
       }
     } catch {
-      state.lastAcpStartError = `Agent cwd missing or inaccessible: ${targetCwd}`;
+      state.lastAcpStartError = `Agent cwd missing or inaccessible: ${targetSessionParentPath}`;
       log2(`[Agent] ${state.lastAcpStartError}`);
     }
     if (!statOk) {
@@ -33552,6 +33666,7 @@ async function ensureAcpClient(options) {
     }
     const hooks = buildAcpSessionBridgeHooks({
       routing,
+      sessionParentPath: targetSessionParentPath,
       getSendSessionUpdate: () => sendSessionUpdate,
       getSendRequest: () => sendRequest,
       log: log2
@@ -33559,7 +33674,6 @@ async function ensureAcpClient(options) {
     state.acpStartPromise = resolved.createClient({
       command: resolved.command,
       sessionMode: mode,
-      cwd: targetCwd,
       backendAgentType: preferredAgentType,
       onAgentSubprocessExit: () => {
         state.acpHandle = null;
@@ -33567,11 +33681,12 @@ async function ensureAcpClient(options) {
         state.acpAgentKey = null;
         state.lastAcpStartError = "Agent subprocess exited";
       },
-      ...hooks
+      ...hooks,
+      cwd: targetSessionParentPath
     }).then((h) => {
       state.lastAcpStartError = null;
       state.acpHandle = h;
-      state.lastAcpCwd = targetCwd;
+      state.lastAcpCwd = targetSessionParentPath;
       state.acpAgentKey = agentKey;
       return h;
     }).catch((err) => {
@@ -33620,7 +33735,7 @@ async function createAcpManager(options) {
       runId,
       mode,
       agentType,
-      cwd,
+      sessionParentPath,
       sendResult: sendResult2,
       sendSessionUpdate,
       followUpCatalogPromptId,
@@ -33639,7 +33754,7 @@ async function createAcpManager(options) {
         state,
         preferredAgentType: preferredForPrompt,
         mode,
-        cwd,
+        sessionParentPath,
         routing: promptRouting,
         sendSessionUpdate,
         sendRequest: sendSessionUpdate,
@@ -33688,7 +33803,7 @@ async function createAcpManager(options) {
         sessionId,
         runId,
         agentType: preferredForPrompt,
-        agentCwd: cwd,
+        agentCwd: resolveSessionParentPathForAgentProcess(sessionParentPath),
         sendResult: sendResult2,
         sendSessionUpdate,
         log: log2,
@@ -33743,12 +33858,12 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import os4 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
 import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -33758,11 +33873,11 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 
 // src/worktrees/worktree-layout-file.ts
 import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import os3 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path12.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path13.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -33783,24 +33898,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path12.dirname(defaultWorktreeLayoutPath());
+    const dir = path13.dirname(defaultWorktreeLayoutPath());
     fs11.mkdirSync(dir, { recursive: true });
     fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
-function baseNameSafe(abs) {
-  return path12.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+function baseNameSafe(pathString) {
+  return path13.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
-function getLauncherDirNameIfPresent(layout, launcherCwdAbs) {
-  const norm = path12.resolve(launcherCwdAbs);
-  const existing = layout.launcherCwds.find((e) => path12.resolve(e.absolutePath) === norm);
+function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
+  const norm = path13.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path13.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
-function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
-  const existing = getLauncherDirNameIfPresent(layout, launcherCwdAbs);
+function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
+  const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path12.resolve(launcherCwdAbs);
+  const norm = path13.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -33816,24 +33931,27 @@ function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
 
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
-  const { rootAbs, launcherCwd, sessionId, layout, log: log2 } = options;
-  const launcherResolved = path13.resolve(launcherCwd);
-  const cwdKey = allocateDirNameForLauncherCwd(layout, launcherResolved);
-  const agentMirrorRoot = path13.join(rootAbs, cwdKey);
-  const repos = await discoverGitReposUnderRoot(launcherResolved);
+  const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2 } = options;
+  const bridgeResolved = path14.resolve(bridgeRoot);
+  const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
+  const bridgeKeyDir = path14.join(worktreesRootPath, cwdKey);
+  const sessionDir = path14.join(bridgeKeyDir, sessionId);
+  const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
-    log2("[worktrees] No Git repositories under launcher working directory; skipping worktree creation.");
+    log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
     return null;
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs12.mkdirSync(agentMirrorRoot, { recursive: true });
+  fs12.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path13.relative(launcherResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path13.isAbsolute(rel)) continue;
+    let rel = path14.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path14.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = path13.join(agentMirrorRoot, relNorm, sessionId);
-    fs12.mkdirSync(path13.dirname(wtPath), { recursive: true });
+    const wtPath = relNorm === "." ? sessionDir : path14.join(sessionDir, relNorm);
+    if (relNorm !== ".") {
+      fs12.mkdirSync(path14.dirname(wtPath), { recursive: true });
+    }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
       log2(`[worktrees] Added worktree ${wtPath} (branch ${branch}).`);
@@ -33845,7 +33963,11 @@ async function prepareNewSessionWorktrees(options) {
     }
   }
   if (worktreePaths.length === 0) return null;
-  return { worktreePaths, agentCwd: agentMirrorRoot };
+  return {
+    worktreePaths,
+    sessionParentPath: sessionDir,
+    workingTreeRelRoot: sessionDir
+  };
 }
 
 // src/git/rename-branch.ts
@@ -33877,16 +33999,16 @@ import * as fs14 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
 import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path14.join(wt, ".git");
+  const gitDirFile = path15.join(wt, ".git");
   if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
   const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path14.resolve(wt, m[1].trim());
-  const gitDir = path14.dirname(path14.dirname(gitWorktreePath));
-  return path14.dirname(gitDir);
+  const gitWorktreePath = path15.resolve(wt, m[1].trim());
+  const gitDir = path15.dirname(path15.dirname(gitWorktreePath));
+  return path15.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -34128,7 +34250,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -34249,16 +34371,16 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
 import * as fs17 from "node:fs";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
 import * as readline2 from "node:readline";
-async function countTextFileLines(absFile) {
+async function countTextFileLines(filePath) {
   let bytes = 0;
   const maxBytes = 512e3;
   let lines = 0;
-  const stream = createReadStream(absFile, { encoding: "utf8" });
+  const stream = createReadStream(filePath, { encoding: "utf8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   for await (const _line of rl) {
     lines += 1;
@@ -34286,15 +34408,15 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
     return null;
   }
 }
-async function readWorktreeFileLines(abs) {
+async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs16.promises.readFile(abs, "utf8");
+    const raw = await fs16.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
   }
 }
-async function hydrateUnifiedPatchWithFileContext(patch, absFile, repoGitCwd, pathInRepo, change) {
+async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, change) {
   if (!patch.trim() || patch.includes("Binary files")) return patch;
   const all = patch.split("\n");
   const out = [];
@@ -34311,7 +34433,7 @@ async function hydrateUnifiedPatchWithFileContext(patch, absFile, repoGitCwd, pa
   };
   const diskLines = async () => {
     if (diskCache !== void 0) return diskCache;
-    diskCache = await readWorktreeFileLines(absFile);
+    diskCache = await readWorktreeFileLines(filePath);
     return diskCache;
   };
   while (i < all.length) {
@@ -34423,7 +34545,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const abs = path15.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path16.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -34436,8 +34558,8 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs17.promises.stat(abs);
-          if (st.isFile()) additions = await countTextFileLines(abs);
+          const st = await fs17.promises.stat(repoFilePath);
+          if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
           additions = 0;
@@ -34462,10 +34584,10 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const absFile = path15.join(repoGitCwd, pathInRepo);
+    const filePath = path16.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
-      patch = await hydrateUnifiedPatchWithFileContext(patch, absFile, repoGitCwd, pathInRepo, row.change);
+      patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
     }
     row.patchContent = patch;
   }
@@ -34478,8 +34600,9 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const launcher = path16.resolve(getBridgeWorkspaceDirectory());
-  const mirror = options.agentMirrorRootAbs ? path16.resolve(options.agentMirrorRootAbs) : null;
+  const bridgeRoot = path17.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path17.resolve(options.sessionWorktreeRootPath) : null;
+  const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
   const basisInput = options.basis ?? { kind: "working" };
@@ -34490,8 +34613,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     throw new Error("commit sha is required for commit changes");
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
-  for (const target of options.commitTargetAbsDirs) {
-    const t = path16.resolve(target);
+  for (const target of options.commitTargetPaths) {
+    const t = path17.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = simpleGit(t);
     let branch = "HEAD";
@@ -34503,8 +34626,9 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteUrl = await getRemoteOriginUrl(t);
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
-    if (mirror) {
-      const relNorm = path16.relative(mirror, path16.dirname(t));
+    if (sessionWtRoot) {
+      const anchor = legacyNested ? path17.dirname(t) : t;
+      const relNorm = path17.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -34513,8 +34637,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path16.relative(launcher, path16.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path16.basename(path16.resolve(top)) : rel;
+      const rel = path17.relative(bridgeRoot, path17.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path17.basename(path17.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -34580,14 +34704,37 @@ async function commitSessionWorktrees(options) {
 
 // src/worktrees/discover-session-worktree-on-disk.ts
 import * as fs18 from "node:fs";
-import * as path17 from "node:path";
-function isGitDir(abs) {
+import * as path18 from "node:path";
+function isGitDir(dirPath) {
   try {
-    return fs18.existsSync(path17.join(abs, ".git"));
+    return fs18.existsSync(path18.join(dirPath, ".git"));
   } catch {
     return false;
   }
 }
+function collectGitRepoRootsUnderDirectory(rootPath) {
+  const out = [];
+  const walk = (dir) => {
+    if (isGitDir(dir)) {
+      out.push(path18.resolve(dir));
+      return;
+    }
+    let entries;
+    try {
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".")) continue;
+      const full = path18.join(dir, e.name);
+      if (!e.isDirectory()) continue;
+      walk(full);
+    }
+  };
+  walk(path18.resolve(rootPath));
+  return [...new Set(out)];
+}
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
   const out = [];
   const walk = (dir, depth) => {
@@ -34600,10 +34747,10 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path17.join(dir, e.name);
+      const full = path18.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path17.resolve(full));
+        if (isGitDir(full)) out.push(path18.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -34612,16 +34759,55 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
   walk(root, 0);
   return out;
 }
+function tryBindingFromSessionDirectory(sessionDir) {
+  let st;
+  try {
+    st = fs18.statSync(sessionDir);
+  } catch {
+    return null;
+  }
+  if (!st.isDirectory()) return null;
+  const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
+  if (worktreePaths.length === 0) return null;
+  const abs = path18.resolve(sessionDir);
+  return {
+    sessionParentPath: abs,
+    workingTreeRelRoot: abs,
+    repoCheckoutPaths: worktreePaths
+  };
+}
+function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  const hintR = path18.resolve(checkoutPath);
+  let best = null;
+  let cur = path18.dirname(hintR);
+  for (let i = 0; i < 40; i++) {
+    const paths = collectWorktreeRootsNamed(cur, sid, 24);
+    if (paths.some((p) => path18.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path18.resolve(paths[0]);
+      best = {
+        sessionParentPath: path18.resolve(isolated),
+        workingTreeRelRoot: path18.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path18.resolve(p))
+      };
+    }
+    const next = path18.dirname(cur);
+    if (next === cur) break;
+    cur = next;
+  }
+  return best;
+}
 function discoverSessionWorktreeOnDisk(options) {
-  const { sessionId, worktreesRootAbs, layout, launcherCwd } = options;
-  if (!sessionId.trim() || !fs18.existsSync(worktreesRootAbs)) return null;
-  const preferredKey = getLauncherDirNameIfPresent(layout, launcherCwd);
+  const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
+  if (!sessionId.trim() || !fs18.existsSync(worktreesRootPath)) return null;
+  const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs18.readdirSync(worktreesRootAbs)) {
+    for (const name of fs18.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path17.join(worktreesRootAbs, name);
+      const p = path18.join(worktreesRootPath, name);
       if (!fs18.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
@@ -34629,26 +34815,58 @@ function discoverSessionWorktreeOnDisk(options) {
     return null;
   }
   for (const key of keys) {
-    const mirrorRoot = path17.join(worktreesRootAbs, key);
-    if (!fs18.existsSync(mirrorRoot) || !fs18.statSync(mirrorRoot).isDirectory()) continue;
-    const worktreePaths = collectWorktreeRootsNamed(mirrorRoot, sessionId, 24);
-    if (worktreePaths.length > 0) {
-      return { agentCwd: path17.resolve(mirrorRoot), worktreePaths };
+    const layoutRoot = path18.join(worktreesRootPath, key);
+    if (!fs18.existsSync(layoutRoot) || !fs18.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path18.join(layoutRoot, sessionId);
+    const nested = tryBindingFromSessionDirectory(sessionDir);
+    if (nested) return nested;
+    const legacyPaths = collectWorktreeRootsNamed(layoutRoot, sessionId, 24);
+    if (legacyPaths.length > 0) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+      return {
+        sessionParentPath: path18.resolve(isolated),
+        workingTreeRelRoot: path18.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+      };
     }
   }
   return null;
 }
-function discoverSessionWorktreesUnderMirrorRoot(mirrorRootAbs, sessionId) {
-  const mirrorRoot = path17.resolve(mirrorRootAbs);
-  if (!sessionId.trim() || !fs18.existsSync(mirrorRoot)) return null;
+function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  const hint = path18.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path18.join(hint, sid));
+  if (underHint) return underHint;
+  const direct = tryBindingFromSessionDirectory(hint);
+  if (direct) {
+    if (path18.basename(hint) === sid && isGitDir(hint)) {
+      const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
+      if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
+        return legacyFromCheckout;
+      }
+    }
+    return direct;
+  }
+  if (path18.basename(hint) === sid && isGitDir(hint)) {
+    const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
+    if (legacyFromCheckout) return legacyFromCheckout;
+  }
+  let st;
   try {
-    if (!fs18.statSync(mirrorRoot).isDirectory()) return null;
+    st = fs18.statSync(hint);
   } catch {
     return null;
   }
-  const worktreePaths = collectWorktreeRootsNamed(mirrorRoot, sessionId, 24);
-  if (worktreePaths.length === 0) return null;
-  return { agentCwd: mirrorRoot, worktreePaths };
+  if (!st.isDirectory()) return null;
+  const legacyPaths = collectWorktreeRootsNamed(hint, sid, 24);
+  if (legacyPaths.length === 0) return null;
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+  return {
+    sessionParentPath: path18.resolve(isolated),
+    workingTreeRelRoot: hint,
+    repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+  };
 }
 
 // src/worktrees/session-worktree-manager.ts
@@ -34658,42 +34876,86 @@ function parseSessionParent(v) {
   return null;
 }
 var SessionWorktreeManager = class {
-  rootAbs;
+  worktreesRootPath;
   log;
-  sessionPaths = /* @__PURE__ */ new Map();
-  sessionAgentCwd = /* @__PURE__ */ new Map();
+  sessionRepoCheckoutPaths = /* @__PURE__ */ new Map();
+  sessionParentPathBySession = /* @__PURE__ */ new Map();
+  sessionWorkingTreeRelRootBySession = /* @__PURE__ */ new Map();
   layout;
   constructor(options) {
-    this.rootAbs = options.worktreesRootAbs;
+    this.worktreesRootPath = options.worktreesRootPath;
     this.log = options.log;
     this.layout = loadWorktreeLayout();
   }
-  rememberWorktrees(sessionId, agentCwd, worktreePaths) {
-    this.sessionPaths.set(sessionId, worktreePaths);
-    this.sessionAgentCwd.set(sessionId, path18.resolve(agentCwd));
+  rememberSessionWorktrees(sessionId, binding) {
+    const paths = binding.repoCheckoutPaths.map((p) => path19.resolve(p));
+    this.sessionRepoCheckoutPaths.set(sessionId, paths);
+    this.sessionParentPathBySession.set(sessionId, path19.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path19.resolve(binding.workingTreeRelRoot));
+  }
+  sessionParentPathAfterRemember(sessionId) {
+    return this.sessionParentPathBySession.get(sessionId);
   }
   tryDiscoverFromDisk(sessionId) {
     return discoverSessionWorktreeOnDisk({
       sessionId,
-      worktreesRootAbs: this.rootAbs,
+      worktreesRootPath: this.worktreesRootPath,
       layout: this.layout,
-      launcherCwd: getBridgeWorkspaceDirectory()
+      bridgeRoot: getBridgeRoot()
     });
   }
+  isLegacyNestedLayout(sessionId) {
+    const parent = this.sessionParentPathBySession.get(sessionId);
+    const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
+    if (!parent || !relRoot) return false;
+    return path19.resolve(parent) !== path19.resolve(relRoot);
+  }
   /**
-   * Returns cwd for the agent (mirror of launcher tree), or undefined to use the bridge workspace directory.
+   * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
    */
-  async resolveCwdForPrompt(sessionId, opts) {
+  getIsolatedSessionParentPathForSession(sessionId) {
+    if (!sessionId) return null;
+    const sid = sessionId.trim();
+    const cached2 = this.sessionParentPathBySession.get(sid);
+    if (cached2) return path19.resolve(cached2);
+    const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
+    if (!paths?.length) return null;
+    return resolveIsolatedSessionParentPathFromCheckouts(paths);
+  }
+  /**
+   * Resolved **session parent path** for the agent: session directory in worktrees mode,
+   * or `undefined` meaning use {@link getBridgeRoot}.
+   */
+  async resolveSessionParentPathForPrompt(sessionId, opts) {
     if (!sessionId) return void 0;
+    const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const agentCwd = path18.resolve(parentPathRaw);
-      const sid = sessionId?.trim();
+      const resolved = path19.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
-        const fromMirror = discoverSessionWorktreesUnderMirrorRoot(agentCwd, sid);
-        if (fromMirror) this.rememberWorktrees(sid, fromMirror.agentCwd, fromMirror.worktreePaths);
+        const diskFirst = this.tryDiscoverFromDisk(sid);
+        if (diskFirst) {
+          this.rememberSessionWorktrees(sid, diskFirst);
+          return this.sessionParentPathAfterRemember(sid);
+        }
+        const fromRoot = discoverSessionWorktreesUnderSessionWorktreeRoot(resolved, sid);
+        if (fromRoot) {
+          this.rememberSessionWorktrees(sid, fromRoot);
+          return this.sessionParentPathAfterRemember(sid);
+        }
+        let cur = resolved;
+        for (let i = 0; i < 16; i++) {
+          const tryRoot = discoverSessionWorktreesUnderSessionWorktreeRoot(cur, sid);
+          if (tryRoot) {
+            this.rememberSessionWorktrees(sid, tryRoot);
+            return this.sessionParentPathAfterRemember(sid);
+          }
+          const next = path19.dirname(cur);
+          if (next === cur) break;
+          cur = next;
+        }
       }
-      return agentCwd;
+      return resolved;
     }
     const parentKind = parseSessionParent(opts.sessionParent);
     if (parentKind === "bridge_root") {
@@ -34701,78 +34963,102 @@ var SessionWorktreeManager = class {
     }
     if (parentKind === "worktrees_root") {
       if (!opts.isNewSession) {
-        const cached2 = this.sessionAgentCwd.get(sessionId);
-        if (cached2) return path18.resolve(cached2);
-        const disc = this.tryDiscoverFromDisk(sessionId);
+        const cached2 = this.sessionParentPathAfterRemember(sid);
+        if (cached2) return cached2;
+        const disc = this.tryDiscoverFromDisk(sid);
         if (disc) {
-          this.rememberWorktrees(sessionId, disc.agentCwd, disc.worktreePaths);
-          return path18.resolve(disc.agentCwd);
+          this.rememberSessionWorktrees(sid, disc);
+          return this.sessionParentPathAfterRemember(sid);
         }
         return void 0;
       }
       const prep2 = await prepareNewSessionWorktrees({
-        rootAbs: this.rootAbs,
-        launcherCwd: getBridgeWorkspaceDirectory(),
-        sessionId,
+        worktreesRootPath: this.worktreesRootPath,
+        bridgeRoot: getBridgeRoot(),
+        sessionId: sid,
         layout: this.layout,
         log: this.log
       });
       if (!prep2) return void 0;
-      this.rememberWorktrees(sessionId, prep2.agentCwd, prep2.worktreePaths);
-      return path18.resolve(prep2.agentCwd);
+      this.rememberSessionWorktrees(sid, {
+        sessionParentPath: prep2.sessionParentPath,
+        workingTreeRelRoot: prep2.workingTreeRelRoot,
+        repoCheckoutPaths: prep2.worktreePaths
+      });
+      return this.sessionParentPathAfterRemember(sid);
     }
     if (!opts.isNewSession) {
-      const cached2 = this.sessionAgentCwd.get(sessionId);
-      if (cached2) return path18.resolve(cached2);
-      const disc = this.tryDiscoverFromDisk(sessionId);
+      const cached2 = this.sessionParentPathAfterRemember(sid);
+      if (cached2) return cached2;
+      const disc = this.tryDiscoverFromDisk(sid);
       if (disc) {
-        this.rememberWorktrees(sessionId, disc.agentCwd, disc.worktreePaths);
-        return path18.resolve(disc.agentCwd);
+        this.rememberSessionWorktrees(sid, disc);
+        return this.sessionParentPathAfterRemember(sid);
       }
       return void 0;
     }
     const prep = await prepareNewSessionWorktrees({
-      rootAbs: this.rootAbs,
-      launcherCwd: getBridgeWorkspaceDirectory(),
-      sessionId,
+      worktreesRootPath: this.worktreesRootPath,
+      bridgeRoot: getBridgeRoot(),
+      sessionId: sid,
       layout: this.layout,
       log: this.log
     });
     if (!prep) return void 0;
-    this.rememberWorktrees(sessionId, prep.agentCwd, prep.worktreePaths);
-    return path18.resolve(prep.agentCwd);
+    this.rememberSessionWorktrees(sid, {
+      sessionParentPath: prep.sessionParentPath,
+      workingTreeRelRoot: prep.workingTreeRelRoot,
+      repoCheckoutPaths: prep.worktreePaths
+    });
+    return this.sessionParentPathAfterRemember(sid);
   }
   async renameSessionBranch(sessionId, newBranch) {
-    const paths = this.sessionPaths.get(sessionId);
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
     if (!paths?.length) return;
     await renameSessionWorktreeBranches(paths, newBranch, this.log);
   }
-  /** True when this session runs in an isolated worktree mirror (not launcher cwd). */
+  /** True when this session uses an isolated worktree layout (not the bridge root). */
   usesWorktreeSession(sessionId) {
     if (!sessionId) return false;
-    return this.sessionAgentCwd.has(sessionId);
+    return this.sessionParentPathBySession.has(sessionId);
   }
-  getWorktreePathsForSession(sessionId) {
+  /** Per-repo git checkout directories for this session (for snapshots, commits, change lists). */
+  getRepoCheckoutPathsForSession(sessionId) {
     if (!sessionId) return void 0;
-    const paths = this.sessionPaths.get(sessionId);
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
     return paths?.length ? [...paths] : void 0;
   }
-  /** Session mirror root (parent of per-repo worktrees), when using worktrees for this session. */
-  getAgentCwdForSession(sessionId) {
-    if (!sessionId) return null;
-    const c = this.sessionAgentCwd.get(sessionId);
-    return c ? path18.resolve(c) : null;
+  /**
+   * Same paths as {@link getRepoCheckoutPathsForSession}, but loads from disk into memory when the CLI
+   * restarted or maps were not yet populated (avoids discovering every repo under the worktrees root).
+   */
+  ensureRepoCheckoutPathsForSession(sessionId) {
+    if (!sessionId?.trim()) return void 0;
+    const sid = sessionId.trim();
+    const cached2 = this.sessionRepoCheckoutPaths.get(sid);
+    if (cached2?.length) return [...cached2];
+    const disc = this.tryDiscoverFromDisk(sid);
+    if (disc?.repoCheckoutPaths.length) {
+      this.rememberSessionWorktrees(sid, disc);
+      return [...disc.repoCheckoutPaths];
+    }
+    return void 0;
+  }
+  /** Session parent directory when in worktrees mode; null otherwise (same as {@link getIsolatedSessionParentPathForSession} path). */
+  getSessionWorktreeRootForSession(sessionId) {
+    return this.getIsolatedSessionParentPathForSession(sessionId);
   }
   async removeSessionWorktrees(sessionId) {
-    const paths = this.sessionPaths.get(sessionId);
-    this.sessionPaths.delete(sessionId);
-    this.sessionAgentCwd.delete(sessionId);
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
+    this.sessionRepoCheckoutPaths.delete(sessionId);
+    this.sessionParentPathBySession.delete(sessionId);
+    this.sessionWorkingTreeRelRootBySession.delete(sessionId);
     if (!paths?.length) return;
     await removeSessionWorktrees(paths, this.log);
   }
   async commitSession(params) {
-    const paths = this.sessionPaths.get(params.sessionId);
-    const targets = paths?.length ? paths : [getBridgeWorkspaceDirectory()];
+    const paths = this.sessionRepoCheckoutPaths.get(params.sessionId);
+    const targets = paths?.length ? paths : [getBridgeRoot()];
     return commitSessionWorktrees({
       paths: targets,
       branch: params.branch,
@@ -34781,14 +35067,14 @@ var SessionWorktreeManager = class {
     });
   }
   resolveCommitTargets(sessionId) {
-    const paths = this.sessionPaths.get(sessionId);
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
     if (paths?.length) return paths;
     const disc = this.tryDiscoverFromDisk(sessionId);
-    if (disc?.worktreePaths.length) {
-      this.rememberWorktrees(sessionId, disc.agentCwd, disc.worktreePaths);
-      return disc.worktreePaths;
+    if (disc?.repoCheckoutPaths.length) {
+      this.rememberSessionWorktrees(sessionId, disc);
+      return disc.repoCheckoutPaths;
     }
-    return [getBridgeWorkspaceDirectory()];
+    return [getBridgeRoot()];
   }
   async getSessionWorkingTreeStatus(sessionId) {
     return aggregateSessionPathsWorkingTreeStatus(this.resolveCommitTargets(sessionId));
@@ -34796,10 +35082,12 @@ var SessionWorktreeManager = class {
   /** Per-repo changed files vs HEAD (or a single commit vs parent) for the same git roots used for commit/push. */
   async getSessionWorkingTreeChangeDetails(sessionId, opts) {
     const targets = this.resolveCommitTargets(sessionId);
-    const mirror = this.getAgentCwdForSession(sessionId);
+    const sessionWorkingTreeRelRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId) ?? null;
+    const legacyNested = this.isLegacyNestedLayout(sessionId);
     return getWorkingTreeChangeRepoDetails({
-      commitTargetAbsDirs: targets,
-      agentMirrorRootAbs: mirror,
+      commitTargetPaths: targets,
+      sessionWorktreeRootPath: sessionWorkingTreeRelRoot,
+      legacyRepoNestedSessionLayout: legacyNested,
       repoFilterRelPath: opts?.repoRelPath?.trim() ? opts.repoRelPath.trim() : null,
       basis: opts?.basis
     });
@@ -34814,31 +35102,31 @@ var SessionWorktreeManager = class {
     }
   }
 };
-function defaultWorktreesRootAbs() {
-  return path18.join(os4.homedir(), ".buildautomaton", "worktrees");
+function defaultWorktreesRootPath() {
+  return path19.join(os4.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path22 from "node:path";
+import path23 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve19) => setImmediate(resolve19));
+  return new Promise((resolve18) => setImmediate(resolve18));
 }
 
 // src/files/index/walk-workspace-tree.ts
 import fs19 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // src/files/index/constants.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import os5 from "node:os";
 var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path19.join(os5.homedir(), ".buildautomaton");
+var INDEX_DIR = path20.join(os5.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 var INDEX_VERSION = 2;
 var INDEX_LOG_PREFIX = "[file-index]";
@@ -34853,14 +35141,14 @@ function walkWorkspaceTreeSync(dir, baseDir, out) {
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path20.join(dir, name);
+    const full = path21.join(dir, name);
     let stat3;
     try {
       stat3 = fs19.statSync(full);
     } catch {
       continue;
     }
-    const relative5 = path20.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       walkWorkspaceTreeSync(full, baseDir, out);
     } else if (stat3.isFile()) {
@@ -34881,14 +35169,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path20.join(dir, name);
+    const full = path21.join(dir, name);
     let stat3;
     try {
       stat3 = await fs19.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path20.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat3.isFile()) {
@@ -34972,11 +35260,11 @@ async function buildTrigramMapForPathsAsync(paths) {
 import fs20 from "node:fs";
 
 // src/files/index/paths.ts
-import path21 from "node:path";
+import path22 from "node:path";
 import crypto2 from "node:crypto";
 function getIndexPathForCwd(resolvedCwd) {
   const hash = crypto2.createHash("sha256").update(resolvedCwd).digest("hex").slice(0, INDEX_HASH_LEN);
-  return path21.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path22.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 
 // src/files/index/write-index-file.ts
@@ -35007,7 +35295,7 @@ function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
 function buildFileIndex(cwd) {
-  const resolved = path22.resolve(cwd);
+  const resolved = path23.resolve(cwd);
   const paths = [];
   walkWorkspaceTreeSync(resolved, resolved, paths);
   sortPaths(paths);
@@ -35017,7 +35305,7 @@ function buildFileIndex(cwd) {
   return data;
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path22.resolve(cwd);
+  const resolved = path23.resolve(cwd);
   const paths = [];
   await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
   await yieldToEventLoop();
@@ -35030,9 +35318,9 @@ async function buildFileIndexAsync(cwd) {
 
 // src/files/index/load-file-index.ts
 import fs21 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function loadFileIndex(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const indexPath = getIndexPathForCwd(resolved);
   try {
     const raw = fs21.readFileSync(indexPath, "utf8");
@@ -35054,9 +35342,9 @@ function loadFileIndex(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path24 from "node:path";
+import path25 from "node:path";
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path24.resolve(cwd);
+  const resolved = path25.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = await buildFileIndexAsync(resolved);
@@ -35138,8 +35426,8 @@ function createFsWatcher(resolved, schedule) {
     throw e;
   }
 }
-function startFileIndexWatcher(cwd = getBridgeWorkspaceDirectory()) {
-  const resolved = path25.resolve(cwd);
+function startFileIndexWatcher(cwd = getBridgeRoot()) {
+  const resolved = path26.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -35189,15 +35477,15 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve19) => {
-    proc.once("exit", () => resolve19());
+  const exited = new Promise((resolve18) => {
+    proc.once("exit", () => resolve18());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve19) => setTimeout(resolve19, graceMs))]);
+  await Promise.race([exited, new Promise((resolve18) => setTimeout(resolve18, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -35477,10 +35765,10 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 import { spawn as spawn6 } from "node:child_process";
 import fs24 from "node:fs";
 import { tmpdir } from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path26.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path26.join(tmpRoot, "combined.log");
+  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path27.join(tmpRoot, "combined.log");
   let logFd;
   try {
     logFd = fs24.openSync(logPath, "a");
@@ -35524,15 +35812,15 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 import { spawn as spawn7 } from "node:child_process";
 import fs25 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path27.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
-  const innerPath = path27.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path27.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path28.join(tmpRoot, "combined.log");
+  const innerPath = path28.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path28.join(tmpRoot, "_run.sh");
   try {
     fs25.writeFileSync(innerPath, `#!/bin/sh
 ${command}
@@ -35563,9 +35851,9 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path27.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
-  const runnerPath = path27.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path28.join(tmpRoot, "combined.log");
+  const runnerPath = path28.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
@@ -35775,13 +36063,13 @@ var DevServerManager = class {
   abortControllersByServerId = /* @__PURE__ */ new Map();
   getWs;
   log;
-  getBridgeCwd;
+  getBridgeRoot;
   e2ee;
   firehoseSink;
   constructor(options) {
     this.getWs = options.getWs;
     this.log = options.log;
-    this.getBridgeCwd = options.getBridgeCwd ?? (() => process.cwd());
+    this.getBridgeRoot = options.getBridgeRoot ?? (() => process.cwd());
     this.e2ee = options.e2ee;
     this.firehoseSink = new DevServerFirehoseSink({
       getTails: (serverId) => this.snapshotTails(serverId),
@@ -35870,7 +36158,7 @@ var DevServerManager = class {
     this.sendStatus(serverId, "starting", void 0, emptyTails());
     const ac = new AbortController();
     this.abortControllersByServerId.set(serverId, ac);
-    const cwd = this.getBridgeCwd();
+    const cwd = this.getBridgeRoot();
     const childEnv = envForSpawn(process.env, def.env, def.ports);
     const cmd = substituteCommand(def.command.trim(), childEnv);
     const title = def.name.trim() || serverId.slice(0, 8);
@@ -36080,7 +36368,7 @@ async function proxyToLocal(request) {
   };
   const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const once = await new Promise((resolve19) => {
+    const once = await new Promise((resolve18) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -36091,7 +36379,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve19({
+          resolve18({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -36100,7 +36388,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve19({
+        resolve18({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -36461,13 +36749,13 @@ function createOnBridgeIdentified(opts) {
 
 // src/skills/discover-local-agent-skills.ts
 import fs26 from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path28.join(cwd, rel);
+    const base = path29.join(cwd, rel);
     if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -36476,13 +36764,13 @@ function discoverLocalSkills(cwd) {
       continue;
     }
     for (const name of entries) {
-      const dir = path28.join(base, name);
+      const dir = path29.join(base, name);
       try {
         if (!fs26.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path28.join(dir, "SKILL.md");
+      const skillMd = path29.join(dir, "SKILL.md");
       if (!fs26.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
@@ -36495,7 +36783,7 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path28.join(cwd, rel);
+    const base = path29.join(cwd, rel);
     if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -36505,13 +36793,13 @@ function discoverSkillLayoutRoots(cwd) {
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path28.join(base, name);
+      const dir = path29.join(base, name);
       try {
         if (!fs26.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs26.existsSync(path28.join(dir, "SKILL.md"))) continue;
+      if (!fs26.existsSync(path29.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -36555,7 +36843,7 @@ function createSendLocalSkillsReport(getWs, logFn) {
       try {
         const socket = getWs();
         if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-        const skills2 = discoverLocalSkills(getBridgeWorkspaceDirectory());
+        const skills2 = discoverLocalSkills(getBridgeRoot());
         sendWsMessage(socket, { type: "local_skills", skills: skills2 });
       } catch (e) {
         logFn(
@@ -36616,6 +36904,7 @@ var API_TO_BRIDGE_MESSAGE_TYPES = [
   "dev_servers_config",
   "server_control",
   "agent_config",
+  "prompt_queue_state",
   "prompt",
   "session_git_request",
   "rename_session_branch",
@@ -36692,8 +36981,178 @@ var handleAgentConfigMessage = (msg, deps) => {
   handleBridgeAgentConfig(msg, deps);
 };
 
-// src/agents/acp/from-bridge/handle-bridge-prompt.ts
-import * as path30 from "node:path";
+// src/prompt-turn-queue/client-report.ts
+function sendPromptQueueClientReport(ws, queues) {
+  if (!ws) return false;
+  sendWsMessage(ws, { type: "prompt_queue_client_report", queues });
+  return true;
+}
+
+// src/prompt-turn-queue/disk-store.ts
+import fs28 from "node:fs";
+
+// src/prompt-turn-queue/paths.ts
+import crypto3 from "node:crypto";
+import fs27 from "node:fs";
+import path30 from "node:path";
+import os6 from "node:os";
+var QUEUE_KEY_HEX_64 = /^[a-f0-9]{64}$/i;
+function queueStateFileSlug(queueKey) {
+  if (QUEUE_KEY_HEX_64.test(queueKey)) return queueKey.toLowerCase();
+  return crypto3.createHash("sha256").update(queueKey, "utf8").digest("hex");
+}
+function getPromptQueuesDirectory() {
+  const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
+  if (override) return path30.resolve(override);
+  return path30.join(os6.homedir(), ".buildautomaton", "queues");
+}
+function ensurePromptQueuesDirectory() {
+  const dir = getPromptQueuesDirectory();
+  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
+}
+function queueStateFilePath(queueKey) {
+  return path30.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
+}
+
+// src/prompt-turn-queue/disk-store.ts
+function parsePersistedQueueFile(raw) {
+  try {
+    const o = JSON.parse(raw);
+    const queueKey = typeof o.queueKey === "string" ? o.queueKey : typeof o.queueKeyHash === "string" ? o.queueKeyHash : null;
+    if (!queueKey || typeof o.updatedAt !== "string" || !Array.isArray(o.turns)) return null;
+    return { queueKey, updatedAt: o.updatedAt, turns: o.turns };
+  } catch {
+    return null;
+  }
+}
+function readPersistedQueue(queueKey) {
+  const p = queueStateFilePath(queueKey);
+  try {
+    return parsePersistedQueueFile(fs28.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writePersistedQueue(file2) {
+  ensurePromptQueuesDirectory();
+  const p = queueStateFilePath(file2.queueKey);
+  fs28.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
+}
+function mergeServerQueueSnapshot(queueKey, serverTurns) {
+  const prev = readPersistedQueue(queueKey);
+  const turns = [];
+  for (const raw of serverTurns) {
+    if (!raw || typeof raw !== "object") continue;
+    const o = raw;
+    const turnId = typeof o.turnId === "string" ? o.turnId : "";
+    const sessionId = typeof o.sessionId === "string" ? o.sessionId : "";
+    const turnOrd = typeof o.turnOrd === "number" ? o.turnOrd : Number(o.turnOrd) || 0;
+    const serverState = o.serverState;
+    const lastClientState = o.lastClientState ?? null;
+    const payload = o.payload && typeof o.payload === "object" ? o.payload : {};
+    if (!turnId || !sessionId) continue;
+    if (serverState !== "queued" && serverState !== "stopping" && serverState !== "discarded") continue;
+    const old = prev?.turns.find((t) => t.turnId === turnId);
+    const mergedClient = old?.lastClientState === "running" && lastClientState == null ? "running" : lastClientState;
+    turns.push({
+      turnId,
+      sessionId,
+      turnOrd,
+      serverState,
+      lastClientState: mergedClient,
+      payload
+    });
+  }
+  turns.sort((a, b) => a.turnOrd - b.turnOrd);
+  return { queueKey, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), turns };
+}
+
+// src/prompt-turn-queue/runner.ts
+var runIdToQueueKey = /* @__PURE__ */ new Map();
+function pickNextRunnableTurn(turns) {
+  for (const t of turns) {
+    if (t.serverState === "discarded" || t.serverState === "stopping") continue;
+    if (t.serverState !== "queued") continue;
+    if (t.lastClientState === "running" || t.lastClientState === "stopped" || t.lastClientState === "failed") continue;
+    return t;
+  }
+  return null;
+}
+function hasRunningTurn(turns) {
+  return turns.some((t) => t.lastClientState === "running");
+}
+function dispatchLocalPrompt(next, deps) {
+  const pl = next.payload;
+  const rawParent = pl["sessionParent"];
+  const sessionParent = rawParent === "bridge_root" || rawParent === "worktrees_root" ? rawParent : void 0;
+  const rawParentPath = pl["sessionParentPath"];
+  const sessionParentPath = typeof rawParentPath === "string" && rawParentPath.trim() !== "" ? rawParentPath.trim() : void 0;
+  const msg = {
+    type: "prompt",
+    sessionId: next.sessionId,
+    runId: next.turnId,
+    prompt: pl.prompt,
+    mode: typeof pl.mode === "string" ? pl.mode : "agent",
+    isNewSession: pl.isNewSession === true,
+    ...sessionParent ? { sessionParent } : {},
+    ...sessionParentPath ? { sessionParentPath } : {},
+    ...typeof pl.followUpCatalogPromptId === "string" ? { followUpCatalogPromptId: pl.followUpCatalogPromptId } : {},
+    ...Array.isArray(pl.sessionChangeSummaryFilePaths) ? { sessionChangeSummaryFilePaths: pl.sessionChangeSummaryFilePaths } : {},
+    ...Array.isArray(pl.sessionChangeSummaryFileSnapshots) ? { sessionChangeSummaryFileSnapshots: pl.sessionChangeSummaryFileSnapshots } : {},
+    ...typeof pl.agentType === "string" && pl.agentType.trim() ? { agentType: pl.agentType.trim() } : {}
+  };
+  handleBridgePrompt(msg, deps);
+}
+function applyPromptQueueStateFromServer(msg, deps) {
+  const raw = msg.queues;
+  if (!raw || typeof raw !== "object") return;
+  const getWs = deps.getWs;
+  for (const [queueKey, serverTurns] of Object.entries(raw)) {
+    if (!Array.isArray(serverTurns)) continue;
+    const file2 = mergeServerQueueSnapshot(queueKey, serverTurns);
+    writePersistedQueue(file2);
+  }
+  const report = {};
+  const startedThisTick = /* @__PURE__ */ new Set();
+  for (const [queueKey, serverTurns] of Object.entries(raw)) {
+    if (!Array.isArray(serverTurns)) continue;
+    const file2 = readPersistedQueue(queueKey);
+    if (!file2) continue;
+    if (hasRunningTurn(file2.turns)) continue;
+    const next = pickNextRunnableTurn(file2.turns);
+    if (!next) continue;
+    next.lastClientState = "running";
+    writePersistedQueue(file2);
+    runIdToQueueKey.set(next.turnId, queueKey);
+    startedThisTick.add(next.turnId);
+    report[queueKey] = [{ turnId: next.turnId, clientState: "running" }];
+  }
+  if (Object.keys(report).length > 0) {
+    sendPromptQueueClientReport(getWs(), report);
+  }
+  for (const [queueKey, serverTurns] of Object.entries(raw)) {
+    if (!Array.isArray(serverTurns)) continue;
+    const file2 = readPersistedQueue(queueKey);
+    if (!file2) continue;
+    const running = file2.turns.find((t) => t.lastClientState === "running");
+    if (!running || !startedThisTick.has(running.turnId)) continue;
+    if (runIdToQueueKey.get(running.turnId) !== queueKey) continue;
+    dispatchLocalPrompt(running, deps);
+  }
+}
+function finalizePromptTurnOnBridge(getWs, runId, success2) {
+  if (!runId) return;
+  const queueKey = runIdToQueueKey.get(runId);
+  runIdToQueueKey.delete(runId);
+  if (!queueKey) return;
+  const f = readPersistedQueue(queueKey);
+  if (!f) return;
+  const t = f.turns.find((x) => x.turnId === runId);
+  if (!t) return;
+  t.lastClientState = success2 ? "stopped" : "failed";
+  writePersistedQueue(f);
+  sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, clientState: t.lastClientState }] });
+}
 
 // src/agents/acp/from-bridge/bridge-prompt-wiring.ts
 function createBridgePromptSenders(deps, getWs) {
@@ -36708,6 +37167,9 @@ function createBridgePromptSenders(deps, getWs) {
     const skipEncryptForChangeSummaryFollowUp = result.type === "prompt_result" && result.followUpCatalogPromptId === BUILTIN_SESSION_CHANGE_SUMMARY_FOLLOW_UP_CATALOG_PROMPT_ID;
     const encryptedFields = result.type === "prompt_result" && !skipEncryptForChangeSummaryFollowUp ? ["output", "error"] : [];
     sendBridgeMessage(result, encryptedFields);
+    if (result.type === "prompt_result") {
+      finalizePromptTurnOnBridge(getWs, typeof result.runId === "string" ? result.runId : void 0, result.success === true);
+    }
   };
   const sendSessionUpdate = (payload) => {
     const s = getWs();
@@ -36732,63 +37194,6 @@ function createBridgePromptSenders(deps, getWs) {
 // src/agents/acp/from-bridge/bridge-prompt-preamble.ts
 import { execFile as execFile10 } from "node:child_process";
 import { promisify as promisify10 } from "node:util";
-
-// src/git/bridge-queue-key.ts
-import * as path29 from "node:path";
-import { createHash as createHash2 } from "node:crypto";
-function normalizeCanonicalGitUrl(url2) {
-  let s = url2.trim();
-  if (!s) return s;
-  if (s.toLowerCase().endsWith(".git")) {
-    s = s.slice(0, -4);
-  }
-  s = s.replace(/\/+$/, "");
-  const httpsMatch = /^(https?):\/\/([^/]+)(\/.*)?$/i.exec(s);
-  if (httpsMatch) {
-    const host = httpsMatch[2].toLowerCase();
-    const p = httpsMatch[3] ?? "";
-    s = `${httpsMatch[1].toLowerCase()}://${host}${p}`;
-  } else {
-    const sshMatch = /^git@([^:]+):(.+)$/i.exec(s);
-    if (sshMatch) {
-      const host = sshMatch[1].toLowerCase();
-      s = `git@${host}:${sshMatch[2]}`;
-    }
-  }
-  return s;
-}
-function canonicalUrlToRepoIdSync(url2) {
-  const normalized = normalizeCanonicalGitUrl(url2);
-  return createHash2("sha256").update(normalized).digest("hex").slice(0, 32);
-}
-function fallbackRepoIdFromPath(absPath) {
-  return createHash2("sha256").update(path29.resolve(absPath)).digest("hex").slice(0, 32);
-}
-async function resolveBridgeQueueBindFields(options) {
-  const { effectiveCwd, worktreePaths, primaryRepoRoots, log: log2 } = options;
-  const cwdAbs = worktreePaths.length > 0 ? path29.resolve(worktreePaths[0]) : path29.resolve(effectiveCwd);
-  if (!primaryRepoRoots.length) {
-    log2("[Bridge service] Prompt queue bind skipped: no Git repository roots under the working directory.");
-    return null;
-  }
-  let primaryRoot = primaryRepoRoots[0];
-  let remote = await getRemoteOriginUrl(primaryRoot);
-  if (!remote) {
-    for (const r of primaryRepoRoots.slice(1)) {
-      const u = await getRemoteOriginUrl(r);
-      if (u) {
-        primaryRoot = r;
-        remote = u;
-        break;
-      }
-    }
-  }
-  const repoId = remote ? canonicalUrlToRepoIdSync(remote) : fallbackRepoIdFromPath(primaryRoot);
-  const canonicalQueueKey = `repo:${repoId}::cwd:${cwdAbs}`;
-  return { canonicalQueueKey, repoId, cwdAbs };
-}
-
-// src/agents/acp/from-bridge/bridge-prompt-preamble.ts
 var execFileAsync9 = promisify10(execFile10);
 async function readGitBranch(cwd) {
   try {
@@ -36802,40 +37207,24 @@ async function readGitBranch(cwd) {
 async function runBridgePromptPreamble(params) {
   const { getWs, log: log2, sessionWorktreeManager, sessionId, runId, effectiveCwd } = params;
   const s = getWs();
-  const worktreePaths = sessionWorktreeManager.getWorktreePathsForSession(sessionId) ?? [];
+  const repoCheckoutPaths = sessionWorktreeManager.ensureRepoCheckoutPathsForSession(sessionId);
   const repoRoots = await resolveSnapshotRepoRoots({
-    worktreePaths,
+    worktreePaths: repoCheckoutPaths,
     fallbackCwd: effectiveCwd,
+    sessionId: sessionId?.trim() || void 0,
     log: log2
   });
-  if (s && sessionId) {
-    const bind = await resolveBridgeQueueBindFields({
-      effectiveCwd,
-      worktreePaths,
-      primaryRepoRoots: repoRoots,
-      log: log2
-    });
-    if (bind) {
-      sendWsMessage(s, {
-        type: "bridge_queue_bind",
-        sessionId,
-        canonicalQueueKey: bind.canonicalQueueKey,
-        repoId: bind.repoId,
-        cwdAbs: bind.cwdAbs
-      });
-    }
-  }
   if (s && sessionId) {
     const cliGitBranch = await readGitBranch(effectiveCwd);
     const usesWt = sessionWorktreeManager.usesWorktreeSession(sessionId);
-    const mirrorAbs = sessionWorktreeManager.getAgentCwdForSession(sessionId);
+    const isolatedSessionParentPath = sessionWorktreeManager.getIsolatedSessionParentPathForSession(sessionId);
     sendWsMessage(s, {
       type: "session_git_context_report",
       sessionId,
       cliGitBranch,
       agentUsesWorktree: usesWt,
       sessionParent: usesWt ? "worktrees_root" : "bridge_root",
-      sessionParentPath: usesWt ? mirrorAbs : getBridgeWorkspaceDirectory()
+      sessionParentPath: usesWt ? isolatedSessionParentPath ?? effectiveCwd : getBridgeRoot()
     });
   }
   if (s && sessionId && runId) {
@@ -36962,7 +37351,7 @@ function handleBridgePrompt(msg, deps) {
   const mode = typeof msg.mode === "string" && msg.mode.trim() ? msg.mode.trim() : void 0;
   acpManager.logPromptReceivedFromBridge({ agentType, mode });
   async function preambleAndPrompt(resolvedCwd) {
-    const effectiveCwd = path30.resolve(resolvedCwd ?? getBridgeWorkspaceDirectory());
+    const effectiveCwd = resolveSessionParentPathForAgentProcess(resolvedCwd);
     await runBridgePromptPreamble({
       getWs,
       log: log2,
@@ -36995,7 +37384,7 @@ function handleBridgePrompt(msg, deps) {
       runId,
       mode,
       agentType,
-      cwd: effectiveCwd,
+      sessionParentPath: effectiveCwd,
       sendResult: sendResult2,
       sendSessionUpdate,
       followUpCatalogPromptId,
@@ -37005,8 +37394,8 @@ function handleBridgePrompt(msg, deps) {
       e2ee: deps.e2ee
     });
   }
-  void sessionWorktreeManager.resolveCwdForPrompt(sessionId, { isNewSession, sessionParent, sessionParentPath }).then((cwd) => preambleAndPrompt(cwd)).catch((err) => {
-    log2(`[Agent] Worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`);
+  void sessionWorktreeManager.resolveSessionParentPathForPrompt(sessionId, { isNewSession, sessionParent, sessionParentPath }).then((cwd) => preambleAndPrompt(cwd)).catch((err) => {
+    log2(`[Agent] Session parent path resolve failed: ${err instanceof Error ? err.message : String(err)}`);
     void preambleAndPrompt(void 0);
   });
 }
@@ -37016,6 +37405,11 @@ var handlePromptMessage = (msg, deps) => {
   handleBridgePrompt(msg, deps);
 };
 
+// src/bridge/routing/handlers/prompt-queue-state.ts
+var handlePromptQueueStateMessage = (msg, deps) => {
+  applyPromptQueueStateFromServer(msg, deps);
+};
+
 // src/agents/acp/from-bridge/handle-bridge-cancel-run.ts
 async function handleBridgeCancelRun(msg, { log: log2, acpManager, getWs }) {
   const runId = msg.runId;
@@ -37035,6 +37429,7 @@ async function handleBridgeCancelRun(msg, { log: log2, acpManager, getWs }) {
     error: "Stopped by user",
     stopReason: "no_local_run"
   });
+  finalizePromptTurnOnBridge(getWs, runId, false);
 }
 
 // src/bridge/routing/handlers/cancel-run.ts
@@ -37134,7 +37529,7 @@ var previewSkill = {
         const exe = parts[0];
         const args = parts.slice(1);
         previewProcess = spawn9(isWindows && exe === "npm" ? "npm.cmd" : exe, args, {
-          cwd: getBridgeWorkspaceDirectory(),
+          cwd: getBridgeRoot(),
           stdio: ["ignore", "pipe", "pipe"],
           env: {
             ...process.env,
@@ -37252,12 +37647,12 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs27 from "node:fs";
+import fs29 from "node:fs";
 import path32 from "node:path";
 
 // src/files/ensure-under-cwd.ts
 import path31 from "node:path";
-function ensureUnderCwd(relativePath, cwd = getBridgeWorkspaceDirectory()) {
+function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
   const normalized = path31.normalize(relativePath).replace(/^(\.\/)+/, "");
   const resolved = path31.resolve(cwd, normalized);
   if (!resolved.startsWith(cwd + path31.sep) && resolved !== cwd) {
@@ -37269,12 +37664,12 @@ function ensureUnderCwd(relativePath, cwd = getBridgeWorkspaceDirectory()) {
 // src/files/list-dir.ts
 var LIST_DIR_YIELD_EVERY = 256;
 async function listDirAsync(relativePath) {
-  const resolved = ensureUnderCwd(relativePath || ".", getBridgeWorkspaceDirectory());
+  const resolved = ensureUnderCwd(relativePath || ".", getBridgeRoot());
   if (!resolved) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs27.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs29.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -37287,7 +37682,7 @@ async function listDirAsync(relativePath) {
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs27.promises.stat(fullPath);
+          const targetStat = await fs29.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -37312,25 +37707,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs28 from "node:fs";
+import fs30 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
-  const resolved = ensureUnderCwd(relativePath, getBridgeWorkspaceDirectory());
+  const resolved = ensureUnderCwd(relativePath, getBridgeRoot());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs28.realpathSync(resolved);
+    real = fs30.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat3 = fs28.statSync(real);
+  const stat3 = fs30.statSync(real);
   if (!stat3.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs28.statSync(filePath).size;
-  const fd = fs28.openSync(filePath, "r");
+  const fileSize = fs30.statSync(filePath).size;
+  const fd = fs30.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -37343,7 +37738,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs28.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs30.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -37478,7 +37873,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs28.closeSync(fd);
+    fs30.closeSync(fd);
   }
 }
 function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -37489,8 +37884,8 @@ function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat3 = fs28.statSync(result);
-    const raw = fs28.readFileSync(result, "utf8");
+    const stat3 = fs30.statSync(result);
+    const raw = fs30.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat3.size };
   } catch (err) {
@@ -37508,7 +37903,7 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const cwd = getBridgeWorkspaceDirectory();
+    const cwd = getBridgeRoot();
     const index = loadFileIndex(cwd);
     if (index === null) {
       const payload2 = {
@@ -37532,7 +37927,7 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
 }
 function triggerFileIndexBuild() {
   setImmediate(() => {
-    void ensureFileIndexAsync(getBridgeWorkspaceDirectory()).catch((e) => {
+    void ensureFileIndexAsync(getBridgeRoot()).catch((e) => {
       console.error("[file-index] Background build failed:", e);
     });
   });
@@ -37601,14 +37996,14 @@ function handleFileBrowserSearchMessage(msg, { getWs, e2ee }) {
 function handleSkillLayoutRequest(msg, deps) {
   const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
-  const roots = discoverSkillLayoutRoots(getBridgeWorkspaceDirectory());
+  const roots = discoverSkillLayoutRoots(getBridgeRoot());
   if (socket) {
     sendWsMessage(socket, { type: "skill_layout_response", id, roots });
   }
 }
 
 // src/skills/install-remote-skills.ts
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 import path33 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
@@ -37624,11 +38019,11 @@ function installRemoteSkills(cwd, targetDir, items) {
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
         const dest = path33.join(skillDir, f.path);
-        fs29.mkdirSync(path33.dirname(dest), { recursive: true });
+        fs31.mkdirSync(path33.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs29.writeFileSync(dest, f.text, "utf8");
+          fs31.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs29.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs31.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -37649,7 +38044,7 @@ var handleInstallSkillsMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const targetDir = typeof msg.targetDir === "string" && msg.targetDir.trim() ? msg.targetDir.trim() : ".agents/skills";
   const rawItems = msg.items;
-  const cwd = getBridgeWorkspaceDirectory();
+  const cwd = getBridgeRoot();
   const result = installRemoteSkills(cwd, targetDir, rawItems);
   if (!result.success) {
     const err = result.error ?? "Invalid items";
@@ -37778,7 +38173,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs30 from "node:fs";
+import * as fs32 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -37788,9 +38183,9 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
   void (async () => {
     const s = getWs();
     if (!s) return;
-    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? getBridgeWorkspaceDirectory();
+    const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs30.existsSync(file2)) {
+    if (!fs32.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -37848,6 +38243,9 @@ function dispatchBridgeMessage(msg, deps) {
     case "agent_config":
       handleAgentConfigMessage(msg, deps);
       break;
+    case "prompt_queue_state":
+      handlePromptQueueStateMessage(msg, deps);
+      break;
     case "prompt":
       handlePromptMessage(msg, deps);
       break;
@@ -38077,9 +38475,9 @@ async function createBridgeConnection(options) {
     firehoseGeneration: 0,
     firehoseQuiet: createEmptyReconnectQuietSlot()
   };
-  const worktreesRootAbs = options.worktreesRootAbs ?? defaultWorktreesRootAbs();
+  const worktreesRootPath = options.worktreesRootPath ?? defaultWorktreesRootPath();
   const sessionWorktreeManager = new SessionWorktreeManager({
-    worktreesRootAbs,
+    worktreesRootPath,
     log: logFn
   });
   const acpManager = await createAcpManager({ log: logFn });
@@ -38088,7 +38486,7 @@ async function createBridgeConnection(options) {
     return state.currentWs;
   }
   const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
-  const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeCwd: getBridgeWorkspaceDirectory, e2ee });
+  const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
   const onBridgeIdentified = createOnBridgeIdentified({
     devServerManager,
     firehoseServerUrl,
@@ -38112,8 +38510,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path34.resolve(getBridgeWorkspaceDirectory()),
-    worktreesRootPath: path34.resolve(worktreesRootAbs)
+    bridgeRootPath: path34.resolve(getBridgeRoot()),
+    worktreesRootPath: path34.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -38130,7 +38528,7 @@ async function createBridgeConnection(options) {
     identifyReportedPaths
   });
   connect();
-  const stopFileIndexWatcher = startFileIndexWatcher(getBridgeWorkspaceDirectory());
+  const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
       stopFileIndexWatcher();
@@ -38200,7 +38598,7 @@ async function runConnectedBridge(options, restartWithoutAuth) {
     authToken,
     refreshToken,
     justAuthenticated,
-    worktreesRootAbs,
+    worktreesRootPath,
     e2eCertificate
   } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
@@ -38212,7 +38610,7 @@ async function runConnectedBridge(options, restartWithoutAuth) {
     refreshToken,
     firehoseServerUrl,
     justAuthenticated,
-    worktreesRootAbs,
+    worktreesRootPath,
     e2eCertificate,
     log,
     persistTokens: (t) => {
@@ -38227,7 +38625,7 @@ async function runConnectedBridge(options, restartWithoutAuth) {
       log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
       clearConfigForApi(apiUrl);
       void handle.close().then(() => {
-        void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootAbs, e2eCertificate });
+        void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootPath, e2eCertificate });
       });
     }
   });
@@ -38275,7 +38673,7 @@ async function runBridge(options) {
     workspaceId,
     authToken,
     bridgeName,
-    worktreesRootAbs,
+    worktreesRootPath,
     e2eCertificate
   } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
@@ -38320,7 +38718,7 @@ async function runBridge(options) {
       firehoseServerUrl,
       bridgeName,
       justAuthenticated: true,
-      worktreesRootAbs,
+      worktreesRootPath,
       e2eCertificate
     });
     return;
@@ -38344,30 +38742,31 @@ async function runCliAction(program2, opts) {
   let workspaceId = opts.workspaceId ?? "";
   let authToken = opts.token;
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
-  if (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim()) {
-    const resolvedCwd = path35.resolve(process.cwd(), opts.cwd.trim());
+  const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
+  if (bridgeRootOpt) {
+    const resolvedBridgeRoot = path35.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs31.statSync(resolvedCwd);
+      const st = fs33.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
-        console.error(`--cwd is not a directory: ${resolvedCwd}`);
+        console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
       }
     } catch {
-      console.error(`--cwd path does not exist or is not accessible: ${resolvedCwd}`);
+      console.error(`Bridge root path does not exist or is not accessible: ${resolvedBridgeRoot}`);
       process.exit(1);
     }
-    process.chdir(resolvedCwd);
+    process.chdir(resolvedBridgeRoot);
   }
-  initBridgeWorkspaceDirectory();
+  initBridgeRoot();
   console.log(
     colorize(
       GOLDEN_YELLOW,
-      `[Workspace] Using ${getBridgeWorkspaceDirectory()} as the working directory for file access and agents.`
+      `[Bridge] Using ${getBridgeRoot()} as the bridge root (repos, file index, agents, and bridge_root sessions).`
     )
   );
-  let worktreesRootAbs;
+  let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootAbs = path35.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path35.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {
@@ -38402,7 +38801,7 @@ async function runCliAction(program2, opts) {
     refreshToken,
     firehoseServerUrl,
     bridgeName: opts.name?.trim() || void 0,
-    worktreesRootAbs,
+    worktreesRootPath,
     e2eCertificate: e2eCertificates?.activeCertificate
   });
 }
@@ -38415,8 +38814,11 @@ async function main() {
     "Firehose server URL (default: Fly app; or BUILDAUTOMATON_FIREHOSE_URL / legacy BUILDAUTOMATON_PROXY_URL)",
     process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL
   ).option("--proxy-url <url>", "Deprecated alias for --firehose-url", void 0).option(
+    "--bridge-root <path>",
+    "Bridge root directory (absolute or relative to the current directory): git repos, skills, file index, and agent cwd for bridge_root sessions"
+  ).option(
     "--cwd <path>",
-    "Working directory for the bridge (absolute or relative to the current directory); affects skills, git, file index, and agent cwd"
+    "Deprecated: same as --bridge-root"
   ).option("-n, --name <name>", "Bridge name when creating via browser (alphanumeric and underscores only)").option(
     "--worktrees-root <path>",
     "Root directory for per-session git worktrees (default: ~/.buildautomaton/worktrees)."