@truefoundry/trueforge 0.1.2 → 0.1.4-rc.0

package/dist/main.js

@@ -8,28 +8,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/db/agentStore.ts
-import { AgentSpecSchema } from "@truefoundry/trueforge-core/agent-session";
-function parseStoredAgentSpec(manifest) {
-  return AgentSpecSchema.parse(manifest);
-}
-var AgentNameConflictError;
-var init_agentStore = __esm({
-  "src/db/agentStore.ts"() {
-    "use strict";
-    AgentNameConflictError = class extends Error {
-      tenant_id;
-      agent_name;
-      constructor({ tenant_id, name }, options) {
-        super(`Agent name already exists: ${name}`, options);
-        this.name = "AgentNameConflictError";
-        this.tenant_id = tenant_id;
-        this.agent_name = name;
-      }
-    };
-  }
-});
-
 // src/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -38,7 +16,8 @@ __export(config_exports, {
   isOidcConfigured: () => isOidcConfigured,
   parseOidcScopes: () => parseOidcScopes
 });
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
+import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
 import envPaths from "env-paths";
@@ -102,7 +81,7 @@ function parseBoolean(options) {
 }
 function resolveDefaultFrontendDir() {
   const packaged = path.join(PACKAGE_ROOT, "dist", "_frontend");
-  if (existsSync(path.join(packaged, "index.html"))) {
+  if (existsSync2(path.join(packaged, "index.html"))) {
     return packaged;
   }
   return path.join(PACKAGE_ROOT, "..", "frontend", "dist");
@@ -129,6 +108,12 @@ function resolveSqlitePath() {
   const paths = envPaths(ENV_PATHS_APP_NAME, { suffix: "" });
   return path.join(paths.data, "db", "db.sqlite");
 }
+function resolveLocalSandboxRootParent() {
+  return path.join(envPaths(ENV_PATHS_APP_NAME, { suffix: "" }).data, "sandboxes");
+}
+function resolveCodeModeSocketParent() {
+  return path.join(os.tmpdir(), "tf_cms");
+}
 function resolveRedisUrl() {
   const raw = getEnv("REDIS_URL", { defaultValue: DEFAULT_REDIS_URL }) ?? DEFAULT_REDIS_URL;
   if (raw.trim() === "") {
@@ -305,7 +290,9 @@ var init_config = __esm({
     configuration = standalone ? {
       ...shared,
       STANDALONE: true,
-      SQLITE_PATH: resolveSqlitePath()
+      SQLITE_PATH: resolveSqlitePath(),
+      LOCAL_SANDBOX_ROOT_PARENT: resolveLocalSandboxRootParent(),
+      CODE_MODE_SOCKET_PARENT: resolveCodeModeSocketParent()
     } : {
       ...shared,
       STANDALONE: false,
@@ -329,7 +316,1609 @@ var init_config = __esm({
       REDIS_URL: resolveRedisUrl(),
       OIDC: resolveOIDCConfig()
     };
-    config_default = configuration;
+    config_default = configuration;
+  }
+});
+
+// src/db/agentStore.ts
+import { AgentSpecSchema } from "@truefoundry/trueforge-core/agent-session";
+function parseStoredAgentSpec(manifest) {
+  return AgentSpecSchema.parse(manifest);
+}
+var AgentNameConflictError;
+var init_agentStore = __esm({
+  "src/db/agentStore.ts"() {
+    "use strict";
+    AgentNameConflictError = class extends Error {
+      tenant_id;
+      agent_name;
+      constructor({ tenant_id, name }, options) {
+        super(`Agent name already exists: ${name}`, options);
+        this.name = "AgentNameConflictError";
+        this.tenant_id = tenant_id;
+        this.agent_name = name;
+      }
+    };
+  }
+});
+
+// src/sandbox/local/sandboxScripts.gen.ts
+var sandboxScripts;
+var init_sandboxScripts_gen = __esm({
+  "src/sandbox/local/sandboxScripts.gen.ts"() {
+    "use strict";
+    sandboxScripts = {
+      mcpClientLocal: `#!/usr/bin/env python3
+"""Code Mode UDS client \u2014 same public surface as product mcp_client.py, stdlib only.
+
+Authoritative reference (do not diverge on API/CLI/policy semantics):
+  packages/trueforge-core/src/core/sandbox/scripts/mcp_client.py
+
+Inlined into TypeScript via scripts/generate-local-sandbox-scripts.mjs
+(src/sandbox/local/sandboxScripts.gen.ts), same pattern as core sandboxScripts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import json
+import logging
+import os
+import socket
+import sys
+import time
+from pathlib import Path
+from typing import Any, TypedDict
+
+logger = logging.getLogger(__name__)
+
+MAX_MESSAGE_BYTES = 64 * 1024 * 1024
+_TOOLS_CACHE_TTL_SECONDS = 600
+
+
+class _ServerConfig(TypedDict):
+    allowed_tools: list[str]
+
+
+_inflight_list_tools: dict[str, asyncio.Task[list[dict[str, Any]]]] = {}
+
+_raw_servers = os.environ.get("TFY_MCP_SERVERS")
+_servers_map: dict[str, _ServerConfig] = (
+    json.loads(base64.b64decode(_raw_servers).decode()) if _raw_servers else {}
+)
+_enable_agent_approvals = os.environ.get("TFY_ENABLE_AGENT_APPROVALS", "true").lower() == "true"
+
+
+def _sock_path() -> str:
+    path = os.environ.get("TFY_MCP_SOCK")
+    if not path:
+        raise RuntimeError("TFY_MCP_SOCK is not set")
+    return path
+
+
+def _request_timeout() -> float:
+    return float(os.environ.get("TFY_CM_REQUEST_TIMEOUT_SECONDS", "60"))
+
+
+def _check_tool_allowed(server: str, tool_name: str) -> None:
+    server_config = _servers_map.get(server)
+    if server_config is None:
+        raise RuntimeError(f"Access denied: MCP server '{server}' is not available for this agent") from None
+    server_tools = server_config.get("allowed_tools") or []
+    if len(server_tools) > 0 and tool_name not in server_tools:
+        raise RuntimeError(f"Access denied: tool '{tool_name}' is not enabled on server '{server}'") from None
+
+
+def _cache_path(server: str) -> Path:
+    return Path(__file__).parent / f"{server}.tools.json"
+
+
+def _read_tools_cache(server: str) -> list[dict[str, Any]] | None:
+    p = _cache_path(server)
+    if not p.exists():
+        return None
+    try:
+        raw = json.loads(p.read_text(encoding="utf-8"))
+        if not isinstance(raw, dict):
+            raise ValueError("cache root must be object")
+        fetched_at = raw.get("fetched_at")
+        tools = raw.get("tools")
+        if not isinstance(fetched_at, (int, float)) or not isinstance(tools, list):
+            raise ValueError("cache shape invalid")
+        if time.time() - float(fetched_at) > _TOOLS_CACHE_TTL_SECONDS:
+            p.unlink(missing_ok=True)
+            return None
+        return [t for t in tools if isinstance(t, dict)]
+    except Exception:
+        logger.exception("_read_tools_cache")
+        p.unlink(missing_ok=True)
+        return None
+
+
+def _write_tools_cache(server: str, tools: list[dict[str, Any]]) -> None:
+    try:
+        payload = {"fetched_at": time.time(), "tools": tools}
+        _cache_path(server).write_text(json.dumps(payload), encoding="utf-8")
+    except Exception:
+        logger.exception("_write_tools_cache")
+
+
+def _read_message(sock: socket.socket) -> Any:
+    body = b""
+    while True:
+        chunk = sock.recv(65536)
+        if not chunk:
+            break
+        body += chunk
+        if len(body) > MAX_MESSAGE_BYTES:
+            raise RuntimeError(f"message exceeds max {MAX_MESSAGE_BYTES} bytes")
+    return json.loads(body.decode("utf-8"))
+
+
+def _write_message(sock: socket.socket, value: Any) -> None:
+    sock.sendall(json.dumps(value).encode("utf-8"))
+
+
+def _uds_request_sync(payload: dict[str, Any]) -> Any:
+    """Connect \u2192 JSON request \u2192 write-close \u2192 JSON reply (no request_id)."""
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        sock.settimeout(_request_timeout())
+        sock.connect(_sock_path())
+        _write_message(sock, payload)
+        sock.shutdown(socket.SHUT_WR)
+        reply = _read_message(sock)
+    finally:
+        sock.close()
+    if not isinstance(reply, dict):
+        raise RuntimeError(f"Code Mode reply is not an object: {reply!r}")
+    ok = reply.get("ok")
+    if ok is not True:
+        source = reply.get("source", "internal")
+        error = reply.get("error", "unknown error")
+        if source == "caller":
+            raise RuntimeError(f"Invalid MCP request: {error}")
+        if source == "transport":
+            raise RuntimeError(f"Code Mode transport error: {error}")
+        raise RuntimeError(f"Internal MCP error: {error}")
+    return reply.get("result")
+
+
+async def _uds_request(payload: dict[str, Any]) -> Any:
+    return await asyncio.to_thread(_uds_request_sync, payload)
+
+
+async def _fetch_tools(server: str) -> list[dict[str, Any]]:
+    result = await _uds_request({"op": "list_tools", "server": server})
+    if not isinstance(result, dict):
+        raise RuntimeError(f"list_tools '{server}' returned unexpected shape: {result!r}") from None
+    tools = result.get("tools", [])
+    if not isinstance(tools, list):
+        raise RuntimeError(f"list_tools '{server}' tools is not a list: {tools!r}") from None
+    return [t for t in tools if isinstance(t, dict)]
+
+
+async def _fetch_and_cache_tools(server: str) -> list[dict[str, Any]]:
+    tools = await _fetch_tools(server)
+    _write_tools_cache(server, tools)
+    return tools
+
+
+async def _get_tools(server: str) -> list[dict[str, Any]]:
+    cached = _read_tools_cache(server)
+    if cached is not None:
+        return cached
+    task = _inflight_list_tools.get(server)
+    if task is None:
+        task = asyncio.create_task(_fetch_and_cache_tools(server))
+        _inflight_list_tools[server] = task
+        task.add_done_callback(lambda _t: _inflight_list_tools.pop(server, None))
+    return await task
+
+
+async def _get_tool(server: str, tool_name: str) -> dict[str, Any] | None:
+    for t in await _get_tools(server):
+        if t.get("name") == tool_name:
+            return t
+    return None
+
+
+def _is_destructive(tool: dict[str, Any]) -> bool:
+    annotations = tool.get("annotations")
+    if annotations is None:
+        return False
+    if not isinstance(annotations, dict):
+        return False
+    destructive = annotations.get("destructiveHint")
+    read_only = annotations.get("readOnlyHint")
+    return bool(destructive) or (not read_only and read_only is not None)
+
+
+async def _ensure_non_destructive(server: str, tool_name: str) -> None:
+    tool = await _get_tool(server, tool_name)
+    if tool is None:
+        raise RuntimeError(f"Tool '{tool_name}' not found on MCP server '{server}'") from None
+    if _is_destructive(tool):
+        raise RuntimeError(
+            f"Tool '{tool_name}' on MCP server '{server}' is destructive and cannot be called in Code Mode; "
+            f"call it directly so it can go through the user approval flow"
+        ) from None
+
+
+def _project_call_tool_result(server: str, tool: str, result: Any) -> Any:
+    """Project an MCP-wire CallToolResult-shaped object into the user-facing Python value."""
+    if not isinstance(result, dict):
+        raise RuntimeError(f"call_tool reply for '{server}/{tool}' is malformed: expected object") from None
+
+    if result.get("isError"):
+        content = result.get("content")
+        text_parts: list[str] = []
+        if isinstance(content, list):
+            for c in content:
+                if isinstance(c, dict) and c.get("type") == "text":
+                    text = c.get("text")
+                    if isinstance(text, str) and text:
+                        text_parts.append(text)
+        msg = "; ".join(text_parts) if text_parts else "tool returned an error"
+        raise RuntimeError(f"MCP tool error (server={server}, tool={tool}): {msg}") from None
+
+    if result.get("structuredContent") is not None:
+        return result["structuredContent"]
+
+    content = result.get("content")
+    if isinstance(content, list) and len(content) == 1:
+        first = content[0]
+        if isinstance(first, dict) and first.get("type") == "text":
+            text = first.get("text")
+            if isinstance(text, str) and text:
+                try:
+                    return json.loads(text)
+                except Exception:
+                    pass
+    if isinstance(content, list) and content:
+        return content
+    return None
+
+
+async def call_tool(server: str, tool: str, body: dict[str, Any]) -> Any:
+    _check_tool_allowed(server, tool)
+    if _enable_agent_approvals:
+        await _ensure_non_destructive(server, tool)
+
+    raw = await _uds_request(
+        {
+            "op": "call_tool",
+            "server": server,
+            "tool": tool,
+            "arguments": body,
+        },
+    )
+    return _project_call_tool_result(server, tool, raw)
+
+
+_USAGE = "mcp_client_local.py call-tool <server> <tool> <args-json>"
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="mcp_client_local.py", usage=_USAGE)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    call_tool_p = sub.add_parser("call-tool", help="Invoke an MCP tool")
+    call_tool_p.add_argument("server")
+    call_tool_p.add_argument("tool")
+    call_tool_p.add_argument("args_json", metavar="args-json", type=json.loads)
+
+    return parser
+
+
+async def _main() -> None:
+    args = _build_arg_parser().parse_args()
+    try:
+        if args.cmd == "call-tool":
+            result = await call_tool(args.server, args.tool, args.args_json)
+            print(json.dumps(result, default=str))
+    except RuntimeError as e:
+        sys.exit(str(e))
+
+
+if __name__ == "__main__":
+    asyncio.run(_main())
+`
+    };
+  }
+});
+
+// src/sandbox/local/schemas/jsonMessage.ts
+import { z as z5 } from "zod";
+var JsonMessageValueSchema;
+var init_jsonMessage = __esm({
+  "src/sandbox/local/schemas/jsonMessage.ts"() {
+    "use strict";
+    JsonMessageValueSchema = z5.json();
+  }
+});
+
+// src/sandbox/local/core/frame.ts
+function encodeJsonMessage(value) {
+  return Buffer.from(JSON.stringify(value), "utf8");
+}
+var MAX_MESSAGE_BYTES, JsonMessageReader;
+var init_frame = __esm({
+  "src/sandbox/local/core/frame.ts"() {
+    "use strict";
+    init_jsonMessage();
+    MAX_MESSAGE_BYTES = 64 * 1024 * 1024;
+    JsonMessageReader = class {
+      #buffer = Buffer.alloc(0);
+      #maxBytes;
+      constructor(options = {}) {
+        this.#maxBytes = options.maxBytes ?? MAX_MESSAGE_BYTES;
+      }
+      push(chunk) {
+        if (this.#buffer.length + chunk.length > this.#maxBytes) {
+          throw new Error(`message exceeds max ${String(this.#maxBytes)} bytes`);
+        }
+        this.#buffer = Buffer.concat([this.#buffer, chunk]);
+      }
+      finish() {
+        try {
+          return JsonMessageValueSchema.parse(JSON.parse(this.#buffer.toString("utf8")));
+        } catch (error) {
+          throw new Error("invalid JSON message", { cause: error });
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox/local/core/CodeModeUdsTransport.ts
+import { CodeModeRequestSchema, validateNoPathTraversal } from "@truefoundry/trueforge-core/core";
+import { chmodSync, existsSync as existsSync3, realpathSync, statSync } from "fs";
+import { chmod, mkdir as mkdir2, rm as rm2, symlink, unlink, writeFile } from "fs/promises";
+import { createServer } from "net";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { ulid } from "ulid";
+function assertCodeModeSocketParentPath(path7) {
+  if (!isAbsolute(path7)) {
+    throw new Error("codeModeSocketParentPath must be an absolute path");
+  }
+  validateNoPathTraversal(path7);
+  const resolved = resolve(path7);
+  if (!existsSync3(resolved) || !statSync(resolved).isDirectory()) {
+    throw new Error("codeModeSocketParentPath must be an existing directory");
+  }
+  const real = realpathSync(resolved);
+  const bytes = Buffer.byteLength(real);
+  if (bytes > MAX_CODE_MODE_SOCKET_PARENT_BYTES) {
+    throw new Error(
+      `codeModeSocketParentPath (${real}) must be at most ${String(MAX_CODE_MODE_SOCKET_PARENT_BYTES)} bytes (got ${String(bytes)})`
+    );
+  }
+  chmodSync(real, CODE_MODE_SOCKET_PARENT_MODE);
+  const mode = statSync(real).mode & 511;
+  if (mode !== CODE_MODE_SOCKET_PARENT_MODE) {
+    throw new Error(`codeModeSocketParentPath must be mode 0700 after chmod (got 0o${mode.toString(8)})`);
+  }
+  return real;
+}
+async function probeCodeModeUnixSocket(parentPath) {
+  const realParent = assertCodeModeSocketParentPath(parentPath);
+  const sockPath = join(realParent, ulid().toLowerCase());
+  await unlink(sockPath).catch(() => void 0);
+  const server = createServer();
+  try {
+    await new Promise((resolveListen, reject) => {
+      server.once("error", reject);
+      server.listen(sockPath, () => {
+        server.off("error", reject);
+        resolveListen();
+      });
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`listen ${sockPath} (${String(Buffer.byteLength(sockPath))} bytes): ${message}`, { cause: error });
+  } finally {
+    await new Promise((resolveClose) => {
+      server.close(() => {
+        resolveClose();
+      });
+    });
+    await unlink(sockPath).catch(() => void 0);
+  }
+  return { sockPath };
+}
+var MAX_CODE_MODE_SOCKET_PARENT_BYTES, CODE_MODE_SOCKET_PARENT_MODE, CODE_MODE_SOCKET_MODE, CodeModeUdsTransport;
+var init_CodeModeUdsTransport = __esm({
+  "src/sandbox/local/core/CodeModeUdsTransport.ts"() {
+    "use strict";
+    init_sandboxScripts_gen();
+    init_frame();
+    MAX_CODE_MODE_SOCKET_PARENT_BYTES = 65;
+    CODE_MODE_SOCKET_PARENT_MODE = 448;
+    CODE_MODE_SOCKET_MODE = 384;
+    CodeModeUdsTransport = class {
+      codeModeSocketParentPath;
+      maxMessageBytes;
+      onProtocolError;
+      clientRemotePath;
+      sessionPromise;
+      server;
+      sockPath;
+      dispatcher;
+      cachedEnv;
+      constructor(options) {
+        this.codeModeSocketParentPath = assertCodeModeSocketParentPath(options.codeModeSocketParentPath);
+        this.maxMessageBytes = options.maxMessageBytes ?? MAX_MESSAGE_BYTES;
+        this.onProtocolError = options.onProtocolError;
+        this.clientRemotePath = options.clientRemotePath;
+      }
+      getClientInstall(params) {
+        return {
+          content: sandboxScripts.mcpClientLocal,
+          remotePath: this.clientRemotePath(params.sandboxId)
+        };
+      }
+      start(params) {
+        this.dispatcher = params.codeModeDispatcher;
+        this.sessionPromise ??= this.listenSession(params).catch((e) => {
+          this.sessionPromise = void 0;
+          this.cachedEnv = void 0;
+          throw e;
+        });
+        return this.sessionPromise;
+      }
+      async stop() {
+        const pending = this.sessionPromise;
+        this.sessionPromise = void 0;
+        this.cachedEnv = void 0;
+        if (pending !== void 0) {
+          try {
+            await pending;
+          } catch {
+          }
+        }
+        const server = this.server;
+        const sockPath = this.sockPath;
+        this.server = void 0;
+        this.sockPath = void 0;
+        if (server !== void 0) {
+          await new Promise((resolveClose) => {
+            server.close(() => {
+              resolveClose();
+            });
+          });
+        }
+        if (sockPath !== void 0) {
+          await unlink(sockPath).catch(() => void 0);
+        }
+      }
+      async listenSession(params) {
+        if (this.server !== void 0 && this.cachedEnv !== void 0) {
+          return { env: this.cachedEnv };
+        }
+        assertCodeModeSocketParentPath(this.codeModeSocketParentPath);
+        const sockPath = join(this.codeModeSocketParentPath, ulid().toLowerCase());
+        await unlink(sockPath).catch(() => void 0);
+        const server = createServer({ allowHalfOpen: true });
+        try {
+          await new Promise((resolveListen, reject) => {
+            server.once("error", reject);
+            server.listen(sockPath, () => {
+              server.off("error", reject);
+              resolveListen();
+            });
+          });
+          await chmod(sockPath, CODE_MODE_SOCKET_MODE);
+        } catch (error) {
+          server.close();
+          await unlink(sockPath).catch(() => void 0);
+          throw error;
+        }
+        this.server = server;
+        this.sockPath = sockPath;
+        server.on("connection", (socket) => {
+          this.handleConnection(socket);
+        });
+        const env = {
+          TFY_MCP_SOCK: sockPath,
+          TFY_CM_REQUEST_TIMEOUT_SECONDS: String(params.requestTimeoutSeconds)
+        };
+        this.cachedEnv = env;
+        return { env };
+      }
+      handleConnection(socket) {
+        const reader = new JsonMessageReader({ maxBytes: this.maxMessageBytes });
+        let settled = false;
+        socket.on("error", () => void 0);
+        const fail = (message) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          this.onProtocolError?.(message);
+          socket.destroy();
+        };
+        socket.on("data", (chunk) => {
+          try {
+            reader.push(chunk);
+          } catch (error) {
+            fail(error instanceof Error ? error.message : String(error));
+          }
+        });
+        socket.on("end", () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          void this.dispatchConnection(socket, reader).catch((error) => {
+            this.onProtocolError?.(error instanceof Error ? error.message : String(error));
+            socket.destroy();
+          });
+        });
+      }
+      async dispatchConnection(socket, reader) {
+        let request;
+        try {
+          const parsed = CodeModeRequestSchema.safeParse(reader.finish());
+          if (!parsed.success) {
+            const reply2 = {
+              ok: false,
+              error: "Malformed Code Mode request",
+              source: "caller"
+            };
+            socket.write(encodeJsonMessage(reply2));
+            socket.end();
+            return;
+          }
+          request = parsed.data;
+        } catch (error) {
+          this.onProtocolError?.(error instanceof Error ? error.message : String(error));
+          socket.destroy();
+          return;
+        }
+        const dispatcher = this.dispatcher;
+        if (dispatcher === void 0) {
+          const reply2 = {
+            ok: false,
+            error: "Code Mode dispatcher is not configured",
+            source: "internal"
+          };
+          socket.write(encodeJsonMessage(reply2));
+          socket.end();
+          return;
+        }
+        const reply = await dispatcher.dispatch({ request, traceCarrier: {} });
+        try {
+          socket.write(encodeJsonMessage(reply));
+        } finally {
+          socket.end();
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox/local/core/hostRun.ts
+import { getDefaultWritePaths, SandboxManager } from "@anthropic-ai/sandbox-runtime";
+import { execFile, spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { realpathSync as realpathSync2 } from "fs";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
+import { createRequire } from "module";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2 } from "path";
+import { promisify } from "util";
+function codeModeSocketParentAllow() {
+  return codeModeSocketParentPath === void 0 ? [] : [codeModeSocketParentPath];
+}
+function requireActivePlatform() {
+  if (activePlatform === void 0) {
+    throw new Error("SRT platform is not set; call initSrt({ platform }) first");
+  }
+  return activePlatform;
+}
+function commandPath(platform) {
+  return COMMAND_PATH_BY_PLATFORM[platform];
+}
+function sandboxVenvPath(sandboxRootPath) {
+  return join2(sandboxRootPath, SANDBOX_VENV_DIR);
+}
+function allowedNetworkDomains() {
+  return [...LOCAL_SANDBOX_ALLOWED_DOMAINS];
+}
+function darwinSandboxNetworkShellPreamble() {
+  return [
+    'if [ -n "${HTTP_PROXY:-}" ]; then export HTTP_PROXY="${HTTP_PROXY//localhost/127.0.0.1}"; fi',
+    'if [ -n "${HTTPS_PROXY:-}" ]; then export HTTPS_PROXY="${HTTPS_PROXY//localhost/127.0.0.1}"; fi',
+    'if [ -n "${http_proxy:-}" ]; then export http_proxy="${http_proxy//localhost/127.0.0.1}"; fi',
+    'if [ -n "${https_proxy:-}" ]; then export https_proxy="${https_proxy//localhost/127.0.0.1}"; fi',
+    'if [ -n "${ALL_PROXY:-}" ]; then export ALL_PROXY="${ALL_PROXY//localhost/127.0.0.1}"; fi',
+    'if [ -n "${all_proxy:-}" ]; then export all_proxy="${all_proxy//localhost/127.0.0.1}"; fi',
+    'if [ -n "${GRPC_PROXY:-}" ]; then export GRPC_PROXY="${GRPC_PROXY//localhost/127.0.0.1}"; fi',
+    'if [ -n "${grpc_proxy:-}" ]; then export grpc_proxy="${grpc_proxy//localhost/127.0.0.1}"; fi'
+  ].join("; ");
+}
+function wrapSandboxCommand(params) {
+  if (params.platform !== "darwin") {
+    return params.command;
+  }
+  return `${darwinSandboxNetworkShellPreamble()}; ${params.command}`;
+}
+function srtHostBinaryNames(platform) {
+  return SRT_HOST_BINARIES_BY_PLATFORM[platform];
+}
+async function checkSrtHostDependencies() {
+  const result = await SandboxManager.checkDependenciesAsync();
+  return { errors: [...result.errors], warnings: [...result.warnings] };
+}
+async function resolveCommandOnHost(params) {
+  if (!/^[A-Za-z0-9._+-]+$/.test(params.name)) {
+    throw new Error(`invalid command name for resolveCommandOnHost: ${params.name}`);
+  }
+  const pathEnv = params.pathEnv !== void 0 && params.pathEnv.length > 0 ? params.pathEnv : commandPath(params.platform);
+  try {
+    const { stdout } = await execFileAsync("/bin/sh", ["-c", `command -v -- ${params.name}`], {
+      env: { PATH: pathEnv },
+      encoding: "utf8"
+    });
+    const resolved = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (resolved === void 0 || resolved.length === 0 || !isAbsolute2(resolved)) {
+      return void 0;
+    }
+    return resolved;
+  } catch {
+    return void 0;
+  }
+}
+async function resolvePythonExecutableOnHost(params) {
+  if (!isAbsolute2(params.commandPath)) {
+    return void 0;
+  }
+  try {
+    const { stdout } = await execFileAsync(params.commandPath, ["-c", "import sys; print(sys.executable)"], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    const executable = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (executable === void 0 || executable.length === 0 || !isAbsolute2(executable)) {
+      return void 0;
+    }
+    return realpathSync2(executable);
+  } catch {
+    return void 0;
+  }
+}
+function denySharedDefaultWritePaths() {
+  return getDefaultWritePaths().filter((path7) => !path7.startsWith("/dev/"));
+}
+function platformAllowRead(platform) {
+  return [...ALLOW_READ_BY_PLATFORM[platform]];
+}
+function filesystemPolicy(params) {
+  return {
+    allowWrite: [params.sandboxRootPath],
+    denyWrite: denySharedDefaultWritePaths(),
+    denyRead: ["/"],
+    allowRead: [params.sandboxRootPath, ...codeModeSocketParentAllow(), ...platformAllowRead(params.platform)]
+  };
+}
+function commandEnv(params) {
+  const tmp = join2(params.sandboxRootPath, ".tmp");
+  const home = join2(params.sandboxRootPath, ".home");
+  const venvDir = sandboxVenvPath(params.sandboxRootPath);
+  const locked = {
+    HOME: home,
+    TMPDIR: tmp,
+    TMP: tmp,
+    TEMP: tmp,
+    VIRTUAL_ENV: venvDir,
+    // Cwd-relative layout dirs (not host-absolute). Absolute paths under
+    // `Application Support` break PATH lookup (`mcp-client: command not found`).
+    PATH: `${join2(SANDBOX_VENV_DIR, "bin")}:mcp-client/bin:${commandPath(params.platform)}`
+  };
+  return {
+    ...params.extra,
+    ...locked
+  };
+}
+function sessionFilesystem(platform) {
+  const allowWrite = [];
+  return {
+    allowWrite,
+    denyWrite: denySharedDefaultWritePaths(),
+    denyRead: ["/"],
+    allowRead: [...platformAllowRead(platform), ...codeModeSocketParentAllow()]
+  };
+}
+function sessionNetwork(params) {
+  const allowedDomains = allowedNetworkDomains();
+  const deniedDomains = [];
+  if (params.platform === "linux") {
+    return {
+      allowedDomains,
+      deniedDomains,
+      allowAllUnixSockets: true
+    };
+  }
+  return {
+    allowedDomains,
+    deniedDomains,
+    allowAllUnixSockets: false,
+    allowUnixSockets: params.unixSockets ?? []
+  };
+}
+function darwinUnixSocketPaths() {
+  return [...darwinUnixSocketSandboxRoots, ...codeModeSocketParentAllow()];
+}
+function syncDarwinUnixSockets() {
+  if (SandboxManager.getConfig() === void 0) {
+    return;
+  }
+  const platform = requireActivePlatform();
+  if (platform !== "darwin") {
+    return;
+  }
+  SandboxManager.updateConfig(buildSessionConfig(platform));
+}
+function buildSessionConfig(platform) {
+  return {
+    network: sessionNetwork({ platform, unixSockets: darwinUnixSocketPaths() }),
+    filesystem: sessionFilesystem(platform)
+  };
+}
+async function createSandbox(sandboxRootPath) {
+  await mkdir3(sandboxRootPath, { recursive: true, mode: 448 });
+  await mkdir3(join2(sandboxRootPath, ".tmp"), { recursive: true, mode: 448 });
+  await mkdir3(join2(sandboxRootPath, ".home"), { recursive: true, mode: 448 });
+  const realRoot = realpathSync2(sandboxRootPath);
+  darwinUnixSocketSandboxRoots.add(realRoot);
+  syncDarwinUnixSockets();
+  return realRoot;
+}
+async function removeSandbox(sandboxRootPath) {
+  darwinUnixSocketSandboxRoots.delete(sandboxRootPath);
+  syncDarwinUnixSockets();
+  await rm3(sandboxRootPath, { recursive: true, force: true });
+}
+async function initSrt(params) {
+  activePlatform = params.platform;
+  codeModeSocketParentPath = params.codeModeSocketParentPath === void 0 ? void 0 : realpathSync2(params.codeModeSocketParentPath);
+  await SandboxManager.initialize(buildSessionConfig(params.platform));
+}
+async function resetSrt() {
+  codeModeSocketParentPath = void 0;
+  activePlatform = void 0;
+  await SandboxManager.reset();
+}
+function isSrtInitialized() {
+  return activePlatform !== void 0 && SandboxManager.getConfig() !== void 0;
+}
+function killExecTree(child) {
+  if (!child) {
+    return;
+  }
+  const pid = child.pid;
+  if (pid !== void 0 && process.platform !== "win32") {
+    try {
+      process.kill(-pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  if (!child.killed) {
+    child.kill("SIGKILL");
+  }
+}
+async function runSupervisorSession(params) {
+  const {
+    sandboxRootPath,
+    command: rawCommand,
+    shell,
+    platform,
+    cwd = sandboxRootPath,
+    env,
+    stdin,
+    onChildSpawn,
+    timeoutMs
+  } = params;
+  const command = wrapSandboxCommand({ platform, command: rawCommand });
+  const wrap = await SandboxManager.wrapWithSandboxArgv(
+    command,
+    shell,
+    {
+      filesystem: filesystemPolicy({ sandboxRootPath, platform }),
+      network: {
+        allowedDomains: allowedNetworkDomains(),
+        deniedDomains: []
+      }
+    },
+    void 0,
+    sandboxRootPath,
+    { commandId: randomUUID(), commandText: command }
+  );
+  const [argv0, ...argvRest] = wrap.argv;
+  if (argv0 === void 0) {
+    throw new Error("wrapWithSandboxArgv returned empty argv");
+  }
+  const childEnv = {
+    ...commandEnv({ sandboxRootPath, platform, ...env === void 0 ? {} : { extra: env } })
+  };
+  const child = spawn(argv0, argvRest, {
+    cwd,
+    env: childEnv,
+    shell: false,
+    // Detached process groups break stdin forwarding for upload (`cat` via pipe) under Jest.
+    detached: stdin === void 0 && process.platform !== "win32",
+    stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+  });
+  if (child.pid !== void 0) {
+    onChildSpawn?.(child.pid);
+  }
+  if (stdin !== void 0) {
+    const stdinStream = child.stdin;
+    if (stdinStream === null) {
+      killExecTree(child);
+      SandboxManager.cleanupAfterCommand();
+      throw new Error("stdin unavailable for sandboxed command");
+    }
+    stdinStream.on("error", () => void 0);
+    await new Promise((resolve3, reject) => {
+      stdinStream.end(stdin, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve3();
+        }
+      });
+    });
+  }
+  let stdoutText = "";
+  let stderrText = "";
+  let bufferedOutput = 0;
+  let protocolError;
+  let timedOut = false;
+  let closed = false;
+  const ignoreStreamError = (stream) => {
+    stream?.on("error", () => void 0);
+  };
+  const appendOutput = (stream, chunk) => {
+    bufferedOutput += chunk.length;
+    if (bufferedOutput > MAX_OUTPUT_BYTES) {
+      protocolError = `buffered output exceeded ${String(MAX_OUTPUT_BYTES)} bytes`;
+      killExecTree(child);
+      return;
+    }
+    const text = chunk.toString("utf8");
+    if (stream === "stdout") {
+      stdoutText += text;
+    } else {
+      stderrText += text;
+    }
+  };
+  ignoreStreamError(child.stdout);
+  ignoreStreamError(child.stderr);
+  child.stdout?.on("data", (chunk) => {
+    appendOutput("stdout", chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    appendOutput("stderr", chunk);
+  });
+  return await new Promise((resolve3, reject) => {
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killExecTree(child);
+    }, timeoutMs);
+    child.on("error", (error) => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      clearTimeout(timer);
+      SandboxManager.cleanupAfterCommand();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      clearTimeout(timer);
+      SandboxManager.cleanupAfterCommand();
+      resolve3({
+        stdoutText,
+        stderrText,
+        exitCode: typeof code === "number" ? code : timedOut ? 1 : 0,
+        protocolError,
+        timedOut,
+        childPid: child.pid
+      });
+    });
+  });
+}
+var execFileAsync, SRT_VENDOR, MAX_OUTPUT_BYTES, activePlatform, codeModeSocketParentPath, COMMAND_PATH_BY_PLATFORM, SANDBOX_VENV_DIR, LOCAL_SANDBOX_ALLOWED_DOMAINS, SRT_HOST_BINARIES_BY_PLATFORM, ALLOW_READ_BY_PLATFORM, darwinUnixSocketSandboxRoots;
+var init_hostRun = __esm({
+  "src/sandbox/local/core/hostRun.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+    SRT_VENDOR = join2(
+      dirname2(createRequire(import.meta.url).resolve("@anthropic-ai/sandbox-runtime/package.json")),
+      "vendor"
+    );
+    MAX_OUTPUT_BYTES = 14 * 1024 * 1024;
+    COMMAND_PATH_BY_PLATFORM = {
+      // On macOS, prefer Homebrew ahead of `/usr/bin` shims (those need Xcode select
+      // paths that we intentionally do not allow-read).
+      darwin: "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+      linux: "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+    };
+    SANDBOX_VENV_DIR = ".venv";
+    LOCAL_SANDBOX_ALLOWED_DOMAINS = [
+      "pypi.org",
+      "*.pypi.org",
+      "pythonhosted.org",
+      "files.pythonhosted.org",
+      "*.pythonhosted.org",
+      "github.com",
+      "api.github.com",
+      "codeload.github.com",
+      "*.github.com",
+      "githubusercontent.com",
+      "raw.githubusercontent.com",
+      "objects.githubusercontent.com",
+      "*.githubusercontent.com"
+    ];
+    SRT_HOST_BINARIES_BY_PLATFORM = {
+      linux: ["bwrap", "socat", "rg"],
+      darwin: []
+    };
+    ALLOW_READ_BY_PLATFORM = {
+      darwin: [
+        "/opt/homebrew/bin",
+        "/usr/local",
+        "/usr/bin",
+        "/bin",
+        "/usr/sbin",
+        "/sbin",
+        "/usr/lib",
+        "/System/Library",
+        "/Library",
+        "/private/var/db/dyld",
+        "/private/var/select",
+        "/opt/homebrew",
+        "/dev",
+        // Darwin `/etc` is a symlink to `/private/etc`. SRT refuses that realpath as
+        // "outside boundary" and keeps `(subpath "/etc")`. Seatbelt still checks the
+        // resolved path, so Apple LibreSSL's fopen(`/private/etc/ssl/openssl.cnf`)
+        // needs `/private/etc` listed too. Do not use a `[/]etc/**` glob: SRT treats
+        // that as cwd-relative (`path.isAbsolute('[/]…')` is false).
+        "/etc",
+        "/private/etc"
+      ],
+      linux: [
+        "/usr/bin",
+        "/bin",
+        "/usr/sbin",
+        "/sbin",
+        "/lib",
+        "/lib64",
+        "/usr/lib",
+        "/usr/lib64",
+        "/usr/local",
+        "/etc",
+        "/dev",
+        "/proc",
+        "/sys",
+        SRT_VENDOR
+      ]
+    };
+    darwinUnixSocketSandboxRoots = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/sandbox/local/schemas/xferFileInfo.ts
+import { z as z6 } from "zod";
+var XferFileInfoSchema;
+var init_xferFileInfo = __esm({
+  "src/sandbox/local/schemas/xferFileInfo.ts"() {
+    "use strict";
+    XferFileInfoSchema = z6.object({
+      size: z6.number(),
+      isDir: z6.boolean()
+    });
+  }
+});
+
+// src/sandbox/local/provider/LocalSandboxProvider.ts
+var LocalSandboxProvider_exports = {};
+__export(LocalSandboxProvider_exports, {
+  LocalSandboxProvider: () => LocalSandboxProvider,
+  formatLocalSandboxSupportReason: () => formatLocalSandboxSupportReason,
+  localSandboxUploadCommand: () => localSandboxUploadCommand
+});
+import {
+  absolutizeRelativeExecEnv,
+  SandboxFileNotFoundError,
+  SandboxFileTooLargeError,
+  SandboxNotAvailableError,
+  SandboxPathIsDirectoryError,
+  shellEscape,
+  validateNoPathTraversal as validateNoPathTraversal2
+} from "@truefoundry/trueforge-core/core";
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync4, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
+import { mkdir as mkdir4, mkdtemp, rm as rm4 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3, relative, resolve as resolve2, sep } from "path";
+import { promisify as promisify2 } from "util";
+import { ulid as ulid2 } from "ulid";
+function formatLocalSandboxSupportReason(params) {
+  const details = params.attempts.map(formatLocalSandboxSupportAttempt).join("; ");
+  return details.length === 0 ? params.summary : `${params.summary}: ${details}`;
+}
+function formatLocalSandboxSupportAttempt(attempt) {
+  if (attempt.resolved === void 0) {
+    return attempt.kind === "host" ? `${attempt.name}: not on PATH` : `${attempt.name}: not on sandbox PATH`;
+  }
+  const parts = [`${attempt.name}: resolved=${attempt.resolved}`];
+  if (attempt.executable !== void 0 && attempt.executable !== attempt.resolved) {
+    parts.push(`executable=${attempt.executable}`);
+  }
+  if (attempt.protocolError !== void 0) {
+    parts.push(`protocolError=${attempt.protocolError}`);
+  }
+  if (attempt.exitCode !== void 0) {
+    parts.push(`exit=${String(attempt.exitCode)}`);
+  }
+  if (attempt.timedOut === true) {
+    parts.push("timedOut");
+  }
+  if (attempt.stderr !== void 0 && attempt.stderr.length > 0) {
+    parts.push(`stderr=${JSON.stringify(attempt.stderr)}`);
+  }
+  if (attempt.stdout !== void 0 && attempt.stdout.length > 0) {
+    parts.push(`stdout=${JSON.stringify(attempt.stdout)}`);
+  }
+  return parts.join(" ");
+}
+function probeAttemptFromSession(params) {
+  return {
+    kind: params.kind,
+    name: params.name,
+    resolved: params.resolved,
+    ...params.executable === void 0 ? {} : { executable: params.executable },
+    exitCode: params.session.exitCode,
+    stdout: params.session.stdoutText,
+    stderr: params.session.stderrText,
+    ...params.session.protocolError === void 0 ? {} : { protocolError: params.session.protocolError },
+    timedOut: params.session.timedOut
+  };
+}
+function unsupported(params) {
+  return {
+    supported: false,
+    reason: params.reason,
+    ...params.platform === void 0 ? {} : { platform: params.platform },
+    ...params.attempts === void 0 ? {} : { attempts: params.attempts }
+  };
+}
+function toSandboxRelativePath(params) {
+  const rel = relative(params.sandboxRootPath, params.absolutePath);
+  return rel === "" ? "." : rel;
+}
+function isStrictDescendant(params) {
+  const rel = relative(params.ancestor, params.descendant);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute3(rel);
+}
+function execFileErrorDetail(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const parts = [error.message];
+  if ("stderr" in error && typeof error.stderr === "string" && error.stderr.length > 0) {
+    parts.push(error.stderr);
+  }
+  if ("stdout" in error && typeof error.stdout === "string" && error.stdout.length > 0) {
+    parts.push(error.stdout);
+  }
+  return parts.join(" ");
+}
+function sessionFailDetail(session) {
+  return [session.protocolError, session.stderrText, session.stdoutText].filter((part) => part !== void 0 && part.length > 0).join(" ");
+}
+function localSandboxUploadCommand(remotePath) {
+  const parent = dirname3(remotePath);
+  return [
+    `mkdir -p ${shellEscape(parent)}`,
+    `{ chmod u+w ${shellEscape(remotePath)} 2>/dev/null || true; }`,
+    `/bin/cat > ${shellEscape(remotePath)}`
+  ].join(" && ");
+}
+var execFileAsync2, DEFAULT_EXEC_TIMEOUT_SECONDS, DEFAULT_FILE_MAX_BYTES, SUPPORT_PROBE_TIMEOUT_MS, VENV_CREATE_TIMEOUT_MS, VENV_PIP_TIMEOUT_MS, VENV_PYDANTIC_PIN, SHELL_CANDIDATES, PYTHON_CANDIDATES, LocalSandboxProvider;
+var init_LocalSandboxProvider = __esm({
+  "src/sandbox/local/provider/LocalSandboxProvider.ts"() {
+    "use strict";
+    init_CodeModeUdsTransport();
+    init_hostRun();
+    init_xferFileInfo();
+    execFileAsync2 = promisify2(execFile2);
+    DEFAULT_EXEC_TIMEOUT_SECONDS = 60;
+    DEFAULT_FILE_MAX_BYTES = 10 * 1024 * 1024;
+    SUPPORT_PROBE_TIMEOUT_MS = 5e3;
+    VENV_CREATE_TIMEOUT_MS = 6e4;
+    VENV_PIP_TIMEOUT_MS = 12e4;
+    VENV_PYDANTIC_PIN = "pydantic>=2.0.0,<3.0.0";
+    SHELL_CANDIDATES = ["bash", "sh"];
+    PYTHON_CANDIDATES = ["python3", "python"];
+    LocalSandboxProvider = class _LocalSandboxProvider {
+      type = "local";
+      sandboxRootPathParent;
+      codeModeSocketParentPath;
+      support;
+      fileMaxBytesForDownload;
+      defaultExecTimeoutSeconds;
+      srtInitialized = false;
+      logger;
+      /** Local SRT has no image build step — always ready. */
+      static readyBuild = {
+        status: "ready",
+        reason: null,
+        metadata: null
+      };
+      /**
+       * Probe whether this host can run LocalSandboxProvider
+       * (OS + Code Mode UDS listen + SRT host binaries + in-sandbox shell + Python 3).
+       * On success, returns platform/shell/python to pass into the constructor as `support`.
+       */
+      static async isSupported(params) {
+        if (process.platform !== "darwin" && process.platform !== "linux") {
+          return unsupported({
+            reason: `LocalSandboxProvider supports macOS and Linux only (got ${process.platform})`
+          });
+        }
+        const platform = process.platform;
+        let createdSocketParent;
+        const socketParentPath = params?.codeModeSocketParentPath;
+        try {
+          const parentPath = socketParentPath ?? await mkdtemp(join3("/tmp", "tfc-"));
+          if (socketParentPath === void 0) {
+            createdSocketParent = parentPath;
+          }
+          try {
+            await probeCodeModeUnixSocket(parentPath);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return unsupported({
+              platform,
+              attempts: [{ kind: "socket", name: "uds", resolved: parentPath, protocolError: message }],
+              reason: `Code Mode UDS listen failed: ${message}`
+            });
+          }
+        } finally {
+          if (createdSocketParent !== void 0) {
+            await rm4(createdSocketParent, { recursive: true, force: true });
+          }
+        }
+        const hostPath = process.env["PATH"];
+        const hostAttempts = [];
+        for (const name of srtHostBinaryNames(platform)) {
+          const resolved = await resolveCommandOnHost({
+            platform,
+            name,
+            ...hostPath === void 0 || hostPath.length === 0 ? {} : { pathEnv: hostPath }
+          });
+          hostAttempts.push({ kind: "host", name, resolved });
+        }
+        if (hostAttempts.some((attempt) => attempt.resolved === void 0)) {
+          const required = srtHostBinaryNames(platform).join(", ");
+          return unsupported({
+            platform,
+            attempts: hostAttempts,
+            reason: formatLocalSandboxSupportReason({
+              summary: `SRT host dependencies missing (${platform}: ${required})`,
+              attempts: hostAttempts
+            })
+          });
+        }
+        const srtDeps = await checkSrtHostDependencies();
+        if (srtDeps.errors.length > 0) {
+          return unsupported({
+            platform,
+            attempts: hostAttempts.length === 0 ? void 0 : hostAttempts,
+            reason: `SRT host dependencies failed: ${srtDeps.errors.join("; ")}`
+          });
+        }
+        const alreadyInitialized = isSrtInitialized();
+        let probeRoot;
+        const attempts = [...hostAttempts];
+        const pythonAttempts = [];
+        try {
+          if (!alreadyInitialized) {
+            await initSrt({
+              platform,
+              ...socketParentPath === void 0 ? {} : { codeModeSocketParentPath: socketParentPath }
+            });
+          }
+          probeRoot = await createSandbox(await mkdtemp(join3(tmpdir(), "tfy-local-sandbox-support-")));
+          let shell;
+          for (const name of SHELL_CANDIDATES) {
+            const resolved = await resolveCommandOnHost({ platform, name });
+            if (resolved === void 0) {
+              attempts.push({ kind: "shell", name, resolved: void 0 });
+              continue;
+            }
+            const probe = await runSupervisorSession({
+              sandboxRootPath: probeRoot,
+              platform,
+              shell: resolved,
+              command: "echo shell-ok",
+              timeoutMs: SUPPORT_PROBE_TIMEOUT_MS
+            });
+            const attempt = probeAttemptFromSession({ kind: "shell", name, resolved, session: probe });
+            if (probe.protocolError === void 0 && probe.exitCode === 0 && probe.stdoutText.includes("shell-ok")) {
+              shell = resolved;
+              break;
+            }
+            attempts.push(attempt);
+          }
+          if (shell === void 0) {
+            return unsupported({
+              platform,
+              attempts,
+              reason: formatLocalSandboxSupportReason({
+                summary: "No usable shell in sandbox (bash or sh via command -v)",
+                attempts
+              })
+            });
+          }
+          let python;
+          for (const name of PYTHON_CANDIDATES) {
+            const resolved = await resolveCommandOnHost({ platform, name });
+            if (resolved === void 0) {
+              pythonAttempts.push({ kind: "python", name, resolved: void 0 });
+              continue;
+            }
+            const executable = await resolvePythonExecutableOnHost({ commandPath: resolved }) ?? resolved;
+            const probe = await runSupervisorSession({
+              sandboxRootPath: probeRoot,
+              platform,
+              shell,
+              command: `${shellEscape(executable)} -c ${shellEscape(
+                "import sys; raise SystemExit(0 if sys.version_info[0] == 3 else 1)"
+              )}`,
+              timeoutMs: SUPPORT_PROBE_TIMEOUT_MS
+            });
+            const attempt = probeAttemptFromSession({
+              kind: "python",
+              name,
+              resolved,
+              executable,
+              session: probe
+            });
+            if (probe.protocolError === void 0 && probe.exitCode === 0) {
+              python = executable;
+              break;
+            }
+            pythonAttempts.push(attempt);
+          }
+          if (python === void 0) {
+            return unsupported({
+              platform,
+              attempts: pythonAttempts,
+              reason: formatLocalSandboxSupportReason({
+                summary: "No usable Python 3 interpreter in sandbox (python3 or python via command -v)",
+                attempts: pythonAttempts
+              })
+            });
+          }
+          return { supported: true, platform, shell, python };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const seen = [...attempts, ...pythonAttempts];
+          return unsupported({
+            platform,
+            attempts: seen.length === 0 ? void 0 : seen,
+            reason: seen.length === 0 ? message : `${message}: ${formatLocalSandboxSupportReason({ summary: "probe aborted", attempts: seen })}`
+          });
+        } finally {
+          if (probeRoot !== void 0) {
+            await removeSandbox(probeRoot);
+          }
+          if (!alreadyInitialized) {
+            await resetSrt();
+          }
+        }
+      }
+      constructor(options) {
+        if (!options.support.supported) {
+          throw new Error(`LocalSandboxProvider is not supported: ${options.support.reason}`);
+        }
+        if (!isAbsolute3(options.sandboxRootPathParent)) {
+          throw new Error("sandboxRootPathParent must be an absolute path");
+        }
+        validateNoPathTraversal2(options.sandboxRootPathParent);
+        const resolvedParent = resolve2(options.sandboxRootPathParent);
+        this.sandboxRootPathParent = existsSync4(resolvedParent) && statSync2(resolvedParent).isDirectory() ? realpathSync3(resolvedParent) : resolvedParent;
+        this.codeModeSocketParentPath = assertCodeModeSocketParentPath(options.codeModeSocketParentPath);
+        this.support = options.support;
+        this.fileMaxBytesForDownload = options.fileMaxBytesForDownload ?? DEFAULT_FILE_MAX_BYTES;
+        this.defaultExecTimeoutSeconds = options.defaultExecTimeoutSeconds ?? DEFAULT_EXEC_TIMEOUT_SECONDS;
+        this.logger = options.logger.child({ module: "LocalSandboxProvider" });
+      }
+      pythonC(code, relPath) {
+        return `${this.support.python} -c ${shellEscape(code)} ${shellEscape(relPath)}`;
+      }
+      statCommand(relPath) {
+        const code = [
+          "import json, os, sys",
+          "p = sys.argv[1]",
+          "st = os.stat(p)",
+          'print(json.dumps({"size": st.st_size, "isDir": os.path.isdir(p)}))'
+        ].join("\n");
+        return this.pythonC(code, relPath);
+      }
+      base64EncodeCommand(relPath) {
+        const code = [
+          "import base64, sys",
+          "p = sys.argv[1]",
+          'sys.stdout.write(base64.b64encode(open(p, "rb").read()).decode("ascii"))'
+        ].join("\n");
+        return this.pythonC(code, relPath);
+      }
+      buildImage() {
+        return Promise.resolve(_LocalSandboxProvider.readyBuild);
+      }
+      getImageBuildStatus() {
+        return Promise.resolve(_LocalSandboxProvider.readyBuild);
+      }
+      async ensureSrt() {
+        if (this.srtInitialized) {
+          return;
+        }
+        await initSrt({
+          platform: this.support.platform,
+          codeModeSocketParentPath: this.codeModeSocketParentPath
+        });
+        this.srtInitialized = true;
+      }
+      /** Missing, non-directory, or not a child of this provider's parent → recreate path in Sandbox. */
+      ensureSandboxRoot(sandboxRootPath) {
+        if (!isAbsolute3(sandboxRootPath)) {
+          throw new SandboxNotAvailableError(sandboxRootPath);
+        }
+        const resolved = resolve2(sandboxRootPath);
+        if (!existsSync4(resolved) || !statSync2(resolved).isDirectory()) {
+          throw new SandboxNotAvailableError(sandboxRootPath);
+        }
+        const parentReal = existsSync4(this.sandboxRootPathParent) ? realpathSync3(this.sandboxRootPathParent) : this.sandboxRootPathParent;
+        const realRoot = realpathSync3(resolved);
+        if (!isStrictDescendant({ ancestor: parentReal, descendant: realRoot })) {
+          throw new SandboxNotAvailableError(sandboxRootPath);
+        }
+      }
+      /**
+       * Host `python -m venv` (stdlib only), then sandboxed pip for pydantic.
+       * Idempotent: skip create when `.venv/bin/python` exists; skip pip when import works.
+       */
+      async ensureVenv(sandboxRootPath) {
+        const venvDir = join3(sandboxRootPath, SANDBOX_VENV_DIR);
+        const venvPython = join3(venvDir, "bin", "python");
+        if (!existsSync4(venvPython)) {
+          try {
+            await execFileAsync2(this.support.python, ["-m", "venv", venvDir], { timeout: VENV_CREATE_TIMEOUT_MS });
+          } catch (error) {
+            throw new Error(`Failed to create sandbox ${SANDBOX_VENV_DIR}: ${execFileErrorDetail(error)}`, {
+              cause: error
+            });
+          }
+        }
+        const relPython = join3(SANDBOX_VENV_DIR, "bin", "python");
+        const relPip = join3(SANDBOX_VENV_DIR, "bin", "pip");
+        const check = await runSupervisorSession({
+          sandboxRootPath,
+          platform: this.support.platform,
+          shell: this.support.shell,
+          command: `${shellEscape(relPython)} -c ${shellEscape("import pydantic")}`,
+          timeoutMs: SUPPORT_PROBE_TIMEOUT_MS
+        });
+        if (check.protocolError !== void 0) {
+          throw new Error(`Sandbox venv pydantic check failed: ${check.protocolError}`);
+        }
+        if (check.exitCode === 0) {
+          return;
+        }
+        const install = await runSupervisorSession({
+          sandboxRootPath,
+          platform: this.support.platform,
+          shell: this.support.shell,
+          command: `${shellEscape(relPip)} install --trusted-host pypi.org --trusted-host files.pythonhosted.org ${shellEscape(VENV_PYDANTIC_PIN)}`,
+          timeoutMs: VENV_PIP_TIMEOUT_MS
+        });
+        if (install.protocolError !== void 0 || install.exitCode !== 0 || install.timedOut) {
+          throw new Error(
+            `Failed to pip install ${VENV_PYDANTIC_PIN} into sandbox ${SANDBOX_VENV_DIR}: ${sessionFailDetail(install)}`
+          );
+        }
+      }
+      resolveInSandboxRoot(sandboxRootPath, userPath) {
+        validateNoPathTraversal2(userPath);
+        const resolved = userPath.startsWith("/") ? resolve2(userPath) : resolve2(sandboxRootPath, userPath);
+        const root = resolve2(sandboxRootPath);
+        if (resolved !== root && !resolved.startsWith(root + sep)) {
+          throw new SandboxFileNotFoundError(userPath);
+        }
+        return resolved;
+      }
+      async runSandboxCommand(params) {
+        const session = await runSupervisorSession({
+          sandboxRootPath: params.sandboxRootPath,
+          platform: this.support.platform,
+          shell: this.support.shell,
+          command: params.command,
+          ...params.stdin === void 0 ? {} : { stdin: params.stdin },
+          timeoutMs: this.defaultExecTimeoutSeconds * 1e3
+        });
+        if (session.protocolError !== void 0) {
+          throw new Error(session.protocolError);
+        }
+        return {
+          exitCode: session.exitCode,
+          stdoutText: session.stdoutText,
+          stderrText: session.stderrText
+        };
+      }
+      async getFileInfo(params) {
+        const result = await this.runSandboxCommand({
+          sandboxRootPath: params.sandboxRootPath,
+          command: this.statCommand(params.relPath)
+        });
+        if (result.exitCode !== 0) {
+          throw new SandboxFileNotFoundError(params.userPath);
+        }
+        return XferFileInfoSchema.parse(JSON.parse(result.stdoutText.trim()));
+      }
+      async createSandbox() {
+        await this.ensureSrt();
+        const sandboxId = await createSandbox(join3(this.sandboxRootPathParent, ulid2().toLowerCase()));
+        this.logger.info("LocalSandboxProvider created sandbox", {
+          sandboxId,
+          shell: this.support.shell,
+          python: this.support.python
+        });
+        await mkdir4(join3(sandboxId, this.getToolResultDumpDir()), { recursive: true, mode: 448 });
+        await mkdir4(join3(sandboxId, this.getFileUploadsDir()), { recursive: true, mode: 448 });
+        await mkdir4(join3(sandboxId, this.getSkillsDir()), { recursive: true, mode: 448 });
+        await this.ensureVenv(sandboxId);
+        return { sandboxId };
+      }
+      async exec(params) {
+        this.ensureSandboxRoot(params.sandboxId);
+        try {
+          await this.ensureSrt();
+          await this.ensureVenv(params.sandboxId);
+          const sandboxRootPath = params.sandboxId;
+          const cwd = params.cwd === void 0 || params.cwd === "" ? sandboxRootPath : this.resolveInSandboxRoot(sandboxRootPath, params.cwd);
+          const timeoutSeconds = params.timeoutSeconds ?? this.defaultExecTimeoutSeconds;
+          const env = params.env === void 0 ? void 0 : absolutizeRelativeExecEnv({ root: sandboxRootPath, env: params.env });
+          const session = await runSupervisorSession({
+            sandboxRootPath,
+            platform: this.support.platform,
+            shell: this.support.shell,
+            command: params.command,
+            cwd,
+            ...env === void 0 ? {} : { env },
+            timeoutMs: timeoutSeconds * 1e3
+          });
+          if (session.protocolError !== void 0) {
+            return { success: false, error: session.protocolError };
+          }
+          const result = session.stdoutText + (session.stderrText ? session.stderrText : "");
+          return {
+            success: true,
+            response: { exitCode: session.exitCode, result }
+          };
+        } catch (error) {
+          if (error instanceof SandboxNotAvailableError) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, error: message };
+        }
+      }
+      getAdditionalInstructions() {
+        return [
+          "SANDBOX RULES:",
+          `- Platform: ${this.support.platform}.`,
+          `- Commands run under the sandbox shell: ${this.support.shell}.`,
+          "- A Python virtualenv lives at .venv. `python` and `pip` on PATH are that environment; packages you `pip install` persist in this sandbox.",
+          "- uploads, skills, and tool-results live in the sandbox working directory.",
+          "- ALL file creation and writes MUST stay within the sandbox working directory.",
+          "- The Agent must NOT write outside the working directory (including host home and /tmp)."
+        ].join("\n");
+      }
+      // Cwd-relative: SRT cwd is the sandbox root. Init mkdir/ln and the agent prompt must not use
+      // host-absolute paths — those contain spaces under macOS Application Support and lose quoting.
+      //   uploads, skills, tool-results, git_downloader.py, .git-credentials, .venv
+      //   mcp-client/mcp_client.py
+      getToolResultDumpDir() {
+        return "tool-results";
+      }
+      getGitCredentialsPath() {
+        return ".git-credentials";
+      }
+      getFileUploadsDir() {
+        return "uploads";
+      }
+      getSkillsDir() {
+        return "skills";
+      }
+      getGitDownloaderPath() {
+        return "git_downloader.py";
+      }
+      async downloadFile(params) {
+        this.ensureSandboxRoot(params.sandboxId);
+        await this.ensureSrt();
+        await this.ensureVenv(params.sandboxId);
+        const sandboxRootPath = params.sandboxId;
+        const absolutePath = this.resolveInSandboxRoot(sandboxRootPath, params.path);
+        const relPath = toSandboxRelativePath({ sandboxRootPath, absolutePath });
+        const info = await this.getFileInfo({ sandboxRootPath, relPath, userPath: params.path });
+        if (info.isDir) {
+          throw new SandboxPathIsDirectoryError(params.path);
+        }
+        if (info.size > this.fileMaxBytesForDownload) {
+          throw new SandboxFileTooLargeError(params.path, info.size, this.fileMaxBytesForDownload);
+        }
+        const result = await this.runSandboxCommand({
+          sandboxRootPath,
+          command: this.base64EncodeCommand(relPath)
+        });
+        if (result.exitCode !== 0) {
+          throw new SandboxFileNotFoundError(params.path);
+        }
+        const buf = Buffer.from(result.stdoutText.trim(), "base64");
+        if (buf.length > this.fileMaxBytesForDownload) {
+          throw new SandboxFileTooLargeError(params.path, buf.length, this.fileMaxBytesForDownload);
+        }
+        return buf;
+      }
+      /** Payload on stdin so large uploads stay off argv. */
+      async uploadFile(params) {
+        this.ensureSandboxRoot(params.sandboxId);
+        await this.ensureSrt();
+        await this.ensureVenv(params.sandboxId);
+        if (params.content.length > this.fileMaxBytesForDownload) {
+          throw new SandboxFileTooLargeError(params.remotePath, params.content.length, this.fileMaxBytesForDownload);
+        }
+        const sandboxRootPath = params.sandboxId;
+        const absolutePath = this.resolveInSandboxRoot(sandboxRootPath, params.remotePath);
+        const remotePath = toSandboxRelativePath({ sandboxRootPath, absolutePath });
+        const result = await this.runSandboxCommand({
+          sandboxRootPath,
+          command: localSandboxUploadCommand(remotePath),
+          stdin: params.content
+        });
+        if (result.exitCode !== 0) {
+          const detail = [result.stderrText, result.stdoutText].filter((part) => part.length > 0).join(" ");
+          throw new Error(
+            detail.length > 0 ? `upload ${params.remotePath} failed (exit ${String(result.exitCode)}): ${detail}` : `upload ${params.remotePath} failed (exit ${String(result.exitCode)})`
+          );
+        }
+      }
+      createCodeModeTransport() {
+        return new CodeModeUdsTransport({
+          codeModeSocketParentPath: this.codeModeSocketParentPath,
+          clientRemotePath: () => join3("mcp-client", "mcp_client.py")
+        });
+      }
+      /** Reset process-scoped SRT for this provider. */
+      async dispose() {
+        if (this.srtInitialized) {
+          await resetSrt();
+          this.srtInitialized = false;
+        }
+      }
+    };
   }
 });
 
@@ -380,14 +1969,14 @@ function toStoredOAuthPendingAuthorizationData(pending) {
   return {
     mcp_server_url: pending.mcpServerUrl,
     code_verifier: pending.codeVerifier,
-    redirect_url: pending.redirectUrl
+    return_to: pending.returnTo
   };
 }
 function fromStoredOAuthPendingAuthorizationData(stored) {
   return {
     mcpServerUrl: stored.mcp_server_url,
     codeVerifier: stored.code_verifier,
-    redirectUrl: stored.redirect_url
+    returnTo: stored.return_to
   };
 }
 var McpServerNameConflictError, PENDING_AUTHORIZATION_TTL_MS;
@@ -740,10 +2329,10 @@ async function assembleTurnRecord(db, args) {
   }
   const contextRows = await db.selectFrom("turn_thread as tt").leftJoin(
     "turn_thread_context as ttc",
-    (join) => join.on("ttc.session_id", "=", args.session_id).on("ttc.turn_id", "=", args.turn_id).onRef("ttc.thread_id", "=", "tt.thread_id")
+    (join5) => join5.on("ttc.session_id", "=", args.session_id).on("ttc.turn_id", "=", args.turn_id).onRef("ttc.thread_id", "=", "tt.thread_id")
   ).leftJoin(
     "thread_context_log as l",
-    (join) => join.on("l.session_id", "=", args.session_id).onRef("l.thread_id", "=", "tt.thread_id").onRef("l.append_id", "=", "ttc.append_id")
+    (join5) => join5.on("l.session_id", "=", args.session_id).onRef("l.thread_id", "=", "tt.thread_id").onRef("l.append_id", "=", "ttc.append_id")
   ).select([
     "tt.thread_id",
     jsonText(sql2.ref("tt.checkpoint")).as("checkpoint"),
@@ -840,10 +2429,10 @@ async function createTurn(db, input) {
       if (prevTurnId != null) {
         const prevRows = await trx.selectFrom("turn as t").leftJoin(
           "turn_thread as tt",
-          (join) => join.onRef("tt.session_id", "=", "t.session_id").onRef("tt.turn_id", "=", "t.turn_id")
+          (join5) => join5.onRef("tt.session_id", "=", "t.session_id").onRef("tt.turn_id", "=", "t.turn_id")
         ).leftJoin(
           db.selectFrom("turn_thread_context").select(["thread_id", "turn_id", sql2`MAX(pos)`.as("max_pos")]).where("session_id", "=", input.session_id).where("turn_id", "=", prevTurnId).groupBy(["thread_id", "turn_id"]).as("tc_agg"),
-          (join) => join.onRef("tc_agg.thread_id", "=", "tt.thread_id").onRef("tc_agg.turn_id", "=", "tt.turn_id")
+          (join5) => join5.onRef("tc_agg.thread_id", "=", "tt.thread_id").onRef("tc_agg.turn_id", "=", "tt.turn_id")
         ).select([
           jsonText(sql2.ref("t.checkpoint")).as("turn_checkpoint"),
           jsonText(sql2.ref("t.state")).as("turn_state"),
@@ -1212,7 +2801,7 @@ async function listTurnEvents(db, input) {
   const eventOrder = input.order === "desc" ? "desc" : "asc";
   const rows = await db.selectFrom("turn as t").leftJoin(
     (eb) => eb.selectFrom("session_event").select(["session_id", "turn_id", "event_id", jsonText(sql4.ref("event")).as("event")]).where("session_id", "=", input.session_id).where("turn_id", "=", input.turn_id).orderBy("event_id", eventOrder).limit(limit + 1).offset(offset).as("e"),
-    (join) => join.onRef("e.session_id", "=", "t.session_id").onRef("e.turn_id", "=", "t.turn_id")
+    (join5) => join5.onRef("e.session_id", "=", "t.session_id").onRef("e.turn_id", "=", "t.turn_id")
   ).select(["t.turn_id", "e.event"]).where("t.session_id", "=", input.session_id).where("t.turn_id", "=", input.turn_id).orderBy("e.event_id", eventOrder).execute();
   if (rows.length === 0) {
     throw new TurnNotFoundError3(input.turn_id);
@@ -1272,7 +2861,7 @@ async function listSessionEvents(db, input) {
   const chainJson = JSON.stringify(chainIds);
   const rows = await db.selectFrom(sql4`json_each(${chainJson})`.as("c")).innerJoin(
     "session_event as e",
-    (join) => join.on("e.session_id", "=", input.session_id).on(sql4`e.turn_id = c.value`)
+    (join5) => join5.on("e.session_id", "=", input.session_id).on(sql4`e.turn_id = c.value`)
   ).select([sql4`c.value`.as("turn_id"), jsonText(sql4.ref("e.event")).as("event")]).orderBy(sql4`c.key`, "desc").orderBy("e.event_id", "desc").limit(limit + 1).offset(cursor.offset).execute();
   return paginateSessionEventRows(rows, limit, cursor);
 }
@@ -1958,7 +3547,7 @@ var SqliteMcpServerStore_exports = {};
 __export(SqliteMcpServerStore_exports, {
   SqliteMcpServerStore: () => SqliteMcpServerStore
 });
-import { ulid as ulid3 } from "ulid";
+import { ulid as ulid5 } from "ulid";
 function recordColumns2(eb) {
   return [
     "id",
@@ -2008,7 +3597,7 @@ var init_SqliteMcpServerStore = __esm({
         const timestamp = nowIso();
         try {
           return await db.insertInto("mcp_server").values({
-            id: ulid3(),
+            id: ulid5(),
             tenant_id: input.tenant_id,
             name: input.name,
             manifest: jsonbBind(input.manifest),
@@ -2028,7 +3617,7 @@ var init_SqliteMcpServerStore = __esm({
         const db = transaction ?? this.#db;
         const timestamp = nowIso();
         return await db.insertInto("mcp_server").values({
-          id: ulid3(),
+          id: ulid5(),
           tenant_id: input.tenant_id,
           name: input.name,
           manifest: jsonbBind(input.manifest),
@@ -2358,7 +3947,7 @@ var SqliteAgentStore_exports = {};
 __export(SqliteAgentStore_exports, {
   SqliteAgentStore: () => SqliteAgentStore
 });
-import { ulid as ulid4 } from "ulid";
+import { ulid as ulid6 } from "ulid";
 function recordColumns5(eb) {
   return [
     "id",
@@ -2405,7 +3994,7 @@ var init_SqliteAgentStore = __esm({
         const timestamp = nowIso();
         try {
           const row = await db.insertInto("agent").values({
-            id: ulid4().toLowerCase(),
+            id: ulid6().toLowerCase(),
             tenant_id: input.tenant_id,
             name: input.name,
             manifest: jsonbBind(input.manifest),
@@ -2669,9 +4258,9 @@ async function assembleTurnRecord2(db, args) {
   if (!turn) {
     return void 0;
   }
-  const contextRows = await db.selectFrom("turn_thread as tt").leftJoin(lateralUnnestBigintArrayWithOrdinality(sql11`tt.context_ids`, "c"), (join) => join.onTrue()).leftJoin(
+  const contextRows = await db.selectFrom("turn_thread as tt").leftJoin(lateralUnnestBigintArrayWithOrdinality(sql11`tt.context_ids`, "c"), (join5) => join5.onTrue()).leftJoin(
     "thread_context_log as l",
-    (join) => join.on("l.session_id", "=", args.session_id).onRef("l.thread_id", "=", "tt.thread_id").onRef("l.append_id", "=", "c.append_id")
+    (join5) => join5.on("l.session_id", "=", args.session_id).onRef("l.thread_id", "=", "tt.thread_id").onRef("l.append_id", "=", "c.append_id")
   ).select(["tt.thread_id", "tt.checkpoint", "tt.agent_info", "tt.current_context_usage", "l.body", "c.pos"]).where("tt.session_id", "=", args.session_id).where("tt.turn_id", "=", args.turn_id).orderBy("tt.thread_id").orderBy("c.pos").execute();
   const capabilityRows = await db.selectFrom("thread_capability_state").select(["thread_id", sql11`jsonb_object_agg(key, state)`.as("capability_state")]).where("session_id", "=", args.session_id).where("turn_id", "=", args.turn_id).groupBy("thread_id").execute();
   const capabilityByThread = /* @__PURE__ */ new Map();
@@ -2754,7 +4343,7 @@ async function createTurn2(db, input) {
       if (prevTurnId != null) {
         const prevRows = await trx.selectFrom("turn as t").leftJoin(
           "turn_thread as tt",
-          (join) => join.onRef("tt.session_id", "=", "t.session_id").onRef("tt.turn_id", "=", "t.turn_id")
+          (join5) => join5.onRef("tt.session_id", "=", "t.session_id").onRef("tt.turn_id", "=", "t.turn_id")
         ).select([
           "t.checkpoint as turn_checkpoint",
           "t.state as turn_state",
@@ -3076,7 +4665,7 @@ async function listTurnEvents2(db, input) {
   const eventOrder = input.order === "desc" ? "desc" : "asc";
   const rows = await db.selectFrom("turn as t").leftJoin(
     (eb) => eb.selectFrom("session_event").select(["session_id", "turn_id", "event_id", "event"]).where("session_id", "=", input.session_id).where("turn_id", "=", input.turn_id).orderBy("event_id", eventOrder).limit(limit + 1).offset(offset).as("e"),
-    (join) => join.onRef("e.session_id", "=", "t.session_id").onRef("e.turn_id", "=", "t.turn_id")
+    (join5) => join5.onRef("e.session_id", "=", "t.session_id").onRef("e.turn_id", "=", "t.turn_id")
   ).select(["t.turn_id", "e.event"]).where("t.session_id", "=", input.session_id).where("t.turn_id", "=", input.turn_id).orderBy("e.event_id", eventOrder).execute();
   if (rows.length === 0) {
     throw new TurnNotFoundError5(input.turn_id);
@@ -3111,7 +4700,7 @@ async function listSessionEvents2(db, input) {
   const chainIds = await resolveAncestorChain2(db, input.session_id, anchor);
   const rows = await db.selectFrom(unnestWithOrdinality(chainIds, "c")).innerJoin(
     "session_event as e",
-    (join) => join.on("e.session_id", "=", input.session_id).onRef("e.turn_id", "=", "c.turn_id")
+    (join5) => join5.on("e.session_id", "=", input.session_id).onRef("e.turn_id", "=", "c.turn_id")
   ).select(["e.turn_id as turn_id", "e.event as event"]).orderBy("c.pos", "desc").orderBy("e.event_id", "desc").limit(limit + 1).offset(cursor.offset).execute();
   return paginateSessionEventRows2(rows, limit, cursor);
 }
@@ -3751,7 +5340,7 @@ var PostgresMcpServerStore_exports = {};
 __export(PostgresMcpServerStore_exports, {
   PostgresMcpServerStore: () => PostgresMcpServerStore
 });
-import { ulid as ulid5 } from "ulid";
+import { ulid as ulid7 } from "ulid";
 function toRecord3(row) {
   return {
     id: row.id,
@@ -3799,7 +5388,7 @@ var init_PostgresMcpServerStore = __esm({
         const db = transaction ?? this.#db;
         try {
           const row = await db.insertInto("mcp_server").values({
-            id: ulid5(),
+            id: ulid7(),
             tenant_id: input.tenant_id,
             name: input.name,
             manifest: json(input.manifest),
@@ -3819,7 +5408,7 @@ var init_PostgresMcpServerStore = __esm({
       async upsertServer(input, transaction) {
         const db = transaction ?? this.#db;
         const row = await db.insertInto("mcp_server").values({
-          id: ulid5(),
+          id: ulid7(),
           tenant_id: input.tenant_id,
           name: input.name,
           manifest: json(input.manifest),
@@ -4142,7 +5731,7 @@ var PostgresAgentStore_exports = {};
 __export(PostgresAgentStore_exports, {
   PostgresAgentStore: () => PostgresAgentStore
 });
-import { ulid as ulid6 } from "ulid";
+import { ulid as ulid8 } from "ulid";
 function toRecord6(row) {
   return {
     id: row.id,
@@ -4185,7 +5774,7 @@ var init_PostgresAgentStore = __esm({
         const db = transaction ?? this.#db;
         try {
           const row = await db.insertInto("agent").values({
-            id: ulid6().toLowerCase(),
+            id: ulid8().toLowerCase(),
             tenant_id: input.tenant_id,
             name: input.name,
             manifest: json(input.manifest),
@@ -4218,8 +5807,41 @@ var init_PostgresAgentStore = __esm({
 
 // src/main.ts
 import { extractErrorLogFields as extractErrorLogFields9 } from "@truefoundry/trueforge-core/core";
-import { mkdir } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import path6 from "path";
+
+// src/sandbox/localLifecycle.ts
+import { existsSync } from "fs";
+import { mkdir, rm } from "fs/promises";
+var SOCKET_PARENT_MODE = 448;
+async function prepareCodeModeSocketParent(params) {
+  if (existsSync(params.path)) {
+    params.logger.warn("Removing leftover Code Mode socket parent", { path: params.path });
+    await rm(params.path, { recursive: true, force: true });
+  }
+  await mkdir(params.path, { recursive: true, mode: SOCKET_PARENT_MODE });
+}
+async function removeCodeModeSocketParent(socketParentPath) {
+  await rm(socketParentPath, { recursive: true, force: true });
+}
+async function ensureLocalSandboxRootParent(sandboxRootPathParent) {
+  await mkdir(sandboxRootPathParent, { recursive: true, mode: SOCKET_PARENT_MODE });
+}
+
+// src/sandbox/localRuntime.ts
+init_config();
+var cachedSupport;
+function setCachedLocalSandboxSupport(support) {
+  cachedSupport = support;
+}
+function getCachedLocalSandboxSupport() {
+  return cachedSupport;
+}
+function isLocalSandboxFallbackEnabled() {
+  return config_default.STANDALONE && cachedSupport?.supported === true;
+}
+
+// src/main.ts
 import { serve } from "@hono/node-server";
 import {
   CancellationReason as CancellationReason4,
@@ -4229,7 +5851,7 @@ import { RequestReplyExecutor, RequestReplyRouter } from "@truefoundry/trueforge
 
 // src/app.ts
 import { swaggerUI } from "@hono/swagger-ui";
-import { OpenAPIHono as OpenAPIHono14, z as z24 } from "@hono/zod-openapi";
+import { OpenAPIHono as OpenAPIHono14, z as z26 } from "@hono/zod-openapi";
 import { extractErrorLogFields as extractErrorLogFields7 } from "@truefoundry/trueforge-core/core";
 import { bodyLimit } from "hono/body-limit";
 import { HTTPException as HTTPException5 } from "hono/http-exception";
@@ -4251,6 +5873,8 @@ var NameSchema = z.string().min(2).max(64).regex(
   /^[a-z](?:[a-z0-9._-]{0,62}[a-z0-9])$/,
   'must be 2\u201364 lowercase chars: start with a letter, end with alphanumeric, optionally separated by ".", "_" or "-"'
 ).openapi("ResourceName");
+var PAGE_LIMIT = 25;
+var EVENTS_PAGE_LIMIT = 100;
 function uniqueNames(entries, ctx) {
   const seen = /* @__PURE__ */ new Set();
   for (const entry of entries) {
@@ -4281,9 +5905,9 @@ var CreateAgentRequestSchema = z2.object({
   name: NameSchema,
   manifest: AgentSpecSchema2
 }).strict().openapi("CreateAgentRequest");
-var PutAgentRequestSchema = z2.object({
+var UpdateAgentRequestSchema = z2.object({
   manifest: AgentSpecSchema2
-}).strict().openapi("PutAgentRequest");
+}).strict().openapi("UpdateAgentRequest");
 var AgentSchema = z2.object({
   id: z2.string().min(1).describe("Immutable server-generated agent identifier."),
   name: NameSchema,
@@ -4304,15 +5928,26 @@ var RequestErrorResponseSchema = z3.object({
   })
 }).openapi("RequestErrorResponse");
 
+// src/routes/openapiTags.ts
+var OPENAPI_DOCUMENT_TAGS = [
+  { name: "Auth" /* AUTH */ },
+  { name: "Capabilities" /* CAPABILITIES */ },
+  { name: "Models" /* MODELS */ },
+  { name: "MCP Servers" /* MCP_SERVERS */ },
+  { name: "Skills" /* SKILLS */ },
+  { name: "Sandboxes" /* SANDBOXES */ },
+  { name: "Agents" /* AGENTS */ },
+  { name: "Agent Sessions" /* AGENT_SESSIONS */ }
+];
+
 // src/routes/agentRoutes.ts
-var AGENTS_TAG = "Agents";
 var AgentIdParamsSchema = z4.object({
   agent_id: z4.string().min(1).max(64).describe("Immutable agent identifier.")
 });
 var listAgentsRoute = createRoute({
   method: "get",
   path: "/",
-  tags: [AGENTS_TAG],
+  tags: ["Agents" /* AGENTS */],
   summary: "List agents",
   description: "All configured agents for the tenant.",
   "x-fern-sdk-group-name": ["agents"],
@@ -4331,7 +5966,7 @@ var listAgentsRoute = createRoute({
 var createAgentRoute = createRoute({
   method: "post",
   path: "/",
-  tags: [AGENTS_TAG],
+  tags: ["Agents" /* AGENTS */],
   summary: "Create an agent",
   description: "Creates an agent and allocates an immutable id. Fails if `name` is already taken. Name cannot be changed later.",
   "x-fern-sdk-group-name": ["agents"],
@@ -4364,7 +5999,7 @@ var createAgentRoute = createRoute({
 var getAgentRoute = createRoute({
   method: "get",
   path: "/{agent_id}",
-  tags: [AGENTS_TAG],
+  tags: ["Agents" /* AGENTS */],
   summary: "Get an agent",
   description: "Fetch a configured agent by immutable id.",
   "x-fern-sdk-group-name": ["agents"],
@@ -4386,7 +6021,7 @@ var getAgentRoute = createRoute({
 var deleteAgentRoute = createRoute({
   method: "delete",
   path: "/{agent_id}",
-  tags: [AGENTS_TAG],
+  tags: ["Agents" /* AGENTS */],
   summary: "Delete an agent",
   description: "Delete a configured agent by immutable id. Idempotent if already gone.",
   "x-fern-sdk-group-name": ["agents"],
@@ -4408,7 +6043,7 @@ var deleteAgentRoute = createRoute({
 var putAgentRoute = createRoute({
   method: "put",
   path: "/{agent_id}",
-  tags: [AGENTS_TAG],
+  tags: ["Agents" /* AGENTS */],
   summary: "Update an agent",
   description: "Replaces the manifest for an existing agent keyed by immutable `agent_id`.",
   "x-fern-sdk-group-name": ["agents"],
@@ -4416,7 +6051,7 @@ var putAgentRoute = createRoute({
   request: {
     params: AgentIdParamsSchema,
     body: {
-      content: { "application/json": { schema: PutAgentRequestSchema } },
+      content: { "application/json": { schema: UpdateAgentRequestSchema } },
       required: true
     }
   },
@@ -4447,6 +6082,7 @@ import {
   SkillMounter
 } from "@truefoundry/trueforge-core/core";
 import { HTTPException } from "hono/http-exception";
+import { join as join4 } from "path";
 
 // src/mcp/auth/mcpDcr.ts
 import {
@@ -4511,19 +6147,6 @@ function isOAuthAccessTokenUsable(expiresAtIso, nowMs) {
   const expiresAtMs = Date.parse(expiresAtIso);
   return !Number.isNaN(expiresAtMs) && expiresAtMs > nowMs;
 }
-function validateRedirectUris({ redirectUris }) {
-  for (const redirectUri of redirectUris) {
-    let parsed;
-    try {
-      parsed = new URL(redirectUri);
-    } catch (error) {
-      throw new McpConnectionError(`Invalid redirect URI: ${redirectUri}. Must be a valid URL.`, 400, { cause: error });
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      throw new McpConnectionError(`Invalid redirect URI: ${redirectUri}. Must be a valid URL.`, 400);
-    }
-  }
-}
 
 // src/mcp/auth/mcpDcr.ts
 var MCP_OAUTH_HTTP_TIMEOUT_MS = 15e3;
@@ -4674,7 +6297,7 @@ async function buildMcpAuthorizationUrl(params) {
     userRef: params.userRef,
     mcpServerUrl: params.mcpServerUrl,
     codeVerifier: started.codeVerifier,
-    redirectUrl: params.redirectUrl ?? null
+    returnTo: params.returnTo ?? null
   });
   return started.authorizationUrl;
 }
@@ -4717,7 +6340,7 @@ async function resolveMcpAuth(params) {
     userRef: params.userRef,
     mcpServerUrl: params.mcpServerUrl,
     mcpServerName: params.mcpServerName,
-    ...params.redirectUrl !== void 0 ? { redirectUrl: params.redirectUrl } : {}
+    ...params.returnTo !== void 0 ? { returnTo: params.returnTo } : {}
   });
   return { authUrl };
 }
@@ -4761,46 +6384,49 @@ async function completeMcpAuthorization(params) {
   });
 }
 
+// src/runtime/sessionResources.ts
+init_LocalSandboxProvider();
+
 // src/sandbox/providerUtils.ts
 init_config();
 import { Daytona, DaytonaError } from "@daytona/sdk";
 import { DaytonaSandboxProvider, SANDBOX_IMAGE_URI } from "@truefoundry/trueforge-core/core";
 
 // src/schemas/sandboxProvider.ts
-import { z as z5 } from "@hono/zod-openapi";
-var DaytonaSandboxProviderAuthSchema = z5.object({
-  api_key: z5.string().min(1).describe(
+import { z as z7 } from "@hono/zod-openapi";
+var DaytonaSandboxProviderAuthSchema = z7.object({
+  api_key: z7.string().min(1).describe(
     "Daytona API key. Responses are redacted; on PUT, a real value sets/rotates and a redacted value keeps the stored key."
   )
 }).strict().describe("Daytona authentication credentials.").openapi("DaytonaSandboxProviderAuth");
-var DaytonaSandboxProviderSchema = z5.object({
-  type: z5.literal("daytona").describe("Daytona sandbox provider."),
+var DaytonaSandboxProviderSchema = z7.object({
+  type: z7.literal("daytona").describe("Daytona sandbox provider."),
   auth: DaytonaSandboxProviderAuthSchema,
-  exec_timeout_ms: z5.number().int().positive().describe("Default sandbox command exec timeout in milliseconds."),
-  auto_stop_interval_in_minutes: z5.number().int().nonnegative().describe("Minutes of idle time before Daytona auto-stops the sandbox (0 disables)."),
-  auto_archive_interval_in_minutes: z5.number().int().nonnegative().describe("Minutes before Daytona auto-archives the sandbox (0 disables)."),
-  auto_delete_interval_in_minutes: z5.number().int().nonnegative().describe("Minutes before Daytona auto-deletes the sandbox (0 disables).")
+  exec_timeout_ms: z7.number().int().positive().describe("Default sandbox command exec timeout in milliseconds."),
+  auto_stop_interval_in_minutes: z7.number().int().nonnegative().describe("Minutes of idle time before Daytona auto-stops the sandbox (0 disables)."),
+  auto_archive_interval_in_minutes: z7.number().int().nonnegative().describe("Minutes before Daytona auto-archives the sandbox (0 disables)."),
+  auto_delete_interval_in_minutes: z7.number().int().nonnegative().describe("Minutes before Daytona auto-deletes the sandbox (0 disables).")
 }).strict();
 var SandboxProviderManifestSchema = DaytonaSandboxProviderSchema.openapi("SandboxProviderManifest");
-var SandboxBuildStatusSchema = z5.enum(["pending", "ready", "failed"]).describe("Current build status.").openapi("SandboxBuildStatus");
-var SandboxBuildMetadataSchema = z5.record(z5.string(), z5.string()).describe("Provider-specific build metadata (opaque string map).");
-var SandboxStatusSchema = z5.object({
+var SandboxBuildStatusSchema = z7.enum(["pending", "ready", "failed"]).describe("Current build status.").openapi("SandboxBuildStatus");
+var SandboxBuildMetadataSchema = z7.record(z7.string(), z7.string()).describe("Provider-specific build metadata (opaque string map).");
+var SandboxStatusSchema = z7.object({
   status: SandboxBuildStatusSchema,
-  status_reason: z5.string().nullable().describe("Human-readable detail for the current status; null when ready."),
+  status_reason: z7.string().nullable().describe("Human-readable detail for the current status; null when ready."),
   build_metadata: SandboxBuildMetadataSchema.nullable().describe(
     "Provider-specific build metadata; null when the provider has none."
   )
 }).strict();
-var SandboxProviderSchema = z5.object({
+var ConfiguredSandboxProviderSchema = z7.object({
   manifest: SandboxProviderManifestSchema,
   status: SandboxBuildStatusSchema,
-  status_reason: z5.string().nullable().describe("Human-readable detail for the current status; null when ready.")
-}).strict().openapi("SandboxProvider");
-var PutSandboxProviderRequestSchema = z5.object({
+  status_reason: z7.string().nullable().describe("Human-readable detail for the current status; null when ready.")
+}).strict().openapi("ConfiguredSandboxProvider");
+var UpdateSandboxProviderRequestSchema = z7.object({
   manifest: SandboxProviderManifestSchema
-}).strict().openapi("PutSandboxProviderRequest");
-var GetSandboxProviderResponseSchema = z5.object({
-  data: SandboxProviderSchema
+}).strict().openapi("UpdateSandboxProviderRequest");
+var GetSandboxProviderResponseSchema = z7.object({
+  data: ConfiguredSandboxProviderSchema
 }).openapi("GetSandboxProviderResponse");
 function toDaytonaSandboxProviderInput(manifest) {
   return {
@@ -4881,57 +6507,57 @@ async function checkSnapshotStatus({
 }
 
 // src/schemas/mcpServer.ts
-import { z as z6 } from "@hono/zod-openapi";
-var McpServerTypeSchema = z6.enum(["remote"]).openapi("McpServerType");
-var McpServerHeaderAuthSchema = z6.object({
-  type: z6.literal("header").describe("Authenticate with static HTTP headers."),
-  headers: z6.record(z6.string().min(1), z6.string().min(1)).refine((headers) => Object.keys(headers).length > 0, {
+import { z as z8 } from "@hono/zod-openapi";
+var McpServerTypeSchema = z8.enum(["remote"]).openapi("MCPServerType");
+var McpServerHeaderAuthSchema = z8.object({
+  type: z8.literal("header").describe("Authenticate with static HTTP headers."),
+  headers: z8.record(z8.string().min(1), z8.string().min(1)).refine((headers) => Object.keys(headers).length > 0, {
     message: "must include at least one header"
   }).describe(
     "Request headers for this MCP server. Responses are redacted; on PUT, a real value sets/rotates and a redacted value keeps the stored secret for that header name."
   )
-}).strict().openapi("McpServerHeaderAuth");
-var McpServerDcrAuthSchema = z6.object({
-  type: z6.literal("dcr").describe("Authenticate via OAuth Dynamic Client Registration.")
-}).strict().openapi("McpServerDcrAuth");
-var McpServerManifestAuthSchema = z6.discriminatedUnion("type", [McpServerHeaderAuthSchema, McpServerDcrAuthSchema]).describe("Optional auth settings. Omit when the server needs no credentials.").openapi("McpServerManifestAuth");
-var McpServerDescriptionSchema = z6.string().trim().min(1).describe("Concise summary of what this MCP server provides.");
-var McpServerManifestObjectSchema = z6.object({
+}).strict().openapi("MCPServerHeaderAuth");
+var McpServerDcrAuthSchema = z8.object({
+  type: z8.literal("dcr").describe("Authenticate via OAuth Dynamic Client Registration.")
+}).strict().openapi("MCPServerDcrAuth");
+var McpServerManifestAuthSchema = z8.discriminatedUnion("type", [McpServerHeaderAuthSchema, McpServerDcrAuthSchema]).describe("Optional auth settings. Omit when the server needs no credentials.").openapi("MCPServerManifestAuth");
+var McpServerDescriptionSchema = z8.string().trim().min(1).describe("Concise summary of what this MCP server provides.");
+var McpServerManifestObjectSchema = z8.object({
   type: McpServerTypeSchema,
   name: NameSchema,
-  url: z6.url().describe("URL of the remote MCP server."),
+  url: z8.url().describe("URL of the remote MCP server."),
   description: McpServerDescriptionSchema,
   auth: McpServerManifestAuthSchema.optional()
 }).strict();
-var McpServerManifestSchema = McpServerManifestObjectSchema.openapi("McpServerManifest");
-var McpAuthStatusSchema = z6.object({
-  status: z6.enum(["authenticated", "auth_required", "not_required"]).describe("Current auth state for this MCP server."),
-  authorization_url: z6.url().optional().describe("When auth is required, this contains the URL to redirect the user to for authorization.")
-}).strict().describe("Current auth state.").openapi("McpAuthStatus");
-var ConfiguredMcpServerSchema = z6.object({
+var McpServerManifestSchema = McpServerManifestObjectSchema.openapi("MCPServerManifest");
+var McpAuthStatusSchema = z8.object({
+  status: z8.enum(["authenticated", "auth_required", "not_required"]).describe("Current auth state for this MCP server."),
+  authorization_url: z8.url().optional().describe("When auth is required, this contains the URL to redirect the user to for authorization.")
+}).strict().describe("Current auth state.").openapi("MCPAuthStatus");
+var ConfiguredMcpServerSchema = z8.object({
   name: NameSchema,
   manifest: McpServerManifestSchema,
   auth_status: McpAuthStatusSchema
-}).strict().openapi("ConfiguredMcpServer");
-var CreateMcpServerRequestSchema = z6.object({
+}).strict().openapi("ConfiguredMCPServer");
+var CreateMcpServerRequestSchema = z8.object({
   manifest: McpServerManifestSchema
-}).strict().openapi("CreateMcpServerRequest");
-var PutMcpServerRequestSchema = z6.object({
+}).strict().openapi("CreateMCPServerRequest");
+var UpdateMcpServerRequestSchema = z8.object({
   manifest: McpServerManifestSchema
-}).strict().openapi("PutMcpServerRequest");
-var GetMcpServerResponseSchema = z6.object({ data: ConfiguredMcpServerSchema }).openapi("GetMcpServerResponse");
-var ListMcpServersResponseSchema = z6.object({ data: z6.array(ConfiguredMcpServerSchema) }).openapi("ListMcpServersResponse");
-var McpServerAuthPublicSchema = z6.discriminatedUnion("type", [
-  z6.object({ type: z6.literal("dcr") }).strict(),
-  z6.object({ type: z6.literal("header") }).strict()
-]).describe("Auth mechanism when configured (no secrets). Omit when the server needs no credentials.").openapi("McpServerAuthPublic");
-var McpServerReadEntrySchema = z6.object({
+}).strict().openapi("UpdateMCPServerRequest");
+var GetMcpServerResponseSchema = z8.object({ data: ConfiguredMcpServerSchema }).openapi("GetMCPServerResponse");
+var ListMcpServersResponseSchema = z8.object({ data: z8.array(ConfiguredMcpServerSchema) }).openapi("ListMCPServersResponse");
+var McpServerAuthPublicSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("dcr") }).strict(),
+  z8.object({ type: z8.literal("header") }).strict()
+]).describe("Auth mechanism when configured (no secrets). Omit when the server needs no credentials.").openapi("MCPServerAuthPublic");
+var AvailableMcpServerSchema = z8.object({
   name: NameSchema,
-  url: z6.url().describe("URL of the remote MCP server."),
+  url: z8.url().describe("URL of the remote MCP server."),
   auth: McpServerAuthPublicSchema.optional(),
   auth_status: McpAuthStatusSchema
-}).strict().openapi("McpServerReadEntry");
-var ListAvailableMcpServersResponseSchema = z6.object({ data: z6.array(McpServerReadEntrySchema) }).openapi("ListAvailableMcpServersResponse");
+}).strict().openapi("AvailableMCPServer");
+var ListAvailableMcpServersResponseSchema = z8.object({ data: z8.array(AvailableMcpServerSchema) }).openapi("ListAvailableMCPServersResponse");
 function resolveConfiguredMcpRequestHeaders(manifest) {
   if (manifest.auth?.type === "header") {
     return { ...manifest.auth.headers };
@@ -5079,20 +6705,40 @@ async function resolveGitSkills({
   }
   return resolved;
 }
+function localSandboxSessionSegment(sessionId) {
+  if (sessionId === void 0 || sessionId.length === 0 || sessionId.includes("/") || sessionId.includes("..")) {
+    return "_";
+  }
+  return sessionId;
+}
 async function resolveSandboxProvider({
   tenant_id,
   store,
-  logger
+  logger,
+  sessionId
 }) {
   const record = await store.getSandboxProvider(tenant_id);
-  if (record === void 0) {
+  if (record !== void 0) {
+    return toDaytonaSandboxProvider({
+      manifest: record.manifest,
+      tenant_id,
+      logger,
+      build_metadata: record.build_metadata
+    });
+  }
+  if (!config_default.STANDALONE) {
     return void 0;
   }
-  return toDaytonaSandboxProvider({
-    manifest: record.manifest,
-    tenant_id,
-    logger,
-    build_metadata: record.build_metadata
+  const support = getCachedLocalSandboxSupport();
+  if (support?.supported !== true) {
+    return void 0;
+  }
+  return new LocalSandboxProvider({
+    sandboxRootPathParent: join4(config_default.LOCAL_SANDBOX_ROOT_PARENT, localSandboxSessionSegment(sessionId)),
+    codeModeSocketParentPath: config_default.CODE_MODE_SOCKET_PARENT,
+    support,
+    fileMaxBytesForDownload: config_default.SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD,
+    logger
   });
 }
 function buildTurnSandbox(input) {
@@ -5104,9 +6750,6 @@ function buildTurnSandbox(input) {
     blockDestructiveToolsInCodeMode: true,
     mcpRequestTimeoutMs: config_default.MCP_REQUEST_TIMEOUT_MS,
     mcpConnectTimeoutMs: config_default.MCP_CONNECT_TIMEOUT_MS,
-    // Sandbox reads its tenant from TFY_TENANT_NAME for the ownership check
-    // against provider-created sandbox ids (`<tenant>.<uuid>`).
-    execExtraEnv: { TFY_TENANT_NAME: input.tenantName },
     ...skillMounter ? { skillMounter } : {},
     tracing: input.tracing,
     logger: input.logger
@@ -5175,7 +6818,7 @@ async function validateAgentSpec({
   const hasSkills = requestedSkills.length > 0;
   if (wantsSandbox || hasSkills) {
     const record = await sandboxProviderStore.getSandboxProvider(tenant_id);
-    if (record === void 0) {
+    if (record === void 0 && !isLocalSandboxFallbackEnabled()) {
       throw new HTTPException(422, {
         message: hasSkills ? "skills require a sandbox provider \u2014 configure via PUT /settings/sandbox-providers" : "sandbox is enabled but no sandbox provider is configured \u2014 PUT /settings/sandbox-providers"
       });
@@ -5198,14 +6841,14 @@ import {
   redisRequest,
   RequestTimeoutError
 } from "@truefoundry/trueforge-core/request-reply";
-import { ulid as ulid2 } from "ulid";
-import { z as z11 } from "zod";
+import { ulid as ulid4 } from "ulid";
+import { z as z13 } from "zod";
 
 // src/routes/sessionRoutes.ts
-import { createRoute as createRoute2, z as z10 } from "@hono/zod-openapi";
+import { createRoute as createRoute2, z as z12 } from "@hono/zod-openapi";
 
 // src/schemas/events.ts
-import { z as z7 } from "@hono/zod-openapi";
+import { z as z9 } from "@hono/zod-openapi";
 import {
   EventType,
   SessionEventItemSchema,
@@ -5225,7 +6868,7 @@ import {
   ToolResponseEventSchema,
   ToolResponseRequiredEventSchema
 } from "@truefoundry/trueforge-core/core";
-var TurnStreamingEventSchema = z7.discriminatedUnion("type", [
+var TurnStreamingEventSchema = z9.discriminatedUnion("type", [
   ModelMessageEventSchema,
   ModelMessageDeltaEventSchema,
   ToolResponseEventSchema,
@@ -5239,105 +6882,94 @@ var TurnStreamingEventSchema = z7.discriminatedUnion("type", [
   TurnCreatedEventSchema,
   TurnDoneEventSchema
 ]).openapi("TurnStreamingEvent");
-var SESSION_EVENTS_LIMIT = 100;
-var ListSessionEventsRequestQuerySchema = z7.object({
-  page_token: z7.string().optional().describe(
+var ListSessionEventsRequestQuerySchema = z9.object({
+  page_token: z9.string().optional().describe(
     "Pagination cursor from `pagination.next_page_token`. It retains the branch anchor turn and returns older events toward the session start."
   ),
-  last_turn_id: z7.string().optional().describe(
+  last_turn_id: z9.string().optional().describe(
     "Newest turn in the listing window (initial load only; ignored when `page_token` is set). Lists that turn and its ancestors, newest events first. Omit to use the session last turn."
   ),
-  limit: z7.coerce.number().int().min(1).max(SESSION_EVENTS_LIMIT).optional().default(SESSION_EVENTS_LIMIT).describe(
-    `Max events per response. Default ${String(SESSION_EVENTS_LIMIT)}, max ${String(SESSION_EVENTS_LIMIT)}.`
-  )
+  limit: z9.coerce.number().int().min(1).max(EVENTS_PAGE_LIMIT).optional().default(EVENTS_PAGE_LIMIT).describe(`Page size. Defaults to ${String(EVENTS_PAGE_LIMIT)}, max ${String(EVENTS_PAGE_LIMIT)}.`)
 }).openapi("ListSessionEventsRequestQuery");
-var ListSessionEventsResponseSchema = z7.object({
-  data: z7.array(SessionEventItemSchema),
+var ListSessionEventsResponseSchema = z9.object({
+  data: z9.array(SessionEventItemSchema),
   pagination: TokenPaginationSchema
 }).openapi("ListSessionEventsResponse");
 
 // src/schemas/session.ts
-import { z as z8 } from "@hono/zod-openapi";
+import { z as z10 } from "@hono/zod-openapi";
 import { AgentSpecSchema as AgentSpecSchema3, SessionSchema, TokenPaginationSchema as TokenPaginationSchema2 } from "@truefoundry/trueforge-core/agent-session";
-var SessionAgentNameRefSchema = z8.object({ name: NameSchema }).strict().openapi("SessionAgentNameRef");
-var SessionAgentSpecBodySchema = z8.object({ spec: AgentSpecSchema3 }).strict().openapi("SessionAgentSpecBody");
-var CreateSessionAgentSchema = z8.union([SessionAgentNameRefSchema, SessionAgentSpecBodySchema]).openapi("CreateSessionAgent");
+var SessionAgentNameRefSchema = z10.object({ name: NameSchema }).strict().openapi("SessionAgentNameRef");
+var SessionAgentSpecBodySchema = z10.object({ spec: AgentSpecSchema3 }).strict().openapi("SessionAgentSpecBody");
+var CreateSessionAgentSchema = z10.union([SessionAgentNameRefSchema, SessionAgentSpecBodySchema]).openapi("CreateSessionAgent");
 function isSessionAgentNameRef(agent) {
   return SessionAgentNameRefSchema.safeParse(agent).success;
 }
-var CreateSessionRequestSchema = z8.object({
+var CreateSessionRequestSchema = z10.object({
   agent: CreateSessionAgentSchema
 }).strict().openapi("CreateSessionRequest");
-var UpdateSessionRequestSchema = z8.object({
+var UpdateSessionRequestSchema = z10.object({
   agent: SessionAgentSpecBodySchema.optional()
 }).strict().openapi("UpdateSessionRequest");
-var DEFAULT_SESSIONS_LIMIT = 10;
-var SESSIONS_MAX_LIMIT = 100;
-var IsoTimestampQueryParam = z8.iso.datetime({ offset: true }).openapi({ type: "string", format: "date-time" }).transform((s) => new Date(s));
-var ListSessionsRequestQuerySchema = z8.object({
-  limit: z8.coerce.number().int().min(1).max(SESSIONS_MAX_LIMIT).optional().default(DEFAULT_SESSIONS_LIMIT).describe(`Page size. Defaults to ${String(DEFAULT_SESSIONS_LIMIT)}, max ${String(SESSIONS_MAX_LIMIT)}.`),
-  order: z8.enum(["asc", "desc"]).optional().default("desc").describe('Sort sessions by `updated_at`. Defaults to "desc".').openapi("ListSessionsOrder"),
-  page_token: z8.string().min(1).optional().describe("Opaque keyset cursor from a previous response `next_page_token`."),
+var IsoTimestampQueryParam = z10.iso.datetime({ offset: true }).openapi({ type: "string", format: "date-time" }).transform((s) => new Date(s));
+var ListSessionsRequestQuerySchema = z10.object({
+  limit: z10.coerce.number().int().min(1).max(PAGE_LIMIT).optional().default(PAGE_LIMIT).describe(`Page size. Defaults to ${String(PAGE_LIMIT)}, max ${String(PAGE_LIMIT)}.`),
+  order: z10.enum(["asc", "desc"]).optional().default("desc").describe('Sort sessions by `updated_at`. Defaults to "desc".').openapi("ListSessionsOrder"),
+  page_token: z10.string().min(1).optional().describe("Opaque keyset cursor from a previous response `next_page_token`."),
   start_timestamp: IsoTimestampQueryParam.optional().describe(
     "Inclusive lower bound on `created_at` (ISO-8601 / RFC 3339)."
   ),
   end_timestamp: IsoTimestampQueryParam.optional().describe(
     "Inclusive upper bound on `created_at` (ISO-8601 / RFC 3339)."
   ),
-  agent_id: z8.string().min(1).optional().describe("When set, only sessions bound to this agent id are returned.")
+  agent_id: z10.string().min(1).optional().describe("When set, only sessions bound to this agent id are returned.")
 }).openapi("ListSessionsRequestQuery");
-var GetSessionResponseSchema = z8.object({
+var GetSessionResponseSchema = z10.object({
   data: SessionSchema
 }).openapi("GetSessionResponse");
-var ListSessionsResponseSchema = z8.object({
-  data: z8.array(SessionSchema),
+var ListSessionsResponseSchema = z10.object({
+  data: z10.array(SessionSchema),
   pagination: TokenPaginationSchema2
 }).openapi("ListSessionsResponse");
 
 // src/schemas/turn.ts
-import { z as z9 } from "@hono/zod-openapi";
+import { z as z11 } from "@hono/zod-openapi";
 import { SessionEventSchema, TokenPaginationSchema as TokenPaginationSchema3, TurnSchema } from "@truefoundry/trueforge-core/agent-session";
 import { CreateTurnRequestSchema, TurnSchema as TurnSchema2 } from "@truefoundry/trueforge-core/agent-session";
-var SubscribeTurnQuerySchema = z9.object({
+var SubscribeTurnQuerySchema = z11.object({
   // Query strings need coerce; map null/'' to undefined first so Number(null)→0
   // cannot silently become a resume cursor (and so OpenAPI does not advertise null).
-  after_sequence_number: z9.preprocess(
+  after_sequence_number: z11.preprocess(
     (val) => val === null || val === "" ? void 0 : val,
-    z9.coerce.number().int().nonnegative().optional().describe(
+    z11.coerce.number().int().nonnegative().optional().describe(
       "Exclusive resume cursor: replay only events with a sequence number greater than this value. Omit to start from the beginning of the live buffer."
     )
   )
 }).openapi("SubscribeTurnQuery");
-var CancelSessionRequestSchema = z9.object({}).describe("Empty request body. Cancel identifies the session via the path only.").openapi("CancelSessionRequest");
-var CancelSessionResponseSchema = z9.object({}).describe("Empty success body. HTTP 200 means the cancel request was accepted (or nothing was running).").openapi("CancelSessionResponse");
-var DEFAULT_TURNS_LIMIT = 10;
-var TURNS_MAX_LIMIT = 100;
-var ListTurnsRequestQuerySchema = z9.object({
-  limit: z9.coerce.number().int().min(1).max(TURNS_MAX_LIMIT).optional().default(DEFAULT_TURNS_LIMIT).describe(`Page size. Defaults to ${String(DEFAULT_TURNS_LIMIT)}, max ${String(TURNS_MAX_LIMIT)}.`),
-  page_token: z9.string().optional().describe("Opaque token from a previous response `next_page_token`.")
+var CancelSessionRequestSchema = z11.object({}).describe("Empty request body. Cancel identifies the session via the path only.").openapi("CancelSessionRequest");
+var CancelSessionResponseSchema = z11.object({}).describe("Empty success body. HTTP 200 means the cancel request was accepted (or nothing was running).").openapi("CancelSessionResponse");
+var ListTurnsRequestQuerySchema = z11.object({
+  limit: z11.coerce.number().int().min(1).max(PAGE_LIMIT).optional().default(PAGE_LIMIT).describe(`Page size. Defaults to ${String(PAGE_LIMIT)}, max ${String(PAGE_LIMIT)}.`),
+  page_token: z11.string().optional().describe("Opaque token from a previous response `next_page_token`.")
 }).openapi("ListTurnsRequestQuery");
-var GetTurnResponseSchema = z9.object({
+var GetTurnResponseSchema = z11.object({
   data: TurnSchema
 }).openapi("GetTurnResponse");
-var ListTurnsResponseSchema = z9.object({
-  data: z9.array(TurnSchema),
+var ListTurnsResponseSchema = z11.object({
+  data: z11.array(TurnSchema),
   pagination: TokenPaginationSchema3
 }).openapi("ListTurnsResponse");
-var DEFAULT_TURN_EVENTS_LIMIT = 25;
-var TURN_EVENTS_MAX_LIMIT = 100;
-var ListTurnEventsRequestQuerySchema = z9.object({
-  limit: z9.coerce.number().int().min(1).max(TURN_EVENTS_MAX_LIMIT).optional().default(DEFAULT_TURN_EVENTS_LIMIT).describe(
-    `Max events per response. Default ${String(DEFAULT_TURN_EVENTS_LIMIT)}, max ${String(TURN_EVENTS_MAX_LIMIT)}.`
-  ),
-  page_token: z9.string().optional().describe("Opaque token from a previous response `next_page_token`."),
-  order: z9.enum(["asc", "desc"]).optional().default("asc").describe('Sort events by insertion order. Defaults to "asc".').openapi("ListTurnEventsOrder")
+var ListTurnEventsRequestQuerySchema = z11.object({
+  limit: z11.coerce.number().int().min(1).max(EVENTS_PAGE_LIMIT).optional().default(EVENTS_PAGE_LIMIT).describe(`Page size. Defaults to ${String(EVENTS_PAGE_LIMIT)}, max ${String(EVENTS_PAGE_LIMIT)}.`),
+  page_token: z11.string().optional().describe("Opaque token from a previous response `next_page_token`."),
+  order: z11.enum(["asc", "desc"]).optional().default("asc").describe('Sort events by insertion order. Defaults to "asc".').openapi("ListTurnEventsOrder")
 }).openapi("ListTurnEventsRequestQuery");
-var ListTurnEventsResponseSchema = z9.object({
-  data: z9.array(SessionEventSchema),
+var ListTurnEventsResponseSchema = z11.object({
+  data: z11.array(SessionEventSchema),
   pagination: TokenPaginationSchema3
 }).openapi("ListTurnEventsResponse");
-var DownloadSandboxFileRequestQuerySchema = z9.object({
-  path: z9.string().min(1).describe(
+var DownloadSandboxFileRequestQuerySchema = z11.object({
+  path: z11.string().min(1).describe(
     "Absolute path of the file inside the sandbox, as listed in the assistant's `sandbox_artifacts` block."
   )
 }).openapi("DownloadSandboxFileRequestQuery");
@@ -5350,14 +6982,13 @@ var TOKEN_PAGINATION = {
 };
 
 // src/routes/sessionRoutes.ts
-var SESSIONS_TAG = "Sessions";
-var SessionIdParamsSchema = z10.object({
-  session_id: z10.string().min(1).max(64).describe("Session identifier.")
+var SessionIdParamsSchema = z12.object({
+  session_id: z12.string().min(1).max(64).describe("Session identifier.")
 });
 var createSessionRoute = createRoute2({
   method: "post",
   path: "/",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Create a session",
   description: 'Create a session with `agent` as either `{ name }` (named registry binding) or `{ spec: AgentSpec }` (inline). Named sessions snapshot the agent name at create and resolve the live agent on each turn. Responses use `{ type: "reference", name, id }` or `{ type: "inline", spec }`.',
   "x-fern-sdk-group-name": ["sessions"],
@@ -5390,7 +7021,7 @@ var createSessionRoute = createRoute2({
 var getSessionRoute = createRoute2({
   method: "get",
   path: "/{session_id}",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Get a session",
   description: "Fetch a session by ID. Only the session creator (`created_by`) may fetch it.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5416,7 +7047,7 @@ var getSessionRoute = createRoute2({
 var deleteSessionRoute = createRoute2({
   method: "delete",
   path: "/{session_id}",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Delete a session",
   description: "Delete a session and all related turns, events, and internal state. Only the session creator (`created_by`) may delete it. Idempotent if already gone.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5437,7 +7068,7 @@ var deleteSessionRoute = createRoute2({
 var updateSessionRoute = createRoute2({
   method: "patch",
   path: "/{session_id}",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Update a session",
   description: "Update a session by replacing `agent` with `{ spec: AgentSpec }`. Named (reference) sessions reject agent updates. An empty body is a valid no-op that refreshes `updated_at`. Only the session creator (`created_by`) may update it.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5475,7 +7106,7 @@ var updateSessionRoute = createRoute2({
 var listSessionsRoute = createRoute2({
   method: "get",
   path: "/",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "List sessions",
   description: "List the caller's sessions (newest first by default), token-paginated. Results are scoped to the authenticated identity via the session store's `created_by` filter (not a client query param). Optional `agent_id` filters to sessions bound to that named agent. Pass `page_token` to fetch the next page, keeping the other query params constant.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5498,7 +7129,7 @@ var listSessionsRoute = createRoute2({
 var cancelSessionRoute = createRoute2({
   method: "post",
   path: "/{session_id}/cancel",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Cancel a running turn in a session",
   description: "Cancel the running last turn for a session. Only the session creator (`created_by`) may cancel.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5532,7 +7163,7 @@ var cancelSessionRoute = createRoute2({
 var listSessionEventsRoute = createRoute2({
   method: "get",
   path: "/{session_id}/events",
-  tags: [SESSIONS_TAG],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "List session events",
   description: "List session events as `{ turn_id, event }` across the active turn branch (newest first), including persisted events from a running tip. Each turn contributes turn.created, content events (model.message, tool.call, \u2026), and turn.done when terminal; streaming deltas are not included. Use `page_token` to paginate backward toward older events while retaining the original branch anchor. Only the session creator (`created_by`) may list events.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -5564,9 +7195,9 @@ var listSessionEventsRoute = createRoute2({
 
 // src/runtime/peeringIds.ts
 import { HTTPException as HTTPException2 } from "hono/http-exception";
-import { ulid } from "ulid";
+import { ulid as ulid3 } from "ulid";
 function mintPeeredTurnId(executorId) {
-  return `${ulid().toLowerCase()}.${executorId}`;
+  return `${ulid3().toLowerCase()}.${executorId}`;
 }
 function executorFromTurnId(turnId) {
   const parts = turnId.split(".");
@@ -5579,10 +7210,10 @@ function executorFromTurnId(turnId) {
 // src/apis/sessions.ts
 var TENANT_ID = "default";
 var SESSIONS_CANCEL_PATH = "sessions/cancel";
-var CancelPeerBodySchema = z11.object({
-  session_id: z11.string(),
-  turn_id: z11.string(),
-  reason: z11.enum(CancellationReason)
+var CancelPeerBodySchema = z13.object({
+  session_id: z13.string(),
+  turn_id: z13.string(),
+  reason: z13.enum(CancellationReason)
 });
 function toWireSession(record) {
   return {
@@ -5683,7 +7314,7 @@ function checkSessionAccess({ userRef, createdBy }) {
 function createSessionsRouter(deps) {
   const createSessionHandler = async (c) => {
     const body = c.req.valid("json");
-    const sessionId = ulid2().toLowerCase();
+    const sessionId = ulid4().toLowerCase();
     if (isSessionAgentNameRef(body.agent)) {
       const agent = await deps.agentStore.getAgent({ tenant_id: TENANT_ID, name: body.agent.name });
       if (agent === void 0) {
@@ -5944,13 +7575,13 @@ import { extractErrorLogFields as extractErrorLogFields2 } from "@truefoundry/tr
 // src/auth/cookies.ts
 init_config();
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 var OAUTH_STATE_COOKIE = "oauth_state";
 var ID_TOKEN_COOKIE = "id_token";
-var OAuthStateSchema = z12.object({
-  state: z12.string(),
-  code_verifier: z12.string(),
-  return_to: z12.string()
+var OAuthStateSchema = z14.object({
+  state: z14.string(),
+  code_verifier: z14.string(),
+  return_to: z14.string()
 });
 function getAuthCookieAttributes() {
   return {
@@ -6044,6 +7675,18 @@ function buildAuthorizationRequestParams(config) {
   };
 }
 
+// src/auth/safeReturnTo.ts
+var SAFE_RETURN_TO = /^\/(?!\/|api(?:\/|$)).*/;
+function isSafeReturnTo(value) {
+  return SAFE_RETURN_TO.test(value);
+}
+function safeReturnTo(value) {
+  if (value && isSafeReturnTo(value)) {
+    return value;
+  }
+  return "/";
+}
+
 // src/auth/oidc.ts
 var CALLBACK_PATH = "/api/v1/auth/callback";
 var OAUTH_STATE_MAX_AGE_SECONDS = 10 * 60;
@@ -6080,13 +7723,6 @@ function authCallbackUrl() {
   const publicBaseUrl = getPublicBaseUrl();
   return `${publicBaseUrl}${CALLBACK_PATH}`;
 }
-var SAFE_RETURN_TO = /^\/(?!\/|api(?:\/|$)).*/;
-function safeReturnTo(value) {
-  if (value && SAFE_RETURN_TO.test(value)) {
-    return value;
-  }
-  return "/";
-}
 async function buildLoginAuthorization(params) {
   const oidcConfig = getOidcVerify()?.oidcConfig;
   if (!oidcConfig) {
@@ -6242,36 +7878,36 @@ var adminAuthMiddleware = async (c, next) => {
 import { createRoute as createRoute3 } from "@hono/zod-openapi";
 
 // src/schemas/auth.ts
-import { z as z13 } from "@hono/zod-openapi";
-var AuthLoginQuerySchema = z13.object({
-  return_to: z13.string().optional().describe('Path to return to after login. Must be a same-origin relative path; anything else falls back to "/".')
+import { z as z15 } from "@hono/zod-openapi";
+var AuthLoginQuerySchema = z15.object({
+  return_to: z15.string().optional().describe('Path to return to after login. Must be a same-origin relative path; anything else falls back to "/".')
 });
-var OAuthCallbackQuerySchema = z13.object({
-  code: z13.string().min(1).optional().describe("Authorization code, present when the user granted consent."),
-  state: z13.string().min(1).describe("Opaque token; correlates this callback to its pending login. Always present, success or error."),
-  error: z13.string().optional().describe("Error code from the identity provider, present instead of `code` if the user denied consent."),
-  error_description: z13.string().optional().describe("Human-readable error detail from the identity provider when `error` is set.")
+var OAuthCallbackQuerySchema = z15.object({
+  code: z15.string().min(1).optional().describe("Authorization code, present when the user granted consent."),
+  state: z15.string().min(1).describe("Opaque token; correlates this callback to its pending login. Always present, success or error."),
+  error: z15.string().optional().describe("Error code from the identity provider, present instead of `code` if the user denied consent."),
+  error_description: z15.string().optional().describe("Human-readable error detail from the identity provider when `error` is set.")
 });
-var OAuthCallbackSuccessSchema = z13.object({
-  success: z13.literal(true).describe("Present when the OAuth callback completed without a redirect_url.")
+var OAuthCallbackSuccessSchema = z15.object({
+  success: z15.literal(true).describe("Present when the OAuth callback completed without a return_to.")
 });
-var MeResponseSchema = z13.object({
-  type: z13.enum(["default", "oidc-connected"]).describe(
+var GetMeResponseSchema = z15.object({
+  type: z15.enum(["default", "oidc-connected"]).describe(
     "Session kind: `default` when no valid OIDC session; `oidc-connected` after a successful browser login."
   ),
-  email: z13.string().describe('User email from the ID token when connected; `"default"` when anonymous.'),
-  role: z13.string().describe("Caller role.")
-}).openapi("MeResponse");
+  email: z15.string().describe('User email from the ID token when connected; `"default"` when anonymous.'),
+  role: z15.string().describe("Caller role.")
+}).openapi("GetMeResponse");
 
 // src/routes/authRoutes.ts
-var AUTH_TAG = "Auth";
 var authLoginRoute = createRoute3({
   method: "get",
   path: "/login",
-  tags: [AUTH_TAG],
+  tags: ["Auth" /* AUTH */],
   summary: "Start the login flow",
   description: "Redirects the browser to the configured identity provider. In local/single-binary mode, redirects straight back into the app \u2014 there is nothing to log into.",
   "x-fern-ignore": true,
+  "x-excluded": true,
   request: { query: AuthLoginQuerySchema },
   responses: {
     302: { description: "Redirect to the IdP authorization endpoint." }
@@ -6280,10 +7916,11 @@ var authLoginRoute = createRoute3({
 var oAuthCallbackRoute = createRoute3({
   method: "get",
   path: "/callback",
-  tags: [AUTH_TAG],
+  tags: ["Auth" /* AUTH */],
   summary: "Login callback",
   description: "Browser-redirect target hit by the identity provider after login, never called directly by SDK consumers. In local/single-binary mode, redirects straight back into the app.",
   "x-fern-ignore": true,
+  "x-excluded": true,
   request: { query: OAuthCallbackQuerySchema },
   responses: {
     302: { description: "Redirect back into the app on success, or to /?error=<reason> on failure." }
@@ -6292,11 +7929,11 @@ var oAuthCallbackRoute = createRoute3({
 var authLogoutRoute = createRoute3({
   method: "post",
   path: "/logout",
-  tags: [AUTH_TAG],
+  tags: ["Auth" /* AUTH */],
   summary: "Clear the local session",
   description: "Ends the local harness session only \u2014 does not hit the IdP end-session endpoint. A no-op in local/single-binary mode, since there is no real session to clear.",
-  "x-fern-sdk-group-name": ["auth"],
-  "x-fern-sdk-method-name": "logout",
+  "x-fern-ignore": true,
+  "x-excluded": true,
   responses: {
     204: { description: "Session cookie cleared." }
   }
@@ -6304,14 +7941,14 @@ var authLogoutRoute = createRoute3({
 var meRoute = createRoute3({
   method: "get",
   path: "/me",
-  tags: [AUTH_TAG],
+  tags: ["Auth" /* AUTH */],
   summary: "Current session",
   description: "Returns the authenticated caller identity. When auth is enabled this requires a valid `id_token` cookie or `Authorization: Bearer` ID token (401 otherwise). When auth is disabled, returns the default identity.",
   "x-fern-sdk-group-name": ["auth"],
   "x-fern-sdk-method-name": "me",
   responses: {
     200: {
-      content: { "application/json": { schema: MeResponseSchema } },
+      content: { "application/json": { schema: GetMeResponseSchema } },
       description: "Session type and identity for the current request."
     },
     401: {
@@ -6351,6 +7988,9 @@ function createAuthRouter(params) {
     const pending = readOAuthStateCookie({ context: c, logger: params.logger });
     clearAuthCookie({ context: c, name: OAUTH_STATE_COOKIE });
     if (pending?.state !== query.state || query.error || !query.code) {
+      if (await resolveAuthUser(c)) {
+        return c.redirect("/", 302);
+      }
       const description = query.error_description?.trim();
       const reason = query.error && description ? description : "login_failed";
       return c.redirect(oauthErrorRedirect(reason), 302);
@@ -6366,6 +8006,9 @@ function createAuthRouter(params) {
       return c.redirect(safeReturnTo(pending.return_to), 302);
     } catch (error) {
       params.logger.error("Failed to exchange authorization code", extractErrorLogFields2(error));
+      if (await resolveAuthUser(c)) {
+        return c.redirect(safeReturnTo(pending.return_to), 302);
+      }
       const reason = error instanceof Error ? error.message : "login_failed";
       return c.redirect(oauthErrorRedirect(reason), 302);
     }
@@ -6390,25 +8033,29 @@ import { OpenAPIHono as OpenAPIHono4 } from "@hono/zod-openapi";
 import { extractErrorLogFields as extractErrorLogFields3 } from "@truefoundry/trueforge-core/core";
 
 // src/routes/capabilityRoutes.ts
-import { createRoute as createRoute4, z as z14 } from "@hono/zod-openapi";
-var GetCapabilitiesResponseSchema = z14.object({
-  data: z14.object({
-    sandbox: z14.object({
-      enabled: z14.boolean().describe("Whether a sandbox provider is configured for this tenant.")
-    }),
-    skill: z14.object({
-      enabled: z14.boolean().describe("Whether skills are available. False when sandbox is not enabled (skills require a sandbox)."),
-      reason: z14.string().optional().describe("Present when skills are disabled. Explains why.")
-    }),
-    settings: z14.object({
-      enabled: z14.boolean().describe("Whether the settings UI/API is enabled.")
-    })
-  })
+import { createRoute as createRoute4, z as z16 } from "@hono/zod-openapi";
+var SandboxCapabilitySchema = z16.object({
+  enabled: z16.boolean().describe("Whether a sandbox provider is configured for this tenant.")
+}).openapi("SandboxCapability");
+var SkillCapabilitySchema = z16.object({
+  enabled: z16.boolean().describe("Whether skills are available. False when sandbox is not enabled (skills require a sandbox)."),
+  reason: z16.string().optional().describe("Present when skills are disabled. Explains why.")
+}).openapi("SkillCapability");
+var SettingsCapabilitySchema = z16.object({
+  enabled: z16.boolean().describe("Whether the settings UI/API is enabled.")
+}).openapi("SettingsCapability");
+var CapabilitiesDataSchema = z16.object({
+  sandbox: SandboxCapabilitySchema,
+  skill: SkillCapabilitySchema,
+  settings: SettingsCapabilitySchema
+}).openapi("CapabilitiesData");
+var GetCapabilitiesResponseSchema = z16.object({
+  data: CapabilitiesDataSchema
 }).openapi("GetCapabilitiesResponse");
 var getCapabilitiesRoute = createRoute4({
   method: "get",
   path: "/",
-  tags: ["Capabilities"],
+  tags: ["Capabilities" /* CAPABILITIES */],
   summary: "Get server capabilities",
   "x-fern-sdk-group-name": ["server"],
   "x-fern-sdk-method-name": "get_capabilities",
@@ -6446,7 +8093,7 @@ function createCapabilitiesRouter(deps) {
     } catch (error) {
       deps.logger.warn("Sandbox image status check failed; reporting sandbox disabled", extractErrorLogFields3(error));
     }
-    const sandboxEnabled = status === "ready";
+    const sandboxEnabled = status === "ready" || status === void 0 && isLocalSandboxFallbackEnabled();
     const settingsEnabled = isAdmin(resolveUserContext(c));
     return c.json(
       {
@@ -6470,42 +8117,42 @@ import { SUPPORTED_REASONING_EFFORTS as SUPPORTED_REASONING_EFFORTS2 } from "@tr
 import { createRoute as createRoute5 } from "@hono/zod-openapi";
 
 // src/schemas/mcpCatalog.ts
-import { z as z15 } from "@hono/zod-openapi";
-var CatalogMcpServerSchema = z15.object({
+import { z as z17 } from "@hono/zod-openapi";
+var CatalogMcpServerSchema = z17.object({
   type: McpServerTypeSchema,
   name: NameSchema,
-  logo: z15.url().optional().describe("URL of the MCP server logo asset."),
-  url: z15.url().describe("URL of the remote MCP server."),
+  logo: z17.url().optional().describe("URL of the MCP server logo asset."),
+  url: z17.url().describe("URL of the remote MCP server."),
   description: McpServerDescriptionSchema,
   auth: McpServerManifestAuthSchema.optional()
-}).strict().openapi("CatalogMcpServer");
-var McpCatalogFileSchema = z15.object({
-  mcp_servers: z15.array(CatalogMcpServerSchema)
+}).strict().openapi("CatalogMCPServer");
+var McpCatalogFileSchema = z17.object({
+  mcp_servers: z17.array(CatalogMcpServerSchema)
 }).strict().superRefine((file, ctx) => {
   uniqueNames(file.mcp_servers, ctx);
 });
-var GetMcpServerCatalogResponseSchema = z15.object({
-  data: z15.array(CatalogMcpServerSchema)
-}).openapi("GetMcpServerCatalogResponse");
+var GetMcpServerCatalogResponseSchema = z17.object({
+  data: z17.array(CatalogMcpServerSchema)
+}).openapi("GetMCPServerCatalogResponse");
 
 // src/schemas/modelCatalog.ts
-import { z as z17 } from "@hono/zod-openapi";
+import { z as z19 } from "@hono/zod-openapi";
 
 // src/schemas/modelProvider.ts
-import { z as z16 } from "@hono/zod-openapi";
+import { z as z18 } from "@hono/zod-openapi";
 import { SUPPORTED_REASONING_EFFORTS, VERCEL_AI_PROVIDER_NAMES } from "@truefoundry/trueforge-core/core";
-var ModelProviderTypeSchema = z16.enum(VERCEL_AI_PROVIDER_NAMES).openapi("ModelProviderType");
-var ReasoningEffortSchema = z16.enum(SUPPORTED_REASONING_EFFORTS).openapi("ReasoningEffort");
-var ModelPropertiesSchema = z16.object({
-  context_length: z16.number().int().positive().optional().describe("Maximum context window size in tokens."),
-  max_output_tokens: z16.number().int().positive().optional().describe("Maximum output tokens the model can generate."),
-  reasoning_efforts: z16.array(ReasoningEffortSchema).min(1).optional().describe("Supported reasoning-effort values for this model.")
+var ModelProviderTypeSchema = z18.enum(VERCEL_AI_PROVIDER_NAMES).openapi("ModelProviderType");
+var ReasoningEffortSchema = z18.enum(SUPPORTED_REASONING_EFFORTS).openapi("ReasoningEffort");
+var ModelPropertiesSchema = z18.object({
+  context_length: z18.number().int().positive().optional().describe("Maximum context window size in tokens."),
+  max_output_tokens: z18.number().int().positive().optional().describe("Maximum output tokens the model can generate."),
+  reasoning_efforts: z18.array(ReasoningEffortSchema).min(1).optional().describe("Supported reasoning-effort values for this model.")
 }).strict().describe("Optional model capability metadata.").openapi("ModelProperties");
-var ModelEntrySchema = z16.object({
-  model_id: z16.string().min(1).describe("Upstream, provider-specific identifier sent to the provider API."),
+var ConfiguredModelSchema = z18.object({
+  model_id: z18.string().min(1).describe("Upstream, provider-specific identifier sent to the provider API."),
   name: NameSchema,
   properties: ModelPropertiesSchema
-}).strict().openapi("ModelEntry");
+}).strict().openapi("ConfiguredModel");
 function refineUniqueModels(models, ctx) {
   uniqueNames(models, ctx);
   const seenModelIds = /* @__PURE__ */ new Set();
@@ -6520,22 +8167,22 @@ function refineUniqueModels(models, ctx) {
     seenModelIds.add(model.model_id);
   }
 }
-var ModelProviderAuthSchema = z16.object({
-  api_key: z16.string().min(1).describe(
+var ModelProviderAuthSchema = z18.object({
+  api_key: z18.string().min(1).describe(
     "Provider API key. Responses are redacted; on PUT, a real value sets/rotates and a redacted value keeps the stored key."
   )
 }).strict().describe("Provider authentication credentials.").openapi("ModelProviderAuth");
-var ModelProviderManifestBaseSchema = z16.object({
+var ModelProviderManifestBaseSchema = z18.object({
   auth: ModelProviderAuthSchema,
-  models: z16.array(ModelEntrySchema).min(1).describe("Models exposed by this provider (at least one).")
+  models: z18.array(ConfiguredModelSchema).min(1).describe("Models exposed by this provider (at least one).")
 }).strict();
 function wellKnownProviderSchema({
   type,
   base_url
 }) {
   return ModelProviderManifestBaseSchema.extend({
-    type: z16.literal(type),
-    base_url: z16.url().default(base_url).describe("Override of the provider's default API base URL.")
+    type: z18.literal(type),
+    base_url: z18.url().default(base_url).describe("Override of the provider's default API base URL.")
   }).strict();
 }
 var OpenAiModelProviderSchema = wellKnownProviderSchema({
@@ -6571,15 +8218,15 @@ var AlibabaModelProviderSchema = wellKnownProviderSchema({
   base_url: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
 }).openapi("AlibabaModelProvider");
 var CustomModelProviderSchema = ModelProviderManifestBaseSchema.extend({
-  type: z16.literal("custom"),
+  type: z18.literal("custom"),
   name: NameSchema,
-  base_url: z16.url().describe("Base URL of the provider's API."),
+  base_url: z18.url().describe("Base URL of the provider's API."),
   auth: ModelProviderAuthSchema.optional()
 }).strict().openapi("CustomModelProvider");
 function refineModelProviderManifest(manifest, ctx) {
   refineUniqueModels(manifest.models, ctx);
 }
-var ModelProviderBodySchema = z16.discriminatedUnion("type", [
+var ModelProviderBodySchema = z18.discriminatedUnion("type", [
   OpenAiModelProviderSchema,
   AnthropicModelProviderSchema,
   GoogleGeminiModelProviderSchema,
@@ -6594,87 +8241,87 @@ var ModelProviderManifestSchema = ModelProviderBodySchema.openapi("ModelProvider
 function modelProviderName(provider) {
   return provider.type === "custom" ? provider.name : provider.type;
 }
-var ModelProviderSchema = z16.object({
+var ConfiguredModelProviderSchema = z18.object({
   name: NameSchema,
   manifest: ModelProviderManifestSchema
-}).strict().openapi("ModelProvider");
-var CreateModelProviderRequestSchema = z16.object({
+}).strict().openapi("ConfiguredModelProvider");
+var CreateModelProviderRequestSchema = z18.object({
   manifest: ModelProviderManifestSchema
 }).strict().openapi("CreateModelProviderRequest");
-var PutModelProviderRequestSchema = z16.object({
+var UpdateModelProviderRequestSchema = z18.object({
   manifest: ModelProviderManifestSchema
-}).strict().openapi("PutModelProviderRequest");
-var GetModelProviderResponseSchema = z16.object({
-  data: ModelProviderSchema
+}).strict().openapi("UpdateModelProviderRequest");
+var GetModelProviderResponseSchema = z18.object({
+  data: ConfiguredModelProviderSchema
 }).openapi("GetModelProviderResponse");
-var ListModelProvidersResponseSchema = z16.object({
-  data: z16.array(ModelProviderSchema)
+var ListModelProvidersResponseSchema = z18.object({
+  data: z18.array(ConfiguredModelProviderSchema)
 }).openapi("ListModelProvidersResponse");
-var ModelListProviderSchema = z16.object({
-  name: z16.string().min(1).describe("Configured provider resource name; matches the FQN prefix of `name`.")
-}).strict().describe("Owning configured provider.").openapi("ModelListProvider");
-var ModelSchema = z16.object({
-  name: z16.string().describe('Fully qualified name `provider_name/model_name`, e.g. "openai/gpt-5-6-sol". Unique within a tenant.'),
-  model_id: z16.string().describe("Upstream, provider-specific identifier sent to the provider API."),
-  provider: ModelListProviderSchema,
+var AvailableModelProviderSchema = z18.object({
+  name: z18.string().min(1).describe("Configured provider resource name; matches the FQN prefix of `name`.")
+}).strict().describe("Owning configured provider.").openapi("AvailableModelProvider");
+var AvailableModelSchema = z18.object({
+  name: z18.string().describe('Fully qualified name `provider_name/model_name`, e.g. "openai/gpt-5-6-sol". Unique within a tenant.'),
+  model_id: z18.string().describe("Upstream, provider-specific identifier sent to the provider API."),
+  provider: AvailableModelProviderSchema,
   properties: ModelPropertiesSchema
-}).strict().openapi("Model");
-var ListModelsResponseSchema = z16.object({
-  data: z16.array(ModelSchema)
-}).openapi("ListModelsResponse");
+}).strict().openapi("AvailableModel");
+var ListAvailableModelsResponseSchema = z18.object({
+  data: z18.array(AvailableModelSchema)
+}).openapi("ListAvailableModelsResponse");
 
 // src/schemas/modelCatalog.ts
 var CatalogWellKnownModelProviderTypeSchema = ModelProviderTypeSchema.exclude(["custom"]).openapi(
   "CatalogWellKnownModelProviderType"
 );
-var CatalogWellKnownModelProviderSchema = z17.object({
+var CatalogModelSchema = ConfiguredModelSchema.openapi("CatalogModel");
+var CatalogWellKnownModelProviderSchema = z19.object({
   type: CatalogWellKnownModelProviderTypeSchema,
-  logo: z17.url().optional().describe("URL of the provider logo asset"),
-  models: z17.array(ModelEntrySchema).describe("Preset models")
+  logo: z19.url().optional().describe("URL of the provider logo asset"),
+  models: z19.array(CatalogModelSchema).describe("Preset models")
 }).strict().openapi("CatalogWellKnownModelProvider");
-var CatalogCustomModelProviderSchema = z17.object({
-  type: z17.literal("custom"),
-  supported_reasoning_efforts: z17.array(ReasoningEffortSchema).describe("Supported reasoning-effort values for this provider")
+var CatalogCustomModelProviderSchema = z19.object({
+  type: z19.literal("custom"),
+  supported_reasoning_efforts: z19.array(ReasoningEffortSchema).describe("Supported reasoning-effort values for this provider")
 }).strict().openapi("CatalogCustomModelProvider");
-var CatalogModelProviderSchema = z17.union([CatalogWellKnownModelProviderSchema, CatalogCustomModelProviderSchema]).openapi("CatalogModelProvider");
-var ModelCatalogFileSchema = z17.object({
-  providers: z17.array(CatalogWellKnownModelProviderSchema)
+var CatalogModelProviderSchema = z19.union([CatalogWellKnownModelProviderSchema, CatalogCustomModelProviderSchema]).openapi("CatalogModelProvider");
+var ModelCatalogFileSchema = z19.object({
+  providers: z19.array(CatalogWellKnownModelProviderSchema)
 }).strict().superRefine((file, ctx) => {
   uniqueTypes(file.providers, ctx);
   for (const provider of file.providers) {
     refineUniqueModels(provider.models, ctx);
   }
 });
-var GetModelProviderCatalogResponseSchema = z17.object({
-  data: z17.array(CatalogModelProviderSchema)
+var GetModelProviderCatalogResponseSchema = z19.object({
+  data: z19.array(CatalogModelProviderSchema)
 }).openapi("GetModelProviderCatalogResponse");
 
 // src/schemas/sandboxCatalog.ts
-import { z as z18 } from "@hono/zod-openapi";
-var CatalogDaytonaSandboxProviderSchema = DaytonaSandboxProviderSchema.omit({ auth: true }).strict().openapi("CatalogDaytonaSandboxProvider");
-var CatalogSandboxProviderSchema = CatalogDaytonaSandboxProviderSchema;
-var SandboxCatalogFileSchema = z18.object({
-  providers: z18.array(CatalogSandboxProviderSchema)
+import { z as z20 } from "@hono/zod-openapi";
+var CatalogSandboxProviderSchema = DaytonaSandboxProviderSchema.omit({ auth: true }).strict().openapi("CatalogSandboxProvider");
+var SandboxCatalogFileSchema = z20.object({
+  providers: z20.array(CatalogSandboxProviderSchema)
 }).strict();
-var GetSandboxProviderCatalogResponseSchema = z18.object({
-  data: z18.array(CatalogSandboxProviderSchema)
+var GetSandboxProviderCatalogResponseSchema = z20.object({
+  data: z20.array(CatalogSandboxProviderSchema)
 }).openapi("GetSandboxProviderCatalogResponse");
 
 // src/schemas/skillCatalog.ts
-import { z as z20 } from "@hono/zod-openapi";
+import { z as z22 } from "@hono/zod-openapi";
 
 // src/schemas/skill.ts
-import { z as z19 } from "@hono/zod-openapi";
-var SkillTypeSchema = z19.enum(["git"]).openapi("SkillType");
+import { z as z21 } from "@hono/zod-openapi";
+var SkillTypeSchema = z21.enum(["git"]).openapi("SkillType");
 var GIT_URL_REGEX = /^https:\/\/(github\.com\/[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+|gitlab\.com\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)+)(\/|\.git)?$/;
 var GIT_REF_REGEX = /^[A-Za-z0-9._\-/]+$/;
 var SKILL_PATH_REGEX = /^[A-Za-z0-9._\-/]+$/;
 var hasParentTraversal = (value) => value.split("/").includes("..");
-var SkillGitUrlSchema = z19.string().trim().min(1).regex(GIT_URL_REGEX, "Must be a GitHub or GitLab HTTPS URL").refine((v) => !hasParentTraversal(v), 'URL must not contain ".." segments').describe("Full HTTPS URL of a GitHub or GitLab repository.");
-var SkillGitPathSchema = z19.string().trim().min(1).regex(SKILL_PATH_REGEX, 'Path may only contain letters, numbers, ".", "_", "-", and "/"').refine((v) => !hasParentTraversal(v), 'Path must not contain ".." segments').refine((v) => !v.split("/").includes("."), 'Path must not contain "." segments').refine((v) => v.replace(/^\/+|\/+$/g, "").length > 0, "Path must reference a subdirectory, not only slashes").describe("Path to the skill directory within the repository. Omit to use the repository root.");
-var SkillGitRefSchema = z19.string().trim().min(1).regex(GIT_REF_REGEX, 'Ref may only contain letters, numbers, ".", "_", "-", and "/"').refine((v) => !hasParentTraversal(v), 'Ref must not contain ".." segments').refine((v) => v.replace(/^\/+|\/+$/g, "").length > 0, "Ref must not consist only of slashes").describe("Git ref \u2014 branch name, tag, or commit SHA.");
-var SkillDescriptionSchema = z19.string().trim().min(1).describe("Concise guidance for when the agent should use the skill.");
-var SkillManifestObjectSchema = z19.object({
+var SkillGitUrlSchema = z21.string().trim().min(1).regex(GIT_URL_REGEX, "Must be a GitHub or GitLab HTTPS URL").refine((v) => !hasParentTraversal(v), 'URL must not contain ".." segments').describe("Full HTTPS URL of a GitHub or GitLab repository.");
+var SkillGitPathSchema = z21.string().trim().min(1).regex(SKILL_PATH_REGEX, 'Path may only contain letters, numbers, ".", "_", "-", and "/"').refine((v) => !hasParentTraversal(v), 'Path must not contain ".." segments').refine((v) => !v.split("/").includes("."), 'Path must not contain "." segments').refine((v) => v.replace(/^\/+|\/+$/g, "").length > 0, "Path must reference a subdirectory, not only slashes").describe("Path to the skill directory within the repository. Omit to use the repository root.");
+var SkillGitRefSchema = z21.string().trim().min(1).regex(GIT_REF_REGEX, 'Ref may only contain letters, numbers, ".", "_", "-", and "/"').refine((v) => !hasParentTraversal(v), 'Ref must not contain ".." segments').refine((v) => v.replace(/^\/+|\/+$/g, "").length > 0, "Ref must not consist only of slashes").describe("Git ref \u2014 branch name, tag, or commit SHA.");
+var SkillDescriptionSchema = z21.string().trim().min(1).describe("Concise guidance for when the agent should use the skill.");
+var SkillManifestObjectSchema = z21.object({
   type: SkillTypeSchema,
   name: NameSchema,
   url: SkillGitUrlSchema,
@@ -6683,26 +8330,26 @@ var SkillManifestObjectSchema = z19.object({
   description: SkillDescriptionSchema
 }).strict();
 var SkillManifestSchema = SkillManifestObjectSchema.openapi("SkillManifest");
-var ConfiguredSkillSchema = z19.object({
+var ConfiguredSkillSchema = z21.object({
   name: NameSchema,
   manifest: SkillManifestSchema
 }).strict().openapi("ConfiguredSkill");
-var CreateSkillRequestSchema = z19.object({
+var CreateSkillRequestSchema = z21.object({
   manifest: SkillManifestSchema
 }).strict().openapi("CreateSkillRequest");
-var PutSkillRequestSchema = z19.object({
+var UpdateSkillRequestSchema = z21.object({
   manifest: SkillManifestSchema
-}).strict().openapi("PutSkillRequest");
-var GetSkillResponseSchema = z19.object({ data: ConfiguredSkillSchema }).openapi("GetSkillResponse");
-var ListSkillsResponseSchema = z19.object({ data: z19.array(ConfiguredSkillSchema) }).openapi("ListSkillsResponse");
-var SkillReadEntrySchema = z19.object({
+}).strict().openapi("UpdateSkillRequest");
+var GetSkillResponseSchema = z21.object({ data: ConfiguredSkillSchema }).openapi("GetSkillResponse");
+var ListSkillsResponseSchema = z21.object({ data: z21.array(ConfiguredSkillSchema) }).openapi("ListSkillsResponse");
+var AvailableSkillSchema = z21.object({
   name: NameSchema,
   description: SkillDescriptionSchema
-}).strict().openapi("SkillReadEntry");
-var ListAvailableSkillsResponseSchema = z19.object({ data: z19.array(SkillReadEntrySchema) }).openapi("ListAvailableSkillsResponse");
+}).strict().openapi("AvailableSkill");
+var ListAvailableSkillsResponseSchema = z21.object({ data: z21.array(AvailableSkillSchema) }).openapi("ListAvailableSkillsResponse");
 
 // src/schemas/skillCatalog.ts
-var CatalogSkillSchema = z20.object({
+var CatalogSkillSchema = z22.object({
   type: SkillTypeSchema,
   name: NameSchema,
   url: SkillGitUrlSchema,
@@ -6710,24 +8357,23 @@ var CatalogSkillSchema = z20.object({
   ref: SkillGitRefSchema,
   description: SkillDescriptionSchema
 }).strict().openapi("CatalogSkill");
-var SkillCatalogFileSchema = z20.object({
-  skills: z20.array(CatalogSkillSchema)
+var SkillCatalogFileSchema = z22.object({
+  skills: z22.array(CatalogSkillSchema)
 }).strict().superRefine((file, ctx) => {
   uniqueNames(file.skills, ctx);
 });
-var GetSkillCatalogResponseSchema = z20.object({
-  data: z20.array(CatalogSkillSchema)
+var GetSkillCatalogResponseSchema = z22.object({
+  data: z22.array(CatalogSkillSchema)
 }).openapi("GetSkillCatalogResponse");
 
 // src/routes/catalogRoutes.ts
-var CATALOG_TAG = "Catalog";
 var listModelProviderCatalogRoute = createRoute5({
   method: "get",
   path: "/model-providers",
-  tags: [CATALOG_TAG],
+  tags: ["Models" /* MODELS */],
   summary: "Get the model catalog",
   description: "Shipped model-provider presets (discovery-only). Copy into PUT /settings/model-providers to configure. Includes a `custom` sentinel with `supported_reasoning_efforts`.",
-  "x-fern-sdk-group-name": ["catalog", "modelProviders"],
+  "x-fern-sdk-group-name": ["catalogs", "modelProviders"],
   "x-fern-sdk-method-name": "list",
   responses: {
     200: {
@@ -6743,10 +8389,10 @@ var listModelProviderCatalogRoute = createRoute5({
 var listMcpServerCatalogRoute = createRoute5({
   method: "get",
   path: "/mcp-servers",
-  tags: [CATALOG_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Get the MCP catalog",
   description: "Shipped MCP server presets (discovery-only). Copy into PUT /settings/mcp-servers to configure.",
-  "x-fern-sdk-group-name": ["catalog", "mcpServers"],
+  "x-fern-sdk-group-name": ["catalogs", "mcpServers"],
   "x-fern-sdk-method-name": "list",
   responses: {
     200: {
@@ -6762,10 +8408,10 @@ var listMcpServerCatalogRoute = createRoute5({
 var listSkillCatalogRoute = createRoute5({
   method: "get",
   path: "/skills",
-  tags: [CATALOG_TAG],
+  tags: ["Skills" /* SKILLS */],
   summary: "Get the skill catalog",
   description: "Shipped skill presets (discovery-only). Copy into PUT /settings/skills to configure.",
-  "x-fern-sdk-group-name": ["catalog", "skills"],
+  "x-fern-sdk-group-name": ["catalogs", "skills"],
   "x-fern-sdk-method-name": "list",
   responses: {
     200: {
@@ -6781,10 +8427,10 @@ var listSkillCatalogRoute = createRoute5({
 var listSandboxProviderCatalogRoute = createRoute5({
   method: "get",
   path: "/sandbox-providers",
-  tags: [CATALOG_TAG],
+  tags: ["Sandboxes" /* SANDBOXES */],
   summary: "Get the sandbox provider catalog",
   description: "Shipped sandbox-provider presets (discovery-only). Copy into PUT /settings/sandbox-providers to configure.",
-  "x-fern-sdk-group-name": ["catalog", "sandboxProviders"],
+  "x-fern-sdk-group-name": ["catalogs", "sandboxProviders"],
   "x-fern-sdk-method-name": "list",
   responses: {
     200: {
@@ -6832,25 +8478,25 @@ import { extractErrorLogFields as extractErrorLogFields4, McpConnectionError as
 
 // src/routes/mcpOAuthRoutes.ts
 import { createRoute as createRoute6 } from "@hono/zod-openapi";
-var MCP_OAUTH_TAG = "MCP OAuth";
 var mcpOAuthCallbackRoute = createRoute6({
   method: "get",
   path: "/callback",
-  tags: [MCP_OAUTH_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "OAuth callback for MCP authorization",
-  description: "Browser redirect target for MCP server OAuth. The authorization server redirects here with `code`/`state` (or `error`). Exchanges the code for tokens, then either returns JSON or redirects to the `redirect_url` supplied at authorize time. Not called by the SDK \u2014 browsers hit this URL directly.",
+  description: "Browser redirect target for MCP server OAuth. The authorization server redirects here with `code`/`state` (or `error`). Exchanges the code for tokens, then either returns JSON or redirects to the `return_to` path supplied at authorize time. Not called by the SDK \u2014 browsers hit this URL directly.",
   // Browser-redirect target hit directly by the authorization server, never called by SDK.
   "x-fern-ignore": true,
+  "x-excluded": true,
   request: {
     query: OAuthCallbackQuerySchema
   },
   responses: {
     200: {
       content: { "application/json": { schema: OAuthCallbackSuccessSchema } },
-      description: "Token exchanged successfully and no `redirect_url` was given at authorize time."
+      description: "Token exchanged successfully and no `return_to` was given at authorize time."
     },
     302: {
-      description: "Redirect to the `redirect_url` given at authorize time, with `isSuccess` (and `reason` when it failed) appended to its existing query params."
+      description: "Redirect to the `return_to` path given at authorize time, with `isSuccess` (and `reason` when it failed) appended to its existing query params."
     },
     400: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
@@ -6864,25 +8510,28 @@ var mcpOAuthCallbackRoute = createRoute6({
 });
 
 // src/apis/mcpOAuth.ts
-function callbackLandingUrl(params) {
-  const url = new URL(params.redirectUrl);
+function callbackLandingPath(params) {
+  const url = new URL(params.returnTo, params.c.req.url);
   url.searchParams.set("isSuccess", String(params.isSuccess));
   if (params.reason) {
     url.searchParams.set("reason", params.reason);
   }
-  return url.href;
+  return `${url.pathname}${url.search}`;
 }
 function callbackSuccess(params) {
-  const redirectUrl = params.pending.redirectUrl;
-  if (redirectUrl) {
-    return params.c.redirect(callbackLandingUrl({ redirectUrl, isSuccess: true }), 302);
+  const returnTo = params.pending.returnTo;
+  if (returnTo) {
+    return params.c.redirect(callbackLandingPath({ c: params.c, returnTo, isSuccess: true }), 302);
   }
   return params.c.json({ success: true }, 200);
 }
 function callbackFailure(params) {
-  const redirectUrl = params.pending?.redirectUrl;
-  if (redirectUrl) {
-    return params.c.redirect(callbackLandingUrl({ redirectUrl, isSuccess: false, reason: params.message }), 302);
+  const returnTo = params.pending?.returnTo;
+  if (returnTo) {
+    return params.c.redirect(
+      callbackLandingPath({ c: params.c, returnTo, isSuccess: false, reason: params.message }),
+      302
+    );
   }
   return params.c.json({ error: { message: params.message } }, params.jsonStatus ?? 400);
 }
@@ -6924,18 +8573,17 @@ function createMcpOAuthRouter(deps) {
 }
 
 // src/apis/mcpServers.ts
-init_config();
-init_mcpServerStore();
 import { OpenAPIHono as OpenAPIHono7 } from "@hono/zod-openapi";
 import { extractErrorLogFields as extractErrorLogFields5, isAuthRequired, McpConnectionError as McpConnectionError4, RemoteMCP } from "@truefoundry/trueforge-core/core";
+init_config();
+init_mcpServerStore();
 
 // src/routes/mcpServerRoutes.ts
-import { createRoute as createRoute7, z as z21 } from "@hono/zod-openapi";
-var MCP_SERVERS_TAG = "MCP Servers";
+import { createRoute as createRoute7, z as z23 } from "@hono/zod-openapi";
 var listAvailableMcpServersRoute = createRoute7({
   method: "get",
   path: "/",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "List MCP servers for chat",
   description: "MCP servers as a slim name/url list for the composer. No auth or auth_status.",
   "x-fern-sdk-group-name": ["mcpServers"],
@@ -6954,7 +8602,7 @@ var listAvailableMcpServersRoute = createRoute7({
 var listMcpServersRoute = createRoute7({
   method: "get",
   path: "/",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "List MCP servers",
   description: "All MCP servers with nested auth_status (settings / admin projection). Header auth values are redacted.",
   "x-fern-sdk-group-name": ["settings", "mcpServers"],
@@ -6974,13 +8622,13 @@ var listMcpServersRoute = createRoute7({
     }
   }
 });
-var McpServerNameParamsSchema = z21.object({
-  name: z21.string().min(1).describe("MCP server name.")
+var McpServerNameParamsSchema = z23.object({
+  name: z23.string().min(1).describe("MCP server name.")
 });
 var getMcpServerRoute = createRoute7({
   method: "get",
   path: "/{name}",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Get a single MCP server by name",
   description: "A single MCP server by name, with nested auth_status (settings / admin projection). Header auth values are redacted.",
   "x-fern-sdk-group-name": ["settings", "mcpServers"],
@@ -7002,7 +8650,7 @@ var getMcpServerRoute = createRoute7({
 var createMcpServerRoute = createRoute7({
   method: "post",
   path: "/",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Create an MCP server",
   description: "Creates an MCP server by `name`. Fails if `name` is already taken. Runs DCR registration when `auth.type` is `dcr`. Header secrets: real value required; redacted with no stored value returns 400.",
   "x-fern-sdk-group-name": ["settings", "mcpServers"],
@@ -7035,14 +8683,14 @@ var createMcpServerRoute = createRoute7({
 var putMcpServerRoute = createRoute7({
   method: "put",
   path: "/",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Create or replace an MCP server",
   description: "Create or replace by `name`. Does not start DCR or change oauth client columns. Header secrets: real value sets/rotates; redacted keeps existing (400 if none).",
   "x-fern-sdk-group-name": ["settings", "mcpServers"],
-  "x-fern-sdk-method-name": "upsert",
+  "x-fern-sdk-method-name": "create_or_update",
   request: {
     body: {
-      content: { "application/json": { schema: PutMcpServerRequestSchema } },
+      content: { "application/json": { schema: UpdateMcpServerRequestSchema } },
       required: true
     }
   },
@@ -7061,16 +8709,16 @@ var putMcpServerRoute = createRoute7({
     }
   }
 });
-var ListMcpServerToolsResponseSchema = z21.object({
+var ListMcpServerToolsResponseSchema = z23.object({
   // TODO: Type tools/list entries to the MCP tool shape (name, description, inputSchema, …) for OpenAPI quality.
-  data: z21.array(z21.record(z21.string(), z21.unknown())).describe("MCP `tools/list` entries, passed through verbatim from the MCP server.")
-}).openapi("ListMcpServerToolsResponse");
+  data: z23.array(z23.record(z23.string(), z23.unknown())).describe("MCP `tools/list` entries, passed through verbatim from the MCP server.")
+}).openapi("ListMCPServerToolsResponse");
 var listMcpServerToolsRoute = createRoute7({
   method: "get",
   path: "/{name}/tools",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "List tools of an MCP server",
-  "x-fern-sdk-group-name": ["settings", "mcpServers"],
+  "x-fern-sdk-group-name": ["mcpServers"],
   "x-fern-sdk-method-name": "list_tools",
   description: "All tools exposed by the given MCP server (non-paginated), as returned by the MCP `tools/list` call.",
   request: {
@@ -7083,7 +8731,7 @@ var listMcpServerToolsRoute = createRoute7({
     },
     401: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
-      description: "Harness session login required."
+      description: "OIDC is configured and the request has no valid session cookie."
     },
     404: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
@@ -7099,17 +8747,19 @@ var listMcpServerToolsRoute = createRoute7({
     }
   }
 });
-var McpAuthorizeQuerySchema = z21.object({
-  redirect_url: z21.url().optional().describe("Optional FE landing URL the OAuth callback redirects to, with `isSuccess`/`reason` appended.")
+var McpAuthorizeQuerySchema = z23.object({
+  return_to: z23.string().optional().describe(
+    "Optional path to return to after OAuth. Must be a same-origin relative path; the OAuth callback redirects here with `isSuccess`/`reason` appended."
+  )
 });
 var authorizeMcpServerRoute = createRoute7({
   method: "get",
   path: "/{name}/authorize",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Start (or short-circuit) the auth flow for an MCP server",
   "x-fern-sdk-group-name": ["mcpServers"],
   "x-fern-sdk-method-name": "authorize",
-  description: "For servers without auth returns not_required, and for header credentials returns authenticated (no browser flow). For auth.type dcr, returns authenticated when a usable (or refreshable) token exists; otherwise runs DCR if needed and returns auth_required with an authorization URL. Optional redirect_url is where the OAuth callback then redirects the browser; without it the callback returns JSON.",
+  description: "For servers without auth returns not_required, and for header credentials returns authenticated (no browser flow). For auth.type dcr, returns authenticated when a usable (or refreshable) token exists; otherwise runs DCR if needed and returns auth_required with an authorization URL. Optional return_to is where the OAuth callback then redirects the browser; without it the callback returns JSON.",
   request: {
     params: McpServerNameParamsSchema,
     query: McpAuthorizeQuerySchema
@@ -7121,7 +8771,7 @@ var authorizeMcpServerRoute = createRoute7({
     },
     400: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
-      description: "Invalid redirect_url."
+      description: "Invalid return_to."
     },
     404: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
@@ -7141,13 +8791,13 @@ var authorizeMcpServerRoute = createRoute7({
     }
   }
 });
-var deleteAuthorizeMcpServerRoute = createRoute7({
+var deleteAuthorizationMcpServerRoute = createRoute7({
   method: "delete",
   path: "/{name}/authorize",
-  tags: [MCP_SERVERS_TAG],
+  tags: ["MCP Servers" /* MCP_SERVERS */],
   summary: "Disconnect OAuth for an MCP server",
   "x-fern-sdk-group-name": ["mcpServers"],
-  "x-fern-sdk-method-name": "delete_authorize",
+  "x-fern-sdk-method-name": "delete_authorization",
   description: "For auth.type dcr, deletes the stored OAuth token and returns the server with auth_status auth_required, keeping the dynamically registered OAuth client so the next authorize can reuse it. No-op for header or no-auth servers (returns the server unchanged).",
   request: {
     params: McpServerNameParamsSchema
@@ -7251,7 +8901,7 @@ function toConfiguredMcpServer({
     })
   };
 }
-function toMcpServerReadEntry({
+function toAvailableMcpServer({
   record,
   token
 }) {
@@ -7407,60 +9057,17 @@ function createSettingsMcpServersRouter(deps) {
       throw error;
     }
   };
-  const listToolsHandler = async (c) => {
-    const { name } = c.req.valid("param");
-    const userRef = deps.resolveUserContext(c).userRef;
-    const connection = await getMcpConnection({
-      tenant_id: TENANT_ID,
-      name,
-      store: deps.mcpServerStore,
-      tokenStore: deps.tokenStore,
-      clientName: config_default.MCP_DCR_OAUTH_CLIENT_NAME,
-      userRef
-    });
-    if (connection === void 0) {
-      return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
-    }
-    const remote = new RemoteMCP({
-      id: name,
-      name,
-      url: connection.url,
-      headers: connection.headers,
-      requestTimeoutMs: config_default.MCP_REQUEST_TIMEOUT_MS,
-      connectTimeoutMs: config_default.MCP_CONNECT_TIMEOUT_MS,
-      logger: deps.logger,
-      signal: c.req.raw.signal
-    });
-    try {
-      const response = await remote.listTools();
-      if (isAuthRequired(response)) {
-        return c.json({ error: { message: `MCP server "${name}" requires authentication` } }, 422);
-      }
-      const data = response.result.tools.map((tool) => omitUndefinedEntries({ ...tool }));
-      return c.json({ data }, 200);
-    } catch (error) {
-      if (error instanceof McpConnectionError4) {
-        deps.logger.warn(`MCP tools/list failed for "${name}"`, extractErrorLogFields5(error));
-        if (error.statusCode === 401) {
-          return c.json({ error: { message: error.message } }, 422);
-        }
-        return c.json({ error: { message: error.message } }, 502);
-      }
-      throw error;
-    }
-  };
   const router = new OpenAPIHono7();
   router.openapi(listMcpServersRoute, listHandler);
   router.openapi(createMcpServerRoute, createHandler);
   router.openapi(putMcpServerRoute, putHandler);
-  router.openapi(listMcpServerToolsRoute, listToolsHandler);
   router.openapi(getMcpServerRoute, getHandler);
   return router;
 }
 function createMcpServersRouter(deps) {
   const authorizeHandler = async (c) => {
     const { name } = c.req.valid("param");
-    const { redirect_url: redirectUrl } = c.req.valid("query");
+    const { return_to: returnTo } = c.req.valid("query");
     const userRef = deps.resolveUserContext(c).userRef;
     const record = await deps.mcpServerStore.getServer({ tenant_id: TENANT_ID, name });
     if (!record) {
@@ -7469,10 +9076,10 @@ function createMcpServersRouter(deps) {
     if (record.manifest.auth?.type !== "dcr") {
       return c.json(resolveMcpAuthStatus({ manifest: record.manifest }), 200);
     }
+    if (returnTo && safeReturnTo(returnTo) !== returnTo) {
+      return c.json({ error: { message: "Invalid return_to: must be a same-origin relative path" } }, 400);
+    }
     try {
-      if (redirectUrl) {
-        validateRedirectUris({ redirectUris: [redirectUrl] });
-      }
       const result = await resolveMcpAuth({
         tokenStore: deps.tokenStore,
         mcpServerStore: deps.mcpServerStore,
@@ -7481,7 +9088,7 @@ function createMcpServersRouter(deps) {
         mcpServerUrl: record.manifest.url,
         mcpServerName: record.name,
         clientName: config_default.MCP_DCR_OAUTH_CLIENT_NAME,
-        ...redirectUrl !== void 0 ? { redirectUrl } : {}
+        ...returnTo !== void 0 ? { returnTo } : {}
       });
       const authStatus = isMcpAuthRequired(result) ? { status: "auth_required", authorization_url: result.authUrl.href } : { status: "authenticated" };
       return c.json(authStatus, 200);
@@ -7503,7 +9110,49 @@ function createMcpServersRouter(deps) {
       return c.json({ error: { message: "Internal server error" } }, 500);
     }
   };
-  const deleteAuthorizeHandler = async (c) => {
+  const listToolsHandler = async (c) => {
+    const { name } = c.req.valid("param");
+    const userRef = deps.resolveUserContext(c).userRef;
+    const connection = await getMcpConnection({
+      tenant_id: TENANT_ID,
+      name,
+      store: deps.mcpServerStore,
+      tokenStore: deps.tokenStore,
+      clientName: config_default.MCP_DCR_OAUTH_CLIENT_NAME,
+      userRef
+    });
+    if (connection === void 0) {
+      return c.json({ error: { message: `MCP server not found: ${name}` } }, 404);
+    }
+    const remote = new RemoteMCP({
+      id: name,
+      name,
+      url: connection.url,
+      headers: connection.headers,
+      requestTimeoutMs: config_default.MCP_REQUEST_TIMEOUT_MS,
+      connectTimeoutMs: config_default.MCP_CONNECT_TIMEOUT_MS,
+      logger: deps.logger,
+      signal: c.req.raw.signal
+    });
+    try {
+      const response = await remote.listTools();
+      if (isAuthRequired(response)) {
+        return c.json({ error: { message: `MCP server "${name}" requires authentication` } }, 422);
+      }
+      const data = response.result.tools.map((tool) => omitUndefinedEntries({ ...tool }));
+      return c.json({ data }, 200);
+    } catch (error) {
+      if (error instanceof McpConnectionError4) {
+        deps.logger.warn(`MCP tools/list failed for "${name}"`, extractErrorLogFields5(error));
+        if (error.statusCode === 401) {
+          return c.json({ error: { message: error.message } }, 422);
+        }
+        return c.json({ error: { message: error.message } }, 502);
+      }
+      throw error;
+    }
+  };
+  const deleteAuthorizationHandler = async (c) => {
     const { name } = c.req.valid("param");
     const userRef = deps.resolveUserContext(c).userRef;
     const record = await deps.mcpServerStore.getServer({ tenant_id: TENANT_ID, name });
@@ -7523,13 +9172,14 @@ function createMcpServersRouter(deps) {
     const tokens = await deps.tokenStore.getTokens({ ids: dcrIds, userRef });
     return c.json(
       {
-        data: records.map((record) => toMcpServerReadEntry({ record, token: tokens.get(record.id) }))
+        data: records.map((record) => toAvailableMcpServer({ record, token: tokens.get(record.id) }))
       },
       200
     );
   });
+  router.openapi(listMcpServerToolsRoute, listToolsHandler);
   router.openapi(authorizeMcpServerRoute, authorizeHandler);
-  router.openapi(deleteAuthorizeMcpServerRoute, deleteAuthorizeHandler);
+  router.openapi(deleteAuthorizationMcpServerRoute, deleteAuthorizationHandler);
   return router;
 }
 
@@ -7538,18 +9188,18 @@ import { OpenAPIHono as OpenAPIHono8 } from "@hono/zod-openapi";
 
 // src/routes/modelRoutes.ts
 import { createRoute as createRoute8 } from "@hono/zod-openapi";
-var listModelsRoute = createRoute8({
+var listAvailableModelsRoute = createRoute8({
   method: "get",
   path: "/",
-  tags: ["Models"],
-  summary: "List models",
+  tags: ["Models" /* MODELS */],
+  summary: "List models for chat",
   "x-fern-sdk-group-name": ["models"],
   "x-fern-sdk-method-name": "list",
-  description: "Models across all configured model providers, addressed by fully qualified name `name/model_name`.",
+  description: "Configured models as a slim FQN list for the composer.",
   responses: {
     200: {
-      content: { "application/json": { schema: ListModelsResponseSchema } },
-      description: "All models of all configured providers."
+      content: { "application/json": { schema: ListAvailableModelsResponseSchema } },
+      description: "All configured models (chat projection)."
     },
     401: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
@@ -7562,7 +9212,7 @@ var listModelsRoute = createRoute8({
 function createModelsRouter(deps) {
   const router = new OpenAPIHono8();
   router.openapi(
-    listModelsRoute,
+    listAvailableModelsRoute,
     async (c) => c.json({ data: await deps.modelProviderStore.listModels(TENANT_ID) }, 200)
   );
   return router;
@@ -7577,11 +9227,10 @@ import { OpenAPIHono as OpenAPIHono9 } from "@hono/zod-openapi";
 
 // src/routes/modelProviderRoutes.ts
 import { createRoute as createRoute9 } from "@hono/zod-openapi";
-var MODEL_PROVIDERS_TAG = "Model Providers";
 var listModelProvidersRoute = createRoute9({
   method: "get",
   path: "/",
-  tags: [MODEL_PROVIDERS_TAG],
+  tags: ["Models" /* MODELS */],
   summary: "List configured model providers",
   description: "All configured providers with nested manifests.",
   "x-fern-sdk-group-name": ["settings", "modelProviders"],
@@ -7604,7 +9253,7 @@ var listModelProvidersRoute = createRoute9({
 var createModelProviderRoute = createRoute9({
   method: "post",
   path: "/",
-  tags: [MODEL_PROVIDERS_TAG],
+  tags: ["Models" /* MODELS */],
   summary: "Create a model provider",
   description: "Creates a provider (models included). Fails if `name` is already taken. Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value required; redacted with no stored secret returns 400.",
   "x-fern-sdk-group-name": ["settings", "modelProviders"],
@@ -7633,14 +9282,14 @@ var createModelProviderRoute = createRoute9({
 var putModelProviderRoute = createRoute9({
   method: "put",
   path: "/",
-  tags: [MODEL_PROVIDERS_TAG],
+  tags: ["Models" /* MODELS */],
   summary: "Create or replace a model provider",
   description: "Create or replace a provider (models included). Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value sets/rotates; redacted keeps existing (400 if none).",
   "x-fern-sdk-group-name": ["settings", "modelProviders"],
-  "x-fern-sdk-method-name": "upsert",
+  "x-fern-sdk-method-name": "create_or_update",
   request: {
     body: {
-      content: { "application/json": { schema: PutModelProviderRequestSchema } },
+      content: { "application/json": { schema: UpdateModelProviderRequestSchema } },
       required: true
     }
   },
@@ -7749,11 +9398,10 @@ import { withTimeout } from "@truefoundry/trueforge-core/core";
 
 // src/routes/sandboxProviderRoutes.ts
 import { createRoute as createRoute10 } from "@hono/zod-openapi";
-var SANDBOX_PROVIDERS_TAG = "Sandbox Providers";
 var getSandboxProviderRoute = createRoute10({
   method: "get",
   path: "/",
-  tags: [SANDBOX_PROVIDERS_TAG],
+  tags: ["Sandboxes" /* SANDBOXES */],
   summary: "Get the configured sandbox provider",
   description: "The single configured sandbox provider for this tenant. `auth.api_key` is redacted.",
   "x-fern-sdk-group-name": ["settings", "sandboxProviders"],
@@ -7772,14 +9420,14 @@ var getSandboxProviderRoute = createRoute10({
 var putSandboxProviderRoute = createRoute10({
   method: "put",
   path: "/",
-  tags: [SANDBOX_PROVIDERS_TAG],
+  tags: ["Sandboxes" /* SANDBOXES */],
   summary: "Create or replace the sandbox provider",
   description: "Upserts the single sandbox provider for this tenant: creates it or replaces its entire configuration. `auth.api_key`: real value sets/rotates; redacted keeps existing (400 if none).",
   "x-fern-sdk-group-name": ["settings", "sandboxProviders"],
-  "x-fern-sdk-method-name": "upsert",
+  "x-fern-sdk-method-name": "create_or_update",
   request: {
     body: {
-      content: { "application/json": { schema: PutSandboxProviderRequestSchema } },
+      content: { "application/json": { schema: UpdateSandboxProviderRequestSchema } },
       required: true
     }
   },
@@ -7892,11 +9540,10 @@ import { OpenAPIHono as OpenAPIHono11 } from "@hono/zod-openapi";
 
 // src/routes/skillRoutes.ts
 import { createRoute as createRoute11 } from "@hono/zod-openapi";
-var SKILLS_TAG = "Skills";
 var listAvailableSkillsRoute = createRoute11({
   method: "get",
   path: "/",
-  tags: [SKILLS_TAG],
+  tags: ["Skills" /* SKILLS */],
   summary: "List skills for chat",
   description: "Configured skills as a slim name/description list for the composer.",
   "x-fern-sdk-group-name": ["skills"],
@@ -7915,7 +9562,7 @@ var listAvailableSkillsRoute = createRoute11({
 var listConfiguredSkillsRoute = createRoute11({
   method: "get",
   path: "/",
-  tags: [SKILLS_TAG],
+  tags: ["Skills" /* SKILLS */],
   summary: "List configured skills",
   description: "All configured skills with nested manifests (settings / admin projection).",
   "x-fern-sdk-group-name": ["settings", "skills"],
@@ -7938,7 +9585,7 @@ var listConfiguredSkillsRoute = createRoute11({
 var createSkillRoute = createRoute11({
   method: "post",
   path: "/",
-  tags: [SKILLS_TAG],
+  tags: ["Skills" /* SKILLS */],
   summary: "Create a skill",
   description: "Creates a skill keyed by `name`. Fails if `name` is already taken.",
   "x-fern-sdk-group-name": ["settings", "skills"],
@@ -7967,14 +9614,14 @@ var createSkillRoute = createRoute11({
 var putSkillRoute = createRoute11({
   method: "put",
   path: "/",
-  tags: [SKILLS_TAG],
+  tags: ["Skills" /* SKILLS */],
   summary: "Create or replace a skill",
   description: "Full upsert keyed by `name`: creates the skill or replaces its entire manifest.",
   "x-fern-sdk-group-name": ["settings", "skills"],
-  "x-fern-sdk-method-name": "upsert",
+  "x-fern-sdk-method-name": "create_or_update",
   request: {
     body: {
-      content: { "application/json": { schema: PutSkillRequestSchema } },
+      content: { "application/json": { schema: UpdateSkillRequestSchema } },
       required: true
     }
   },
@@ -8102,27 +9749,27 @@ import {
 } from "@truefoundry/trueforge-core/agent-session";
 import {
   AgentHarnessError,
+  existingSandboxIdForProvider,
   extractErrorLogFields as extractErrorLogFields6,
   isAgentInputUserMessage,
   isFileContentPart,
   McpConnectionError as McpConnectionError5,
+  rawSandboxId,
   SandboxError as SandboxError2,
-  validateSandboxOwnedByTenant,
   VercelAILLM
 } from "@truefoundry/trueforge-core/core";
 import { HTTPException as HTTPException4 } from "hono/http-exception";
 import { streamSSE } from "hono/streaming";
 
 // src/routes/turnRoutes.ts
-import { createRoute as createRoute12, z as z22 } from "@hono/zod-openapi";
-var SESSIONS_TAG2 = "Sessions";
+import { createRoute as createRoute12, z as z24 } from "@hono/zod-openapi";
 var TurnIdParamsSchema = SessionIdParamsSchema.extend({
-  turn_id: z22.string().min(1).describe("Turn identifier.")
+  turn_id: z24.string().min(1).describe("Turn identifier.")
 });
 var listTurnsRoute = createRoute12({
   method: "get",
   path: "/{session_id}/turns",
-  tags: [SESSIONS_TAG2],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "List turns in a session",
   description: "List turns for a session (newest first by default), token-paginated. Only the session creator (`created_by`) may list turns.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -8154,7 +9801,7 @@ var listTurnsRoute = createRoute12({
 var getTurnRoute = createRoute12({
   method: "get",
   path: "/{session_id}/turns/{turn_id}",
-  tags: [SESSIONS_TAG2],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Get a turn",
   description: "Fetch a single turn by ID. Only the session creator (`created_by`) may fetch it.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -8179,8 +9826,8 @@ var getTurnRoute = createRoute12({
 });
 var downloadSandboxFileRoute = createRoute12({
   method: "get",
-  path: "/{session_id}/turns/{turn_id}/download",
-  tags: [SESSIONS_TAG2],
+  path: "/{session_id}/turns/{turn_id}/download-sandbox-file",
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Download a file from the turn sandbox",
   description: "Download a file from the sandbox this turn ran in. Paths come from the assistant's `sandbox_artifacts` block. Only the session creator (`created_by`) may download.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -8191,7 +9838,7 @@ var downloadSandboxFileRoute = createRoute12({
   },
   responses: {
     200: {
-      content: { "application/octet-stream": { schema: z22.string().openapi({ format: "binary" }) } },
+      content: { "application/octet-stream": { schema: z24.string().openapi({ format: "binary" }) } },
       description: "File contents."
     },
     400: {
@@ -8200,7 +9847,7 @@ var downloadSandboxFileRoute = createRoute12({
     },
     403: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
-      description: "Caller is not the session creator, or sandbox belongs to another tenant."
+      description: "Caller is not the session creator."
     },
     404: {
       content: { "application/json": { schema: RequestErrorResponseSchema } },
@@ -8227,7 +9874,7 @@ var downloadSandboxFileRoute = createRoute12({
 var listTurnEventsRoute = createRoute12({
   method: "get",
   path: "/{session_id}/turns/{turn_id}/events",
-  tags: [SESSIONS_TAG2],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "List turn events",
   description: "Paginated persisted events for a turn (insertion order by default). Only the session creator (`created_by`) may list events.",
   "x-fern-sdk-group-name": ["sessions"],
@@ -8259,7 +9906,7 @@ var listTurnEventsRoute = createRoute12({
 var createAndExecuteTurnRoute = createRoute12({
   method: "post",
   path: "/{session_id}/turns",
-  tags: [SESSIONS_TAG2],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Create and execute a turn in a session",
   description: `Create a turn within a session and execute it.
 Only the session creator (\`created_by\`) may create turns.
@@ -8323,7 +9970,7 @@ Use \`previous_turn_id\` to chain to the session's last turn (defaults to \`auto
 var subscribeTurnRoute = createRoute12({
   method: "get",
   path: "/{session_id}/turns/{turn_id}/subscribe",
-  tags: [SESSIONS_TAG2],
+  tags: ["Agent Sessions" /* AGENT_SESSIONS */],
   summary: "Subscribe to a running turn",
   description: "Subscribe to the live SSE stream for a turn. Only the session creator (`created_by`) may subscribe. Pass `after_sequence_number` to resume after a disconnect (exclusive \u2014 events after this sequence number are replayed).",
   "x-fern-sdk-group-name": ["sessions"],
@@ -8604,7 +10251,7 @@ var StreamGoneError = class extends Error {
 };
 
 // src/runtime/sandboxFilePath.ts
-import { SandboxError, validateNoPathTraversal } from "@truefoundry/trueforge-core/core";
+import { SandboxError, validateNoPathTraversal as validateNoPathTraversal3 } from "@truefoundry/trueforge-core/core";
 var SandboxInvalidPathError = class extends SandboxError {
   statusCode = 400;
   constructor({ path: path7, reason }) {
@@ -8630,7 +10277,7 @@ function validateSandboxFilePath(path7) {
       reason: `must not have a segment longer than ${String(MAX_SEGMENT_BYTES)} bytes`
     });
   }
-  validateNoPathTraversal(path7);
+  validateNoPathTraversal3(path7);
 }
 
 // src/apis/turns.ts
@@ -8667,7 +10314,8 @@ function createTurnResolver(deps) {
     modelProviderStore,
     logger,
     signal,
-    userRef
+    userRef,
+    sessionId
   } = deps;
   return new TurnResourceResolver({
     llm: async (name) => {
@@ -8707,14 +10355,19 @@ function createTurnResolver(deps) {
       const provider = await resolveSandboxProvider({
         tenant_id: TENANT_ID,
         store: sandboxProviderStore,
-        logger
+        logger,
+        sessionId
       });
       if (provider === void 0) {
         throw new HTTPException4(422, {
           message: "no sandbox provider configured \u2014 PUT /settings/sandbox-providers"
         });
       }
-      if (existingSandboxId === void 0) {
+      const carriedSandboxId = existingSandboxIdForProvider({
+        existingSandboxId,
+        currentProviderType: provider.type
+      });
+      if (carriedSandboxId === void 0 && provider.type !== "local") {
         const status = await checkSnapshotStatus({ store: sandboxProviderStore, tenant_id: TENANT_ID, logger });
         if (status?.status !== "ready") {
           throw new HTTPException4(422, {
@@ -8732,9 +10385,8 @@ function createTurnResolver(deps) {
         logger,
         gitSkills,
         fileDownloadEnabled: spec.config.sandbox.file_downloads,
-        existingSandboxId,
-        tracing,
-        tenantName: TENANT_ID
+        existingSandboxId: carriedSandboxId,
+        tracing
       });
     },
     agent: async (agentId) => {
@@ -8884,13 +10536,13 @@ function createTurnsRouter(deps) {
       const provider = await resolveSandboxProvider({
         tenant_id: TENANT_ID,
         store: deps.sandboxProviderStore,
-        logger: deps.logger
+        logger: deps.logger,
+        sessionId
       });
       if (provider === void 0) {
         return c.json({ error: { message: "No sandbox provider configured" } }, 412);
       }
-      validateSandboxOwnedByTenant(sandboxId, TENANT_ID);
-      const content = await provider.downloadFile({ sandboxId, path: path7 });
+      const content = await provider.downloadFile({ sandboxId: rawSandboxId(sandboxId), path: path7 });
       return c.body(toArrayBuffer(content), 200, {
         "Content-Type": "application/octet-stream",
         "Content-Length": String(content.byteLength),
@@ -8959,7 +10611,8 @@ function createTurnsRouter(deps) {
       modelProviderStore: deps.modelProviderStore,
       logger: deps.logger,
       signal: abortController.signal,
-      userRef: deps.resolveUserContext(c).userRef
+      userRef: deps.resolveUserContext(c).userRef,
+      sessionId
     });
     const title = session.record.last_turn_id ? void 0 : deriveSessionTitle(body.input);
     let turn;
@@ -9139,9 +10792,9 @@ function readPackageVersion() {
 var PACKAGE_VERSION = readPackageVersion();
 
 // src/zodErrorResponse.ts
-import { z as z23 } from "@hono/zod-openapi";
+import { z as z25 } from "@hono/zod-openapi";
 function zodErrorResponse(c, error) {
-  return c.json({ error: { message: z23.prettifyError(error) } }, 400);
+  return c.json({ error: { message: z25.prettifyError(error) } }, 400);
 }
 var zodValidationHook = (result, c) => {
   if (!result.success) {
@@ -9160,7 +10813,7 @@ function createRequestBodyLimitMiddleware(maxSize) {
 }
 function createAppErrorHandler(params) {
   return (error, c) => {
-    if (error instanceof z24.ZodError) {
+    if (error instanceof z26.ZodError) {
       return zodErrorResponse(c, error);
     }
     if (error instanceof HTTPException5) {
@@ -9182,7 +10835,8 @@ var openApiDocConfig = {
     title: "TrueForge API",
     description: "HTTP API for the TrueForge agent server (`/api/v1`). Interactive docs are served at `/api/v1/docs` (OpenAPI JSON at `/api/v1/openapi.json`).\n\n**Authentication:** Standalone deployments (no OIDC) accept requests without credentials \u2014 middleware stamps a local default user. When OIDC is configured, protected routes require a valid `id_token` cookie or `Authorization: Bearer` ID token. There is no built-in API-key scheme; pass custom headers only if your reverse proxy or IdP layer requires them.\n\nCovers DB-backed sessions, the agent registry, settings catalogs, and model/MCP/skill/sandbox providers.",
     version: PACKAGE_VERSION
-  }
+  },
+  tags: OPENAPI_DOCUMENT_TAGS
 };
 function registerOpenApiBearerAuth(app) {
   app.openAPIRegistry.registerComponent("securitySchemes", BEARER_AUTH_SCHEME, {
@@ -9243,7 +10897,7 @@ function createServerApp(deps) {
     )
   );
   app.route(
-    "/api/v1/catalog",
+    "/api/v1/catalogs",
     withAuth(
       createCatalogRouter({
         modelCatalog: deps.modelCatalog,
@@ -9613,7 +11267,7 @@ init_config();
 import { serveStatic } from "@hono/node-server/serve-static";
 import { every } from "hono/combine";
 import { compress } from "hono/compress";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path3 from "path";
 var SERVER_PATH_PREFIXES = ["/api", "/healthz"];
 var HASHED_ASSET_PREFIX = "/assets/";
@@ -9623,7 +11277,7 @@ function isServerPath(pathname) {
   return SERVER_PATH_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));
 }
 function mountFrontend(app, dir) {
-  if (!existsSync2(path3.join(dir, "index.html"))) {
+  if (!existsSync5(path3.join(dir, "index.html"))) {
     return false;
   }
   const serveFile = serveStatic({ root: dir, precompressed: true });
@@ -9756,9 +11410,9 @@ var ActiveTurnRegistry = class {
    */
   track(input) {
     const key = activeTurnKey(input.sessionId, input.turnId);
-    const { promise: waitUntilCompleted, resolve } = Promise.withResolvers();
+    const { promise: waitUntilCompleted, resolve: resolve3 } = Promise.withResolvers();
     const markCompleted = () => {
-      resolve(void 0);
+      resolve3(void 0);
     };
     const run = {
       abortController: input.abortController,
@@ -9948,7 +11602,7 @@ try {
 }
 async function createStandalonePersistence(options) {
   const { sqlitePath, logger } = options;
-  await mkdir(path6.dirname(sqlitePath), { recursive: true });
+  await mkdir5(path6.dirname(sqlitePath), { recursive: true });
   const [{ createSqliteDb: createSqliteDb2 }, { migrateSqliteToLatest: migrateSqliteToLatest2 }, sqliteStores] = await Promise.all([
     Promise.resolve().then(() => (init_client(), client_exports)),
     Promise.resolve().then(() => (init_migrateSqlite(), migrateSqlite_exports)),
@@ -10097,6 +11751,26 @@ try {
   });
   if (configuration2.STANDALONE) {
     printStandaloneStartupBanner({ version: PACKAGE_VERSION, color: shouldColorize() });
+    await prepareCodeModeSocketParent({ path: configuration2.CODE_MODE_SOCKET_PARENT, logger });
+    await ensureLocalSandboxRootParent(configuration2.LOCAL_SANDBOX_ROOT_PARENT);
+    const { LocalSandboxProvider: LocalSandboxProvider2 } = await Promise.resolve().then(() => (init_LocalSandboxProvider(), LocalSandboxProvider_exports));
+    const support = await LocalSandboxProvider2.isSupported({
+      codeModeSocketParentPath: configuration2.CODE_MODE_SOCKET_PARENT
+    });
+    setCachedLocalSandboxSupport(support);
+    if (support.supported) {
+      logger.info("Local sandbox fallback is available", {
+        platform: support.platform,
+        shell: support.shell,
+        python: support.python
+      });
+    } else {
+      logger.warn("Local sandbox fallback is unavailable", {
+        reason: support.reason,
+        ...support.platform === void 0 ? {} : { platform: support.platform },
+        ...support.attempts === void 0 ? {} : { attempts: support.attempts }
+      });
+    }
   } else {
     logger.info("TrueForge starting", { mode: "distributed" });
   }
@@ -10151,9 +11825,9 @@ try {
         logger.warn(`Drain timed out after ${String(configuration2.GRACEFUL_TIMEOUT_SECONDS)}s, exiting`);
         process.exit(1);
       }, configuration2.GRACEFUL_TIMEOUT_SECONDS * 1e3).unref();
-      const closed = new Promise((resolve) => {
+      const closed = new Promise((resolve3) => {
         server.close(() => {
-          resolve();
+          resolve3();
         });
       });
       await activeTurns.shutdownAndWait(CancellationReason4.Abandoned);
@@ -10165,6 +11839,11 @@ try {
       await redis?.close().catch((error) => {
         logger.warn("[Redis] Error closing client during shutdown", extractErrorLogFields9(error));
       });
+      if (configuration2.STANDALONE) {
+        await removeCodeModeSocketParent(configuration2.CODE_MODE_SOCKET_PARENT).catch((error) => {
+          logger.warn("Error removing Code Mode socket parent during shutdown", extractErrorLogFields9(error));
+        });
+      }
       await destroyDb();
       process.exit(0);
     };