openfox 2.0.64 → 2.0.66

package/dist/{chunk-WD75RSGR.js → chunk-3ACDQKK6.js}

@@ -10,10 +10,10 @@ import {
   createToolCallEvent,
   createToolResultEvent,
   streamLLMPure
-} from "./chunk-X5YCWKNS.js";
+} from "./chunk-R4UTFE63.js";
 import {
   startInspectProxy
-} from "./chunk-LBGHZLLH.js";
+} from "./chunk-WNA5VPZG.js";
 import {
   createProcess,
   getPlatformShell,
@@ -31,12 +31,15 @@ import {
 import {
   createMcpTools
 } from "./chunk-NWO6GRYE.js";
+import {
+  listBranches
+} from "./chunk-OBK3I4KD.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore,
   getRuntimeConfig
-} from "./chunk-AIJE3RYH.js";
+} from "./chunk-TFDK6VSG.js";
 import {
   buildContextMessagesFromEventHistory,
   foldContextState,
@@ -46,7 +49,7 @@ import {
   handleToolResult,
   reorderToolMessages,
   stripOrphanedToolCalls
-} from "./chunk-TMUBLQFC.js";
+} from "./chunk-C3VLGVSQ.js";
 import {
   createChatDoneMessage,
   createChatMessageMessage,
@@ -54,19 +57,19 @@ import {
   createChatPathConfirmationMessage,
   createQueueStateMessage
 } from "./chunk-F4PMNP7S.js";
-import {
-  AskUserInterrupt,
-  askUserTool
-} from "./chunk-EU3WWTFH.js";
 import {
   SETTINGS_KEYS,
   deleteSetting,
   getSetting,
   setSetting
-} from "./chunk-SVSKQYFH.js";
+} from "./chunk-PVRSNXD4.js";
+import {
+  AskUserInterrupt,
+  askUserTool
+} from "./chunk-EU3WWTFH.js";
 import {
   getProject
-} from "./chunk-YQ3SOPBI.js";
+} from "./chunk-KXVFHMSM.js";
 import {
   modelSupportsVision
 } from "./chunk-V4IE7HJY.js";
@@ -225,6 +228,10 @@ async function isPathWithinSandbox(path, workdir, sessionId) {
 function looksLikeRegex(str) {
   return /[*?+[\]\\]/.test(str);
 }
+var isWindows = () => process.platform === "win32";
+function isWindowsAbsolutePath(str) {
+  return /^[A-Za-z]:[\\/]/.test(str);
+}
 function isPlaceholderToken(str) {
   return str.includes("__URL__") || str.includes("__FILEURL__") || str.includes("__SED__") || str.includes("__COMMIT_MSG__");
 }
@@ -269,7 +276,12 @@ function extractAbsolutePathsFromCommand(command) {
     if (content.startsWith("/") && looksLikeRegex(content)) {
       continue;
     }
-    if (content.startsWith("/")) {
+    if (isWindowsAbsolutePath(content)) {
+      const resolved = normalize(content);
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    } else if (!isWindows() && content.startsWith("/")) {
       const resolved = normalize(content);
       if (!isSafePath(resolved)) {
         paths.push(resolved);
@@ -283,15 +295,27 @@ function extractAbsolutePathsFromCommand(command) {
       }
     }
   }
-  const absolutePattern = /(?:^|[\s=(])(\/[^\s"'|&;<>`()]+)/g;
-  while ((match = absolutePattern.exec(sanitized)) !== null) {
-    const candidate = match[1];
-    if (isPlaceholderToken(candidate)) continue;
-    if (looksLikeRegex(candidate)) continue;
-    const resolved = normalize(candidate);
-    if (resolved === "/" || resolved === "") continue;
-    if (!isSafePath(resolved)) {
-      paths.push(resolved);
+  if (isWindows()) {
+    const winAbsolutePattern = /(?:^|[\s=(])([A-Za-z]:[\\/][^\s"'|&;<>`()]+)/g;
+    while ((match = winAbsolutePattern.exec(sanitized)) !== null) {
+      const candidate = match[1];
+      if (isPlaceholderToken(candidate)) continue;
+      const resolved = normalize(candidate);
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
+    }
+  } else {
+    const absolutePattern = /(?:^|[\s=(])(\/[^\s"'|&;<>`()]+)/g;
+    while ((match = absolutePattern.exec(sanitized)) !== null) {
+      const candidate = match[1];
+      if (isPlaceholderToken(candidate)) continue;
+      if (looksLikeRegex(candidate)) continue;
+      const resolved = normalize(candidate);
+      if (resolved === "/" || resolved === "") continue;
+      if (!isSafePath(resolved)) {
+        paths.push(resolved);
+      }
     }
   }
   return [...new Set(paths)];
@@ -1448,7 +1472,10 @@ Make sure whitespace and indentation match exactly.`
 );
 
 // src/server/tools/shell.ts
+import { spawn as spawn2 } from "child_process";
 import { resolve as resolve4, isAbsolute as isAbsolute2 } from "path";
+import { access } from "fs/promises";
+import stripAnsi from "strip-ansi";
 
 // src/server/utils/shell.ts
 import { spawn } from "child_process";
@@ -1480,6 +1507,33 @@ function stripTailPipe(command) {
 }
 
 // src/server/tools/shell.ts
+var rtkAvailable;
+async function checkRtkAvailability() {
+  if (rtkAvailable !== void 0) return rtkAvailable;
+  try {
+    await access("/usr/local/bin/rtk");
+    rtkAvailable = true;
+  } catch {
+    try {
+      const out = await new Promise((resolve6, reject) => {
+        const proc = spawn2("rtk", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        proc.stdout?.on("data", (d) => {
+          output += d.toString();
+        });
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+          if (code === 0) resolve6(output.trim());
+          else reject(new Error(`exit ${code}`));
+        });
+      });
+      rtkAvailable = out.startsWith("rtk ");
+    } catch {
+      rtkAvailable = false;
+    }
+  }
+  return rtkAvailable;
+}
 function hasBackgroundAmpersand(command) {
   const trimmed = command.replace(/[;\s]+$/, "");
   if (trimmed.endsWith("&")) {
@@ -1538,7 +1592,9 @@ var runCommandTool = createTool(
     await helpers.checkPathAccess(pathsToCheck, args.command);
     const tailInfo = stripTailPipe(args.command);
     const execCommand = tailInfo ? tailInfo.command : args.command;
-    const result = await executeCommand(execCommand, workingDir, timeout, context.signal, context.onProgress);
+    const useRtk = getSetting(SETTINGS_KEYS.TOOLS_USE_RTK) === "true";
+    const finalCommand = useRtk ? await tryRtkRewrite(execCommand) : execCommand;
+    const result = await executeCommand(finalCommand, workingDir, timeout, context.signal, context.onProgress);
     let output = "";
     if (result.stdout) {
       output += result.stdout;
@@ -1556,13 +1612,14 @@ ${result.stderr}`;
       const tailed = lines.slice(-tailInfo.tailLines);
       output = tailed.join("\n");
     }
+    const visible = stripAnsi(output);
     let truncated = false;
-    if (output.length > OUTPUT_LIMITS.run_command.maxBytes) {
+    if (visible.length > OUTPUT_LIMITS.run_command.maxBytes) {
       output = output.slice(0, OUTPUT_LIMITS.run_command.maxBytes);
       output += "\n\n[Output truncated due to size limit]";
       truncated = true;
     }
-    const linesCount = output.split("\n").length;
+    const linesCount = visible.split("\n").length;
     if (linesCount > OUTPUT_LIMITS.run_command.maxLines) {
       const limitedLines = output.split("\n").slice(0, OUTPUT_LIMITS.run_command.maxLines);
       output = limitedLines.join("\n");
@@ -1576,6 +1633,29 @@ ${result.stderr}`;
     });
   }
 );
+async function tryRtkRewrite(command) {
+  if (!await checkRtkAvailability()) return command;
+  try {
+    const result = await new Promise((resolve6, reject) => {
+      const proc = spawn2("rtk", ["rewrite", command], {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 2e3
+      });
+      let stdout = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.on("error", reject);
+      proc.on("close", (code) => {
+        if (code === 0 || code === 3) resolve6(stdout.trim());
+        else reject(new Error(`exit ${code}`));
+      });
+    });
+    if (result && result !== command) return result;
+  } catch {
+  }
+  return command;
+}
 function executeCommand(command, cwd, timeout, signal, onProgress) {
   return new Promise((resolve6, reject) => {
     if (checkAborted(signal)) {
@@ -1800,24 +1880,24 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
 );
 
 // src/server/sub-agents/manager.ts
-import { readFile as readFile8, access as access4 } from "fs/promises";
+import { readFile as readFile8, access as access5 } from "fs/promises";
 import { join as join7, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
 
 // src/server/agents/registry.ts
-import { readdir as readdir3, readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3, access as access2, unlink as unlink2 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3, access as access3, unlink as unlink2 } from "fs/promises";
 import { join as join4, dirname as dirname2 } from "path";
 import { constants as constants2 } from "fs";
 import { fileURLToPath } from "url";
 import matter2 from "gray-matter";
 
 // src/server/shared/item-loader.ts
-import { readdir as readdir2, readFile as readFile4, access, writeFile as writeFile3, mkdir as mkdir2, unlink } from "fs/promises";
+import { readdir as readdir2, readFile as readFile4, access as access2, writeFile as writeFile3, mkdir as mkdir2, unlink } from "fs/promises";
 import { join as join3 } from "path";
 import { constants } from "fs";
 import matter from "gray-matter";
 async function pathExists(path) {
   try {
-    await access(path, constants.R_OK);
+    await access2(path, constants.R_OK);
     return true;
   } catch {
     return false;
@@ -1895,7 +1975,7 @@ function getProjectAgentsDir(projectDir) {
 }
 async function pathExists2(path) {
   try {
-    await access2(path, constants2.R_OK);
+    await access3(path, constants2.R_OK);
     return true;
   } catch {
     return false;
@@ -2074,7 +2154,7 @@ async function deleteAgent(configDir, agentId) {
 }
 
 // src/server/context/instructions.ts
-import { readFile as readFile6, access as access3 } from "fs/promises";
+import { readFile as readFile6, access as access4 } from "fs/promises";
 import { join as join5, dirname as dirname3 } from "path";
 import { constants as constants3 } from "fs";
 var INSTRUCTION_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
@@ -2157,7 +2237,7 @@ ${agentContent}`);
 }
 async function fileExists(path) {
   try {
-    await access3(path, constants3.R_OK);
+    await access4(path, constants3.R_OK);
     return true;
   } catch {
     return false;
@@ -2500,7 +2580,7 @@ function createToolProgressHandler(append, messageId, callId, _sessionId) {
 }
 
 // src/server/chat/execute-tools.ts
-import stripAnsi from "strip-ansi";
+import stripAnsi2 from "strip-ansi";
 var INTERRUPTED_ERROR = "Tool execution was interrupted by user";
 function createInterruptedResult(startTime) {
   return {
@@ -2564,19 +2644,24 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
       };
     }
     if (toolCall.parseError) {
-      const toolResult2 = {
-        success: false,
-        error: `Failed to parse tool call arguments: ${toolCall.parseError}. Please ensure your JSON function call arguments are valid.`,
-        durationMs: 0,
-        truncated: false
-      };
-      append(createToolResultEvent(assistantMsgId, toolCall.id, toolResult2));
-      return {
-        toolCall,
-        toolResult: toolResult2,
-        content: `Error: ${toolResult2.error}`,
-        index
-      };
+      if (toolCall.name === "step_done") {
+        const { parseError: _pe, rawArguments: _ra, ...rest } = toolCall;
+        toolCall = { ...rest, arguments: {} };
+      } else {
+        const toolResult2 = {
+          success: false,
+          error: `Failed to parse tool call arguments: ${toolCall.parseError}. Please ensure your JSON function call arguments are valid.`,
+          durationMs: 0,
+          truncated: false
+        };
+        append(createToolResultEvent(assistantMsgId, toolCall.id, toolResult2));
+        return {
+          toolCall,
+          toolResult: toolResult2,
+          content: `Error: ${toolResult2.error}`,
+          index
+        };
+      }
     }
     const onProgress = ctx.onMessage ? createToolProgressHandler(append, assistantMsgId, toolCall.id, ctx.sessionId) : void 0;
     const toolContext = {
@@ -2612,7 +2697,7 @@ async function executeTools(assistantMsgId, toolCalls, ctx, append) {
     if (toolCall.name === "step_done" && toolResult.success) {
       stepDoneCalled = true;
     }
-    const content = stripAnsi(
+    const content = stripAnsi2(
       toolResult.success ? toolResult.output ?? "Success" : toolResult.output ? `${toolResult.output}
 
 Error: ${toolResult.error}` : `Error: ${toolResult.error}`
@@ -2883,7 +2968,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
     sessionManager.setCurrentContextSize(sessionId, result.usage.promptTokens);
     if (!compacting) {
       const contextState2 = sessionManager.getContextState(sessionId);
-      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-I3N56PSJ.js");
+      const { shouldCompact, appendCompactionPrompt } = await import("./compactor-V43WJ3WX.js");
       if (shouldCompact(contextState2.currentTokens, contextState2.maxTokens, runtimeConfig.context.compactionThreshold)) {
         appendCompactionPrompt(sessionId, append);
         compacting = true;
@@ -2964,7 +3049,7 @@ ${COMPACTION_PROMPT}`,
           toolRegistry,
           sessionManager,
           sessionId,
-          workdir: session.workdir,
+          workdir: session.worktree ?? session.workdir,
           turnMetrics,
           signal,
           onMessage,
@@ -3585,7 +3670,7 @@ async function loadGitIgnoreRules(workdir) {
   while (true) {
     const gitignorePath = join7(currentDir, ".gitignore");
     try {
-      await access4(gitignorePath);
+      await access5(gitignorePath);
       const content = await readFile8(gitignorePath, "utf-8");
       const trimmed = content.trim();
       if (!trimmed) return "";
@@ -3673,13 +3758,14 @@ async function executeSubAgent(options) {
       })
     );
   }
-  const { content: instructionContent } = await getAllInstructions(session.workdir, session.projectId);
+  const effectiveWorkdir = session.worktree ?? session.workdir;
+  const { content: instructionContent } = await getAllInstructions(effectiveWorkdir, session.projectId);
   const config = getRuntimeConfig();
   const configDir = getGlobalConfigDir(config.mode ?? "production");
   const skills = await getEnabledSkillMetadata(configDir, config.workdir);
   const hasRunCommand = agentDef.metadata.allowedTools?.includes("run_command") ?? false;
-  const gitignoreSection = hasRunCommand ? await loadGitIgnoreRules(session.workdir) : "";
-  const systemPrompt = buildBasePrompt(session.workdir, void 0, skills.length > 0 ? skills : void 0, llmClient.getModel()) + "\n\n" + agentDef.prompt + (gitignoreSection ? "\n\n" + gitignoreSection : "") + RETURN_VALUE_INSTRUCTION;
+  const gitignoreSection = hasRunCommand ? await loadGitIgnoreRules(effectiveWorkdir) : "";
+  const systemPrompt = buildBasePrompt(effectiveWorkdir, void 0, skills.length > 0 ? skills : void 0, llmClient.getModel()) + "\n\n" + agentDef.prompt + (gitignoreSection ? "\n\n" + gitignoreSection : "") + RETURN_VALUE_INSTRUCTION;
   const subAgentScope = { type: "subagent", sessionId, subAgentId, subAgentType };
   const loopResult = await runTopLevelAgentLoop(
     {
@@ -3787,7 +3873,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-R6LPK6OS.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-2EB7C6H2.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -4071,11 +4157,15 @@ var webFetchTool = createTool(
 );
 
 // src/server/dev-server/manager.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
 import { resolve as resolve5, join as join8 } from "path";
+import net from "net";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
+var DEFAULT_PROBE_PORT = 3e3;
+var MAX_PORT_SCAN = 200;
+var PROBE_TIMEOUT_MS = 300;
 var getDevServerConfigPath = (workdir) => {
   const mode = getRuntimeConfig().mode ?? "production";
   return join8(resolve5(workdir), ".openfox", `${mode === "development" ? "dev-dev" : "dev"}.json`);
@@ -4096,6 +4186,9 @@ function createInstance() {
     process: null,
     state: "off",
     config: null,
+    resolvedUrl: null,
+    resolvedCommand: null,
+    assignedPort: null,
     logs: [],
     totalLogBytes: 0,
     errorMessage: void 0,
@@ -4104,6 +4197,17 @@ function createInstance() {
     proxyCleanup: null
   };
 }
+function parsePortFromUrl(url) {
+  const substituted = url.replace(/\$\{PORT\}/g, String(DEFAULT_PROBE_PORT));
+  try {
+    const parsed = new URL(substituted);
+    const port = parsed.port ? parseInt(parsed.port, 10) : DEFAULT_PROBE_PORT;
+    return { hostname: parsed.hostname, port: isNaN(port) ? DEFAULT_PROBE_PORT : port };
+  } catch {
+    logger.warn("Failed to parse dev server URL, falling back to defaults", { url });
+    return { hostname: "127.0.0.1", port: DEFAULT_PROBE_PORT };
+  }
+}
 var DevServerManager = class {
   instances = /* @__PURE__ */ new Map();
   outputListeners = /* @__PURE__ */ new Set();
@@ -4136,21 +4240,78 @@ var DevServerManager = class {
       listener(resolved, state, errorMessage);
     }
   }
+  /** Probe whether a TCP port is in use */
+  async probePort(host, port) {
+    return new Promise((resolvePromise) => {
+      const socket = new net.Socket();
+      socket.setTimeout(PROBE_TIMEOUT_MS);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolvePromise(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolvePromise(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolvePromise(false);
+      });
+      socket.connect(port, host);
+    });
+  }
+  /**
+   * Find a free port starting from preferred, scanning upward.
+   * Throws if no free port found within range.
+   */
+  async findFreePort(host, preferred) {
+    const inUse = await this.probePort(host, preferred);
+    if (!inUse) return preferred;
+    const maxPort = Math.min(preferred + MAX_PORT_SCAN, 65535);
+    for (let port = preferred + 1; port <= maxPort; port++) {
+      const taken = await this.probePort(host, port);
+      if (!taken) return port;
+    }
+    throw new Error(
+      `No free port found in range ${preferred}-${maxPort} on ${host}. Close some applications or configure a different port in .openfox/dev.json`
+    );
+  }
+  /** Substitute ${PORT} placeholders with actual port number */
+  substitutePort(template, port) {
+    return template.replace(/\$\{PORT\}/g, String(port));
+  }
+  /**
+   * Load dev server config from workdir.
+   * If not found and the path looks like a git worktree (contains /worktrees/),
+   * falls back to the parent project root.
+   */
   async loadConfig(workdir) {
-    try {
-      const configPath = getDevServerConfigPath(workdir);
-      const raw = await readFile9(configPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!parsed.command || !parsed.url) return null;
-      return {
-        command: parsed.command,
-        url: parsed.url,
-        hotReload: parsed.hotReload ?? false,
-        disableInspect: parsed.disableInspect ?? false
-      };
-    } catch {
-      return null;
+    const tryLoad = async (dir) => {
+      try {
+        const configPath = getDevServerConfigPath(dir);
+        const raw = await readFile9(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.command || !parsed.url) return null;
+        return {
+          command: parsed.command,
+          url: parsed.url,
+          hotReload: parsed.hotReload ?? false,
+          disableInspect: parsed.disableInspect ?? false
+        };
+      } catch {
+        return null;
+      }
+    };
+    const config = await tryLoad(workdir);
+    if (config) return config;
+    const wtIdx = workdir.indexOf("/worktrees/");
+    if (wtIdx !== -1) {
+      const projectRoot = workdir.slice(0, wtIdx);
+      if (projectRoot !== workdir) {
+        return tryLoad(projectRoot);
+      }
     }
+    return null;
   }
   async saveConfig(workdir, config) {
     const resolved = this.resolveWorkdir(workdir);
@@ -4168,24 +4329,31 @@ var DevServerManager = class {
     if (!config) {
       return this.getStatus(workdir);
     }
+    const { hostname, port: configuredPort } = parsePortFromUrl(config.url);
+    const assignedPort = await this.findFreePort(hostname, configuredPort);
+    instance.assignedPort = assignedPort;
+    const resolvedCommand = this.substitutePort(config.command, assignedPort);
+    const resolvedUrl = this.substitutePort(config.url, assignedPort);
+    instance.resolvedCommand = resolvedCommand;
+    instance.resolvedUrl = resolvedUrl;
     instance.config = config;
     instance.logs = [];
     instance.totalLogBytes = 0;
     instance.errorMessage = void 0;
     instance.exited = false;
-    if (!config.disableInspect && config.url && this._sessionManager) {
+    if (!config.disableInspect && resolvedUrl && this._sessionManager) {
       try {
-        const { port, cleanup } = startInspectProxy(config.url, this._sessionManager, workdir);
+        const { port, cleanup } = startInspectProxy(resolvedUrl, this._sessionManager, workdir);
         instance.inspectProxyPort = port;
         instance.proxyCleanup = cleanup;
-        logger.debug("Inspect proxy started", { workdir, port, target: config.url });
+        logger.debug("Inspect proxy started", { workdir, port, target: resolvedUrl });
       } catch (err) {
         logger.warn("Failed to start inspect proxy", { workdir, error: err });
       }
     }
     const resolved = this.resolveWorkdir(workdir);
     const shell = getPlatformShell();
-    const proc = spawn2(shell.command, [...shell.args, config.command], {
+    const proc = spawn3(shell.command, [...shell.args, resolvedCommand], {
       cwd: resolved,
       env: { ...process.env, FORCE_COLOR: "1" },
       stdio: ["ignore", "pipe", "pipe"],
@@ -4243,7 +4411,7 @@ ${recentLogs}`.trim();
     instance.state = "running";
     instance.errorMessage = void 0;
     this.emitStateChange(workdir, "running", void 0);
-    logger.info("Dev server started", { workdir, command: config.command });
+    logger.info("Dev server started", { workdir, command: resolvedCommand, port: assignedPort });
     return this.getStatus(workdir);
   }
   async stop(workdir) {
@@ -4272,7 +4440,7 @@ ${recentLogs}`.trim();
     const instance = this.getInstance(workdir);
     return {
       state: instance.state,
-      url: instance.config?.url ?? null,
+      url: instance.resolvedUrl ?? instance.config?.url ?? null,
       hotReload: instance.config?.hotReload ?? false,
       config: instance.config,
       errorMessage: instance.errorMessage,
@@ -4318,7 +4486,7 @@ var devServerTool = createTool(
     type: "function",
     function: {
       name: "dev_server",
-      description: "Control the project dev server. Start, stop, restart, check status, or fetch logs with optional pagination. The dev server is configured via .openfox/dev.json in the project root with fields: command (string, required), url (string, required), hotReload (boolean, optional, default false), disableInspect (boolean, optional, default false).",
+      description: "Control the project dev server. Start, stop, restart, check status, or fetch logs with optional pagination. The dev server is configured via .openfox/dev.json in the project root with fields: command (string, required), url (string, required), hotReload (boolean, optional, default false), disableInspect (boolean, optional, default false). You can use ${PORT} in command and url \u2014 it will be replaced with an available port at runtime (auto-assigned if the configured port is taken).",
       parameters: {
         type: "object",
         properties: {
@@ -4709,7 +4877,7 @@ var mcpConfigTool = createTool(
       mcpNotifyChanged?.(sessionId);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-R6LPK6OS.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-2EB7C6H2.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4807,270 +4975,6 @@ var mcpConfigTool = createTool(
   }
 );
 
-// src/server/tools/trace-code.ts
-import { stat as stat2, readFile as readFile10 } from "fs/promises";
-function graphNode(location, depth, relation, symbolName, symbolKind) {
-  const node = { location, depth, relation, symbolName };
-  if (symbolKind) node.symbolKind = symbolKind;
-  return node;
-}
-var MAX_DEPTH = 5;
-var VALID_DIRECTIONS = ["up", "down", "both"];
-var SNIPPET_RADIUS = 2;
-var CACHE_MAX_SIZE = 50;
-function locationKey(loc) {
-  return `${loc.path}:${loc.line}:${loc.character}`;
-}
-function formatLocation(loc, workdir) {
-  const relPath = loc.path.startsWith(workdir) ? loc.path.slice(workdir.length + 1) : loc.path;
-  return `${relPath}:${loc.line + 1}:${loc.character}`;
-}
-var fileCache = /* @__PURE__ */ new Map();
-async function getCachedLines(path, approvedPaths) {
-  if (!approvedPaths.has(path)) return [];
-  const cached = fileCache.get(path);
-  if (cached) {
-    try {
-      const stats = await stat2(path);
-      if (stats.mtimeMs === cached.mtimeMs) {
-        return cached.lines;
-      }
-    } catch {
-    }
-  }
-  try {
-    const stats = await stat2(path);
-    const content = await readFile10(path, "utf-8");
-    const lines = content.split("\n");
-    fileCache.set(path, { mtimeMs: stats.mtimeMs, lines });
-    if (fileCache.size > CACHE_MAX_SIZE) {
-      const oldest = fileCache.keys().next();
-      if (!oldest.done && oldest.value !== void 0) {
-        fileCache.delete(oldest.value);
-      }
-    }
-    return lines;
-  } catch {
-    return [];
-  }
-}
-async function getSnippet(path, line, approvedPaths, radius = SNIPPET_RADIUS) {
-  const lines = await getCachedLines(path, approvedPaths);
-  if (lines.length === 0) return "";
-  const start = Math.max(0, line - radius);
-  const end = Math.min(lines.length - 1, line + radius);
-  const lineNumWidth = String(end + 1).length;
-  const result = [];
-  for (let i = start; i <= end; i++) {
-    const gutter = i === line ? ">" : " ";
-    const lineNum = String(i + 1).padStart(lineNumWidth);
-    result.push(`${gutter} ${lineNum}\u2502 ${lines[i] ?? ""}`);
-  }
-  return result.join("\n");
-}
-function formatEdgeLabel(relation) {
-  switch (relation) {
-    case "definition":
-      return "definition";
-    case "references":
-      return "reference";
-    case "type-definition":
-      return "type definition";
-    default:
-      return relation;
-  }
-}
-async function collectNodes(lsp, startLocations, symbolName, symbolKind, maxDepth, direction) {
-  const visited = /* @__PURE__ */ new Set();
-  const nodes = [];
-  const edges = [];
-  const queue = startLocations.map((loc) => ({ location: loc, depth: 0, relation: "match" }));
-  let idx = 0;
-  while (idx < queue.length) {
-    const item = queue[idx];
-    idx++;
-    const key = locationKey(item.location);
-    if (visited.has(key)) continue;
-    visited.add(key);
-    nodes.push(graphNode(item.location, item.depth, item.relation, symbolName, symbolKind));
-    if (item.parentKey) {
-      const relation = item.relation === "definition" ? "definition" : item.relation === "type-definition" ? "type-definition" : "references";
-      edges.push({ from: item.parentKey, to: key, relation });
-    }
-    if (item.depth >= maxDepth) continue;
-    const { path, line, character } = item.location;
-    if (direction === "down" || direction === "both") {
-      const defs = await lsp.getDefinition(path, line, character);
-      for (const def of defs) {
-        const defKey = locationKey(def);
-        if (!visited.has(defKey)) {
-          queue.push({ location: def, depth: item.depth + 1, relation: "definition", parentKey: key });
-        }
-      }
-      const typeDefs = await lsp.getTypeDefinition(path, line, character);
-      for (const td of typeDefs) {
-        const tdKey = locationKey(td);
-        if (!visited.has(tdKey)) {
-          queue.push({ location: td, depth: item.depth + 1, relation: "type-definition", parentKey: key });
-        }
-      }
-    }
-    if (direction === "up" || direction === "both") {
-      const refs = await lsp.getReferences(path, line, character);
-      for (const ref of refs) {
-        const refKey = locationKey(ref);
-        if (!visited.has(refKey)) {
-          queue.push({ location: ref, depth: item.depth + 1, relation: "reference", parentKey: key });
-        }
-      }
-    }
-  }
-  return { nodes, edges };
-}
-async function formatOutput(symbolName, direction, depth, nodes, edges, workdir, approvedPaths) {
-  const lines = [];
-  lines.push(`Symbol: ${symbolName}`);
-  lines.push(`Direction: ${direction} | Depth: ${depth}`);
-  lines.push(`Nodes: ${nodes.length} | Edges: ${edges.length}`);
-  lines.push("");
-  if (nodes.length === 0) {
-    lines.push("No results found.");
-    return lines.join("\n");
-  }
-  const byDepth = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    const group = byDepth.get(node.depth) ?? [];
-    group.push(node);
-    byDepth.set(node.depth, group);
-  }
-  for (const [depth2, group] of [...byDepth.entries()].sort(([a], [b]) => a - b)) {
-    lines.push(`\u2500\u2500 Depth ${depth2} \u2500\u2500`);
-    const fileGroups = /* @__PURE__ */ new Map();
-    for (const node of group) {
-      const fileKey = node.location.path;
-      const fileGroup = fileGroups.get(fileKey) ?? [];
-      fileGroup.push(node);
-      fileGroups.set(fileKey, fileGroup);
-    }
-    for (const [filePath, fileNodes] of fileGroups) {
-      const relPath = filePath.startsWith(workdir) ? filePath.slice(workdir.length + 1) : filePath;
-      if (fileNodes.length > 5) {
-        const kinds = [...new Set(fileNodes.map((n) => formatEdgeLabel(n.relation)))];
-        lines.push(`  ${kinds.join(", ")} \xD7 ${fileNodes.length} in ${relPath}`);
-      } else {
-        for (const node of fileNodes) {
-          const label = formatEdgeLabel(node.relation);
-          const kind = node.symbolKind ? ` (${node.symbolKind})` : "";
-          const loc = formatLocation(node.location, workdir);
-          lines.push(`  ${label}: ${loc}${kind}`);
-          const snippet = await getSnippet(node.location.path, node.location.line, approvedPaths);
-          if (snippet) {
-            for (const snipLine of snippet.split("\n")) {
-              lines.push(`    ${snipLine}`);
-            }
-          }
-        }
-      }
-    }
-    lines.push("");
-  }
-  if (edges.length > 0 && edges.length <= 20) {
-    lines.push("Edges:");
-    for (const edge of edges) {
-      lines.push(`  ${edge.from} \u2500\u2500${edge.relation}\u2500\u2500\u25B6 ${edge.to}`);
-    }
-    lines.push("");
-  } else if (edges.length > 20) {
-    lines.push(`Edges: ${edges.length} total (suppressed, too many to display individually)`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-var traceCodeTool = createTool(
-  "trace_code",
-  {
-    type: "function",
-    function: {
-      name: "trace_code",
-      description: 'Trace a symbol through the codebase using LSP. Finds definitions, references, and type definitions up to a configurable depth. The "file" param is just a seed for LSP \u2014 use any file where you saw the symbol, it searches the whole project.',
-      parameters: {
-        type: "object",
-        properties: {
-          symbol: {
-            type: "string",
-            description: 'Symbol name to trace (e.g., "rebuildTools", "handleSubmit", "UserProfile")'
-          },
-          file: {
-            type: "string",
-            description: "Seed file for LSP (any file referencing the symbol). Determines language. Not required to be the definition file. Relative to workdir."
-          },
-          depth: {
-            type: "number",
-            description: "Graph traversal depth (default: 1, max: 5). How many hops to follow. Start with 1 for immediate defs+refs.",
-            default: 1
-          },
-          direction: {
-            type: "string",
-            enum: ["up", "down", "both"],
-            description: '"down" follows definitions, "up" finds references, "both" does both (default).',
-            default: "both"
-          }
-        },
-        required: ["symbol", "file"]
-      }
-    }
-  },
-  async (args, context, helpers) => {
-    const symbol = args.symbol?.trim();
-    if (!symbol) {
-      return helpers.error("symbol is required");
-    }
-    const file = args.file?.trim();
-    if (!file) {
-      return helpers.error("file is required");
-    }
-    const depth = args.depth ?? 1;
-    if (depth > MAX_DEPTH) {
-      return helpers.error(`depth cannot exceed ${MAX_DEPTH}`);
-    }
-    const direction = args.direction ?? "both";
-    if (!VALID_DIRECTIONS.includes(direction)) {
-      return helpers.error(`direction must be one of: ${VALID_DIRECTIONS.join(", ")}`);
-    }
-    const lsp = context.lspManager;
-    if (!lsp) {
-      return helpers.error("LSP is not available. The trace_code tool requires a running LSP server.");
-    }
-    const fullPath = helpers.resolvePath(file);
-    try {
-      await stat2(fullPath);
-    } catch {
-      return helpers.error(`File not found: "${file}". Check that the path exists.`);
-    }
-    let symbols;
-    try {
-      symbols = await lsp.seedAndFindWorkspaceSymbol(symbol, fullPath);
-    } catch {
-      return helpers.error(`Failed to search for symbol "${symbol}". LSP may not be responding.`);
-    }
-    if (symbols.length === 0) {
-      const installHint = lsp.getInstallHint(fullPath);
-      const hint = installHint ? ` ${installHint}` : "";
-      return helpers.error(
-        `Symbol "${symbol}" not found in "${file}". Check that the symbol name is correct and that the LSP server has indexed the project.${hint}`
-      );
-    }
-    const startLocations = symbols.map((s) => s.location);
-    const symbolKind = symbols[0].kind;
-    const { nodes, edges } = await collectNodes(lsp, startLocations, symbol, symbolKind, depth, direction);
-    const allPaths = [...new Set(nodes.map((n) => n.location.path))];
-    await helpers.checkPathAccess(allPaths);
-    const approvedPaths = new Set(allPaths);
-    const output = await formatOutput(symbol, direction, depth, nodes, edges, context.workdir, approvedPaths);
-    return helpers.success(output);
-  }
-);
-
 // src/server/tools/web-search.ts
 var DEFAULT_TIMEOUT_MS2 = 15e3;
 var DEFAULT_MAX_RESULTS = 5;
@@ -5206,6 +5110,120 @@ var webSearchTool = createTool(
   }
 );
 
+// src/server/tools/worktree.ts
+var worktreeTool = createTool(
+  "worktree",
+  {
+    type: "function",
+    function: {
+      name: "worktree",
+      description: "Manage git worktrees for the current session. Use this to work on isolated branches without affecting the main working tree.\n\nActions:\n- list_branches: List local git branches for the current project\n- create: Create a new branch + git worktree and attach this session to it (provide: name)\n- attach: Attach this session to an existing git worktree by path (provide: path)\n- close: Close the current worktree and return the session to the project root\n- status: Show current worktree state (active branch, worktree path)",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list_branches", "create", "attach", "close", "status"],
+            description: "The action to perform"
+          },
+          name: {
+            type: "string",
+            description: "Branch name for creating a new worktree (required for action=create)"
+          },
+          path: {
+            type: "string",
+            description: "Path to an existing worktree directory (required for action=attach)"
+          }
+        },
+        required: ["action"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const { sessionId, sessionManager } = context;
+    const validActions = ["list_branches", "create", "attach", "close", "status"];
+    if (!validActions.includes(args.action)) {
+      return helpers.error(`Invalid action: ${args.action}. Must be one of: ${validActions.join(", ")}`);
+    }
+    switch (args.action) {
+      case "list_branches": {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) return helpers.error("Session not found");
+        const project = sessionManager.getProject(session.projectId);
+        if (!project) return helpers.error("Project not found");
+        const branches = await listBranches(project.workdir);
+        return helpers.success(JSON.stringify({ branches }, null, 2));
+      }
+      case "create": {
+        if (!args.name || typeof args.name !== "string") {
+          return helpers.error('Parameter "name" is required for action=create (the branch name)');
+        }
+        const updated = await sessionManager.createSessionWorktree(sessionId, args.name);
+        return helpers.success(
+          JSON.stringify(
+            {
+              worktree: updated.worktree,
+              branch: args.name,
+              message: `Worktree created and session attached to branch "${args.name}"`
+            },
+            null,
+            2
+          )
+        );
+      }
+      case "attach": {
+        if (!args.path || typeof args.path !== "string") {
+          return helpers.error('Parameter "path" is required for action=attach (path to existing worktree)');
+        }
+        const updated = await sessionManager.attachSessionWorktree(sessionId, args.path);
+        return helpers.success(
+          JSON.stringify(
+            {
+              worktree: updated.worktree,
+              message: `Session attached to existing worktree at ${args.path}`
+            },
+            null,
+            2
+          )
+        );
+      }
+      case "close": {
+        const updated = await sessionManager.closeSessionWorktree(sessionId);
+        return helpers.success(
+          JSON.stringify(
+            {
+              worktree: updated.worktree,
+              workdir: updated.workdir,
+              message: "Worktree closed. Session returned to project root."
+            },
+            null,
+            2
+          )
+        );
+      }
+      case "status": {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) return helpers.error("Session not found");
+        const active = !!session.worktree;
+        return helpers.success(
+          JSON.stringify(
+            {
+              active,
+              worktree: session.worktree ?? null,
+              workdir: session.workdir,
+              ...active ? { branch: session.worktree?.split("/worktrees/")[1] ?? session.worktree } : {}
+            },
+            null,
+            2
+          )
+        );
+      }
+      default:
+        return helpers.error(`Unknown action: ${args.action}`);
+    }
+  }
+);
+
 // src/server/tools/index.ts
 var _builtInTools;
 function getBuiltInTools() {
@@ -5226,7 +5244,7 @@ function getBuiltInTools() {
       stepDoneTool,
       backgroundProcessTool,
       mcpConfigTool,
-      traceCodeTool
+      worktreeTool
     ];
   }
   return _builtInTools;
@@ -5524,4 +5542,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-WD75RSGR.js.map
+//# sourceMappingURL=chunk-3ACDQKK6.js.map