tarsk 0.5.59 → 0.5.60

package/dist/index.js

@@ -636,8 +636,8 @@ var init_observations = __esm({
     "use strict";
     OBSERVATION_ID_PREFIX = "obs_";
     OBSERVATION_EXTERNALIZE_MIN_BYTES = 8 * 1024;
-    OBSERVATION_PREVIEW_MAX_BYTES = 4 * 1024;
-    OBSERVATION_PREVIEW_MAX_LINES = 120;
+    OBSERVATION_PREVIEW_MAX_BYTES = 10 * 1024;
+    OBSERVATION_PREVIEW_MAX_LINES = 250;
     OBSERVATION_RETRIEVAL_DEFAULT_LINES = 200;
     OBSERVATION_RETRIEVAL_MAX_LINES = 2e3;
     OBSERVATION_RETRIEVAL_MAX_BYTES = 50 * 1024;
@@ -648,7 +648,7 @@ var init_observations = __esm({
 function isMicrocompactEligibleTool(toolName) {
   return MICROCOMPACT_ELIGIBLE_TOOL_SET.has(toolName);
 }
-var MICROCOMPACT_KEEP_RECENT, MICROCOMPACT_KEEP_TOKENS, MICROCOMPACT_TRIGGER_MARGIN, MICROCOMPACT_MIN_SAVE_TOKENS, MICROCOMPACT_DIGEST_MIN_CHARS, MICROCOMPACT_MARKER_PREFIX, MICROCOMPACT_ELIGIBLE_TOOLS, MICROCOMPACT_ELIGIBLE_TOOL_SET;
+var MICROCOMPACT_KEEP_RECENT, MICROCOMPACT_KEEP_TOKENS, MICROCOMPACT_TRIGGER_MARGIN, MICROCOMPACT_MIN_SAVE_TOKENS, MICROCOMPACT_DIGEST_MIN_CHARS, MICROCOMPACT_PROACTIVE_TURN_THRESHOLD, MICROCOMPACT_PROACTIVE_PAYLOAD_TOKENS, MICROCOMPACT_PROACTIVE_MIN_SAVE_TOKENS, MICROCOMPACT_MARKER_PREFIX, MICROCOMPACT_ELIGIBLE_TOOLS, MICROCOMPACT_ELIGIBLE_TOOL_SET;
 var init_microcompact = __esm({
   "../shared/dist/microcompact.js"() {
     "use strict";
@@ -657,6 +657,9 @@ var init_microcompact = __esm({
     MICROCOMPACT_TRIGGER_MARGIN = 2e4;
     MICROCOMPACT_MIN_SAVE_TOKENS = 2e4;
     MICROCOMPACT_DIGEST_MIN_CHARS = 2e3;
+    MICROCOMPACT_PROACTIVE_TURN_THRESHOLD = 15;
+    MICROCOMPACT_PROACTIVE_PAYLOAD_TOKENS = 5e4;
+    MICROCOMPACT_PROACTIVE_MIN_SAVE_TOKENS = 5e3;
     MICROCOMPACT_MARKER_PREFIX = "[Tool result compacted]";
     MICROCOMPACT_ELIGIBLE_TOOLS = [
       "read",
@@ -1102,6 +1105,77 @@ var init_tool_display = __esm({
   }
 });
 
+// ../shared/dist/tool-call-group.js
+function pluralize(count, singular, plural) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function categoryPhrases(verb, singular, plural) {
+  return {
+    formatPhrase: (count) => verb === null ? pluralize(count, singular, plural) : `${verb} ${pluralize(count, singular, plural)}`,
+    formatNeutral: (count) => pluralize(count, singular, plural)
+  };
+}
+var otherToolCallGroupCategory, toolCallGroupCategories, categoryByToolName;
+var init_tool_call_group = __esm({
+  "../shared/dist/tool-call-group.js"() {
+    "use strict";
+    otherToolCallGroupCategory = {
+      id: "other",
+      toolNames: [],
+      ...categoryPhrases(null, "tool call", "tool calls")
+    };
+    toolCallGroupCategories = [
+      {
+        id: "files",
+        toolNames: ["edit", "write"],
+        ...categoryPhrases("edited", "file", "files")
+      },
+      {
+        id: "commands",
+        toolNames: ["bash", "execute_skill_script", "run_js"],
+        ...categoryPhrases("ran", "command", "commands")
+      },
+      {
+        id: "reads",
+        toolNames: ["read", "get_observation"],
+        ...categoryPhrases("read", "file", "files")
+      },
+      {
+        id: "searches",
+        toolNames: ["grep", "find"],
+        ...categoryPhrases(null, "search", "searches")
+      },
+      {
+        id: "webSearches",
+        toolNames: ["web_search"],
+        ...categoryPhrases(null, "web search", "web searches")
+      },
+      {
+        id: "pages",
+        toolNames: ["fetch"],
+        ...categoryPhrases("fetched", "page", "pages")
+      },
+      {
+        id: "browserActions",
+        toolNames: ["browser"],
+        ...categoryPhrases(null, "browser action", "browser actions")
+      },
+      {
+        id: "images",
+        toolNames: ["generate_image"],
+        ...categoryPhrases("generated", "image", "images")
+      },
+      {
+        id: "subagents",
+        toolNames: ["agent"],
+        ...categoryPhrases(null, "subagent", "subagents")
+      },
+      otherToolCallGroupCategory
+    ];
+    categoryByToolName = new Map(toolCallGroupCategories.flatMap((category) => category.toolNames.map((name) => [name, category])));
+  }
+});
+
 // ../shared/dist/project-tools.js
 function normalizeDisabledTools(names) {
   if (!Array.isArray(names)) {
@@ -1241,12 +1315,12 @@ function getFileExtension(filename) {
     return "";
   }
   const trimmed = filename.trim();
-  const basename7 = trimmed.split(/[/\\]/).pop() ?? trimmed;
-  const dotIndex = basename7.lastIndexOf(".");
-  if (dotIndex <= 0 || dotIndex === basename7.length - 1) {
+  const basename8 = trimmed.split(/[/\\]/).pop() ?? trimmed;
+  const dotIndex = basename8.lastIndexOf(".");
+  if (dotIndex <= 0 || dotIndex === basename8.length - 1) {
     return "";
   }
-  return basename7.slice(dotIndex + 1).toLowerCase();
+  return basename8.slice(dotIndex + 1).toLowerCase();
 }
 function getExplorerFileMediaType(path8, name) {
   const ext = getFileExtension(path8) || (name ? getFileExtension(name) : "");
@@ -2346,6 +2420,7 @@ var init_dist = __esm({
     init_typography();
     init_font_scale();
     init_tool_display();
+    init_tool_call_group();
     init_project_tools();
     init_providers();
     init_web_fetch();
@@ -6837,7 +6912,8 @@ var init_command_pattern = __esm({
 // src/tools/path-utils.ts
 import { accessSync, constants } from "node:fs";
 import * as os from "node:os";
-import { isAbsolute, resolve as resolvePath, relative } from "node:path";
+import { basename, isAbsolute, resolve as resolvePath, relative } from "node:path";
+import { globSync } from "glob";
 function normalizeUnicodeSpaces(str) {
   return str.replace(UNICODE_SPACES, " ");
 }
@@ -6872,6 +6948,41 @@ function findMatchingSuffixInCwd(resolvedPath2, cwd) {
   }
   return void 0;
 }
+function findFilesByBasenameInCwd(fileBasename, cwd, limit) {
+  if (!fileBasename || fileBasename === "." || fileBasename === "..") {
+    return [];
+  }
+  try {
+    const found = globSync(`**/${fileBasename}`, {
+      cwd,
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**"],
+      nodir: true
+    });
+    return found.slice(0, limit).map((match) => match.replace(/\\/g, "/"));
+  } catch {
+    return [];
+  }
+}
+function collectFileNotFoundHints(resolvedPath2, cwd) {
+  const requestedRelative = relative(cwd, resolvedPath2).replace(/\\/g, "/");
+  const suffixMatch = findMatchingSuffixInCwd(resolvedPath2, cwd);
+  if (suffixMatch && suffixMatch !== requestedRelative && suffixMatch !== ".") {
+    return [`Try: ${suffixMatch}`];
+  }
+  const matches = findFilesByBasenameInCwd(
+    basename(resolvedPath2),
+    cwd,
+    BASENAME_SEARCH_LIMIT
+  ).filter((match) => match !== requestedRelative);
+  if (matches.length === 1) {
+    return [`Try: ${matches[0]}`];
+  }
+  if (matches.length > 1) {
+    return [`Similar files: ${matches.join(", ")}`];
+  }
+  return [];
+}
 function collectPathSuggestionHints(resolvedPath2, cwd) {
   const hints = ["Use a path relative to the project instead of an absolute path."];
   const suffixMatch = findMatchingSuffixInCwd(resolvedPath2, cwd);
@@ -6930,7 +7041,9 @@ function toDisplayPath(cwd, resolvedPath2, requestedPath) {
 }
 function fileNotFoundError(cwd, resolvedPath2, requestedPath) {
   const displayPath = toDisplayPath(cwd, resolvedPath2, requestedPath);
-  return new Error(`no such file or directory '${displayPath}'`);
+  const hints = collectFileNotFoundHints(resolvedPath2, cwd);
+  const suffix = hints.length > 0 ? ` ${hints.join(" ")}` : "";
+  return new Error(`no such file or directory '${displayPath}'.${suffix}`);
 }
 function rethrowIfFileNotFound(error, cwd, resolvedPath2, requestedPath) {
   if (isEnoentError(error)) {
@@ -6961,16 +7074,18 @@ function resolveReadPath(filePath, cwd) {
   }
   return resolved;
 }
-var UNICODE_SPACES, NARROW_NO_BREAK_SPACE;
+var UNICODE_SPACES, NARROW_NO_BREAK_SPACE, BASENAME_SEARCH_LIMIT;
 var init_path_utils = __esm({
   "src/tools/path-utils.ts"() {
     "use strict";
     UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
     NARROW_NO_BREAK_SPACE = "\u202F";
+    BASENAME_SEARCH_LIMIT = 3;
   }
 });
 
 // src/tools/bash-command-guard.ts
+import { isAbsolute as isAbsolute2 } from "node:path";
 function commandBinary(token) {
   if (!token) return "";
   const parts = token.split("/");
@@ -7150,7 +7265,7 @@ function shouldRedirectReadSegment(tokens) {
   }
   return isSedPrintRange(tokens);
 }
-function validateBashDedicatedToolRedirect(command) {
+function getBashDedicatedToolRedirectMessage(command) {
   const segments = splitShellSegments(command);
   for (let index = 0; index < segments.length; index++) {
     const tokens = getCommandTokens(segments[index]);
@@ -7158,15 +7273,16 @@ function validateBashDedicatedToolRedirect(command) {
       continue;
     }
     if (shouldRedirectGrepSegment(tokens, index === 0)) {
-      throw redirectError("grep", "Shell grep/rg is not allowed for codebase search.");
+      return redirectError("grep", "Shell grep/rg is not allowed for codebase search.").message;
     }
     if (shouldRedirectFindSegment(tokens)) {
-      throw redirectError("find", "Shell find is not allowed for file discovery.");
+      return redirectError("find", "Shell find is not allowed for file discovery.").message;
     }
     if (shouldRedirectReadSegment(tokens)) {
-      throw redirectError("read", "Shell cat/head/tail/sed is not allowed for reading files.");
+      return redirectError("read", "Shell cat/head/tail/sed is not allowed for reading files.").message;
     }
   }
+  return void 0;
 }
 function validateBashFilesystemSearch(command, cwd) {
   for (const segment of splitShellSegments(command)) {
@@ -7192,6 +7308,109 @@ function validateBashFilesystemSearch(command, cwd) {
     }
   }
 }
+function unquoteRedirectTarget(target) {
+  if (target.startsWith('"') && target.endsWith('"') || target.startsWith("'") && target.endsWith("'")) {
+    return target.slice(1, -1);
+  }
+  return target;
+}
+function extractShellRedirectTargets(command) {
+  const targets = [];
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < command.length; index++) {
+    const char = command[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    const rest = command.slice(index);
+    const operatorMatch = rest.match(/^(\d>>|\d>|>>|>|&>>|&>)(?![&\d])/);
+    if (!operatorMatch) {
+      continue;
+    }
+    index += operatorMatch[0].length;
+    while (index < command.length && /\s/.test(command[index])) {
+      index++;
+    }
+    if (index >= command.length) {
+      continue;
+    }
+    if (command[index] === "'" || command[index] === '"') {
+      const quoteChar = command[index];
+      index++;
+      let target2 = "";
+      while (index < command.length && command[index] !== quoteChar) {
+        target2 += command[index];
+        index++;
+      }
+      if (target2) {
+        targets.push(target2);
+      }
+      continue;
+    }
+    let target = "";
+    while (index < command.length && !/[\s;|&<>]/.test(command[index])) {
+      target += command[index];
+      index++;
+    }
+    if (target && !target.startsWith("&")) {
+      targets.push(target);
+    }
+    index--;
+  }
+  return targets;
+}
+function isIgnorableRedirectTarget(target) {
+  const cleaned = unquoteRedirectTarget(target);
+  return IGNORABLE_REDIRECT_TARGETS.has(cleaned);
+}
+function isRedirectTargetOutsideRepo(target, repositoryRoot) {
+  const cleaned = unquoteRedirectTarget(target);
+  const expanded = expandPath(cleaned);
+  if (expanded === "/dev/null" || expanded === "/dev/null2") {
+    return false;
+  }
+  if (expanded === "/tmp" || expanded.startsWith("/tmp/")) {
+    return true;
+  }
+  if (expanded === "~" || expanded.startsWith("~/")) {
+    return true;
+  }
+  const resolved = isAbsolute2(expanded) ? expanded : resolveToCwd(cleaned, repositoryRoot);
+  try {
+    validatePathWithinCwd(resolved, repositoryRoot);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function getBashOutsideRepoRedirectMessage(command, repositoryRoot) {
+  for (const target of extractShellRedirectTargets(command)) {
+    if (isIgnorableRedirectTarget(target)) {
+      continue;
+    }
+    if (isRedirectTargetOutsideRepo(target, repositoryRoot)) {
+      const display = unquoteRedirectTarget(target);
+      return `Redirecting command output outside the project (${display}) is not allowed when sandbox is enabled. The grep and read tools cannot access paths outside the repo. Use a repo-relative log file instead (e.g. .tarsk-test.log), then grep or read that path.`;
+    }
+  }
+  return void 0;
+}
 function isSearchShapedBashCommand(command) {
   for (const segment of splitShellSegments(command)) {
     const tokens = getCommandTokens(segment);
@@ -7205,7 +7424,7 @@ function isSearchShapedBashCommand(command) {
   }
   return false;
 }
-var BROAD_SEARCH_ROOTS, FIND_OPTIONS_WITH_ARG, GREP_BINARIES, RECURSIVE_GREP_FLAGS, GREP_FLAGS_WITH_ARG, HEAD_TAIL_FLAGS_WITH_ARG;
+var BROAD_SEARCH_ROOTS, FIND_OPTIONS_WITH_ARG, GREP_BINARIES, RECURSIVE_GREP_FLAGS, GREP_FLAGS_WITH_ARG, HEAD_TAIL_FLAGS_WITH_ARG, IGNORABLE_REDIRECT_TARGETS;
 var init_bash_command_guard = __esm({
   "src/tools/bash-command-guard.ts"() {
     "use strict";
@@ -7250,6 +7469,7 @@ var init_bash_command_guard = __esm({
       "--exclude-dir"
     ]);
     HEAD_TAIL_FLAGS_WITH_ARG = /* @__PURE__ */ new Set(["-n", "-c", "--lines", "--bytes"]);
+    IGNORABLE_REDIRECT_TARGETS = /* @__PURE__ */ new Set(["/dev/null", "/dev/null2", "NUL", "&1", "1"]);
   }
 });
 
@@ -7788,6 +8008,115 @@ var init_log = __esm({
   }
 });
 
+// src/tools/compress/test-runner.ts
+function stripAnsi(text) {
+  return text.replace(ANSI_ESCAPE_RE, "");
+}
+function looksLikeTestRunnerOutput(text) {
+  const plain = stripAnsi(text);
+  return TEST_FILES_LINE_RE.test(plain) || TESTS_SUMMARY_LINE_RE.test(plain);
+}
+function isSummaryOrTimingLine(line) {
+  const plain = stripAnsi(line);
+  return TEST_FILES_LINE_RE.test(plain) || TESTS_SUMMARY_LINE_RE.test(plain) || TIMING_LINE_RE.test(plain);
+}
+function isFailureHeader(line) {
+  return FAIL_HEADER_RE.test(stripAnsi(line));
+}
+function isWorkerNoise(line) {
+  const plain = stripAnsi(line);
+  return WORKER_NOISE_RE.test(plain) || /^\s*at processTicksAndRejections/.test(plain);
+}
+function shouldKeepFailureLine(line) {
+  const plain = stripAnsi(line);
+  if (!plain.trim()) {
+    return false;
+  }
+  if (isWorkerNoise(line)) {
+    return false;
+  }
+  if (/node_modules[/\\]/.test(plain) && !FAILURE_DETAIL_RE.test(plain)) {
+    return false;
+  }
+  return true;
+}
+function extractFailureBlocks(lines) {
+  const blocks = [];
+  let blockLines = [];
+  let inBlock = false;
+  function flushBlock() {
+    if (blockLines.length === 0) {
+      return;
+    }
+    blocks.push(blockLines.join("\n"));
+    blockLines = [];
+    inBlock = false;
+  }
+  for (const line of lines) {
+    if (isFailureHeader(line)) {
+      flushBlock();
+      inBlock = true;
+      blockLines = [stripAnsi(line)];
+      continue;
+    }
+    if (!inBlock) {
+      continue;
+    }
+    if (blockLines.length >= MAX_FAILURE_BLOCK_LINES) {
+      continue;
+    }
+    if (line.trim() === "" && blockLines.length > 2) {
+      flushBlock();
+      continue;
+    }
+    if (shouldKeepFailureLine(line)) {
+      blockLines.push(stripAnsi(line));
+    }
+  }
+  flushBlock();
+  return blocks;
+}
+function summarizeTestRunnerOutput(text) {
+  if (!text || !looksLikeTestRunnerOutput(text)) {
+    return { text, applied: false };
+  }
+  const lines = text.split("\n");
+  const summaryLines = [];
+  for (const line of lines) {
+    if (isSummaryOrTimingLine(line)) {
+      summaryLines.push(stripAnsi(line).trimEnd());
+    }
+  }
+  const failureBlocks = extractFailureBlocks(lines);
+  const parts = [TEST_RUNNER_BANNER];
+  if (summaryLines.length > 0) {
+    parts.push(summaryLines.join("\n"));
+  }
+  if (failureBlocks.length > 0) {
+    parts.push(failureBlocks.join("\n\n"));
+  }
+  const compressed = parts.join("\n");
+  if (compressed === text || Buffer.byteLength(compressed) >= Buffer.byteLength(text)) {
+    return { text, applied: false };
+  }
+  return { text: compressed, applied: true };
+}
+var TEST_RUNNER_BANNER, ANSI_ESCAPE_RE, TEST_FILES_LINE_RE, TESTS_SUMMARY_LINE_RE, TIMING_LINE_RE, FAIL_HEADER_RE, FAILURE_DETAIL_RE, WORKER_NOISE_RE, MAX_FAILURE_BLOCK_LINES;
+var init_test_runner = __esm({
+  "src/tools/compress/test-runner.ts"() {
+    "use strict";
+    TEST_RUNNER_BANNER = "[Test output summarized; passing tests and worker teardown omitted]";
+    ANSI_ESCAPE_RE = /\u001b\[[0-9;]*m/g;
+    TEST_FILES_LINE_RE = /\bTest Files\b/;
+    TESTS_SUMMARY_LINE_RE = /^\s*Tests\s+\d+/;
+    TIMING_LINE_RE = /^\s*(Start at|Duration)\b/;
+    FAIL_HEADER_RE = /^\s*FAIL\s+/;
+    FAILURE_DETAIL_RE = /AssertionError|Expected|Received|\berror TS\d+\b|Cannot find name|✗|×|❯/;
+    WORKER_NOISE_RE = /^\[vitest-pool\]:|^Emitted 'error' event|^Error: kill EPERM|^node:events:/;
+    MAX_FAILURE_BLOCK_LINES = 14;
+  }
+});
+
 // src/tools/compress/bash.ts
 function looksLikePathLine(line) {
   if (!line) {
@@ -7903,6 +8232,11 @@ function compressBashOutput(text) {
   if (!text) {
     return text;
   }
+  const testSummary = summarizeTestRunnerOutput(text);
+  if (testSummary.applied) {
+    logCompressOutput("bash.test-runner", text, testSummary.text);
+    return testSummary.text;
+  }
   const lines = text.split("\n");
   const attempts = [
     tryCompressPurePathList,
@@ -7925,6 +8259,7 @@ var init_bash = __esm({
     init_find();
     init_grep();
     init_log();
+    init_test_runner();
     GIT_COMMIT_HEADER = /^[0-9a-f]{7,40} /;
   }
 });
@@ -8120,7 +8455,29 @@ function createBashTool(repositoryRoot, options) {
       const resolvedCommand = commandPrefix ? `${commandPrefix}
 ${command}` : command;
       tarskDebugLog(`[ai] bash-start: ${resolvedCommand}`);
-      validateBashDedicatedToolRedirect(resolvedCommand);
+      if (sandboxConfig) {
+        const outsideRepoRedirect = getBashOutsideRepoRedirectMessage(
+          resolvedCommand,
+          repositoryRoot
+        );
+        if (outsideRepoRedirect) {
+          log12.debug("Redirecting bash away from out-of-repo output path", {
+            command: resolvedCommand
+          });
+          return {
+            content: [{ type: "text", text: outsideRepoRedirect }],
+            details: void 0
+          };
+        }
+      }
+      const dedicatedRedirect = getBashDedicatedToolRedirectMessage(resolvedCommand);
+      if (dedicatedRedirect) {
+        log12.debug("Redirecting bash to dedicated tool", { command: resolvedCommand });
+        return {
+          content: [{ type: "text", text: dedicatedRedirect }],
+          details: void 0
+        };
+      }
       validateBashFilesystemSearch(resolvedCommand, repositoryRoot);
       if (shellPermissionGate) {
         await shellPermissionGate.ensureAllowed(toolCallId, resolvedCommand, "bash", signal);
@@ -8526,16 +8883,86 @@ var init_tool_helpers = __esm({
 import { Type as Type2 } from "@sinclair/typebox";
 import { constants as constants2 } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+function resolveReplacements(input) {
+  if (input.replacements && input.replacements.length > 0) {
+    return input.replacements.map((replacement) => ({
+      oldText: replacement.oldText,
+      newText: replacement.newText,
+      replaceAll: replacement.replaceAll ?? input.replaceAll ?? false
+    }));
+  }
+  if (input.oldText !== void 0 && input.newText !== void 0) {
+    return [
+      {
+        oldText: input.oldText,
+        newText: input.newText,
+        replaceAll: input.replaceAll ?? false
+      }
+    ];
+  }
+  throw new Error(
+    "Provide either oldText+newText or a non-empty replacements array of { oldText, newText } hunks."
+  );
+}
+function applySingleReplacement(content, normalizedOldText, normalizedNewText) {
+  const matchResult = fuzzyFindText(content, normalizedOldText);
+  if (!matchResult.found) {
+    return { content, replaced: false };
+  }
+  return {
+    content: content.substring(0, matchResult.index) + normalizedNewText + content.substring(matchResult.index + matchResult.matchLength),
+    replaced: true
+  };
+}
+function applyReplacement(content, path8, oldText, newText, replaceAll) {
+  const normalizedOldText = normalizeToLF(oldText);
+  const normalizedNewText = normalizeToLF(newText);
+  if (!replaceAll) {
+    const matchResult = fuzzyFindText(content, normalizedOldText);
+    if (!matchResult.found) {
+      throw new Error(
+        `Could not find the exact text in ${path8}. The old text must match exactly including all whitespace and newlines.`
+      );
+    }
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+    const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+    if (occurrences > 1) {
+      throw new Error(
+        `Found ${occurrences} occurrences of the text in ${path8}. The text must be unique. Please provide more context to make it unique, or set replaceAll: true to replace every occurrence.`
+      );
+    }
+    return content.substring(0, matchResult.index) + normalizedNewText + content.substring(matchResult.index + matchResult.matchLength);
+  }
+  let result = content;
+  let replacedCount = 0;
+  while (true) {
+    const next = applySingleReplacement(result, normalizedOldText, normalizedNewText);
+    if (!next.replaced) {
+      break;
+    }
+    result = next.content;
+    replacedCount++;
+  }
+  if (replacedCount === 0) {
+    throw new Error(
+      `Could not find the exact text in ${path8}. The old text must match exactly including all whitespace and newlines.`
+    );
+  }
+  return result;
+}
 function createEditTool(cwd, options) {
   const ops = options?.operations ?? defaultEditOperations;
   return {
     name: "edit",
     label: "edit",
-    description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+    description: "Edit a file by replacing exact text (oldText must match uniquely unless replaceAll is true). Prefer fewer larger hunks over many tiny serial edits. Use replacements to apply multiple hunks in one call; set replaceAll on a hunk (or top-level) for mechanical refactors with repeated oldText. Call edit in parallel across independent files.",
     parameters: editSchema,
-    execute: async (_toolCallId, { path: path8, oldText, newText }, signal) => {
+    execute: async (_toolCallId, input, signal) => {
+      const { path: path8 } = input;
       const absolutePath = resolveToCwd(path8, cwd);
       validatePathWithinCwd(absolutePath, cwd);
+      const hunks = resolveReplacements(input);
       return withAbortSignal(signal, async (isAborted) => {
         try {
           await ops.access(absolutePath);
@@ -8548,26 +8975,18 @@ function createEditTool(cwd, options) {
         if (isAborted()) return { content: [], details: void 0 };
         const { bom, text: content } = stripBom(rawContent);
         const originalEnding = detectLineEnding(content);
-        const normalizedContent = normalizeToLF(content);
-        const normalizedOldText = normalizeToLF(oldText);
-        const normalizedNewText = normalizeToLF(newText);
-        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
-        if (!matchResult.found) {
-          throw new Error(
-            `Could not find the exact text in ${path8}. The old text must match exactly including all whitespace and newlines.`
+        const baseContent = normalizeToLF(content);
+        let newContent = baseContent;
+        for (const hunk of hunks) {
+          newContent = applyReplacement(
+            newContent,
+            path8,
+            hunk.oldText,
+            hunk.newText,
+            hunk.replaceAll
           );
+          if (isAborted()) return { content: [], details: void 0 };
         }
-        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
-        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
-        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
-        if (occurrences > 1) {
-          throw new Error(
-            `Found ${occurrences} occurrences of the text in ${path8}. The text must be unique. Please provide more context to make it unique.`
-          );
-        }
-        if (isAborted()) return { content: [], details: void 0 };
-        const baseContent = normalizedContent;
-        const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
         if (baseContent === newContent) {
           throw new Error(
             `No changes made to ${path8}. The replacement produced identical content.`
@@ -8577,25 +8996,65 @@ function createEditTool(cwd, options) {
         await ops.writeFile(absolutePath, finalContent);
         if (isAborted()) return { content: [], details: void 0 };
         const diffResult = generateDiffString(baseContent, newContent);
+        const hunkLabel = hunks.length === 1 ? "text" : `${hunks.length} hunks`;
         return {
-          content: [{ type: "text", text: `Successfully replaced text in ${path8}.` }],
-          details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+          content: [
+            {
+              type: "text",
+              text: `Successfully replaced ${hunkLabel} in ${path8}.`
+            }
+          ],
+          details: {
+            diff: diffResult.diff,
+            firstChangedLine: diffResult.firstChangedLine,
+            replacementCount: hunks.length
+          }
         };
       });
     }
   };
 }
-var editSchema, defaultEditOperations, editTool;
+var replacementSchema, editSchema, defaultEditOperations, editTool;
 var init_edit = __esm({
   "src/tools/edit.ts"() {
     "use strict";
     init_edit_diff();
     init_path_utils();
     init_tool_helpers();
+    replacementSchema = Type2.Object({
+      oldText: Type2.String({
+        description: "Exact text to find and replace (must match exactly; unique unless replaceAll is true)"
+      }),
+      newText: Type2.String({ description: "Replacement text" }),
+      replaceAll: Type2.Optional(
+        Type2.Boolean({
+          description: "When true, replace every occurrence of oldText in the file."
+        })
+      )
+    });
     editSchema = Type2.Object({
       path: Type2.String({ description: "Path to the file to edit (relative or absolute)" }),
-      oldText: Type2.String({ description: "Exact text to find and replace (must match exactly)" }),
-      newText: Type2.String({ description: "New text to replace the old text with" })
+      oldText: Type2.Optional(
+        Type2.String({
+          description: "Exact text to find and replace (must match exactly). Required unless replacements is set."
+        })
+      ),
+      newText: Type2.Optional(
+        Type2.String({
+          description: "New text to replace oldText with. Required unless replacements is set."
+        })
+      ),
+      replaceAll: Type2.Optional(
+        Type2.Boolean({
+          description: "When true with oldText/newText, replace every occurrence. Per-hunk replaceAll in replacements overrides this."
+        })
+      ),
+      replacements: Type2.Optional(
+        Type2.Array(replacementSchema, {
+          minItems: 1,
+          description: "Multiple hunks to apply in one call (applied in order). Prefer this over serial single-hunk edits on the same file."
+        })
+      )
     });
     defaultEditOperations = {
       readFile: (path8) => fsReadFile(path8),
@@ -8611,13 +9070,13 @@ import { Type as Type3 } from "@sinclair/typebox";
 import { existsSync as existsSync7 } from "fs";
 import os2 from "node:os";
 import path2 from "path";
-import { globSync } from "glob";
+import { globSync as globSync2 } from "glob";
 function createFindTool(cwd, options) {
   const customOps = options?.operations;
   return {
     name: "find",
     label: "find",
-    description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. When many results share directories, output is grouped as "dir/: file1, file2" lines (one path per file, "dir/name") to save space; bare filenames are root-level files. Output truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB.`,
+    description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. When many results share directories, output is grouped as "dir/: file1, file2" lines (one path per file, "dir/name") to save space; bare filenames are root-level files. Brace expansion like dir/{a,b}.tsx only matches that directory level; use **/name.tsx or dir/**/*.tsx for nested files. Output truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB.`,
     parameters: findSchema,
     execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
       return withAbortSignal(signal, async (isAborted) => {
@@ -8727,7 +9186,7 @@ var init_find2 = __esm({
       glob: async (pattern, searchCwd, { ignore, limit }) => {
         const results = [];
         try {
-          const found = globSync(pattern, {
+          const found = globSync2(pattern, {
             cwd: searchCwd,
             dot: true,
             ignore: ["**/node_modules/**", "**/.git/**", ...ignore],
@@ -9155,6 +9614,16 @@ function toRipgrepSearchPath(absoluteSearchPath, cwd) {
   }
   return relative8.replace(/\\/g, "/");
 }
+function formatRipgrepFailure(stderr, code) {
+  const trimmed = stderr.trim();
+  const base = trimmed || (code === 2 ? "ripgrep exited with code 2" : `ripgrep exited with code ${code}`);
+  if (REGEX_PARSE_ERROR_RE.test(trimmed)) {
+    return new Error(`${base}
+
+${REGEX_PARSE_HINT}`);
+  }
+  return new Error(base);
+}
 async function runRipgrep(args2, searchPath, cwd) {
   const rgSearchPath = toRipgrepSearchPath(searchPath, cwd);
   const { code, stdout, stderr } = await ripgrep([...args2, rgSearchPath], {
@@ -9162,10 +9631,10 @@ async function runRipgrep(args2, searchPath, cwd) {
     preopens: { ".": cwd }
   });
   if (code === 2) {
-    throw new Error(stderr.trim() || "ripgrep exited with code 2");
+    throw formatRipgrepFailure(stderr, code);
   }
   if (code !== 0 && code !== 1) {
-    throw new Error(stderr.trim() || `ripgrep exited with code ${code}`);
+    throw formatRipgrepFailure(stderr, code);
   }
   return parseRipgrepOutput(stdout);
 }
@@ -9188,13 +9657,25 @@ function sortFilesByMtime(files) {
     return timeComparison;
   }).map(([filePath]) => filePath);
 }
-function formatContentResult(cwd, results, headLimit, offset) {
+function looksLikePathScopedGlob(glob3) {
+  if (!glob3) {
+    return false;
+  }
+  return glob3.includes("/") || glob3.includes("\\");
+}
+function emptyMatchText(input) {
+  if (looksLikePathScopedGlob(input.glob)) {
+    return 'No matches found. Tip: prefer path for file/directory scope (e.g. path="app/components") and extension globs like "*.tsx" or "**/*.ts"; path-prefixed globs can miss matches depending on the search root.';
+  }
+  return "No matches found";
+}
+function formatContentResult(cwd, results, headLimit, offset, emptyText) {
   const { items: limitedResults, appliedLimit } = applyHeadLimit(results, headLimit, offset);
   const finalLines = limitedResults.map((line) => relativizeContentLine(cwd, line));
   const limitInfo = formatLimitInfo(appliedLimit, offset > 0 ? offset : void 0);
   let text;
   if (finalLines.length === 0) {
-    text = "No matches found";
+    text = emptyText;
   } else {
     const flat = finalLines.join("\n");
     const compressed = compressContent(finalLines);
@@ -9215,7 +9696,7 @@ ${compressed.text}` : compressed.text;
   };
   return { text, details };
 }
-function formatCountResult(cwd, results, headLimit, offset) {
+function formatCountResult(cwd, results, headLimit, offset, emptyText) {
   const { items: limitedResults, appliedLimit } = applyHeadLimit(results, headLimit, offset);
   const finalCountLines = limitedResults.map((line) => relativizeCountLine(cwd, line));
   const limitInfo = formatLimitInfo(appliedLimit, offset > 0 ? offset : void 0);
@@ -9233,7 +9714,7 @@ function formatCountResult(cwd, results, headLimit, offset) {
   }
   let text;
   if (finalCountLines.length === 0) {
-    text = "No matches found";
+    text = emptyText;
   } else {
     const flat = finalCountLines.join("\n");
     const compressed = compressCount(finalCountLines);
@@ -9258,14 +9739,14 @@ Found ${totalMatches} total ${occurrenceLabel} across ${fileCount} ${fileLabel}.
   };
   return { text, details };
 }
-function formatFilesResult(cwd, results, headLimit, offset) {
+function formatFilesResult(cwd, results, headLimit, offset, emptyText) {
   const sortedMatches = sortFilesByMtime(results);
   const { items: finalMatches, appliedLimit } = applyHeadLimit(sortedMatches, headLimit, offset);
   const relativeMatches = finalMatches.map((filePath) => toRelativePath(cwd, filePath));
   const limitInfo = formatLimitInfo(appliedLimit, offset > 0 ? offset : void 0);
   let text;
   if (relativeMatches.length === 0) {
-    text = "No files found";
+    text = emptyText === "No matches found" ? "No files found" : emptyText.replace("No matches found", "No files found");
   } else {
     const fileLabel = relativeMatches.length === 1 ? "file" : "files";
     const flat = relativeMatches.join("\n");
@@ -9306,13 +9787,14 @@ function createRipGrepTool(cwd) {
       const offset = input.offset ?? 0;
       const args2 = buildRipgrepArgs({ ...input, output_mode: outputMode });
       const results = await runRipgrep(args2, searchPath, cwd);
+      const emptyText = emptyMatchText(input);
       let formatted;
       if (outputMode === "content") {
-        formatted = formatContentResult(cwd, results, headLimit, offset);
+        formatted = formatContentResult(cwd, results, headLimit, offset, emptyText);
       } else if (outputMode === "count") {
-        formatted = formatCountResult(cwd, results, headLimit, offset);
+        formatted = formatCountResult(cwd, results, headLimit, offset, emptyText);
       } else {
-        formatted = formatFilesResult(cwd, results, headLimit, offset);
+        formatted = formatFilesResult(cwd, results, headLimit, offset, emptyText);
       }
       const truncation = truncateHead(formatted.text);
       let output = truncation.content;
@@ -9351,7 +9833,7 @@ function createRipGrepTool(cwd) {
     }
   };
 }
-var VCS_DIRECTORIES_TO_EXCLUDE, DEFAULT_HEAD_LIMIT, ripGrepSchema, log15, PATHLESS_CONTENT_LINE2, ripGrepTool;
+var VCS_DIRECTORIES_TO_EXCLUDE, DEFAULT_HEAD_LIMIT, ripGrepSchema, log15, PATHLESS_CONTENT_LINE2, REGEX_PARSE_ERROR_RE, REGEX_PARSE_HINT, ripGrepTool;
 var init_rip_grep = __esm({
   "src/tools/rip-grep.ts"() {
     "use strict";
@@ -9438,6 +9920,8 @@ var init_rip_grep = __esm({
     });
     log15 = createLogger("tools.rip-grep");
     PATHLESS_CONTENT_LINE2 = /^\d+[:-]/;
+    REGEX_PARSE_ERROR_RE = /regex parse error/i;
+    REGEX_PARSE_HINT = "Tip: grep patterns use ripgrep regex syntax. Escape special characters ($, {, }, (, ), [, ], *, +, ?, |, \\) with a backslash, or search for a simpler literal substring.";
     ripGrepTool = createRipGrepTool(process.cwd());
   }
 });
@@ -10780,11 +11264,49 @@ var init_ralph_progress = __esm({
 
 // src/tools/todo.ts
 import { Type as Type13 } from "@sinclair/typebox";
+function truncateTodoDescription(description, maxLength = 48) {
+  const oneLine = description.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= maxLength) {
+    return oneLine;
+  }
+  return `${oneLine.slice(0, maxLength - 1)}\u2026`;
+}
+function formatUpdatedTodosAck(items) {
+  if (items.length === 1) {
+    const item = items[0];
+    return `Updated 1 todo: "${truncateTodoDescription(item.description)}" \u2192 ${item.status}`;
+  }
+  const parts = items.map(
+    (item) => `"${truncateTodoDescription(item.description)}" \u2192 ${item.status}`
+  );
+  return `Updated ${items.length} todos: ${parts.join("; ")}`;
+}
+function formatDeletedTodosAck(items) {
+  if (items.length === 1) {
+    return `Deleted 1 todo: "${truncateTodoDescription(items[0].description)}"`;
+  }
+  const parts = items.map((item) => `"${truncateTodoDescription(item.description)}"`);
+  return `Deleted ${items.length} todos: ${parts.join("; ")}`;
+}
+async function fetchTodosByIds(db, threadId, ids) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const result = await db.execute({
+      sql: `SELECT id, description, status FROM todos WHERE id = ? AND threadId = ?`,
+      args: [id, threadId]
+    });
+    const row = result.rows[0];
+    if (row) {
+      rows.set(id, row);
+    }
+  }
+  return rows;
+}
 function createTodoTool(threadId, threadPath) {
   return {
     name: "todo",
     label: "todo",
-    description: "Manage todo items to break down the current task into 2 more items. Use 'add' to create items when planning work, 'update' to change an item's status as you progress (pending \u2192 working \u2192 done), 'list' to see all current items, and 'delete' to remove one. Marking an item done does not end the conversation \u2014 continue working on remaining items. Call 'list' at the end so the user sees a completion checklist.",
+    description: "Manage todo items to break down the current task into 2 more items. Use 'add' to create items when planning work, 'update' to change an item's status as you progress (pending \u2192 working \u2192 done), 'list' to see all current items, and 'delete' to remove one. Marking an item done does not end the conversation \u2014 continue working on remaining items. Use 'list' when you need the full checklist; 'update' and 'delete' return a short confirmation only.",
     parameters: todoSchema,
     execute: async (_toolCallId, { action, descriptions, ids, status, assignedTo, passes, learnings }) => {
       const db = await getDatabase();
@@ -10818,16 +11340,22 @@ function createTodoTool(threadId, threadPath) {
               details: void 0
             };
           }
-          const notFound = [];
+          const existingById = await fetchTodosByIds(db, threadId, ids);
+          const notFound = ids.filter((id) => !existingById.has(id));
+          if (notFound.length > 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: todos not found: ${notFound.join(", ")}`
+                }
+              ],
+              details: void 0
+            };
+          }
+          const updatedItems = [];
           for (const id of ids) {
-            const existing = await db.execute({
-              sql: `SELECT id FROM todos WHERE id = ? AND threadId = ?`,
-              args: [id, threadId]
-            });
-            if (existing.rows.length === 0) {
-              notFound.push(id);
-              continue;
-            }
+            const existing = existingById.get(id);
             const updates = [];
             const args2 = [];
             if (status) {
@@ -10849,24 +11377,16 @@ function createTodoTool(threadId, threadPath) {
               sql: `UPDATE todos SET ${updates.join(", ")} WHERE id = ? AND threadId = ?`,
               args: args2
             });
+            updatedItems.push({
+              description: existing.description,
+              status: status ?? existing.status
+            });
           }
-          if (notFound.length > 0) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: todos not found: ${notFound.join(", ")}`
-                }
-              ],
-              details: void 0
-            };
-          }
-          const todosAfterUpdate = await fetchAllTodos(db, threadId);
           return {
             content: [
               {
                 type: "text",
-                text: JSON.stringify({ todos: todosAfterUpdate })
+                text: formatUpdatedTodosAck(updatedItems)
               }
             ],
             details: void 0
@@ -10891,18 +11411,19 @@ function createTodoTool(threadId, threadPath) {
               details: void 0
             };
           }
+          const existingById = await fetchTodosByIds(db, threadId, ids);
+          const deletedItems = ids.map((id) => existingById.get(id)).filter((row) => row !== void 0).map((row) => ({ description: row.description }));
           for (const id of ids) {
             await db.execute({
               sql: `DELETE FROM todos WHERE id = ? AND threadId = ?`,
               args: [id, threadId]
             });
           }
-          const todosAfterDelete = await fetchAllTodos(db, threadId);
           return {
             content: [
               {
                 type: "text",
-                text: JSON.stringify({ todos: todosAfterDelete })
+                text: formatDeletedTodosAck(deletedItems)
               }
             ],
             details: void 0
@@ -11665,7 +12186,7 @@ var init_spend_record = __esm({
 
 // src/features/git/git.utils.ts
 import { existsSync as existsSync11, readFileSync as readFileSync4, statSync as statSync6 } from "fs";
-import { isAbsolute as isAbsolute2, normalize as normalize2, resolve as resolve2, join as join10 } from "path";
+import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve2, join as join10 } from "path";
 async function resolveModelAndKey(provider, modelId, metadataManager) {
   const providerConfig = await resolveProviderConfig(provider);
   if (!providerConfig) return null;
@@ -11812,7 +12333,7 @@ Generate only the commit message, nothing else:`;
   }
 }
 function resolveThreadPath(repoPath) {
-  const base = isAbsolute2(repoPath) ? repoPath : resolve2(getDataDir(), repoPath);
+  const base = isAbsolute3(repoPath) ? repoPath : resolve2(getDataDir(), repoPath);
   return normalize2(base);
 }
 async function getGitRoot(cwd) {
@@ -17675,7 +18196,7 @@ function createGetObservationTool(threadId, options) {
   return {
     name: "get_observation",
     label: "get_observation",
-    description: `Retrieve exact stored tool output by observation ID. Output is limited to ${OBSERVATION_RETRIEVAL_MAX_LINES} lines or ${formatSize(OBSERVATION_RETRIEVAL_MAX_BYTES)}. Use offset and limit to page through large observations. IDs are scoped to the current thread.`,
+    description: `Retrieve exact stored tool output by observation ID. Output is limited to ${OBSERVATION_RETRIEVAL_MAX_LINES} lines or ${formatSize(OBSERVATION_RETRIEVAL_MAX_BYTES)}. Use offset and limit to page through large observations; offset counts lines within the stored output (see the preview's lines=N attribute), not line numbers shown inside grep results. IDs are scoped to the current thread.`,
     parameters: getObservationSchema,
     execute: async (_toolCallId, input) => {
       if (!isObservationId(input.id)) {
@@ -17692,7 +18213,7 @@ function createGetObservationTool(threadId, options) {
       const startIndex = offset - 1;
       if (startIndex >= lines.length) {
         throw new Error(
-          `Offset ${offset} is beyond end of observation (${stored.ref.lineCount} lines total)`
+          `Offset ${offset} is beyond end of observation (${stored.ref.lineCount} lines total). Observation offset is 1-indexed within the stored tool output, not a source-file line number. Use offset=1 to read from the start.`
         );
       }
       const selected = lines.slice(startIndex, startIndex + limit).join("\n");
@@ -17743,7 +18264,7 @@ var init_get_observation = __esm({
       }),
       offset: Type23.Optional(
         Type23.Integer({
-          description: "Line number to start reading from (1-indexed)",
+          description: "Line number to start reading within the stored tool output (1-indexed). Not a source-file line number from grep/read content.",
           minimum: 1
         })
       ),
@@ -20618,6 +21139,13 @@ function usesTailPreview(toolName) {
   const normalized = toolName.toLowerCase();
   return normalized === "bash" || normalized.includes("shell") || normalized.includes("terminal");
 }
+function observationRetrievalHint(toolName, ref, firstLine, previewEndLine, nextOffset) {
+  const base = `[Full output stored as ${ref.id} (${formatSize(ref.byteLength)}, ${ref.lineCount} lines). Preview shows lines ${firstLine}-${previewEndLine}. Use get_observation with id="${ref.id}", offset=${nextOffset}, and limit=200 to retrieve exact output.`;
+  if (toolName.toLowerCase() === "grep") {
+    return `${base} Line numbers in grep output (e.g. :275:) are source-file lines; get_observation offset is relative to this stored output (lines=${ref.lineCount}).`;
+  }
+  return base;
+}
 function buildObservationPreview(fullContent, toolName, ref) {
   const options = {
     maxBytes: OBSERVATION_PREVIEW_MAX_BYTES - PREVIEW_METADATA_RESERVE_BYTES,
@@ -20626,13 +21154,14 @@ function buildObservationPreview(fullContent, toolName, ref) {
   const tail = usesTailPreview(toolName);
   const truncation = tail ? truncateTail(fullContent, options) : truncateHead(fullContent, options);
   const firstLine = tail ? Math.max(1, ref.lineCount - truncation.outputLines + 1) : 1;
+  const previewEndLine = firstLine + Math.max(0, truncation.outputLines - 1);
   const nextOffset = tail ? 1 : truncation.outputLines + 1;
   const preview = [
     `<observation_preview id="${ref.id}" tool="${toolName}" bytes="${ref.byteLength}" lines="${ref.lineCount}">`,
     truncation.content,
     "</observation_preview>",
     "",
-    `[Full output stored as ${ref.id} (${formatSize(ref.byteLength)}, ${ref.lineCount} lines). Preview shows lines ${firstLine}-${firstLine + Math.max(0, truncation.outputLines - 1)}. Use get_observation with id="${ref.id}", offset=${nextOffset}, and limit=200 to retrieve exact output.]`
+    observationRetrievalHint(toolName, ref, firstLine, previewEndLine, nextOffset)
   ].join("\n");
   return {
     content: preview,
@@ -20758,6 +21287,94 @@ function estimateMessageTokens(message) {
   }
   return 0;
 }
+function countAssistantTurns(messages) {
+  let count = 0;
+  for (const message of messages) {
+    if (typeof message === "object" && message !== null && "role" in message && message.role === "assistant") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function isUserMessage(message) {
+  return typeof message === "object" && message !== null && "role" in message && message.role === "user";
+}
+function countUserMessages(messages) {
+  let count = 0;
+  for (const message of messages) {
+    if (isUserMessage(message)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function findLastUserMessageIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (isUserMessage(messages[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+function isCompactedToolResultText(text) {
+  return text.startsWith(MICROCOMPACT_MARKER_PREFIX) || text.startsWith(TODO_DUPLICATE_OMITTED_PREFIX);
+}
+async function digestToolResultMessage(original, text, options, memo) {
+  const memoized = memo.get(original.toolCallId);
+  if (memoized) {
+    return { compacted: memoized, observationIdsReused: 0, observationIdsCreated: 0 };
+  }
+  let observation = findObservationRef(original);
+  let observationIdsReused = 0;
+  let observationIdsCreated = 0;
+  if (observation) {
+    observationIdsReused = 1;
+  } else {
+    const created = await maybeExternalizeForDigest(original, text, options);
+    if (created) {
+      observation = created;
+      observationIdsCreated = 1;
+    }
+  }
+  const digest = observation ? buildObservationDigest(original.toolName, observation, original.isError) : buildHeuristicDigest(original.toolName, text, original.isError);
+  const compacted = replaceToolResultContent(original, digest, observation);
+  memo.set(original.toolCallId, compacted);
+  return { compacted, observationIdsReused, observationIdsCreated };
+}
+function deduplicateIdenticalTodoResults(messages) {
+  const lastIndexByContent = /* @__PURE__ */ new Map();
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (!isToolResultMessage(message) || message.toolName !== "todo") {
+      continue;
+    }
+    const text = extractTextContent(message.content);
+    if (text.length > 0) {
+      lastIndexByContent.set(text, i);
+    }
+  }
+  const next = messages.slice();
+  let changed = false;
+  for (let i = 0; i < next.length; i++) {
+    const message = next[i];
+    if (!isToolResultMessage(message) || message.toolName !== "todo") {
+      continue;
+    }
+    const text = extractTextContent(message.content);
+    const keepIndex = lastIndexByContent.get(text);
+    if (keepIndex === void 0 || keepIndex === i) {
+      continue;
+    }
+    const keptId = messages[keepIndex].toolCallId;
+    next[i] = replaceToolResultContent(
+      message,
+      `${TODO_DUPLICATE_OMITTED_PREFIX}${keptId}]`,
+      void 0
+    );
+    changed = true;
+  }
+  return changed ? next : messages;
+}
 function findObservationRef(message) {
   if (isObservationRef(message.details?.observation)) {
     return message.details.observation;
@@ -20887,6 +21504,9 @@ async function microcompactMessages(messages, options = {}) {
   const triggerMargin = options.triggerMargin ?? MICROCOMPACT_TRIGGER_MARGIN;
   const minSaveTokens = options.minSaveTokens ?? MICROCOMPACT_MIN_SAVE_TOKENS;
   const digestMinChars = options.digestMinChars ?? MICROCOMPACT_DIGEST_MIN_CHARS;
+  const proactiveTurnThreshold = options.proactiveTurnThreshold ?? MICROCOMPACT_PROACTIVE_TURN_THRESHOLD;
+  const proactivePayloadTokens = options.proactivePayloadTokens ?? MICROCOMPACT_PROACTIVE_PAYLOAD_TOKENS;
+  const proactiveMinSaveTokens = options.proactiveMinSaveTokens ?? MICROCOMPACT_PROACTIVE_MIN_SAVE_TOKENS;
   const effectiveWindow = computeEffectiveContextWindow(
     options.contextWindow,
     options.maxOutputTokens
@@ -20894,12 +21514,16 @@ async function microcompactMessages(messages, options = {}) {
   const messageTokens = messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
   const fixedOverheadTokens = typeof options.fixedOverheadTokens === "number" && options.fixedOverheadTokens > 0 ? options.fixedOverheadTokens : 0;
   const tokensBefore = messageTokens + fixedOverheadTokens;
-  if (tokensBefore < effectiveWindow - triggerMargin) {
+  const agentTurnCount = countAssistantTurns(messages);
+  const proactiveTrigger = agentTurnCount >= proactiveTurnThreshold || tokensBefore >= proactivePayloadTokens;
+  const nearWindowCeiling = tokensBefore >= effectiveWindow - triggerMargin;
+  if (!nearWindowCeiling && !proactiveTrigger) {
     return {
       messages,
       stats: { ...emptyStats, tokensBefore, tokensAfter: tokensBefore }
     };
   }
+  const effectiveMinSaveTokens = proactiveTrigger && !nearWindowCeiling ? proactiveMinSaveTokens : minSaveTokens;
   const eligibleIndexes = [];
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i];
@@ -20943,7 +21567,7 @@ async function microcompactMessages(messages, options = {}) {
   for (const index of clearCandidates) {
     clearableTokens += estimateMessageTokens(messages[index]);
   }
-  if (clearableTokens < minSaveTokens || clearCandidates.length === 0) {
+  if (clearableTokens < effectiveMinSaveTokens || clearCandidates.length === 0) {
     return {
       messages,
       stats: {
@@ -20961,26 +21585,14 @@ async function microcompactMessages(messages, options = {}) {
   let clearedCount = 0;
   for (const index of clearCandidates) {
     const original = messages[index];
-    const memoized = memo.get(original.toolCallId);
-    if (memoized) {
-      next[index] = memoized;
-      clearedCount += 1;
-      continue;
-    }
     const text = extractTextContent(original.content);
-    let observation = findObservationRef(original);
-    if (observation) {
-      observationIdsReused += 1;
-    } else {
-      const created = await maybeExternalizeForDigest(original, text, options);
-      if (created) {
-        observation = created;
-        observationIdsCreated += 1;
-      }
-    }
-    const digest = observation ? buildObservationDigest(original.toolName, observation, original.isError) : buildHeuristicDigest(original.toolName, text, original.isError);
-    const compacted = replaceToolResultContent(original, digest, observation);
-    memo.set(original.toolCallId, compacted);
+    const {
+      compacted,
+      observationIdsReused: reused,
+      observationIdsCreated: created
+    } = await digestToolResultMessage(original, text, options, memo);
+    observationIdsReused += reused;
+    observationIdsCreated += created;
     next[index] = compacted;
     clearedCount += 1;
   }
@@ -21002,19 +21614,98 @@ async function microcompactMessages(messages, options = {}) {
   }
   return { messages: next, stats };
 }
+async function prunePriorTurnToolResults(messages, options = {}) {
+  const emptyStats = {
+    eligibleCount: 0,
+    keptCount: 0,
+    clearedCount: 0,
+    tokensBefore: 0,
+    tokensAfter: 0,
+    tokensSaved: 0,
+    observationIdsReused: 0,
+    observationIdsCreated: 0,
+    applied: false
+  };
+  if (!areMicrocompactEnabled()) {
+    return { messages, stats: emptyStats };
+  }
+  if (countUserMessages(messages) < 2) {
+    return { messages, stats: emptyStats };
+  }
+  const lastUserIndex = findLastUserMessageIndex(messages);
+  if (lastUserIndex <= 0) {
+    return { messages, stats: emptyStats };
+  }
+  const memo = options.memo ?? /* @__PURE__ */ new Map();
+  const digestMinChars = options.digestMinChars ?? MICROCOMPACT_DIGEST_MIN_CHARS;
+  const next = messages.slice();
+  let observationIdsReused = 0;
+  let observationIdsCreated = 0;
+  let clearedCount = 0;
+  let eligibleCount = 0;
+  for (let index = 0; index < lastUserIndex; index++) {
+    const message = messages[index];
+    if (!isToolResultMessage(message) || message.isError) {
+      continue;
+    }
+    if (!isMicrocompactEligibleTool(message.toolName)) {
+      continue;
+    }
+    const text = extractTextContent(message.content);
+    if (text.length < digestMinChars || isCompactedToolResultText(text)) {
+      continue;
+    }
+    eligibleCount += 1;
+    const {
+      compacted,
+      observationIdsReused: reused,
+      observationIdsCreated: created
+    } = await digestToolResultMessage(message, text, options, memo);
+    observationIdsReused += reused;
+    observationIdsCreated += created;
+    next[index] = compacted;
+    clearedCount += 1;
+  }
+  if (clearedCount === 0) {
+    return { messages, stats: emptyStats };
+  }
+  const messagesTokensBefore = messages.reduce(
+    (sum, message) => sum + estimateMessageTokens(message),
+    0
+  );
+  const messagesTokensAfter = next.reduce(
+    (sum, message) => sum + estimateMessageTokens(message),
+    0
+  );
+  const stats = {
+    eligibleCount,
+    keptCount: 0,
+    clearedCount,
+    tokensBefore: messagesTokensBefore,
+    tokensAfter: messagesTokensAfter,
+    tokensSaved: Math.max(0, messagesTokensBefore - messagesTokensAfter),
+    observationIdsReused,
+    observationIdsCreated,
+    applied: true
+  };
+  log49.info("Applied prior-turn tool-result prune", stats);
+  return { messages: next, stats };
+}
 function createMicrocompactTransformContext(options) {
   const memo = options.memo ?? /* @__PURE__ */ new Map();
   return async function transformContext(messages) {
     try {
-      const result = await microcompactMessages(messages, { ...options, memo });
+      const deduped = deduplicateIdenticalTodoResults(messages);
+      const pruned = await prunePriorTurnToolResults(deduped, { ...options, memo });
+      const result = await microcompactMessages(pruned.messages, { ...options, memo });
       return result.messages;
     } catch (error) {
       log49.warn("Micro-compaction failed; sending original context", { error });
-      return messages;
+      return deduplicateIdenticalTodoResults(messages);
     }
   };
 }
-var log49, OBSERVATION_ID_IN_TEXT;
+var log49, OBSERVATION_ID_IN_TEXT, TODO_DUPLICATE_OMITTED_PREFIX;
 var init_microcompact2 = __esm({
   "src/features/microcompact/microcompact.ts"() {
     "use strict";
@@ -21024,6 +21715,7 @@ var init_microcompact2 = __esm({
     init_microcompact_config();
     log49 = createLogger("microcompact");
     OBSERVATION_ID_IN_TEXT = /obs_[a-f0-9]{64}/;
+    TODO_DUPLICATE_OMITTED_PREFIX = "[Duplicate todo result omitted; identical to toolCallId=";
   }
 });
 
@@ -21833,7 +22525,7 @@ import {
   InMemorySessionRepo as InMemorySessionRepo2
 } from "@earendil-works/pi-agent-core";
 import { homedir as homedir6 } from "node:os";
-import { resolve as resolve4, isAbsolute as isAbsolute3 } from "path";
+import { resolve as resolve4, isAbsolute as isAbsolute4 } from "path";
 function getAssistantHistoryContent(exchange, isMostRecent) {
   return resolveAssistantHistoryContent(exchange, isMostRecent);
 }
@@ -22023,7 +22715,7 @@ var init_agent_executor = __esm({
           if (!model) {
             throw new Error("No model specified in execution context");
           }
-          const cwd = isAbsolute3(context.threadPath) ? context.threadPath : resolve4(getDataDir(), context.threadPath);
+          const cwd = isAbsolute4(context.threadPath) ? context.threadPath : resolve4(getDataDir(), context.threadPath);
           log52.info("Execution context", {
             model,
             cwd,
@@ -22241,6 +22933,11 @@ var init_agent_executor = __esm({
           });
           if (microcompactTransform) {
             harness.on("context", createHarnessContextHandler(microcompactTransform));
+          } else {
+            harness.on(
+              "context",
+              createHarnessContextHandler((messages) => deduplicateIdenticalTodoResults(messages))
+            );
           }
           harness.on("before_provider_payload", (event) => {
             recordPromptCacheFingerprint(
@@ -24967,8 +25664,23 @@ async function resolveSeatbeltSandboxEnabled(db) {
   }
   return true;
 }
-function buildAccountSettingsResponse(rawMaximumTurnCount, rawUseToolsThroughCode, rawVoiceAiProcessing, rawBetterStackLogging, rawFileLogging, rawShowDailySpend, rawSeatbeltSandboxEnabled, serverBindMode) {
+function isLoggingEnabled(rawLogging, rawFileLogging, rawBetterStackLogging) {
+  if (rawLogging !== null && rawLogging !== void 0) {
+    return rawLogging === true;
+  }
+  return rawFileLogging === true || rawBetterStackLogging === true;
+}
+async function applyLoggingEnabled(db, enabled) {
+  await setState(db, KEY_LOGGING, enabled);
+  await setState(db, KEY_FILE_LOGGING, enabled);
+  await setState(db, KEY_BETTERSTACK_LOGGING, enabled);
+  setFileLoggingEnabledByUser(enabled);
+  setBetterStackLoggingEnabledByUser(enabled);
+  syncRuntimeLogLevel(isCliDebugMode());
+}
+function buildAccountSettingsResponse(rawMaximumTurnCount, rawUseToolsThroughCode, rawVoiceAiProcessing, rawLogging, rawFileLogging, rawBetterStackLogging, rawShowDailySpend, rawSeatbeltSandboxEnabled, serverBindMode) {
   const betterStackEnvConfigured = isBetterStackEnvConfigured();
+  const loggingEnabled = isLoggingEnabled(rawLogging, rawFileLogging, rawBetterStackLogging);
   const seatbeltHealth = checkSeatbeltSandboxHealth();
   const seatbeltPreferenceEnabled = isSeatbeltSandboxPreferenceEnabled(rawSeatbeltSandboxEnabled);
   const seatbeltSandboxEnabled = seatbeltPreferenceEnabled && seatbeltHealth.healthy;
@@ -24981,11 +25693,12 @@ function buildAccountSettingsResponse(rawMaximumTurnCount, rawUseToolsThroughCod
     seatbeltSandboxSupported: seatbeltHealth.supported,
     seatbeltSandboxHealthy: seatbeltHealth.healthy,
     seatbeltSandboxMessage: seatbeltHealth.message,
-    betterStackLoggingEnabled: rawBetterStackLogging === true,
+    betterStackLoggingEnabled: loggingEnabled,
     betterStackEnvConfigured,
     betterStackIngestingHost: betterStackEnvConfigured ? getBetterStackIngestingHost() : null,
-    fileLoggingEnabled: rawFileLogging === true,
+    fileLoggingEnabled: loggingEnabled,
     fileLoggingPath: getFileLoggingPath(),
+    loggingEnabled,
     serverBindMode,
     networkAddresses: serverBindMode === "network" ? getLocalNetworkAddresses() : []
   };
@@ -25015,10 +25728,16 @@ async function getServerBindModeSetting() {
 }
 async function initializeLoggingSettings() {
   const db = await getDatabase();
+  const rawLogging = await getState(db, KEY_LOGGING);
   const rawBetterStackLogging = await getState(db, KEY_BETTERSTACK_LOGGING);
   const rawFileLogging = await getState(db, KEY_FILE_LOGGING);
-  setBetterStackLoggingEnabledByUser(rawBetterStackLogging === true);
-  setFileLoggingEnabledByUser(rawFileLogging === true);
+  const loggingEnabled = isLoggingEnabled(rawLogging, rawFileLogging, rawBetterStackLogging);
+  if (loggingEnabled && rawLogging !== true) {
+    await applyLoggingEnabled(db, true);
+    return;
+  }
+  setBetterStackLoggingEnabledByUser(loggingEnabled);
+  setFileLoggingEnabledByUser(loggingEnabled);
   syncRuntimeLogLevel(isCliDebugMode());
 }
 async function getAccountSettings(c) {
@@ -25028,6 +25747,7 @@ async function getAccountSettings(c) {
   const rawMaximumTurnCount = await getState(db, KEY_MAXIMUM_TURN_COUNT);
   const rawBetterStackLogging = await getState(db, KEY_BETTERSTACK_LOGGING);
   const rawFileLogging = await getState(db, KEY_FILE_LOGGING);
+  const rawLogging = await getState(db, KEY_LOGGING);
   const rawShowDailySpend = await getState(db, KEY_SHOW_DAILY_SPEND);
   let rawSeatbeltSandboxEnabled = await getState(db, KEY_SEATBELT_SANDBOX_ENABLED);
   const serverBindMode = await getServerBindModeSetting();
@@ -25040,8 +25760,9 @@ async function getAccountSettings(c) {
       rawMaximumTurnCount,
       rawUseToolsThroughCode,
       rawVoiceAiProcessing,
-      rawBetterStackLogging,
+      rawLogging,
       rawFileLogging,
+      rawBetterStackLogging,
       rawShowDailySpend,
       rawSeatbeltSandboxEnabled,
       serverBindMode
@@ -25078,15 +25799,9 @@ async function updateAccountSettings(c) {
     }
     await setState(db, KEY_SEATBELT_SANDBOX_ENABLED, body.seatbeltSandboxEnabled);
   }
-  if (typeof body.betterStackLoggingEnabled === "boolean") {
-    await setState(db, KEY_BETTERSTACK_LOGGING, body.betterStackLoggingEnabled);
-    setBetterStackLoggingEnabledByUser(body.betterStackLoggingEnabled);
-    syncRuntimeLogLevel(isCliDebugMode());
-  }
-  if (typeof body.fileLoggingEnabled === "boolean") {
-    await setState(db, KEY_FILE_LOGGING, body.fileLoggingEnabled);
-    setFileLoggingEnabledByUser(body.fileLoggingEnabled);
-    syncRuntimeLogLevel(isCliDebugMode());
+  const loggingEnabledUpdate = typeof body.loggingEnabled === "boolean" ? body.loggingEnabled : typeof body.fileLoggingEnabled === "boolean" ? body.fileLoggingEnabled : typeof body.betterStackLoggingEnabled === "boolean" ? body.betterStackLoggingEnabled : void 0;
+  if (typeof loggingEnabledUpdate === "boolean") {
+    await applyLoggingEnabled(db, loggingEnabledUpdate);
   }
   if (body.maximumTurnCount !== void 0) {
     await setState(db, KEY_MAXIMUM_TURN_COUNT, normalizeMaximumTurnCount(body.maximumTurnCount));
@@ -25099,6 +25814,7 @@ async function updateAccountSettings(c) {
   const rawMaximumTurnCount = await getState(db, KEY_MAXIMUM_TURN_COUNT);
   const rawBetterStackLogging = await getState(db, KEY_BETTERSTACK_LOGGING);
   const rawFileLogging = await getState(db, KEY_FILE_LOGGING);
+  const rawLogging = await getState(db, KEY_LOGGING);
   const rawShowDailySpend = await getState(db, KEY_SHOW_DAILY_SPEND);
   const rawSeatbeltSandboxEnabled = await getState(db, KEY_SEATBELT_SANDBOX_ENABLED);
   const serverBindMode = readServerBindMode();
@@ -25107,15 +25823,16 @@ async function updateAccountSettings(c) {
       rawMaximumTurnCount,
       rawUseToolsThroughCode,
       rawVoiceAiProcessing,
-      rawBetterStackLogging,
+      rawLogging,
       rawFileLogging,
+      rawBetterStackLogging,
       rawShowDailySpend,
       rawSeatbeltSandboxEnabled,
       serverBindMode
     )
   );
 }
-var DEFAULT_MAXIMUM_TURN_COUNT, KEY_MAXIMUM_TURN_COUNT, KEY_USE_TOOLS_THROUGH_CODE, KEY_VOICE_AI_PROCESSING, KEY_BETTERSTACK_LOGGING, KEY_FILE_LOGGING, KEY_SHOW_DAILY_SPEND, KEY_SEATBELT_SANDBOX_ENABLED, LEGACY_KEY_SERVER_BIND_MODE;
+var DEFAULT_MAXIMUM_TURN_COUNT, KEY_MAXIMUM_TURN_COUNT, KEY_USE_TOOLS_THROUGH_CODE, KEY_VOICE_AI_PROCESSING, KEY_BETTERSTACK_LOGGING, KEY_FILE_LOGGING, KEY_LOGGING, KEY_SHOW_DAILY_SPEND, KEY_SEATBELT_SANDBOX_ENABLED, LEGACY_KEY_SERVER_BIND_MODE;
 var init_account_settings_route = __esm({
   "src/features/account/account-settings.route.ts"() {
     "use strict";
@@ -25134,6 +25851,7 @@ var init_account_settings_route = __esm({
     KEY_VOICE_AI_PROCESSING = "VoiceAiProcessing";
     KEY_BETTERSTACK_LOGGING = "BetterStackLogging";
     KEY_FILE_LOGGING = "FileLogging";
+    KEY_LOGGING = "Logging";
     KEY_SHOW_DAILY_SPEND = "ShowDailySpend";
     KEY_SEATBELT_SANDBOX_ENABLED = "SeatbeltSandboxEnabled";
     LEGACY_KEY_SERVER_BIND_MODE = "ServerBindMode";
@@ -30421,7 +31139,7 @@ var init_ai_files_route_helpers = __esm({
 
 // src/features/projects/projects-ai-files.route.ts
 import { readdir as readdir6 } from "fs/promises";
-import { join as join28, extname as extname3, basename } from "path";
+import { join as join28, extname as extname3, basename as basename2 } from "path";
 import { existsSync as existsSync20 } from "fs";
 async function buildFullTree(dirPath, relativeDirPath) {
   const nodes = [];
@@ -30474,7 +31192,7 @@ async function buildMarkdownFilteredTree(dirPath, relativeDirPath) {
       } else if (entry.isFile() && MARKDOWN_EXTS.has(extname3(entry.name))) {
         nodes.push({
           id: entryRelPath,
-          name: basename(entry.name, extname3(entry.name)),
+          name: basename2(entry.name, extname3(entry.name)),
           type: "file",
           path: entryRelPath
         });
@@ -30533,7 +31251,7 @@ async function buildAIFileTree(projectPath) {
       if (entry.isFile() && MARKDOWN_EXTS.has(extname3(entry.name))) {
         nodes.push({
           id: entryRelPath,
-          name: basename(entry.name, extname3(entry.name)),
+          name: basename2(entry.name, extname3(entry.name)),
           type: "file",
           path: entryRelPath
         });
@@ -32344,7 +33062,7 @@ var init_random_words = __esm({
 
 // src/features/projects/projects.creator.ts
 import { randomUUID as randomUUID13 } from "crypto";
-import { basename as basename2, join as join30, relative as relative4, resolve as resolvePath2 } from "path";
+import { basename as basename3, join as join30, relative as relative4, resolve as resolvePath2 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
 import { access as access4, mkdir as mkdir5, rm as rm3, stat as stat4, readdir as readdir8 } from "fs/promises";
 async function loadUtils() {
@@ -32844,7 +33562,7 @@ var init_projects_creator = __esm({
         try {
           const existingNames = existingProjects.map((p) => p.name);
           const projectName = this.ensureUniqueProjectName(
-            basename2(normalizedPath) || "project",
+            basename3(normalizedPath) || "project",
             existingNames
           );
           yield {
@@ -34611,7 +35329,7 @@ var init_scaffold_routes = __esm({
 
 // src/features/slash-commands/slash-commands.manager.ts
 import { readdir as readdir9, readFile as readFile13, mkdir as mkdir6, writeFile as writeFile6, unlink as unlink4 } from "fs/promises";
-import { join as join33, basename as basename3, extname as extname4, relative as relative5 } from "path";
+import { join as join33, basename as basename4, extname as extname4, relative as relative5 } from "path";
 import { existsSync as existsSync22 } from "fs";
 import { homedir as homedir9 } from "os";
 function slugify(filename) {
@@ -34739,7 +35457,7 @@ var init_slash_commands_manager = __esm({
             const filePath = join33(dir, file);
             const fileContent = await readFile13(filePath, "utf-8");
             const { metadata, content } = parseFrontmatter2(fileContent);
-            const nameWithoutExt = basename3(file, extname4(file));
+            const nameWithoutExt = basename4(file, extname4(file));
             const commandName = slugify(nameWithoutExt);
             if (!commandName) continue;
             commands.push({
@@ -35440,7 +36158,7 @@ var init_rules_routes = __esm({
 });
 
 // src/features/threads/thread-folder-name.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 function normalizeThreadFolderName(input) {
   return input.trim().toLowerCase().replace(/[\\/]+/g, "-").replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 120);
 }
@@ -35470,7 +36188,7 @@ function deriveRepoSlugFromGitUrl(gitUrl) {
   if (segments.length === 1) {
     return normalizeThreadFolderName(segments[0]);
   }
-  return normalizeThreadFolderName(basename4(trimmed));
+  return normalizeThreadFolderName(basename5(trimmed));
 }
 var init_thread_folder_name = __esm({
   "src/features/threads/thread-folder-name.ts"() {
@@ -36214,7 +36932,7 @@ var init_project_scripts_database = __esm({
 // src/core/project-inspector.ts
 import { readFile as readFile14, readdir as readdir10 } from "fs/promises";
 import { existsSync as existsSync23 } from "fs";
-import { join as join35, basename as basename5, relative as relative6 } from "path";
+import { join as join35, basename as basename6, relative as relative6 } from "path";
 import { glob as glob2 } from "glob";
 async function inspectProject(projectPath, projectId) {
   const packageManager = await detectPackageManager2(projectPath);
@@ -36309,7 +37027,7 @@ async function collectWorkspacesFromGlobs(projectPath, patterns, options = {}) {
   for (const folder of folders) {
     const absPath = join35(projectPath, folder);
     if (!existsSync23(join35(absPath, "package.json"))) continue;
-    let name = basename5(folder);
+    let name = basename6(folder);
     if (options.preferPackageName) {
       const wsPkg = await readPackageJson(absPath);
       name = wsPkg?.name ?? name;
@@ -36752,7 +37470,7 @@ var init_threads_files_route = __esm({
 
 // src/features/threads/threads-explorer.route.ts
 import { readdir as readdir11, readFile as readFile15, rename as rename3, writeFile as writeFile7, mkdir as mkdir8, access as access5, open as open2, stat as stat6, rm as rm6 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join36, resolve as resolve5, basename as basename6 } from "path";
+import { isAbsolute as isAbsolute5, join as join36, resolve as resolve5, basename as basename7 } from "path";
 import { spawn as spawn2 } from "child_process";
 import openFilePath from "open";
 async function loadUtils2() {
@@ -37068,7 +37786,7 @@ async function handlePrintMarkdownExplorerFile(c, threadManager) {
     const exportDir = join36(thread.path, ".tarsk", "exports");
     await mkdir8(exportDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-    const safeBaseName = basename6(filePath, ".md").replace(/[^a-zA-Z0-9._-]+/g, "-") || "document";
+    const safeBaseName = basename7(filePath, ".md").replace(/[^a-zA-Z0-9._-]+/g, "-") || "document";
     const outputPath = join36(exportDir, `${safeBaseName}-${timestamp}.pdf`);
     await runMarkdownToPdf(absPath, outputPath);
     await openExportPath(outputPath);
@@ -37131,7 +37849,7 @@ async function handleCreateExplorerFile(c, threadManager) {
   }
 }
 function resolveExplorerMediaAbsolutePath(threadPath, filePath) {
-  if (isAbsolute4(filePath)) {
+  if (isAbsolute5(filePath)) {
     const normalized = resolve5(filePath);
     const dataDir = resolve5(getDataDir());
     if ((normalized === dataDir || normalized.startsWith(`${dataDir}/`)) && getExplorerFileMediaType(normalized)) {