@sentry/junior 0.115.0 → 0.116.1

package/dist/{chunk-43RYMWJ2.js → chunk-GDAXWEIJ.js}

@@ -25,7 +25,7 @@ import {
   surfaceFromRouting,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-LYA2AB5G.js";
+} from "./chunk-CGXLCMWI.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -41,6 +41,7 @@ import {
   getPiMessageRole,
   getTerminalAssistantMessages,
   hasRuntimeTurnContext,
+  historyItemFromPiMessage,
   isAssistantMessage,
   isContinuablePiBoundary,
   isToolResultError,
@@ -57,6 +58,7 @@ import {
   persistContinuationSessionRecord,
   persistRunningSessionRecord,
   persistYieldSessionRecord,
+  piMessageFromHistoryItem,
   recordAuthorizationRequested,
   recordMcpProviderConnected,
   recordToolExecutionStarted,
@@ -65,7 +67,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-CEYOL62C.js";
+} from "./chunk-RYFAVWP3.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -73,6 +75,7 @@ import {
   sandboxEgressCredentialLeaseSchema
 } from "./chunk-HDSDCEPK.js";
 import {
+  bindSandboxFileSystem,
   buildNonInteractiveShellScript,
   createSandboxSession,
   getRuntimeDependencyProfileHash,
@@ -88,7 +91,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-PVZHG2XZ.js";
+} from "./chunk-VBMMMVVQ.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -103,7 +106,7 @@ import {
   getPluginUserPromptContributions,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-RAVKCKXA.js";
+} from "./chunk-ZYHLNTC2.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -111,7 +114,7 @@ import {
   getStateAdapter,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-67CVNDJ7.js";
+} from "./chunk-7CSVG54J.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -120,15 +123,16 @@ import {
   isConversationScopedChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-CWEZEPD4.js";
+} from "./chunk-FAEALXEH.js";
 import {
+  KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
   getConversationEventStore,
   getConversationSearchStore,
   getConversationStore,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-HWCQRGLL.js";
+} from "./chunk-BFYVIOTS.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -161,8 +165,9 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-SYJT7AKB.js";
+} from "./chunk-CY7NXM32.js";
 import {
+  canExposeConversationPayload,
   parseSlackThreadId,
   resolveConversationPrivacy,
   runWithConversationPrivacy,
@@ -177,15 +182,15 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-2QG4MZQ7.js";
+} from "./chunk-DLLW5ITL.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-6FKLPVF3.js";
+} from "./chunk-OY2PQQ4P.js";
 import {
   CredentialUnavailableError,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-EW5MLKT5.js";
+} from "./chunk-XA3VLFPK.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -209,7 +214,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-NVUQSFWX.js";
+} from "./chunk-F3SWGSPG.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
@@ -2623,7 +2628,6 @@ ${usage}
     name: plugin.manifest.name,
     displayName: plugin.manifest.displayName,
     description: plugin.manifest.description,
-    capabilities: [...plugin.manifest.capabilities],
     configKeys: [...plugin.manifest.configKeys]
   })).sort((left, right) => left.name.localeCompare(right.name));
   return commandResult({
@@ -3020,7 +3024,6 @@ async function resolveSandboxCommandEnvironment() {
 // src/chat/sandbox/session.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { Sandbox } from "@vercel/sandbox";
-import { createBashTool } from "bash-tool";
 
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
@@ -3195,36 +3198,8 @@ var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
 var SNAPSHOT_BOOT_RETRY_COUNT = 3;
 var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
 var SANDBOX_NAME_PREFIX = "junior-";
-function createBashToolSandboxAdapter(sandbox) {
-  return {
-    async executeCommand(command) {
-      const result = await sandbox.runCommand({
-        cmd: "bash",
-        args: ["-c", command]
-      });
-      return {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: result.exitCode
-      };
-    },
-    async readFile(filePath) {
-      const content = await sandbox.readFileToBuffer({ path: filePath });
-      if (content == null) {
-        throw new Error(`File not found: ${filePath}`);
-      }
-      return content.toString("utf8");
-    },
-    async writeFiles(files) {
-      await sandbox.writeFiles(
-        files.map((file) => ({
-          path: file.path,
-          content: file.content
-        }))
-      );
-    }
-  };
-}
+var MAX_KEEPALIVE_INTERVAL_MS = 3e4;
+var MIN_KEEPALIVE_INTERVAL_MS = 1e3;
 function truncateOutput(output, maxLength) {
   if (output.length <= maxLength) {
     return { value: output, truncated: false };
@@ -3261,6 +3236,8 @@ function createSandboxRuntime(options) {
   const availableSkills = [...options.skills];
   const availableReferenceFiles = [...options.referenceFiles];
   let acquiringSandbox;
+  let keepAliveTimer;
+  let closed = false;
   const timeoutMs = options.timeoutMs ?? 1e3 * 60 * 30;
   const traceContext = options.traceContext ?? {};
   const dependencyProfileHash = getRuntimeDependencyProfileHash(SANDBOX_RUNTIME);
@@ -3271,6 +3248,10 @@ function createSandboxRuntime(options) {
       return;
     }
     activeSandbox = null;
+    if (keepAliveTimer) {
+      clearTimeout(keepAliveTimer);
+      keepAliveTimer = void 0;
+    }
   };
   const adaptSandbox = (vercelSandbox) => createSandboxSession(vercelSandbox, {
     onUnavailable: invalidateSession
@@ -3640,24 +3621,37 @@ function createSandboxRuntime(options) {
       }
     }
   };
-  const buildToolExecutors = async (sandboxInstance) => {
-    const toolkit = await withSandboxSpan(
-      "sandbox.bash_tool.init",
-      "sandbox.tool.init",
-      {
-        "app.sandbox.tool_name": "bash",
-        "app.sandbox.destination": SANDBOX_WORKSPACE_ROOT
-      },
-      async () => await createBashTool({
-        sandbox: createBashToolSandboxAdapter(sandboxInstance),
-        destination: SANDBOX_WORKSPACE_ROOT
-      })
-    );
-    const executeReadFile = toolkit.tools.readFile.execute;
-    const executeWriteFile = toolkit.tools.writeFile.execute;
-    if (!executeReadFile || !executeWriteFile) {
-      throw new Error("bash-tool did not return executable tool handlers");
+  const startKeepAlive = (session) => {
+    const keepAliveMs = parseKeepAliveMs();
+    if (keepAliveMs === 0 || closed || keepAliveTimer) {
+      return;
     }
+    const intervalMs = Math.max(
+      MIN_KEEPALIVE_INTERVAL_MS,
+      Math.min(MAX_KEEPALIVE_INTERVAL_MS, Math.floor(keepAliveMs / 2))
+    );
+    const schedule = () => {
+      keepAliveTimer = setTimeout(async () => {
+        keepAliveTimer = void 0;
+        if (closed || activeSandbox?.session !== session) {
+          return;
+        }
+        try {
+          await extendKeepAlive(session);
+        } catch {
+          invalidateSession(session.sessionId);
+          return;
+        }
+        if (closed || activeSandbox?.session !== session) {
+          return;
+        }
+        schedule();
+      }, intervalMs);
+      keepAliveTimer.unref?.();
+    };
+    schedule();
+  };
+  const createToolExecutors = (sandboxInstance) => {
     return {
       sessionId: sandboxInstance.sessionId,
       bash: async (input) => {
@@ -3725,50 +3719,17 @@ function createSandboxRuntime(options) {
           }
         }
       },
-      readFile: async (input) => await executeReadFile(input, {
-        toolCallId: "sandbox-read-file",
-        messages: []
-      }),
-      writeFile: async (input) => await executeWriteFile(input, {
-        toolCallId: "sandbox-write-file",
-        messages: []
-      }),
-      fs: sandboxInstance.fs
+      fs: sandboxInstance.fs,
+      runCommand: async (input) => await sandboxInstance.runCommand(input)
     };
   };
   const ensureReadySandbox = async () => {
     const activeSandbox2 = await getOrAcquireSandbox();
     await probeSession(activeSandbox2);
     await extendKeepAlive(activeSandbox2);
+    startKeepAlive(activeSandbox2);
     return activeSandbox2;
   };
-  const loadToolExecutors = async (session) => {
-    const active = activeSandbox;
-    if (!active || active.session !== session) {
-      throw new Error("sandbox session changed before tool initialization");
-    }
-    if (active.toolExecutors) {
-      return active.toolExecutors;
-    }
-    if (active.loadingToolExecutors) {
-      return await active.loadingToolExecutors;
-    }
-    let nextToolExecutors;
-    nextToolExecutors = buildToolExecutors(session).then((executors) => {
-      if (activeSandbox === active && active.loadingToolExecutors === nextToolExecutors) {
-        active.toolExecutors = executors;
-      }
-      return executors;
-    });
-    active.loadingToolExecutors = nextToolExecutors;
-    try {
-      return await nextToolExecutors;
-    } finally {
-      if (active.loadingToolExecutors === nextToolExecutors) {
-        active.loadingToolExecutors = void 0;
-      }
-    }
-  };
   return {
     sandboxRef() {
       return sandboxRef ? { ...sandboxRef } : void 0;
@@ -3777,7 +3738,7 @@ function createSandboxRuntime(options) {
       return await getOrAcquireSandbox();
     },
     async tools() {
-      return await loadToolExecutors(await ensureReadySandbox());
+      return createToolExecutors(await ensureReadySandbox());
     },
     async refreshNetworkPolicy(traceHeaders) {
       const active = activeSandbox;
@@ -3785,6 +3746,13 @@ function createSandboxRuntime(options) {
         return;
       }
       await applyNetworkPolicy(active.session, traceHeaders);
+    },
+    close() {
+      closed = true;
+      if (keepAliveTimer) {
+        clearTimeout(keepAliveTimer);
+        keepAliveTimer = void 0;
+      }
     }
   };
 }
@@ -3802,6 +3770,10 @@ var ToolInputError = class extends Error {
 
 // src/chat/tools/sandbox/file-utils.ts
 var MAX_TEXT_CHARS = 6e4;
+var RIPGREP_EXCLUDED_GLOBS = [
+  "!**/.git/**",
+  "!**/node_modules/**"
+];
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
 function positiveInteger(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -3905,6 +3877,15 @@ function resolveWorkspacePath(input, fallback = ".") {
   }
   return normalized;
 }
+function getRipgrepSearchLocation(root, rootIsDirectory) {
+  if (rootIsDirectory) {
+    return { cwd: root, target: "." };
+  }
+  return {
+    cwd: path4.posix.dirname(root),
+    target: path4.posix.basename(root)
+  };
+}
 async function collectFiles(params) {
   const files = [];
   let limitReached = false;
@@ -4387,6 +4368,16 @@ async function findFiles(params) {
   }
   const root = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_FIND_LIMIT;
+  if (params.runCommand) {
+    return await findFilesWithRipgrep({
+      fs: params.fs,
+      limit,
+      path: params.path,
+      pattern: params.pattern,
+      root,
+      runCommand: params.runCommand
+    });
+  }
   const { files, limitReached, missingPath, missingRoot } = await collectFiles({
     fs: params.fs,
     root,
@@ -4435,6 +4426,80 @@ async function findFiles(params) {
     { content: [{ type: "text", text }] }
   );
 }
+async function findFilesWithRipgrep(params) {
+  let rootIsDirectory;
+  try {
+    rootIsDirectory = (await params.fs.stat(params.root)).isDirectory();
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({
+        path: params.path ?? ".",
+        displayPath: params.path ?? "."
+      });
+    }
+    throw error;
+  }
+  const location = getRipgrepSearchLocation(params.root, rootIsDirectory);
+  const args = [
+    "--files",
+    "--null",
+    "--hidden",
+    "--sort=path",
+    "--glob",
+    params.pattern
+  ];
+  for (const excludedGlob of RIPGREP_EXCLUDED_GLOBS) {
+    args.push("--glob", excludedGlob);
+  }
+  args.push("--", location.target);
+  const result = await params.runCommand({
+    cmd: "rg",
+    args,
+    cwd: location.cwd
+  });
+  if (result.exitCode !== 0 && result.exitCode !== 1) {
+    const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
+    throw new Error(`ripgrep file search failed: ${detail}`);
+  }
+  const allPaths = result.stdout.split("\0").filter(Boolean).map((filePath) => {
+    const absolute = filePath.startsWith("/") ? path5.posix.normalize(filePath) : path5.posix.resolve(location.cwd, filePath);
+    return rootIsDirectory ? path5.posix.relative(params.root, absolute) : path5.posix.basename(absolute);
+  });
+  const limitReached = allPaths.length > params.limit;
+  const relativePaths = allPaths.slice(0, params.limit);
+  const bounded = truncateText(
+    relativePaths.length > 0 ? relativePaths.join("\n") : "No files found matching pattern"
+  );
+  const notices = [];
+  if (limitReached) {
+    notices.push(
+      `${params.limit} results limit reached. Refine pattern or raise limit.`
+    );
+  }
+  if (bounded.truncated) {
+    notices.push(`${MAX_TEXT_CHARS} character output limit reached.`);
+  }
+  const text = notices.length > 0 ? `${bounded.content}
+
+[${notices.join(" ")}]` : bounded.content;
+  return makeStructuredToolResult(
+    {
+      ok: true,
+      status: "success",
+      target: params.path ?? ".",
+      path: params.path ?? ".",
+      truncated: limitReached || bounded.truncated,
+      data: {
+        files: relativePaths,
+        file_count: relativePaths.length,
+        path: params.path ?? ".",
+        ...notices.length > 0 ? { truncation_reasons: notices } : {}
+      },
+      ...limitReached ? { result_limit_reached: params.limit } : {}
+    },
+    { content: [{ type: "text", text }] }
+  );
+}
 function createFindFilesTool() {
   return zodTool({
     description: "Find sandbox workspace files by glob pattern. Returns bounded paths relative to the search root and skips dependency/cache directories.",
@@ -4491,6 +4556,20 @@ async function grepFiles(params) {
   const root = resolveWorkspacePath(params.path);
   const limit = positiveInteger(params.limit) ?? DEFAULT_GREP_LIMIT;
   const context = positiveInteger(params.context) ?? 0;
+  if (params.runCommand) {
+    return await grepFilesWithRipgrep({
+      context,
+      fs: params.fs,
+      glob: params.glob,
+      ignoreCase: params.ignoreCase,
+      limit,
+      literal: params.literal,
+      path: params.path,
+      pattern: params.pattern,
+      root,
+      runCommand: params.runCommand
+    });
+  }
   let regex;
   if (!params.literal) {
     try {
@@ -4609,6 +4688,174 @@ async function grepFiles(params) {
     ...lineTruncated ? { line_truncated: true } : {}
   });
 }
+function decodeRipgrepText(value) {
+  if (typeof value?.text === "string") {
+    return value.text;
+  }
+  if (typeof value?.bytes === "string") {
+    return Buffer.from(value.bytes, "base64").toString("utf8");
+  }
+  return "";
+}
+async function grepFilesWithRipgrep(params) {
+  let rootIsDirectory;
+  try {
+    rootIsDirectory = (await params.fs.stat(params.root)).isDirectory();
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return missingPathSearchResult({
+        path: params.path ?? ".",
+        displayPath: params.path ?? "."
+      });
+    }
+    throw error;
+  }
+  const location = getRipgrepSearchLocation(params.root, rootIsDirectory);
+  const args = ["--json", "--line-number", "--hidden", "--sort=path"];
+  if (params.ignoreCase) {
+    args.push("--ignore-case");
+  }
+  if (params.literal) {
+    args.push("--fixed-strings");
+  }
+  if (params.glob) {
+    args.push("--glob", params.glob);
+  }
+  for (const excludedGlob of RIPGREP_EXCLUDED_GLOBS) {
+    args.push("--glob", excludedGlob);
+  }
+  if (params.context > 0) {
+    args.push("--context", String(params.context));
+  }
+  args.push("--", params.pattern, location.target);
+  const result = await params.runCommand({
+    cmd: "rg",
+    args,
+    cwd: location.cwd
+  });
+  if (result.exitCode !== 0 && result.exitCode !== 1) {
+    const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
+    if (/regex parse error|error parsing regex/i.test(detail)) {
+      throw new ToolInputError(`Invalid regex pattern: ${params.pattern}`, {
+        cause: new Error(detail)
+      });
+    }
+    throw new Error(`ripgrep search failed: ${detail}`);
+  }
+  const recordsByPath = /* @__PURE__ */ new Map();
+  const pathOrder = [];
+  let totalMatches = 0;
+  for (const rawLine of normalizeToLf(result.stdout).split("\n")) {
+    if (!rawLine) {
+      continue;
+    }
+    let record;
+    try {
+      record = JSON.parse(rawLine);
+    } catch (error) {
+      throw new Error("ripgrep returned invalid JSON output", { cause: error });
+    }
+    if (record.type !== "match" && record.type !== "context") {
+      continue;
+    }
+    const line = record.data?.line_number;
+    const rawPath = decodeRipgrepText(record.data?.path);
+    if (!line || !rawPath) {
+      continue;
+    }
+    const absolutePath = rawPath.startsWith("/") ? path6.posix.normalize(rawPath) : path6.posix.resolve(location.cwd, rawPath);
+    const displayPath = rootIsDirectory ? path6.posix.relative(params.root, absolutePath) : path6.posix.basename(absolutePath);
+    let records = recordsByPath.get(displayPath);
+    if (!records) {
+      records = [];
+      recordsByPath.set(displayPath, records);
+      pathOrder.push(displayPath);
+    }
+    const matched = record.type === "match";
+    if (matched) {
+      totalMatches += 1;
+    }
+    records.push({
+      line,
+      matched,
+      text: decodeRipgrepText(record.data?.lines).replace(/\r?\n$/, "")
+    });
+  }
+  let remainingMatches = params.limit;
+  const output = [];
+  let lineTruncated = false;
+  for (const displayPath of pathOrder) {
+    const records = recordsByPath.get(displayPath) ?? [];
+    const selectedMatchLines = [];
+    for (const record of records) {
+      if (record.matched && remainingMatches > 0) {
+        selectedMatchLines.push(record.line);
+        remainingMatches -= 1;
+      }
+    }
+    if (selectedMatchLines.length === 0) {
+      continue;
+    }
+    const selectedMatchSet = new Set(selectedMatchLines);
+    const emittedLines = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      if (emittedLines.has(record.line)) {
+        continue;
+      }
+      const include = selectedMatchLines.some(
+        (matchLine) => Math.abs(record.line - matchLine) <= params.context
+      );
+      if (!include) {
+        continue;
+      }
+      emittedLines.add(record.line);
+      const truncated = truncateGrepLine(record.text);
+      lineTruncated ||= truncated.truncated;
+      const separator = selectedMatchSet.has(record.line) ? ":" : "-";
+      output.push(
+        `${displayPath}${separator}${record.line}${separator} ${truncated.line}`
+      );
+    }
+  }
+  const matchCount = Math.min(totalMatches, params.limit);
+  const matchLimitReached = totalMatches > params.limit;
+  const bounded = truncateText(
+    output.length > 0 ? output.join("\n") : "No matches found"
+  );
+  const notices = [];
+  if (matchLimitReached) {
+    notices.push(
+      `${params.limit} matches limit reached. Refine pattern or raise limit.`
+    );
+  }
+  if (lineTruncated) {
+    notices.push(
+      `Some lines were truncated to ${MAX_GREP_LINE_CHARS} characters.`
+    );
+  }
+  if (bounded.truncated) {
+    notices.push(`${MAX_TEXT_CHARS} character output limit reached.`);
+  }
+  return makeStructuredToolResult({
+    ok: true,
+    status: "success",
+    target: params.path ?? ".",
+    path: params.path ?? ".",
+    truncated: matchLimitReached || lineTruncated || bounded.truncated,
+    data: {
+      context: params.context,
+      ...params.glob ? { glob: params.glob } : {},
+      line_count: output.length,
+      lines: bounded.content === "No matches found" ? [] : bounded.content.split("\n"),
+      match_count: matchCount,
+      pattern: params.pattern,
+      path: params.path ?? ".",
+      ...notices.length > 0 ? { truncation_reasons: notices } : {}
+    },
+    ...matchLimitReached ? { match_limit_reached: params.limit } : {},
+    ...lineTruncated ? { line_truncated: true } : {}
+  });
+}
 function createGrepTool() {
   return zodTool({
     description: "Search sandbox workspace file contents. Returns bounded matching lines with file paths and line numbers. Respects path/glob filters and includes truncation notices.",
@@ -4738,6 +4985,7 @@ import { z as z8 } from "zod";
 
 // src/chat/tool-support/text-range-result.ts
 var DEFAULT_READ_LIMIT = 1e3;
+var MAX_READ_CHARS = 6e4;
 function positiveInteger2(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return void 0;
@@ -4757,16 +5005,42 @@ function sliceFileContent(params) {
   const maxLines = requestedLimit ?? DEFAULT_READ_LIMIT;
   const startIndex = Math.min(lines.length, startLine - 1);
   const selected = lines.slice(startIndex, startIndex + maxLines);
-  const endLine = selected.length > 0 ? startLine + selected.length - 1 : startLine - 1;
-  const truncated = startIndex > 0 || endLine < lines.length;
+  const returnedLines = [];
+  let returnedCharacters = 0;
+  let characterLimitReached = false;
+  let lineTruncated = false;
+  for (const line of selected) {
+    const separatorLength = returnedLines.length > 0 ? 1 : 0;
+    if (returnedCharacters + separatorLength + line.length <= MAX_READ_CHARS) {
+      returnedLines.push(line);
+      returnedCharacters += separatorLength + line.length;
+      continue;
+    }
+    characterLimitReached = true;
+    if (returnedLines.length === 0) {
+      returnedLines.push(line.slice(0, MAX_READ_CHARS));
+      lineTruncated = true;
+    }
+    break;
+  }
+  const endLine = returnedLines.length > 0 ? startLine + returnedLines.length - 1 : startLine - 1;
+  const truncated = startIndex > 0 || endLine < lines.length || characterLimitReached;
   const rangeRequested = requestedOffset !== void 0 || requestedLimit !== void 0;
-  const returnedContent = !rangeRequested && !truncated ? params.content : selected.join("\n");
+  const returnedContent = !rangeRequested && !truncated ? params.content : returnedLines.join("\n");
+  const truncationReasons = [];
+  if (characterLimitReached) {
+    truncationReasons.push(`${MAX_READ_CHARS} character output limit reached.`);
+  }
+  if (lineTruncated) {
+    truncationReasons.push(`Line ${startLine} was truncated.`);
+  }
   const range = {
     content: returnedContent,
     end_line: selected.length > 0 ? endLine : void 0,
     path: params.path,
     start_line: startLine,
     total_lines: lines.length,
+    ...truncationReasons.length > 0 ? { truncation_reasons: truncationReasons } : {},
     truncated
   };
   return makeStructuredToolResult({
@@ -4775,6 +5049,8 @@ function sliceFileContent(params) {
     target: params.path,
     data: range,
     truncated,
+    ...characterLimitReached ? { character_limit_reached: MAX_READ_CHARS } : {},
+    ...lineTruncated ? { line_truncated: true } : {},
     ...endLine < lines.length ? {
       continuation: {
         arguments: {
@@ -4782,7 +5058,7 @@ function sliceFileContent(params) {
           offset: endLine + 1,
           limit: maxLines
         },
-        reason: "file has more lines"
+        reason: characterLimitReached ? "character output limit reached; file has more lines" : "file has more lines"
       }
     } : {}
   });
@@ -4918,6 +5194,30 @@ function createSandbox(options) {
     onSandboxPrepare: options.prepare,
     onSandboxRefChanged: options.onSandboxRefChanged
   });
+  const createToolCallContext = (signal) => {
+    let fileSystemPromise;
+    let commandRunnerPromise;
+    return {
+      signal,
+      fileSystem() {
+        signal?.throwIfAborted();
+        return fileSystemPromise ??= runtime.tools().then(({ fs: fs5 }) => {
+          signal?.throwIfAborted();
+          return bindSandboxFileSystem(fs5, signal);
+        });
+      },
+      commandRunner() {
+        signal?.throwIfAborted();
+        return commandRunnerPromise ??= runtime.tools().then(({ runCommand }) => {
+          signal?.throwIfAborted();
+          return async (input) => await runCommand({
+            ...input,
+            ...signal ? { signal } : {}
+          });
+        });
+      }
+    };
+  };
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
   const withSandboxToolSpan = (name, op, attributes, callback) => withSandboxSpan(name, op, attributes, async () => {
     await runtime.refreshNetworkPolicy(getTracePropagationHeaders());
@@ -4937,7 +5237,7 @@ function createSandbox(options) {
       "Sandbox boot requested"
     );
   };
-  const executeBashTool = async (rawInput, command, signal) => {
+  const executeBashTool = async (rawInput, command, context) => {
     const env = parseEnv(rawInput.env);
     const timeoutMs = positiveInteger(rawInput.timeoutMs);
     logSandboxBootRequest("tool.bash", {
@@ -4957,7 +5257,7 @@ function createSandbox(options) {
             command,
             ...env ? { env } : {},
             ...timeoutMs ? { timeoutMs } : {},
-            ...signal ? { signal } : {}
+            ...context.signal ? { signal: context.signal } : {}
           });
           setSpanAttributes({
             "process.exit.code": response.exitCode,
@@ -4999,7 +5299,7 @@ function createSandbox(options) {
       ...permissionDenied ? { permission_denied: permissionDenied } : {}
     });
   };
-  const executeReadFileTool = async (rawInput) => {
+  const executeReadFileTool = async (rawInput, context) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
       throw new ToolInputError("path is required");
@@ -5010,7 +5310,10 @@ function createSandbox(options) {
       const hostPath = resolveHostSkillPath(options.skills, filePath) ?? resolveHostDataPath(options.referenceFiles, filePath);
       if (hostPath) {
         try {
-          const content = await fs4.readFile(hostPath, "utf8");
+          const content = await fs4.readFile(hostPath, {
+            encoding: "utf8",
+            ...context.signal ? { signal: context.signal } : {}
+          });
           setSpanAttributes({
             "app.sandbox.path.length": filePath.length,
             "app.sandbox.read.bytes": Buffer.byteLength(content, "utf8"),
@@ -5034,7 +5337,7 @@ function createSandbox(options) {
     logSandboxBootRequest("tool.readFile", {
       "file.path": filePath
     });
-    const executeReadFile = (await runtime.tools()).readFile;
+    const fileSystem = await context.fileSystem();
     const result = await withSandboxToolSpan(
       "sandbox.readFile",
       "sandbox.fs.read",
@@ -5044,7 +5347,11 @@ function createSandbox(options) {
       async () => {
         let response;
         try {
-          response = await executeReadFile({ path: filePath });
+          response = {
+            content: await fileSystem.readFile(resolveWorkspacePath(filePath), {
+              encoding: "utf8"
+            })
+          };
         } catch (error) {
           if (isMissingPathError(error)) {
             setSpanStatus("ok");
@@ -5070,16 +5377,17 @@ function createSandbox(options) {
     );
     return result;
   };
-  const executeWriteFileTool = async (rawInput) => {
+  const executeWriteFileTool = async (rawInput, context) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
       throw new ToolInputError("path is required");
     }
+    const workspacePath = resolveWorkspacePath(filePath);
     const content = String(rawInput.content ?? "");
     logSandboxBootRequest("tool.writeFile", {
       "file.path": filePath
     });
-    const executeWriteFile = (await runtime.tools()).writeFile;
+    const fileSystem = await context.fileSystem();
     await withSandboxToolSpan(
       "sandbox.writeFile",
       "sandbox.fs.write",
@@ -5089,8 +5397,13 @@ function createSandbox(options) {
       },
       async () => {
         try {
-          await executeWriteFile({ path: filePath, content });
+          await fileSystem.writeFile(workspacePath, content, {
+            encoding: "utf8"
+          });
         } catch (error) {
+          if (context.signal?.aborted) {
+            throw error;
+          }
           throwSandboxOperationError("sandbox writeFile", error);
         }
         setSpanStatus("ok");
@@ -5108,7 +5421,7 @@ function createSandbox(options) {
       bytes_written: Buffer.byteLength(content, "utf8")
     });
   };
-  const executeEditFileTool = async (rawInput) => {
+  const executeEditFileTool = async (rawInput, context) => {
     const filePath = String(rawInput.path ?? "").trim();
     if (!filePath) {
       throw new ToolInputError("path is required");
@@ -5119,7 +5432,7 @@ function createSandbox(options) {
     logSandboxBootRequest("tool.editFile", {
       "file.path": filePath
     });
-    const executors = await runtime.tools();
+    const fileSystem = await context.fileSystem();
     const result = await withSandboxToolSpan(
       "sandbox.editFile",
       "sandbox.fs.edit",
@@ -5129,7 +5442,7 @@ function createSandbox(options) {
       },
       async () => {
         const response = await editFile({
-          fs: executors.fs,
+          fs: fileSystem,
           path: filePath,
           edits: rawInput.edits
         });
@@ -5139,7 +5452,7 @@ function createSandbox(options) {
     );
     return result;
   };
-  const executeGrepTool = async (rawInput) => {
+  const executeGrepTool = async (rawInput, context) => {
     const pattern = String(rawInput.pattern ?? "");
     if (!pattern) {
       throw new ToolInputError("pattern is required");
@@ -5147,7 +5460,7 @@ function createSandbox(options) {
     logSandboxBootRequest("tool.grep");
     const contextLines = positiveInteger(rawInput.context);
     const limit = positiveInteger(rawInput.limit);
-    const executors = await runtime.tools();
+    const fileSystem = await context.fileSystem();
     const result = await withSandboxToolSpan(
       "sandbox.grep",
       "sandbox.fs.search",
@@ -5156,7 +5469,8 @@ function createSandbox(options) {
       },
       async () => {
         const response = await grepFiles({
-          fs: executors.fs,
+          fs: fileSystem,
+          runCommand: await context.commandRunner(),
           pattern,
           ...typeof rawInput.path === "string" ? { path: rawInput.path } : {},
           ...typeof rawInput.glob === "string" ? { glob: rawInput.glob } : {},
@@ -5171,14 +5485,14 @@ function createSandbox(options) {
     );
     return result;
   };
-  const executeFindFilesTool = async (rawInput) => {
+  const executeFindFilesTool = async (rawInput, context) => {
     const pattern = String(rawInput.pattern ?? "");
     if (!pattern) {
       throw new ToolInputError("pattern is required");
     }
     logSandboxBootRequest("tool.findFiles");
     const limit = positiveInteger(rawInput.limit);
-    const executors = await runtime.tools();
+    const fileSystem = await context.fileSystem();
     const result = await withSandboxToolSpan(
       "sandbox.findFiles",
       "sandbox.fs.find",
@@ -5187,7 +5501,8 @@ function createSandbox(options) {
       },
       async () => {
         const response = await findFiles({
-          fs: executors.fs,
+          fs: fileSystem,
+          runCommand: await context.commandRunner(),
           pattern,
           ...typeof rawInput.path === "string" ? { path: rawInput.path } : {},
           ...limit ? { limit } : {}
@@ -5198,17 +5513,17 @@ function createSandbox(options) {
     );
     return result;
   };
-  const executeListDirTool = async (rawInput) => {
+  const executeListDirTool = async (rawInput, context) => {
     logSandboxBootRequest("tool.listDir");
     const limit = positiveInteger(rawInput.limit);
-    const executors = await runtime.tools();
+    const fileSystem = await context.fileSystem();
     const result = await withSandboxToolSpan(
       "sandbox.listDir",
       "sandbox.fs.list",
       {},
       async () => {
         const response = await listDir({
-          fs: executors.fs,
+          fs: fileSystem,
           ...typeof rawInput.path === "string" ? { path: rawInput.path } : {},
           ...limit ? { limit } : {}
         });
@@ -5220,6 +5535,7 @@ function createSandbox(options) {
   };
   const execute = async (params) => {
     const rawInput = params.input ?? {};
+    const context = createToolCallContext(params.signal);
     const bashCommand2 = params.toolName === "bash" ? String(rawInput.command ?? "").trim() : void 0;
     if (params.toolName === "bash") {
       if (!bashCommand2) {
@@ -5228,27 +5544,28 @@ function createSandbox(options) {
     }
     try {
       if (bashCommand2 !== void 0) {
-        return await executeBashTool(rawInput, bashCommand2, params.signal);
+        return await executeBashTool(rawInput, bashCommand2, context);
       }
       if (params.toolName === "readFile") {
-        return await executeReadFileTool(rawInput);
+        return await executeReadFileTool(rawInput, context);
       }
       if (params.toolName === "editFile") {
-        return await executeEditFileTool(rawInput);
+        return await executeEditFileTool(rawInput, context);
       }
       if (params.toolName === "grep") {
-        return await executeGrepTool(rawInput);
+        return await executeGrepTool(rawInput, context);
       }
       if (params.toolName === "findFiles") {
-        return await executeFindFilesTool(rawInput);
+        return await executeFindFilesTool(rawInput, context);
       }
       if (params.toolName === "listDir") {
-        return await executeListDirTool(rawInput);
+        return await executeListDirTool(rawInput, context);
       }
       if (params.toolName === "writeFile") {
-        return await executeWriteFileTool(rawInput);
+        return await executeWriteFileTool(rawInput, context);
       }
     } catch (error) {
+      params.signal?.throwIfAborted();
       if (isSandboxUnavailableError(error)) {
         throw createSandboxUnavailableToolError(params.toolName, error);
       }
@@ -5295,6 +5612,9 @@ function createSandbox(options) {
     },
     sandboxRef() {
       return runtime.sandboxRef();
+    },
+    close() {
+      runtime.close();
     }
   };
 }
@@ -5494,6 +5814,7 @@ function createAgentSandbox(options) {
   return {
     workspace: sandbox.workspace,
     sandboxRef: sandbox.sandboxRef,
+    close: sandbox.close,
     tools: {
       supports: sandbox.tools.supports,
       async execute(params) {
@@ -6077,7 +6398,7 @@ var McpToolManager = class {
   }
   toManagedTool(plugin, client, tool) {
     const outputSchema = toOptionalRecord(tool.outputSchema);
-    const annotations = toOptionalRecord(tool.annotations);
+    const annotations = tool.annotations;
     return {
       name: normalizeMcpToolName(plugin.manifest.name, tool.name),
       description: describeMcpTool(plugin.manifest.name, tool),
@@ -6224,7 +6545,7 @@ function serializeMcpPayload(payload, privacy, options = {}) {
 
 // src/chat/tools/sandbox/bash.ts
 import { z as z10 } from "zod";
-function createBashTool2() {
+function createBashTool() {
   return zodTool({
     description: "Run a bash command inside the isolated sandbox workspace. Use this for repository inspection/execution tasks that need shell access. Do not use for network-sensitive or destructive actions unless explicitly required.",
     inputSchema: z10.object({
@@ -9646,11 +9967,249 @@ function createSystemTimeTool() {
   });
 }
 
-// src/chat/tools/handoff/tool.ts
+// src/chat/tools/query-conversation-events.ts
 import { z as z36 } from "zod";
+var DEFAULT_LIMIT3 = 25;
+var MAX_LIMIT = 100;
+var CONVERSATION_EVENTS_TOOL_SOURCE = {
+  id: "conversation-events",
+  description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
+};
+var knownEventTypeSchema = z36.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z36.object({
+  seq: z36.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
+  history_version: z36.number().int().nonnegative().describe(
+    "Model-history generation. It increments when handoff or compaction replaces active model context."
+  ),
+  created_at: z36.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z36.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
+  data: z36.record(z36.string(), z36.unknown()).describe(
+    "Event payload. The type field identifies the event; replacement-history events report replacement_history_count instead of replaying the full model context."
+  )
+}).strict();
+var queryConversationEventsOutputSchema = juniorToolResultSchema.extend({
+  conversation_id: z36.string().min(1),
+  events: z36.array(projectedEventSchema),
+  has_older: z36.boolean().describe(
+    "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
+  ),
+  has_newer: z36.boolean().describe(
+    "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
+  )
+});
+function createQueryConversationEventsTool(context) {
+  return zodTool({
+    description: "Inspect Junior's stored turns, tool calls, handoffs, and compaction events when debugging its behavior. Returns events from the current conversation tree or another retained public conversation in the same Slack workspace, newest first by default.",
+    exposure: "deferred",
+    source: CONVERSATION_EVENTS_TOOL_SOURCE,
+    annotations: { readOnlyHint: true, destructiveHint: false },
+    inputSchema: z36.object({
+      conversation_id: z36.string().trim().min(1).describe(
+        "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
+      ),
+      after_seq: z36.number().int().nonnegative().nullable().describe(
+        "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
+      ).optional(),
+      before_seq: z36.number().int().nonnegative().nullable().describe(
+        "Exclusive upper bound on event seq. Combine with defaults or after_seq to page older or bounded ranges."
+      ).optional(),
+      limit: z36.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+        `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
+      ).optional(),
+      types: z36.array(knownEventTypeSchema).min(1).nullable().describe(
+        "Optional event-type filter. Omit to return every durable event type."
+      ).optional()
+    }).strict(),
+    outputSchema: queryConversationEventsOutputSchema,
+    execute: async (input) => {
+      const currentConversationId = context.conversationId?.trim();
+      if (!currentConversationId) {
+        throw new ToolInputError(
+          "queryConversationEvents requires an active conversation"
+        );
+      }
+      const conversationId = input.conversation_id;
+      const afterSeq = input.after_seq ?? void 0;
+      const beforeSeq = input.before_seq ?? void 0;
+      const limit = input.limit ?? DEFAULT_LIMIT3;
+      const types = input.types ?? void 0;
+      if (afterSeq !== void 0 && beforeSeq !== void 0 && afterSeq >= beforeSeq) {
+        throw new ToolInputError(
+          "after_seq must be less than before_seq when both are provided"
+        );
+      }
+      const conversationStore = getConversationStore();
+      const target = await conversationStore.get({ conversationId });
+      if (!target) {
+        throw new ToolInputError(`Conversation not found: ${conversationId}`);
+      }
+      if (target.transcriptPurgedAtMs !== void 0) {
+        throw new ToolInputError(
+          `Conversation transcript was purged: ${conversationId}`
+        );
+      }
+      const accessScope = await resolveAccessScope(
+        conversationStore,
+        context,
+        currentConversationId
+      );
+      const targetRootConversationId = await resolveRootConversationId(
+        conversationStore,
+        conversationId,
+        target.lineage?.parentConversationId
+      );
+      const targetRoot = targetRootConversationId === conversationId ? target : await conversationStore.get({
+        conversationId: targetRootConversationId
+      });
+      assertCanQueryConversationEvents({
+        accessScope,
+        targetConversationId: conversationId,
+        targetRootConversationId,
+        targetVisibility: targetRoot?.visibility ?? target.visibility,
+        targetDestination: targetRoot?.destination ?? target.destination
+      });
+      const page = await getConversationEventStore().query(conversationId, {
+        limit,
+        ...afterSeq === void 0 ? {} : { afterSeq },
+        ...beforeSeq === void 0 ? {} : { beforeSeq },
+        ...types === void 0 ? {} : { types }
+      });
+      const events = projectEventsForTool(page);
+      return {
+        ok: true,
+        status: "success",
+        conversation_id: conversationId,
+        events,
+        has_older: page.hasOlder,
+        has_newer: page.hasNewer
+      };
+    }
+  });
+}
+async function resolveAccessScope(conversationStore, context, currentConversationId) {
+  const current = await conversationStore.get({
+    conversationId: currentConversationId
+  });
+  const currentRootConversationId = current ? await resolveRootConversationId(
+    conversationStore,
+    currentConversationId,
+    current.lineage?.parentConversationId
+  ) : currentConversationId;
+  if (context.source.platform === "slack") {
+    return {
+      currentConversationId,
+      currentRootConversationId,
+      provider: "slack",
+      providerTenantId: context.source.teamId
+    };
+  }
+  if (context.destination.platform === "slack" && "teamId" in context.destination) {
+    return {
+      currentConversationId,
+      currentRootConversationId,
+      provider: "slack",
+      providerTenantId: context.destination.teamId
+    };
+  }
+  return {
+    currentConversationId,
+    currentRootConversationId
+  };
+}
+async function resolveRootConversationId(conversationStore, conversationId, parentConversationId) {
+  if (!parentConversationId) {
+    return conversationId;
+  }
+  let cursor = parentConversationId;
+  const seen = /* @__PURE__ */ new Set([conversationId]);
+  while (cursor) {
+    if (seen.has(cursor)) {
+      return conversationId;
+    }
+    seen.add(cursor);
+    const parent = await conversationStore.get({ conversationId: cursor });
+    if (!parent) {
+      return conversationId;
+    }
+    if (!parent.lineage?.parentConversationId) {
+      return parent.conversationId;
+    }
+    cursor = parent.lineage.parentConversationId;
+  }
+  return conversationId;
+}
+function assertCanQueryConversationEvents(args) {
+  const {
+    accessScope,
+    targetConversationId,
+    targetRootConversationId,
+    targetVisibility,
+    targetDestination
+  } = args;
+  if (targetConversationId === accessScope.currentConversationId || targetRootConversationId !== void 0 && targetRootConversationId === accessScope.currentRootConversationId) {
+    return;
+  }
+  const publicPayloadAllowed = canExposeConversationPayload({
+    conversationId: targetRootConversationId ?? targetConversationId,
+    ...targetVisibility ? { visibility: targetVisibility } : {},
+    ...targetDestination?.platform === "slack" ? { channelId: targetDestination.channelId } : {}
+  });
+  if (!publicPayloadAllowed) {
+    throw new ToolInputError(
+      `Conversation events are not accessible: ${targetConversationId}`
+    );
+  }
+  if (accessScope.provider === "slack" && targetDestination?.platform === "slack" && accessScope.providerTenantId && targetDestination.teamId === accessScope.providerTenantId) {
+    return;
+  }
+  throw new ToolInputError(
+    `Conversation events are not accessible: ${targetConversationId}`
+  );
+}
+function projectEventsForTool(page) {
+  return page.events.map(projectEvent);
+}
+function projectEvent(event) {
+  const data = stripReplacementHistory(event.data);
+  return {
+    seq: event.seq,
+    history_version: event.historyVersion,
+    created_at: new Date(event.createdAtMs).toISOString(),
+    ...event.idempotencyKey ? { idempotency_key: event.idempotencyKey } : {},
+    data
+  };
+}
+function stripReplacementHistory(data) {
+  if (data.type === "unknown") {
+    return {
+      ...data,
+      payload: stripReplacementHistoryField(data.payload)
+    };
+  }
+  if (data.type === "compaction" || data.type === "handoff") {
+    return stripReplacementHistoryField(data);
+  }
+  return data;
+}
+function stripReplacementHistoryField(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const { replacementHistory, ...rest } = value;
+  if (replacementHistory === void 0) {
+    return value;
+  }
+  return {
+    ...rest,
+    replacement_history_count: Array.isArray(replacementHistory) ? replacementHistory.length : 0
+  };
+}
+
+// src/chat/tools/handoff/tool.ts
+import { z as z37 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z36.enum(handoff.profiles);
+  const profileSchema = z37.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: profileSchema
   });
@@ -9658,7 +10217,7 @@ function createHandoffTool(handoff) {
   return zodTool({
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z36.object({
+    inputSchema: z37.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -9681,7 +10240,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -10131,9 +10690,9 @@ function createWebFetchTool(hooks, options = {}) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z37.object({
-      url: z37.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z37.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z38.object({
+      url: z38.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z38.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, max_chars }) => {
@@ -10194,7 +10753,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -10243,9 +10802,9 @@ function createWebSearchTool(modelId, override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z38.object({
-      query: z38.string().min(1).max(500).describe("Search query."),
-      max_results: z38.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z39.object({
+      query: z39.string().min(1).max(500).describe("Search query."),
+      max_results: z39.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -10314,14 +10873,14 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or deliberate full-file replacement after validation; use editFile instead for targeted changes to existing files. Do not use for exploratory analysis-only turns.",
     executionMode: "sequential",
-    inputSchema: z39.object({
-      path: z39.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z39.string().describe("UTF-8 file content to write.")
+    inputSchema: z40.object({
+      path: z40.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z40.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -10374,7 +10933,7 @@ function createTools(availableSkills, hooks = {}, context) {
     }),
     reportProgress: createReportProgressTool(),
     systemTime: createSystemTimeTool(),
-    bash: createBashTool2(),
+    bash: createBashTool(),
     readFile: createReadFileTool(),
     editFile: createEditFileTool(),
     grep: createGrepTool(),
@@ -10390,6 +10949,9 @@ function createTools(availableSkills, hooks = {}, context) {
     }),
     ...createResourceEventTools(context)
   };
+  if (context.conversationId) {
+    tools.queryConversationEvents = createQueryConversationEventsTool(context);
+  }
   if (hooks.writeGeneratedArtifacts) {
     tools.imageGenerate = createImageGenerateTool(
       {
@@ -11063,17 +11625,17 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z40.object({
-      tool_name: z40.string().min(1).describe(
+    inputSchema: z41.object({
+      tool_name: z41.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z40.record(z40.string(), z40.unknown()).describe(
+      arguments: z41.record(z41.string(), z41.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -11113,42 +11675,42 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z41.object({
-  id: z41.string(),
-  description: z41.string()
+var searchToolsSourceSchema = z42.object({
+  id: z42.string(),
+  description: z42.string()
 }).strict();
-var toolCallExampleSchema = z41.object({
-  tool_name: z41.string(),
-  arguments: z41.record(z41.string(), z41.string())
+var toolCallExampleSchema = z42.object({
+  tool_name: z42.string(),
+  arguments: z42.record(z42.string(), z42.string())
 }).strict();
-var searchToolsToolSchema = z41.object({
-  tool_name: z41.string(),
-  description: z41.string(),
-  exposure: z41.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z41.string().optional(),
-  signature: z41.string(),
+var searchToolsToolSchema = z42.object({
+  tool_name: z42.string(),
+  description: z42.string(),
+  exposure: z42.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z42.string().optional(),
+  signature: z42.string(),
   call: toolCallExampleSchema,
-  input_schema: z41.unknown(),
-  input_schema_summary: z41.string(),
-  call_notes: z41.array(z41.string()),
-  annotations: z41.record(z41.string(), z41.unknown())
+  input_schema: z42.unknown(),
+  input_schema_summary: z42.string(),
+  call_notes: z42.array(z42.string()),
+  annotations: z42.record(z42.string(), z42.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z41.string().nullable(),
-  source: z41.string().nullable(),
-  sources: z41.array(searchToolsSourceSchema),
-  total_catalog_tools: z41.number().int().nonnegative(),
-  total_eligible_tools: z41.number().int().nonnegative(),
-  total_matches: z41.number().int().nonnegative(),
-  returned_tools: z41.number().int().nonnegative(),
-  execution_tool: z41.literal("executeTool"),
+  query: z42.string().nullable(),
+  source: z42.string().nullable(),
+  sources: z42.array(searchToolsSourceSchema),
+  total_catalog_tools: z42.number().int().nonnegative(),
+  total_eligible_tools: z42.number().int().nonnegative(),
+  total_matches: z42.number().int().nonnegative(),
+  returned_tools: z42.number().int().nonnegative(),
+  execution_tool: z42.literal("executeTool"),
   execution_example: toolCallExampleSchema,
-  tools: z41.array(searchToolsToolSchema)
+  tools: z42.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -11340,14 +11902,14 @@ function createSearchToolsTool(catalogTools) {
   return zodTool({
     description: renderSearchToolsDescription(knownSources),
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z41.object({
-      query: z41.string().nullable().describe(
+    inputSchema: z42.object({
+      query: z42.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z41.string().nullable().describe(
+      source: z42.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z41.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z42.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -12859,6 +13421,21 @@ async function wireAgentTools(args) {
     mcpToolManager,
     pluginHooks,
     getSandboxRef: agentSandbox.sandboxRef,
+    async close() {
+      agentSandbox.close();
+      try {
+        await mcpToolManager.close();
+      } catch (closeError) {
+        logWarn(
+          "mcp_tool_manager_close_failed",
+          {},
+          {
+            "exception.message": closeError instanceof Error ? closeError.message : String(closeError)
+          },
+          "Failed to close MCP tool manager"
+        );
+      }
+    },
     toolGuidance,
     toolRuntimeContext
   };
@@ -12884,6 +13461,7 @@ function createResumeState(args) {
     channelName: args.channelName,
     conversationId: args.conversationId,
     destination: args.destination,
+    ...args.dispatchId ? { dispatchId: args.dispatchId } : {},
     source: args.runSource,
     sessionId: args.turnId,
     loadedSkillNames: args.getLoadedSkillNames(),
@@ -13249,12 +13827,29 @@ function estimateHistoryTokens(messages) {
 }
 function buildReplacementProvenance(args) {
   return [
-    ...args.retained.map(
-      (entry) => args.sourceProvenance[entry.sourceIndex] ?? contextProvenance
-    ),
+    ...args.retained.map((entry) => {
+      const provenance = args.sourceProvenance[entry.sourceIndex];
+      if (!provenance) {
+        throw new Error("retained message provenance is missing");
+      }
+      return provenance;
+    }),
     contextProvenance
   ];
 }
+async function loadLastInstruction(conversationId) {
+  const event = await getConversationEventStore().loadLatestInstruction(conversationId);
+  if (!event) return void 0;
+  if (event.data.type === "user_message") {
+    if (event.data.provenance.authority !== "instruction") return void 0;
+    return {
+      message: piMessageFromHistoryItem(event.data),
+      provenance: event.data.provenance,
+      sourceEventSeq: event.seq
+    };
+  }
+  return void 0;
+}
 function loadCompactionSource(messages) {
   if (messages.length > 0) {
     return {
@@ -13346,8 +13941,10 @@ ${summary}`)
       replacementHistory: replacement.map((message, index) => {
         const sourceEventSeq = index < retained.length ? sourceProjection.seqs[retained[index].sourceIndex] : void 0;
         return {
-          message,
-          provenance: replacementProvenance[index],
+          item: historyItemFromPiMessage(
+            message,
+            replacementProvenance[index]
+          ),
           ...sourceEventSeq === void 0 ? {} : { sourceEventSeq }
         };
       })
@@ -13399,8 +13996,7 @@ ${generatedSummary}`;
       ...args.triggeringToolCallId ? { triggeringToolCallId: args.triggeringToolCallId } : {},
       summary: generatedSummary,
       replacementHistory: replacementMessages.map((replacementMessage) => ({
-        message: replacementMessage,
-        provenance: contextProvenance
+        item: historyItemFromPiMessage(replacementMessage, contextProvenance)
       }))
     }
   });
@@ -13464,14 +14060,14 @@ ${summary}`;
       ...runtimeMessage,
       content: [
         ...runtimeMessage.content,
-        { type: "text", text: renderCurrentInstruction(summaryText) }
+        { type: "text", text: summaryText }
       ]
     }
-  ] : [userMessage(renderCurrentInstruction(summaryText))];
-  const messages = [
-    ...summaryMessages,
-    ...pendingMessages.map((entry) => entry.message)
-  ];
+  ] : [userMessage(summaryText)];
+  const retainedInstruction = pendingMessages.length === 0 ? await loadLastInstruction(args.conversationId) : void 0;
+  const instructionMessages = retainedInstruction ? [retainedInstruction.message] : pendingMessages.map((entry) => entry.message);
+  const instructionProvenance = retainedInstruction ? [retainedInstruction.provenance] : pendingMessages.map((entry) => entry.provenance);
+  const messages = [...summaryMessages, ...instructionMessages];
   const replacementInputTokens = estimateHistoryTokens(messages);
   if (replacementInputTokens >= inputLimitTokens) {
     throw new ContextInputLimitExceededError(
@@ -13480,6 +14076,11 @@ ${summary}`;
     );
   }
   const replacementMessages = stripRuntimeTurnContext(messages);
+  if (replacementMessages.length !== 1 + instructionProvenance.length) {
+    throw new Error(
+      "persisted instruction provenance must align one-to-one with messages"
+    );
+  }
   args.signal?.throwIfAborted();
   await getConversationEventStore().replaceHistory(args.conversationId, {
     createdAtMs: Date.now(),
@@ -13494,20 +14095,23 @@ ${summary}`;
         triggerTokens,
         inputLimitTokens,
         inputMessageCount: source.messages.length,
-        retainedMessageCount: pendingMessages.length,
+        retainedMessageCount: instructionMessages.length,
         summaryChars: summary.length
       },
       summary,
-      replacementHistory: replacementMessages.map((message, index) => ({
-        message,
-        provenance: index === 0 ? contextProvenance : pendingMessages[index - 1]?.provenance ?? contextProvenance
-      }))
+      replacementHistory: replacementMessages.map((message, index) => {
+        const provenance = index === 0 ? contextProvenance : instructionProvenance[index - 1];
+        return {
+          item: historyItemFromPiMessage(message, provenance),
+          ...index === 1 && retainedInstruction ? { sourceEventSeq: retainedInstruction.sourceEventSeq } : {}
+        };
+      })
     }
   });
   setSpanAttributes({
     "app.compaction.input_messages": source.messages.length,
     "app.compaction.replacement_tokens": replacementInputTokens,
-    "app.compaction.retained_messages": pendingMessages.length,
+    "app.compaction.retained_messages": instructionMessages.length,
     "app.compaction.summary_chars": summary.length,
     "app.compaction.trigger_tokens": triggerTokens,
     "app.context_input_limit_tokens": inputLimitTokens,
@@ -13612,6 +14216,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
   let resume;
   let lastKnownSandboxRef = state.sandboxRef;
   let mcpToolManager;
+  let closeTools;
   let connectedMcpProviders = /* @__PURE__ */ new Set();
   let turnUsage;
   let priorPhaseUsage;
@@ -13717,6 +14322,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     resume = createResumeState({
       channelName: routing.slackConversation?.name,
       destination: routing.destination,
+      ...routing.dispatch?.id ? { dispatchId: routing.dispatch.id } : {},
       durability,
       getLoadedSkillNames: () => loadedSkillNamesForResume,
       getReasoningLevel: () => turnRoute?.reasoningLevel,
@@ -13977,6 +14583,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       userInput
     });
     mcpToolManager = wiring.mcpToolManager;
+    closeTools = wiring.close;
     const getPendingAuthPause = wiring.getPendingAuthPause;
     const toolsAfterHandoff = wiring.agentTools;
     const {
@@ -14576,18 +15183,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       }
     };
   } finally {
-    try {
-      await mcpToolManager?.close();
-    } catch (closeError) {
-      logWarn(
-        "mcp_tool_manager_close_failed",
-        {},
-        {
-          "exception.message": closeError instanceof Error ? closeError.message : String(closeError)
-        },
-        "Failed to close MCP tool manager"
-      );
-    }
+    await closeTools?.();
   }
 }