@hachej/boring-agent 0.1.40 → 0.1.42

package/dist/server/index.js

@@ -87,17 +87,18 @@ function getBoringAgentRuntimeEnv(paths, adapterCacheRoot = paths.cache) {
 
 // src/server/sandbox/workspacePythonEnv.ts
 function withWorkspacePythonEnv(opts) {
-  const { workspaceRoot, env, sandboxRoot } = opts;
+  const { workspaceRoot, env, sandboxRoot, preserveHostHome } = opts;
   const runtimeRoot = sandboxRoot ?? workspaceRoot;
   const paths = getBoringAgentRuntimePaths(runtimeRoot);
   const baseEnv = env ?? getEnvSnapshot();
   const pathParts = getBoringAgentPathEntries(paths);
   const existingPath = baseEnv.PATH;
   if (existingPath) pathParts.push(existingPath);
+  const home = preserveHostHome ? baseEnv.HOME : runtimeRoot;
   return {
     ...baseEnv,
     PATH: pathParts.join(":"),
-    HOME: runtimeRoot,
+    HOME: home,
     VIRTUAL_ENV: paths.venv,
     PYTHONHOME: void 0,
     BORING_AGENT_WORKSPACE_ROOT: runtimeRoot
@@ -168,7 +169,7 @@ function createDirectSandbox(opts = {}) {
       return await new Promise((resolve11, reject) => {
         const child = spawn(cmd, {
           cwd,
-          env: withWorkspacePythonEnv({ workspaceRoot, env: opts2?.env }),
+          env: withWorkspacePythonEnv({ workspaceRoot, env: opts2?.env, preserveHostHome: true }),
           shell: true,
           windowsHide: true,
           detached: process.platform !== "win32"
@@ -256,7 +257,7 @@ function createDirectSandbox(opts = {}) {
 import { access, stat as stat3 } from "fs/promises";
 import { constants } from "fs";
 import { spawn as spawn2 } from "child_process";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join2, posix, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join3, posix, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
 
 // src/server/sandbox/bwrap/buildBwrapArgs.ts
 import { isAbsolute } from "path";
@@ -344,9 +345,8 @@ function buildBwrapArgs(workspaceRoot, options) {
 }
 
 // src/server/workspace/createNodeWorkspace.ts
-import { lstat as lstat2, mkdir, readdir, readFile, rename, rm, stat as stat2, unlink, writeFile } from "fs/promises";
-import { dirname as dirname3, relative as relative2, resolve as resolve3, sep } from "path";
-import chokidar from "chokidar";
+import { lstat as lstat2, mkdir, readdir as readdir2, readFile, rename, rm, stat as stat2, unlink, writeFile } from "fs/promises";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 
 // src/server/workspace/paths.ts
 import { lstat, realpath, stat } from "fs/promises";
@@ -427,9 +427,13 @@ async function ensureWritableWorkspacePath(workspaceRoot, relPath) {
   return absPath;
 }
 
-// src/server/workspace/createNodeWorkspace.ts
-var EPERM_CODE = "EPERM";
-var DEFAULT_WATCH_IGNORES = [
+// src/server/workspace/nodeWatcher.ts
+import { readdir } from "fs/promises";
+import { join as join2, relative as relative2, sep } from "path";
+import chokidar from "chokidar";
+
+// src/server/workspace/ignore.ts
+var DEFAULT_IGNORED_DIR_NAMES = [
   "node_modules",
   ".git",
   ".DS_Store",
@@ -441,19 +445,141 @@ var DEFAULT_WATCH_IGNORES = [
   ".turbo",
   "test-results"
 ];
+var IGNORED_SET = new Set(DEFAULT_IGNORED_DIR_NAMES);
+function isIgnoredDirName(name) {
+  return IGNORED_SET.has(name) || name.endsWith(".tsbuildinfo");
+}
+
+// src/server/logging.ts
+var SENSITIVE_KEYS = new Set([
+  "apiKey",
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "authorization",
+  "cookie",
+  "oidcToken",
+  "accessToken",
+  "refreshToken",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "VERCEL_OIDC_TOKEN",
+  "VERCEL_TEAM_ID"
+].map((key) => key.toLowerCase()));
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(key.toLowerCase());
+}
+function redactValue(key, value, seen) {
+  if (key && isSensitiveKey(key) && value != null) return "***";
+  if (value == null || typeof value !== "object") return value;
+  if (value instanceof Date) return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = value.map((item) => redactValue(void 0, item, seen));
+    seen.delete(value);
+    return out2;
+  }
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactValue(childKey, childValue, seen);
+  }
+  seen.delete(value);
+  return out;
+}
+function redact(fields) {
+  const out = {};
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (const [k, v] of Object.entries(fields)) {
+    out[k] = redactValue(k, v, seen);
+  }
+  return out;
+}
+var verbose = typeof process !== "undefined" && process.env?.BORING_AGENT_VERBOSE === "1";
+function createLogger(prefix) {
+  function emit(level, msg, fields) {
+    const entry = {
+      level,
+      prefix,
+      msg,
+      ...fields ? redact(fields) : {},
+      t: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (level === "error") {
+      console.error(JSON.stringify(entry));
+    } else if (level === "warn") {
+      console.warn(JSON.stringify(entry));
+    } else {
+      console.log(JSON.stringify(entry));
+    }
+  }
+  return {
+    debug(msg, fields) {
+      if (verbose) emit("debug", msg, fields);
+    },
+    info(msg, fields) {
+      emit("info", msg, fields);
+    },
+    warn(msg, fields) {
+      emit("warn", msg, fields);
+    },
+    error(msg, fields) {
+      emit("error", msg, fields);
+    }
+  };
+}
+
+// src/server/workspace/nodeWatcher.ts
+var log = createLogger("workspace-watch");
 function shouldIgnoreWatchPath(root, path4) {
   const relPath = relative2(root, path4);
   const parts = relPath.split(sep);
-  return parts.some(
-    (part) => DEFAULT_WATCH_IGNORES.includes(part) || part.endsWith(".tsbuildinfo")
-  );
+  return parts.some((part) => isIgnoredDirName(part));
+}
+function toPosixRel(root, absPath) {
+  return relative2(root, absPath).split(sep).join("/");
+}
+var RENAME_ECHO_IDLE_MS = 1e3;
+var RENAME_ECHO_MAX_MS = 3e4;
+var RENAME_ECHO_FROM_KINDS = /* @__PURE__ */ new Set(["unlink", "unlinkDir"]);
+var RENAME_ECHO_TO_KINDS = /* @__PURE__ */ new Set(["add", "addDir"]);
+var DEFAULT_MAX_WATCHED_ENTRIES = 5e4;
+function maxWatchedEntries() {
+  const raw = getEnv("BORING_MAX_WATCHED_ENTRIES");
+  if (!raw) return DEFAULT_MAX_WATCHED_ENTRIES;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_WATCHED_ENTRIES;
+}
+async function countWatchableEntries(root, cap) {
+  let count = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      count += 1;
+      if (count > cap) return count;
+      if (entry.isDirectory() && !isIgnoredDirName(entry.name)) {
+        stack.push(join2(dir, entry.name));
+      }
+    }
+  }
+  return count;
 }
 function createNodeWatcher(root) {
   const listeners = /* @__PURE__ */ new Set();
+  const suppressions = [];
   let fsw = null;
   let closed = false;
-  const ensureFsw = () => {
-    if (fsw) return fsw;
+  let readiness = null;
+  const startFsw = () => {
+    if (fsw || closed) return;
     fsw = chokidar.watch(root, {
       ignored: (path4) => shouldIgnoreWatchPath(root, path4),
       ignoreInitial: true,
@@ -463,23 +589,43 @@ function createNodeWatcher(root) {
       // servers. Consumers already reconcile by mtime after invalidation.
       // No native renames from chokidar — `unlinkDir`/`addDir`/
       // `unlink`/`add` are the primitives we get. We surface them as
-      // separate `unlink` + `write`/`mkdir` events; renames are best
-      // recovered at the consumer level if needed.
+      // separate `unlink` + `write`/`mkdir` events. Renames the host
+      // performs itself arrive via `emitRename` instead, which also
+      // mutes this echo.
     });
-    fsw.on("add", (p, s) => emit({ op: "write", path: rel(p), mtimeMs: s?.mtimeMs }));
-    fsw.on("change", (p, s) => emit({ op: "write", path: rel(p), mtimeMs: s?.mtimeMs }));
-    fsw.on("addDir", (p) => emit({ op: "mkdir", path: rel(p) }));
-    fsw.on("unlink", (p) => emit({ op: "unlink", path: rel(p) }));
-    fsw.on("unlinkDir", (p) => emit({ op: "unlink", path: rel(p) }));
-    fsw.on("error", () => {
+    fsw.on("add", (p, s) => emit("add", { op: "write", path: rel(p), mtimeMs: s?.mtimeMs }));
+    fsw.on("change", (p, s) => emit("change", { op: "write", path: rel(p), mtimeMs: s?.mtimeMs }));
+    fsw.on("addDir", (p) => emit("addDir", { op: "mkdir", path: rel(p) }));
+    fsw.on("unlink", (p) => emit("unlink", { op: "unlink", path: rel(p) }));
+    fsw.on("unlinkDir", (p) => emit("unlinkDir", { op: "unlink", path: rel(p) }));
+    let loggedError = false;
+    fsw.on("error", (err) => {
+      if (loggedError) return;
+      loggedError = true;
+      log.error("file watcher error \u2014 live file events may be incomplete", {
+        root,
+        error: err instanceof Error ? err.message : String(err)
+      });
     });
-    return fsw;
   };
-  const rel = (abs) => {
-    const r = relative2(root, abs);
-    return r.split(sep).join("/");
+  const ensureFsw = () => {
+    if (readiness) return readiness;
+    readiness = (async () => {
+      const cap = maxWatchedEntries();
+      const count = await countWatchableEntries(root, cap);
+      if (closed) return { ok: false, reason: "closed" };
+      if (count > cap) {
+        const message = `workspace at ${root} has more than ${cap} entries \u2014 file watching disabled. Start boring-ui in a smaller subfolder for live file updates, or raise BORING_MAX_WATCHED_ENTRIES.`;
+        log.error(message, { root, cap });
+        return { ok: false, reason: "workspace_too_large", message };
+      }
+      startFsw();
+      return { ok: true };
+    })();
+    return readiness;
   };
-  const emit = (event) => {
+  const rel = (abs) => toPosixRel(root, abs);
+  const fanout = (event) => {
     if (closed) return;
     if (event.path === "" || event.path.startsWith("..")) return;
     for (const l of [...listeners]) {
@@ -489,26 +635,67 @@ function createNodeWatcher(root) {
       }
     }
   };
+  const isSuppressedEcho = (kind, path4) => {
+    const now = Date.now();
+    for (let i = suppressions.length - 1; i >= 0; i--) {
+      const s = suppressions[i];
+      if (now > s.idleDeadline || now > s.hardDeadline) {
+        suppressions.splice(i, 1);
+        continue;
+      }
+      if (s.kinds.has(kind) && (path4 === s.prefix || path4.startsWith(`${s.prefix}/`))) {
+        s.idleDeadline = Math.min(now + RENAME_ECHO_IDLE_MS, s.hardDeadline);
+        return true;
+      }
+    }
+    return false;
+  };
+  const emit = (kind, event) => {
+    if (isSuppressedEcho(kind, event.path)) return;
+    fanout(event);
+  };
   return {
     subscribe(listener) {
       if (closed) return () => {
       };
       listeners.add(listener);
-      ensureFsw();
+      void ensureFsw();
       return () => {
         listeners.delete(listener);
       };
     },
+    whenReady() {
+      return ensureFsw();
+    },
+    emitRename(fromRel, toRel) {
+      if (closed) return;
+      if (fsw) {
+        const now = Date.now();
+        const window = {
+          idleDeadline: now + RENAME_ECHO_IDLE_MS,
+          hardDeadline: now + RENAME_ECHO_MAX_MS
+        };
+        suppressions.push(
+          { prefix: fromRel, kinds: RENAME_ECHO_FROM_KINDS, ...window },
+          { prefix: toRel, kinds: RENAME_ECHO_TO_KINDS, ...window }
+        );
+      }
+      fanout({ op: "rename", path: toRel, oldPath: fromRel });
+    },
     close() {
       if (closed) return;
       closed = true;
       listeners.clear();
+      suppressions.length = 0;
       fsw?.close().catch(() => {
       });
       fsw = null;
     }
   };
 }
+
+// src/server/workspace/createNodeWorkspace.ts
+var EPERM_CODE = "EPERM";
 var nodeWorkspaceHostRoots = /* @__PURE__ */ new WeakMap();
 function getNodeWorkspaceHostRoot(workspace) {
   return nodeWorkspaceHostRoots.get(workspace);
@@ -589,7 +776,7 @@ function createNodeWorkspace(root, opts = {}) {
     },
     async readdir(relPath) {
       const absPath = await ensureExistingWorkspacePath(root, relPath);
-      const entries = await readdir(absPath, { withFileTypes: true });
+      const entries = await readdir2(absPath, { withFileTypes: true });
       return entries.map((entry) => ({
         name: entry.name,
         kind: entry.isDirectory() ? "dir" : "file"
@@ -627,6 +814,7 @@ function createNodeWorkspace(root, opts = {}) {
       const fromAbsPath = await ensureExistingWorkspacePath(root, fromRelPath);
       const toAbsPath = await ensureWritableWorkspacePath(root, toRelPath2);
       await rename(fromAbsPath, toAbsPath);
+      cachedWatcher?.emitRename(toPosixRel(root, fromAbsPath), toPosixRel(root, toAbsPath));
     }
   };
   nodeWorkspaceHostRoots.set(workspace, root);
@@ -752,8 +940,8 @@ async function buildGlobalToolMounts(workspaceRoot) {
   if (globalRoot === workspaceRoot) return [];
   const args = [];
   const mountIfChildLacks = async (runtimeRelPath) => {
-    const parentRuntimePath = join2(globalRoot, runtimeRelPath);
-    const childRuntimePath = join2(workspaceRoot, runtimeRelPath);
+    const parentRuntimePath = join3(globalRoot, runtimeRelPath);
+    const childRuntimePath = join3(workspaceRoot, runtimeRelPath);
     if (!await dirExists(parentRuntimePath)) return false;
     if (await pathExists(childRuntimePath)) return false;
     args.push("--ro-bind", parentRuntimePath, `${SANDBOX_HOME2}/${runtimeRelPath}`);
@@ -1696,86 +1884,6 @@ function createAuthMiddleware(opts = {}) {
   };
 }
 
-// src/server/logging.ts
-var SENSITIVE_KEYS = new Set([
-  "apiKey",
-  "api_key",
-  "token",
-  "secret",
-  "password",
-  "authorization",
-  "cookie",
-  "oidcToken",
-  "accessToken",
-  "refreshToken",
-  "ANTHROPIC_API_KEY",
-  "OPENAI_API_KEY",
-  "VERCEL_OIDC_TOKEN",
-  "VERCEL_TEAM_ID"
-].map((key) => key.toLowerCase()));
-function isSensitiveKey(key) {
-  return SENSITIVE_KEYS.has(key.toLowerCase());
-}
-function redactValue(key, value, seen) {
-  if (key && isSensitiveKey(key) && value != null) return "***";
-  if (value == null || typeof value !== "object") return value;
-  if (value instanceof Date) return value;
-  if (seen.has(value)) return "[Circular]";
-  seen.add(value);
-  if (Array.isArray(value)) {
-    const out2 = value.map((item) => redactValue(void 0, item, seen));
-    seen.delete(value);
-    return out2;
-  }
-  const out = {};
-  for (const [childKey, childValue] of Object.entries(value)) {
-    out[childKey] = redactValue(childKey, childValue, seen);
-  }
-  seen.delete(value);
-  return out;
-}
-function redact(fields) {
-  const out = {};
-  const seen = /* @__PURE__ */ new WeakSet();
-  for (const [k, v] of Object.entries(fields)) {
-    out[k] = redactValue(k, v, seen);
-  }
-  return out;
-}
-var verbose = typeof process !== "undefined" && process.env?.BORING_AGENT_VERBOSE === "1";
-function createLogger(prefix) {
-  function emit(level, msg, fields) {
-    const entry = {
-      level,
-      prefix,
-      msg,
-      ...fields ? redact(fields) : {},
-      t: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (level === "error") {
-      console.error(JSON.stringify(entry));
-    } else if (level === "warn") {
-      console.warn(JSON.stringify(entry));
-    } else {
-      console.log(JSON.stringify(entry));
-    }
-  }
-  return {
-    debug(msg, fields) {
-      if (verbose) emit("debug", msg, fields);
-    },
-    info(msg, fields) {
-      emit("info", msg, fields);
-    },
-    warn(msg, fields) {
-      emit("warn", msg, fields);
-    },
-    error(msg, fields) {
-      emit("error", msg, fields);
-    }
-  };
-}
-
 // src/server/http/routes/fileRecords.ts
 import { extname } from "path/posix";
 var MAX_RECORD_FILE_BYTES = 2 * 1024 * 1024;
@@ -1982,7 +2090,7 @@ function buildFileRecordsResult(args) {
 }
 
 // src/server/http/routes/file.ts
-var log = createLogger("boring/workspace-settings");
+var log2 = createLogger("boring/workspace-settings");
 var BORING_SETTINGS_PATH = ".boring/settings";
 var DEFAULT_MARKDOWN_IMAGE_UPLOAD_DIR = "assets/images";
 var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
@@ -2057,7 +2165,7 @@ function parseWorkspaceSettings(raw) {
       }
     };
   } catch (err) {
-    log.warn("failed to parse .boring/settings \u2014 falling back to defaults", {
+    log2.warn("failed to parse .boring/settings \u2014 falling back to defaults", {
       error: err instanceof Error ? err.message : String(err)
     });
     return defaultWorkspaceSettings();
@@ -2405,8 +2513,8 @@ function fileRoutes(app, opts, done) {
 // src/server/workspace/provisionRuntime.ts
 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 stat4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join3, relative as relative5, resolve as resolve5 } from "path";
+import { access as access2, chmod as chmod3, cp, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, realpath as realpath2, stat as stat4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute4, join as join4, relative as relative5, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -2442,11 +2550,11 @@ async function commandExists(cmd) {
 async function hashPath(path4, hash) {
   const info = await stat4(path4);
   if (info.isDirectory()) {
-    const entries = (await readdir2(path4)).filter((entry) => entry !== "__pycache__" && entry !== "build" && !entry.endsWith(".egg-info")).sort();
+    const entries = (await readdir3(path4)).filter((entry) => entry !== "__pycache__" && entry !== "build" && !entry.endsWith(".egg-info")).sort();
     for (const entry of entries) {
       hash.update(`dir:${entry}
 `);
-      await hashPath(join3(path4, entry), hash);
+      await hashPath(join4(path4, entry), hash);
     }
     return;
   }
@@ -2479,16 +2587,16 @@ async function fingerprint(contributions) {
       const packageRoot = toPath(spec.packageRoot);
       hash.update(`node-package:${spec.id}:${spec.packageName}:${packageRoot}
 `);
-      const packageJson = join3(packageRoot, "package.json");
-      const distDir = join3(packageRoot, "dist");
-      const docsDir = join3(packageRoot, "docs");
-      const skillsDir = join3(packageRoot, "skills");
-      const referencesDir = join3(packageRoot, "references");
-      const sourceDocsDir = join3(packageRoot, "src", "server", "docs");
+      const packageJson = join4(packageRoot, "package.json");
+      const distDir = join4(packageRoot, "dist");
+      const docsDir = join4(packageRoot, "docs");
+      const skillsDir = join4(packageRoot, "skills");
+      const referencesDir = join4(packageRoot, "references");
+      const sourceDocsDir = join4(packageRoot, "src", "server", "docs");
       if (await exists(packageJson)) await hashPath(packageJson, hash);
       if (await exists(distDir)) await hashPath(distDir, hash);
-      const templatesDir = join3(packageRoot, "templates");
-      const publicDir = join3(packageRoot, "public");
+      const templatesDir = join4(packageRoot, "templates");
+      const publicDir = join4(packageRoot, "public");
       if (await exists(templatesDir)) await hashPath(templatesDir, hash);
       if (await exists(publicDir)) await hashPath(publicDir, hash);
       if (await exists(docsDir)) await hashPath(docsDir, hash);
@@ -2539,7 +2647,7 @@ function nodePackageTarget(workspaceRoot, packageName) {
   if (parts.length === 0 || parts.some((part) => part === "." || part === "..")) {
     throw new Error(`Invalid node package name: ${packageName}`);
   }
-  return join3(workspaceRoot, "node_modules", ...parts);
+  return join4(workspaceRoot, "node_modules", ...parts);
 }
 async function copyIfExists(source, target) {
   if (!await exists(source)) return false;
@@ -2557,27 +2665,27 @@ async function ensureNodePackages(workspaceRoot, specs) {
     const packageRoot = toPath(spec.packageRoot);
     const target = nodePackageTarget(workspaceRoot, spec.packageName);
     await mkdir4(target, { recursive: true });
-    const copiedPackageJson = await copyIfExists(join3(packageRoot, "package.json"), join3(target, "package.json"));
+    const copiedPackageJson = await copyIfExists(join4(packageRoot, "package.json"), join4(target, "package.json"));
     if (!copiedPackageJson) {
       throw new Error(`Node package provisioning source is missing package.json: ${packageRoot}`);
     }
-    await copyIfExists(join3(packageRoot, "dist"), join3(target, "dist"));
-    await copyIfExists(join3(packageRoot, "templates"), join3(target, "templates"));
-    await copyIfExists(join3(packageRoot, "public"), join3(target, "public"));
-    if (!await exists(join3(target, "dist", "docs", "plugins.md"))) {
-      await copyIfExists(join3(packageRoot, "src", "server", "docs"), join3(target, "dist", "docs"));
+    await copyIfExists(join4(packageRoot, "dist"), join4(target, "dist"));
+    await copyIfExists(join4(packageRoot, "templates"), join4(target, "templates"));
+    await copyIfExists(join4(packageRoot, "public"), join4(target, "public"));
+    if (!await exists(join4(target, "dist", "docs", "plugins.md"))) {
+      await copyIfExists(join4(packageRoot, "src", "server", "docs"), join4(target, "dist", "docs"));
     }
-    if (!await copyIfExists(join3(packageRoot, "docs"), join3(target, "docs"))) {
-      await copyIfExists(join3(packageRoot, "src", "server", "docs"), join3(target, "docs"));
+    if (!await copyIfExists(join4(packageRoot, "docs"), join4(target, "docs"))) {
+      await copyIfExists(join4(packageRoot, "src", "server", "docs"), join4(target, "docs"));
     }
-    await copyIfExists(join3(packageRoot, "skills"), join3(target, "skills"));
-    await copyIfExists(join3(packageRoot, "references"), join3(target, "references"));
-    await copyIfExists(join3(packageRoot, "src", "globals.css"), join3(target, "src", "globals.css"));
+    await copyIfExists(join4(packageRoot, "skills"), join4(target, "skills"));
+    await copyIfExists(join4(packageRoot, "references"), join4(target, "references"));
+    await copyIfExists(join4(packageRoot, "src", "globals.css"), join4(target, "src", "globals.css"));
   }
 }
 async function ensurePython(workspaceRoot, specs) {
   if (specs.length === 0) return;
-  const venvPython = join3(workspaceRoot, ".boring-agent", "venv", "bin", "python");
+  const venvPython = join4(workspaceRoot, ".boring-agent", "venv", "bin", "python");
   const uv = await commandExists("uv");
   if (!await exists(venvPython)) {
     if (uv) await run("uv", ["venv", ".boring-agent/venv"], workspaceRoot);
@@ -2610,17 +2718,17 @@ function assertEnvKey(key) {
 }
 async function isRuntimeMaterialized(workspaceRoot, contributions) {
   const hasPython = contributions.some(({ provisioning }) => (provisioning.python ?? []).length > 0);
-  if (hasPython && !await exists(join3(workspaceRoot, ".boring-agent", "venv", "bin", "python"))) return false;
+  if (hasPython && !await exists(join4(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;
+      if (!await exists(join4(nodePackageTarget(workspaceRoot, spec.packageName), "package.json"))) return false;
     }
   }
   return true;
 }
 async function writeShims(workspaceRoot, env) {
-  const shimDir = join3(workspaceRoot, ".boring-agent", "bin");
-  const venvBin = join3(workspaceRoot, ".boring-agent", "venv", "bin");
+  const shimDir = join4(workspaceRoot, ".boring-agent", "bin");
+  const venvBin = join4(workspaceRoot, ".boring-agent", "venv", "bin");
   await mkdir4(shimDir, { recursive: true });
   const exports = Object.entries(env).map(([key, value]) => {
     assertEnvKey(key);
@@ -2634,21 +2742,21 @@ export BORING_AGENT_WORKSPACE_ROOT="$WORKSPACE_ROOT"
 ${exports}
 VENV_BIN="$WORKSPACE_ROOT/.boring-agent/venv/bin"
 `;
-  await writeExecutable(join3(shimDir, "python"), `${base}exec "$VENV_BIN/python" "$@"
+  await writeExecutable(join4(shimDir, "python"), `${base}exec "$VENV_BIN/python" "$@"
 `);
-  await writeExecutable(join3(shimDir, "python3"), `${base}exec "$VENV_BIN/python" "$@"
+  await writeExecutable(join4(shimDir, "python3"), `${base}exec "$VENV_BIN/python" "$@"
 `);
-  await writeExecutable(join3(shimDir, "pip"), `${base}exec "$VENV_BIN/python" -m pip "$@"
+  await writeExecutable(join4(shimDir, "pip"), `${base}exec "$VENV_BIN/python" -m pip "$@"
 `);
-  await writeExecutable(join3(shimDir, "pip3"), `${base}exec "$VENV_BIN/python" -m pip "$@"
+  await writeExecutable(join4(shimDir, "pip3"), `${base}exec "$VENV_BIN/python" -m pip "$@"
 `);
   if (await exists(venvBin)) {
-    for (const entry of await readdir2(venvBin)) {
+    for (const entry of await readdir3(venvBin)) {
       if (["python", "python3", "pip", "pip3"].includes(entry)) continue;
-      const full = join3(venvBin, entry);
+      const full = join4(venvBin, entry);
       const info = await stat4(full).catch(() => null);
       if (!info?.isFile()) continue;
-      await writeExecutable(join3(shimDir, entry), `${base}TARGET="$VENV_BIN"/${bashSingleQuote(entry)}
+      await writeExecutable(join4(shimDir, entry), `${base}TARGET="$VENV_BIN"/${bashSingleQuote(entry)}
 SHEBANG="$(head -n 1 "$TARGET" 2>/dev/null || true)"
 case "$SHEBANG" in
   *python*) exec "$VENV_BIN/python" "$TARGET" "$@" ;;
@@ -2671,8 +2779,8 @@ async function provisionRuntimeWorkspace({
   await mkdir4(workspaceRoot, { recursive: true });
   const env = collectEnv(active);
   const hash = await fingerprint(active);
-  const markerPath = join3(workspaceRoot, ".boring-agent", "provisioning.json");
-  const binDir = join3(workspaceRoot, ".boring-agent", "bin");
+  const markerPath = join4(workspaceRoot, ".boring-agent", "provisioning.json");
+  const binDir = join4(workspaceRoot, ".boring-agent", "bin");
   if (!force && await exists(markerPath)) {
     try {
       const marker = JSON.parse(await readFile4(markerPath, "utf8"));
@@ -3110,7 +3218,7 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
 // src/server/workspace/provisioning/packArtifact.ts
 import { execFile as execFile2 } from "child_process";
 import { mkdir as mkdir5, mkdtemp, rename as rename4 } from "fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute5, join as join4 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute5, join as join5 } from "path";
 import { tmpdir } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { promisify as promisify2 } from "util";
@@ -3155,7 +3263,7 @@ async function packProvisioningArtifact(request) {
     ], { maxBuffer: 1024 * 1024 * 20 });
     const packedName = stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
     if (!packedName) throw new Error(`pnpm pack produced no artifact for ${sourcePath}`);
-    const packedPath = isAbsolute5(packedName) ? packedName : join4(dirname7(request.outputPath), packedName);
+    const packedPath = isAbsolute5(packedName) ? packedName : join5(dirname7(request.outputPath), packedName);
     await rename4(packedPath, request.outputPath);
     return;
   }
@@ -3177,8 +3285,8 @@ async function resolveArtifactInstallSource(args) {
   const name = provisioningArtifactName(kind, id, fingerprint2);
   const workspaceRel = `.boring-agent/tmp/${name}`;
   if (!await args.workspaceFs.exists(workspaceRel)) {
-    const artifactDir = await mkdtemp(join4(tmpdir(), "boring-agent-artifact-"));
-    const outputPath = join4(artifactDir, name);
+    const artifactDir = await mkdtemp(join5(tmpdir(), "boring-agent-artifact-"));
+    const outputPath = join5(artifactDir, name);
     try {
       await args.prepareArtifact({ kind, id, fingerprint: fingerprint2, source: args.source, outputPath });
       await args.workspaceFs.copyFromHost(outputPath, workspaceRel);
@@ -3285,7 +3393,7 @@ function createPythonRuntimeFingerprint(input) {
 }
 
 // src/server/workspace/provisioning/node.ts
-import { join as join5, relative as relative6, sep as sep3 } from "path";
+import { join as join6, 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`;
@@ -3323,9 +3431,9 @@ function nodeInstallSource(spec) {
 }
 function expectedNodeOutputs(paths, packages) {
   return [
-    join5(paths.node, "package-lock.json"),
+    join6(paths.node, "package-lock.json"),
     ...packages.flatMap(
-      (pkg) => (pkg.expectedBins ?? []).map((bin) => join5(paths.nodeBin, bin))
+      (pkg) => (pkg.expectedBins ?? []).map((bin) => join6(paths.nodeBin, bin))
     )
   ];
 }
@@ -3416,7 +3524,7 @@ async function ensureNodeRuntime(options) {
 }
 
 // src/server/workspace/provisioning/python.ts
-import { dirname as dirname9, join as join6, relative as relative7, sep as sep4 } from "path";
+import { dirname as dirname9, join as join7, relative as relative7, sep as sep4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var VENV_REL = ".boring-agent/venv";
 var VENV_FINGERPRINT_REL = `${VENV_REL}/.fingerprint`;
@@ -3435,7 +3543,7 @@ async function ensureUv(options) {
       const uvVersion = await commandOutput2(options.adapter, explicitUvBin, ["--version"]) || "uv unknown";
       try {
         await options.adapter.exec("mkdir", ["-p", options.runtimeLayout.uvBin], { cwd: options.runtimeLayout.workspaceRoot });
-        await options.adapter.exec("ln", ["-sf", explicitUvBin, join6(options.runtimeLayout.uvBin, "uv")], { cwd: options.runtimeLayout.workspaceRoot });
+        await options.adapter.exec("ln", ["-sf", explicitUvBin, join7(options.runtimeLayout.uvBin, "uv")], { cwd: options.runtimeLayout.workspaceRoot });
       } catch {
       }
       return { uvBin: explicitUvBin, uvVersion, installedWorkspaceUv: false };
@@ -3462,7 +3570,7 @@ async function ensureUv(options) {
     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");
+    const uvBin = join7(options.runtimeLayout.uvBin, "uv");
     await options.adapter.exec("chmod", ["+x", uvBin], { cwd: options.runtimeLayout.workspaceRoot });
     return {
       uvBin,
@@ -3495,7 +3603,7 @@ function expectedPythonOutputs(paths, packages) {
   return [
     paths.venvPython,
     ...packages.flatMap(
-      (pkg) => (pkg.expectedBins ?? []).map((bin) => join6(paths.venvBin, bin))
+      (pkg) => (pkg.expectedBins ?? []).map((bin) => join7(paths.venvBin, bin))
     )
   ];
 }
@@ -3608,7 +3716,7 @@ async function ensurePythonRuntime(options) {
 
 // src/server/workspace/provisioning/skills.ts
 import { stat as stat5 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var GENERATED_SKILLS_REL = ".boring-agent/skills";
 var USER_SKILLS_REL = ".agents/skills";
@@ -3621,7 +3729,7 @@ function assertSafeSegment(kind, value) {
   }
 }
 function getProvisionedSkillPaths(paths) {
-  return [paths.skills, join7(paths.workspaceRoot, USER_SKILLS_REL)];
+  return [paths.skills, join8(paths.workspaceRoot, USER_SKILLS_REL)];
 }
 async function mirrorPluginSkills(options) {
   await options.adapter.workspaceFs.rm(GENERATED_SKILLS_REL);
@@ -3654,7 +3762,7 @@ async function mirrorPluginSkills(options) {
 // src/server/workspace/provisioning/workspaceFiles.ts
 import { basename, join as joinPath } from "path";
 import { posix as posix2 } from "path";
-import { readdir as readdir3, stat as stat6 } from "fs/promises";
+import { readdir as readdir4, stat as stat6 } from "fs/promises";
 import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
 function sourceToPath3(source) {
   return source instanceof URL ? fileURLToPath5(source) : source;
@@ -3696,7 +3804,7 @@ async function collectTemplateWorkItems(template) {
         kind: "directory"
       });
     }
-    const entries = await readdir3(dir, { withFileTypes: true });
+    const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
       const childPath = joinPath(dir, entry.name);
       const childRel = rel ? `${rel}/${entry.name}` : entry.name;
@@ -4295,8 +4403,8 @@ var localModeAdapter = {
 };
 
 // src/server/runtime/modes/vercel-sandbox.ts
-import { readFile as readFile8, readdir as readdir5, stat as stat8 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile8, readdir as readdir6, stat as stat8 } from "fs/promises";
+import { join as join9 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { Sandbox as VercelSandbox } from "@vercel/sandbox";
 
@@ -4442,20 +4550,20 @@ function createVercelSandboxExec(sandbox, execOpts = {}) {
 
 // src/server/sandbox/vercel-sandbox/packageTemplate.ts
 import { createHash as createHash5 } from "crypto";
-import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { createGzip } from "zlib";
 import { put } from "@vercel/blob";
 var urlCache = /* @__PURE__ */ new Map();
 var LOG_PREFIX = "[template-tarball]";
-function log2(msg, meta = {}) {
+function log3(msg, meta = {}) {
   const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
   process.stderr.write(`${LOG_PREFIX} ${msg}${metaStr}
 `);
 }
 async function collectFiles(dir, base = "") {
-  const entries = await readdir4(dir, { withFileTypes: true });
+  const entries = await readdir5(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = path3.join(dir, entry.name);
@@ -4532,11 +4640,11 @@ async function packageTemplate(templatePath, opts = {}) {
   const hash = computeTemplateHash(files);
   const cached = urlCache.get(hash);
   if (cached) {
-    log2("cache hit", { hash, fileCount: files.length });
+    log3("cache hit", { hash, fileCount: files.length });
     return { url: cached, hash };
   }
   const tarball = await buildTarGz(files);
-  log2("tarball built", {
+  log3("tarball built", {
     hash,
     fileCount: files.length,
     sizeBytes: tarball.length,
@@ -4545,7 +4653,7 @@ async function packageTemplate(templatePath, opts = {}) {
   const upload = opts.uploadFn ?? defaultUpload;
   const url = await upload(hash, tarball);
   urlCache.set(hash, url);
-  log2("uploaded", { hash, url, totalMs: Date.now() - startMs });
+  log3("uploaded", { hash, url, totalMs: Date.now() - startMs });
   return { url, hash };
 }
 
@@ -4711,10 +4819,10 @@ async function copyHostPathToVercelWorkspace(options) {
   const sourceStat = await stat8(sourcePath);
   if (sourceStat.isDirectory()) {
     await options.workspace.mkdir(options.targetRel, { recursive: true });
-    for (const entry of await readdir5(sourcePath, { withFileTypes: true })) {
+    for (const entry of await readdir6(sourcePath, { withFileTypes: true })) {
       await copyHostPathToVercelWorkspace({
         workspace: options.workspace,
-        source: join8(sourcePath, entry.name),
+        source: join9(sourcePath, entry.name),
         targetRel: `${options.targetRel}/${entry.name}`
       });
     }
@@ -5142,7 +5250,7 @@ function getRuntimeBundleStorageRoot(bundle) {
 
 // src/server/harness/pi-coding-agent/createHarness.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { extname as extname3, join as join10 } from "path";
+import { extname as extname3, join as join11 } from "path";
 import {
   createAgentSession,
   SessionManager,
@@ -5422,7 +5530,7 @@ function createPiAgentSessionAdapter(session, options = {}) {
 // src/server/harness/pi-coding-agent/sessions.ts
 import { randomUUID } from "crypto";
 import {
-  readdir as readdir6,
+  readdir as readdir7,
   readFile as readFile9,
   stat as fsStat,
   rm as rm4,
@@ -5433,7 +5541,7 @@ import {
   open as open2
 } from "fs/promises";
 import { closeSync, openSync, readFileSync, readSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join9, basename as basename2, resolve as resolve7 } from "path";
+import { join as join10, basename as basename2, resolve as resolve7 } from "path";
 import { homedir as homedir3 } from "os";
 import {
   parseSessionEntries,
@@ -5441,7 +5549,7 @@ import {
 } from "@mariozechner/pi-coding-agent";
 function defaultSessionDir(cwd) {
   const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return join9(homedir3(), ".pi", "agent", "sessions", safePath);
+  return join10(homedir3(), ".pi", "agent", "sessions", safePath);
 }
 var SAFE_ID = /^[a-zA-Z0-9_-]+$/;
 var SAFE_SESSION_NAMESPACE = /^[a-zA-Z0-9_-]+$/;
@@ -5451,7 +5559,7 @@ function sessionDirForNamespace(namespace) {
   if (!SAFE_SESSION_NAMESPACE.test(safeNamespace)) {
     throw new Error("session namespace must contain only letters, numbers, underscores, and dashes");
   }
-  return join9(homedir3(), ".pi", "agent", "sessions", safeNamespace);
+  return join10(homedir3(), ".pi", "agent", "sessions", safeNamespace);
 }
 function normalizeListOptions(options) {
   return {
@@ -5496,9 +5604,9 @@ var PiSessionStore = class {
     }
   }
   async listUncached(_ctx, options) {
-    const files = await readdir6(this.sessionDir).catch(() => []);
+    const files = await readdir7(this.sessionDir).catch(() => []);
     const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-    const filepaths = jsonlFiles.map((f) => join9(this.sessionDir, f));
+    const filepaths = jsonlFiles.map((f) => join10(this.sessionDir, f));
     const fileStats = await Promise.all(filepaths.map(async (filepath) => {
       try {
         return { filepath, stat: await fsStat(filepath) };
@@ -5542,7 +5650,7 @@ var PiSessionStore = class {
       };
       lines.push(JSON.stringify(infoEntry));
     }
-    const filepath = join9(this.sessionDir, `${id}.jsonl`);
+    const filepath = join10(this.sessionDir, `${id}.jsonl`);
     await writeFile6(filepath, lines.join("\n") + "\n", "utf-8");
     return {
       id,
@@ -5624,7 +5732,7 @@ var PiSessionStore = class {
   loadPiSessionFileSync(sessionId) {
     if (!SAFE_ID.test(sessionId)) return null;
     try {
-      const direct = join9(this.sessionDir, `${sessionId}.jsonl`);
+      const direct = join10(this.sessionDir, `${sessionId}.jsonl`);
       let filepath = direct;
       let content;
       try {
@@ -5634,7 +5742,7 @@ var PiSessionStore = class {
           (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
         );
         if (files.length === 0) return null;
-        filepath = join9(this.sessionDir, files[0]);
+        filepath = join10(this.sessionDir, files[0]);
         content = readFileSync(filepath, "utf-8");
       }
       const entries = safeParseEntries(content);
@@ -5690,18 +5798,18 @@ var PiSessionStore = class {
     if (!SAFE_ID.test(sessionId)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const direct = join9(this.sessionDir, `${sessionId}.jsonl`);
+    const direct = join10(this.sessionDir, `${sessionId}.jsonl`);
     try {
       await fsStat(direct);
       return direct;
     } catch {
     }
-    const files = await readdir6(this.sessionDir).catch(() => []);
+    const files = await readdir7(this.sessionDir).catch(() => []);
     const match = files.find(
       (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
     );
     if (!match) throw new Error(`Session not found: ${sessionId}`);
-    const matchedPath = join9(this.sessionDir, match);
+    const matchedPath = join10(this.sessionDir, match);
     if (!isTimestampNamedPiSessionFile(matchedPath, sessionId)) return matchedPath;
     const existingWrapper = await this.findWrapperReferencingNativeSession(matchedPath);
     if (existingWrapper) {
@@ -5866,7 +5974,7 @@ var PiSessionStore = class {
     try {
       const files = readdirSync(this.sessionDir).filter((file) => file.endsWith(".jsonl"));
       for (const file of files) {
-        const filepath = join9(this.sessionDir, file);
+        const filepath = join10(this.sessionDir, file);
         if (resolve7(filepath) === resolvedNativePath) continue;
         try {
           const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(readJsonlPrefixSync(filepath)));
@@ -5881,10 +5989,10 @@ var PiSessionStore = class {
   }
   async findWrapperReferencingNativeSession(nativePath) {
     const resolvedNativePath = resolve7(nativePath);
-    const files = await readdir6(this.sessionDir).catch(() => []);
+    const files = await readdir7(this.sessionDir).catch(() => []);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filepath = join9(this.sessionDir, file);
+      const filepath = join10(this.sessionDir, file);
       if (resolve7(filepath) === resolvedNativePath) continue;
       try {
         const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(await readJsonlPrefix(filepath)));
@@ -5895,7 +6003,7 @@ var PiSessionStore = class {
     return null;
   }
   ensureWrapperForNativeSessionSync(sessionId, nativePath, entries) {
-    const wrapperPath = join9(this.sessionDir, `${sessionId}.jsonl`);
+    const wrapperPath = join10(this.sessionDir, `${sessionId}.jsonl`);
     if (resolve7(wrapperPath) === resolve7(nativePath)) return wrapperPath;
     try {
       readFileSync(wrapperPath, "utf-8");
@@ -5915,7 +6023,7 @@ var PiSessionStore = class {
     return wrapperPath;
   }
   async ensureWrapperForNativeSession(sessionId, nativePath) {
-    const wrapperPath = join9(this.sessionDir, `${sessionId}.jsonl`);
+    const wrapperPath = join10(this.sessionDir, `${sessionId}.jsonl`);
     if (resolve7(wrapperPath) === resolve7(nativePath)) return wrapperPath;
     try {
       await fsStat(wrapperPath);
@@ -6294,6 +6402,10 @@ var PYTHON_RUNTIME_GUIDELINE = [
 function composeSystemPromptAppend(hostAppend) {
   return [WORKSPACE_PATHS_GUIDELINE, PYTHON_RUNTIME_GUIDELINE, hostAppend?.trim()].filter(Boolean).join("\n\n");
 }
+function withPiHarnessDefaults(pi) {
+  const { noContextFiles = true, noSkills = true, ...rest } = pi ?? {};
+  return { ...rest, noContextFiles, noSkills };
+}
 function buildDynamicPromptExtension(source) {
   return (pi) => {
     pi.on("before_agent_start", async (event) => {
@@ -6349,8 +6461,8 @@ function mergeInjectedProjectPackages(settingsJson, piPackages) {
 }
 function createResourceSettingsManager(cwd, agentDir, piPackages) {
   if (piPackages.length === 0) return SettingsManager2.create(cwd, agentDir);
-  const globalSettingsPath = join10(agentDir, "settings.json");
-  const projectSettingsPath = join10(cwd, ".pi", "settings.json");
+  const globalSettingsPath = join11(agentDir, "settings.json");
+  const projectSettingsPath = join11(cwd, ".pi", "settings.json");
   let globalSettingsOverrideJson;
   let projectSettingsOverrideJson;
   const storage = {
@@ -6380,7 +6492,7 @@ async function applyRequestedSessionOptions(handle, input) {
     handle.piSession.setThinkingLevel(input.thinkingLevel);
   }
 }
-var log3 = createLogger("pi-harness");
+var log4 = createLogger("pi-harness");
 function deriveSourcePlugin(sourceInfo) {
   if (!sourceInfo) return void 0;
   const path4 = typeof sourceInfo.path === "string" ? sourceInfo.path : "";
@@ -6405,6 +6517,7 @@ function normalizeSlashCommandInfo(command) {
   };
 }
 function createPiCodingAgentHarness(opts) {
+  const pi = withPiHarnessDefaults(opts.pi);
   const sessionStore = new PiSessionStore(opts.runtimeCwd ?? opts.cwd, {
     sessionNamespace: opts.sessionNamespace,
     sessionDir: opts.sessionDir,
@@ -6415,32 +6528,48 @@ function createPiCodingAgentHarness(opts) {
   const effectivePackages = [];
   const effectiveExtensionPaths = [];
   const refreshEffectiveResources = () => {
-    const dynamic = opts.pi?.getHotReloadableResources?.() ?? {};
+    const dynamic = pi.getHotReloadableResources?.() ?? {};
     effectiveSkillPaths.splice(
       0,
       effectiveSkillPaths.length,
-      ...opts.pi?.additionalSkillPaths ?? [],
+      ...pi.additionalSkillPaths ?? [],
       ...dynamic.additionalSkillPaths ?? []
     );
     effectivePackages.splice(
       0,
       effectivePackages.length,
-      ...mergePiPackageSources(opts.pi?.packages ?? [], dynamic.packages ?? [])
+      ...mergePiPackageSources(pi.packages ?? [], dynamic.packages ?? [])
     );
     effectiveExtensionPaths.splice(
       0,
       effectiveExtensionPaths.length,
-      ...opts.pi?.extensionPaths ?? [],
+      ...pi.extensionPaths ?? [],
       ...dynamic.extensionPaths ?? []
     );
   };
   refreshEffectiveResources();
+  const piSessionCreations = /* @__PURE__ */ new Map();
   async function getOrCreatePiSession(sessionId, input, ctx) {
     const existing = piSessions.get(sessionId);
     if (existing) {
       await applyRequestedSessionOptions(existing, input);
       return existing;
     }
+    const inFlight = piSessionCreations.get(sessionId);
+    if (inFlight) {
+      const handle = await inFlight;
+      await applyRequestedSessionOptions(handle, input);
+      return handle;
+    }
+    const creation = createPiSession(sessionId, input, ctx);
+    piSessionCreations.set(sessionId, creation);
+    try {
+      return await creation;
+    } finally {
+      if (piSessionCreations.get(sessionId) === creation) piSessionCreations.delete(sessionId);
+    }
+  }
+  async function createPiSession(sessionId, input, ctx) {
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     registerConfiguredModelProviders(modelRegistry);
@@ -6471,7 +6600,7 @@ function createPiCodingAgentHarness(opts) {
     const extensionFactories = [
       toolErrorResultExtension,
       ...dynamicPromptExtension ? [dynamicPromptExtension] : [],
-      ...opts.pi?.extensionFactories ?? []
+      ...pi.extensionFactories ?? []
     ];
     const settingsManager = createResourceSettingsManager(
       opts.cwd,
@@ -6485,8 +6614,8 @@ function createPiCodingAgentHarness(opts) {
       appendSystemPromptOverride: (base) => [...base, composedSystemPromptAppend],
       ...effectiveExtensionPaths.length ? { additionalExtensionPaths: effectiveExtensionPaths } : {},
       ...extensionFactories.length ? { extensionFactories } : {},
-      ...opts.pi?.noContextFiles ? { noContextFiles: true } : {},
-      ...opts.pi?.noSkills ? { noSkills: true } : {},
+      ...pi.noContextFiles ? { noContextFiles: true } : {},
+      ...pi.noSkills ? { noSkills: true } : {},
       ...effectiveSkillPaths.length ? { additionalSkillPaths: effectiveSkillPaths } : {},
       // skillsOverride REPLACES Pi's resolved skill set, which includes
       // skills contributed by host-declared pi packages (e.g.
@@ -6495,7 +6624,7 @@ function createPiCodingAgentHarness(opts) {
       // Passing additionalSkillPaths is not, by itself, a request to throw
       // away package skills — those should keep flowing through Pi's loader
       // and merge with the additional paths.
-      ...opts.pi?.noSkills ? {
+      ...pi.noSkills ? {
         skillsOverride: () => loadSkills({
           cwd: opts.cwd,
           agentDir,
@@ -6626,12 +6755,12 @@ ${entry.message}`;
 }
 
 // src/server/harness/pi-coding-agent/pluginLoader.ts
-import { readdir as readdir7, stat as stat9, readFile as readFile10 } from "fs/promises";
-import { join as join11, extname as extname4, resolve as resolve8, sep as sep6, relative as relative9 } from "path";
+import { readdir as readdir8, stat as stat9, readFile as readFile10 } from "fs/promises";
+import { join as join12, extname as extname4, resolve as resolve8, sep as sep6, relative as relative9 } from "path";
 import { homedir as homedir4 } from "os";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs"]);
-var GLOBAL_DIR = join11(homedir4(), ".pi", "agent", "extensions");
+var GLOBAL_DIR = join12(homedir4(), ".pi", "agent", "extensions");
 var LOCAL_DIR = ".pi/extensions";
 var EXTENSIONS_JSON = ".pi/extensions.json";
 async function dirExists2(path4) {
@@ -6652,8 +6781,8 @@ async function fileExists(path4) {
 }
 async function discoverFromDir(dir, source) {
   if (!await dirExists2(dir)) return [];
-  const entries = await readdir7(dir);
-  return entries.filter((e) => VALID_EXTENSIONS.has(extname4(e))).map((e) => ({ path: join11(dir, e), source }));
+  const entries = await readdir8(dir);
+  return entries.filter((e) => VALID_EXTENSIONS.has(extname4(e))).map((e) => ({ path: join12(dir, e), source }));
 }
 function extractTools(mod) {
   const tools = [];
@@ -6683,17 +6812,17 @@ async function loadModule(filePath, importFn) {
   return extractTools(mod);
 }
 async function discoverNpmPlugins(cwd) {
-  const nodeModulesDir = join11(cwd, "node_modules");
+  const nodeModulesDir = join12(cwd, "node_modules");
   if (!await dirExists2(nodeModulesDir)) return [];
   try {
-    const entries = await readdir7(nodeModulesDir);
-    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join11(nodeModulesDir, e));
+    const entries = await readdir8(nodeModulesDir);
+    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join12(nodeModulesDir, e));
   } catch {
     return [];
   }
 }
 async function loadNpmPlugin(pkgDir, importFn) {
-  const pkgJsonPath = join11(pkgDir, "package.json");
+  const pkgJsonPath = join12(pkgDir, "package.json");
   if (!await fileExists(pkgJsonPath)) return [];
   const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
   const main = pkgJson.main ?? "index.js";
@@ -6709,7 +6838,7 @@ async function loadNpmPlugin(pkgDir, importFn) {
   return loadModule(resolvedMain, importFn);
 }
 async function loadExtensionsJson(cwd) {
-  const configPath = join11(cwd, EXTENSIONS_JSON);
+  const configPath = join12(cwd, EXTENSIONS_JSON);
   if (!await fileExists(configPath)) return null;
   try {
     const raw = await readFile10(configPath, "utf-8");
@@ -6727,7 +6856,7 @@ async function loadPlugins(options) {
     const globals = await discoverFromDir(GLOBAL_DIR, "global");
     candidates.push(...globals);
   }
-  const localDir = join11(options.cwd, LOCAL_DIR);
+  const localDir = join12(options.cwd, LOCAL_DIR);
   const locals = await discoverFromDir(localDir, "local");
   candidates.push(...locals);
   const npmDirs = await discoverNpmPlugins(options.cwd);
@@ -6737,7 +6866,7 @@ async function loadPlugins(options) {
   const config = await loadExtensionsJson(options.cwd);
   if (config?.npm) {
     for (const pkg of config.npm) {
-      const pkgDir = join11(options.cwd, "node_modules", pkg);
+      const pkgDir = join12(options.cwd, "node_modules", pkg);
       if (await dirExists2(pkgDir)) {
         const already = candidates.some((c) => c.path === pkgDir);
         if (!already) {
@@ -6786,8 +6915,8 @@ import {
 
 // src/server/tools/operations/bound.ts
 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 stat10, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute7, join as join12, relative as relative10, resolve as resolve9 } from "path";
+import { access as access4, lstat as lstat4, mkdir as mkdir12, readFile as readFile11, readdir as readdir9, readlink, realpath as realpath4, stat as stat10, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname11, isAbsolute as isAbsolute7, join as join13, relative as relative10, resolve as resolve9 } from "path";
 function toPosixPath(value) {
   return value.split("\\").join("/");
 }
@@ -6840,7 +6969,7 @@ function shouldSkipDir(relativePath, ignore) {
 }
 async function walkMatches(root, current, pattern, ignore, limit, out) {
   if (out.length >= limit) return;
-  const entries = await readdir8(current, { withFileTypes: true });
+  const entries = await readdir9(current, { withFileTypes: true });
   for (const entry of entries) {
     if (out.length >= limit) return;
     const absolutePath = resolve9(current, entry.name);
@@ -6918,7 +7047,7 @@ function boundFs(workspaceRoot, opts = {}) {
     const normalized = toPosixPath(absolutePath);
     if (normalized === runtimeRoot) return workspaceRoot;
     if (normalized.startsWith(`${runtimeRoot}/`)) {
-      return join12(workspaceRoot, ...normalized.slice(runtimeRoot.length + 1).split("/"));
+      return join13(workspaceRoot, ...normalized.slice(runtimeRoot.length + 1).split("/"));
     }
     return absolutePath;
   };
@@ -7022,7 +7151,7 @@ function boundFs(workspaceRoot, opts = {}) {
     async readdir(absolutePath) {
       const storagePath = toStoragePath(absolutePath);
       await assertWithinWorkspace(workspaceRoot, storagePath);
-      return await readdir8(storagePath);
+      return await readdir9(storagePath);
     }
   };
   return { read, write, edit, find, grep, ls };
@@ -7588,7 +7717,8 @@ function directSpawnHook(workspaceRoot, runtime) {
     ...context,
     env: withWorkspacePythonEnv({
       workspaceRoot,
-      env: mergeRuntimeEnv(runtime, context.env)
+      env: mergeRuntimeEnv(runtime, context.env),
+      preserveHostHome: true
     })
   });
 }
@@ -7855,11 +7985,20 @@ function fsEventsRoutes(app, opts, done) {
   const ensureBroadcaster = async (request) => {
     const workspace = opts.getWorkspace ? await opts.getWorkspace(request) : opts.workspace;
     if (!workspace) throw new Error("fs event route requires workspace or getWorkspace");
-    if (typeof workspace.watch !== "function") return null;
+    if (typeof workspace.watch !== "function") {
+      return { unsupported: { reason: "watch_not_implemented" } };
+    }
     const workspaceId = request.workspaceContext?.workspaceId ?? "default";
     const existing = broadcasters.get(workspaceId);
     if (existing) return { workspaceId, entry: existing };
-    const broadcaster = createFsEventBroadcaster(workspace.watch());
+    const watcher = workspace.watch();
+    const readiness = await watcher.whenReady?.() ?? { ok: true };
+    if (!readiness.ok) {
+      return { unsupported: { reason: readiness.reason, ...readiness.message ? { message: readiness.message } : {} } };
+    }
+    const existingAfterWait = broadcasters.get(workspaceId);
+    if (existingAfterWait) return { workspaceId, entry: existingAfterWait };
+    const broadcaster = createFsEventBroadcaster(watcher);
     const entry = { broadcaster, subscribers: 0 };
     broadcasters.set(workspaceId, entry);
     return { workspaceId, entry };
@@ -7879,8 +8018,8 @@ function fsEventsRoutes(app, opts, done) {
     const resolved = await ensureBroadcaster(request);
     reply.hijack();
     setupSse(request, reply.raw);
-    if (!resolved) {
-      writeSse(reply.raw, "unsupported", { reason: "watch_not_implemented" });
+    if ("unsupported" in resolved) {
+      writeSse(reply.raw, "unsupported", resolved.unsupported);
       reply.raw.end();
       return;
     }
@@ -7990,7 +8129,7 @@ async function listTree(workspace, dir, recursive) {
       if (entries.length >= MAX_ENTRIES) break;
       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) {
+      if (recursive && e.kind === "dir" && batch.depth < MAX_DEPTH && !isIgnoredDirName(e.name)) {
         try {
           const subEntries = await workspace.readdir(entryPath);
           queue.push({ parentDir: entryPath, items: subEntries, depth: batch.depth + 1 });
@@ -8106,8 +8245,8 @@ function skillsRoutes(app, opts, done) {
       const workspaceRoot = opts.getWorkspaceRoot ? await opts.getWorkspaceRoot(request) : opts.workspaceRoot;
       const additionalSkillPaths = opts.getAdditionalSkillPaths ? await opts.getAdditionalSkillPaths(request) : opts.additionalSkillPaths;
       const piPackages = opts.getPiPackages ? await opts.getPiPackages(request) : opts.piPackages;
-      const noSkills = opts.getNoSkills ? await opts.getNoSkills(request) : opts.noSkills;
-      const cacheKey = JSON.stringify([workspaceRoot, additionalSkillPaths ?? [], piPackages ?? [], Boolean(noSkills)]);
+      const noSkills = (opts.getNoSkills ? await opts.getNoSkills(request) : opts.noSkills) ?? withPiHarnessDefaults().noSkills;
+      const cacheKey = JSON.stringify([workspaceRoot, additionalSkillPaths ?? [], piPackages ?? [], noSkills]);
       const now = Date.now();
       for (const [key, entry] of cached) {
         if (entry.expiresAt <= now) cached.delete(key);
@@ -8136,7 +8275,7 @@ function skillsRoutes(app, opts, done) {
         cwd: workspaceRoot,
         agentDir,
         skillPaths: [...packageSkillPaths, ...additionalSkillPaths ?? []],
-        includeDefaults: false
+        includeDefaults: !noSkills
       });
       const skills = result.skills.map((s) => ({
         name: s.name,
@@ -10089,6 +10228,11 @@ var HarnessPiChatService = class {
   sessionStore;
   workdir;
   channels = /* @__PURE__ */ new Map();
+  // Single-flight guard so concurrent cold callers (e.g. two browser tabs each
+  // opening /events while the session is still being created) converge on one
+  // LiveSessionChannel instead of racing through ensureChannel and orphaning
+  // the loser's adapter subscription.
+  channelCreations = /* @__PURE__ */ new Map();
   messageMetadata = new PiChatMessageMetadataReconciler();
   activePromptRuns = /* @__PURE__ */ new Map();
   syntheticPromptFailures = /* @__PURE__ */ new Map();
@@ -10348,10 +10492,38 @@ var HarnessPiChatService = class {
   async getChannel(ctx, sessionId) {
     const existing = this.channels.get(sessionId);
     if (existing) return existing;
-    const adapter = await this.getAdapter(ctx, sessionId, "");
-    return this.ensureChannel(ctx, sessionId, adapter);
+    return this.createChannelOnce(sessionId, () => this.getAdapter(ctx, sessionId, ""));
   }
   async ensureChannel(ctx, sessionId, adapter) {
+    const existing = this.channels.get(sessionId);
+    if (existing) return existing;
+    return this.createChannelOnce(sessionId, async () => adapter);
+  }
+  /**
+   * Resolve (or create) the single LiveSessionChannel for a session, coalescing
+   * concurrent cold callers onto one in-flight creation. Without this guard two
+   * tabs opening /events on a not-yet-live session both fall through the channel
+   * cache miss, build separate channels + adapter subscriptions, and the second
+   * `this.channels.set` orphans the first — so the first tab's stream silently
+   * stops receiving events.
+   */
+  async createChannelOnce(sessionId, resolveAdapter) {
+    const inFlight = this.channelCreations.get(sessionId);
+    if (inFlight) return inFlight;
+    const creation = (async () => {
+      const existing = this.channels.get(sessionId);
+      if (existing) return existing;
+      const adapter = await resolveAdapter();
+      return this.buildChannel(sessionId, adapter);
+    })();
+    this.channelCreations.set(sessionId, creation);
+    try {
+      return await creation;
+    } finally {
+      if (this.channelCreations.get(sessionId) === creation) this.channelCreations.delete(sessionId);
+    }
+  }
+  buildChannel(sessionId, adapter) {
     const existing = this.channels.get(sessionId);
     if (existing) return existing;
     const buffer = new PiChatReplayBuffer();
@@ -10516,7 +10688,7 @@ async function createAgentApp(opts = {}) {
   }
   const getRuntimeProvisioning = opts.getRuntimeProvisioning ?? (() => opts.runtimeProvisioning);
   const runtimePi = {
-    ...opts.pi,
+    ...withPiHarnessDefaults(opts.pi),
     additionalSkillPaths: [
       ...getRuntimeProvisioning()?.skillPaths ?? [],
       ...opts.pi?.additionalSkillPaths ?? []
@@ -10544,11 +10716,7 @@ async function createAgentApp(opts = {}) {
   ];
   const harnessFactory = opts.harnessFactory ?? ((input) => createPiCodingAgentHarness({
     ...input,
-    pi: {
-      noContextFiles: true,
-      noSkills: true,
-      ...runtimePi
-    }
+    pi: runtimePi
   }));
   const harness = await harnessFactory({
     tools,
@@ -10684,7 +10852,7 @@ function mergeTools(options) {
 
 // src/server/tools/upload/index.ts
 import { readFile as readFile12 } from "fs/promises";
-import { extname as extname5, join as join13 } from "path";
+import { extname as extname5, join as join14 } from "path";
 var DEFAULT_UPLOAD_DIR = "assets/images";
 var MAX_UPLOAD_BYTES2 = 10 * 1024 * 1024;
 function contentTypeFromExt(path4) {
@@ -10753,7 +10921,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 = workspace.readBinaryFile ? Buffer.from(await workspace.readBinaryFile(filePath)) : await readFile12(join13(storageRoot, filePath));
+          const bytes = workspace.readBinaryFile ? Buffer.from(await workspace.readBinaryFile(filePath)) : await readFile12(join14(storageRoot, 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` }],
@@ -10916,10 +11084,13 @@ var registerAgentRoutes = async (app, opts) => {
       runtimeBindings.delete(keys[i]);
     }
   }
+  async function resolveScopePi(workspaceId, root, request) {
+    return withPiHarnessDefaults(opts.getPi ? await opts.getPi({ workspaceId, workspaceRoot: root, request }) : opts.pi);
+  }
   async function resolveRuntimeScope(workspaceId, request) {
     const root = request && opts.getWorkspaceRoot ? await opts.getWorkspaceRoot(workspaceId, request) : workspaceRoot;
     const scopedTemplatePath = opts.getTemplatePath ? await opts.getTemplatePath({ workspaceId, workspaceRoot: root, request }) : templatePath;
-    const pi = opts.getPi ? await opts.getPi({ workspaceId, workspaceRoot: root, request }) : opts.pi;
+    const pi = await resolveScopePi(workspaceId, root, request);
     const sessionNamespace = normalizeSessionNamespace(opts.getSessionNamespace ? await opts.getSessionNamespace({ workspaceId, workspaceRoot: root, request }) : opts.sessionNamespace);
     return {
       root,
@@ -10931,29 +11102,29 @@ var registerAgentRoutes = async (app, opts) => {
         workspaceId,
         root,
         scopedTemplatePath ?? null,
-        pi ?? null,
+        pi,
         sessionNamespace ?? null
       ])
     };
   }
   async function resolveSkillScope(workspaceId, request) {
     const root = request && opts.getWorkspaceRoot ? await opts.getWorkspaceRoot(workspaceId, request) : workspaceRoot;
-    const pi = opts.getPi ? await opts.getPi({ workspaceId, workspaceRoot: root, request }) : opts.pi;
-    const hot = pi?.getHotReloadableResources?.();
+    const pi = await resolveScopePi(workspaceId, root, request);
+    const hot = pi.getHotReloadableResources?.();
     return {
       root,
       pi: hot ? {
         ...pi,
         additionalSkillPaths: [
-          ...pi?.additionalSkillPaths ?? [],
+          ...pi.additionalSkillPaths ?? [],
           ...hot.additionalSkillPaths ?? []
         ],
         packages: [
-          ...pi?.packages ?? [],
+          ...pi.packages ?? [],
           ...hot.packages ?? []
         ],
         extensionPaths: [
-          ...pi?.extensionPaths ?? [],
+          ...pi.extensionPaths ?? [],
           ...hot.extensionPaths ?? []
         ]
       } : pi
@@ -11130,14 +11301,13 @@ var registerAgentRoutes = async (app, opts) => {
     const harnessFactory = opts.harnessFactory ?? ((input) => createPiCodingAgentHarness({
       ...input,
       pi: {
-        noContextFiles: true,
-        noSkills: true,
+        // scope.pi is already defaulted at the resolveScopePi chokepoint.
         ...scope.pi,
         additionalSkillPaths: [
-          ...scope.pi?.additionalSkillPaths ?? []
+          ...scope.pi.additionalSkillPaths ?? []
         ],
         getHotReloadableResources: () => {
-          const hot = scope.pi?.getHotReloadableResources?.() ?? {};
+          const hot = scope.pi.getHotReloadableResources?.() ?? {};
           return {
             ...hot,
             additionalSkillPaths: [
@@ -11381,19 +11551,21 @@ var registerAgentRoutes = async (app, opts) => {
       ...opts.pi?.additionalSkillPaths ?? []
     ],
     piPackages: opts.pi?.packages,
+    // Undefined is fine: skillsRoutes resolves it through the canonical
+    // harness policy (withPiHarnessDefaults), same as the factory above.
     noSkills: opts.pi?.noSkills,
     getWorkspaceRoot: staticBinding ? void 0 : async (request) => (await getSkillsScopeForRequest(request)).root,
     getAdditionalSkillPaths: staticBinding && !hasRuntimeProvisioningInput ? void 0 : async (request) => {
       const scope = await getSkillsScopeForRequest(request);
-      if (!hasRuntimeProvisioningInput) return scope.pi?.additionalSkillPaths;
+      if (!hasRuntimeProvisioningInput) return scope.pi.additionalSkillPaths;
       const binding = await getBindingForRequest(request);
       return [
         ...binding.runtimeProvisioning?.skillPaths ?? [],
-        ...scope.pi?.additionalSkillPaths ?? []
+        ...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
+    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) => {