@hachej/boring-agent 0.1.20 → 0.1.23

package/dist/server/index.js

@@ -1,14 +1,13 @@
 import {
   ErrorCode,
+  noopTelemetry,
+  safeCapture,
   validateTool
-} from "../chunk-W73RUHY3.js";
+} from "../chunk-6R7O6BHW.js";
 
 // src/server/sandbox/direct/createDirectSandbox.ts
 import { spawn } from "child_process";
 
-// src/server/sandbox/workspacePythonEnv.ts
-import { join } from "path";
-
 // src/server/config/env.ts
 function getEnv(name) {
   return process.env[name];
@@ -17,21 +16,72 @@ function getEnvSnapshot() {
   return { ...process.env };
 }
 
+// src/server/workspace/runtimeLayout.ts
+import { join, resolve } from "path";
+var BORING_AGENT_DIR = ".boring-agent";
+var BORING_AGENT_GITIGNORE_CONTENT = "*\n";
+var BORING_AGENT_RUNTIME_DIR_NAMES = [
+  "node",
+  "venv",
+  "sdk",
+  "skills",
+  "cache",
+  "tmp"
+];
+function getBoringAgentRuntimePaths(runtimeWorkspaceRoot) {
+  const workspaceRoot = resolve(runtimeWorkspaceRoot);
+  const agentDir = join(workspaceRoot, BORING_AGENT_DIR);
+  const node = join(agentDir, "node");
+  const venv = join(agentDir, "venv");
+  const sdk = join(agentDir, "sdk");
+  const uvHome = join(sdk, "uv");
+  const cache = join(agentDir, "cache");
+  return {
+    workspaceRoot,
+    agentDir,
+    node,
+    nodeModules: join(node, "node_modules"),
+    nodeBin: join(node, "node_modules", ".bin"),
+    venv,
+    venvBin: join(venv, "bin"),
+    venvPython: join(venv, "bin", "python"),
+    sdk,
+    uvHome,
+    uvBin: join(uvHome, "bin"),
+    skills: join(agentDir, "skills"),
+    cache,
+    nodeCache: join(cache, "npm"),
+    uvCache: join(cache, "uv"),
+    pipCache: join(cache, "pip"),
+    tmp: join(agentDir, "tmp")
+  };
+}
+function getBoringAgentPathEntries(paths) {
+  return [paths.nodeBin, paths.venvBin, paths.uvBin];
+}
+function getBoringAgentRuntimeEnv(paths, adapterCacheRoot = paths.cache) {
+  return {
+    BORING_AGENT_WORKSPACE_ROOT: paths.workspaceRoot,
+    VIRTUAL_ENV: paths.venv,
+    UV_CACHE_DIR: join(adapterCacheRoot, "uv"),
+    PIP_CACHE_DIR: join(adapterCacheRoot, "pip"),
+    npm_config_cache: join(adapterCacheRoot, "npm")
+  };
+}
+
 // src/server/sandbox/workspacePythonEnv.ts
 function withWorkspacePythonEnv(opts) {
   const { workspaceRoot, env, sandboxRoot } = opts;
   const runtimeRoot = sandboxRoot ?? workspaceRoot;
-  const venvRoot = join(runtimeRoot, ".venv");
-  const venvBin = join(venvRoot, "bin");
-  const shimBin = join(runtimeRoot, ".boring-agent", "bin");
+  const paths = getBoringAgentRuntimePaths(runtimeRoot);
   const baseEnv = env ?? getEnvSnapshot();
-  const pathParts = [shimBin, venvBin];
+  const pathParts = getBoringAgentPathEntries(paths);
   const existingPath = baseEnv.PATH;
   if (existingPath) pathParts.push(existingPath);
   return {
     ...baseEnv,
     PATH: pathParts.join(":"),
-    VIRTUAL_ENV: baseEnv.VIRTUAL_ENV ?? venvRoot,
+    VIRTUAL_ENV: baseEnv.VIRTUAL_ENV ?? paths.venv,
     BORING_AGENT_WORKSPACE_ROOT: baseEnv.BORING_AGENT_WORKSPACE_ROOT ?? runtimeRoot
   };
 }
@@ -92,7 +142,7 @@ function createDirectSandbox() {
       const maxOutputBytes = opts?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
       const workspaceRoot = workspace.root;
       const cwd = opts?.cwd ?? workspaceRoot;
-      return await new Promise((resolve7, reject) => {
+      return await new Promise((resolve9, reject) => {
         const child = spawn(cmd, {
           cwd,
           env: withWorkspacePythonEnv({ workspaceRoot, env: opts?.env }),
@@ -121,7 +171,7 @@ function createDirectSandbox() {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve7({
+          resolve9({
             stdout: new Uint8Array(Buffer.concat(stdoutChunks)),
             stderr: new Uint8Array(Buffer.concat(stderrChunks)),
             exitCode: typeof exitCode === "number" ? exitCode : timedOut ? 124 : 1,
@@ -183,7 +233,7 @@ function createDirectSandbox() {
 import { access } from "fs/promises";
 import { constants } from "fs";
 import { spawn as spawn2 } from "child_process";
-import { dirname, isAbsolute as isAbsolute2, join as join2, relative, resolve, sep } from "path";
+import { dirname, isAbsolute as isAbsolute2, join as join2, relative, resolve as resolve2, sep } from "path";
 
 // src/server/sandbox/bwrap/buildBwrapArgs.ts
 import { isAbsolute } from "path";
@@ -300,7 +350,7 @@ function terminateProcess2(child, signal) {
 }
 function computeSandboxCwd(workspaceRoot, cwd) {
   if (!cwd) return SANDBOX_HOME2;
-  const absoluteCwd = isAbsolute2(cwd) ? cwd : resolve(workspaceRoot, cwd);
+  const absoluteCwd = isAbsolute2(cwd) ? cwd : resolve2(workspaceRoot, cwd);
   const relPath = relative(workspaceRoot, absoluteCwd);
   if (relPath === "") return SANDBOX_HOME2;
   if (relPath === ".." || relPath.startsWith(`..${sep}`)) {
@@ -400,7 +450,7 @@ function createBwrapSandbox() {
         "-c",
         cmd
       ];
-      return await new Promise((resolve7, reject) => {
+      return await new Promise((resolve9, reject) => {
         const child = spawn2("bwrap", args, {
           env: withWorkspacePythonEnv({ workspaceRoot, env: opts?.env, sandboxRoot: SANDBOX_HOME2 }),
           stdio: ["ignore", "pipe", "pipe"],
@@ -427,7 +477,7 @@ function createBwrapSandbox() {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve7({
+          resolve9({
             stdout: new Uint8Array(Buffer.concat(stdoutChunks)),
             stderr: new Uint8Array(Buffer.concat(stderrChunks)),
             exitCode: typeof exitCode === "number" ? exitCode : timedOut ? 124 : 1,
@@ -1222,7 +1272,7 @@ import chokidar from "chokidar";
 
 // src/server/workspace/paths.ts
 import { lstat, realpath, stat } from "fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve2 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve3 } from "path";
 function createPathValidationError(reason, requestedPath, message) {
   return Object.assign(new Error(message), {
     statusCode: 400,
@@ -1255,15 +1305,15 @@ function validatePath(workspaceRoot, relPath) {
   if (hasTraversalSegment(normalized) || normalized.startsWith("~") || normalized.startsWith("$") || /[\r\n]/.test(normalized)) {
     throw createPathValidationError("path-escape", relPath, "Path escapes workspace root");
   }
-  const resolvedRoot = resolve2(workspaceRoot);
-  const resolvedPath = resolve2(workspaceRoot, relPath);
+  const resolvedRoot = resolve3(workspaceRoot);
+  const resolvedPath = resolve3(workspaceRoot, relPath);
   if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}/`)) {
     throw createPathValidationError("path-escape", relPath, "Path escapes workspace root");
   }
   return resolvedPath;
 }
 async function assertRealPathWithinWorkspace(workspaceRoot, absPath) {
-  const realRoot = await realpath(resolve2(workspaceRoot));
+  const realRoot = await realpath(resolve3(workspaceRoot));
   const realCandidate = await realpath(absPath);
   const rel = relative2(realRoot, realCandidate);
   if (rel.startsWith("..") || isAbsolute3(rel)) {
@@ -1810,8 +1860,8 @@ function fileRoutes(app, opts, done) {
           error: { code: ERROR_CODE_INTERNAL, message: "workspace does not support binary reads" }
         });
       }
-      const stat7 = await workspace.stat(path4);
-      if (stat7.kind !== "file") {
+      const stat10 = await workspace.stat(path4);
+      if (stat10.kind !== "file") {
         return reply.code(400).send({
           error: { code: ERROR_CODE_VALIDATION_ERROR, message: "path is not a file", field: "path" }
         });
@@ -1829,12 +1879,12 @@ function fileRoutes(app, opts, done) {
     try {
       const workspace = await resolveWorkspace(request);
       if (workspace.readFileWithStat) {
-        const { content: content2, stat: stat8 } = await workspace.readFileWithStat(path4);
-        return { content: content2, mtimeMs: stat8.kind === "file" ? stat8.mtimeMs : void 0 };
+        const { content: content2, stat: stat11 } = await workspace.readFileWithStat(path4);
+        return { content: content2, mtimeMs: stat11.kind === "file" ? stat11.mtimeMs : void 0 };
       }
       const content = await workspace.readFile(path4);
-      const stat7 = await workspace.stat(path4);
-      return { content, mtimeMs: stat7.kind === "file" ? stat7.mtimeMs : void 0 };
+      const stat10 = await workspace.stat(path4);
+      return { content, mtimeMs: stat10.kind === "file" ? stat10.mtimeMs : void 0 };
     } catch (err) {
       return classifyError(err, reply, "file");
     }
@@ -1883,11 +1933,11 @@ function fileRoutes(app, opts, done) {
         if (dir) await workspace.mkdir(dir, { recursive: true });
       }
       const content = body.content;
-      const stat7 = workspace.writeFileWithStat ? await workspace.writeFileWithStat(path4, content) : await (async () => {
+      const stat10 = workspace.writeFileWithStat ? await workspace.writeFileWithStat(path4, content) : await (async () => {
         await workspace.writeFile(path4, content);
         return await workspace.stat(path4);
       })();
-      return { ok: true, mtimeMs: stat7.kind === "file" ? stat7.mtimeMs : void 0 };
+      return { ok: true, mtimeMs: stat10.kind === "file" ? stat10.mtimeMs : void 0 };
     } catch (err) {
       return classifyError(err, reply, "file");
     }
@@ -1920,7 +1970,7 @@ function fileRoutes(app, opts, done) {
       }
       const bytes = Buffer.from(contentBase64, "base64");
       await workspace.mkdir(dir, { recursive: true });
-      const stat7 = workspace.writeBinaryFileWithStat ? await workspace.writeBinaryFileWithStat(path4, bytes) : await (async () => {
+      const stat10 = workspace.writeBinaryFileWithStat ? await workspace.writeBinaryFileWithStat(path4, bytes) : await (async () => {
         if (!workspace.writeBinaryFile) {
           throw new Error("workspace does not support binary uploads");
         }
@@ -1934,7 +1984,7 @@ function fileRoutes(app, opts, done) {
         ok: true,
         path: path4,
         markdownUrl: markdownUrlFor(sourcePath, path4),
-        mtimeMs: stat7.kind === "file" ? stat7.mtimeMs : void 0
+        mtimeMs: stat10.kind === "file" ? stat10.mtimeMs : void 0
       };
     } catch (err) {
       return classifyError(err, reply, "upload");
@@ -2021,8 +2071,8 @@ function fileRoutes(app, opts, done) {
     if (path4 === null) return;
     try {
       const workspace = await resolveWorkspace(request);
-      const stat7 = await workspace.stat(path4);
-      return stat7;
+      const stat10 = await workspace.stat(path4);
+      return stat10;
     } catch (err) {
       return classifyError(err, reply, "path");
     }
@@ -2034,7 +2084,7 @@ function fileRoutes(app, opts, done) {
 import { createHash as createHash3 } from "crypto";
 import { constants as constants2 } from "fs";
 import { access as access2, chmod as chmod3, cp, mkdir as mkdir4, readdir as readdir2, readFile as readFile4, realpath as realpath2, stat as stat3, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative5, resolve as resolve3 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative5, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -2143,8 +2193,8 @@ function resolveTemplateTarget(workspaceRoot, target) {
   if (rawTarget.length === 0 || rawTarget.includes("\0") || rawTarget.includes("\\") || rawTarget.startsWith("/") || rawTarget.startsWith("//") || /^[A-Za-z]:[\\/]/.test(rawTarget) || rawTarget.split("/").includes("..")) {
     throw new Error(`Unsafe runtime template target: ${JSON.stringify(rawTarget)}. Template targets must be relative paths inside the workspace.`);
   }
-  const root = resolve3(workspaceRoot);
-  const resolved = resolve3(root, rawTarget);
+  const root = resolve4(workspaceRoot);
+  const resolved = resolve4(root, rawTarget);
   const rel = relative5(root, resolved);
   if (rel.startsWith("..") || isAbsolute4(rel)) {
     throw new Error(`Unsafe runtime template target: ${JSON.stringify(rawTarget)} resolves outside the workspace.`);
@@ -2171,7 +2221,7 @@ function nodePackageTarget(workspaceRoot, packageName) {
 }
 async function copyIfExists(source, target) {
   if (!await exists(source)) return false;
-  if (resolve3(source) === resolve3(target)) return true;
+  if (resolve4(source) === resolve4(target)) return true;
   if (await exists(target) && await realpath2(source) === await realpath2(target)) return true;
   await cp(source, target, {
     recursive: true,
@@ -2205,11 +2255,11 @@ async function ensureNodePackages(workspaceRoot, specs) {
 }
 async function ensurePython(workspaceRoot, specs) {
   if (specs.length === 0) return;
-  const venvPython = join3(workspaceRoot, ".venv", "bin", "python");
+  const venvPython = join3(workspaceRoot, ".boring-agent", "venv", "bin", "python");
   const uv = await commandExists("uv");
   if (!await exists(venvPython)) {
-    if (uv) await run("uv", ["venv", ".venv"], workspaceRoot);
-    else await run("/usr/bin/python3", ["-m", "venv", ".venv"], workspaceRoot);
+    if (uv) await run("uv", ["venv", ".boring-agent/venv"], workspaceRoot);
+    else await run("/usr/bin/python3", ["-m", "venv", ".boring-agent/venv"], workspaceRoot);
   }
   for (const spec of specs) {
     const projectDir = dirname5(toPath(spec.projectFile));
@@ -2238,7 +2288,7 @@ function assertEnvKey(key) {
 }
 async function isRuntimeMaterialized(workspaceRoot, contributions) {
   const hasPython = contributions.some(({ provisioning }) => (provisioning.python ?? []).length > 0);
-  if (hasPython && !await exists(join3(workspaceRoot, ".venv", "bin", "python"))) return false;
+  if (hasPython && !await exists(join3(workspaceRoot, ".boring-agent", "venv", "bin", "python"))) return false;
   for (const { provisioning } of contributions) {
     for (const spec of provisioning.nodePackages ?? []) {
       if (!await exists(join3(nodePackageTarget(workspaceRoot, spec.packageName), "package.json"))) return false;
@@ -2248,7 +2298,7 @@ async function isRuntimeMaterialized(workspaceRoot, contributions) {
 }
 async function writeShims(workspaceRoot, env) {
   const shimDir = join3(workspaceRoot, ".boring-agent", "bin");
-  const venvBin = join3(workspaceRoot, ".venv", "bin");
+  const venvBin = join3(workspaceRoot, ".boring-agent", "venv", "bin");
   await mkdir4(shimDir, { recursive: true });
   const exports = Object.entries(env).map(([key, value]) => {
     assertEnvKey(key);
@@ -2260,7 +2310,7 @@ SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
 WORKSPACE_ROOT="$(CDPATH= cd -- "$SCRIPT_DIR/../.." && pwd)"
 export BORING_AGENT_WORKSPACE_ROOT="$WORKSPACE_ROOT"
 ${exports}
-VENV_BIN="$WORKSPACE_ROOT/.venv/bin"
+VENV_BIN="$WORKSPACE_ROOT/.boring-agent/venv/bin"
 `;
   await writeExecutable(join3(shimDir, "python"), `${base}exec "$VENV_BIN/python" "$@"
 `);
@@ -2359,11 +2409,11 @@ function createTimedLruCache(ttlMs, maxEntries) {
     }
   };
 }
-function cloneStat(stat7) {
+function cloneStat(stat10) {
   return {
-    size: stat7.size,
-    mtimeMs: stat7.mtimeMs,
-    kind: stat7.kind
+    size: stat10.size,
+    mtimeMs: stat10.mtimeMs,
+    kind: stat10.kind
   };
 }
 function cloneEntries(entries) {
@@ -2521,15 +2571,15 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
           remote.fs.readFile(sandboxPath, "utf8"),
           remote.fs.stat(sandboxPath)
         ]);
-        const stat7 = {
+        const stat10 = {
           size: fileStat.size,
           mtimeMs: fileStat.mtimeMs,
           kind: fileStat.isDirectory() ? "dir" : "file"
         };
-        statCache.set(sandboxPath, stat7);
+        statCache.set(sandboxPath, stat10);
         return {
           content: typeof content === "string" ? content : Buffer.from(content).toString("utf-8"),
-          stat: cloneStat(stat7)
+          stat: cloneStat(stat10)
         };
       }
       const version = metadataVersion;
@@ -2689,11 +2739,801 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
   };
 }
 
+// src/server/sandbox/vercel-sandbox/provisioningAdapter.ts
+import { mkdtemp } from "fs/promises";
+import { join as join4 } from "path";
+import { tmpdir } from "os";
+
+// src/server/workspace/provisioning/errors.ts
+var ProvisioningError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}, cause) {
+    super(message, { cause });
+    this.name = "ProvisioningError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function toProvisioningError(code, phase, error, details = {}) {
+  if (error instanceof ProvisioningError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new ProvisioningError(
+    code,
+    `Workspace provisioning failed during ${phase}: ${message}`,
+    { phase, ...details },
+    error
+  );
+}
+function logProvisioning(logger, level, message, fields = {}) {
+  logger?.[level]?.(message, fields);
+}
+
+// src/server/sandbox/vercel-sandbox/provisioningAdapter.ts
+var VERCEL_PROVISIONING_CACHE_ROOT = "/tmp/boring-agent-cache";
+function artifactExtension(kind) {
+  return kind === "node" ? ".tgz" : ".tar.gz";
+}
+function artifactName(kind, id, fingerprint2) {
+  const safeId = id.replace(/[^A-Za-z0-9._-]/g, "-");
+  const safeFingerprint = fingerprint2.replace(/^sha256:/, "");
+  return `${safeId}-${safeFingerprint}${artifactExtension(kind)}`;
+}
+function createVercelProvisioningAdapter(options) {
+  return {
+    mode: "vercel-sandbox",
+    async exec(command, args, opts) {
+      return await options.exec(command, args, {
+        cwd: opts?.cwd ?? options.runtimeLayout.workspaceRoot,
+        env: opts?.env,
+        timeoutMs: opts?.timeoutMs
+      });
+    },
+    async resolveInstallSource(source, opts) {
+      const name = artifactName(opts.kind, opts.id, opts.fingerprint);
+      const workspaceRel = `.boring-agent/tmp/${name}`;
+      const runtimePath = `${options.runtimeLayout.tmp}/${name}`;
+      if (!await options.workspaceFs.exists(workspaceRel)) {
+        const artifactDir = await mkdtemp(join4(tmpdir(), "boring-agent-vercel-artifact-"));
+        const outputPath = join4(artifactDir, name);
+        try {
+          await options.prepareArtifact({
+            kind: opts.kind,
+            id: opts.id,
+            fingerprint: opts.fingerprint,
+            source,
+            outputPath
+          });
+          await options.workspaceFs.copyFromHost(outputPath, workspaceRel);
+        } catch (error) {
+          throw toProvisioningError(
+            ErrorCode.enum.PROVISIONING_ARTIFACT_FAILED,
+            "adapter-artifact",
+            error,
+            { runtime: opts.kind, id: opts.id, artifact: workspaceRel }
+          );
+        }
+      }
+      return runtimePath;
+    },
+    workspaceFs: options.workspaceFs,
+    getRuntimeCacheRoot() {
+      return options.cacheRoot ?? VERCEL_PROVISIONING_CACHE_ROOT;
+    }
+  };
+}
+
+// src/server/workspace/provisioning/fingerprint.ts
+import { createHash as createHash4 } from "crypto";
+import { constants as constants3 } from "fs";
+import { access as access3, mkdir as mkdir5, open, readFile as readFile5, rename as rename4, rm } from "fs/promises";
+import { dirname as dirname6 } from "path";
+var FINGERPRINT_RE = /^sha256:[a-f0-9]{64}$/;
+function isValidFingerprint(value) {
+  return FINGERPRINT_RE.test(value.trim());
+}
+function normalizeSource(value) {
+  if (value === void 0) return void 0;
+  return String(value);
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function createRuntimeFingerprint(input) {
+  const hash = createHash4("sha256");
+  hash.update(stableStringify(input));
+  return `sha256:${hash.digest("hex")}`;
+}
+function createNodeRuntimeFingerprint(input) {
+  return createRuntimeFingerprint({
+    kind: "node",
+    nodeVersion: input.nodeVersion,
+    npmVersion: input.npmVersion,
+    packages: input.packages.map((pkg) => ({
+      id: pkg.id,
+      packageName: pkg.packageName,
+      packageRoot: normalizeSource(pkg.packageRoot),
+      version: pkg.version,
+      expectedBins: pkg.expectedBins ?? []
+    }))
+  });
+}
+function createPythonRuntimeFingerprint(input) {
+  return createRuntimeFingerprint({
+    kind: "python",
+    pythonVersion: input.pythonVersion,
+    uvVersion: input.uvVersion,
+    packages: input.packages.map((pkg) => ({
+      id: pkg.id,
+      projectFile: normalizeSource(pkg.projectFile),
+      packageName: pkg.packageName,
+      packageRoot: normalizeSource(pkg.packageRoot),
+      version: pkg.version,
+      extraLibs: pkg.extraLibs ?? [],
+      env: Object.fromEntries(
+        Object.entries(pkg.env ?? {}).map(([key, value]) => [key, normalizeSource(value)])
+      ),
+      expectedBins: pkg.expectedBins ?? []
+    }))
+  });
+}
+
+// src/server/workspace/provisioning/node.ts
+import { join as join5, relative as relative6, sep as sep3 } from "path";
+var NODE_RUNTIME_REL = ".boring-agent/node";
+var NODE_PACKAGE_JSON_REL = `${NODE_RUNTIME_REL}/package.json`;
+var NODE_FINGERPRINT_REL = `${NODE_RUNTIME_REL}/.fingerprint`;
+function parseNodeMajor(version) {
+  const match = version.trim().match(/^v?(\d+)\./);
+  return match ? Number(match[1]) : null;
+}
+async function commandOutput(adapter, command, args) {
+  const result = await adapter.exec(command, args);
+  return result?.stdout?.trim() ?? "";
+}
+async function ensureNodeEnv(adapter) {
+  try {
+    const nodeVersion = await commandOutput(adapter, "node", ["--version"]);
+    const npmVersion = await commandOutput(adapter, "npm", ["--version"]);
+    const major = parseNodeMajor(nodeVersion || process.version);
+    if (major === null || major < 18) {
+      throw new Error(`Unsupported Node.js version for runtime provisioning: ${nodeVersion || process.version}`);
+    }
+    return {
+      nodeVersion: nodeVersion || process.version,
+      npmVersion: npmVersion || "unknown"
+    };
+  } catch (error) {
+    throw toProvisioningError(
+      ErrorCode.enum.PROVISIONING_NODE_PREFLIGHT_FAILED,
+      "node-preflight",
+      error,
+      { runtime: "node" }
+    );
+  }
+}
+function nodeInstallSource(spec) {
+  return spec.version ? `${spec.packageName}@${spec.version}` : spec.packageName;
+}
+function expectedNodeOutputs(paths, packages) {
+  return [
+    join5(paths.node, "package-lock.json"),
+    ...packages.flatMap(
+      (pkg) => (pkg.expectedBins ?? []).map((bin) => join5(paths.nodeBin, bin))
+    )
+  ];
+}
+function toWorkspaceRel(paths, absolutePath) {
+  return relative6(paths.workspaceRoot, absolutePath).split(sep3).join("/");
+}
+async function shouldInstallNodeRuntime(options) {
+  const currentFingerprint = (await options.adapter.workspaceFs.readText(NODE_FINGERPRINT_REL))?.trim();
+  if (!currentFingerprint || !isValidFingerprint(currentFingerprint) || currentFingerprint !== options.desiredFingerprint) {
+    return true;
+  }
+  for (const output of options.expectedOutputs) {
+    if (!await options.adapter.workspaceFs.exists(toWorkspaceRel(options.runtimeLayout, output))) return true;
+  }
+  return false;
+}
+async function ensureNodeRuntime(options) {
+  if (options.packages.length === 0) {
+    return { changed: false, pathEntries: [], fingerprint: null };
+  }
+  const versions = await ensureNodeEnv(options.adapter);
+  const fingerprint2 = createNodeRuntimeFingerprint({
+    ...versions,
+    packages: options.packages
+  });
+  const expectedOutputs = expectedNodeOutputs(options.runtimeLayout, options.packages);
+  if (!await shouldInstallNodeRuntime({
+    adapter: options.adapter,
+    runtimeLayout: options.runtimeLayout,
+    desiredFingerprint: fingerprint2,
+    expectedOutputs
+  })) {
+    return {
+      changed: false,
+      pathEntries: [options.runtimeLayout.nodeBin],
+      fingerprint: fingerprint2
+    };
+  }
+  const installSources = [];
+  for (const pkg of options.packages) {
+    if (pkg.packageRoot) {
+      const packageFingerprint = createRuntimeFingerprint({ kind: "node-source", package: pkg });
+      installSources.push(await options.adapter.resolveInstallSource(pkg.packageRoot, {
+        kind: "node",
+        id: pkg.id,
+        fingerprint: packageFingerprint
+      }));
+      continue;
+    }
+    installSources.push(nodeInstallSource(pkg));
+  }
+  await options.adapter.workspaceFs.rm(NODE_RUNTIME_REL);
+  await options.adapter.workspaceFs.mkdir(NODE_RUNTIME_REL);
+  await options.adapter.workspaceFs.writeText(
+    NODE_PACKAGE_JSON_REL,
+    `${JSON.stringify({ name: "boring-agent-runtime", private: true }, null, 2)}
+`
+  );
+  try {
+    await options.adapter.exec("npm", [
+      "install",
+      "--prefix",
+      options.runtimeLayout.node,
+      ...installSources
+    ], {
+      cwd: options.runtimeLayout.workspaceRoot,
+      env: getBoringAgentRuntimeEnv(
+        options.runtimeLayout,
+        options.adapter.getRuntimeCacheRoot()
+      )
+    });
+  } catch (error) {
+    throw toProvisioningError(
+      ErrorCode.enum.PROVISIONING_NPM_INSTALL_FAILED,
+      "node-packages",
+      error,
+      { runtime: "node", packageIds: options.packages.map((pkg) => pkg.id) }
+    );
+  }
+  await options.adapter.workspaceFs.writeText(NODE_FINGERPRINT_REL, `${fingerprint2}
+`);
+  return {
+    changed: true,
+    pathEntries: [options.runtimeLayout.nodeBin],
+    fingerprint: fingerprint2
+  };
+}
+
+// src/server/workspace/provisioning/python.ts
+import { dirname as dirname7, join as join6, relative as relative7, sep as sep4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var VENV_REL = ".boring-agent/venv";
+var VENV_FINGERPRINT_REL = `${VENV_REL}/.fingerprint`;
+var UV_BIN_REL = ".boring-agent/sdk/uv/bin/uv";
+function sourceToPath(source) {
+  return source instanceof URL ? fileURLToPath2(source) : source;
+}
+async function commandOutput2(adapter, command, args) {
+  const result = await adapter.exec(command, args);
+  return result?.stdout?.trim() ?? "";
+}
+async function ensureUv(options) {
+  try {
+    return {
+      uvBin: "uv",
+      uvVersion: await commandOutput2(options.adapter, "uv", ["--version"]) || "uv unknown",
+      installedWorkspaceUv: false
+    };
+  } catch {
+    if (!options.uvStandaloneSource) {
+      throw toProvisioningError(
+        ErrorCode.enum.PROVISIONING_UV_BOOTSTRAP_FAILED,
+        "uv-bootstrap",
+        new Error("uv is required for Python runtime provisioning; install uv or provide a standalone uv binary"),
+        { runtime: "python" }
+      );
+    }
+  }
+  try {
+    await options.adapter.workspaceFs.mkdir(".boring-agent/sdk/uv/bin");
+    await options.adapter.workspaceFs.rm(UV_BIN_REL);
+    await options.adapter.workspaceFs.copyFromHost(options.uvStandaloneSource, UV_BIN_REL);
+    const uvBin = join6(options.runtimeLayout.uvBin, "uv");
+    await options.adapter.exec("chmod", ["+x", uvBin], { cwd: options.runtimeLayout.workspaceRoot });
+    return {
+      uvBin,
+      uvVersion: await commandOutput2(options.adapter, uvBin, ["--version"]) || "uv unknown",
+      installedWorkspaceUv: true
+    };
+  } catch (error) {
+    throw toProvisioningError(
+      ErrorCode.enum.PROVISIONING_UV_BOOTSTRAP_FAILED,
+      "uv-bootstrap",
+      error,
+      { runtime: "python" }
+    );
+  }
+}
+async function ensurePythonEnv(adapter) {
+  return await commandOutput2(adapter, "python3", ["--version"]) || "Python unknown";
+}
+function pythonInstallSource(spec) {
+  if (spec.version && spec.packageName) return `${spec.packageName}==${spec.version}`;
+  if (spec.packageName) return spec.packageName;
+  throw new Error(`Python runtime package ${spec.id} must declare packageName when no projectFile/packageRoot is provided`);
+}
+function sourceRootForPythonSpec(spec) {
+  if (spec.packageRoot) return spec.packageRoot;
+  if (spec.projectFile) return dirname7(sourceToPath(spec.projectFile));
+  return null;
+}
+function expectedPythonOutputs(paths, packages) {
+  return [
+    paths.venvPython,
+    ...packages.flatMap(
+      (pkg) => (pkg.expectedBins ?? []).map((bin) => join6(paths.venvBin, bin))
+    )
+  ];
+}
+function collectPythonEnv(packages) {
+  const env = {};
+  for (const pkg of packages) {
+    for (const [key, value] of Object.entries(pkg.env ?? {})) {
+      env[key] = String(value);
+    }
+  }
+  return env;
+}
+function toWorkspaceRel2(paths, absolutePath) {
+  return relative7(paths.workspaceRoot, absolutePath).split(sep4).join("/");
+}
+async function shouldInstallPythonRuntime(options) {
+  const currentFingerprint = (await options.adapter.workspaceFs.readText(VENV_FINGERPRINT_REL))?.trim();
+  if (!currentFingerprint || !isValidFingerprint(currentFingerprint) || currentFingerprint !== options.desiredFingerprint) {
+    return true;
+  }
+  for (const output of options.expectedOutputs) {
+    if (!await options.adapter.workspaceFs.exists(toWorkspaceRel2(options.runtimeLayout, output))) return true;
+  }
+  return false;
+}
+async function ensurePythonRuntime(options) {
+  const env = collectPythonEnv(options.packages);
+  if (options.packages.length === 0) {
+    return { changed: false, env, pathEntries: [], fingerprint: null };
+  }
+  const pythonVersion = await ensurePythonEnv(options.adapter);
+  const uv = await ensureUv(options);
+  const fingerprint2 = createPythonRuntimeFingerprint({
+    packages: options.packages,
+    pythonVersion,
+    uvVersion: uv.uvVersion
+  });
+  const expectedOutputs = expectedPythonOutputs(options.runtimeLayout, options.packages);
+  if (!await shouldInstallPythonRuntime({
+    adapter: options.adapter,
+    runtimeLayout: options.runtimeLayout,
+    desiredFingerprint: fingerprint2,
+    expectedOutputs
+  })) {
+    return {
+      changed: false,
+      env,
+      pathEntries: [options.runtimeLayout.venvBin, options.runtimeLayout.uvBin],
+      fingerprint: fingerprint2
+    };
+  }
+  const installSources = [];
+  for (const pkg of options.packages) {
+    const sourceRoot = sourceRootForPythonSpec(pkg);
+    if (sourceRoot) {
+      const packageFingerprint = createRuntimeFingerprint({ kind: "python-source", package: pkg });
+      installSources.push(await options.adapter.resolveInstallSource(sourceRoot, {
+        kind: "python",
+        id: pkg.id,
+        fingerprint: packageFingerprint
+      }));
+    } else {
+      installSources.push(pythonInstallSource(pkg));
+    }
+    installSources.push(...pkg.extraLibs ?? []);
+  }
+  await options.adapter.workspaceFs.rm(VENV_REL);
+  try {
+    await options.adapter.exec(uv.uvBin, ["venv", options.runtimeLayout.venv], {
+      cwd: options.runtimeLayout.workspaceRoot,
+      env: getBoringAgentRuntimeEnv(
+        options.runtimeLayout,
+        options.adapter.getRuntimeCacheRoot()
+      )
+    });
+    await options.adapter.exec(uv.uvBin, [
+      "pip",
+      "install",
+      "--python",
+      options.runtimeLayout.venvPython,
+      ...installSources
+    ], {
+      cwd: options.runtimeLayout.workspaceRoot,
+      env: {
+        ...getBoringAgentRuntimeEnv(
+          options.runtimeLayout,
+          options.adapter.getRuntimeCacheRoot()
+        ),
+        ...env
+      }
+    });
+  } catch (error) {
+    throw toProvisioningError(
+      ErrorCode.enum.PROVISIONING_UV_INSTALL_FAILED,
+      "python-packages",
+      error,
+      { runtime: "python", packageIds: options.packages.map((pkg) => pkg.id) }
+    );
+  }
+  await options.adapter.workspaceFs.writeText(VENV_FINGERPRINT_REL, `${fingerprint2}
+`);
+  return {
+    changed: true,
+    env,
+    pathEntries: [options.runtimeLayout.venvBin, options.runtimeLayout.uvBin],
+    fingerprint: fingerprint2
+  };
+}
+
+// src/server/workspace/provisioning/skills.ts
+import { stat as stat4 } from "fs/promises";
+import { join as join7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var GENERATED_SKILLS_REL = ".boring-agent/skills";
+var USER_SKILLS_REL = ".agents/skills";
+function sourceToPath2(source) {
+  return source instanceof URL ? fileURLToPath3(source) : source;
+}
+function assertSafeSegment(kind, value) {
+  if (value.length === 0 || value.includes("\0") || value.includes("/") || value.includes("\\") || value === "." || value === "..") {
+    throw new Error(`Invalid ${kind} for plugin skill mirror: ${value}`);
+  }
+}
+function getProvisionedSkillPaths(paths) {
+  return [paths.skills, join7(paths.workspaceRoot, USER_SKILLS_REL)];
+}
+async function mirrorPluginSkills(options) {
+  await options.adapter.workspaceFs.rm(GENERATED_SKILLS_REL);
+  await options.adapter.workspaceFs.mkdir(GENERATED_SKILLS_REL);
+  const seen = /* @__PURE__ */ new Set();
+  let copiedSkillCount = 0;
+  for (const plugin of options.plugins) {
+    assertSafeSegment("plugin id", plugin.id);
+    for (const skill of plugin.skills ?? []) {
+      assertSafeSegment("skill name", skill.name);
+      const key = `${plugin.id}/${skill.name}`;
+      if (seen.has(key)) {
+        throw new Error(`Duplicate plugin skill mirror target: ${key}`);
+      }
+      seen.add(key);
+      const sourcePath = sourceToPath2(skill.source);
+      const sourceStat = await stat4(sourcePath);
+      const skillTarget = `${GENERATED_SKILLS_REL}/${plugin.id}/${skill.name}`;
+      const target = sourceStat.isDirectory() ? skillTarget : `${skillTarget}/SKILL.md`;
+      await options.adapter.workspaceFs.copyFromHost(skill.source, target);
+      copiedSkillCount += 1;
+    }
+  }
+  return {
+    changed: copiedSkillCount > 0,
+    skillPaths: getProvisionedSkillPaths(options.runtimeLayout)
+  };
+}
+
+// src/server/workspace/provisioning/workspaceFiles.ts
+import { basename, join as joinPath } from "path";
+import { posix } from "path";
+import { readdir as readdir3, stat as stat5 } from "fs/promises";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "url";
+function sourceToPath3(source) {
+  return source instanceof URL ? fileURLToPath4(source) : source;
+}
+function toWorkspaceRel3(...parts) {
+  return posix.normalize(parts.filter(Boolean).join("/"));
+}
+function sourceForChild(rootSource, childPath) {
+  return rootSource instanceof URL ? pathToFileURL(childPath) : childPath;
+}
+async function collectTemplateWorkItems(template) {
+  const sourcePath = sourceToPath3(template.path);
+  const sourceStat = await stat5(sourcePath);
+  const targetPrefix = template.target ?? "";
+  if (!sourceStat.isDirectory()) {
+    const targetRel = toWorkspaceRel3(targetPrefix || basename(sourcePath));
+    return [{
+      hostSourcePath: sourcePath,
+      source: template.path,
+      targetRel,
+      kind: "file"
+    }];
+  }
+  const items = [];
+  async function walk(dir, rel) {
+    const targetRel = toWorkspaceRel3(targetPrefix, rel);
+    if (rel !== "") {
+      items.push({
+        hostSourcePath: dir,
+        source: sourceForChild(template.path, dir),
+        targetRel,
+        kind: "directory"
+      });
+    } else if (targetPrefix) {
+      items.push({
+        hostSourcePath: dir,
+        source: sourceForChild(template.path, dir),
+        targetRel: toWorkspaceRel3(targetPrefix),
+        kind: "directory"
+      });
+    }
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const childPath = joinPath(dir, entry.name);
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        await walk(childPath, childRel);
+      } else if (entry.isFile()) {
+        items.push({
+          hostSourcePath: childPath,
+          source: sourceForChild(template.path, childPath),
+          targetRel: toWorkspaceRel3(targetPrefix, childRel),
+          kind: "file"
+        });
+      }
+    }
+  }
+  await walk(sourcePath, "");
+  return items;
+}
+async function seedTemplate(options) {
+  const items = await collectTemplateWorkItems(options.template);
+  let changed = false;
+  for (const item of items) {
+    let exists2;
+    try {
+      exists2 = await options.adapter.workspaceFs.exists(item.targetRel);
+      if (exists2) continue;
+      if (item.kind === "directory") {
+        await options.adapter.workspaceFs.mkdir(item.targetRel);
+      } else {
+        await options.adapter.workspaceFs.copyFromHost(item.source, item.targetRel);
+      }
+      changed = true;
+    } catch (error) {
+      throw new Error(
+        `Failed to seed workspace template file (plugin=${options.pluginId}, template=${options.template.id}, source=${item.hostSourcePath}, targetRel=${item.targetRel}): ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  return changed;
+}
+async function seedWorkspaceFiles(options) {
+  let changed = false;
+  for (const plugin of options.plugins) {
+    for (const template of plugin.provisioning?.templateDirs ?? []) {
+      const templateChanged = await seedTemplate({
+        adapter: options.adapter,
+        pluginId: plugin.id,
+        template
+      });
+      changed = changed || templateChanged;
+    }
+  }
+  return { changed };
+}
+
+// src/server/workspace/provisioning/provisionWorkspaceRuntime.ts
+async function ensureRuntimeLayout(opts) {
+  let changed = false;
+  const dirs = [
+    BORING_AGENT_DIR,
+    ...BORING_AGENT_RUNTIME_DIR_NAMES.map((dir) => `${BORING_AGENT_DIR}/${dir}`)
+  ];
+  for (const dir of dirs) {
+    if (!await opts.adapter.workspaceFs.exists(dir)) changed = true;
+    await opts.adapter.workspaceFs.mkdir(dir);
+  }
+  const gitignorePath = `${BORING_AGENT_DIR}/.gitignore`;
+  const currentGitignore = await opts.adapter.workspaceFs.readText(gitignorePath);
+  if (currentGitignore !== BORING_AGENT_GITIGNORE_CONTENT) {
+    await opts.adapter.workspaceFs.writeText(gitignorePath, BORING_AGENT_GITIGNORE_CONTENT);
+    changed = true;
+  }
+  return changed;
+}
+function collectNodePackages(plugins) {
+  return plugins.flatMap((plugin) => plugin.provisioning?.nodePackages ?? []);
+}
+function collectPythonPackages(plugins) {
+  return plugins.flatMap((plugin) => plugin.provisioning?.python ?? []);
+}
+function countSkills(plugins) {
+  return plugins.reduce((count, plugin) => count + (plugin.skills?.length ?? 0), 0);
+}
+function countTemplateDirs(plugins) {
+  return plugins.reduce((count, plugin) => count + (plugin.provisioning?.templateDirs?.length ?? 0), 0);
+}
+function changedString(result) {
+  const changed = result?.changed;
+  return typeof changed === "boolean" ? changed ? "true" : "false" : void 0;
+}
+function telemetryProperties(opts, extra = {}) {
+  return {
+    runtimeMode: opts.telemetryContext?.runtimeMode ?? opts.adapter.mode,
+    workspaceId: opts.telemetryContext?.workspaceId,
+    sessionId: opts.telemetryContext?.sessionId,
+    requestId: opts.telemetryContext?.requestId,
+    ...extra
+  };
+}
+function captureProvisioningEvent(opts, name, properties) {
+  if (!opts.telemetry) return;
+  safeCapture(opts.telemetry, {
+    name,
+    properties: telemetryProperties(opts, properties)
+  });
+}
+async function runPhase(options) {
+  const startedAt = Date.now();
+  logProvisioning(options.logger, "info", `workspace provisioning ${options.phase} started`, options.details);
+  try {
+    const result = await options.run();
+    const changed = changedString(result);
+    captureProvisioningEvent(options.opts, "agent.runtime.provisioning.step", {
+      phase: options.telemetryPhase,
+      status: "ok",
+      durationMs: Date.now() - startedAt,
+      ...changed ? { changed } : {}
+    });
+    logProvisioning(options.logger, "info", `workspace provisioning ${options.phase} completed`, options.details);
+    return result;
+  } catch (error) {
+    const provisioningError = toProvisioningError(
+      options.code,
+      options.phase,
+      error,
+      options.details
+    );
+    captureProvisioningEvent(options.opts, "agent.runtime.provisioning.step", {
+      phase: options.telemetryPhase,
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      errorCode: provisioningError.code
+    });
+    logProvisioning(options.logger, "error", `workspace provisioning ${options.phase} failed`, {
+      code: provisioningError.code,
+      ...provisioningError.details
+    });
+    throw provisioningError;
+  }
+}
+async function provisionWorkspaceRuntime(opts) {
+  const logger = opts.logger;
+  const startedAt = Date.now();
+  const pluginIds = opts.plugins.map((plugin) => plugin.id);
+  const nodePackages = collectNodePackages(opts.plugins);
+  const pythonPackages = collectPythonPackages(opts.plugins);
+  const summaryCounts = {
+    nodePackageCount: nodePackages.length,
+    pythonPackageCount: pythonPackages.length,
+    skillCount: countSkills(opts.plugins),
+    templateDirCount: countTemplateDirs(opts.plugins)
+  };
+  captureProvisioningEvent(opts, "agent.runtime.provisioning.started", {
+    status: "started",
+    ...summaryCounts
+  });
+  try {
+    const layoutChanged = await runPhase({
+      opts,
+      logger,
+      phase: "layout",
+      telemetryPhase: "layout",
+      code: ErrorCode.enum.PROVISIONING_LAYOUT_FAILED,
+      details: { workspaceRoot: opts.runtimeLayout.workspaceRoot },
+      run: () => ensureRuntimeLayout(opts)
+    });
+    const skills = await runPhase({
+      opts,
+      logger,
+      phase: "skill mirror",
+      telemetryPhase: "skills-mirror",
+      code: ErrorCode.enum.PROVISIONING_SKILLS_FAILED,
+      details: { workspaceRoot: opts.runtimeLayout.workspaceRoot, pluginIds },
+      run: () => mirrorPluginSkills({
+        plugins: opts.plugins,
+        adapter: opts.adapter,
+        runtimeLayout: opts.runtimeLayout
+      })
+    });
+    const workspaceFiles = await runPhase({
+      opts,
+      logger,
+      phase: "workspace files",
+      telemetryPhase: "workspace-files",
+      code: ErrorCode.enum.PROVISIONING_TEMPLATES_FAILED,
+      details: { workspaceRoot: opts.runtimeLayout.workspaceRoot, pluginIds },
+      run: () => seedWorkspaceFiles({
+        plugins: opts.plugins,
+        adapter: opts.adapter
+      })
+    });
+    const node = await runPhase({
+      opts,
+      logger,
+      phase: "node packages",
+      telemetryPhase: "node-packages",
+      code: ErrorCode.enum.PROVISIONING_NPM_INSTALL_FAILED,
+      details: { workspaceRoot: opts.runtimeLayout.workspaceRoot, packageIds: nodePackages.map((pkg) => pkg.id) },
+      run: () => ensureNodeRuntime({
+        adapter: opts.adapter,
+        runtimeLayout: opts.runtimeLayout,
+        packages: nodePackages
+      })
+    });
+    const python = await runPhase({
+      opts,
+      logger,
+      phase: "python packages",
+      telemetryPhase: "python-packages",
+      code: ErrorCode.enum.PROVISIONING_UV_INSTALL_FAILED,
+      details: { workspaceRoot: opts.runtimeLayout.workspaceRoot, packageIds: pythonPackages.map((pkg) => pkg.id) },
+      run: () => ensurePythonRuntime({
+        adapter: opts.adapter,
+        runtimeLayout: opts.runtimeLayout,
+        packages: pythonPackages
+      })
+    });
+    const result = {
+      changed: layoutChanged || skills.changed || workspaceFiles.changed || node.changed || python.changed,
+      env: {
+        ...getBoringAgentRuntimeEnv(opts.runtimeLayout, opts.adapter.getRuntimeCacheRoot()),
+        ...python.env
+      },
+      pathEntries: getBoringAgentPathEntries(opts.runtimeLayout),
+      skillPaths: skills.skillPaths
+    };
+    captureProvisioningEvent(opts, "agent.runtime.provisioning.completed", {
+      status: "ok",
+      durationMs: Date.now() - startedAt,
+      changed: result.changed ? "true" : "false",
+      ...summaryCounts
+    });
+    return result;
+  } catch (error) {
+    const code = error?.code;
+    captureProvisioningEvent(opts, "agent.runtime.provisioning.failed", {
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      ...typeof code === "string" ? { errorCode: code } : {},
+      ...summaryCounts
+    });
+    throw error;
+  }
+}
+
 // src/server/runtime/resolveMode.ts
 import { spawnSync } from "child_process";
 
 // src/server/runtime/modes/direct.ts
-import { mkdir as mkdir6 } from "fs/promises";
+import { mkdir as mkdir7 } from "fs/promises";
 
 // src/server/runtime/createServerFileSearch.ts
 var DEFAULT_LIMIT = 500;
@@ -2751,28 +3591,14 @@ function createServerFileSearch(workspace, sandbox) {
 }
 
 // src/server/workspace/provision.ts
-import { cp as cp2, mkdir as mkdir5, stat as stat4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname6, join as join4 } from "path";
-var PROVISION_MARKER_REL_PATH = ".boring-agent/provisioned";
-async function fileExists(targetPath) {
-  try {
-    await stat4(targetPath);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
+import { cp as cp2 } from "fs/promises";
 async function copyTemplate(templatePath, workspaceRoot) {
   if (!templatePath) return;
-  const markerPath = join4(workspaceRoot, PROVISION_MARKER_REL_PATH);
-  if (await fileExists(markerPath)) return;
   try {
     await cp2(templatePath, workspaceRoot, {
       recursive: true,
-      errorOnExist: false
+      errorOnExist: false,
+      force: false
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -2781,16 +3607,230 @@ async function copyTemplate(templatePath, workspaceRoot) {
       { cause: error }
     );
   }
-  await mkdir5(dirname6(markerPath), { recursive: true });
-  await writeFile5(markerPath, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+}
+
+// src/server/runtime/modes/provisioningAdapter.ts
+import { spawn as spawn3 } from "child_process";
+import { cp as cp3, lstat as lstat3, mkdir as mkdir6, readFile as readFile6, realpath as realpath3, rm as rm2, stat as stat6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute5, relative as relative8, resolve as resolve5, sep as sep5 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var LOCAL_SANDBOX_WORKSPACE_ROOT = "/workspace";
+function sourceToPath4(source) {
+  return source instanceof URL ? fileURLToPath5(source) : source;
+}
+async function assertExistingInsideWorkspace(root, relPath) {
+  const absPath = validatePath(root, relPath);
+  try {
+    await assertRealPathWithinWorkspace(root, absPath);
+    return absPath;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function prepareWritablePath(root, relPath) {
+  const absPath = validatePath(root, relPath);
+  await mkdir6(dirname8(absPath), { recursive: true });
+  await assertRealPathWithinWorkspace(root, dirname8(absPath));
+  try {
+    const targetStat = await lstat3(absPath);
+    if (targetStat.isSymbolicLink()) {
+      throw Object.assign(new Error("Target path is a symlink"), {
+        statusCode: 400,
+        reason: "symlink-escape",
+        requestedPath: relPath
+      });
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return absPath;
+}
+async function spawnCommand(command, args, opts) {
+  return await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn3(command, args, {
+      cwd: opts.cwd,
+      env: { ...process.env, ...opts.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      windowsHide: true
+    });
+    const stdout = [];
+    const stderr = [];
+    let timeout = null;
+    let settled = false;
+    const settle = (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (error) rejectPromise(error);
+      else resolvePromise({
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8")
+      });
+    };
+    child.stdout?.on("data", (chunk2) => stdout.push(chunk2));
+    child.stderr?.on("data", (chunk2) => stderr.push(chunk2));
+    child.on("error", settle);
+    child.on("close", (code) => {
+      if (code === 0) {
+        settle();
+        return;
+      }
+      const message = Buffer.concat(stderr).toString("utf8").trim();
+      settle(new Error(`Command failed (${command}) with exit code ${code ?? "unknown"}${message ? `: ${message}` : ""}`));
+    });
+    timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      settle(new Error(`Command timed out after ${opts.timeoutMs}ms: ${command}`));
+    }, opts.timeoutMs);
+  });
+}
+function defaultExecOptions(paths, opts) {
+  return {
+    cwd: opts?.cwd ?? paths.workspaceRoot,
+    env: opts?.env ?? {},
+    timeoutMs: opts?.timeoutMs ?? 12e4
+  };
+}
+function mapWorkspacePathToLocalSandbox(paths, value) {
+  const absolute = isAbsolute5(value) ? value : resolve5(paths.workspaceRoot, value);
+  const relPath = relative8(paths.workspaceRoot, absolute);
+  if (relPath === "") return LOCAL_SANDBOX_WORKSPACE_ROOT;
+  if (relPath === ".." || relPath.startsWith(`..${sep5}`)) return value;
+  return `${LOCAL_SANDBOX_WORKSPACE_ROOT}/${relPath.split(sep5).join("/")}`;
+}
+function mapValueToLocalSandbox(paths, value) {
+  return value.startsWith(paths.workspaceRoot) ? mapWorkspacePathToLocalSandbox(paths, value) : value;
+}
+function mapEnvToLocalSandbox(paths, env) {
+  return Object.fromEntries(
+    Object.entries(env).map(([key, value]) => [key, mapValueToLocalSandbox(paths, value)])
+  );
+}
+function sanitizeInstallSourcePart(value) {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized.length > 0 ? sanitized : "source";
+}
+async function copyExternalSourceIntoWorkspace(paths, sourcePath, opts) {
+  const fingerprint2 = opts.fingerprint.replace(/^sha256:/, "");
+  const relTarget = `.boring-agent/tmp/${sanitizeInstallSourcePart(opts.kind)}-${sanitizeInstallSourcePart(opts.id)}-${sanitizeInstallSourcePart(fingerprint2)}-source`;
+  const absTarget = validatePath(paths.workspaceRoot, relTarget);
+  await rm2(absTarget, { recursive: true, force: true });
+  await mkdir6(dirname8(absTarget), { recursive: true });
+  await assertRealPathWithinWorkspace(paths.workspaceRoot, dirname8(absTarget));
+  const sourceStat = await stat6(sourcePath);
+  await cp3(sourcePath, absTarget, {
+    recursive: sourceStat.isDirectory(),
+    force: false,
+    errorOnExist: true
+  });
+  return `${LOCAL_SANDBOX_WORKSPACE_ROOT}/${relTarget}`;
+}
+function createWorkspaceFs(workspaceRoot) {
+  return {
+    async exists(workspaceRelativePath) {
+      const absPath = await assertExistingInsideWorkspace(workspaceRoot, workspaceRelativePath);
+      if (!absPath) return false;
+      await lstat3(absPath);
+      return true;
+    },
+    async rm(workspaceRelativePath) {
+      const absPath = await assertExistingInsideWorkspace(workspaceRoot, workspaceRelativePath);
+      if (!absPath) return;
+      await rm2(absPath, { recursive: true, force: true });
+    },
+    async mkdir(workspaceRelativePath) {
+      const absPath = validatePath(workspaceRoot, workspaceRelativePath);
+      await mkdir6(absPath, { recursive: true });
+      await assertRealPathWithinWorkspace(workspaceRoot, absPath);
+    },
+    async writeText(workspaceRelativePath, content) {
+      const absPath = await prepareWritablePath(workspaceRoot, workspaceRelativePath);
+      await writeFile5(absPath, content, "utf8");
+    },
+    async readText(workspaceRelativePath) {
+      const absPath = await assertExistingInsideWorkspace(workspaceRoot, workspaceRelativePath);
+      if (!absPath) return null;
+      return await readFile6(absPath, "utf8");
+    },
+    async copyFromHost(hostSourcePath, workspaceRelativeTarget) {
+      const sourcePath = sourceToPath4(hostSourcePath);
+      const absTarget = await prepareWritablePath(workspaceRoot, workspaceRelativeTarget);
+      const sourceStat = await stat6(sourcePath);
+      await cp3(sourcePath, absTarget, {
+        recursive: sourceStat.isDirectory(),
+        force: false,
+        errorOnExist: true
+      });
+    }
+  };
+}
+function createDirectProvisioningAdapter(paths, runner = spawnCommand) {
+  return {
+    mode: "direct",
+    async exec(command, args, opts) {
+      return await runner(command, args, defaultExecOptions(paths, opts));
+    },
+    async resolveInstallSource(source) {
+      return sourceToPath4(source);
+    },
+    workspaceFs: createWorkspaceFs(paths.workspaceRoot),
+    getRuntimeCacheRoot() {
+      return paths.cache;
+    }
+  };
+}
+function createLocalProvisioningAdapter(paths, runner = spawnCommand) {
+  const sourceMounts = /* @__PURE__ */ new Map();
+  return {
+    mode: "local",
+    async exec(command, args, opts) {
+      const execOpts = defaultExecOptions(paths, opts);
+      const bwrapArgs = buildBwrapArgs(paths.workspaceRoot, {
+        extraArgs: [
+          "--dir",
+          "/mnt",
+          "--dir",
+          "/mnt/boring-agent-sources",
+          ...[...sourceMounts.entries()].flatMap(([host, sandbox]) => ["--ro-bind", host, sandbox])
+        ]
+      });
+      return await runner("bwrap", [
+        ...bwrapArgs,
+        mapValueToLocalSandbox(paths, command),
+        ...args.map((arg) => mapValueToLocalSandbox(paths, arg))
+      ], {
+        ...execOpts,
+        cwd: paths.workspaceRoot,
+        env: mapEnvToLocalSandbox(paths, execOpts.env)
+      });
+    },
+    async resolveInstallSource(source, opts) {
+      const hostPath = sourceToPath4(source);
+      const realWorkspaceRoot = await realpath3(paths.workspaceRoot);
+      const realSource = await realpath3(hostPath);
+      const relPath = relative8(realWorkspaceRoot, realSource);
+      if (relPath === "") return LOCAL_SANDBOX_WORKSPACE_ROOT;
+      if (!relPath.startsWith("..") && !isAbsolute5(relPath)) {
+        return `${LOCAL_SANDBOX_WORKSPACE_ROOT}/${relPath.split(sep5).join("/")}`;
+      }
+      return await copyExternalSourceIntoWorkspace(paths, realSource, opts);
+    },
+    workspaceFs: createWorkspaceFs(paths.workspaceRoot),
+    getRuntimeCacheRoot() {
+      return paths.cache;
+    }
+  };
 }
 
 // src/server/runtime/modes/direct.ts
 var directModeAdapter = {
   id: "direct",
   workspaceFsCapability: "strong",
+  createProvisioningAdapter: (runtimeLayout) => createDirectProvisioningAdapter(runtimeLayout),
   async create(ctx) {
-    await mkdir6(ctx.workspaceRoot, { recursive: true });
+    await mkdir7(ctx.workspaceRoot, { recursive: true });
     await copyTemplate(ctx.templatePath, ctx.workspaceRoot);
     const workspace = createNodeWorkspace(ctx.workspaceRoot);
     const sandbox = createDirectSandbox();
@@ -2804,15 +3844,16 @@ var directModeAdapter = {
 };
 
 // src/server/runtime/modes/local.ts
-import { mkdir as mkdir7 } from "fs/promises";
+import { mkdir as mkdir8 } from "fs/promises";
 var localModeAdapter = {
   id: "local",
   workspaceFsCapability: "strong",
+  createProvisioningAdapter: (runtimeLayout) => createLocalProvisioningAdapter(runtimeLayout),
   async create(ctx) {
     if (process.platform !== "linux") {
       throw new Error("local mode requires Linux with bubblewrap");
     }
-    await mkdir7(ctx.workspaceRoot, { recursive: true });
+    await mkdir8(ctx.workspaceRoot, { recursive: true });
     await copyTemplate(ctx.templatePath, ctx.workspaceRoot);
     const workspace = createNodeWorkspace(ctx.workspaceRoot);
     const sandbox = createBwrapSandbox();
@@ -2826,6 +3867,11 @@ var localModeAdapter = {
 };
 
 // src/server/runtime/modes/vercel-sandbox.ts
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir9, readFile as readFile8, readdir as readdir5, rename as rename5, stat as stat7 } from "fs/promises";
+import { dirname as dirname9, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { promisify as promisify2 } from "util";
 import { Sandbox as VercelSandbox } from "@vercel/sandbox";
 
 // src/server/sandbox/vercel-sandbox/createVercelSandboxExec.ts
@@ -2980,8 +4026,8 @@ function createVercelSandboxExec(sandbox, execOpts = {}) {
 }
 
 // src/server/sandbox/vercel-sandbox/packageTemplate.ts
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { createHash as createHash5 } from "crypto";
+import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { createGzip } from "zlib";
@@ -2994,7 +4040,7 @@ function log2(msg, meta = {}) {
 `);
 }
 async function collectFiles(dir, base = "") {
-  const entries = await readdir3(dir, { withFileTypes: true });
+  const entries = await readdir4(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = path3.join(dir, entry.name);
@@ -3002,13 +4048,13 @@ async function collectFiles(dir, base = "") {
     if (entry.isDirectory()) {
       files.push(...await collectFiles(fullPath, relPath));
     } else if (entry.isFile()) {
-      files.push({ rel: relPath, content: await readFile5(fullPath) });
+      files.push({ rel: relPath, content: await readFile7(fullPath) });
     }
   }
   return files.sort((a, b) => a.rel.localeCompare(b.rel));
 }
 function computeTemplateHash(files) {
-  const hash = createHash4("sha256");
+  const hash = createHash5("sha256");
   for (const file of files) {
     hash.update(file.rel);
     hash.update("\0");
@@ -3049,11 +4095,11 @@ async function buildTarGz(files) {
   }
   chunks.push(Buffer.alloc(1024));
   const tarBuffer = Buffer.concat(chunks);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const gzip = createGzip({ level: 6 });
     const gzChunks = [];
     gzip.on("data", (chunk2) => gzChunks.push(chunk2));
-    gzip.on("end", () => resolve7(Buffer.concat(gzChunks)));
+    gzip.on("end", () => resolve9(Buffer.concat(gzChunks)));
     gzip.on("error", reject);
     Readable.from(tarBuffer).pipe(gzip);
   });
@@ -3091,6 +4137,46 @@ async function packageTemplate(templatePath, opts = {}) {
 // src/server/runtime/modes/vercel-sandbox.ts
 var ORPHAN_GUARD_MAX_IDLE_MS = 24 * 60 * 60 * 1e3;
 var VERCEL_SANDBOX_TIMEOUT_MS_ENV = "BORING_AGENT_VERCEL_SANDBOX_TIMEOUT_MS";
+var VERCEL_SANDBOX_RUNTIME_ENV = "BORING_AGENT_VERCEL_SANDBOX_RUNTIME";
+var DEFAULT_VERCEL_SANDBOX_RUNTIME = "node24";
+var execFileAsync2 = promisify2(execFile2);
+function sandboxTelemetryProperties(ctx, extra = {}) {
+  return {
+    runtimeMode: "vercel-sandbox",
+    workspaceId: ctx?.workspaceId,
+    sessionId: ctx?.sessionId,
+    requestId: ctx?.requestId,
+    ...extra
+  };
+}
+function captureSandboxSetupEvent(telemetry, ctx, name, properties) {
+  if (!telemetry) return;
+  safeCapture(telemetry, {
+    name,
+    properties: sandboxTelemetryProperties(ctx, properties)
+  });
+}
+async function runSandboxSetupStep(options) {
+  const startedAt = Date.now();
+  try {
+    const result = await options.run();
+    captureSandboxSetupEvent(options.telemetry, options.ctx, "agent.runtime.sandbox.setup.step", {
+      phase: options.phase,
+      status: "ok",
+      durationMs: Date.now() - startedAt
+    });
+    return result;
+  } catch (error) {
+    const code = error?.code;
+    captureSandboxSetupEvent(options.telemetry, options.ctx, "agent.runtime.sandbox.setup.step", {
+      phase: options.phase,
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      ...typeof code === "string" ? { errorCode: code } : {}
+    });
+    throw error;
+  }
+}
 function createDefaultVercelClient(auth, opts = {}) {
   const credentials = {
     token: auth.token,
@@ -3103,12 +4189,14 @@ function createDefaultVercelClient(auth, opts = {}) {
       const base = {
         ...createOptions,
         ...params?.name ? { name: params.name } : {},
+        ...opts.runtime ? { runtime: opts.runtime } : {},
         persistent: params?.persistent ?? true,
         snapshotExpiration: params?.snapshotExpiration ?? 0
       };
       if (params?.source?.type === "snapshot") {
+        const { runtime: _runtime, ...snapshotBase } = base;
         return await VercelSandbox.create({
-          ...base,
+          ...snapshotBase,
           source: { type: "snapshot", snapshotId: params.source.snapshotId }
         });
       }
@@ -3180,6 +4268,161 @@ async function seedTemplateIntoVercelWorkspace(workspace, templatePath, logger)
     fileCount: files.length
   });
 }
+function provisioningSourceToPath(source) {
+  return source instanceof URL ? fileURLToPath6(source) : source;
+}
+async function prepareVercelProvisioningArtifact(request) {
+  const sourcePath = provisioningSourceToPath(request.source);
+  await mkdir9(dirname9(request.outputPath), { recursive: true });
+  if (request.kind === "node") {
+    const { stdout } = await execFileAsync2("npm", [
+      "pack",
+      sourcePath,
+      "--pack-destination",
+      dirname9(request.outputPath)
+    ], { maxBuffer: 1024 * 1024 * 20 });
+    const packedName = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (!packedName) throw new Error(`npm pack produced no artifact for ${sourcePath}`);
+    await rename5(join8(dirname9(request.outputPath), packedName), request.outputPath);
+    return;
+  }
+  await execFileAsync2("tar", ["-czf", request.outputPath, "-C", sourcePath, "."], {
+    maxBuffer: 1024 * 1024 * 20
+  });
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function copyHostPathToVercelWorkspace(options) {
+  const sourcePath = provisioningSourceToPath(options.source);
+  const sourceStat = await stat7(sourcePath);
+  if (sourceStat.isDirectory()) {
+    await options.workspace.mkdir(options.targetRel, { recursive: true });
+    for (const entry of await readdir5(sourcePath, { withFileTypes: true })) {
+      await copyHostPathToVercelWorkspace({
+        workspace: options.workspace,
+        source: join8(sourcePath, entry.name),
+        targetRel: `${options.targetRel}/${entry.name}`
+      });
+    }
+    return;
+  }
+  if (!sourceStat.isFile()) return;
+  const bytes = new Uint8Array(await readFile8(sourcePath));
+  if (options.workspace.writeBinaryFile) await options.workspace.writeBinaryFile(options.targetRel, bytes);
+  else await options.workspace.writeFile(options.targetRel, Buffer.from(bytes).toString("utf8"));
+}
+function isMissingWorkspacePathError(error) {
+  if (error.code === "ENOENT") return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return /\bENOENT\b|no such file|file not found/i.test(message);
+}
+function createVercelWorkspaceFs(options) {
+  const exists2 = async (rel) => {
+    try {
+      await options.workspace.stat(rel);
+      return true;
+    } catch (error) {
+      if (isMissingWorkspacePathError(error)) return false;
+      throw error;
+    }
+  };
+  return {
+    exists: exists2,
+    async rm(rel) {
+      const targetExists = await exists2(rel);
+      if (!targetExists) return;
+      const target = `${VERCEL_SANDBOX_REMOTE_ROOT}/${rel.replace(/^\/+/, "")}`;
+      const result = await options.sandbox.runCommand({
+        cmd: "sh",
+        args: ["-c", `rm -rf -- ${shellSingleQuote(target)}`]
+      });
+      if ((result.exitCode ?? 1) !== 0) {
+        const err = await (result.stderr?.() ?? Promise.resolve(""));
+        throw new Error(err || `failed to remove ${rel}`);
+      }
+    },
+    async mkdir(rel) {
+      await options.workspace.mkdir(rel, { recursive: true });
+    },
+    async writeText(rel, content) {
+      await options.workspace.writeFile(rel, content);
+    },
+    async readText(rel) {
+      try {
+        return await options.workspace.readFile(rel);
+      } catch (error) {
+        if (isMissingWorkspacePathError(error)) return null;
+        throw error;
+      }
+    },
+    async copyFromHost(source, targetRel) {
+      await copyHostPathToVercelWorkspace({ workspace: options.workspace, source, targetRel });
+    }
+  };
+}
+async function ensureVercelProvisioningParts(options) {
+  const auth = resolveVercelAuth(options.getEnvVar);
+  const teamId = requireEnvVar("VERCEL_TEAM_ID", options.getEnvVar);
+  const projectId = options.getEnvVar("VERCEL_PROJECT_ID")?.trim();
+  const timeoutMs = readOptionalPositiveIntegerEnv(VERCEL_SANDBOX_TIMEOUT_MS_ENV, options.getEnvVar);
+  const runtime = options.getEnvVar(VERCEL_SANDBOX_RUNTIME_ENV)?.trim() || DEFAULT_VERCEL_SANDBOX_RUNTIME;
+  const vercelClient = options.vercelClient ?? createDefaultVercelClient({
+    token: auth.token,
+    teamId,
+    projectId
+  }, { timeoutMs, runtime });
+  const workspaceId = options.ctx?.workspaceId ?? options.ctx?.workspaceRoot ?? options.runtimeLayout.workspaceRoot;
+  const telemetry = options.ctx?.telemetry;
+  const totalStartedAt = Date.now();
+  captureSandboxSetupEvent(telemetry, options.ctx, "agent.runtime.sandbox.setup.started", {
+    status: "started"
+  });
+  try {
+    const sandboxHandle = await runSandboxSetupStep({
+      telemetry,
+      ctx: options.ctx,
+      phase: "resolve-handle",
+      run: async () => await resolveSandboxHandle(workspaceId, options.store, vercelClient, {
+        logger: options.logger,
+        maxIdleMs: options.orphanGuardMaxIdleMs === null ? void 0 : options.orphanGuardMaxIdleMs ?? ORPHAN_GUARD_MAX_IDLE_MS,
+        expiredSandboxPolicy: options.expiredSandboxPolicy
+      })
+    });
+    await runSandboxSetupStep({
+      telemetry,
+      ctx: options.ctx,
+      phase: "ensure-workspace-root",
+      run: async () => {
+        await ensureVercelWorkspaceRoot(sandboxHandle);
+      }
+    });
+    const workspace = createVercelSandboxWorkspace(sandboxHandle);
+    const workspaceFs = createVercelWorkspaceFs({ workspace, sandbox: sandboxHandle });
+    const sandbox = createVercelSandboxExec(sandboxHandle);
+    await runSandboxSetupStep({
+      telemetry,
+      ctx: options.ctx,
+      phase: "sandbox-init",
+      run: async () => {
+        await sandbox.init?.({ workspace, sessionId: options.ctx?.sessionId ?? "default" });
+      }
+    });
+    captureSandboxSetupEvent(telemetry, options.ctx, "agent.runtime.sandbox.setup.completed", {
+      status: "ok",
+      durationMs: Date.now() - totalStartedAt
+    });
+    return { workspace, workspaceFs, sandbox, sandboxHandle };
+  } catch (error) {
+    const code = error?.code;
+    captureSandboxSetupEvent(telemetry, options.ctx, "agent.runtime.sandbox.setup.failed", {
+      status: "error",
+      durationMs: Date.now() - totalStartedAt,
+      ...typeof code === "string" ? { errorCode: code } : {}
+    });
+    throw error;
+  }
+}
 async function ensureTemplateExecutables(sandbox) {
   if (!sandbox.runCommand) return;
   await sandbox.runCommand({
@@ -3235,7 +4478,67 @@ function createVercelSandboxModeAdapter(opts = {}) {
     async dispose() {
       await snapshotScheduler?.shutdown();
     },
+    createProvisioningAdapter(runtimeLayout, ctx) {
+      let partsPromise = null;
+      const getParts = () => {
+        partsPromise ??= ensureVercelProvisioningParts({
+          store,
+          getEnvVar,
+          logger,
+          vercelClient: opts.vercelClient,
+          runtimeLayout,
+          ctx,
+          expiredSandboxPolicy: opts.expiredSandboxPolicy,
+          orphanGuardMaxIdleMs: opts.orphanGuardMaxIdleMs
+        });
+        return partsPromise;
+      };
+      return createVercelProvisioningAdapter({
+        runtimeLayout,
+        workspaceFs: {
+          async exists(rel) {
+            return await (await getParts()).workspaceFs.exists(rel);
+          },
+          async rm(rel) {
+            return await (await getParts()).workspaceFs.rm(rel);
+          },
+          async mkdir(rel) {
+            return await (await getParts()).workspaceFs.mkdir(rel);
+          },
+          async writeText(rel, content) {
+            return await (await getParts()).workspaceFs.writeText(rel, content);
+          },
+          async readText(rel) {
+            return await (await getParts()).workspaceFs.readText(rel);
+          },
+          async copyFromHost(source, target) {
+            return await (await getParts()).workspaceFs.copyFromHost(source, target);
+          }
+        },
+        async exec(command, args, execOpts) {
+          const { sandbox } = await getParts();
+          const commandLine = [command, ...args].map(shellSingleQuote).join(" ");
+          const result = await sandbox.exec(commandLine, {
+            cwd: execOpts?.cwd,
+            env: execOpts?.env,
+            timeoutMs: execOpts?.timeoutMs
+          });
+          const stdout = Buffer.from(result.stdout).toString("utf8");
+          const stderr = Buffer.from(result.stderr).toString("utf8");
+          if (result.exitCode !== 0) {
+            throw new Error(`Command failed (${command}) with exit code ${result.exitCode}${stderr.trim() ? `: ${stderr.trim()}` : ""}`);
+          }
+          return { stdout, stderr };
+        },
+        prepareArtifact: prepareVercelProvisioningArtifact
+      });
+    },
     async create(ctx) {
+      const telemetry = ctx.telemetry;
+      const totalStartedAt = Date.now();
+      captureSandboxSetupEvent(telemetry, ctx, "agent.runtime.sandbox.setup.started", {
+        status: "started"
+      });
       const auth = resolveVercelAuth(getEnvVar);
       const teamId = requireEnvVar("VERCEL_TEAM_ID", getEnvVar);
       const projectId = getEnvVar("VERCEL_PROJECT_ID")?.trim();
@@ -3243,80 +4546,127 @@ function createVercelSandboxModeAdapter(opts = {}) {
         VERCEL_SANDBOX_TIMEOUT_MS_ENV,
         getEnvVar
       );
+      const runtime = getEnvVar(VERCEL_SANDBOX_RUNTIME_ENV)?.trim() || DEFAULT_VERCEL_SANDBOX_RUNTIME;
       const vercelClient = opts.vercelClient ?? createDefaultVercelClient({
         token: auth.token,
         teamId,
         projectId
-      }, { timeoutMs });
+      }, { timeoutMs, runtime });
       logger.info("[vercel-sandbox:mode] auth resolved", {
         source: auth.source,
         hasProjectId: Boolean(projectId),
-        timeoutMs: timeoutMs ?? null
+        timeoutMs: timeoutMs ?? null,
+        runtime
       });
       const workspaceId = ctx.workspaceId ?? ctx.workspaceRoot;
       let tarballUrl;
-      if (ctx.templatePath) {
-        try {
-          const result = await packageTemplate(ctx.templatePath, opts.packageTemplateOpts);
-          tarballUrl = result.url;
-          logger.info("[vercel-sandbox:mode] template packaged", {
-            hash: result.hash,
-            url: result.url
-          });
-        } catch (error) {
-          logger.info("[vercel-sandbox:mode] template packaging failed, will use writeFiles fallback", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-      const sandboxHandle = await resolveSandboxHandle(
-        workspaceId,
-        store,
-        vercelClient,
-        {
-          tarballUrl,
-          logger,
-          maxIdleMs: opts.orphanGuardMaxIdleMs === null ? void 0 : opts.orphanGuardMaxIdleMs ?? ORPHAN_GUARD_MAX_IDLE_MS,
-          expiredSandboxPolicy: opts.expiredSandboxPolicy
+      try {
+        if (ctx.templatePath) {
+          try {
+            const result = await runSandboxSetupStep({
+              telemetry,
+              ctx,
+              phase: "template-package",
+              run: async () => await packageTemplate(ctx.templatePath, opts.packageTemplateOpts)
+            });
+            tarballUrl = result.url;
+            logger.info("[vercel-sandbox:mode] template packaged", {
+              hash: result.hash,
+              url: result.url
+            });
+          } catch (error) {
+            logger.info("[vercel-sandbox:mode] template packaging failed, will use writeFiles fallback", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
         }
-      );
-      const sandboxId = sandboxHandle.name ?? sandboxHandle.sandboxId ?? "unknown-sandbox";
-      logger.info("[vercel-sandbox:mode] resolved sandbox handle", {
-        workspaceId,
-        sandboxId,
-        snapshotId: sandboxHandle.currentSnapshotId ?? sandboxHandle.sourceSnapshotId ?? null,
-        tarballUrl: tarballUrl ?? null
-      });
-      if (snapshotScheduler && sandboxHandle.sandboxId) {
-        snapshotScheduler.trackWorkspace({
+        const sandboxHandle = await runSandboxSetupStep({
+          telemetry,
+          ctx,
+          phase: "resolve-handle",
+          run: async () => await resolveSandboxHandle(
+            workspaceId,
+            store,
+            vercelClient,
+            {
+              tarballUrl,
+              logger,
+              maxIdleMs: opts.orphanGuardMaxIdleMs === null ? void 0 : opts.orphanGuardMaxIdleMs ?? ORPHAN_GUARD_MAX_IDLE_MS,
+              expiredSandboxPolicy: opts.expiredSandboxPolicy
+            }
+          )
+        });
+        const sandboxId = sandboxHandle.name ?? sandboxHandle.sandboxId ?? "unknown-sandbox";
+        logger.info("[vercel-sandbox:mode] resolved sandbox handle", {
           workspaceId,
-          sandbox: sandboxHandle,
-          store
+          sandboxId,
+          snapshotId: sandboxHandle.currentSnapshotId ?? sandboxHandle.sourceSnapshotId ?? null,
+          tarballUrl: tarballUrl ?? null
         });
-      }
-      const markDirty = () => snapshotScheduler?.markDirty(workspaceId);
-      const workspace = createVercelSandboxWorkspace(sandboxHandle, {
-        onMutation: markDirty
-      });
-      await ensureVercelWorkspaceRoot(sandboxHandle);
-      if (ctx.templatePath) {
-        if (!tarballUrl) {
-          logger.info("[vercel-sandbox:mode] falling back to writeFiles for template", {
-            templatePath: ctx.templatePath
+        if (snapshotScheduler && sandboxHandle.sandboxId) {
+          snapshotScheduler.trackWorkspace({
+            workspaceId,
+            sandbox: sandboxHandle,
+            store
+          });
+        }
+        const markDirty = () => snapshotScheduler?.markDirty(workspaceId);
+        const workspace = createVercelSandboxWorkspace(sandboxHandle, {
+          onMutation: markDirty
+        });
+        await runSandboxSetupStep({
+          telemetry,
+          ctx,
+          phase: "ensure-workspace-root",
+          run: async () => {
+            await ensureVercelWorkspaceRoot(sandboxHandle);
+          }
+        });
+        if (ctx.templatePath) {
+          if (!tarballUrl) {
+            logger.info("[vercel-sandbox:mode] falling back to writeFiles for template", {
+              templatePath: ctx.templatePath
+            });
+          }
+          await runSandboxSetupStep({
+            telemetry,
+            ctx,
+            phase: "template-seed",
+            run: async () => {
+              await seedTemplateIntoVercelWorkspace(workspace, ctx.templatePath, logger);
+              await ensureTemplateExecutables(sandboxHandle);
+            }
           });
         }
-        await seedTemplateIntoVercelWorkspace(workspace, ctx.templatePath, logger);
-        await ensureTemplateExecutables(sandboxHandle);
+        const sandbox = createVercelSandboxExec(sandboxHandle, {
+          onMutation: markDirty
+        });
+        await runSandboxSetupStep({
+          telemetry,
+          ctx,
+          phase: "sandbox-init",
+          run: async () => {
+            await sandbox.init?.({ workspace, sessionId: ctx.sessionId });
+          }
+        });
+        captureSandboxSetupEvent(telemetry, ctx, "agent.runtime.sandbox.setup.completed", {
+          status: "ok",
+          durationMs: Date.now() - totalStartedAt
+        });
+        return {
+          workspace,
+          sandbox,
+          fileSearch: createServerFileSearch(workspace, sandbox)
+        };
+      } catch (error) {
+        const code = error?.code;
+        captureSandboxSetupEvent(telemetry, ctx, "agent.runtime.sandbox.setup.failed", {
+          status: "error",
+          durationMs: Date.now() - totalStartedAt,
+          ...typeof code === "string" ? { errorCode: code } : {}
+        });
+        throw error;
       }
-      const sandbox = createVercelSandboxExec(sandboxHandle, {
-        onMutation: markDirty
-      });
-      await sandbox.init?.({ workspace, sessionId: ctx.sessionId });
-      return {
-        workspace,
-        sandbox,
-        fileSearch: createServerFileSearch(workspace, sandbox)
-      };
     }
   };
 }
@@ -3360,8 +4710,8 @@ import Fastify from "fastify";
 
 // src/server/harness/pi-coding-agent/createHarness.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { mkdir as mkdir9, writeFile as writeFile7 } from "fs/promises";
-import { extname as extname2, join as join6 } from "path";
+import { mkdir as mkdir11, writeFile as writeFile7 } from "fs/promises";
+import { extname as extname2, join as join10 } from "path";
 import {
   createAgentSession,
   SessionManager,
@@ -3374,7 +4724,20 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // src/server/harness/pi-coding-agent/tool-adapter.ts
-function adaptToolForPi(tool, sessionId) {
+function toolTelemetryProperties(toolName2, sessionId, status, startedAt, result) {
+  const properties = {
+    toolName: toolName2,
+    status,
+    durationMs: Date.now() - startedAt
+  };
+  if (sessionId) properties.sessionId = sessionId;
+  const errorCode = result?.details?.code;
+  if (status === "error") {
+    properties.errorCode = ErrorCode.safeParse(errorCode).success ? errorCode : ErrorCode.enum.TOOL_EXECUTION_ERROR;
+  }
+  return properties;
+}
+function adaptToolForPi(tool, sessionId, telemetry = noopTelemetry) {
   return {
     name: tool.name,
     label: tool.name,
@@ -3382,24 +4745,47 @@ function adaptToolForPi(tool, sessionId) {
     parameters: tool.parameters,
     promptSnippet: tool.promptSnippet ?? tool.description,
     async execute(toolCallId, params, signal, onUpdate, _ctx) {
-      const result = await tool.execute(params, {
-        toolCallId,
-        abortSignal: signal ?? new AbortController().signal,
-        onUpdate: onUpdate ? (partial) => onUpdate({ content: [{ type: "text", text: partial }], details: void 0 }) : void 0,
-        sessionId
-      });
-      if (result.isError) {
-        throw new Error(result.content.map((c) => c.text).join("\n"));
+      const startedAt = Date.now();
+      let emittedFailure = false;
+      try {
+        const result = await tool.execute(params, {
+          toolCallId,
+          abortSignal: signal ?? new AbortController().signal,
+          onUpdate: onUpdate ? (partial) => onUpdate({ content: [{ type: "text", text: partial }], details: void 0 }) : void 0,
+          sessionId
+        });
+        safeCapture(telemetry, {
+          name: result.isError ? "agent.tool.failed" : "agent.tool.completed",
+          properties: toolTelemetryProperties(
+            tool.name,
+            sessionId,
+            result.isError ? "error" : "ok",
+            startedAt,
+            result
+          )
+        });
+        if (result.isError) {
+          emittedFailure = true;
+          throw new Error(result.content.map((c) => c.text).join("\n"));
+        }
+        return {
+          content: result.content,
+          details: result.details
+        };
+      } catch (error) {
+        if (!emittedFailure) {
+          safeCapture(telemetry, {
+            name: "agent.tool.failed",
+            properties: toolTelemetryProperties(tool.name, sessionId, "error", startedAt)
+          });
+        }
+        throw error;
       }
-      return {
-        content: result.content,
-        details: result.details
-      };
     }
   };
 }
-function adaptToolsForPi(tools, sessionId) {
-  return tools.map((tool) => adaptToolForPi(tool, sessionId));
+function adaptToolsForPi(tools, sessionId, telemetry) {
+  return tools.map((tool) => adaptToolForPi(tool, sessionId, telemetry));
 }
 
 // src/server/harness/pi-coding-agent/stream-adapter.ts
@@ -3587,17 +4973,17 @@ function piEventToChunks(event) {
 // src/server/harness/pi-coding-agent/sessions.ts
 import { randomUUID } from "crypto";
 import {
-  readdir as readdir4,
-  readFile as readFile6,
+  readdir as readdir6,
+  readFile as readFile9,
   stat as fsStat,
-  rm,
-  mkdir as mkdir8,
+  rm as rm3,
+  mkdir as mkdir10,
   writeFile as writeFile6,
   appendFile,
   utimes
 } from "fs/promises";
 import { readFileSync, readdirSync } from "fs";
-import { join as join5 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir3 } from "os";
 import {
   parseSessionEntries,
@@ -3606,7 +4992,7 @@ import {
 } from "@mariozechner/pi-coding-agent";
 function defaultSessionDir(cwd) {
   const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return join5(homedir3(), ".pi", "agent", "sessions", safePath);
+  return join9(homedir3(), ".pi", "agent", "sessions", safePath);
 }
 var SAFE_ID = /^[a-zA-Z0-9_-]+$/;
 var SAFE_SESSION_NAMESPACE = /^[a-zA-Z0-9_-]+$/;
@@ -3615,7 +5001,7 @@ function sessionDirForNamespace(namespace) {
   if (!SAFE_SESSION_NAMESPACE.test(safeNamespace)) {
     throw new Error("session namespace must contain only letters, numbers, underscores, and dashes");
   }
-  return join5(homedir3(), ".pi", "agent", "sessions", safeNamespace);
+  return join9(homedir3(), ".pi", "agent", "sessions", safeNamespace);
 }
 var PiSessionStore = class {
   cwd;
@@ -3629,15 +5015,15 @@ var PiSessionStore = class {
     this.sessionDir = options?.sessionDir ?? (options?.sessionNamespace ? sessionDirForNamespace(options.sessionNamespace) : defaultSessionDir(cwd));
   }
   async list(ctx) {
-    const files = await readdir4(this.sessionDir).catch(() => []);
+    const files = await readdir6(this.sessionDir).catch(() => []);
     const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
     const summaries = await Promise.all(
-      jsonlFiles.map((f) => this.summarizeFile(join5(this.sessionDir, f)))
+      jsonlFiles.map((f) => this.summarizeFile(join9(this.sessionDir, f)))
     );
     return summaries.filter((s) => s !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   }
   async create(ctx, init) {
-    await mkdir8(this.sessionDir, { recursive: true });
+    await mkdir10(this.sessionDir, { recursive: true });
     const id = randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const header = {
@@ -3658,7 +5044,7 @@ var PiSessionStore = class {
       };
       lines.push(JSON.stringify(infoEntry));
     }
-    const filepath = join5(this.sessionDir, `${id}.jsonl`);
+    const filepath = join9(this.sessionDir, `${id}.jsonl`);
     await writeFile6(filepath, lines.join("\n") + "\n", "utf-8");
     return {
       id,
@@ -3672,7 +5058,7 @@ var PiSessionStore = class {
     const filepath = await this.resolveSessionFile(sessionId);
     let content;
     try {
-      content = await readFile6(filepath, "utf-8");
+      content = await readFile9(filepath, "utf-8");
     } catch {
       throw new Error(`Session not found: ${sessionId}`);
     }
@@ -3715,7 +5101,7 @@ var PiSessionStore = class {
   loadPiSessionFileSync(sessionId) {
     if (!SAFE_ID.test(sessionId)) return null;
     try {
-      const direct = join5(this.sessionDir, `${sessionId}.jsonl`);
+      const direct = join9(this.sessionDir, `${sessionId}.jsonl`);
       let content;
       try {
         content = readFileSync(direct, "utf-8");
@@ -3724,7 +5110,7 @@ var PiSessionStore = class {
           (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
         );
         if (files.length === 0) return null;
-        content = readFileSync(join5(this.sessionDir, files[0]), "utf-8");
+        content = readFileSync(join9(this.sessionDir, files[0]), "utf-8");
       }
       const entries = safeParseEntries(content);
       let piFilePath = null;
@@ -3742,7 +5128,7 @@ var PiSessionStore = class {
   async loadPiSessionFile(_ctx, sessionId) {
     try {
       const filepath = await this.resolveSessionFile(sessionId);
-      const content = await readFile6(filepath, "utf-8");
+      const content = await readFile9(filepath, "utf-8");
       const entries = safeParseEntries(content);
       let piFilePath = null;
       for (const e of entries) {
@@ -3769,7 +5155,7 @@ var PiSessionStore = class {
     const filepath = await this.resolveSessionFile(sessionId).catch(
       () => null
     );
-    if (filepath) await rm(filepath, { force: true });
+    if (filepath) await rm3(filepath, { force: true });
   }
   touchSession(sessionId, title) {
     this.resolveSessionFile(sessionId).then((filepath) => {
@@ -3792,24 +5178,24 @@ var PiSessionStore = class {
     if (!SAFE_ID.test(sessionId)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const direct = join5(this.sessionDir, `${sessionId}.jsonl`);
+    const direct = join9(this.sessionDir, `${sessionId}.jsonl`);
     try {
       await fsStat(direct);
       return direct;
     } catch {
     }
-    const files = await readdir4(this.sessionDir).catch(() => []);
+    const files = await readdir6(this.sessionDir).catch(() => []);
     const match = files.find(
       (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
     );
     if (!match) throw new Error(`Session not found: ${sessionId}`);
-    return join5(this.sessionDir, match);
+    return join9(this.sessionDir, match);
   }
   async summarizeFile(filepath) {
     try {
       const [fileStat, content] = await Promise.all([
         fsStat(filepath),
-        readFile6(filepath, "utf-8")
+        readFile9(filepath, "utf-8")
       ]);
       const firstNewline = content.indexOf("\n");
       if (firstNewline === -1) return null;
@@ -3959,7 +5345,7 @@ var DEFAULT_POLL_MS = 250;
 var MAX_PROMPT_CHARS = 1200;
 var MAX_TITLE_CHARS = 80;
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 function truncateForPrompt(text) {
   const trimmed = text.trim();
@@ -4380,8 +5766,8 @@ function mergeInjectedProjectPackages(settingsJson, piPackages) {
 }
 function createResourceSettingsManager(cwd, agentDir, piPackages) {
   if (piPackages.length === 0) return SettingsManager2.create(cwd, agentDir);
-  const globalSettingsPath = join6(agentDir, "settings.json");
-  const projectSettingsPath = join6(cwd, ".pi", "settings.json");
+  const globalSettingsPath = join10(agentDir, "settings.json");
+  const projectSettingsPath = join10(cwd, ".pi", "settings.json");
   let globalSettingsOverrideJson;
   let projectSettingsOverrideJson;
   const storage = {
@@ -4534,7 +5920,7 @@ function createPiCodingAgentHarness(opts) {
     const { session: piSession } = await createAgentSession({
       cwd: ctx.workdir,
       tools: [],
-      customTools: adaptToolsForPi(opts.tools, input.sessionId),
+      customTools: adaptToolsForPi(opts.tools, input.sessionId, opts.telemetry),
       model,
       thinkingLevel: input.thinkingLevel ?? "off",
       sessionManager,
@@ -4982,8 +6368,8 @@ function createPiCodingAgentHarness(opts) {
             const base = basenameForAttachment(a.filename ?? "image");
             const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
             const relPath = `${DEFAULT_ATTACHMENT_DIR}/${base}-${unique}.${ext}`;
-            await mkdir9(join6(ctx.workdir, DEFAULT_ATTACHMENT_DIR), { recursive: true });
-            await writeFile7(join6(ctx.workdir, relPath), bytes);
+            await mkdir11(join10(ctx.workdir, DEFAULT_ATTACHMENT_DIR), { recursive: true });
+            await writeFile7(join10(ctx.workdir, relPath), bytes);
             savedPaths.push(relPath);
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -5072,25 +6458,25 @@ ${attachmentNotes.join("\n")}` : message,
 }
 
 // src/server/harness/pi-coding-agent/pluginLoader.ts
-import { readdir as readdir5, stat as stat5, readFile as readFile7 } from "fs/promises";
-import { join as join7, extname as extname3, resolve as resolve4, sep as sep3, relative as relative6 } from "path";
+import { readdir as readdir7, stat as stat8, readFile as readFile10 } from "fs/promises";
+import { join as join11, extname as extname3, resolve as resolve6, sep as sep6, relative as relative9 } from "path";
 import { homedir as homedir4 } from "os";
-import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL2 } from "url";
 var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs"]);
-var GLOBAL_DIR = join7(homedir4(), ".pi", "agent", "extensions");
+var GLOBAL_DIR = join11(homedir4(), ".pi", "agent", "extensions");
 var LOCAL_DIR = ".pi/extensions";
 var EXTENSIONS_JSON = ".pi/extensions.json";
 async function dirExists(path4) {
   try {
-    const s = await stat5(path4);
+    const s = await stat8(path4);
     return s.isDirectory();
   } catch {
     return false;
   }
 }
-async function fileExists2(path4) {
+async function fileExists(path4) {
   try {
-    const s = await stat5(path4);
+    const s = await stat8(path4);
     return s.isFile();
   } catch {
     return false;
@@ -5098,8 +6484,8 @@ async function fileExists2(path4) {
 }
 async function discoverFromDir(dir, source) {
   if (!await dirExists(dir)) return [];
-  const entries = await readdir5(dir);
-  return entries.filter((e) => VALID_EXTENSIONS.has(extname3(e))).map((e) => ({ path: join7(dir, e), source }));
+  const entries = await readdir7(dir);
+  return entries.filter((e) => VALID_EXTENSIONS.has(extname3(e))).map((e) => ({ path: join11(dir, e), source }));
 }
 function extractTools(mod) {
   const tools = [];
@@ -5124,41 +6510,41 @@ function extractTools(mod) {
   return tools;
 }
 async function loadModule(filePath, importFn) {
-  const url = pathToFileURL(filePath).href;
+  const url = pathToFileURL2(filePath).href;
   const mod = await importFn(url);
   return extractTools(mod);
 }
 async function discoverNpmPlugins(cwd) {
-  const nodeModulesDir = join7(cwd, "node_modules");
+  const nodeModulesDir = join11(cwd, "node_modules");
   if (!await dirExists(nodeModulesDir)) return [];
   try {
-    const entries = await readdir5(nodeModulesDir);
-    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join7(nodeModulesDir, e));
+    const entries = await readdir7(nodeModulesDir);
+    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join11(nodeModulesDir, e));
   } catch {
     return [];
   }
 }
 async function loadNpmPlugin(pkgDir, importFn) {
-  const pkgJsonPath = join7(pkgDir, "package.json");
-  if (!await fileExists2(pkgJsonPath)) return [];
-  const pkgJson = JSON.parse(await readFile7(pkgJsonPath, "utf-8"));
+  const pkgJsonPath = join11(pkgDir, "package.json");
+  if (!await fileExists(pkgJsonPath)) return [];
+  const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
   const main = pkgJson.main ?? "index.js";
-  const resolvedMain = resolve4(pkgDir, main);
-  const resolvedPkgDir = resolve4(pkgDir);
-  if (resolvedMain !== resolvedPkgDir && !resolvedMain.startsWith(resolvedPkgDir + sep3)) {
+  const resolvedMain = resolve6(pkgDir, main);
+  const resolvedPkgDir = resolve6(pkgDir);
+  if (resolvedMain !== resolvedPkgDir && !resolvedMain.startsWith(resolvedPkgDir + sep6)) {
     return [];
   }
-  const relPath = relative6(resolvedPkgDir, resolvedMain);
+  const relPath = relative9(resolvedPkgDir, resolvedMain);
   if (relPath.startsWith("..")) {
     return [];
   }
   return loadModule(resolvedMain, importFn);
 }
 async function loadExtensionsJson(cwd) {
-  const configPath = join7(cwd, EXTENSIONS_JSON);
-  if (!await fileExists2(configPath)) return null;
+  const configPath = join11(cwd, EXTENSIONS_JSON);
+  if (!await fileExists(configPath)) return null;
   try {
-    const raw = await readFile7(configPath, "utf-8");
+    const raw = await readFile10(configPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5173,7 +6559,7 @@ async function loadPlugins(options) {
     const globals = await discoverFromDir(GLOBAL_DIR, "global");
     candidates.push(...globals);
   }
-  const localDir = join7(options.cwd, LOCAL_DIR);
+  const localDir = join11(options.cwd, LOCAL_DIR);
   const locals = await discoverFromDir(localDir, "local");
   candidates.push(...locals);
   const npmDirs = await discoverNpmPlugins(options.cwd);
@@ -5183,7 +6569,7 @@ async function loadPlugins(options) {
   const config = await loadExtensionsJson(options.cwd);
   if (config?.npm) {
     for (const pkg of config.npm) {
-      const pkgDir = join7(options.cwd, "node_modules", pkg);
+      const pkgDir = join11(options.cwd, "node_modules", pkg);
       if (await dirExists(pkgDir)) {
         const already = candidates.some((c) => c.path === pkgDir);
         if (!already) {
@@ -5231,9 +6617,9 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // src/server/tools/operations/bound.ts
-import { constants as constants3 } from "fs";
-import { access as access3, lstat as lstat3, mkdir as mkdir10, readFile as readFile8, readdir as readdir6, readlink, realpath as realpath3, stat as stat6, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute5, relative as relative7, resolve as resolve5 } from "path";
+import { constants as constants4 } from "fs";
+import { access as access4, lstat as lstat4, mkdir as mkdir12, readFile as readFile11, readdir as readdir8, readlink, realpath as realpath4, stat as stat9, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname10, isAbsolute as isAbsolute6, relative as relative10, resolve as resolve7 } from "path";
 function toPosixPath(value) {
   return value.split("\\").join("/");
 }
@@ -5278,19 +6664,19 @@ function matchesGlob(relativePath, pattern) {
 }
 function shouldSkipDir(relativePath, ignore) {
   const normalizedRel = toPosixPath(relativePath);
-  const basename3 = normalizedRel.split("/").at(-1) ?? normalizedRel;
-  if (basename3 === ".git" || basename3 === "node_modules") return true;
+  const basename4 = normalizedRel.split("/").at(-1) ?? normalizedRel;
+  if (basename4 === ".git" || basename4 === "node_modules") return true;
   return ignore.some((pattern) => {
     return matchesGlob(normalizedRel, pattern) || matchesGlob(`${normalizedRel}/`, pattern);
   });
 }
 async function walkMatches(root, current, pattern, ignore, limit, out) {
   if (out.length >= limit) return;
-  const entries = await readdir6(current, { withFileTypes: true });
+  const entries = await readdir8(current, { withFileTypes: true });
   for (const entry of entries) {
     if (out.length >= limit) return;
-    const absolutePath = resolve5(current, entry.name);
-    const relativePath = toPosixPath(relative7(root, absolutePath));
+    const absolutePath = resolve7(current, entry.name);
+    const relativePath = toPosixPath(relative10(root, absolutePath));
     if (entry.isDirectory() && shouldSkipDir(relativePath, ignore)) continue;
     if (matchesGlob(relativePath, pattern)) {
       out.push(absolutePath);
@@ -5304,26 +6690,26 @@ async function findNearestExistingAncestor(absPath) {
   let current = absPath;
   for (; ; ) {
     try {
-      await stat6(current);
+      await stat9(current);
       return current;
     } catch {
-      const parent = dirname7(current);
+      const parent = dirname10(current);
       if (parent === current) return current;
       current = parent;
     }
   }
 }
 async function assertWithinWorkspace(workspaceRoot, absPath) {
-  const realRoot = await realpath3(resolve5(workspaceRoot));
+  const realRoot = await realpath4(resolve7(workspaceRoot));
   try {
-    const s = await lstat3(absPath);
+    const s = await lstat4(absPath);
     if (s.isSymbolicLink()) {
       const target = await readlink(absPath);
-      const resolvedTarget = resolve5(dirname7(absPath), target);
+      const resolvedTarget = resolve7(dirname10(absPath), target);
       const nearestAncestor = await findNearestExistingAncestor(resolvedTarget);
-      const realAncestor = await realpath3(nearestAncestor);
-      const rel2 = relative7(realRoot, realAncestor);
-      if (rel2.startsWith("..") || isAbsolute5(rel2)) {
+      const realAncestor = await realpath4(nearestAncestor);
+      const rel2 = relative10(realRoot, realAncestor);
+      if (rel2.startsWith("..") || isAbsolute6(rel2)) {
         throw new Error(`path "${absPath}" is outside workspace`);
       }
       return;
@@ -5337,22 +6723,22 @@ async function assertWithinWorkspace(workspaceRoot, absPath) {
   }
   let realCandidate;
   try {
-    realCandidate = await realpath3(absPath);
+    realCandidate = await realpath4(absPath);
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
-      const nearestAncestor = await findNearestExistingAncestor(dirname7(absPath));
-      const realAncestor = await realpath3(nearestAncestor);
-      const rel2 = relative7(realRoot, realAncestor);
-      if (rel2.startsWith("..") || isAbsolute5(rel2)) {
+      const nearestAncestor = await findNearestExistingAncestor(dirname10(absPath));
+      const realAncestor = await realpath4(nearestAncestor);
+      const rel2 = relative10(realRoot, realAncestor);
+      if (rel2.startsWith("..") || isAbsolute6(rel2)) {
         throw new Error(`path "${absPath}" is outside workspace`);
       }
       return;
     }
     throw err;
   }
-  const rel = relative7(realRoot, realCandidate);
-  if (rel.startsWith("..") || isAbsolute5(rel)) {
+  const rel = relative10(realRoot, realCandidate);
+  if (rel.startsWith("..") || isAbsolute6(rel)) {
     throw new Error(`path "${absPath}" is outside workspace`);
   }
 }
@@ -5360,28 +6746,28 @@ function boundFs(workspaceRoot) {
   const read = {
     async readFile(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return await readFile8(absolutePath);
+      return await readFile11(absolutePath);
     },
     async access(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await access3(absolutePath, constants3.R_OK);
+      await access4(absolutePath, constants4.R_OK);
     }
   };
   const write = {
     async writeFile(absolutePath, content) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await mkdir10(dirname7(absolutePath), { recursive: true });
+      await mkdir12(dirname10(absolutePath), { recursive: true });
       await writeFile8(absolutePath, content);
     },
     async mkdir(dir) {
       await assertWithinWorkspace(workspaceRoot, dir);
-      await mkdir10(dir, { recursive: true });
+      await mkdir12(dir, { recursive: true });
     }
   };
   const edit = {
     async readFile(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return await readFile8(absolutePath);
+      return await readFile11(absolutePath);
     },
     async writeFile(absolutePath, content) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
@@ -5389,14 +6775,14 @@ function boundFs(workspaceRoot) {
     },
     async access(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await access3(absolutePath, constants3.R_OK | constants3.W_OK);
+      await access4(absolutePath, constants4.R_OK | constants4.W_OK);
     }
   };
   const find = {
     async exists(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
       try {
-        await stat6(absolutePath);
+        await stat9(absolutePath);
         return true;
       } catch (err) {
         if (err.code === "ENOENT") return false;
@@ -5413,18 +6799,18 @@ function boundFs(workspaceRoot) {
   const grep = {
     async isDirectory(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return (await stat6(absolutePath)).isDirectory();
+      return (await stat9(absolutePath)).isDirectory();
     },
     async readFile(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return await readFile8(absolutePath, "utf8");
+      return await readFile11(absolutePath, "utf8");
     }
   };
   const ls = {
     async exists(absolutePath) {
       try {
         await assertWithinWorkspace(workspaceRoot, absolutePath);
-        await stat6(absolutePath);
+        await stat9(absolutePath);
         return true;
       } catch {
         return false;
@@ -5432,18 +6818,18 @@ function boundFs(workspaceRoot) {
     },
     async stat(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return await stat6(absolutePath);
+      return await stat9(absolutePath);
     },
     async readdir(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      return await readdir6(absolutePath);
+      return await readdir8(absolutePath);
     }
   };
   return { read, write, edit, find, grep, ls };
 }
 
 // src/server/tools/operations/vercel.ts
-import { isAbsolute as isAbsolute6, relative as relative8 } from "path";
+import { isAbsolute as isAbsolute7, relative as relative11 } from "path";
 function rootAliases(workspace) {
   const aliases = [workspace.root];
   if (workspace.root === VERCEL_SANDBOX_WORKSPACE_ROOT) aliases.push(VERCEL_SANDBOX_REMOTE_ROOT);
@@ -5451,11 +6837,11 @@ function rootAliases(workspace) {
   return aliases;
 }
 function isOutsideWorkspaceRel(rel) {
-  return rel === ".." || rel.startsWith("../") || rel.startsWith("..\\") || isAbsolute6(rel);
+  return rel === ".." || rel.startsWith("../") || rel.startsWith("..\\") || isAbsolute7(rel);
 }
 function toRelPath(workspace, absolutePath) {
   for (const root of rootAliases(workspace)) {
-    const rel = relative8(root, absolutePath);
+    const rel = relative11(root, absolutePath);
     if (!isOutsideWorkspaceRel(rel)) return rel;
   }
   const skillMarker = "/.agents/skills/";
@@ -5471,10 +6857,11 @@ function toRelPath(workspace, absolutePath) {
     `path "${absolutePath}" is outside workspace; use a path relative to the workspace root or under ${rootAliases(workspace).join(" / ")}`
   );
 }
-function vercelBashOps(sandbox) {
+function vercelBashOps(sandbox, opts = {}) {
   return {
     exec(command, cwd, { onData, signal, timeout, env }) {
-      const filteredEnv = env ? Object.fromEntries(Object.entries(env).filter((e) => e[1] != null)) : void 0;
+      const effectiveEnv = opts.mergeEnv ? opts.mergeEnv(env) : env;
+      const filteredEnv = effectiveEnv ? Object.fromEntries(Object.entries(effectiveEnv).filter((e) => e[1] != null)) : void 0;
       return sandbox.exec(command, {
         cwd,
         env: filteredEnv,
@@ -5638,7 +7025,7 @@ import {
   truncateHead,
   truncateLine
 } from "@mariozechner/pi-coding-agent";
-import { resolve as resolve6, relative as relative9 } from "path";
+import { resolve as resolve8, relative as relative12 } from "path";
 
 // src/server/catalog/tools/_shared.ts
 function makeError(message) {
@@ -5790,8 +7177,8 @@ function vercelGrepTool(sandbox, workspaceRoot) {
         return makeError("pattern is required");
       }
       if (workspaceRoot && typeof params.path === "string" && params.path.length > 0) {
-        const resolved = resolve6(workspaceRoot, params.path);
-        const rel = relative9(workspaceRoot, resolved);
+        const resolved = resolve8(workspaceRoot, params.path);
+        const rel = relative12(workspaceRoot, resolved);
         if (rel.startsWith("..") || rel.startsWith("/")) {
           return makeError(`path "${params.path}" is outside workspace`);
         }
@@ -5879,7 +7266,20 @@ import {
 function shellEscape2(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
-function bwrapSpawnHook(workspaceRoot) {
+function mergeRuntimeEnv(runtime, commandEnv) {
+  const current = runtime?.getCurrent?.() ?? runtime;
+  if (!current?.env && !current?.pathEntries?.length) return commandEnv;
+  const merged = {
+    ...current.env ?? {},
+    ...commandEnv ?? {}
+  };
+  const pathParts = [...current.pathEntries ?? []];
+  if (current.env?.PATH) pathParts.push(current.env.PATH);
+  if (commandEnv?.PATH) pathParts.push(commandEnv.PATH);
+  if (pathParts.length > 0) merged.PATH = pathParts.join(":");
+  return merged;
+}
+function bwrapSpawnHook(workspaceRoot, runtime) {
   const args = buildBwrapArgs(workspaceRoot);
   const bwrapPrefix = ["bwrap", ...args].map(shellEscape2).join(" ");
   return (context) => ({
@@ -5887,30 +7287,41 @@ function bwrapSpawnHook(workspaceRoot) {
     command: `${bwrapPrefix} bash -lc ${shellEscape2(context.command)}`,
     env: withWorkspacePythonEnv({
       workspaceRoot,
-      env: context.env,
+      env: mergeRuntimeEnv(runtime, context.env),
       sandboxRoot: "/workspace"
     })
   });
 }
-function directSpawnHook(workspaceRoot) {
+function directSpawnHook(workspaceRoot, runtime) {
   return (context) => ({
     ...context,
-    env: withWorkspacePythonEnv({ workspaceRoot, env: context.env })
+    env: withWorkspacePythonEnv({
+      workspaceRoot,
+      env: mergeRuntimeEnv(runtime, context.env)
+    })
   });
 }
-function bashOptionsForMode(bundle) {
+var VERCEL_SAFE_DEFAULT_PATH = "/vercel/runtimes/node24/bin:/vercel/runtimes/node22/bin:/usr/local/bin:/usr/bin:/bin";
+function bashOptionsForMode(bundle, runtime) {
   switch (bundle.sandbox.provider) {
     case "vercel-sandbox":
-      return { operations: vercelBashOps(bundle.sandbox) };
+      return {
+        operations: vercelBashOps(bundle.sandbox, {
+          // The pi bash tool's env may include the host process env. Never
+          // forward host secrets into a remote sandbox; provide only the
+          // provisioned runtime env plus a conservative remote PATH tail.
+          mergeEnv: () => mergeRuntimeEnv(runtime, { PATH: VERCEL_SAFE_DEFAULT_PATH })
+        })
+      };
     case "bwrap":
       return {
         operations: createLocalBashOperations(),
-        spawnHook: bwrapSpawnHook(bundle.workspace.root)
+        spawnHook: bwrapSpawnHook(bundle.workspace.root, runtime)
       };
     default:
       return {
         operations: createLocalBashOperations(),
-        spawnHook: directSpawnHook(bundle.workspace.root)
+        spawnHook: directSpawnHook(bundle.workspace.root, runtime)
       };
   }
 }
@@ -5993,9 +7404,9 @@ function createExecuteIsolatedCodeTool(sandbox) {
     }
   };
 }
-function buildHarnessAgentTools(bundle) {
+function buildHarnessAgentTools(bundle, runtime) {
   const tools = [
-    adaptPiTool2(createBashToolDefinition(bundle.workspace.root, bashOptionsForMode(bundle)))
+    adaptPiTool2(createBashToolDefinition(bundle.workspace.root, bashOptionsForMode(bundle, runtime)))
   ];
   if (bundle.sandbox.capabilities.includes("isolated-code")) {
     tools.push(createExecuteIsolatedCodeTool(bundle.sandbox));
@@ -6220,7 +7631,7 @@ var PathError = class extends Error {
     this.name = "PathError";
   }
 };
-function joinPath(base, name) {
+function joinPath2(base, name) {
   if (base === ".") return name;
   return `${base}/${name}`;
 }
@@ -6235,7 +7646,7 @@ async function listTree(workspace, dir, recursive) {
     const batch = queue.shift();
     for (const e of batch.items) {
       if (entries.length >= MAX_ENTRIES) break;
-      const entryPath = joinPath(batch.parentDir, e.name);
+      const entryPath = joinPath2(batch.parentDir, e.name);
       entries.push({ name: e.name, kind: e.kind, path: entryPath });
       if (recursive && e.kind === "dir" && batch.depth < MAX_DEPTH) {
         try {
@@ -6544,8 +7955,17 @@ var chatBodySchema = z.object({
     })
   ).max(20).optional()
 });
+function addTelemetryProperty(properties, key, value) {
+  if (typeof value === "string" && value) properties[key] = value;
+  if (typeof value === "number" && Number.isFinite(value)) properties[key] = value;
+}
+function safeTelemetryErrorCode(value) {
+  const parsed = ErrorCode.safeParse(value);
+  return parsed.success ? parsed.data : ErrorCode.enum.INTERNAL_ERROR;
+}
 function chatRoutes(app, opts, done) {
   const { sessionChangesTracker } = opts;
+  const telemetry = opts.telemetry ?? noopTelemetry;
   const validateBody = createBodyValidator(chatBodySchema);
   const buffers = new StreamBufferStore();
   const lastFollowUpBySession = /* @__PURE__ */ new Map();
@@ -6590,8 +8010,18 @@ function chatRoutes(app, opts, done) {
     async (request, reply) => {
       const { sessionId, message, model, thinkingLevel, attachments } = request.body;
       const turnId = randomUUID3();
+      const startedAt = Date.now();
+      const telemetryProperties2 = {
+        sessionId,
+        requestId: request.id
+      };
+      addTelemetryProperty(telemetryProperties2, "workspaceId", request.workspaceContext?.workspaceId);
+      addTelemetryProperty(telemetryProperties2, "modelProvider", model?.provider);
       request.log.info({ sessionId, turnId, model, thinkingLevel }, "[chat] start");
-      const runtime = await resolveRuntime(request);
+      safeCapture(telemetry, {
+        name: "agent.chat.started",
+        properties: telemetryProperties2
+      });
       const abortController = new AbortController();
       let streamStarted = false;
       let streamCompleted = false;
@@ -6600,18 +8030,24 @@ function chatRoutes(app, opts, done) {
           abortController.abort();
         }
       });
-      const ctx = {
-        abortSignal: abortController.signal,
-        workdir: runtime.workdir
-      };
       const buf = buffers.create(sessionId, turnId);
       try {
+        const runtime = await resolveRuntime(request);
+        const ctx = {
+          abortSignal: abortController.signal,
+          workdir: runtime.workdir
+        };
+        safeCapture(telemetry, {
+          name: "agent.chat.message.submitted",
+          properties: telemetryProperties2
+        });
         const chunks = runtime.harness.sendMessage(
           { sessionId, message, model, thinkingLevel, attachments },
           ctx
         );
         const stream = createUIMessageStream({
           async execute({ writer }) {
+            let streamFailed = false;
             try {
               for await (const chunk2 of chunks) {
                 const c = chunk2;
@@ -6623,7 +8059,17 @@ function chatRoutes(app, opts, done) {
                 writer.write(c);
               }
             } catch (err) {
+              streamFailed = true;
               request.log.error({ err, sessionId }, "[chat] stream error");
+              safeCapture(telemetry, {
+                name: "agent.chat.failed",
+                properties: {
+                  ...telemetryProperties2,
+                  status: "error",
+                  durationMs: Date.now() - startedAt,
+                  errorCode: ErrorCode.enum.INTERNAL_ERROR
+                }
+              });
               const errChunk = {
                 type: "error",
                 errorText: "internal error"
@@ -6632,6 +8078,16 @@ function chatRoutes(app, opts, done) {
               writer.write(errChunk);
             } finally {
               streamCompleted = true;
+              if (!streamFailed) {
+                safeCapture(telemetry, {
+                  name: "agent.chat.completed",
+                  properties: {
+                    ...telemetryProperties2,
+                    status: "ok",
+                    durationMs: Date.now() - startedAt
+                  }
+                });
+              }
               buf.markComplete(() => buffers.evict(sessionId, turnId));
             }
           }
@@ -6651,6 +8107,15 @@ function chatRoutes(app, opts, done) {
         return;
       } catch (err) {
         request.log.error({ err, sessionId }, "[chat] error");
+        safeCapture(telemetry, {
+          name: "agent.chat.failed",
+          properties: {
+            ...telemetryProperties2,
+            status: "error",
+            durationMs: Date.now() - startedAt,
+            errorCode: safeTelemetryErrorCode(err?.code)
+          }
+        });
         buf.markComplete(() => buffers.evict(sessionId, turnId));
         if (streamStarted) return;
         return reply.code(500).send({
@@ -6695,17 +8160,17 @@ function chatRoutes(app, opts, done) {
           const replayed = buf.replay(cursor);
           for (const e of replayed) writer.write(e.chunk);
           if (buf.complete) return;
-          await new Promise((resolve7) => {
+          await new Promise((resolve9) => {
             const unsub = buf.subscribe(
               (e) => writer.write(e.chunk),
               () => {
                 unsub();
-                resolve7();
+                resolve9();
               }
             );
             request.raw.on("close", () => {
               unsub();
-              resolve7();
+              resolve9();
             });
           });
         }
@@ -7061,7 +8526,7 @@ function classifySessionError(err, reply) {
     }
   });
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   if (typeof value === "string") return value;
   try {
     return JSON.stringify(value, null, 2);
@@ -7087,10 +8552,10 @@ function formatToolPart(part) {
   const name = toolName(part);
   const lines = [`[tool:${name}]`];
   if ("input" in part) {
-    lines.push("input:", stableStringify(part.input));
+    lines.push("input:", stableStringify2(part.input));
   }
   if ("output" in part) {
-    lines.push("output:", stableStringify(part.output));
+    lines.push("output:", stableStringify2(part.output));
   }
   if (typeof part.errorText === "string" && part.errorText.length > 0) {
     lines.push("error:", part.errorText);
@@ -7640,8 +9105,21 @@ async function createAgentApp(opts = {}) {
       pluginTools.push(...plugin.tools);
     }
   }
+  const getRuntimeProvisioning = opts.getRuntimeProvisioning ?? (() => opts.runtimeProvisioning);
+  const runtimePi = {
+    ...opts.pi,
+    additionalSkillPaths: [
+      ...getRuntimeProvisioning()?.skillPaths ?? [],
+      ...opts.pi?.additionalSkillPaths ?? []
+    ]
+  };
   const tools = [
-    ...buildHarnessAgentTools(runtimeBundle),
+    ...buildHarnessAgentTools(runtimeBundle, {
+      getCurrent: () => {
+        const current = getRuntimeProvisioning();
+        return current ? { env: current.env, pathEntries: current.pathEntries } : void 0;
+      }
+    }),
     ...opts.disableDefaultFileTools ? [] : buildFilesystemAgentTools(runtimeBundle),
     ...opts.extraTools ?? [],
     ...pluginTools
@@ -7651,7 +9129,7 @@ async function createAgentApp(opts = {}) {
     pi: {
       noContextFiles: true,
       noSkills: true,
-      ...opts.pi
+      ...runtimePi
     }
   }));
   const harness = await harnessFactory({
@@ -7660,7 +9138,8 @@ async function createAgentApp(opts = {}) {
     sessionNamespace: opts.sessionNamespace,
     sessionDir: opts.sessionDir,
     systemPromptAppend: opts.systemPromptAppend,
-    systemPromptDynamic: opts.systemPromptDynamic
+    systemPromptDynamic: opts.systemPromptDynamic,
+    telemetry: opts.telemetry
   });
   const sessionChangesTracker = new InMemorySessionChangesTracker();
   const readyTracker = new ReadyStatusTracker({
@@ -7688,7 +9167,8 @@ async function createAgentApp(opts = {}) {
   await app.register(chatRoutes, {
     harness,
     workdir: runtimeBundle.workspace.root,
-    sessionChangesTracker
+    sessionChangesTracker,
+    telemetry: opts.telemetry
   });
   await app.register(sessionRoutes, {
     sessionStore: harness.sessions,
@@ -7699,9 +9179,18 @@ async function createAgentApp(opts = {}) {
   await app.register(modelsRoutes);
   await app.register(skillsRoutes, {
     workspaceRoot,
-    additionalSkillPaths: opts.pi?.additionalSkillPaths,
-    piPackages: opts.pi?.packages,
-    noSkills: opts.pi?.noSkills
+    additionalSkillPaths: runtimePi.additionalSkillPaths,
+    piPackages: runtimePi.packages,
+    noSkills: runtimePi.noSkills,
+    getAdditionalSkillPaths: () => [
+      ...getRuntimeProvisioning()?.skillPaths ?? [],
+      ...opts.pi?.additionalSkillPaths ?? [],
+      ...opts.pi?.getHotReloadableResources?.().additionalSkillPaths ?? []
+    ],
+    getPiPackages: () => [
+      ...opts.pi?.packages ?? [],
+      ...opts.pi?.getHotReloadableResources?.().packages ?? []
+    ]
   });
   await app.register(sessionChangesRoutes, { tracker: sessionChangesTracker });
   await app.register(catalogRoutes, { tools });
@@ -7735,7 +9224,7 @@ function applyCspHeaders(response, opts = {}) {
 }
 
 // src/server/registerAgentRoutes.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 import { AuthStorage as AuthStorage3, ModelRegistry as ModelRegistry3 } from "@mariozechner/pi-coding-agent";
 
 // src/server/catalog/mergeTools.ts
@@ -7770,8 +9259,8 @@ function mergeTools(options) {
 }
 
 // src/server/tools/upload/index.ts
-import { readFile as readFile9 } from "fs/promises";
-import { extname as extname4, join as join8 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { extname as extname4, join as join12 } from "path";
 var DEFAULT_UPLOAD_DIR = "assets/images";
 var MAX_UPLOAD_BYTES2 = 10 * 1024 * 1024;
 function contentTypeFromExt(path4) {
@@ -7839,7 +9328,7 @@ function buildUploadAgentTools(bundle) {
         const rawDir = typeof input.directory === "string" ? input.directory.trim() : "";
         const dir = rawDir ? rawDir.replace(/^\.\/+/, "").replace(/\/+$/, "") : DEFAULT_UPLOAD_DIR;
         try {
-          const bytes = await readFile9(join8(cwd, filePath));
+          const bytes = await readFile12(join12(cwd, filePath));
           if (bytes.byteLength === 0 || bytes.byteLength > MAX_UPLOAD_BYTES2) {
             return {
               content: [{ type: "text", text: `file must be between 1 byte and ${MAX_UPLOAD_BYTES2} bytes` }],
@@ -7882,7 +9371,7 @@ var DEFAULT_WORKSPACE_ID3 = "default";
 var STANDARD_AGENT_TOOL_NAMES = ["bash", "read", "write", "edit", "find", "grep", "ls"];
 var VERCEL_BINDING_HEALTHCHECK_INTERVAL_MS = 15e3;
 function pluginNameFromPath(path4) {
-  const fileName = basename2(path4);
+  const fileName = basename3(path4);
   if (fileName.endsWith(".mjs")) return fileName.slice(0, -4);
   if (fileName.endsWith(".js")) return fileName.slice(0, -3);
   return fileName;
@@ -7977,16 +9466,47 @@ var registerAgentRoutes = async (app, opts) => {
     const pi = opts.getPi ? await opts.getPi({ workspaceId, workspaceRoot: root, request }) : opts.pi;
     return { root, pi };
   }
+  async function runRuntimeProvisioning(workspaceId, scope, request) {
+    if (opts.provisionWorkspace === false || !opts.provisionRuntime) return void 0;
+    const modeCtx = {
+      workspaceRoot: scope.root,
+      sessionId: workspaceId,
+      workspaceId,
+      templatePath: scope.templatePath,
+      requestId: request?.id,
+      telemetry: opts.telemetry
+    };
+    const runtimeLayout = getBoringAgentRuntimePaths(
+      resolvedMode === "vercel-sandbox" ? VERCEL_SANDBOX_WORKSPACE_ROOT : scope.root
+    );
+    return await opts.provisionRuntime({
+      workspaceId,
+      workspaceRoot: scope.root,
+      runtimeMode: resolvedMode,
+      runtimeLayout,
+      provisioningAdapter: modeAdapter.createProvisioningAdapter?.(runtimeLayout, modeCtx),
+      request
+    });
+  }
   async function createRuntimeBinding(workspaceId, scope, request) {
     const root = scope.root;
-    const runtimeBundle = await modeAdapter.create({
+    const modeCtx = {
       workspaceRoot: root,
       sessionId: workspaceId,
       workspaceId,
-      templatePath: scope.templatePath
-    });
+      templatePath: scope.templatePath,
+      requestId: request?.id,
+      telemetry: opts.telemetry
+    };
+    let runtimeProvisioning = await runRuntimeProvisioning(workspaceId, scope, request);
+    const runtimeBundle = await modeAdapter.create(modeCtx);
     const standardTools = [
-      ...buildHarnessAgentTools(runtimeBundle),
+      ...buildHarnessAgentTools(runtimeBundle, {
+        getCurrent: () => runtimeProvisioning ? {
+          env: runtimeProvisioning.env,
+          pathEntries: runtimeProvisioning.pathEntries
+        } : void 0
+      }),
       ...buildFilesystemAgentTools(runtimeBundle),
       ...buildUploadAgentTools(runtimeBundle)
     ];
@@ -8025,14 +9545,19 @@ var registerAgentRoutes = async (app, opts) => {
       pi: {
         noContextFiles: true,
         noSkills: true,
-        ...scope.pi
+        ...scope.pi,
+        additionalSkillPaths: [
+          ...runtimeProvisioning?.skillPaths ?? [],
+          ...scope.pi?.additionalSkillPaths ?? []
+        ]
       }
     }));
     const harness = await harnessFactory({
       tools,
       cwd: root,
       sessionNamespace: scope.sessionNamespace,
-      systemPromptAppend: opts.systemPromptAppend
+      systemPromptAppend: opts.systemPromptAppend,
+      telemetry: opts.telemetry
     });
     const readyTracker = new ReadyStatusTracker({
       sandboxReady: resolvedMode !== "vercel-sandbox",
@@ -8043,6 +9568,11 @@ var registerAgentRoutes = async (app, opts) => {
     }
     return {
       runtimeBundle,
+      runtimeProvisioning,
+      reprovision: async (reloadRequest) => {
+        runtimeProvisioning = await runRuntimeProvisioning(workspaceId, scope, reloadRequest);
+        return runtimeProvisioning;
+      },
       harness,
       tools,
       readyTracker
@@ -8106,6 +9636,7 @@ var registerAgentRoutes = async (app, opts) => {
       return await recreateRuntimeBinding(workspaceId, scope);
     }
   }
+  const hasRuntimeProvisioningInput = opts.provisionWorkspace !== false && Boolean(opts.provisionRuntime);
   const staticBinding = requestScopedRuntime ? null : await getOrCreateRuntimeBinding(sessionId);
   const skillsScopeByRequest = /* @__PURE__ */ new WeakMap();
   function getSkillsScopeForRequest(request) {
@@ -8194,7 +9725,8 @@ var registerAgentRoutes = async (app, opts) => {
         workdir: binding.runtimeBundle.workspace.root
       };
     },
-    sessionChangesTracker
+    sessionChangesTracker,
+    telemetry: opts.telemetry
   });
   await app.register(sessionRoutes, {
     getSessionStore: async (request) => {
@@ -8215,15 +9747,55 @@ var registerAgentRoutes = async (app, opts) => {
   await app.register(modelsRoutes);
   await app.register(skillsRoutes, {
     workspaceRoot,
-    additionalSkillPaths: opts.pi?.additionalSkillPaths,
+    additionalSkillPaths: [
+      ...staticBinding?.runtimeProvisioning?.skillPaths ?? [],
+      ...opts.pi?.additionalSkillPaths ?? []
+    ],
     piPackages: opts.pi?.packages,
     noSkills: opts.pi?.noSkills,
     getWorkspaceRoot: staticBinding ? void 0 : async (request) => (await getSkillsScopeForRequest(request)).root,
-    getAdditionalSkillPaths: staticBinding ? void 0 : async (request) => (await getSkillsScopeForRequest(request)).pi?.additionalSkillPaths,
+    getAdditionalSkillPaths: staticBinding && !hasRuntimeProvisioningInput ? void 0 : async (request) => {
+      const scope = await getSkillsScopeForRequest(request);
+      if (!hasRuntimeProvisioningInput) return scope.pi?.additionalSkillPaths;
+      const binding = await getBindingForRequest(request);
+      return [
+        ...binding.runtimeProvisioning?.skillPaths ?? [],
+        ...scope.pi?.additionalSkillPaths ?? []
+      ];
+    },
     getPiPackages: staticBinding ? void 0 : async (request) => (await getSkillsScopeForRequest(request)).pi?.packages,
     getNoSkills: staticBinding ? void 0 : async (request) => (await getSkillsScopeForRequest(request)).pi?.noSkills
   });
   await app.register(sessionChangesRoutes, { tracker: sessionChangesTracker });
+  app.post("/api/v1/agent/reload", async (request, reply) => {
+    const workspaceId = getRequestWorkspaceId(request);
+    const binding = await getBindingForRequest(request);
+    if (!binding.harness.reloadSession) {
+      return reply.status(501).send({ ok: false, error: "Agent harness does not support reload" });
+    }
+    try {
+      binding.runtimeProvisioning = await binding.reprovision(request);
+      const hookResult = await opts.beforeReload?.({
+        workspaceId,
+        workspaceRoot: binding.runtimeBundle.workspace.root,
+        request
+      });
+      const reloadSessionId = request.body?.sessionId || sessionId;
+      const reloaded = await binding.harness.reloadSession(reloadSessionId);
+      const restart_warnings = hookResult?.restart_warnings;
+      const diagnostics = hookResult?.diagnostics;
+      return {
+        ok: true,
+        sessionId: reloadSessionId,
+        reloaded,
+        ...restart_warnings && restart_warnings.length > 0 ? { restart_warnings } : {},
+        ...diagnostics && diagnostics.length > 0 ? { diagnostics } : {}
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return reply.status(422).send({ ok: false, error: message });
+    }
+  });
   await app.register(
     catalogRoutes,
     staticBinding ? { tools: staticBinding.tools } : { getTools: async (request) => (await getBindingForRequest(request)).tools }
@@ -8239,6 +9811,8 @@ export {
   FileHandleStore,
   PI_PACKAGE_RESOURCE_FILTERS,
   UV_SETUP_COMMANDS,
+  VERCEL_PROVISIONING_CACHE_ROOT,
+  VERCEL_SANDBOX_WORKSPACE_ROOT,
   UV_SETUP_COMMANDS as VERCEL_UV_SETUP_COMMANDS,
   applyCspHeaders,
   autoDetectMode,
@@ -8254,14 +9828,19 @@ export {
   createNodeWorkspace,
   createResourceSettingsManager,
   createVercelDeploymentSnapshotProvider,
+  createVercelProvisioningAdapter,
   createVercelSandboxWorkspace,
   fileRoutes,
+  getBoringAgentPathEntries,
+  getBoringAgentRuntimeEnv,
+  getBoringAgentRuntimePaths,
   hasBwrap,
   mergePiPackageSources,
   piPackageSourceKey,
   prepareDeploymentSnapshot,
   prepareVercelDeploymentSnapshot,
   provisionRuntimeWorkspace,
+  provisionWorkspaceRuntime,
   registerAgentRoutes,
   resolveMode,
   resolveSandboxHandle