@hachej/boring-agent 0.1.30 → 0.1.32

package/dist/server/index.js

@@ -3,6 +3,10 @@ import {
   safeCapture,
   validateTool
 } from "../chunk-HDOSWEXG.js";
+import {
+  dropEmptyAssistantUiMessages,
+  sanitizeUiMessages
+} from "../chunk-IDRC4SFU.js";
 import {
   ErrorCode
 } from "../chunk-UBWQ5LT4.js";
@@ -100,23 +104,23 @@ function withWorkspacePythonEnv(opts) {
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_OUTPUT_BYTES = 1048576;
 var TERMINATION_GRACE_MS = 5e3;
-function appendOutput(chunks, chunk2, state, onChunk) {
+function appendOutput(chunks, chunk3, state, onChunk) {
   const remaining = state.maxBytes - state.capturedBytes;
   if (remaining <= 0) {
     state.truncated = true;
     return;
   }
-  if (chunk2.length > remaining) {
-    const partial = chunk2.subarray(0, remaining);
+  if (chunk3.length > remaining) {
+    const partial = chunk3.subarray(0, remaining);
     chunks.push(partial);
     state.capturedBytes += remaining;
     state.truncated = true;
     onChunk?.(new Uint8Array(partial));
     return;
   }
-  chunks.push(chunk2);
-  state.capturedBytes += chunk2.length;
-  onChunk?.(new Uint8Array(chunk2));
+  chunks.push(chunk3);
+  state.capturedBytes += chunk3.length;
+  onChunk?.(new Uint8Array(chunk3));
 }
 function terminateProcess(child, signal) {
   const pid = child.pid;
@@ -157,7 +161,7 @@ function createDirectSandbox(opts = {}) {
       const maxOutputBytes = opts2?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
       const workspaceRoot = runtimeContext.runtimeCwd;
       const cwd = opts2?.cwd ?? workspaceRoot;
-      return await new Promise((resolve10, reject) => {
+      return await new Promise((resolve11, reject) => {
         const child = spawn(cmd, {
           cwd,
           env: withWorkspacePythonEnv({ workspaceRoot, env: opts2?.env }),
@@ -186,7 +190,7 @@ function createDirectSandbox(opts = {}) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve10({
+          resolve11({
             stdout: new Uint8Array(Buffer.concat(stdoutChunks)),
             stderr: new Uint8Array(Buffer.concat(stderrChunks)),
             exitCode: typeof exitCode === "number" ? exitCode : timedOut ? 124 : 1,
@@ -196,11 +200,11 @@ function createDirectSandbox(opts = {}) {
             stderrEncoding: "utf-8"
           });
         };
-        child.stdout?.on("data", (chunk2) => {
-          appendOutput(stdoutChunks, chunk2, captureState, opts2?.onStdout);
+        child.stdout?.on("data", (chunk3) => {
+          appendOutput(stdoutChunks, chunk3, captureState, opts2?.onStdout);
         });
-        child.stderr?.on("data", (chunk2) => {
-          appendOutput(stderrChunks, chunk2, captureState, opts2?.onStderr);
+        child.stderr?.on("data", (chunk3) => {
+          appendOutput(stderrChunks, chunk3, captureState, opts2?.onStderr);
         });
         child.on("error", (error) => {
           if (settled) return;
@@ -625,23 +629,23 @@ function createNodeWorkspace(root, opts = {}) {
 var DEFAULT_TIMEOUT_MS2 = BWRAP_TIMEOUT_SECONDS * 1e3;
 var DEFAULT_MAX_OUTPUT_BYTES2 = 1048576;
 var SANDBOX_HOME2 = "/workspace";
-function appendOutput2(chunks, chunk2, state, onChunk) {
+function appendOutput2(chunks, chunk3, state, onChunk) {
   const remaining = state.maxBytes - state.capturedBytes;
   if (remaining <= 0) {
     state.truncated = true;
     return;
   }
-  if (chunk2.length > remaining) {
-    const partial = chunk2.subarray(0, remaining);
+  if (chunk3.length > remaining) {
+    const partial = chunk3.subarray(0, remaining);
     chunks.push(partial);
     state.capturedBytes += remaining;
     state.truncated = true;
     onChunk?.(new Uint8Array(partial));
     return;
   }
-  chunks.push(chunk2);
-  state.capturedBytes += chunk2.length;
-  onChunk?.(new Uint8Array(chunk2));
+  chunks.push(chunk3);
+  state.capturedBytes += chunk3.length;
+  onChunk?.(new Uint8Array(chunk3));
 }
 function terminateProcess2(child, signal) {
   const pid = child.pid;
@@ -788,7 +792,7 @@ function createBwrapSandbox(opts = {}) {
         "-c",
         cmd
       ];
-      return await new Promise((resolve10, reject) => {
+      return await new Promise((resolve11, reject) => {
         const child = spawn2("bwrap", args, {
           env: {
             ...withWorkspacePythonEnv({ workspaceRoot, env: opts2?.env, sandboxRoot: SANDBOX_HOME2 }),
@@ -818,7 +822,7 @@ function createBwrapSandbox(opts = {}) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve10({
+          resolve11({
             stdout: new Uint8Array(Buffer.concat(stdoutChunks)),
             stderr: new Uint8Array(Buffer.concat(stderrChunks)),
             exitCode: typeof exitCode === "number" ? exitCode : timedOut ? 124 : 1,
@@ -828,11 +832,11 @@ function createBwrapSandbox(opts = {}) {
             stderrEncoding: "utf-8"
           });
         };
-        child.stdout?.on("data", (chunk2) => {
-          appendOutput2(stdoutChunks, chunk2, captureState, opts2?.onStdout);
+        child.stdout?.on("data", (chunk3) => {
+          appendOutput2(stdoutChunks, chunk3, captureState, opts2?.onStdout);
         });
-        child.stderr?.on("data", (chunk2) => {
-          appendOutput2(stderrChunks, chunk2, captureState, opts2?.onStderr);
+        child.stderr?.on("data", (chunk3) => {
+          appendOutput2(stderrChunks, chunk3, captureState, opts2?.onStderr);
         });
         child.on("error", (error) => {
           if (settled) return;
@@ -1618,7 +1622,7 @@ async function prepareVercelDeploymentSnapshot(opts) {
 }
 
 // src/server/http/routes/file.ts
-import { dirname as dirname5, extname, relative as relative4 } from "path/posix";
+import { dirname as dirname5, extname as extname2, relative as relative4 } from "path/posix";
 
 // src/server/http/middleware.ts
 var ERROR_CODE_AUTH_REQUIRED = "auth_required";
@@ -1783,6 +1787,211 @@ function createLogger(prefix) {
   };
 }
 
+// src/server/http/routes/fileRecords.ts
+import { extname } from "path/posix";
+var MAX_RECORD_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_RECORD_ROWS_SCANNED = 1e4;
+var MAX_RECORD_ROWS_RETURNED = 100;
+var DEFAULT_RECORD_ROWS_RETURNED = 50;
+var MAX_RECORD_OUTPUT_BYTES = 512 * 1024;
+var MAX_RECORD_QUERY_LENGTH = 256;
+var MAX_RECORD_COLUMNS = 100;
+var MAX_RECORD_COLUMN_SAMPLE_ROWS = 100;
+var FileRecordsValidationError = class extends Error {
+  field;
+  constructor(message, field) {
+    super(message);
+    this.name = "FileRecordsValidationError";
+    this.field = field;
+  }
+};
+function firstQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function requireStringQueryParam(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new FileRecordsValidationError(`${field} is required`, field);
+  }
+  if (value.includes("\0")) {
+    throw new FileRecordsValidationError("null bytes not allowed", field);
+  }
+  return value;
+}
+function parseNonNegativeInteger(value, field, fallback, max = MAX_RECORD_ROWS_SCANNED) {
+  const raw = firstQueryValue(value);
+  if (raw === void 0) return fallback;
+  const text = typeof raw === "number" ? String(raw) : typeof raw === "string" ? raw.trim() : "";
+  if (!/^\d+$/.test(text)) {
+    throw new FileRecordsValidationError(`${field} must be a non-negative integer`, field);
+  }
+  const parsed = Number(text);
+  if (!Number.isSafeInteger(parsed) || parsed > max) {
+    throw new FileRecordsValidationError(`${field} is too large`, field);
+  }
+  return parsed;
+}
+function parseLimit(value) {
+  const raw = firstQueryValue(value);
+  if (raw === void 0) return DEFAULT_RECORD_ROWS_RETURNED;
+  const text = typeof raw === "number" ? String(raw) : typeof raw === "string" ? raw.trim() : "";
+  if (!/^\d+$/.test(text) || Number(text) < 1) {
+    throw new FileRecordsValidationError("limit must be a positive integer", "limit");
+  }
+  return Math.min(Number(text), MAX_RECORD_ROWS_RETURNED);
+}
+function parseFileRecordsRequest(query) {
+  const path4 = requireStringQueryParam(firstQueryValue(query.path), "path");
+  const recordSet = firstQueryValue(query.recordSet);
+  if (recordSet !== void 0 && String(recordSet).trim() !== "") {
+    throw new FileRecordsValidationError("recordSet is not supported for file records in v1", "recordSet");
+  }
+  const offset = parseNonNegativeInteger(query.offset, "offset", 0);
+  const limit = parseLimit(query.limit);
+  const rawQ = firstQueryValue(query.q);
+  const q = typeof rawQ === "string" ? rawQ.trim() : rawQ === void 0 ? "" : String(rawQ).trim();
+  if (q.length > MAX_RECORD_QUERY_LENGTH) {
+    throw new FileRecordsValidationError("q is too long", "q");
+  }
+  return { path: path4, offset, limit, q: q ? q.toLowerCase() : null };
+}
+function detectRecordsFormat(path4, content) {
+  const ext = extname(path4).toLowerCase();
+  if (ext === ".ndjson" || ext === ".jsonl") return "ndjson";
+  if (ext === ".csv") return "csv";
+  if (ext === ".json") return "json-array";
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("[")) return "json-array";
+  if (trimmed.startsWith("{")) return "ndjson";
+  return null;
+}
+function normalizeRecord(row) {
+  if (row && typeof row === "object" && !Array.isArray(row)) return row;
+  return { value: row };
+}
+function scalarMatches(value, q) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return false;
+  return String(value).toLowerCase().includes(q);
+}
+function recordMatches(record, q) {
+  if (!q) return true;
+  return Object.values(record).some((value) => scalarMatches(value, q));
+}
+function inferValueType(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function inferColumns(rows) {
+  const typesByName = /* @__PURE__ */ new Map();
+  for (const row of rows.slice(0, MAX_RECORD_COLUMN_SAMPLE_ROWS)) {
+    for (const [name, value] of Object.entries(row)) {
+      if (!typesByName.has(name)) {
+        if (typesByName.size >= MAX_RECORD_COLUMNS) continue;
+        typesByName.set(name, /* @__PURE__ */ new Set());
+      }
+      typesByName.get(name)?.add(inferValueType(value));
+    }
+  }
+  return [...typesByName.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, types]) => ({ name, type: types.size === 1 ? [...types][0] ?? "unknown" : "mixed" }));
+}
+function parseJsonArrayRecords(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new FileRecordsValidationError("malformed JSON records file");
+  }
+  if (!Array.isArray(parsed)) throw new FileRecordsValidationError("JSON records file must contain an array");
+  if (parsed.length > MAX_RECORD_ROWS_SCANNED) throw new FileRecordsValidationError("record scan limit exceeded");
+  return parsed.map(normalizeRecord);
+}
+function parseNdjsonRecords(content) {
+  const rows = [];
+  for (const line of content.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    if (rows.length >= MAX_RECORD_ROWS_SCANNED) throw new FileRecordsValidationError("record scan limit exceeded");
+    try {
+      rows.push(normalizeRecord(JSON.parse(line)));
+    } catch {
+      throw new FileRecordsValidationError("malformed NDJSON records file");
+    }
+  }
+  return rows;
+}
+function parseCsvRows(content) {
+  const rows = [];
+  let row = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    if (char === '"') {
+      if (quoted && content[i + 1] === '"') {
+        current += '"';
+        i += 1;
+      } else {
+        quoted = !quoted;
+      }
+      continue;
+    }
+    if (char === "," && !quoted) {
+      row.push(current);
+      current = "";
+      continue;
+    }
+    if ((char === "\n" || char === "\r") && !quoted) {
+      if (char === "\r" && content[i + 1] === "\n") i += 1;
+      row.push(current);
+      if (row.some((value) => value.length > 0)) rows.push(row);
+      row = [];
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (quoted) throw new FileRecordsValidationError("malformed CSV records file");
+  row.push(current);
+  if (row.some((value) => value.length > 0)) rows.push(row);
+  return rows;
+}
+function parseCsvRecords(content) {
+  const parsedRows = parseCsvRows(content);
+  if (parsedRows.length === 0) return [];
+  const headers = (parsedRows[0] ?? []).map((header) => header.trim());
+  if (headers.some((header) => !header)) throw new FileRecordsValidationError("CSV records file must have a non-empty header row");
+  const rows = [];
+  for (const values of parsedRows.slice(1)) {
+    if (rows.length >= MAX_RECORD_ROWS_SCANNED) throw new FileRecordsValidationError("record scan limit exceeded");
+    const row = {};
+    for (const [index, header] of headers.entries()) row[header] = values[index] ?? "";
+    rows.push(row);
+  }
+  return rows;
+}
+function buildFileRecordsResult(args) {
+  const format = detectRecordsFormat(args.path, args.content);
+  if (!format) throw new FileRecordsValidationError("unsupported records file format");
+  const allRows = format === "json-array" ? parseJsonArrayRecords(args.content) : format === "ndjson" ? parseNdjsonRecords(args.content) : parseCsvRecords(args.content);
+  const matching = allRows.filter((row) => recordMatches(row, args.q));
+  const rows = matching.slice(args.offset, args.offset + args.limit);
+  const result = {
+    source: { kind: "file", path: args.path, format },
+    path: args.path,
+    format,
+    columns: inferColumns(matching),
+    rows,
+    total: matching.length,
+    hasMore: args.offset + rows.length < matching.length,
+    offset: args.offset,
+    limit: args.limit,
+    mtimeMs: args.mtimeMs
+  };
+  if (Buffer.byteLength(JSON.stringify(result), "utf8") > MAX_RECORD_OUTPUT_BYTES) {
+    throw new FileRecordsValidationError("record output limit exceeded");
+  }
+  return result;
+}
+
 // src/server/http/routes/file.ts
 var log = createLogger("boring/workspace-settings");
 var BORING_SETTINGS_PATH = ".boring/settings";
@@ -1881,7 +2090,7 @@ function normalizeUploadDir(value) {
   return dir.replace(/\/+$/, "");
 }
 function extForUpload(filename, contentType) {
-  const fromName = extname(filename).toLowerCase().replace(/^\./, "");
+  const fromName = extname2(filename).toLowerCase().replace(/^\./, "");
   if (/^[a-z0-9]{1,12}$/.test(fromName)) return fromName;
   if (contentType === "image/jpeg") return "jpg";
   if (contentType === "image/png") return "png";
@@ -1903,7 +2112,7 @@ function markdownUrlFor(sourcePath, assetPath) {
   return rel && !rel.startsWith(".") ? rel : rel || assetPath;
 }
 function contentTypeForPath(path4) {
-  switch (extname(path4).toLowerCase()) {
+  switch (extname2(path4).toLowerCase()) {
     case ".avif":
       return "image/avif";
     case ".gif":
@@ -1932,6 +2141,11 @@ function contentTypeForPath(path4) {
       return "application/octet-stream";
   }
 }
+function sendValidationError(reply, message, field) {
+  return reply.code(400).send({
+    error: { code: ERROR_CODE_VALIDATION_ERROR, message, ...field ? { field } : {} }
+  });
+}
 function fileRoutes(app, opts, done) {
   async function resolveWorkspace(request) {
     if (opts.getWorkspace) return await opts.getWorkspace(request);
@@ -1961,6 +2175,36 @@ function fileRoutes(app, opts, done) {
       return classifyError(err, reply, "file");
     }
   });
+  app.get("/api/v1/files/records", async (request, reply) => {
+    try {
+      const parsed = parseFileRecordsRequest(request.query);
+      const workspace = await resolveWorkspace(request);
+      const stat11 = await workspace.stat(parsed.path);
+      if (stat11.kind !== "file") {
+        return sendValidationError(reply, "path is not a file", "path");
+      }
+      if (stat11.size > MAX_RECORD_FILE_BYTES) {
+        return sendValidationError(reply, "records file is too large", "path");
+      }
+      const content = await workspace.readFile(parsed.path);
+      if (Buffer.byteLength(content, "utf8") > MAX_RECORD_FILE_BYTES) {
+        return sendValidationError(reply, "records file is too large", "path");
+      }
+      return buildFileRecordsResult({
+        path: parsed.path,
+        content,
+        mtimeMs: stat11.mtimeMs,
+        offset: parsed.offset,
+        limit: parsed.limit,
+        q: parsed.q
+      });
+    } catch (err) {
+      if (err instanceof FileRecordsValidationError) {
+        return sendValidationError(reply, err.message, err.field);
+      }
+      return classifyError(err, reply, "file");
+    }
+  });
   app.get("/api/v1/files", async (request, reply) => {
     const query = request.query;
     const path4 = requireStringParam(query.path, "path", reply);
@@ -2874,10 +3118,13 @@ function createVercelSandboxWorkspace(sandbox, workspaceOpts = {}) {
   };
 }
 
-// src/server/sandbox/vercel-sandbox/provisioningAdapter.ts
-import { mkdtemp } from "fs/promises";
-import { join as join4 } from "path";
+// 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 { tmpdir } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { promisify as promisify2 } from "util";
 
 // src/server/workspace/provisioning/errors.ts
 var ProvisioningError = class extends Error {
@@ -2904,17 +3151,62 @@ 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";
+// src/server/workspace/provisioning/packArtifact.ts
+var execFileAsync2 = promisify2(execFile2);
+async function packProvisioningArtifact(request) {
+  const sourcePath = request.source instanceof URL ? fileURLToPath2(request.source) : request.source;
+  await mkdir5(dirname7(request.outputPath), { recursive: true });
+  if (request.kind === "node") {
+    const { stdout } = await execFileAsync2("pnpm", [
+      "--dir",
+      sourcePath,
+      "pack",
+      "--pack-destination",
+      dirname7(request.outputPath)
+    ], { 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);
+    await rename4(packedPath, request.outputPath);
+    return;
+  }
+  await execFileAsync2("tar", ["-czf", request.outputPath, "-C", sourcePath, "."], {
+    maxBuffer: 1024 * 1024 * 20
+  });
+}
 function artifactExtension(kind) {
   return kind === "node" ? ".tgz" : ".tar.gz";
 }
-function artifactName(kind, id, fingerprint2) {
+function provisioningArtifactName(kind, id, fingerprint2) {
   const safeId = id.replace(/[^A-Za-z0-9._-]/g, "-");
   const safeFingerprint = fingerprint2.replace(/^sha256:/, "");
   const formatVersion = kind === "node" ? "pnpm-pack-v2" : "v1";
   return `${safeId}-${formatVersion}-${safeFingerprint}${artifactExtension(kind)}`;
 }
+async function resolveArtifactInstallSource(args) {
+  const { kind, id, fingerprint: fingerprint2 } = args.opts;
+  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);
+    try {
+      await args.prepareArtifact({ kind, id, fingerprint: fingerprint2, source: args.source, outputPath });
+      await args.workspaceFs.copyFromHost(outputPath, workspaceRel);
+    } catch (error) {
+      throw toProvisioningError(
+        ErrorCode.enum.PROVISIONING_ARTIFACT_FAILED,
+        "adapter-artifact",
+        error,
+        { runtime: kind, id, artifact: workspaceRel }
+      );
+    }
+  }
+  return `${args.runtimeTmpDir}/${name}`;
+}
+
+// src/server/sandbox/vercel-sandbox/provisioningAdapter.ts
+var VERCEL_PROVISIONING_CACHE_ROOT = "/tmp/boring-agent-cache";
 function createVercelProvisioningAdapter(options) {
   return {
     mode: "vercel-sandbox",
@@ -2926,31 +3218,13 @@ function createVercelProvisioningAdapter(options) {
       });
     },
     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;
+      return await resolveArtifactInstallSource({
+        workspaceFs: options.workspaceFs,
+        prepareArtifact: options.prepareArtifact,
+        runtimeTmpDir: options.runtimeLayout.tmp,
+        source,
+        opts
+      });
     },
     workspaceFs: options.workspaceFs,
     getRuntimeCacheRoot() {
@@ -2962,8 +3236,8 @@ function createVercelProvisioningAdapter(options) {
 // 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 as rm2 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { access as access3, mkdir as mkdir6, open, readFile as readFile5, rename as rename5, rm as rm2 } from "fs/promises";
+import { dirname as dirname8 } from "path";
 var FINGERPRINT_RE = /^sha256:[a-f0-9]{64}$/;
 function isValidFingerprint(value) {
   return FINGERPRINT_RE.test(value.trim());
@@ -3153,13 +3427,13 @@ async function ensureNodeRuntime(options) {
 }
 
 // src/server/workspace/provisioning/python.ts
-import { dirname as dirname8, join as join6, relative as relative7, sep as sep4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname9, join as join6, 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`;
 var UV_BIN_REL = ".boring-agent/sdk/uv/bin/uv";
 function sourceToPath(source) {
-  return source instanceof URL ? fileURLToPath2(source) : source;
+  return source instanceof URL ? fileURLToPath3(source) : source;
 }
 async function commandOutput2(adapter, command, args) {
   const result = await adapter.exec(command, args);
@@ -3225,7 +3499,7 @@ function pythonInstallSource(spec) {
 }
 function sourceRootForPythonSpec(spec) {
   if (spec.packageRoot) return spec.packageRoot;
-  if (spec.projectFile) return dirname8(sourceToPath(spec.projectFile));
+  if (spec.projectFile) return dirname9(sourceToPath(spec.projectFile));
   return null;
 }
 function expectedPythonOutputs(paths, packages) {
@@ -3254,6 +3528,7 @@ async function shouldInstallPythonRuntime(options) {
     return true;
   }
   for (const output of options.expectedOutputs) {
+    if (output === options.runtimeLayout.venvPython) continue;
     if (!await options.adapter.workspaceFs.exists(toWorkspaceRel2(options.runtimeLayout, output))) return true;
   }
   return false;
@@ -3345,11 +3620,11 @@ async function ensurePythonRuntime(options) {
 // src/server/workspace/provisioning/skills.ts
 import { stat as stat5 } from "fs/promises";
 import { join as join7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } 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;
+  return source instanceof URL ? fileURLToPath4(source) : source;
 }
 function assertSafeSegment(kind, value) {
   if (value.length === 0 || value.includes("\0") || value.includes("/") || value.includes("\\") || value === "." || value === "..") {
@@ -3391,9 +3666,9 @@ async function mirrorPluginSkills(options) {
 import { basename, join as joinPath } from "path";
 import { posix as posix2 } from "path";
 import { readdir as readdir3, stat as stat6 } from "fs/promises";
-import { fileURLToPath as fileURLToPath4, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
 function sourceToPath3(source) {
-  return source instanceof URL ? fileURLToPath4(source) : source;
+  return source instanceof URL ? fileURLToPath5(source) : source;
 }
 function toWorkspaceRel3(...parts) {
   return posix2.normalize(parts.filter(Boolean).join("/"));
@@ -3687,7 +3962,7 @@ async function provisionWorkspaceRuntime(opts) {
 import { spawnSync } from "child_process";
 
 // src/server/runtime/modes/direct.ts
-import { mkdir as mkdir7 } from "fs/promises";
+import { mkdir as mkdir8 } from "fs/promises";
 
 // src/server/runtime/createServerFileSearch.ts
 var DEFAULT_LIMIT = 500;
@@ -3765,12 +4040,12 @@ async function copyTemplate(templatePath, workspaceRoot) {
 
 // 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 rm3, stat as stat7, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname9, isAbsolute as isAbsolute5, relative as relative8, resolve as resolve6, sep as sep5 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { cp as cp3, lstat as lstat3, mkdir as mkdir7, readFile as readFile6, realpath as realpath3, rm as rm3, stat as stat7, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname10, isAbsolute as isAbsolute6, relative as relative8, resolve as resolve6, sep as sep5 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 var LOCAL_SANDBOX_WORKSPACE_ROOT = "/workspace";
 function sourceToPath4(source) {
-  return source instanceof URL ? fileURLToPath5(source) : source;
+  return source instanceof URL ? fileURLToPath6(source) : source;
 }
 async function assertExistingInsideWorkspace(root, relPath, enforceSymlinkBoundary) {
   const absPath = validatePath(root, relPath);
@@ -3788,9 +4063,9 @@ async function assertExistingInsideWorkspace(root, relPath, enforceSymlinkBounda
 }
 async function prepareWritablePath(root, relPath, enforceSymlinkBoundary) {
   const absPath = validatePath(root, relPath);
-  await mkdir6(dirname9(absPath), { recursive: true });
+  await mkdir7(dirname10(absPath), { recursive: true });
   if (enforceSymlinkBoundary) {
-    await assertRealPathWithinWorkspace(root, dirname9(absPath));
+    await assertRealPathWithinWorkspace(root, dirname10(absPath));
   }
   try {
     const targetStat = await lstat3(absPath);
@@ -3829,8 +4104,8 @@ async function spawnCommand(command, args, opts) {
         stderr: Buffer.concat(stderr).toString("utf8")
       });
     };
-    child.stdout?.on("data", (chunk2) => stdout.push(chunk2));
-    child.stderr?.on("data", (chunk2) => stderr.push(chunk2));
+    child.stdout?.on("data", (chunk3) => stdout.push(chunk3));
+    child.stderr?.on("data", (chunk3) => stderr.push(chunk3));
     child.on("error", settle);
     child.on("close", (code) => {
       if (code === 0) {
@@ -3854,7 +4129,7 @@ function defaultExecOptions(paths, opts) {
   };
 }
 function mapWorkspacePathToLocalSandbox(paths, value) {
-  const absolute = isAbsolute5(value) ? value : resolve6(paths.workspaceRoot, value);
+  const absolute = isAbsolute6(value) ? value : resolve6(paths.workspaceRoot, value);
   const relPath = relative8(paths.workspaceRoot, absolute);
   if (relPath === "") return LOCAL_SANDBOX_WORKSPACE_ROOT;
   if (relPath === ".." || relPath.startsWith(`..${sep5}`)) return value;
@@ -3868,33 +4143,18 @@ function mapEnvToLocalSandbox(paths, env) {
     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 rm3(absTarget, { recursive: true, force: true });
-  await mkdir6(dirname9(absTarget), { recursive: true });
-  await assertRealPathWithinWorkspace(paths.workspaceRoot, dirname9(absTarget));
-  const sourceStat = await stat7(sourcePath);
-  await cp3(sourcePath, absTarget, {
-    recursive: sourceStat.isDirectory(),
-    force: false,
-    errorOnExist: true
-  });
-  return `${LOCAL_SANDBOX_WORKSPACE_ROOT}/${relTarget}`;
-}
 function createWorkspaceFs(workspaceRoot, opts) {
   const { enforceSymlinkBoundary } = opts;
   return {
     async exists(workspaceRelativePath) {
-      const absPath = await assertExistingInsideWorkspace(workspaceRoot, workspaceRelativePath, enforceSymlinkBoundary);
-      if (!absPath) return false;
-      await lstat3(absPath);
-      return true;
+      const absPath = validatePath(workspaceRoot, workspaceRelativePath);
+      try {
+        await stat7(absPath);
+        return true;
+      } catch (error) {
+        if (error.code === "ENOENT") return false;
+        throw error;
+      }
     },
     async rm(workspaceRelativePath) {
       const absPath = await assertExistingInsideWorkspace(workspaceRoot, workspaceRelativePath, enforceSymlinkBoundary);
@@ -3903,7 +4163,7 @@ function createWorkspaceFs(workspaceRoot, opts) {
     },
     async mkdir(workspaceRelativePath) {
       const absPath = validatePath(workspaceRoot, workspaceRelativePath);
-      await mkdir6(absPath, { recursive: true });
+      await mkdir7(absPath, { recursive: true });
       if (enforceSymlinkBoundary) {
         await assertRealPathWithinWorkspace(workspaceRoot, absPath);
       }
@@ -3946,6 +4206,7 @@ function createDirectProvisioningAdapter(paths, runner = spawnCommand) {
 }
 function createLocalProvisioningAdapter(paths, runner = spawnCommand) {
   const sourceMounts = /* @__PURE__ */ new Map();
+  const workspaceFs = createWorkspaceFs(paths.workspaceRoot, { enforceSymlinkBoundary: true });
   return {
     mode: "local",
     async exec(command, args, opts) {
@@ -3975,12 +4236,18 @@ function createLocalProvisioningAdapter(paths, runner = spawnCommand) {
       const realSource = await realpath3(hostPath);
       const relPath = relative8(realWorkspaceRoot, realSource);
       if (relPath === "") return LOCAL_SANDBOX_WORKSPACE_ROOT;
-      if (!relPath.startsWith("..") && !isAbsolute5(relPath)) {
+      if (!relPath.startsWith("..") && !isAbsolute6(relPath)) {
         return `${LOCAL_SANDBOX_WORKSPACE_ROOT}/${relPath.split(sep5).join("/")}`;
       }
-      return await copyExternalSourceIntoWorkspace(paths, realSource, opts);
+      return await resolveArtifactInstallSource({
+        workspaceFs,
+        prepareArtifact: packProvisioningArtifact,
+        runtimeTmpDir: `${LOCAL_SANDBOX_WORKSPACE_ROOT}/.boring-agent/tmp`,
+        source: realSource,
+        opts
+      });
     },
-    workspaceFs: createWorkspaceFs(paths.workspaceRoot, { enforceSymlinkBoundary: true }),
+    workspaceFs,
     getRuntimeCacheRoot() {
       return paths.cache;
     }
@@ -3993,7 +4260,7 @@ var directModeAdapter = {
   workspaceFsCapability: "strong",
   createProvisioningAdapter: (runtimeLayout) => createDirectProvisioningAdapter(runtimeLayout),
   async create(ctx) {
-    await mkdir7(ctx.workspaceRoot, { recursive: true });
+    await mkdir8(ctx.workspaceRoot, { recursive: true });
     await copyTemplate(ctx.templatePath, ctx.workspaceRoot);
     const runtimeContext = { runtimeCwd: ctx.workspaceRoot };
     const workspace = createNodeWorkspace(ctx.workspaceRoot, { runtimeContext });
@@ -4010,7 +4277,7 @@ var directModeAdapter = {
 };
 
 // src/server/runtime/modes/local.ts
-import { mkdir as mkdir8 } from "fs/promises";
+import { mkdir as mkdir9 } from "fs/promises";
 var localModeAdapter = {
   id: "local",
   workspaceFsCapability: "strong",
@@ -4019,7 +4286,7 @@ var localModeAdapter = {
     if (process.platform !== "linux") {
       throw new Error("local mode requires Linux with bubblewrap");
     }
-    await mkdir8(ctx.workspaceRoot, { recursive: true });
+    await mkdir9(ctx.workspaceRoot, { recursive: true });
     await copyTemplate(ctx.templatePath, ctx.workspaceRoot);
     const runtimeContext = { runtimeCwd: "/workspace" };
     const workspace = createNodeWorkspace(ctx.workspaceRoot, { runtimeContext });
@@ -4039,11 +4306,9 @@ 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 stat8 } from "fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute6, join as join8 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { promisify as promisify2 } from "util";
+import { readFile as readFile8, readdir as readdir5, stat as stat8 } from "fs/promises";
+import { join as join8 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 import { Sandbox as VercelSandbox } from "@vercel/sandbox";
 
 // src/server/sandbox/vercel-sandbox/createVercelSandboxExec.ts
@@ -4054,15 +4319,15 @@ var DEFAULT_MAX_OUTPUT_BYTES3 = 1048576;
 var VERCEL_SANDBOX_DEFAULT_PATH = "/vercel/runtimes/node24/bin:/vercel/runtimes/node22/bin:/vercel/runtimes/python/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
 function createStreamWritable(collector, shared, onChunk) {
   return new Writable({
-    write(chunk2, _enc, cb) {
+    write(chunk3, _enc, cb) {
       const remaining = shared.maxBytes - shared.totalBytes;
       if (remaining <= 0) {
         shared.truncated = true;
         cb();
         return;
       }
-      if (chunk2.length > remaining) {
-        const partial = chunk2.subarray(0, remaining);
+      if (chunk3.length > remaining) {
+        const partial = chunk3.subarray(0, remaining);
         collector.chunks.push(partial);
         shared.totalBytes += remaining;
         shared.truncated = true;
@@ -4070,9 +4335,9 @@ function createStreamWritable(collector, shared, onChunk) {
         cb();
         return;
       }
-      collector.chunks.push(chunk2);
-      shared.totalBytes += chunk2.length;
-      onChunk?.(new Uint8Array(chunk2));
+      collector.chunks.push(chunk3);
+      shared.totalBytes += chunk3.length;
+      onChunk?.(new Uint8Array(chunk3));
       cb();
     }
   });
@@ -4256,11 +4521,11 @@ async function buildTarGz(files) {
   }
   chunks.push(Buffer.alloc(1024));
   const tarBuffer = Buffer.concat(chunks);
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const gzip = createGzip({ level: 6 });
     const gzChunks = [];
-    gzip.on("data", (chunk2) => gzChunks.push(chunk2));
-    gzip.on("end", () => resolve10(Buffer.concat(gzChunks)));
+    gzip.on("data", (chunk3) => gzChunks.push(chunk3));
+    gzip.on("end", () => resolve11(Buffer.concat(gzChunks)));
     gzip.on("error", reject);
     Readable.from(tarBuffer).pipe(gzip);
   });
@@ -4300,7 +4565,6 @@ 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",
@@ -4379,6 +4643,13 @@ function createDefaultVercelClient(auth, opts = {}) {
     }
   };
 }
+function buildWorkspaceRootSetupScript(remoteRoot, workspaceRoot) {
+  return [
+    `if [ -L ${workspaceRoot} ]; then rm -f ${workspaceRoot}; fi`,
+    `mkdir -p ${remoteRoot}`,
+    `if [ ${remoteRoot} != ${workspaceRoot} ]; then ln -sfn ${remoteRoot} ${workspaceRoot} 2>/dev/null || true; fi`
+  ].join("; ");
+}
 async function ensureVercelWorkspaceRoot(sandbox) {
   let rootCreated = false;
   if (sandbox.fs?.mkdir) {
@@ -4397,7 +4668,7 @@ async function ensureVercelWorkspaceRoot(sandbox) {
   }
   const result = await sandbox.runCommand({
     cmd: "sh",
-    args: ["-c", `mkdir -p ${VERCEL_SANDBOX_REMOTE_ROOT} && (ln -sfn ${VERCEL_SANDBOX_REMOTE_ROOT} ${VERCEL_SANDBOX_WORKSPACE_ROOT} 2>/dev/null || true)`]
+    args: ["-c", buildWorkspaceRootSetupScript(VERCEL_SANDBOX_REMOTE_ROOT, VERCEL_SANDBOX_WORKSPACE_ROOT)]
   });
   if ((result.exitCode ?? 1) !== 0) {
     throw new Error(`failed to initialize ${VERCEL_SANDBOX_REMOTE_ROOT} (exit ${result.exitCode ?? "unknown"})`);
@@ -4441,28 +4712,7 @@ async function seedTemplateIntoVercelWorkspace(workspace, templatePath, logger)
   });
 }
 function provisioningSourceToPath(source) {
-  return source instanceof URL ? fileURLToPath6(source) : source;
-}
-async function prepareVercelProvisioningArtifact(request) {
-  const sourcePath = provisioningSourceToPath(request.source);
-  await mkdir9(dirname10(request.outputPath), { recursive: true });
-  if (request.kind === "node") {
-    const { stdout } = await execFileAsync2("pnpm", [
-      "--dir",
-      sourcePath,
-      "pack",
-      "--pack-destination",
-      dirname10(request.outputPath)
-    ], { 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 = isAbsolute6(packedName) ? packedName : join8(dirname10(request.outputPath), packedName);
-    await rename5(packedPath, request.outputPath);
-    return;
-  }
-  await execFileAsync2("tar", ["-czf", request.outputPath, "-C", sourcePath, "."], {
-    maxBuffer: 1024 * 1024 * 20
-  });
+  return source instanceof URL ? fileURLToPath7(source) : source;
 }
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -4712,7 +4962,7 @@ function createVercelSandboxModeAdapter(opts = {}) {
           }
           return { stdout, stderr };
         },
-        prepareArtifact: prepareVercelProvisioningArtifact
+        prepareArtifact: packProvisioningArtifact
       });
     },
     async create(ctx) {
@@ -4893,8 +5143,8 @@ import Fastify from "fastify";
 
 // src/server/harness/pi-coding-agent/createHarness.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { mkdir as mkdir11, writeFile as writeFile7 } from "fs/promises";
-import { extname as extname2, join as join10 } from "path";
+import { mkdir as mkdir12, writeFile as writeFile7 } from "fs/promises";
+import { extname as extname3, join as join10 } from "path";
 import {
   createAgentSession,
   SessionManager,
@@ -5175,17 +5425,16 @@ import {
   readFile as readFile9,
   stat as fsStat,
   rm as rm4,
-  mkdir as mkdir10,
+  mkdir as mkdir11,
   writeFile as writeFile6,
   appendFile,
   utimes
 } from "fs/promises";
 import { readFileSync, readdirSync } from "fs";
-import { join as join9 } from "path";
+import { join as join9, resolve as resolve7 } from "path";
 import { homedir as homedir3 } from "os";
 import {
   parseSessionEntries,
-  buildSessionContext,
   CURRENT_SESSION_VERSION
 } from "@mariozechner/pi-coding-agent";
 function defaultSessionDir(cwd) {
@@ -5218,13 +5467,16 @@ var PiSessionStore = class {
   async list(ctx) {
     const files = await readdir6(this.sessionDir).catch(() => []);
     const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    const filepaths = jsonlFiles.map((f) => join9(this.sessionDir, f));
+    const referencedPiFiles = await this.referencedPiFiles(filepaths);
+    const visibleFiles = filepaths.filter((filepath) => !referencedPiFiles.has(resolve7(filepath)));
     const summaries = await Promise.all(
-      jsonlFiles.map((f) => this.summarizeFile(join9(this.sessionDir, f)))
+      visibleFiles.map((filepath) => this.summarizeFile(filepath))
     );
     return summaries.filter((s) => s !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   }
   async create(ctx, init) {
-    await mkdir10(this.sessionDir, { recursive: true });
+    await mkdir11(this.sessionDir, { recursive: true });
     const id = randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const header = {
@@ -5271,17 +5523,25 @@ var PiSessionStore = class {
       (e) => e.type !== "session"
     );
     const fileStat = await fsStat(filepath);
+    const linkedPiFile = extractPiSessionFilePath(fileEntries);
+    const linked = linkedPiFile && resolve7(linkedPiFile) !== resolve7(filepath) ? await this.readLinkedPiSession(linkedPiFile) : null;
+    const linkedEntries = linked?.entries.filter(
+      (e) => e.type !== "session"
+    ) ?? [];
     const uiSnapshot = extractLatestUiSnapshot(fileEntries);
-    const messages = uiSnapshot ?? piMessagesToUIMessages(
-      buildSessionContext(sessionEntries).messages
-    );
-    const title = extractTitle(sessionEntries) ?? "New session";
+    const transcriptEntries = linkedEntries.length > 0 ? linkedEntries : sessionEntries;
+    const messages = uiSnapshot ?? dropEmptyAssistantUiMessages(piMessagesToUIMessages(
+      transcriptEntries.filter((entry) => entry.type === "message").map((entry) => entry.message),
+      sessionId
+    ));
+    const title = extractTitle(sessionEntries) ?? extractTitle(linkedEntries) ?? "New session";
     const turnCount = messages.filter((m) => m.role === "user").length;
+    const updatedAtMs = Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
     return {
       id: sessionId,
       title,
       createdAt: header?.timestamp ?? fileStat.birthtime.toISOString(),
-      updatedAt: fileStat.mtime.toISOString(),
+      updatedAt: new Date(updatedAtMs).toISOString(),
       turnCount,
       messages
     };
@@ -5292,7 +5552,7 @@ var PiSessionStore = class {
       type: "ui_snapshot",
       id: randomUUID(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      messages
+      messages: sanitizeUiMessages(messages, { dropEmptyAssistantMessages: true })
     });
     await appendFile(filepath, entry + "\n");
   }
@@ -5356,7 +5616,12 @@ var PiSessionStore = class {
     const filepath = await this.resolveSessionFile(sessionId).catch(
       () => null
     );
-    if (filepath) await rm4(filepath, { force: true });
+    if (!filepath) return;
+    const linkedPiFile = await this.linkedPiFileFor(filepath);
+    await rm4(filepath, { force: true });
+    if (linkedPiFile && resolve7(linkedPiFile) !== resolve7(filepath)) {
+      await rm4(linkedPiFile, { force: true });
+    }
   }
   touchSession(sessionId, title) {
     this.resolveSessionFile(sessionId).then((filepath) => {
@@ -5392,6 +5657,28 @@ var PiSessionStore = class {
     if (!match) throw new Error(`Session not found: ${sessionId}`);
     return join9(this.sessionDir, match);
   }
+  async linkedPiFileFor(filepath) {
+    try {
+      const content = await readFile9(filepath, "utf-8");
+      return extractPiSessionFilePath(safeParseEntries(content));
+    } catch {
+      return null;
+    }
+  }
+  async referencedPiFiles(filepaths) {
+    const referenced = /* @__PURE__ */ new Set();
+    await Promise.all(filepaths.map(async (filepath) => {
+      try {
+        const content = await readFile9(filepath, "utf-8");
+        const piFilePath = extractPiSessionFilePath(safeParseEntries(content));
+        if (piFilePath && resolve7(piFilePath) !== resolve7(filepath)) {
+          referenced.add(resolve7(piFilePath));
+        }
+      } catch {
+      }
+    }));
+    return referenced;
+  }
   async summarizeFile(filepath) {
     try {
       const [fileStat, content] = await Promise.all([
@@ -5408,28 +5695,56 @@ var PiSessionStore = class {
       const sessionEntries = entries.filter(
         (e) => e.type !== "session"
       );
-      const title = extractTitle(sessionEntries) ?? firstUserMessage(sessionEntries) ?? "New session";
-      const turnCount = sessionEntries.filter(
+      const linkedPiFile = extractPiSessionFilePath(entries);
+      const linked = linkedPiFile && resolve7(linkedPiFile) !== resolve7(filepath) ? await this.readLinkedPiSession(linkedPiFile) : null;
+      const linkedEntries = linked?.entries.filter(
+        (e) => e.type !== "session"
+      ) ?? [];
+      const uiSnapshot = extractLatestUiSnapshot(entries);
+      const title = extractTitle(sessionEntries) ?? extractTitle(linkedEntries) ?? firstUserMessage(linkedEntries) ?? firstUserMessage(sessionEntries) ?? "New session";
+      const turnCount = uiSnapshot ? uiSnapshot.filter((m) => m.role === "user").length : [...sessionEntries, ...linkedEntries].filter(
         (e) => e.type === "message" && e.message?.role === "user"
       ).length;
+      const updatedAtMs = Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
       return {
         id: header.id,
         title,
         createdAt: header.timestamp,
-        updatedAt: fileStat.mtime.toISOString(),
+        updatedAt: new Date(updatedAtMs).toISOString(),
         turnCount
       };
     } catch {
       return null;
     }
   }
+  async readLinkedPiSession(filepath) {
+    try {
+      const [fileStat, content] = await Promise.all([
+        fsStat(filepath),
+        readFile9(filepath, "utf-8")
+      ]);
+      return { entries: safeParseEntries(content), mtime: fileStat.mtime };
+    } catch {
+      return null;
+    }
+  }
 };
+function extractPiSessionFilePath(entries) {
+  let piFilePath = null;
+  for (const e of entries) {
+    const rec = e;
+    if (rec.type === "pi_session_file" && typeof rec.path === "string") {
+      piFilePath = rec.path;
+    }
+  }
+  return piFilePath;
+}
 function extractLatestUiSnapshot(entries) {
   let latest = null;
   for (const e of entries) {
     const rec = e;
     if (rec.type === "ui_snapshot" && Array.isArray(rec.messages)) {
-      latest = rec.messages;
+      latest = sanitizeUiMessages(rec.messages, { dropEmptyAssistantMessages: true });
     }
   }
   return latest;
@@ -5462,7 +5777,10 @@ function safeParseEntries(content) {
     return results;
   }
 }
-function piMessagesToUIMessages(messages) {
+function reconstructedMessageId(sessionId, role, index) {
+  return sessionId ? `${sessionId}-${role}-${index}` : `${role}-${index}`;
+}
+function piMessagesToUIMessages(messages, sessionId) {
   const result = [];
   let currentAssistant = null;
   for (const raw of messages) {
@@ -5474,7 +5792,7 @@ function piMessagesToUIMessages(messages) {
         const content = msg.content;
         const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((c) => c.type === "text").map((c) => c.text).join("") : "";
         result.push({
-          id: randomUUID(),
+          id: reconstructedMessageId(sessionId, "user", result.length),
           role: "user",
           parts: [{ type: "text", text }]
         });
@@ -5508,7 +5826,7 @@ function piMessagesToUIMessages(messages) {
           }
         }
         const uiMsg = {
-          id: randomUUID(),
+          id: reconstructedMessageId(sessionId, "assistant", result.length),
           role: "assistant",
           parts
         };
@@ -5546,7 +5864,7 @@ var DEFAULT_POLL_MS = 250;
 var MAX_PROMPT_CHARS = 1200;
 var MAX_TITLE_CHARS = 80;
 function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 function truncateForPrompt(text) {
   const trimmed = text.trim();
@@ -6021,7 +6339,7 @@ async function applyRequestedSessionOptions(handle, input) {
 var log3 = createLogger("pi-harness");
 var DEFAULT_ATTACHMENT_DIR = "assets/images";
 function extForAttachment(filename, contentType) {
-  const fromName = extname2(filename).toLowerCase().replace(/^\./, "");
+  const fromName = extname3(filename).toLowerCase().replace(/^\./, "");
   if (/^[a-z0-9]{1,12}$/.test(fromName)) return fromName;
   if (contentType === "image/jpeg") return "jpg";
   if (contentType === "image/png") return "png";
@@ -6181,6 +6499,7 @@ function createPiCodingAgentHarness(opts) {
     handle.piSession.dispose();
     piSessions.delete(sessionId);
     clearNativeFollowUpWork(sessionId);
+    consumedNativeFollowUpKeys.delete(sessionId);
   }
   const originalDelete = sessionStore.delete.bind(sessionStore);
   sessionStore.delete = async (ctx, sessionId) => {
@@ -6189,6 +6508,7 @@ function createPiCodingAgentHarness(opts) {
   };
   const nativeFollowUpPending = /* @__PURE__ */ new Set();
   const nativeFollowUpQueues = /* @__PURE__ */ new Map();
+  const consumedNativeFollowUpKeys = /* @__PURE__ */ new Map();
   function clearNativeFollowUpWork(sessionId) {
     nativeFollowUpPending.delete(sessionId);
     nativeFollowUpQueues.delete(sessionId);
@@ -6224,12 +6544,38 @@ function createPiCodingAgentHarness(opts) {
     }
     session._emitQueueUpdate?.();
   }
+  function followUpDedupeKeys(options) {
+    const keys = [];
+    if (options?.clientNonce) keys.push(`nonce:${options.clientNonce}`);
+    if (options?.clientSeq !== void 0) keys.push(`seq:${options.clientSeq}`);
+    return keys;
+  }
   function hasFollowUpSelector(options) {
-    return Boolean(options?.clientNonce) || options?.clientSeq !== void 0;
+    return followUpDedupeKeys(options).length > 0;
   }
   function matchesFollowUpSelector(item, options) {
     if (!hasFollowUpSelector(options)) return true;
-    return Boolean(options?.clientNonce && item.clientNonce === options.clientNonce) || options?.clientSeq !== void 0 && item.clientSeq === options.clientSeq;
+    const optionKeys = new Set(followUpDedupeKeys(options));
+    return followUpDedupeKeys(item).some((key) => optionKeys.has(key));
+  }
+  function rememberConsumedNativeFollowUp(sessionId, request) {
+    const keys = followUpDedupeKeys(request);
+    if (keys.length === 0) return;
+    const consumed = consumedNativeFollowUpKeys.get(sessionId) ?? /* @__PURE__ */ new Set();
+    for (const key of keys) consumed.add(key);
+    consumedNativeFollowUpKeys.set(sessionId, consumed);
+  }
+  function followUpPostDedupeKeys(options) {
+    if (options?.clientNonce) return [`nonce:${options.clientNonce}`];
+    if (options?.clientSeq !== void 0) return [`seq:${options.clientSeq}`];
+    return [];
+  }
+  function hasQueuedOrConsumedNativeFollowUp(sessionId, options) {
+    const optionKeys = new Set(followUpPostDedupeKeys(options));
+    if (optionKeys.size === 0) return false;
+    const consumed = consumedNativeFollowUpKeys.get(sessionId);
+    if (consumed && [...optionKeys].some((key) => consumed.has(key))) return true;
+    return (nativeFollowUpQueues.get(sessionId) ?? []).some((request) => followUpPostDedupeKeys(request).some((key) => optionKeys.has(key)));
   }
   function removeNativeFollowUp(sessionId, options) {
     const queue = nativeFollowUpQueues.get(sessionId);
@@ -6257,6 +6603,7 @@ function createPiCodingAgentHarness(opts) {
     async followUp(sessionId, text, _attachments, displayText = text, options) {
       const handle = piSessions.get(sessionId);
       if (!handle) throw new Error("followup_session_not_ready");
+      if (hasQueuedOrConsumedNativeFollowUp(sessionId, options)) return;
       const queue = nativeFollowUpQueues.get(sessionId) ?? [];
       queue.push({
         text,
@@ -6361,34 +6708,34 @@ function createPiCodingAgentHarness(opts) {
         "tool-output-error"
       ]);
       const standardToolInputsSeen = /* @__PURE__ */ new Set();
-      function isStandardVisibleChunk(chunk2) {
-        const type = chunk2.type;
+      function isStandardVisibleChunk(chunk3) {
+        const type = chunk3.type;
         return typeof type === "string" && STANDARD_VISIBLE_CHUNK_TYPES.has(type);
       }
       function namespaceInlinePartIds(input2) {
         if (inlineTurnIndex === 0) return input2;
-        return input2.map((chunk2) => {
-          const rec = chunk2;
+        return input2.map((chunk3) => {
+          const rec = chunk3;
           if ((rec.type === "text-start" || rec.type === "text-delta" || rec.type === "text-end" || rec.type === "reasoning-start" || rec.type === "reasoning-delta" || rec.type === "reasoning-end") && typeof rec.id === "string") {
             return { ...rec, id: `turn-${inlineTurnIndex}:${rec.id}` };
           }
-          return chunk2;
+          return chunk3;
         });
       }
       function filterSdkChunksForCurrentSegment(input2) {
         const out = [];
-        for (const chunk2 of input2) {
-          const rec = chunk2;
-          if (inlineTurnIndex > 0 && isStandardVisibleChunk(chunk2)) continue;
+        for (const chunk3 of input2) {
+          const rec = chunk3;
+          if (inlineTurnIndex > 0 && isStandardVisibleChunk(chunk3)) continue;
           if (rec.type === "tool-input-available" && rec.toolCallId) {
             standardToolInputsSeen.add(rec.toolCallId);
-            out.push(chunk2);
+            out.push(chunk3);
             continue;
           }
           if ((rec.type === "tool-output-available" || rec.type === "tool-output-error" || rec.type === "tool-output-denied") && rec.toolCallId && !standardToolInputsSeen.has(rec.toolCallId)) {
             continue;
           }
-          out.push(chunk2);
+          out.push(chunk3);
         }
         return out;
       }
@@ -6520,8 +6867,8 @@ function createPiCodingAgentHarness(opts) {
             const queue = nativeFollowUpQueues.get(input.sessionId);
             if (queue?.length) {
               const index = queue.findIndex((item) => item.text === text || item.displayText === text);
-              if (index >= 0) queue.splice(index, 1);
-              else queue.shift();
+              const consumed = index >= 0 ? queue.splice(index, 1)[0] : queue.shift();
+              rememberConsumedNativeFollowUp(input.sessionId, consumed);
               if (queue.length > 0) nativeFollowUpQueues.set(input.sessionId, queue);
               else clearNativeFollowUpWork(input.sessionId);
             } else {
@@ -6533,10 +6880,10 @@ function createPiCodingAgentHarness(opts) {
         } else {
           const sdkChunks = namespaceInlinePartIds(dedupStartChunks(piEventToChunks(event)));
           const shouldBufferTerminalError = event.type === "message_update" && event.assistantMessageEvent?.type === "error";
-          const visibleSdkChunks = shouldBufferTerminalError ? sdkChunks.filter((chunk2) => {
-            const type = chunk2.type;
+          const visibleSdkChunks = shouldBufferTerminalError ? sdkChunks.filter((chunk3) => {
+            const type = chunk3.type;
             if (type === "error" || type === "finish") {
-              pendingTerminalErrorChunks.push(chunk2);
+              pendingTerminalErrorChunks.push(chunk3);
               return false;
             }
             return true;
@@ -6544,12 +6891,12 @@ function createPiCodingAgentHarness(opts) {
           const sdkChunksForTurn = filterSdkChunksForCurrentSegment(visibleSdkChunks);
           converted = [...piHistoryChunks, ...sdkChunksForTurn];
         }
-        for (const chunk2 of converted) {
-          const t = chunk2.type;
+        for (const chunk3 of converted) {
+          const t = chunk3.type;
           if (t === "text-delta" || t === "data-pi-text-delta" || t === "data-pi-text-end") {
             sawTextChunk = true;
           }
-          const piEndData = chunk2.data;
+          const piEndData = chunk3.data;
           if (t === "data-pi-message-end" && piEndData?.role === "assistant" && typeof piEndData.text === "string" && piEndData.text.length > 0) {
             sawTextChunk = true;
           }
@@ -6618,7 +6965,7 @@ 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 mkdir11(join10(opts.cwd, DEFAULT_ATTACHMENT_DIR), { recursive: true });
+            await mkdir12(join10(opts.cwd, DEFAULT_ATTACHMENT_DIR), { recursive: true });
             await writeFile7(join10(opts.cwd, relPath), bytes);
             savedPaths.push(relPath);
           } catch (err) {
@@ -6709,7 +7056,7 @@ ${attachmentNotes.join("\n")}` : 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 extname3, resolve as resolve7, sep as sep6, relative as relative9 } from "path";
+import { join as join11, 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"]);
@@ -6735,7 +7082,7 @@ 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(extname3(e))).map((e) => ({ path: join11(dir, e), source }));
+  return entries.filter((e) => VALID_EXTENSIONS.has(extname4(e))).map((e) => ({ path: join11(dir, e), source }));
 }
 function extractTools(mod) {
   const tools = [];
@@ -6779,8 +7126,8 @@ async function loadNpmPlugin(pkgDir, importFn) {
   if (!await fileExists(pkgJsonPath)) return [];
   const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
   const main = pkgJson.main ?? "index.js";
-  const resolvedMain = resolve7(pkgDir, main);
-  const resolvedPkgDir = resolve7(pkgDir);
+  const resolvedMain = resolve8(pkgDir, main);
+  const resolvedPkgDir = resolve8(pkgDir);
   if (resolvedMain !== resolvedPkgDir && !resolvedMain.startsWith(resolvedPkgDir + sep6)) {
     return [];
   }
@@ -6878,8 +7225,8 @@ function getRuntimeBundleStorageRoot(bundle) {
 
 // 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 writeFile8 } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute7, join as join12, relative as relative10, resolve as resolve8 } from "path";
+import { access as access4, lstat as lstat4, mkdir as mkdir13, readFile as readFile11, readdir as readdir8, readlink, realpath as realpath4, stat as stat10, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname11, isAbsolute as isAbsolute7, join as join12, relative as relative10, resolve as resolve9 } from "path";
 function toPosixPath(value) {
   return value.split("\\").join("/");
 }
@@ -6935,7 +7282,7 @@ async function walkMatches(root, current, pattern, ignore, limit, out) {
   const entries = await readdir8(current, { withFileTypes: true });
   for (const entry of entries) {
     if (out.length >= limit) return;
-    const absolutePath = resolve8(current, entry.name);
+    const absolutePath = resolve9(current, entry.name);
     const relativePath = toPosixPath(relative10(root, absolutePath));
     if (entry.isDirectory() && shouldSkipDir(relativePath, ignore)) continue;
     if (matchesGlob(relativePath, pattern)) {
@@ -6960,12 +7307,12 @@ async function findNearestExistingAncestor(absPath) {
   }
 }
 async function assertWithinWorkspace(workspaceRoot, absPath) {
-  const realRoot = await realpath4(resolve8(workspaceRoot));
+  const realRoot = await realpath4(resolve9(workspaceRoot));
   try {
     const s = await lstat4(absPath);
     if (s.isSymbolicLink()) {
       const target = await readlink(absPath);
-      const resolvedTarget = resolve8(dirname11(absPath), target);
+      const resolvedTarget = resolve9(dirname11(absPath), target);
       const nearestAncestor = await findNearestExistingAncestor(resolvedTarget);
       const realAncestor = await realpath4(nearestAncestor);
       const rel2 = relative10(realRoot, realAncestor);
@@ -7037,13 +7384,13 @@ function boundFs(workspaceRoot, opts = {}) {
     async writeFile(absolutePath, content) {
       const storagePath = toStoragePath(absolutePath);
       await assertWithinWorkspace(workspaceRoot, storagePath);
-      await mkdir12(dirname11(storagePath), { recursive: true });
+      await mkdir13(dirname11(storagePath), { recursive: true });
       await writeFile8(storagePath, content);
     },
     async mkdir(dir) {
       const storagePath = toStoragePath(dir);
       await assertWithinWorkspace(workspaceRoot, storagePath);
-      await mkdir12(storagePath, { recursive: true });
+      await mkdir13(storagePath, { recursive: true });
     }
   };
   const edit = {
@@ -7160,8 +7507,8 @@ function vercelBashOps(sandbox, opts = {}) {
         env: filteredEnv,
         signal,
         timeoutMs: timeout ? timeout * 1e3 : void 0,
-        onStdout: (chunk2) => onData(Buffer.from(chunk2)),
-        onStderr: (chunk2) => onData(Buffer.from(chunk2))
+        onStdout: (chunk3) => onData(Buffer.from(chunk3)),
+        onStderr: (chunk3) => onData(Buffer.from(chunk3))
       }).then((result) => ({ exitCode: result.exitCode }));
     }
   };
@@ -7328,7 +7675,7 @@ import {
   truncateHead,
   truncateLine
 } from "@mariozechner/pi-coding-agent";
-import { resolve as resolve9, relative as relative12 } from "path";
+import { resolve as resolve10, relative as relative12 } from "path";
 
 // src/server/catalog/tools/_shared.ts
 function makeError(message) {
@@ -7480,7 +7827,7 @@ function vercelGrepTool(sandbox, workspaceRoot) {
         return makeError("pattern is required");
       }
       if (workspaceRoot && typeof params.path === "string" && params.path.length > 0) {
-        const resolved = resolve9(workspaceRoot, params.path);
+        const resolved = resolve10(workspaceRoot, params.path);
         const rel = relative12(workspaceRoot, resolved);
         if (rel.startsWith("..") || rel.startsWith("/")) {
           return makeError(`path "${params.path}" is outside workspace`);
@@ -7568,6 +7915,84 @@ import {
   createBashToolDefinition,
   createLocalBashOperations
 } from "@mariozechner/pi-coding-agent";
+
+// src/server/catalog/toolReadiness.ts
+var WORKSPACE_PREPARING_MESSAGE = "Workspace is still preparing. Try again in a moment.";
+function isRuntimeRequirement(requirement) {
+  return requirement === "runtime-dependencies" || requirement.startsWith("runtime:");
+}
+function isReadyState(state) {
+  return state === true || typeof state === "object" && state !== null && state.ready === true;
+}
+function blockedState(state) {
+  if (state && typeof state === "object" && state.ready === false) return state;
+  return { ready: false, state: "preparing", retryable: true };
+}
+function runtimeRequirementMessage(requirement, state) {
+  if (state === "failed") {
+    return "Runtime setup failed. Retry provisioning or reload the workspace.";
+  }
+  switch (requirement) {
+    case "runtime:python":
+      return "Python runtime dependencies are still installing. This usually takes a few seconds.";
+    case "runtime:node":
+      return "Node runtime dependencies are still installing. This usually takes a few seconds.";
+    default:
+      return "Runtime dependencies are still installing. This usually takes a few seconds.";
+  }
+}
+function workspaceNotReadyToolResult(requirement) {
+  return {
+    content: [{ type: "text", text: WORKSPACE_PREPARING_MESSAGE }],
+    isError: true,
+    details: {
+      code: ErrorCode.enum.WORKSPACE_NOT_READY,
+      retryable: true,
+      requirement
+    }
+  };
+}
+function runtimeNotReadyToolResult(requirement, state = { ready: false, state: "preparing", retryable: true }) {
+  const readinessState = state.state ?? "preparing";
+  const code = readinessState === "failed" ? ErrorCode.enum.RUNTIME_PROVISIONING_FAILED : ErrorCode.enum.AGENT_RUNTIME_NOT_READY;
+  const message = state.message ?? runtimeRequirementMessage(requirement, readinessState);
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true,
+    details: {
+      code,
+      retryable: state.retryable ?? true,
+      requirement,
+      state: readinessState,
+      ...state.workspaceId ? { workspaceId: state.workspaceId } : {},
+      ...state.errorCode ? { errorCode: state.errorCode } : {},
+      ...state.causeCode ? { causeCode: state.causeCode } : {}
+    }
+  };
+}
+function readinessToolResult(requirement, state) {
+  if (isRuntimeRequirement(requirement)) return runtimeNotReadyToolResult(requirement, blockedState(state));
+  return workspaceNotReadyToolResult(requirement);
+}
+function withReadinessRequirements(tool, readinessRequirements) {
+  if (tool.readinessRequirements === readinessRequirements) return tool;
+  return { ...tool, readinessRequirements };
+}
+function wrapToolForReadiness(tool, checkReadiness) {
+  if (!checkReadiness || !tool.readinessRequirements || tool.readinessRequirements.length === 0) return tool;
+  return {
+    ...tool,
+    async execute(params, ctx) {
+      for (const requirement of tool.readinessRequirements ?? []) {
+        const readiness = checkReadiness(requirement, tool);
+        if (!isReadyState(readiness)) return readinessToolResult(requirement, readiness);
+      }
+      return await tool.execute(params, ctx);
+    }
+  };
+}
+
+// src/server/tools/harness/index.ts
 function shellEscape2(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
@@ -7631,27 +8056,77 @@ function bashOptionsForMode(bundle, runtime) {
       };
   }
 }
-function adaptPiTool2(piTool) {
+function isRuntimeReady(readiness) {
+  return readiness === void 0 || readiness === true || typeof readiness === "object" && readiness !== null && readiness.ready === true;
+}
+function runtimeRequirementForCommand(command) {
+  if (command.includes(".boring-agent/venv/bin/")) return "runtime:python";
+  if (/python(?:3)?\s+-c\s+['\"][^'\"]*(?:from\s+\S+\s+)?import\s+/.test(command)) return "runtime:python";
+  if (command.includes(".boring-agent/node/")) return "runtime:node";
+  if (command.includes(".boring-agent/")) return "runtime-dependencies";
+  return void 0;
+}
+function runtimeRequirementForFailure(text) {
+  if (/\.boring-agent\/venv\/bin\/[^\s:]+: (?:No such file or directory|not found)/i.test(text)) return "runtime:python";
+  if (/ModuleNotFoundError: No module named ['\"][^'\"]+['\"]/i.test(text)) return "runtime:python";
+  if (/\.boring-agent\/node\/[^\s:]+: (?:No such file or directory|not found)/i.test(text)) return "runtime:node";
+  if (/(?:^|\n)(?:[^\n:]+:\s*)?(?:line \d+:\s*)?[A-Za-z0-9_.-]+: command not found/i.test(text)) return "runtime-dependencies";
+  return void 0;
+}
+function adaptPiTool2(piTool, runtime) {
   return {
     name: piTool.name,
     description: piTool.description,
     promptSnippet: piTool.promptSnippet,
     parameters: piTool.parameters,
+    readinessRequirements: ["sandbox-exec"],
     async execute(params, ctx) {
-      const result = await piTool.execute(
-        ctx.toolCallId,
-        params,
-        ctx.abortSignal,
-        ctx.onUpdate ? (update) => {
-          const text = update.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-          ctx.onUpdate(text);
-        } : void 0,
-        {}
-      );
+      const command = typeof params.command === "string" ? params.command : "";
+      const readiness = runtime?.getReadiness?.();
+      const commandRuntimeRequirement = command ? runtimeRequirementForCommand(command) : void 0;
+      if (commandRuntimeRequirement && !isRuntimeReady(readiness)) {
+        return runtimeNotReadyToolResult(
+          commandRuntimeRequirement,
+          readiness && typeof readiness === "object" && readiness.ready === false ? readiness : { ready: false, state: "preparing", retryable: true }
+        );
+      }
+      let result;
+      try {
+        result = await piTool.execute(
+          ctx.toolCallId,
+          params,
+          ctx.abortSignal,
+          ctx.onUpdate ? (update) => {
+            const text2 = update.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+            ctx.onUpdate(text2);
+          } : void 0,
+          {}
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const latestReadiness2 = runtime?.getReadiness?.();
+        const failureRuntimeRequirement2 = runtimeRequirementForFailure(message);
+        if (command && failureRuntimeRequirement2 && !isRuntimeReady(latestReadiness2)) {
+          return runtimeNotReadyToolResult(
+            failureRuntimeRequirement2,
+            latestReadiness2 && typeof latestReadiness2 === "object" && latestReadiness2.ready === false ? latestReadiness2 : { ready: false, state: "preparing", retryable: true }
+          );
+        }
+        throw error;
+      }
       const textContent = (result.content ?? []).filter((c) => c.type === "text").map((c) => ({ type: "text", text: c.text }));
+      const text = textContent.map((part) => part.text).join("\n");
+      const latestReadiness = runtime?.getReadiness?.();
+      const failureRuntimeRequirement = runtimeRequirementForFailure(text);
+      if (command && failureRuntimeRequirement && !isRuntimeReady(latestReadiness)) {
+        return runtimeNotReadyToolResult(
+          failureRuntimeRequirement,
+          latestReadiness && typeof latestReadiness === "object" && latestReadiness.ready === false ? latestReadiness : { ready: false, state: "preparing", retryable: true }
+        );
+      }
       return {
         content: textContent.length > 0 ? textContent : [{ type: "text", text: "" }],
-        isError: false,
+        isError: Boolean(result.isError),
         details: result.details
       };
     }
@@ -7712,7 +8187,7 @@ function createExecuteIsolatedCodeTool(sandbox) {
 }
 function buildHarnessAgentTools(bundle, runtime) {
   const tools = [
-    adaptPiTool2(createBashToolDefinition(bundle.workspace.root, bashOptionsForMode(bundle, runtime)))
+    adaptPiTool2(createBashToolDefinition(bundle.workspace.root, bashOptionsForMode(bundle, runtime)), runtime)
   ];
   if (bundle.sandbox.capabilities.includes("isolated-code")) {
     tools.push(createExecuteIsolatedCodeTool(bundle.sandbox));
@@ -8040,9 +8515,9 @@ var TurnBuffer = class {
   onChunk = /* @__PURE__ */ new Set();
   onDone = /* @__PURE__ */ new Set();
   gc = null;
-  append(chunk2) {
+  append(chunk3) {
     const idx = this.nextIdx++;
-    const entry = { idx, chunk: chunk2 };
+    const entry = { idx, chunk: chunk3 };
     this.ring.push(entry);
     if (this.ring.length > MAX_CHUNKS) this.ring.shift();
     for (const h of this.onChunk) h(entry);
@@ -8157,11 +8632,11 @@ var VALID_OPS = /* @__PURE__ */ new Set([
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
-function parseFileChangeChunk(chunk2) {
-  if (!isRecord2(chunk2) || chunk2.type !== "data-file-changed") {
+function parseFileChangeChunk(chunk3) {
+  if (!isRecord2(chunk3) || chunk3.type !== "data-file-changed") {
     return null;
   }
-  const data = chunk2.data;
+  const data = chunk3.data;
   if (!isRecord2(data)) {
     return null;
   }
@@ -8187,6 +8662,115 @@ function parseFileChangeChunk(chunk2) {
   return change;
 }
 
+// src/server/http/turnManager.ts
+function chunk2(data) {
+  return data;
+}
+var TurnManager = class {
+  buffers = new StreamBufferStore();
+  activeAbortControllersBySession = /* @__PURE__ */ new Map();
+  activeTurnBySession = /* @__PURE__ */ new Map();
+  async startTurn(options) {
+    const reserved = this.reserve(options.sessionId, options.turnId);
+    if (!reserved) return { active: true };
+    try {
+      const runtime = await options.resolveRuntime();
+      options.onSubmitted?.();
+      const chunks = runtime.harness.sendMessage(options.input, {
+        abortSignal: reserved.abortController.signal,
+        workdir: runtime.workdir
+      });
+      this.pump(reserved, chunks, options);
+      return { turnId: reserved.turnId, buffer: reserved.buffer };
+    } catch (err) {
+      this.cleanup(reserved);
+      reserved.buffer.markComplete(() => this.buffers.evict(reserved.sessionId, reserved.turnId));
+      throw err;
+    }
+  }
+  abortTurn(sessionId, turnId) {
+    const requestedTurnId = turnId ?? this.activeTurnBySession.get(sessionId);
+    if (!requestedTurnId) return;
+    this.activeAbortControllersBySession.get(sessionId)?.get(requestedTurnId)?.abort();
+  }
+  getActive(sessionId) {
+    return this.buffers.getActive(sessionId);
+  }
+  reserve(sessionId, turnId) {
+    if (this.activeTurnBySession.has(sessionId)) return null;
+    const abortController = new AbortController();
+    const sessionAbortControllers = this.activeAbortControllersBySession.get(sessionId) ?? /* @__PURE__ */ new Map();
+    sessionAbortControllers.set(turnId, abortController);
+    this.activeAbortControllersBySession.set(sessionId, sessionAbortControllers);
+    this.activeTurnBySession.set(sessionId, turnId);
+    return {
+      sessionId,
+      turnId,
+      abortController,
+      buffer: this.buffers.create(sessionId, turnId)
+    };
+  }
+  pump(reserved, chunks, options) {
+    void (async () => {
+      let streamFailed = false;
+      try {
+        reserved.buffer.append(chunk2({ type: "data-turn-start", data: { turnId: reserved.turnId } }));
+        for await (const rawChunk of chunks) {
+          const nextChunk = rawChunk;
+          const fileChange = parseFileChangeChunk(nextChunk);
+          if (fileChange) {
+            options.sessionChangesTracker?.record(reserved.sessionId, fileChange);
+          }
+          reserved.buffer.append(nextChunk);
+        }
+      } catch (err) {
+        streamFailed = true;
+        options.onStreamError?.(err);
+        reserved.buffer.append({
+          type: "error",
+          errorText: "internal error"
+        });
+      } finally {
+        this.cleanup(reserved);
+        if (!streamFailed) options.onStreamComplete?.();
+        reserved.buffer.markComplete(() => this.buffers.evict(reserved.sessionId, reserved.turnId));
+      }
+    })();
+  }
+  cleanup(reserved) {
+    const sessionAbortControllers = this.activeAbortControllersBySession.get(reserved.sessionId);
+    if (sessionAbortControllers?.get(reserved.turnId) === reserved.abortController) {
+      sessionAbortControllers.delete(reserved.turnId);
+      if (sessionAbortControllers.size === 0) this.activeAbortControllersBySession.delete(reserved.sessionId);
+    }
+    if (this.activeTurnBySession.get(reserved.sessionId) === reserved.turnId) {
+      this.activeTurnBySession.delete(reserved.sessionId);
+    }
+  }
+};
+function createBufferedUiMessageStream(buffer, closeEmitter, cursor = -1) {
+  return createUIMessageStream({
+    async execute({ writer }) {
+      const replayed = buffer.replay(cursor);
+      for (const e of replayed) writer.write(e.chunk);
+      if (buffer.complete) return;
+      await new Promise((resolve11) => {
+        const unsub = buffer.subscribe(
+          (e) => writer.write(e.chunk),
+          () => {
+            unsub();
+            resolve11();
+          }
+        );
+        closeEmitter.on("close", () => {
+          unsub();
+          resolve11();
+        });
+      });
+    }
+  });
+}
+
 // src/server/harness/pi-coding-agent/projectPiDataMessages.ts
 function projectPiDataMessages(messages) {
   const dataParts = messages.flatMap((message) => message.parts ?? []).filter((part) => {
@@ -8260,7 +8844,8 @@ var chatBodySchema = z.object({
       mediaType: z.string().optional(),
       url: z.string()
     })
-  ).max(20).optional()
+  ).max(20).optional(),
+  clientTurnId: z.string().min(1).max(128).optional()
 });
 function addTelemetryProperty(properties, key, value) {
   if (typeof value === "string" && value) properties[key] = value;
@@ -8274,7 +8859,7 @@ function chatRoutes(app, opts, done) {
   const { sessionChangesTracker } = opts;
   const telemetry = opts.telemetry ?? noopTelemetry;
   const validateBody = createBodyValidator(chatBodySchema);
-  const buffers = new StreamBufferStore();
+  const turnManager = new TurnManager();
   const lastFollowUpBySession = /* @__PURE__ */ new Map();
   const cancelledFollowUpsBySession = /* @__PURE__ */ new Map();
   const MAX_FOLLOWUP_CACHE = 5e3;
@@ -8311,12 +8896,18 @@ function chatRoutes(app, opts, done) {
     }
     throw new Error("chat route requires harness/workdir or getRuntime");
   }
+  async function resolveSessionStore(request) {
+    if (opts.getSessionStore) return await opts.getSessionStore(request);
+    if (opts.sessionStore) return opts.sessionStore;
+    const runtime = await resolveRuntime(request);
+    return runtime.harness.sessions;
+  }
   app.post(
     "/api/v1/agent/chat",
     { preHandler: validateBody },
     async (request, reply) => {
-      const { sessionId, message, model, thinkingLevel, attachments } = request.body;
-      const turnId = randomUUID3();
+      const { sessionId, message, model, thinkingLevel, attachments, clientTurnId } = request.body;
+      const turnId = clientTurnId ?? randomUUID3();
       const startedAt = Date.now();
       const telemetryProperties2 = {
         sessionId,
@@ -8329,83 +8920,57 @@ function chatRoutes(app, opts, done) {
         name: "agent.chat.started",
         properties: telemetryProperties2
       });
-      const abortController = new AbortController();
-      let streamStarted = false;
-      let streamCompleted = false;
-      reply.raw.on("close", () => {
-        if (streamStarted && !streamCompleted && !abortController.signal.aborted) {
-          abortController.abort();
-        }
-      });
-      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;
-                const fileChange = parseFileChangeChunk(c);
-                if (fileChange) {
-                  sessionChangesTracker?.record(sessionId, fileChange);
-                }
-                buf.append(c);
-                writer.write(c);
+        const startedTurn = await turnManager.startTurn({
+          sessionId,
+          turnId,
+          input: { sessionId, message, model, thinkingLevel, attachments },
+          resolveRuntime: () => resolveRuntime(request),
+          sessionChangesTracker,
+          onSubmitted: () => {
+            safeCapture(telemetry, {
+              name: "agent.chat.message.submitted",
+              properties: telemetryProperties2
+            });
+          },
+          onStreamError: (err) => {
+            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
               }
-            } 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"
-              };
-              buf.append(errChunk);
-              writer.write(errChunk);
-            } finally {
-              streamCompleted = true;
-              if (!streamFailed) {
-                safeCapture(telemetry, {
-                  name: "agent.chat.completed",
-                  properties: {
-                    ...telemetryProperties2,
-                    status: "ok",
-                    durationMs: Date.now() - startedAt
-                  }
-                });
+            });
+          },
+          onStreamComplete: () => {
+            safeCapture(telemetry, {
+              name: "agent.chat.completed",
+              properties: {
+                ...telemetryProperties2,
+                status: "ok",
+                durationMs: Date.now() - startedAt
               }
-              buf.markComplete(() => buffers.evict(sessionId, turnId));
-            }
+            });
           }
         });
-        streamStarted = true;
+        if ("active" in startedTurn) {
+          return reply.code(409).send({
+            error: {
+              code: ERROR_CODE_CONFLICT,
+              message: "turn_already_active"
+            }
+          });
+        }
+        const stream = createBufferedUiMessageStream(startedTurn.buffer, request.raw);
         reply.hijack();
         pipeUIMessageStreamToResponse({
           response: reply.raw,
           stream,
           headers: {
-            "X-Turn-Id": turnId,
+            "X-Turn-Id": startedTurn.turnId,
             "X-Accel-Buffering": "no",
             "Cache-Control": "no-cache, no-transform"
           }
@@ -8423,8 +8988,6 @@ function chatRoutes(app, opts, done) {
             errorCode: safeTelemetryErrorCode(err?.code)
           }
         });
-        buf.markComplete(() => buffers.evict(sessionId, turnId));
-        if (streamStarted) return;
         const statusCode = err?.statusCode;
         const stableCode = err?.code;
         if (typeof statusCode === "number" && statusCode >= 400 && statusCode < 600) {
@@ -8456,7 +9019,7 @@ function chatRoutes(app, opts, done) {
           }
         });
       }
-      const active = buffers.getActive(sessionId);
+      const active = turnManager.getActive(sessionId);
       if (!active) {
         return reply.code(204).send();
       }
@@ -8473,26 +9036,7 @@ function chatRoutes(app, opts, done) {
         { sessionId, cursor, bufHigh: buf.highIdx },
         "[resume] replaying"
       );
-      const stream = createUIMessageStream({
-        async execute({ writer }) {
-          const replayed = buf.replay(cursor);
-          for (const e of replayed) writer.write(e.chunk);
-          if (buf.complete) return;
-          await new Promise((resolve10) => {
-            const unsub = buf.subscribe(
-              (e) => writer.write(e.chunk),
-              () => {
-                unsub();
-                resolve10();
-              }
-            );
-            request.raw.on("close", () => {
-              unsub();
-              resolve10();
-            });
-          });
-        }
-      });
+      const stream = createBufferedUiMessageStream(buf, request.raw, cursor);
       reply.hijack();
       pipeUIMessageStreamToResponse({
         response: reply.raw,
@@ -8513,8 +9057,8 @@ function chatRoutes(app, opts, done) {
         workspaceId: request.workspaceContext?.workspaceId ?? "default"
       };
       try {
-        const runtime = await resolveRuntime(request);
-        const detail = await runtime.harness.sessions.load(ctx, sessionId);
+        const store = await resolveSessionStore(request);
+        const detail = await store.load(ctx, sessionId);
         const messages = Array.isArray(detail?.messages) ? detail.messages : [];
         return reply.code(200).send({ messages });
       } catch {
@@ -8522,6 +9066,16 @@ function chatRoutes(app, opts, done) {
       }
     }
   );
+  app.delete(
+    "/api/v1/agent/chat/:sessionId/turn",
+    async (request, reply) => {
+      const { sessionId } = request.params;
+      const query = request.query;
+      const requestedTurnId = typeof query.turnId === "string" && query.turnId.length > 0 ? query.turnId : void 0;
+      turnManager.abortTurn(sessionId, requestedTurnId);
+      return reply.code(204).send();
+    }
+  );
   app.post(
     "/api/v1/agent/chat/:sessionId/followup",
     async (request, reply) => {
@@ -8611,9 +9165,9 @@ function chatRoutes(app, opts, done) {
         workspaceId: request.workspaceContext?.workspaceId ?? "default"
       };
       try {
-        const runtime = await resolveRuntime(request);
-        if (runtime.harness.sessions.saveMessages) {
-          await runtime.harness.sessions.saveMessages(ctx, sessionId, projectPiDataMessages(body.messages));
+        const store = await resolveSessionStore(request);
+        if (store.saveMessages) {
+          await store.saveMessages(ctx, sessionId, projectPiDataMessages(body.messages));
         }
         return reply.code(204).send();
       } catch {
@@ -8626,41 +9180,23 @@ function chatRoutes(app, opts, done) {
 
 // src/server/http/routes/models.ts
 import { AuthStorage as AuthStorage2, ModelRegistry as ModelRegistry2 } from "@mariozechner/pi-coding-agent";
-var AUTH_CHECK_TTL_MS = 6e4;
 function modelsRoutes(app, _opts, done) {
   const authStorage = AuthStorage2.create();
   const registry = ModelRegistry2.create(authStorage);
   registerConfiguredModelProviders(registry);
-  const providerAuthCache = /* @__PURE__ */ new Map();
-  async function providerHasResolvableAuth(provider) {
-    const now = Date.now();
-    const cached = providerAuthCache.get(provider);
-    if (cached && cached.expiresAt > now) return cached.available;
-    let available = false;
-    try {
-      const model = registry.getAvailable().find((candidate) => candidate.provider === provider);
-      const auth = model ? await registry.getApiKeyAndHeaders(model) : void 0;
-      available = auth?.ok === true && (typeof auth.apiKey === "string" && auth.apiKey.trim().length > 0 || auth.headers !== void 0);
-    } catch {
-      available = false;
-    }
-    providerAuthCache.set(provider, { available, expiresAt: now + AUTH_CHECK_TTL_MS });
-    return available;
-  }
   app.get("/api/v1/agent/models", async (_request, reply) => {
     const availableModels = registry.getAvailable();
     const availableSet = new Set(
       availableModels.map((m) => `${m.provider}:${m.id}`)
     );
-    const providerAvailability = /* @__PURE__ */ new Map();
-    await Promise.all([...new Set(availableModels.map((m) => m.provider))].map(async (provider) => {
-      providerAvailability.set(provider, await providerHasResolvableAuth(provider));
-    }));
     const models = registry.getAll().map((m) => ({
       provider: m.provider,
       id: m.id,
       label: m.label ?? m.id,
-      available: availableSet.has(`${m.provider}:${m.id}`) && providerAvailability.get(m.provider) === true
+      // Keep this endpoint cheap: it is fetched on chat mount, so it must never
+      // block workspace load on deep provider auth resolution. ModelRegistry's
+      // available set is already derived from configured auth sources.
+      available: availableSet.has(`${m.provider}:${m.id}`)
     }));
     models.sort((a, b) => {
       if (a.available !== b.available) return a.available ? -1 : 1;
@@ -8973,8 +9509,8 @@ function buildAnalysisPrompt(session, transcript, instructions) {
   ].filter(Boolean).join("\n");
 }
 function analysisTextFromChunks(chunks) {
-  return chunks.map((chunk2) => {
-    const record = chunk2;
+  return chunks.map((chunk3) => {
+    const record = chunk3;
     return record.type === "text-delta" && typeof record.delta === "string" ? record.delta : "";
   }).join("").trim();
 }
@@ -9104,14 +9640,14 @@ function sessionRoutes(app, opts, done) {
         }
         const abortController = new AbortController();
         const chunks = [];
-        for await (const chunk2 of runtime.harness.sendMessage(
+        for await (const chunk3 of runtime.harness.sendMessage(
           { sessionId: analysisSession.id, message: prompt },
           {
             abortSignal: abortController.signal,
             workdir: runtime.workdir
           }
         )) {
-          chunks.push(chunk2);
+          chunks.push(chunk3);
         }
         return {
           sourceSession: {
@@ -9241,12 +9777,35 @@ function readyStatusRoutes(app, opts, done) {
   app.get("/api/v1/ready-status", async (request, reply) => {
     const tracker = opts.getTracker ? await opts.getTracker(request) : opts.tracker;
     if (!tracker) throw new Error("ready-status route requires tracker or getTracker");
+    const initial = tracker.getReadiness();
+    const initialEvent = {
+      state: tracker.state,
+      sandboxReady: initial.sandboxReady,
+      harnessReady: initial.harnessReady,
+      capabilities: initial.capabilities,
+      message: initial.degradedReason,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const initialRuntimePending = initialEvent.capabilities.runtimeDependencies.state === "preparing";
+    if (initialEvent.state === "degraded" || initialEvent.state === "ready" && !initialRuntimePending) {
+      return reply.type("text/event-stream").headers({ "Cache-Control": "no-cache" }).send(`:
+
+event: status
+data: ${JSON.stringify(initialEvent)}
+
+`);
+    }
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
       Connection: "keep-alive"
     });
-    reply.raw.write(":\n\n");
+    reply.raw.write(`:
+
+event: status
+data: ${JSON.stringify(initialEvent)}
+
+`);
     let closed = false;
     let unsubscribe = null;
     const closeStream = () => {
@@ -9255,16 +9814,19 @@ function readyStatusRoutes(app, opts, done) {
       unsubscribe?.();
       reply.raw.end();
     };
+    request.raw.on("close", closeStream);
+    reply.hijack();
     unsubscribe = tracker.subscribe((event) => {
       if (closed) return;
       reply.raw.write(`event: status
 data: ${JSON.stringify(event)}
 
 `);
-      if (event.state === "ready" || event.state === "degraded") closeStream();
+      const runtimePending = event.capabilities.runtimeDependencies.state === "preparing";
+      if (event.state === "degraded" || event.state === "ready" && !runtimePending) {
+        queueMicrotask(closeStream);
+      }
     });
-    request.raw.on("close", closeStream);
-    reply.hijack();
     return reply;
   });
   done();
@@ -9362,14 +9924,26 @@ function searchRoutes(app, opts, done) {
 }
 
 // src/server/sandbox/vercel-sandbox/readyStatus.ts
+function defaultCapabilities(sandboxReady, harnessReady) {
+  return {
+    chat: { state: harnessReady ? "ready" : "preparing" },
+    workspace: { state: sandboxReady ? "ready" : "preparing" },
+    runtimeDependencies: { state: "ready" }
+  };
+}
 var ReadyStatusTracker = class {
   _sandboxReady;
   _harnessReady;
   _degradedReason;
+  _capabilities;
   subscribers = /* @__PURE__ */ new Set();
   constructor(opts) {
     this._sandboxReady = opts?.sandboxReady ?? false;
     this._harnessReady = opts?.harnessReady ?? false;
+    this._capabilities = {
+      ...defaultCapabilities(this._sandboxReady, this._harnessReady),
+      ...opts?.capabilities ?? {}
+    };
   }
   get state() {
     if (this._degradedReason) return "degraded";
@@ -9382,23 +9956,52 @@ var ReadyStatusTracker = class {
     return {
       sandboxReady: this._sandboxReady,
       harnessReady: this._harnessReady,
+      capabilities: this.getCapabilities(),
       degradedReason: this._degradedReason
     };
   }
+  getCapabilities() {
+    return {
+      chat: { ...this._capabilities.chat },
+      workspace: { ...this._capabilities.workspace },
+      runtimeDependencies: { ...this._capabilities.runtimeDependencies }
+    };
+  }
+  updateCapability(name, detail) {
+    this._capabilities = {
+      ...this._capabilities,
+      [name]: { ...detail }
+    };
+    this.emit();
+  }
+  updateRuntimeDependencies(detail) {
+    this.updateCapability("runtimeDependencies", detail);
+  }
   markSandboxReady() {
     if (this._sandboxReady) return;
     this._sandboxReady = true;
+    if (this._capabilities.workspace.state === "preparing") {
+      this._capabilities.workspace = { state: "ready" };
+    }
     this.emit();
   }
   markHarnessReady() {
     if (this._harnessReady) return;
     this._harnessReady = true;
+    if (this._capabilities.chat.state === "preparing") {
+      this._capabilities.chat = { state: "ready" };
+    }
     this.emit();
   }
   markDegraded(reason) {
     this._degradedReason = reason;
     this.emit();
   }
+  clearDegraded() {
+    if (!this._degradedReason) return;
+    this._degradedReason = void 0;
+    this.emit();
+  }
   subscribe(handler) {
     this.subscribers.add(handler);
     handler(this.snapshot());
@@ -9415,6 +10018,7 @@ var ReadyStatusTracker = class {
       state: this.state,
       sandboxReady: this._sandboxReady,
       harnessReady: this._harnessReady,
+      capabilities: this.getCapabilities(),
       message: this._degradedReason,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -9510,6 +10114,7 @@ async function createAgentApp(opts = {}) {
   await app.register(chatRoutes, {
     harness,
     workdir: runtimeBundle.workspace.root,
+    sessionStore: harness.sessions,
     sessionChangesTracker,
     telemetry: opts.telemetry
   });
@@ -9570,36 +10175,6 @@ function applyCspHeaders(response, opts = {}) {
 import { basename as basename3 } from "path";
 import { AuthStorage as AuthStorage3, ModelRegistry as ModelRegistry3 } from "@mariozechner/pi-coding-agent";
 
-// src/server/catalog/toolReadiness.ts
-var WORKSPACE_PREPARING_MESSAGE = "Workspace is still preparing. Try again in a moment.";
-function workspaceNotReadyToolResult(requirement) {
-  return {
-    content: [{ type: "text", text: WORKSPACE_PREPARING_MESSAGE }],
-    isError: true,
-    details: {
-      code: ErrorCode.enum.WORKSPACE_NOT_READY,
-      retryable: true,
-      requirement
-    }
-  };
-}
-function withReadinessRequirements(tool, readinessRequirements) {
-  if (tool.readinessRequirements === readinessRequirements) return tool;
-  return { ...tool, readinessRequirements };
-}
-function wrapToolForReadiness(tool, checkReadiness) {
-  if (!checkReadiness || !tool.readinessRequirements || tool.readinessRequirements.length === 0) return tool;
-  return {
-    ...tool,
-    async execute(params, ctx) {
-      for (const requirement of tool.readinessRequirements ?? []) {
-        if (!checkReadiness(requirement, tool)) return workspaceNotReadyToolResult(requirement);
-      }
-      return await tool.execute(params, ctx);
-    }
-  };
-}
-
 // src/server/catalog/mergeTools.ts
 function setLastRegistered(merged, tool) {
   merged.delete(tool.name);
@@ -9634,11 +10209,11 @@ function mergeTools(options) {
 
 // src/server/tools/upload/index.ts
 import { readFile as readFile12 } from "fs/promises";
-import { extname as extname4, join as join13 } from "path";
+import { extname as extname5, join as join13 } from "path";
 var DEFAULT_UPLOAD_DIR = "assets/images";
 var MAX_UPLOAD_BYTES2 = 10 * 1024 * 1024;
 function contentTypeFromExt(path4) {
-  switch (extname4(path4).toLowerCase()) {
+  switch (extname5(path4).toLowerCase()) {
     case ".jpg":
     case ".jpeg":
       return "image/jpeg";
@@ -9657,7 +10232,7 @@ function contentTypeFromExt(path4) {
   }
 }
 function extForUpload2(filename, contentType) {
-  const fromName = extname4(filename).toLowerCase().replace(/^\./, "");
+  const fromName = extname5(filename).toLowerCase().replace(/^\./, "");
   if (/^[a-z0-9]{1,12}$/.test(fromName)) return fromName;
   if (contentType === "image/jpeg") return "jpg";
   if (contentType === "image/png") return "png";
@@ -9823,6 +10398,29 @@ function createRuntimeProvisioningFailedError(workspaceId, cause) {
     }
   );
 }
+function isRuntimeReadinessRequirement(requirement) {
+  return requirement === "runtime-dependencies" || requirement.startsWith("runtime:");
+}
+function causeCodeFrom(error) {
+  const code = error?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function createRuntimeReadinessCheck(workspaceId, getRuntimeDependencies) {
+  return (requirement) => {
+    if (!isRuntimeReadinessRequirement(requirement)) return true;
+    const runtimeDependencies = getRuntimeDependencies();
+    if (runtimeDependencies.state === "ready" || runtimeDependencies.state === "not-started") return true;
+    return {
+      ready: false,
+      state: runtimeDependencies.state,
+      errorCode: runtimeDependencies.errorCode,
+      causeCode: runtimeDependencies.causeCode,
+      message: runtimeDependencies.message,
+      workspaceId,
+      retryable: runtimeDependencies.retryable ?? true
+    };
+  };
+}
 var registerAgentRoutes = async (app, opts) => {
   const workspaceRoot = opts.workspaceRoot ?? process.cwd();
   const sessionId = opts.sessionId ?? DEFAULT_WORKSPACE_ID3;
@@ -9918,14 +10516,99 @@ var registerAgentRoutes = async (app, opts) => {
       requestId: request?.id,
       telemetry: opts.telemetry
     };
-    let runtimeProvisioning = await runRuntimeProvisioning(workspaceId, scope, request);
+    let runtimeProvisioning;
+    let runtimeDependencies = hasRuntimeProvisioningInput ? {
+      state: "preparing",
+      requirement: "runtime-dependencies",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      retryable: true
+    } : { state: "ready" };
+    let provisioningGeneration = 0;
     const runtimeBundle = await modeAdapter.create(modeCtx);
+    const readyTracker = new ReadyStatusTracker({
+      sandboxReady: resolvedMode !== "vercel-sandbox",
+      harnessReady: false,
+      capabilities: {
+        chat: { state: "preparing" },
+        workspace: { state: resolvedMode !== "vercel-sandbox" ? "ready" : "preparing" },
+        runtimeDependencies
+      }
+    });
+    if (resolvedMode === "vercel-sandbox") {
+      queueMicrotask(() => readyTracker.markSandboxReady());
+    }
+    let binding;
+    const updateRuntimeDependencies = (next) => {
+      runtimeDependencies = next;
+      if (binding) binding.runtimeDependencies = next;
+      readyTracker.updateRuntimeDependencies(next);
+    };
+    const startRuntimeProvisioning = (provisionRequest) => {
+      if (!hasRuntimeProvisioningInput) return void 0;
+      if (binding?.runtimeProvisioningTask && runtimeDependencies.state === "preparing") {
+        return binding.runtimeProvisioningTask;
+      }
+      const generation = ++provisioningGeneration;
+      readyTracker.clearDegraded();
+      updateRuntimeDependencies({
+        state: "preparing",
+        requirement: "runtime-dependencies",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retryable: true
+      });
+      const task = runRuntimeProvisioning(workspaceId, scope, provisionRequest).then(
+        async (result) => {
+          if (generation !== provisioningGeneration) return result;
+          runtimeProvisioning = result;
+          if (binding) binding.runtimeProvisioning = result;
+          if (binding?.harness.reloadSession) {
+            try {
+              const sessions = await binding.harness.sessions.list({ workspaceId });
+              await Promise.allSettled(
+                sessions.map((session) => binding?.harness.reloadSession?.(session.id))
+              );
+            } catch (error) {
+              app.log.warn({ err: error, workspaceId }, "[agent] failed to refresh harness sessions after runtime provisioning");
+            }
+          }
+          updateRuntimeDependencies({
+            state: "ready",
+            requirement: "runtime-dependencies",
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            retryable: true
+          });
+          return result;
+        },
+        (error) => {
+          if (generation !== provisioningGeneration) throw error;
+          const causeCode = causeCodeFrom(error);
+          updateRuntimeDependencies({
+            state: "failed",
+            requirement: "runtime-dependencies",
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            errorCode: ErrorCode.enum.RUNTIME_PROVISIONING_FAILED,
+            ...causeCode ? { causeCode } : {},
+            retryable: true,
+            message: "Agent runtime provisioning failed. Reload the workspace and try again."
+          });
+          readyTracker.markDegraded("runtime dependency provisioning failed");
+          app.log.warn({ err: error, workspaceId }, "[agent] background runtime provisioning failed");
+          throw error;
+        }
+      );
+      task.catch(() => {
+      });
+      if (binding) binding.runtimeProvisioningTask = task;
+      return task;
+    };
+    const checkReadiness = createRuntimeReadinessCheck(workspaceId, () => runtimeDependencies);
     const standardTools = [
       ...buildHarnessAgentTools(runtimeBundle, {
         getCurrent: () => runtimeProvisioning ? {
           env: runtimeProvisioning.env,
           pathEntries: runtimeProvisioning.pathEntries
-        } : void 0
+        } : void 0,
+        getReadiness: () => checkReadiness("runtime:python", {})
       }),
       ...buildFilesystemAgentTools(runtimeBundle),
       ...buildUploadAgentTools(runtimeBundle)
@@ -9958,7 +10641,8 @@ var registerAgentRoutes = async (app, opts) => {
         ...scopedExtraTools
       ],
       pluginTools,
-      logger: app.log
+      logger: app.log,
+      checkReadiness
     });
     const harnessFactory = opts.harnessFactory ?? ((input) => createPiCodingAgentHarness({
       ...input,
@@ -9967,9 +10651,18 @@ var registerAgentRoutes = async (app, opts) => {
         noSkills: true,
         ...scope.pi,
         additionalSkillPaths: [
-          ...runtimeProvisioning?.skillPaths ?? [],
           ...scope.pi?.additionalSkillPaths ?? []
-        ]
+        ],
+        getHotReloadableResources: () => {
+          const hot = scope.pi?.getHotReloadableResources?.() ?? {};
+          return {
+            ...hot,
+            additionalSkillPaths: [
+              ...runtimeProvisioning?.skillPaths ?? [],
+              ...hot.additionalSkillPaths ?? []
+            ]
+          };
+        }
       }
     }));
     const harness = await harnessFactory({
@@ -9980,24 +10673,22 @@ var registerAgentRoutes = async (app, opts) => {
       systemPromptDynamic: opts.getSystemPromptDynamic ? () => opts.getSystemPromptDynamic?.({ workspaceId, workspaceRoot: root }) : opts.systemPromptDynamic,
       telemetry: opts.telemetry
     });
-    const readyTracker = new ReadyStatusTracker({
-      sandboxReady: resolvedMode !== "vercel-sandbox",
-      harnessReady: true
-    });
-    if (resolvedMode === "vercel-sandbox") {
-      queueMicrotask(() => readyTracker.markSandboxReady());
-    }
-    return {
+    readyTracker.markHarnessReady();
+    binding = {
       runtimeBundle,
       runtimeProvisioning,
+      runtimeDependencies,
+      runtimeProvisioningTask: void 0,
       reprovision: async (reloadRequest) => {
-        runtimeProvisioning = await runRuntimeProvisioning(workspaceId, scope, reloadRequest);
-        return runtimeProvisioning;
+        const result = await startRuntimeProvisioning(reloadRequest);
+        return await result;
       },
       harness,
       tools,
       readyTracker
     };
+    startRuntimeProvisioning(request);
+    return binding;
   }
   function createRuntimeBindingEntry(workspaceId, scope, request) {
     const entry = {
@@ -10091,6 +10782,7 @@ var registerAgentRoutes = async (app, opts) => {
   const hasRuntimeProvisioningInput = opts.provisionWorkspace !== false && Boolean(opts.provisionRuntime);
   const staticBinding = requestScopedRuntime ? null : await getOrCreateRuntimeBinding(sessionId);
   const skillsScopeByRequest = /* @__PURE__ */ new WeakMap();
+  const earlySessionStores = /* @__PURE__ */ new Map();
   function getSkillsScopeForRequest(request) {
     let promise = skillsScopeByRequest.get(request);
     if (!promise) {
@@ -10103,6 +10795,18 @@ var registerAgentRoutes = async (app, opts) => {
     if (staticBinding) return staticBinding;
     return await getOrCreateRuntimeBinding(getRequestWorkspaceId(request), request, options);
   }
+  async function getSessionStoreForRequest(request) {
+    if (staticBinding) return staticBinding.harness.sessions;
+    const scope = await resolveRuntimeScope(getRequestWorkspaceId(request), request);
+    const cached = earlySessionStores.get(scope.key);
+    if (cached) return cached;
+    const store = new PiSessionStore(scope.root, {
+      sessionNamespace: scope.sessionNamespace,
+      storageCwd: scope.root
+    });
+    earlySessionStores.set(scope.key, store);
+    return store;
+  }
   const agentToolNames = staticBinding ? staticBinding.tools.map((tool) => tool.name) : [
     ...STANDARD_AGENT_TOOL_NAMES,
     ...(opts.extraTools ?? []).map((tool) => tool.name)
@@ -10171,20 +10875,18 @@ var registerAgentRoutes = async (app, opts) => {
   });
   await app.register(chatRoutes, {
     getRuntime: async (request) => {
-      const binding = await getBindingForRequest(request, { failIfPending: hasRuntimeProvisioningInput });
+      const binding = await getBindingForRequest(request);
       return {
         harness: binding.harness,
         workdir: binding.runtimeBundle.workspace.root
       };
     },
+    getSessionStore: getSessionStoreForRequest,
     sessionChangesTracker,
     telemetry: opts.telemetry
   });
   await app.register(sessionRoutes, {
-    getSessionStore: async (request) => {
-      const binding = await getBindingForRequest(request);
-      return binding.harness.sessions;
-    },
+    getSessionStore: getSessionStoreForRequest,
     getRuntime: async (request) => {
       const binding = await getBindingForRequest(request);
       return {