@shareai-lab/kode 2.0.2 → 2.0.3

package/dist/chunks/chunk-TNWB3U5Y.js

@@ -0,0 +1,2077 @@
+import {
+  appendSessionJsonlFromMessage
+} from "./chunk-UVDJL6ZZ.js";
+import {
+  kodeMessageToSdkMessage
+} from "./chunk-CDGRYGPZ.js";
+import {
+  formatSystemPromptWithContext,
+  getCodeStyle,
+  getContext
+} from "./chunk-HPYNW6TT.js";
+import {
+  emitReminderEvent,
+  getAgentFilePath,
+  systemReminderService
+} from "./chunk-LOD5ZHCI.js";
+import {
+  asRecord,
+  drainHookSystemPromptAdditions,
+  getHookTranscriptPath,
+  queueHookAdditionalContexts,
+  queueHookSystemMessages,
+  runPostToolUseHooks,
+  runPreToolUseHooks,
+  runStopHooks,
+  runUserPromptSubmitHooks,
+  updateHookTranscriptForMessages
+} from "./chunk-3BYE3ME6.js";
+import {
+  setRequestStatus
+} from "./chunk-LOCXPQNJ.js";
+import {
+  queryLLM
+} from "./chunk-BHDHXOXB.js";
+import {
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  REJECT_MESSAGE,
+  SYNTHETIC_ASSISTANT_MESSAGES,
+  createAssistantMessage,
+  createProgressMessage,
+  createUserMessage,
+  normalizeMessagesForAPI
+} from "./chunk-HRJ3ICQK.js";
+import {
+  getModelManager
+} from "./chunk-6ZWEOSEI.js";
+import {
+  debug,
+  getCurrentRequest,
+  logUserFriendly,
+  markPhase
+} from "./chunk-YIO5EBMQ.js";
+import {
+  execFileNoThrow,
+  getPlanModeSystemPromptAdditions,
+  hydratePlanSlugFromMessages,
+  logError
+} from "./chunk-3OEJVB5A.js";
+import {
+  getCwd
+} from "./chunk-BBJFHTBC.js";
+import {
+  BunShell,
+  renderBackgroundShellStatusAttachment,
+  renderBashNotification
+} from "./chunk-B3MW3YGY.js";
+
+// packages/core/src/utils/tokens.ts
+function countTokens(messages) {
+  let i = messages.length - 1;
+  while (i >= 0) {
+    const message = messages[i];
+    if (message?.type === "assistant" && "usage" in message.message && !(message.message.content[0]?.type === "text" && SYNTHETIC_ASSISTANT_MESSAGES.has(message.message.content[0].text))) {
+      const { usage } = message.message;
+      return usage.input_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + usage.output_tokens;
+    }
+    i--;
+  }
+  return 0;
+}
+
+// packages/core/src/messages.ts
+var getMessages = () => [];
+var setMessages = () => {
+};
+function setMessagesGetter(getter) {
+  getMessages = getter;
+}
+function getMessagesGetter() {
+  return getMessages;
+}
+function setMessagesSetter(setter) {
+  setMessages = setter;
+}
+function getMessagesSetter() {
+  return setMessages;
+}
+var onModelConfigChange = null;
+function setModelConfigChangeHandler(handler) {
+  onModelConfigChange = handler;
+}
+function triggerModelConfigChange() {
+  if (onModelConfigChange) {
+    onModelConfigChange();
+  }
+}
+
+// packages/core/src/services/fileFreshness.ts
+import { statSync, existsSync, watchFile, unwatchFile } from "fs";
+var FileFreshnessService = class {
+  state = {
+    readTimestamps: /* @__PURE__ */ new Map(),
+    editConflicts: /* @__PURE__ */ new Set(),
+    sessionFiles: /* @__PURE__ */ new Set(),
+    watchedTodoFiles: /* @__PURE__ */ new Map()
+  };
+  constructor() {
+    this.setupEventListeners();
+  }
+  /**
+   * Setup event listeners for session management
+   */
+  setupEventListeners() {
+    systemReminderService.addEventListener(
+      "session:startup",
+      (context) => {
+        this.resetSession();
+      }
+    );
+  }
+  /**
+   * Record file read operation with timestamp tracking
+   */
+  recordFileRead(filePath) {
+    try {
+      if (!existsSync(filePath)) {
+        return;
+      }
+      const stats = statSync(filePath);
+      const timestamp = {
+        path: filePath,
+        lastRead: Date.now(),
+        lastModified: stats.mtimeMs,
+        size: stats.size
+      };
+      this.state.readTimestamps.set(filePath, timestamp);
+      this.state.sessionFiles.add(filePath);
+      emitReminderEvent("file:read", {
+        filePath,
+        timestamp: timestamp.lastRead,
+        size: timestamp.size,
+        modified: timestamp.lastModified
+      });
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_RECORD_READ_FAILED", {
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Check if file has been modified since last read
+   */
+  checkFileFreshness(filePath) {
+    const recorded = this.state.readTimestamps.get(filePath);
+    if (!recorded) {
+      return { isFresh: true, conflict: false };
+    }
+    try {
+      if (!existsSync(filePath)) {
+        return { isFresh: false, conflict: true };
+      }
+      const currentStats = statSync(filePath);
+      const isFresh = currentStats.mtimeMs <= recorded.lastModified;
+      const conflict = !isFresh;
+      if (conflict) {
+        this.state.editConflicts.add(filePath);
+        emitReminderEvent("file:conflict", {
+          filePath,
+          lastRead: recorded.lastRead,
+          lastModified: recorded.lastModified,
+          currentModified: currentStats.mtimeMs,
+          sizeDiff: currentStats.size - recorded.size
+        });
+      }
+      return {
+        isFresh,
+        lastRead: recorded.lastRead,
+        currentModified: currentStats.mtimeMs,
+        conflict
+      };
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_CHECK_FAILED", {
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return { isFresh: false, conflict: true };
+    }
+  }
+  /**
+   * Record file edit operation by Agent
+   */
+  recordFileEdit(filePath, content) {
+    try {
+      const now = Date.now();
+      if (existsSync(filePath)) {
+        const stats = statSync(filePath);
+        const existing = this.state.readTimestamps.get(filePath);
+        if (existing) {
+          existing.lastModified = stats.mtimeMs;
+          existing.size = stats.size;
+          existing.lastAgentEdit = now;
+          this.state.readTimestamps.set(filePath, existing);
+        } else {
+          const timestamp = {
+            path: filePath,
+            lastRead: now,
+            lastModified: stats.mtimeMs,
+            size: stats.size,
+            lastAgentEdit: now
+          };
+          this.state.readTimestamps.set(filePath, timestamp);
+        }
+      }
+      this.state.editConflicts.delete(filePath);
+      emitReminderEvent("file:edited", {
+        filePath,
+        timestamp: now,
+        contentLength: content?.length || 0,
+        source: "agent"
+      });
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_RECORD_EDIT_FAILED", {
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  generateFileModificationReminder(filePath) {
+    const recorded = this.state.readTimestamps.get(filePath);
+    if (!recorded) {
+      return null;
+    }
+    try {
+      if (!existsSync(filePath)) {
+        return `Note: ${filePath} was deleted since last read.`;
+      }
+      const currentStats = statSync(filePath);
+      const isModified = currentStats.mtimeMs > recorded.lastModified;
+      if (!isModified) {
+        return null;
+      }
+      const TIME_TOLERANCE_MS = 100;
+      if (recorded.lastAgentEdit && recorded.lastAgentEdit >= recorded.lastModified - TIME_TOLERANCE_MS) {
+        return null;
+      }
+      return `Note: ${filePath} was modified externally since last read. The file may have changed outside of this session.`;
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_CHECK_MODIFICATION_FAILED", {
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  getConflictedFiles() {
+    return Array.from(this.state.editConflicts);
+  }
+  getSessionFiles() {
+    return Array.from(this.state.sessionFiles);
+  }
+  resetSession() {
+    this.state.watchedTodoFiles.forEach((filePath) => {
+      try {
+        unwatchFile(filePath);
+      } catch (error) {
+        logError(error);
+        debug.warn("FILE_FRESHNESS_UNWATCH_FAILED", {
+          filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    this.state = {
+      readTimestamps: /* @__PURE__ */ new Map(),
+      editConflicts: /* @__PURE__ */ new Set(),
+      sessionFiles: /* @__PURE__ */ new Set(),
+      watchedTodoFiles: /* @__PURE__ */ new Map()
+    };
+  }
+  /**
+   * Start watching todo file for an agent
+   */
+  startWatchingTodoFile(agentId) {
+    try {
+      const filePath = getAgentFilePath(agentId);
+      if (this.state.watchedTodoFiles.has(agentId)) {
+        return;
+      }
+      this.state.watchedTodoFiles.set(agentId, filePath);
+      if (existsSync(filePath)) {
+        this.recordFileRead(filePath);
+      }
+      watchFile(filePath, { interval: 1e3 }, (curr, prev) => {
+        const reminder = this.generateFileModificationReminder(filePath);
+        if (reminder) {
+          emitReminderEvent("todo:file_changed", {
+            agentId,
+            filePath,
+            reminder,
+            timestamp: Date.now(),
+            currentStats: { mtime: curr.mtime, size: curr.size },
+            previousStats: { mtime: prev.mtime, size: prev.size }
+          });
+        }
+      });
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_TODO_WATCH_START_FAILED", {
+        agentId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Stop watching todo file for an agent
+   */
+  stopWatchingTodoFile(agentId) {
+    try {
+      const filePath = this.state.watchedTodoFiles.get(agentId);
+      if (filePath) {
+        unwatchFile(filePath);
+        this.state.watchedTodoFiles.delete(agentId);
+      }
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_FRESHNESS_TODO_WATCH_STOP_FAILED", {
+        agentId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  getFileInfo(filePath) {
+    return this.state.readTimestamps.get(filePath) || null;
+  }
+  isFileTracked(filePath) {
+    return this.state.readTimestamps.has(filePath);
+  }
+  /**
+   * Retrieves files prioritized for recovery during conversation compression
+   *
+   * Selects recently accessed files based on:
+   * - File access recency (most recent first)
+   * - File type relevance (excludes dependencies, build artifacts)
+   * - Development workflow importance
+   *
+   * Used to maintain coding context when conversation history is compressed
+   */
+  getImportantFiles(maxFiles = 5) {
+    return Array.from(this.state.readTimestamps.entries()).map(([path2, info]) => ({
+      path: path2,
+      timestamp: info.lastRead,
+      size: info.size
+    })).filter((file) => this.isValidForRecovery(file.path)).sort((a, b) => b.timestamp - a.timestamp).slice(0, maxFiles);
+  }
+  /**
+   * Determines which files are suitable for automatic recovery
+   *
+   * Excludes files that are typically not relevant for development context:
+   * - Build artifacts and generated files
+   * - Dependencies and cached files
+   * - Temporary files and system directories
+   */
+  isValidForRecovery(filePath) {
+    return !filePath.includes("node_modules") && !filePath.includes(".git") && !filePath.startsWith("/tmp") && !filePath.includes(".cache") && !filePath.includes("dist/") && !filePath.includes("build/");
+  }
+};
+var fileFreshnessService = new FileFreshnessService();
+var recordFileRead = (filePath) => fileFreshnessService.recordFileRead(filePath);
+var recordFileEdit = (filePath, content) => fileFreshnessService.recordFileEdit(filePath, content);
+var generateFileModificationReminder = (filePath) => fileFreshnessService.generateFileModificationReminder(filePath);
+var resetFileFreshnessSession = () => fileFreshnessService.resetSession();
+var startWatchingTodoFile = (agentId) => fileFreshnessService.startWatchingTodoFile(agentId);
+
+// packages/core/src/utils/file.ts
+import {
+  readFileSync,
+  writeFileSync,
+  openSync,
+  readSync,
+  closeSync,
+  existsSync as existsSync3,
+  readdirSync
+} from "fs";
+import {
+  isAbsolute,
+  normalize,
+  resolve as resolve2,
+  resolve as resolvePath,
+  relative,
+  sep,
+  basename,
+  dirname as dirname2,
+  extname,
+  join as join2
+} from "path";
+import { cwd } from "process";
+
+// packages/core/src/utils/ripgrep.ts
+import { findActualExecutable } from "spawn-rx";
+import { memoize } from "lodash-es";
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as path from "path";
+import { execFile } from "child_process";
+import debug2 from "debug";
+import { quote } from "shell-quote";
+var d = debug2("kode:ripgrep");
+function getCurrentModuleUrl() {
+  if (typeof __filename === "string" && __filename) {
+    return pathToFileURL(__filename).href;
+  }
+  return import.meta.url;
+}
+function getVscodeRipgrepPathOrThrow() {
+  try {
+    const req = createRequire(getCurrentModuleUrl());
+    const mod = req("@vscode/ripgrep");
+    if (typeof mod?.rgPath === "string" && mod.rgPath.trim()) return mod.rgPath;
+  } catch (err) {
+    throw new Error(
+      [
+        "@vscode/ripgrep is required but could not be loaded.",
+        "Fix:",
+        "- Reinstall dependencies: bun install",
+        "- Or install ripgrep system-wide and ensure `rg` is on PATH",
+        err instanceof Error ? `Reason: ${err.message}` : ""
+      ].filter(Boolean).join("\n")
+    );
+  }
+  throw new Error("Invalid @vscode/ripgrep export: rgPath missing");
+}
+function findRipgrepVendorRoot() {
+  const explicit = process.env.KODE_RIPGREP_VENDOR_ROOT;
+  if (explicit && existsSync2(explicit)) {
+    return explicit;
+  }
+  const startDir = path.dirname(fileURLToPath(getCurrentModuleUrl()));
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    const direct = path.join(dir, "vendor", "ripgrep");
+    if (existsSync2(direct)) return direct;
+    const distVendor = path.join(dir, "dist", "vendor", "ripgrep");
+    if (existsSync2(distVendor)) return distVendor;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveExplicitRipgrepPathOrThrow() {
+  const explicit = process.env.KODE_RIPGREP_PATH;
+  if (!explicit) return null;
+  if (!existsSync2(explicit)) {
+    throw new Error(`KODE_RIPGREP_PATH points to a missing file: ${explicit}`);
+  }
+  return explicit;
+}
+function resolveVendorRipgrepPathOrNull() {
+  const rgRoot = findRipgrepVendorRoot();
+  if (!rgRoot) {
+    return null;
+  }
+  if (process.platform === "win32") {
+    const candidates = [`${process.arch}-win32`, "x64-win32"];
+    for (const dirName of candidates) {
+      const p = path.resolve(rgRoot, dirName, "rg.exe");
+      if (existsSync2(p)) {
+        d("internal ripgrep resolved as: %s", p);
+        return p;
+      }
+    }
+    return null;
+  }
+  const ret = path.resolve(rgRoot, `${process.arch}-${process.platform}`, "rg");
+  if (!existsSync2(ret)) {
+    return null;
+  }
+  d("internal ripgrep resolved as: %s", ret);
+  return ret;
+}
+var getRipgrepPath = memoize(() => {
+  const explicit = resolveExplicitRipgrepPathOrThrow();
+  if (explicit) return explicit;
+  const vscodeRgPath = getVscodeRipgrepPathOrThrow();
+  const useBuiltinRipgrep = !!process.env.USE_BUILTIN_RIPGREP;
+  if (useBuiltinRipgrep) {
+    d("Using builtin ripgrep because USE_BUILTIN_RIPGREP is set");
+    const vendor2 = resolveVendorRipgrepPathOrNull();
+    if (vendor2) return vendor2;
+    return vscodeRgPath;
+  }
+  const { cmd } = findActualExecutable("rg", []);
+  d(`ripgrep initially resolved as: ${cmd}`);
+  if (cmd !== "rg") return cmd;
+  const vendor = resolveVendorRipgrepPathOrNull();
+  if (vendor) return vendor;
+  return vscodeRgPath;
+});
+async function ripGrep(args, target, abortSignal, options) {
+  await codesignRipgrepIfNecessary();
+  const rg = getRipgrepPath();
+  d("ripgrep called: %s %o", rg, target, args);
+  if (options?.sandbox?.enabled === true) {
+    const cmd = quote([rg, ...args, target]);
+    const result = await BunShell.getInstance().exec(cmd, abortSignal, 1e4, {
+      sandbox: options.sandbox
+    });
+    if (result.code === 1) return [];
+    if (result.code !== 0) {
+      logError(`ripgrep failed with exit code ${result.code}: ${result.stderr}`);
+      return [];
+    }
+    return result.stdout.trim().split("\n").filter(Boolean);
+  }
+  return new Promise((resolve3) => {
+    execFile(
+      getRipgrepPath(),
+      [...args, target],
+      {
+        maxBuffer: 1e6,
+        signal: abortSignal,
+        timeout: 1e4
+      },
+      (error, stdout) => {
+        if (error) {
+          if (error.code !== 1) {
+            d("ripgrep error: %o", error);
+            logError(error);
+          }
+          resolve3([]);
+        } else {
+          d("ripgrep succeeded with %s", stdout);
+          resolve3(stdout.trim().split("\n").filter(Boolean));
+        }
+      }
+    );
+  });
+}
+async function listAllContentFiles(path2, abortSignal, limit) {
+  try {
+    d("listAllContentFiles called: %s", path2);
+    return (await ripGrep(["-l", ".", path2], path2, abortSignal)).slice(0, limit);
+  } catch (e) {
+    d("listAllContentFiles failed: %o", e);
+    logError(e);
+    return [];
+  }
+}
+var alreadyDoneSignCheck = false;
+async function codesignRipgrepIfNecessary() {
+  if (process.platform !== "darwin" || alreadyDoneSignCheck) {
+    return;
+  }
+  alreadyDoneSignCheck = true;
+  d("checking if ripgrep is already signed");
+  const lines = (await execFileNoThrow(
+    "codesign",
+    ["-vv", "-d", getRipgrepPath()],
+    void 0,
+    void 0,
+    false
+  )).stdout.split("\n");
+  const needsSigned = lines.find((line) => line.includes("linker-signed"));
+  if (!needsSigned) {
+    d("seems to be already signed");
+    return;
+  }
+  try {
+    d("signing ripgrep");
+    const signResult = await execFileNoThrow("codesign", [
+      "--sign",
+      "-",
+      "--force",
+      "--preserve-metadata=entitlements,requirements,flags,runtime",
+      getRipgrepPath()
+    ]);
+    if (signResult.code !== 0) {
+      d("failed to sign ripgrep: %o", signResult);
+      logError(
+        `Failed to sign ripgrep: ${signResult.stdout} ${signResult.stderr}`
+      );
+    }
+    d("removing quarantine");
+    const quarantineResult = await execFileNoThrow("xattr", [
+      "-d",
+      "com.apple.quarantine",
+      getRipgrepPath()
+    ]);
+    if (quarantineResult.code !== 0) {
+      d("failed to remove quarantine: %o", quarantineResult);
+      logError(
+        `Failed to remove quarantine: ${quarantineResult.stdout} ${quarantineResult.stderr}`
+      );
+    }
+  } catch (e) {
+    d("failed during sign: %o", e);
+    logError(e);
+  }
+}
+
+// packages/core/src/utils/file.ts
+import { LRUCache } from "lru-cache";
+
+// packages/core/src/utils/file/glob.ts
+import { glob as globLib } from "glob";
+
+// packages/runtime/src/searcher.ts
+import { glob } from "glob";
+
+// packages/core/src/utils/file.ts
+function isInDirectory(relativePath, relativeCwd) {
+  if (relativePath === ".") {
+    return true;
+  }
+  if (relativePath.startsWith("~")) {
+    return false;
+  }
+  if (relativePath.includes("\0") || relativeCwd.includes("\0")) {
+    return false;
+  }
+  let normalizedPath = normalize(relativePath);
+  let normalizedCwd = normalize(relativeCwd);
+  normalizedPath = normalizedPath.endsWith(sep) ? normalizedPath : normalizedPath + sep;
+  normalizedCwd = normalizedCwd.endsWith(sep) ? normalizedCwd : normalizedCwd + sep;
+  const fullPath = resolvePath(cwd(), normalizedCwd, normalizedPath);
+  const fullCwd = resolvePath(cwd(), normalizedCwd);
+  const rel = relative(fullCwd, fullPath);
+  if (!rel || rel === "") return true;
+  if (rel.startsWith("..")) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+function readTextContent(filePath, offset = 0, maxLines) {
+  const enc = detectFileEncoding(filePath);
+  const content = readFileSync(filePath, enc);
+  const lines = content.split(/\r?\n/);
+  const toReturn = maxLines !== void 0 && lines.length - offset > maxLines ? lines.slice(offset, offset + maxLines) : lines.slice(offset);
+  return {
+    content: toReturn.join("\n"),
+    // NOTE: Normalizes line endings to LF for display/LLM consumption.
+    lineCount: toReturn.length,
+    totalLines: lines.length
+  };
+}
+function writeTextContent(filePath, content, encoding, endings) {
+  let toWrite = content;
+  if (endings === "CRLF") {
+    toWrite = content.split("\n").join("\r\n");
+  }
+  writeFileSync(filePath, toWrite, { encoding, flush: true });
+}
+var repoEndingCache = new LRUCache({
+  fetchMethod: (path2) => detectRepoLineEndingsDirect(path2),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+async function detectRepoLineEndings(filePath) {
+  return repoEndingCache.fetch(resolve2(filePath));
+}
+async function detectRepoLineEndingsDirect(cwd2) {
+  const abortController = new AbortController();
+  setTimeout(() => {
+    abortController.abort();
+  }, 1e3);
+  const allFiles = await listAllContentFiles(cwd2, abortController.signal, 15);
+  let crlfCount = 0;
+  for (const file of allFiles) {
+    const lineEnding = detectLineEndings(file);
+    if (lineEnding === "CRLF") {
+      crlfCount++;
+    }
+  }
+  return crlfCount > 3 ? "CRLF" : "LF";
+}
+function fetch(cache, key, value) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  const v = value();
+  cache.set(key, v);
+  return v;
+}
+var fileEncodingCache = new LRUCache({
+  fetchMethod: (path2) => detectFileEncodingDirect(path2),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+function detectFileEncoding(filePath) {
+  const k = resolve2(filePath);
+  return fetch(fileEncodingCache, k, () => detectFileEncodingDirect(k));
+}
+function detectFileEncodingDirect(filePath) {
+  const BUFFER_SIZE = 4096;
+  const buffer = Buffer.alloc(BUFFER_SIZE);
+  let fd = void 0;
+  try {
+    fd = openSync(filePath, "r");
+    const bytesRead = readSync(fd, buffer, 0, BUFFER_SIZE, 0);
+    if (bytesRead >= 2) {
+      if (buffer[0] === 255 && buffer[1] === 254) return "utf16le";
+    }
+    if (bytesRead >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+      return "utf8";
+    }
+    const isUtf8 = buffer.slice(0, bytesRead).toString("utf8").length > 0;
+    return isUtf8 ? "utf8" : "ascii";
+  } catch (error) {
+    logError(`Error detecting encoding for file ${filePath}: ${error}`);
+    return "utf8";
+  } finally {
+    if (fd) closeSync(fd);
+  }
+}
+var lineEndingCache = new LRUCache({
+  fetchMethod: (path2) => detectLineEndingsDirect(path2),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+function detectLineEndings(filePath) {
+  const k = resolve2(filePath);
+  return fetch(lineEndingCache, k, () => detectLineEndingsDirect(k));
+}
+function detectLineEndingsDirect(filePath, encoding = "utf8") {
+  try {
+    const buffer = Buffer.alloc(4096);
+    const fd = openSync(filePath, "r");
+    const bytesRead = readSync(fd, buffer, 0, 4096, 0);
+    closeSync(fd);
+    const content = buffer.toString(encoding, 0, bytesRead);
+    let crlfCount = 0;
+    let lfCount = 0;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") {
+        if (i > 0 && content[i - 1] === "\r") {
+          crlfCount++;
+        } else {
+          lfCount++;
+        }
+      }
+    }
+    return crlfCount > lfCount ? "CRLF" : "LF";
+  } catch (error) {
+    logError(`Error detecting line endings for file ${filePath}: ${error}`);
+    return "LF";
+  }
+}
+function normalizeFilePath(filePath) {
+  const absoluteFilePath = isAbsolute(filePath) ? filePath : resolve2(getCwd(), filePath);
+  if (absoluteFilePath.endsWith(" AM.png")) {
+    return absoluteFilePath.replace(
+      " AM.png",
+      `${String.fromCharCode(8239)}AM.png`
+    );
+  }
+  if (absoluteFilePath.endsWith(" PM.png")) {
+    return absoluteFilePath.replace(
+      " PM.png",
+      `${String.fromCharCode(8239)}PM.png`
+    );
+  }
+  return absoluteFilePath;
+}
+function getAbsolutePath(path2) {
+  return path2 ? isAbsolute(path2) ? path2 : resolve2(getCwd(), path2) : void 0;
+}
+function getAbsoluteAndRelativePaths(path2) {
+  const absolutePath = getAbsolutePath(path2);
+  const relativePath = absolutePath ? relative(getCwd(), absolutePath) : void 0;
+  return { absolutePath, relativePath };
+}
+function findSimilarFile(filePath) {
+  try {
+    const dir = dirname2(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+    if (!existsSync3(dir)) {
+      return void 0;
+    }
+    const files = readdirSync(dir);
+    const similarFiles = files.filter(
+      (file) => basename(file, extname(file)) === fileBaseName && join2(dir, file) !== filePath
+    );
+    const firstMatch = similarFiles[0];
+    if (firstMatch) {
+      return firstMatch;
+    }
+    return void 0;
+  } catch (error) {
+    logError(`Error finding similar file for ${filePath}: ${error}`);
+    return void 0;
+  }
+}
+function addLineNumbers({
+  content,
+  // 1-indexed
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  return content.split(/\r?\n/).map((line, index) => {
+    const lineNum = index + startLine;
+    const numStr = String(lineNum);
+    if (numStr.length >= 6) {
+      return `${numStr}\u2192${line}`;
+    }
+    return `${numStr.padStart(6, " ")}\u2192${line}`;
+  }).join("\n");
+}
+function isDirEmpty(dirPath) {
+  try {
+    const entries = readdirSync(dirPath);
+    return entries.length === 0;
+  } catch (error) {
+    logError(`Error checking directory: ${error}`);
+    return false;
+  }
+}
+
+// packages/core/src/utils/fileRecoveryCore.ts
+var MAX_FILES_TO_RECOVER = 5;
+var MAX_TOKENS_PER_FILE = 1e4;
+var MAX_TOTAL_FILE_TOKENS = 5e4;
+async function selectAndReadFiles() {
+  const importantFiles = fileFreshnessService.getImportantFiles(MAX_FILES_TO_RECOVER);
+  const results = [];
+  let totalTokens = 0;
+  for (const fileInfo of importantFiles) {
+    try {
+      const { content } = readTextContent(fileInfo.path);
+      const estimatedTokens = Math.ceil(content.length * 0.25);
+      let finalContent = content;
+      let truncated = false;
+      if (estimatedTokens > MAX_TOKENS_PER_FILE) {
+        const maxChars = Math.floor(MAX_TOKENS_PER_FILE / 0.25);
+        finalContent = content.substring(0, maxChars);
+        truncated = true;
+      }
+      const finalTokens = Math.min(estimatedTokens, MAX_TOKENS_PER_FILE);
+      if (totalTokens + finalTokens > MAX_TOTAL_FILE_TOKENS) {
+        break;
+      }
+      totalTokens += finalTokens;
+      results.push({
+        path: fileInfo.path,
+        content: finalContent,
+        tokens: finalTokens,
+        truncated
+      });
+    } catch (error) {
+      logError(error);
+      debug.warn("FILE_RECOVERY_READ_FAILED", {
+        path: fileInfo.path,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+
+// packages/core/src/utils/autoCompactThreshold.ts
+var AUTO_COMPACT_THRESHOLD_RATIO = 0.9;
+function calculateAutoCompactThresholds(tokenCount, contextLimit, ratio = AUTO_COMPACT_THRESHOLD_RATIO) {
+  const safeContextLimit = Number.isFinite(contextLimit) && contextLimit > 0 ? contextLimit : 1;
+  const autoCompactThreshold = safeContextLimit * ratio;
+  return {
+    isAboveAutoCompactThreshold: tokenCount >= autoCompactThreshold,
+    percentUsed: Math.round(tokenCount / safeContextLimit * 100),
+    tokensRemaining: Math.max(0, autoCompactThreshold - tokenCount),
+    contextLimit: safeContextLimit,
+    autoCompactThreshold,
+    ratio
+  };
+}
+
+// packages/core/src/utils/autoCompactCore.ts
+async function getMainConversationContextLimit() {
+  try {
+    const modelManager = getModelManager();
+    const resolution = modelManager.resolveModelWithInfo("main");
+    const modelProfile = resolution.success ? resolution.profile : null;
+    if (modelProfile?.contextLength) {
+      return modelProfile.contextLength;
+    }
+    return 2e5;
+  } catch (error) {
+    return 2e5;
+  }
+}
+var COMPRESSION_PROMPT = `Please provide a comprehensive summary of our conversation structured as follows:
+
+## Technical Context
+Development environment, tools, frameworks, and configurations in use. Programming languages, libraries, and technical constraints. File structure, directory organization, and project architecture.
+
+## Project Overview  
+Main project goals, features, and scope. Key components, modules, and their relationships. Data models, APIs, and integration patterns.
+
+## Code Changes
+Files created, modified, or analyzed during our conversation. Specific code implementations, functions, and algorithms added. Configuration changes and structural modifications.
+
+## Debugging & Issues
+Problems encountered and their root causes. Solutions implemented and their effectiveness. Error messages, logs, and diagnostic information.
+
+## Current Status
+What we just completed successfully. Current state of the codebase and any ongoing work. Test results, validation steps, and verification performed.
+
+## Pending Tasks
+Immediate next steps and priorities. Planned features, improvements, and refactoring. Known issues, technical debt, and areas needing attention.
+
+## User Preferences
+Coding style, formatting, and organizational preferences. Communication patterns and feedback style. Tool choices and workflow preferences.
+
+## Key Decisions
+Important technical decisions made and their rationale. Alternative approaches considered and why they were rejected. Trade-offs accepted and their implications.
+
+Focus on information essential for continuing the conversation effectively, including specific details about code, files, errors, and plans.`;
+async function calculateThresholds(tokenCount) {
+  const contextLimit = await getMainConversationContextLimit();
+  return calculateAutoCompactThresholds(
+    tokenCount,
+    contextLimit,
+    AUTO_COMPACT_THRESHOLD_RATIO
+  );
+}
+async function shouldAutoCompact(messages) {
+  if (messages.length < 3) return false;
+  const tokenCount = countTokens(messages);
+  const { isAboveAutoCompactThreshold } = await calculateThresholds(tokenCount);
+  return isAboveAutoCompactThreshold;
+}
+async function checkAutoCompact(messages, toolUseContext) {
+  if (!await shouldAutoCompact(messages)) {
+    return { messages, wasCompacted: false };
+  }
+  try {
+    const compactedMessages = await executeAutoCompact(messages, toolUseContext);
+    return {
+      messages: compactedMessages,
+      wasCompacted: true
+    };
+  } catch (error) {
+    logError(error);
+    debug.warn("AUTO_COMPACT_FAILED", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { messages, wasCompacted: false };
+  }
+}
+async function executeAutoCompact(messages, toolUseContext) {
+  const summaryRequest = createUserMessage(COMPRESSION_PROMPT);
+  const tokenCount = countTokens(messages);
+  const modelManager = getModelManager();
+  const compactResolution = modelManager.resolveModelWithInfo("compact");
+  const mainResolution = modelManager.resolveModelWithInfo("main");
+  let compressionModelPointer = "compact";
+  let compressionNotice = null;
+  if (!compactResolution.success || !compactResolution.profile) {
+    compressionModelPointer = "main";
+    compressionNotice = compactResolution.error || "Compression model pointer 'compact' is not configured.";
+  } else {
+    const compactBudget = Math.floor(
+      compactResolution.profile.contextLength * 0.9
+    );
+    if (compactBudget > 0 && tokenCount > compactBudget) {
+      compressionModelPointer = "main";
+      compressionNotice = `Compression model '${compactResolution.profile.name}' does not fit current context (~${Math.round(tokenCount / 1e3)}k tokens).`;
+    }
+  }
+  if (compressionModelPointer === "main" && (!mainResolution.success || !mainResolution.profile)) {
+    throw new Error(
+      mainResolution.error || "Compression fallback failed: model pointer 'main' is not configured."
+    );
+  }
+  const summaryResponse = await queryLLM(
+    normalizeMessagesForAPI([...messages, summaryRequest]),
+    [
+      "You are a helpful AI assistant tasked with creating comprehensive conversation summaries that preserve all essential context for continuing development work."
+    ],
+    0,
+    [],
+    toolUseContext.abortController.signal,
+    {
+      safeMode: false,
+      model: compressionModelPointer,
+      prependCLISysprompt: true
+    }
+  );
+  const content = summaryResponse.message.content;
+  const summary = typeof content === "string" ? content : content.length > 0 && content[0]?.type === "text" ? content[0].text : null;
+  if (!summary) {
+    throw new Error(
+      "Failed to generate conversation summary - response did not contain valid text content"
+    );
+  }
+  summaryResponse.message.usage = {
+    input_tokens: 0,
+    output_tokens: summaryResponse.message.usage.output_tokens,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0
+  };
+  const recoveredFiles = await selectAndReadFiles();
+  const compactedMessages = [
+    createUserMessage(
+      compressionNotice ? `Context automatically compressed due to token limit. ${compressionNotice} Using '${compressionModelPointer}' for compression.` : `Context automatically compressed due to token limit. Using '${compressionModelPointer}' for compression.`
+    ),
+    summaryResponse
+  ];
+  if (recoveredFiles.length > 0) {
+    for (const file of recoveredFiles) {
+      const contentWithLines = addLineNumbers({
+        content: file.content,
+        startLine: 1
+      });
+      const recoveryMessage = createUserMessage(
+        `**Recovered File: ${file.path}**
+
+\`\`\`
+${contentWithLines}
+\`\`\`
+
+*Automatically recovered (${file.tokens} tokens)${file.truncated ? " [truncated]" : ""}*`
+      );
+      compactedMessages.push(recoveryMessage);
+    }
+  }
+  getMessagesSetter()([]);
+  getContext.cache.clear?.();
+  getCodeStyle.cache.clear?.();
+  resetFileFreshnessSession();
+  return compactedMessages;
+}
+
+// packages/core/src/feedback/binaryFeedback.ts
+import { isEqual, zip } from "lodash-es";
+async function getBinaryFeedbackConfig() {
+  return { sampleFrequency: 0 };
+}
+function textContentBlocksEqual(cb1, cb2) {
+  return cb1.text === cb2.text;
+}
+function contentBlocksEqual(cb1, cb2) {
+  if (cb1.type !== cb2.type) {
+    return false;
+  }
+  if (cb1.type === "text") {
+    return textContentBlocksEqual(cb1, cb2);
+  }
+  cb2 = cb2;
+  return cb1.name === cb2.name && isEqual(cb1.input, cb2.input);
+}
+function allContentBlocksEqual(content1, content2) {
+  if (content1.length !== content2.length) {
+    return false;
+  }
+  return zip(content1, content2).every(
+    ([cb1, cb2]) => contentBlocksEqual(cb1, cb2)
+  );
+}
+async function shouldUseBinaryFeedback() {
+  if (process.env.DISABLE_BINARY_FEEDBACK) {
+    return false;
+  }
+  if (process.env.FORCE_BINARY_FEEDBACK) {
+    return true;
+  }
+  if (process.env.USER_TYPE !== "ant") {
+    return false;
+  }
+  if (process.env.NODE_ENV === "test") {
+    return false;
+  }
+  const config = await getBinaryFeedbackConfig();
+  if (config.sampleFrequency === 0) {
+    return false;
+  }
+  if (Math.random() > config.sampleFrequency) {
+    return false;
+  }
+  return true;
+}
+function messagePairValidForBinaryFeedback(m1, m2) {
+  const logPass = () => {
+  };
+  const logFail = (_reason) => {
+  };
+  const nonThinkingBlocks1 = m1.message.content.filter(
+    (b) => b.type !== "thinking" && b.type !== "redacted_thinking"
+  );
+  const nonThinkingBlocks2 = m2.message.content.filter(
+    (b) => b.type !== "thinking" && b.type !== "redacted_thinking"
+  );
+  const hasToolUse = nonThinkingBlocks1.some((b) => b.type === "tool_use") || nonThinkingBlocks2.some((b) => b.type === "tool_use");
+  if (!hasToolUse) {
+    if (allContentBlocksEqual(nonThinkingBlocks1, nonThinkingBlocks2)) {
+      logFail("contents_identical");
+      return false;
+    }
+    logPass();
+    return true;
+  }
+  if (allContentBlocksEqual(
+    nonThinkingBlocks1.filter((b) => b.type === "tool_use"),
+    nonThinkingBlocks2.filter((b) => b.type === "tool_use")
+  )) {
+    logFail("contents_identical");
+    return false;
+  }
+  logPass();
+  return true;
+}
+function getBinaryFeedbackResultForChoice(m1, m2, choice) {
+  switch (choice) {
+    case "prefer-left":
+      return { message: m1, shouldSkipPermissionCheck: true };
+    case "prefer-right":
+      return { message: m2, shouldSkipPermissionCheck: true };
+    case "no-preference":
+      return {
+        message: Math.random() < 0.5 ? m1 : m2,
+        shouldSkipPermissionCheck: false
+      };
+    case "neither":
+      return { message: null, shouldSkipPermissionCheck: false };
+  }
+}
+async function logBinaryFeedbackEvent(_m1, _m2, _choice) {
+}
+
+// packages/core/src/engine/query-executor.ts
+async function queryWithBinaryFeedback(toolUseContext, getAssistantResponse, getBinaryFeedbackResponse) {
+  if (process.env.USER_TYPE !== "ant" || !getBinaryFeedbackResponse || !await shouldUseBinaryFeedback()) {
+    const assistantMessage = await getAssistantResponse();
+    if (toolUseContext.abortController.signal.aborted) {
+      return { message: null, shouldSkipPermissionCheck: false };
+    }
+    return { message: assistantMessage, shouldSkipPermissionCheck: false };
+  }
+  const [m1, m2] = await Promise.all([
+    getAssistantResponse(),
+    getAssistantResponse()
+  ]);
+  if (toolUseContext.abortController.signal.aborted) {
+    return { message: null, shouldSkipPermissionCheck: false };
+  }
+  if (m2.isApiErrorMessage) {
+    return { message: m1, shouldSkipPermissionCheck: false };
+  }
+  if (m1.isApiErrorMessage) {
+    return { message: m2, shouldSkipPermissionCheck: false };
+  }
+  if (!messagePairValidForBinaryFeedback(m1, m2)) {
+    return { message: m1, shouldSkipPermissionCheck: false };
+  }
+  return await getBinaryFeedbackResponse(m1, m2);
+}
+
+// packages/core/src/utils/toolNameAliases.ts
+function resolveToolNameAlias(name) {
+  const originalName = name;
+  const resolvedName = name === "AgentOutputTool" ? "TaskOutput" : name === "BashOutputTool" ? "TaskOutput" : name === "BashOutput" ? "TaskOutput" : name === "TaskOutputTool" ? "TaskOutput" : name;
+  return {
+    originalName,
+    resolvedName,
+    wasAliased: resolvedName !== originalName
+  };
+}
+
+// packages/core/src/engine/pipeline/tool-input.ts
+function normalizeToolInput(tool, input) {
+  if (tool.name === "Bash") {
+    const parsed = tool.inputSchema.parse(input);
+    const command = parsed.command;
+    const timeout = parsed.timeout;
+    const description = parsed.description;
+    const run_in_background = parsed.run_in_background;
+    const dangerouslyDisableSandbox = parsed.dangerouslyDisableSandbox;
+    return {
+      command: String(command).replace(`cd ${getCwd()} && `, "").replace(/\\\\;/g, "\\;"),
+      ...typeof timeout === "number" ? { timeout } : {},
+      ...typeof description === "string" && description ? { description } : {},
+      ...typeof run_in_background === "boolean" && run_in_background ? { run_in_background } : {},
+      ...typeof dangerouslyDisableSandbox === "boolean" && dangerouslyDisableSandbox ? { dangerouslyDisableSandbox } : {}
+    };
+  }
+  return input;
+}
+function preprocessToolInput(tool, input) {
+  if (tool.name === "TaskOutput") {
+    const task_id = typeof input.task_id === "string" && input.task_id || typeof input.agentId === "string" && input.agentId || typeof input.bash_id === "string" && input.bash_id || "";
+    const block = typeof input.block === "boolean" ? input.block : true;
+    const timeout = typeof input.timeout === "number" ? input.timeout : typeof input.wait_up_to === "number" ? input.wait_up_to * 1e3 : void 0;
+    return {
+      task_id,
+      block,
+      ...timeout !== void 0 ? { timeout } : {}
+    };
+  }
+  return input;
+}
+
+// packages/core/src/engine/pipeline/tool-call.ts
+function asRecord2(value) {
+  if (!value || typeof value !== "object") return null;
+  return value;
+}
+function isPipelineMessage(value) {
+  const record = asRecord2(value);
+  if (!record) return false;
+  return record.type === "user" || record.type === "assistant" || record.type === "progress";
+}
+function toToolResultContent(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value;
+  return String(value);
+}
+async function* checkPermissionsAndCallTool(tool, toolUseID, siblingToolUseIDs, input, context, canUseTool, assistantMessage, shouldSkipPermissionCheck) {
+  const preprocessedInput = preprocessToolInput(tool, input);
+  const isValidInput = tool.inputSchema.safeParse(preprocessedInput);
+  if (!isValidInput.success) {
+    let errorMessage = `InputValidationError: ${isValidInput.error.message}`;
+    if (tool.name === "Read" && Object.keys(preprocessedInput).length === 0) {
+      errorMessage = `Error: The Read tool requires a 'file_path' parameter to specify which file to read. Please provide the absolute path to the file you want to read. For example: {"file_path": "/path/to/file.txt"}`;
+    }
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: errorMessage,
+        is_error: true,
+        tool_use_id: toolUseID
+      }
+    ]);
+    return;
+  }
+  let normalizedInput = normalizeToolInput(tool, isValidInput.data);
+  const isValidCall = await tool.validateInput?.(
+    normalizedInput,
+    context
+  );
+  if (isValidCall?.result === false) {
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: isValidCall.message,
+        is_error: true,
+        tool_use_id: toolUseID
+      }
+    ]);
+    return;
+  }
+  const hookOutcome = await runPreToolUseHooks({
+    toolName: tool.name,
+    toolInput: normalizedInput,
+    toolUseId: toolUseID,
+    permissionMode: context.options?.toolPermissionContext?.mode,
+    cwd: getCwd(),
+    transcriptPath: getHookTranscriptPath(context),
+    safeMode: context.options?.safeMode ?? false,
+    signal: context.abortController.signal
+  });
+  if (hookOutcome.kind === "block") {
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: hookOutcome.message,
+        is_error: true,
+        tool_use_id: toolUseID
+      }
+    ]);
+    return;
+  }
+  if (hookOutcome.warnings.length > 0) {
+    const warningText = hookOutcome.warnings.join("\n");
+    yield createProgressMessage(
+      toolUseID,
+      siblingToolUseIDs,
+      createAssistantMessage(warningText),
+      [],
+      context.options?.tools ?? []
+    );
+  }
+  if (hookOutcome.systemMessages && hookOutcome.systemMessages.length > 0) {
+    queueHookSystemMessages(context, hookOutcome.systemMessages);
+  }
+  if (hookOutcome.additionalContexts && hookOutcome.additionalContexts.length > 0) {
+    queueHookAdditionalContexts(context, hookOutcome.additionalContexts);
+  }
+  if (hookOutcome.updatedInput) {
+    const merged = { ...normalizedInput, ...hookOutcome.updatedInput };
+    const parsed = tool.inputSchema.safeParse(merged);
+    if (!parsed.success) {
+      yield createUserMessage([
+        {
+          type: "tool_result",
+          content: `Hook updatedInput failed validation: ${parsed.error.message}`,
+          is_error: true,
+          tool_use_id: toolUseID
+        }
+      ]);
+      return;
+    }
+    normalizedInput = normalizeToolInput(tool, parsed.data);
+    const isValidUpdate = await tool.validateInput?.(
+      normalizedInput,
+      context
+    );
+    if (isValidUpdate?.result === false) {
+      yield createUserMessage([
+        {
+          type: "tool_result",
+          content: isValidUpdate.message,
+          is_error: true,
+          tool_use_id: toolUseID
+        }
+      ]);
+      return;
+    }
+  }
+  const hookPermissionDecision = hookOutcome.kind === "allow" ? hookOutcome.permissionDecision : void 0;
+  const effectiveShouldSkipPermissionCheck = hookPermissionDecision === "allow" ? true : hookPermissionDecision === "ask" ? false : shouldSkipPermissionCheck;
+  const permissionContextForCall = hookPermissionDecision === "ask" && context.options?.toolPermissionContext && context.options.toolPermissionContext.mode !== "default" ? {
+    ...context,
+    options: {
+      ...context.options,
+      toolPermissionContext: {
+        ...context.options.toolPermissionContext,
+        mode: "default"
+      }
+    }
+  } : context;
+  const permissionResult = effectiveShouldSkipPermissionCheck ? { result: true } : await canUseTool(
+    tool,
+    normalizedInput,
+    { ...permissionContextForCall, toolUseId: toolUseID },
+    assistantMessage
+  );
+  if (permissionResult.result === false) {
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: permissionResult.message,
+        is_error: true,
+        tool_use_id: toolUseID
+      }
+    ]);
+    return;
+  }
+  try {
+    const generator = tool.call(normalizedInput, {
+      ...context,
+      toolUseId: toolUseID
+    });
+    for await (const result of generator) {
+      switch (result.type) {
+        case "result": {
+          const rawContent = result.resultForAssistant ?? tool.renderResultForAssistant(result.data);
+          const content = toToolResultContent(rawContent);
+          const newMessages = Array.isArray(result.newMessages) ? result.newMessages.filter(isPipelineMessage) : [];
+          const postOutcome = await runPostToolUseHooks({
+            toolName: tool.name,
+            toolInput: normalizedInput,
+            toolResult: result.data,
+            toolUseId: toolUseID,
+            permissionMode: context.options?.toolPermissionContext?.mode,
+            cwd: getCwd(),
+            transcriptPath: getHookTranscriptPath(context),
+            safeMode: context.options?.safeMode ?? false,
+            signal: context.abortController.signal
+          });
+          if (postOutcome.systemMessages.length > 0) {
+            queueHookSystemMessages(context, postOutcome.systemMessages);
+          }
+          if (postOutcome.additionalContexts.length > 0) {
+            queueHookAdditionalContexts(context, postOutcome.additionalContexts);
+          }
+          if (postOutcome.warnings.length > 0) {
+            const warningText = postOutcome.warnings.join("\n");
+            yield createProgressMessage(
+              toolUseID,
+              siblingToolUseIDs,
+              createAssistantMessage(warningText),
+              [],
+              context.options?.tools ?? []
+            );
+          }
+          yield createUserMessage(
+            [
+              {
+                type: "tool_result",
+                content,
+                tool_use_id: toolUseID
+              }
+            ],
+            {
+              data: result.data,
+              resultForAssistant: content,
+              ...newMessages.length > 0 ? { newMessages } : {},
+              ...result.contextModifier ? { contextModifier: result.contextModifier } : {}
+            }
+          );
+          for (const message of newMessages) {
+            yield message;
+          }
+          return;
+        }
+        case "progress":
+          yield createProgressMessage(
+            toolUseID,
+            siblingToolUseIDs,
+            result.content,
+            result.normalizedMessages || [],
+            result.tools || []
+          );
+          break;
+      }
+    }
+  } catch (error) {
+    const content = formatError(error);
+    logError(error);
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content,
+        is_error: true,
+        tool_use_id: toolUseID
+      }
+    ]);
+  }
+}
+function formatError(error) {
+  if (!(error instanceof Error)) return String(error);
+  const parts = [error.message];
+  if ("stderr" in error && typeof error.stderr === "string") {
+    parts.push(error.stderr);
+  }
+  if ("stdout" in error && typeof error.stdout === "string") {
+    parts.push(error.stdout);
+  }
+  const fullMessage = parts.filter(Boolean).join("\n");
+  if (fullMessage.length <= 1e4) return fullMessage;
+  const halfLength = 5e3;
+  const start = fullMessage.slice(0, halfLength);
+  const end = fullMessage.slice(-halfLength);
+  return `${start}
+
+... [${fullMessage.length - 1e4} characters truncated] ...
+
+${end}`;
+}
+
+// packages/core/src/engine/pipeline/tool-use.ts
+async function* runToolUse(toolUse, siblingToolUseIDs, assistantMessage, canUseTool, toolUseContext, shouldSkipPermissionCheck) {
+  const currentRequest = getCurrentRequest();
+  const aliasResolution = resolveToolNameAlias(toolUse.name);
+  setRequestStatus({ kind: "tool", detail: aliasResolution.resolvedName });
+  debug.flow("TOOL_USE_START", {
+    toolName: toolUse.name,
+    toolUseID: toolUse.id,
+    inputSize: JSON.stringify(toolUse.input).length,
+    siblingToolCount: siblingToolUseIDs.size,
+    shouldSkipPermissionCheck: Boolean(shouldSkipPermissionCheck),
+    requestId: currentRequest?.id
+  });
+  logUserFriendly(
+    "TOOL_EXECUTION",
+    {
+      toolName: toolUse.name,
+      action: "Starting",
+      target: toolUse.input ? Object.keys(toolUse.input).join(", ") : ""
+    },
+    currentRequest?.id
+  );
+  const toolName = aliasResolution.resolvedName;
+  const tool = toolUseContext.options.tools.find((t) => t.name === toolName);
+  if (!tool) {
+    debug.error("TOOL_NOT_FOUND", {
+      requestedTool: toolName,
+      availableTools: toolUseContext.options.tools.map((t) => t.name),
+      toolUseID: toolUse.id,
+      requestId: currentRequest?.id
+    });
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: `Error: No such tool available: ${toolName}`,
+        is_error: true,
+        tool_use_id: toolUse.id
+      }
+    ]);
+    return;
+  }
+  const toolInput = toolUse.input;
+  debug.flow("TOOL_VALIDATION_START", {
+    toolName: tool.name,
+    toolUseID: toolUse.id,
+    inputKeys: Object.keys(toolInput),
+    requestId: currentRequest?.id
+  });
+  try {
+    for await (const message of checkPermissionsAndCallTool(
+      tool,
+      toolUse.id,
+      siblingToolUseIDs,
+      toolInput,
+      toolUseContext,
+      canUseTool,
+      assistantMessage,
+      shouldSkipPermissionCheck
+    )) {
+      yield message;
+    }
+  } catch (e) {
+    logError(e);
+    yield createUserMessage([
+      {
+        type: "tool_result",
+        content: `Tool execution failed: ${e instanceof Error ? e.message : String(e)}`,
+        is_error: true,
+        tool_use_id: toolUse.id
+      }
+    ]);
+  }
+}
+
+// packages/core/src/engine/pipeline/tool-use-queue.ts
+function createSyntheticToolUseErrorMessage(toolUseId, reason) {
+  if (reason === "user_interrupted") {
+    return createUserMessage([
+      {
+        type: "tool_result",
+        content: REJECT_MESSAGE,
+        is_error: true,
+        tool_use_id: toolUseId
+      }
+    ]);
+  }
+  return createUserMessage([
+    {
+      type: "tool_result",
+      content: "<tool_use_error>Sibling tool call errored</tool_use_error>",
+      is_error: true,
+      tool_use_id: toolUseId
+    }
+  ]);
+}
+var ToolUseQueue = class {
+  toolDefinitions;
+  canUseTool;
+  tools = [];
+  toolUseContext;
+  hasErrored = false;
+  progressAvailableResolve;
+  siblingToolUseIDs;
+  shouldSkipPermissionCheck;
+  constructor(options) {
+    this.toolDefinitions = options.toolDefinitions;
+    this.canUseTool = options.canUseTool;
+    this.toolUseContext = options.toolUseContext;
+    this.siblingToolUseIDs = options.siblingToolUseIDs;
+    this.shouldSkipPermissionCheck = options.shouldSkipPermissionCheck;
+  }
+  addTool(toolUse, assistantMessage) {
+    const resolvedToolName = resolveToolNameAlias(toolUse.name).resolvedName;
+    const toolDefinition = this.toolDefinitions.find(
+      (t) => t.name === resolvedToolName
+    );
+    const parsedInput = toolDefinition?.inputSchema.safeParse(toolUse.input);
+    const isConcurrencySafe = toolDefinition && parsedInput?.success ? toolDefinition.isConcurrencySafe(parsedInput.data) : false;
+    this.tools.push({
+      id: toolUse.id,
+      block: toolUse,
+      assistantMessage,
+      status: "queued",
+      isConcurrencySafe,
+      pendingProgress: [],
+      queuedProgressEmitted: false
+    });
+    void this.processQueue();
+  }
+  canExecuteTool(isConcurrencySafe) {
+    const executing = this.tools.filter((t) => t.status === "executing");
+    return executing.length === 0 || isConcurrencySafe && executing.every((t) => t.isConcurrencySafe);
+  }
+  async processQueue() {
+    for (const entry of this.tools) {
+      if (entry.status !== "queued") continue;
+      if (this.canExecuteTool(entry.isConcurrencySafe)) {
+        await this.executeTool(entry);
+      } else {
+        if (!entry.queuedProgressEmitted) {
+          entry.queuedProgressEmitted = true;
+          entry.pendingProgress.push(
+            createProgressMessage(
+              entry.id,
+              this.siblingToolUseIDs,
+              createAssistantMessage("<tool-progress>Waiting\u2026</tool-progress>"),
+              [],
+              this.toolUseContext.options.tools
+            )
+          );
+          if (this.progressAvailableResolve) {
+            this.progressAvailableResolve();
+            this.progressAvailableResolve = void 0;
+          }
+        }
+        if (!entry.isConcurrencySafe) {
+          break;
+        }
+      }
+    }
+  }
+  getAbortReason() {
+    if (this.hasErrored) return "sibling_error";
+    if (this.toolUseContext.abortController.signal.aborted)
+      return "user_interrupted";
+    return null;
+  }
+  async executeTool(entry) {
+    entry.status = "executing";
+    const results = [];
+    const contextModifiers = [];
+    const promise = (async () => {
+      const abortReason = this.getAbortReason();
+      if (abortReason) {
+        results.push(createSyntheticToolUseErrorMessage(entry.id, abortReason));
+        entry.results = results;
+        entry.contextModifiers = contextModifiers;
+        entry.status = "completed";
+        return;
+      }
+      const generator = runToolUse(
+        entry.block,
+        this.siblingToolUseIDs,
+        entry.assistantMessage,
+        this.canUseTool,
+        this.toolUseContext,
+        this.shouldSkipPermissionCheck
+      );
+      let toolErrored = false;
+      for await (const message of generator) {
+        const reason = this.getAbortReason();
+        if (reason && !toolErrored) {
+          results.push(createSyntheticToolUseErrorMessage(entry.id, reason));
+          break;
+        }
+        if (message.type === "user" && Array.isArray(message.message.content) && message.message.content.some(
+          (block) => block.type === "tool_result" && block.is_error === true
+        )) {
+          this.hasErrored = true;
+          toolErrored = true;
+        }
+        if (message.type === "progress") {
+          entry.pendingProgress.push(message);
+          if (this.progressAvailableResolve) {
+            this.progressAvailableResolve();
+            this.progressAvailableResolve = void 0;
+          }
+        } else {
+          results.push(message);
+          if (message.type === "user" && message.toolUseResult?.contextModifier) {
+            contextModifiers.push(
+              message.toolUseResult.contextModifier.modifyContext
+            );
+          }
+        }
+      }
+      entry.results = results;
+      entry.contextModifiers = contextModifiers;
+      entry.status = "completed";
+      if (!entry.isConcurrencySafe && contextModifiers.length > 0) {
+        for (const modifyContext of contextModifiers) {
+          this.toolUseContext = modifyContext(this.toolUseContext);
+        }
+      }
+    })();
+    entry.promise = promise;
+    promise.finally(() => {
+      void this.processQueue();
+    });
+  }
+  *getCompletedResults() {
+    let barrierExecuting = false;
+    for (const entry of this.tools) {
+      while (entry.pendingProgress.length > 0) {
+        yield entry.pendingProgress.shift();
+      }
+      if (entry.status === "yielded") continue;
+      if (barrierExecuting) continue;
+      if (entry.status === "completed" && entry.results) {
+        entry.status = "yielded";
+        for (const message of entry.results) {
+          yield message;
+        }
+      } else if (entry.status === "executing" && !entry.isConcurrencySafe) {
+        barrierExecuting = true;
+      }
+    }
+  }
+  hasPendingProgress() {
+    return this.tools.some((t) => t.pendingProgress.length > 0);
+  }
+  hasCompletedResults() {
+    return this.tools.some((t) => t.status === "completed");
+  }
+  hasExecutingTools() {
+    return this.tools.some((t) => t.status === "executing");
+  }
+  hasUnfinishedTools() {
+    return this.tools.some((t) => t.status !== "yielded");
+  }
+  async *getRemainingResults() {
+    while (this.hasUnfinishedTools()) {
+      await this.processQueue();
+      for (const message of this.getCompletedResults()) {
+        yield message;
+      }
+      if (this.hasExecutingTools() && !this.hasCompletedResults() && !this.hasPendingProgress()) {
+        const promises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
+        const progressPromise = new Promise((resolve3) => {
+          this.progressAvailableResolve = resolve3;
+        });
+        if (promises.length > 0) {
+          await Promise.race([...promises, progressPromise]);
+        }
+      }
+    }
+    for (const message of this.getCompletedResults()) {
+      yield message;
+    }
+  }
+  getUpdatedContext() {
+    return this.toolUseContext;
+  }
+};
+
+// packages/core/src/engine/pipeline/types.ts
+function isToolUseLikeBlock(block) {
+  return block && typeof block === "object" && (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use");
+}
+
+// packages/core/src/query/agentEvents.ts
+function messageToAgentEvent(message, sessionId) {
+  return kodeMessageToSdkMessage(
+    message,
+    sessionId
+  );
+}
+async function* messagesToAgentEvents(args) {
+  for await (const message of args.source) {
+    const event = messageToAgentEvent(message, args.sessionId);
+    if (event) yield event;
+  }
+}
+
+// packages/core/src/engine/message-pipeline.ts
+async function* messagePipeline(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse) {
+  yield* messagePipelineCore(
+    messages,
+    systemPrompt,
+    context,
+    canUseTool,
+    toolUseContext,
+    getBinaryFeedbackResponse
+  );
+}
+async function* messagePipelineCore(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse, hookState) {
+  setRequestStatus({ kind: "thinking" });
+  try {
+    let getAssistantResponse = function() {
+      return queryLLM(
+        normalizeMessagesForAPI(messages),
+        fullSystemPrompt,
+        toolUseContext.options.maxThinkingTokens,
+        toolUseContext.options.tools,
+        toolUseContext.abortController.signal,
+        {
+          safeMode: toolUseContext.options.safeMode ?? false,
+          model: toolUseContext.options.model || "main",
+          prependCLISysprompt: true,
+          toolUseContext
+        }
+      );
+    };
+    markPhase("QUERY_INIT");
+    const stopHookActive = hookState?.stopHookActive === true;
+    const stopHookAttempts = hookState?.stopHookAttempts ?? 0;
+    const { messages: processedMessages, wasCompacted } = await checkAutoCompact(messages, toolUseContext);
+    if (wasCompacted) {
+      messages = processedMessages;
+    }
+    if (toolUseContext.agentId === "main") {
+      const shell = BunShell.getInstance();
+      const notifications = shell.flushBashNotifications();
+      for (const notification of notifications) {
+        const text = renderBashNotification(notification);
+        if (text.trim().length === 0) continue;
+        const msg = createAssistantMessage(text);
+        messages = [...messages, msg];
+        yield msg;
+      }
+      const attachments = shell.flushBackgroundShellStatusAttachments();
+      for (const attachment of attachments) {
+        const text = renderBackgroundShellStatusAttachment(attachment);
+        if (text.trim().length === 0) continue;
+        const msg = createAssistantMessage(
+          `<tool-progress>${text}</tool-progress>`
+        );
+        messages = [...messages, msg];
+        yield msg;
+      }
+    }
+    updateHookTranscriptForMessages(toolUseContext, messages);
+    {
+      const last = messages[messages.length - 1];
+      let userPromptText = null;
+      if (last?.type === "user") {
+        const content = last.message.content;
+        if (typeof content === "string") {
+          userPromptText = content;
+        } else if (Array.isArray(content)) {
+          const hasToolResult = content.some(
+            (b) => b && typeof b === "object" && b.type === "tool_result"
+          );
+          if (!hasToolResult) {
+            userPromptText = content.filter(
+              (b) => b && typeof b === "object" && b.type === "text"
+            ).map((b) => String(b.text ?? "")).join("");
+          }
+        }
+      }
+      if (userPromptText !== null) {
+        toolUseContext.options.lastUserPrompt = userPromptText;
+        const promptOutcome = await runUserPromptSubmitHooks({
+          prompt: userPromptText,
+          permissionMode: toolUseContext.options?.toolPermissionContext?.mode,
+          cwd: getCwd(),
+          transcriptPath: getHookTranscriptPath(toolUseContext),
+          safeMode: toolUseContext.options?.safeMode ?? false,
+          signal: toolUseContext.abortController.signal
+        });
+        queueHookSystemMessages(toolUseContext, promptOutcome.systemMessages);
+        queueHookAdditionalContexts(
+          toolUseContext,
+          promptOutcome.additionalContexts
+        );
+        if (promptOutcome.decision === "block") {
+          yield createAssistantMessage(promptOutcome.message);
+          return;
+        }
+      }
+    }
+    markPhase("SYSTEM_PROMPT_BUILD");
+    hydratePlanSlugFromMessages(messages, toolUseContext);
+    const { systemPrompt: fullSystemPrompt, reminders } = formatSystemPromptWithContext(
+      systemPrompt,
+      context,
+      toolUseContext.agentId
+    );
+    const planModeAdditions = getPlanModeSystemPromptAdditions(
+      messages,
+      toolUseContext
+    );
+    if (planModeAdditions.length > 0) {
+      fullSystemPrompt.push(...planModeAdditions);
+    }
+    const hookAdditions = drainHookSystemPromptAdditions(toolUseContext);
+    if (hookAdditions.length > 0) {
+      fullSystemPrompt.push(...hookAdditions);
+    }
+    if (toolUseContext.agentId === "main") {
+      const customAdditions = toolUseContext.options.getCustomSystemPromptAdditions?.() ?? [];
+      if (customAdditions.length > 0) {
+        fullSystemPrompt.push(...customAdditions);
+      }
+    }
+    emitReminderEvent("session:startup", {
+      agentId: toolUseContext.agentId,
+      messages: messages.length,
+      timestamp: Date.now()
+    });
+    if (reminders && messages.length > 0) {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.type === "user") {
+          const lastUserMessage = msg;
+          messages[i] = {
+            ...lastUserMessage,
+            message: {
+              ...lastUserMessage.message,
+              content: typeof lastUserMessage.message.content === "string" ? reminders + lastUserMessage.message.content : [
+                ...Array.isArray(lastUserMessage.message.content) ? lastUserMessage.message.content : [],
+                { type: "text", text: reminders }
+              ]
+            }
+          };
+          break;
+        }
+      }
+    }
+    markPhase("LLM_PREPARATION");
+    const result = await queryWithBinaryFeedback(
+      toolUseContext,
+      getAssistantResponse,
+      getBinaryFeedbackResponse
+    );
+    if (toolUseContext.abortController.signal.aborted) {
+      yield createAssistantMessage(INTERRUPT_MESSAGE);
+      return;
+    }
+    if (result.message === null) {
+      yield createAssistantMessage(INTERRUPT_MESSAGE);
+      return;
+    }
+    const assistantMessage = result.message;
+    const shouldSkipPermissionCheck = result.shouldSkipPermissionCheck;
+    const toolUseMessages = assistantMessage.message.content.filter(isToolUseLikeBlock);
+    if (!toolUseMessages.length) {
+      const stopHookEvent = toolUseContext.agentId && toolUseContext.agentId !== "main" ? "SubagentStop" : "Stop";
+      const record = asRecord(assistantMessage.message);
+      const stopReason = (record && typeof record.stop_reason === "string" ? record.stop_reason : "") || (record && typeof record.stopReason === "string" ? record.stopReason : "") || "end_turn";
+      const stopOutcome = await runStopHooks({
+        hookEvent: stopHookEvent,
+        reason: String(stopReason ?? ""),
+        agentId: toolUseContext.agentId,
+        permissionMode: toolUseContext.options?.toolPermissionContext?.mode,
+        cwd: getCwd(),
+        transcriptPath: getHookTranscriptPath(toolUseContext),
+        safeMode: toolUseContext.options?.safeMode ?? false,
+        stopHookActive,
+        signal: toolUseContext.abortController.signal
+      });
+      if (stopOutcome.systemMessages.length > 0) {
+        queueHookSystemMessages(toolUseContext, stopOutcome.systemMessages);
+      }
+      if (stopOutcome.additionalContexts.length > 0) {
+        queueHookAdditionalContexts(
+          toolUseContext,
+          stopOutcome.additionalContexts
+        );
+      }
+      if (stopOutcome.decision === "block") {
+        queueHookSystemMessages(toolUseContext, [stopOutcome.message]);
+        const MAX_STOP_HOOK_ATTEMPTS = 5;
+        if (stopHookAttempts < MAX_STOP_HOOK_ATTEMPTS) {
+          yield* await messagePipelineCore(
+            [...messages, assistantMessage],
+            systemPrompt,
+            context,
+            canUseTool,
+            toolUseContext,
+            getBinaryFeedbackResponse,
+            {
+              stopHookActive: true,
+              stopHookAttempts: stopHookAttempts + 1
+            }
+          );
+          return;
+        }
+      }
+      yield assistantMessage;
+      return;
+    }
+    yield assistantMessage;
+    const siblingToolUseIDs = new Set(toolUseMessages.map((_) => _.id));
+    const toolQueue = new ToolUseQueue({
+      toolDefinitions: toolUseContext.options.tools,
+      canUseTool,
+      toolUseContext,
+      siblingToolUseIDs,
+      shouldSkipPermissionCheck
+    });
+    for (const toolUse of toolUseMessages) {
+      toolQueue.addTool(toolUse, assistantMessage);
+    }
+    const toolMessagesForNextTurn = [];
+    for await (const message of toolQueue.getRemainingResults()) {
+      yield message;
+      if (message.type !== "progress") {
+        toolMessagesForNextTurn.push(message);
+      }
+    }
+    toolUseContext = toolQueue.getUpdatedContext();
+    if (toolUseContext.abortController.signal.aborted) {
+      yield createAssistantMessage(INTERRUPT_MESSAGE_FOR_TOOL_USE);
+      return;
+    }
+    try {
+      yield* await messagePipelineCore(
+        [...messages, assistantMessage, ...toolMessagesForNextTurn],
+        systemPrompt,
+        context,
+        canUseTool,
+        toolUseContext,
+        getBinaryFeedbackResponse,
+        hookState
+      );
+    } catch (error) {
+      throw error;
+    }
+  } finally {
+    setRequestStatus({ kind: "idle" });
+  }
+}
+
+// packages/core/src/engine/orchestrator.ts
+async function* query(messages, systemPrompt, context, canUseTool, toolUseContext, getBinaryFeedbackResponse) {
+  const shouldPersistSession = toolUseContext.options?.persistSession !== false && process.env.NODE_ENV !== "test";
+  const cwd2 = shouldPersistSession ? getCwd() : null;
+  for await (const message of messagePipeline(
+    messages,
+    systemPrompt,
+    context,
+    canUseTool,
+    toolUseContext,
+    getBinaryFeedbackResponse
+  )) {
+    if (shouldPersistSession) {
+      appendSessionJsonlFromMessage({
+        cwd: cwd2 ?? getCwd(),
+        message,
+        toolUseContext
+      });
+    }
+    yield message;
+  }
+}
+
+export {
+  ripGrep,
+  isInDirectory,
+  readTextContent,
+  writeTextContent,
+  detectRepoLineEndings,
+  detectFileEncoding,
+  detectLineEndings,
+  normalizeFilePath,
+  getAbsolutePath,
+  getAbsoluteAndRelativePaths,
+  findSimilarFile,
+  addLineNumbers,
+  isDirEmpty,
+  recordFileRead,
+  recordFileEdit,
+  generateFileModificationReminder,
+  resetFileFreshnessSession,
+  startWatchingTodoFile,
+  countTokens,
+  setMessagesGetter,
+  getMessagesGetter,
+  setMessagesSetter,
+  getMessagesSetter,
+  setModelConfigChangeHandler,
+  triggerModelConfigChange,
+  getBinaryFeedbackResultForChoice,
+  logBinaryFeedbackEvent,
+  resolveToolNameAlias,
+  messagesToAgentEvents,
+  query
+};