tarsk 0.4.15 → 0.4.16

package/dist/index.js

@@ -99,18 +99,18 @@ __export(database_exports, {
   initializeSchema: () => initializeSchema
 });
 import { createClient } from "@libsql/client";
-import { join as join4 } from "path";
+import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import { mkdirSync } from "fs";
 function getDatabasePath() {
-  const appSupportDir = join4(homedir2(), "Library", "Application Support", "Tarsk");
-  const dataDir = join4(appSupportDir, "data");
-  return join4(dataDir, "tarsk.db");
+  const appSupportDir = join2(homedir2(), "Library", "Application Support", "Tarsk");
+  const dataDir = join2(appSupportDir, "data");
+  return join2(dataDir, "tarsk.db");
 }
 async function initializeDatabase() {
   const dbPath = getDatabasePath();
   try {
-    const dataDir = join4(homedir2(), "Library", "Application Support", "Tarsk", "data");
+    const dataDir = join2(homedir2(), "Library", "Application Support", "Tarsk", "data");
     mkdirSync(dataDir, { recursive: true });
     const db = createClient({
       url: `file:${dbPath}`
@@ -214,6 +214,46 @@ async function initializeSchema(db) {
         cachedAt TEXT NOT NULL
       )
     `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS code_files (
+        id INTEGER PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        content TEXT NOT NULL,
+        indexed_at TEXT NOT NULL,
+        UNIQUE(thread_id, file_path)
+      )
+    `);
+    await db.execute(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS code_index USING fts5(
+        content,
+        content='code_files',
+        content_rowid='id'
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS code_index_meta (
+        thread_id TEXT PRIMARY KEY,
+        indexed_at TEXT NOT NULL,
+        file_count INTEGER NOT NULL
+      )
+    `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS project_scripts (
+        id TEXT PRIMARY KEY,
+        projectId TEXT NOT NULL,
+        workspace TEXT NOT NULL,
+        name TEXT NOT NULL,
+        command TEXT NOT NULL,
+        friendlyName TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE,
+        UNIQUE(projectId, name)
+      )
+    `);
+    await db.execute(`
+      CREATE INDEX IF NOT EXISTS idx_project_scripts_projectId ON project_scripts(projectId)
+    `);
     await db.execute(`
       CREATE INDEX IF NOT EXISTS idx_threads_projectId ON threads(projectId)
     `);
@@ -558,6 +598,36 @@ async function runMigrations(db) {
         )
       `);
     }
+    const codeFilesExists = await db.execute(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name='code_files'`
+    );
+    if (codeFilesExists.rows.length === 0) {
+      console.log("[db] Running migration: Creating code search tables");
+      await db.execute(`
+        CREATE TABLE code_files (
+          id INTEGER PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          content TEXT NOT NULL,
+          indexed_at TEXT NOT NULL,
+          UNIQUE(thread_id, file_path)
+        )
+      `);
+      await db.execute(`
+        CREATE VIRTUAL TABLE code_index USING fts5(
+          content,
+          content='code_files',
+          content_rowid='id'
+        )
+      `);
+      await db.execute(`
+        CREATE TABLE code_index_meta (
+          thread_id TEXT PRIMARY KEY,
+          indexed_at TEXT NOT NULL,
+          file_count INTEGER NOT NULL
+        )
+      `);
+    }
     const projectsInfo = await db.execute(`PRAGMA table_info(projects)`);
     const hasPlanPrompt = projectsInfo.rows.some(
       (col) => col.name === "planPrompt"
@@ -568,6 +638,28 @@ async function runMigrations(db) {
       await db.execute(`ALTER TABLE projects ADD COLUMN testPrompt TEXT`);
       await db.execute(`ALTER TABLE projects ADD COLUMN reviewPrompt TEXT`);
     }
+    const projectScriptsExists = await db.execute(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name='project_scripts'`
+    );
+    if (projectScriptsExists.rows.length === 0) {
+      console.log("[db] Running migration: Creating project_scripts table");
+      await db.execute(`
+        CREATE TABLE project_scripts (
+          id TEXT PRIMARY KEY,
+          projectId TEXT NOT NULL,
+          workspace TEXT NOT NULL,
+          name TEXT NOT NULL,
+          command TEXT NOT NULL,
+          friendlyName TEXT NOT NULL,
+          updatedAt TEXT NOT NULL,
+          FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE,
+          UNIQUE(projectId, name)
+        )
+      `);
+      await db.execute(`
+        CREATE INDEX idx_project_scripts_projectId ON project_scripts(projectId)
+      `);
+    }
   } catch (error) {
     console.error("Failed to run migrations:", error);
     throw error;
@@ -676,8 +768,8 @@ import fs3 from "fs";
 import { Hono as Hono21 } from "hono";
 import { cors } from "hono/cors";
 import open3 from "open";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path4 from "path";
+import { fileURLToPath } from "url";
 
 // src/agent/agent.executor.ts
 import { Agent as Agent2 } from "@mariozechner/pi-agent-core";
@@ -1392,9 +1484,9 @@ var editSchema = Type2.Object({
   newText: Type2.String({ description: "New text to replace the old text with" })
 });
 var defaultEditOperations = {
-  readFile: (path7) => fsReadFile(path7),
-  writeFile: (path7, content) => fsWriteFile(path7, content, "utf-8"),
-  access: (path7) => fsAccess(path7, constants2.R_OK | constants2.W_OK)
+  readFile: (path6) => fsReadFile(path6),
+  writeFile: (path6, content) => fsWriteFile(path6, content, "utf-8"),
+  access: (path6) => fsAccess(path6, constants2.R_OK | constants2.W_OK)
 };
 function createEditTool(cwd, options) {
   const ops = options?.operations ?? defaultEditOperations;
@@ -1403,14 +1495,14 @@ function createEditTool(cwd, options) {
     label: "edit",
     description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
     parameters: editSchema,
-    execute: async (_toolCallId, { path: path7, oldText, newText }, signal) => {
-      const absolutePath = resolveToCwd(path7, cwd);
+    execute: async (_toolCallId, { path: path6, oldText, newText }, signal) => {
+      const absolutePath = resolveToCwd(path6, cwd);
       validatePathWithinCwd(absolutePath, cwd);
       return withAbortSignal(signal, async (isAborted) => {
         try {
           await ops.access(absolutePath);
         } catch {
-          throw new Error(`File not found: ${path7}`);
+          throw new Error(`File not found: ${path6}`);
         }
         if (isAborted()) return { content: [], details: void 0 };
         const buffer = await ops.readFile(absolutePath);
@@ -1424,7 +1516,7 @@ function createEditTool(cwd, options) {
         const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
         if (!matchResult.found) {
           throw new Error(
-            `Could not find the exact text in ${path7}. The old text must match exactly including all whitespace and newlines.`
+            `Could not find the exact text in ${path6}. The old text must match exactly including all whitespace and newlines.`
           );
         }
         const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
@@ -1432,7 +1524,7 @@ function createEditTool(cwd, options) {
         const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
         if (occurrences > 1) {
           throw new Error(
-            `Found ${occurrences} occurrences of the text in ${path7}. The text must be unique. Please provide more context to make it unique.`
+            `Found ${occurrences} occurrences of the text in ${path6}. The text must be unique. Please provide more context to make it unique.`
           );
         }
         if (isAborted()) return { content: [], details: void 0 };
@@ -1440,7 +1532,7 @@ function createEditTool(cwd, options) {
         const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
         if (baseContent === newContent) {
           throw new Error(
-            `No changes made to ${path7}. The replacement produced identical content.`
+            `No changes made to ${path6}. The replacement produced identical content.`
           );
         }
         const finalContent = bom + restoreLineEndings(newContent, originalEnding);
@@ -1448,7 +1540,7 @@ function createEditTool(cwd, options) {
         if (isAborted()) return { content: [], details: void 0 };
         const diffResult = generateDiffString(baseContent, newContent);
         return {
-          content: [{ type: "text", text: `Successfully replaced text in ${path7}.` }],
+          content: [{ type: "text", text: `Successfully replaced text in ${path6}.` }],
           details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
         };
       });
@@ -1475,13 +1567,13 @@ var findSchema = Type3.Object({
 var DEFAULT_LIMIT = 1e3;
 var defaultFindOperations = {
   exists: existsSync3,
-  glob: async (pattern, searchCwd, { ignore, limit }) => {
+  glob: async (pattern, searchCwd, { ignore: ignore2, limit }) => {
     const results = [];
     try {
       const found = globSync(pattern, {
         cwd: searchCwd,
         dot: true,
-        ignore: ["**/node_modules/**", "**/.git/**", ...ignore],
+        ignore: ["**/node_modules/**", "**/.git/**", ...ignore2],
         mark: false
       });
       for (let i = 0; i < Math.min(found.length, limit); i++) {
@@ -1677,9 +1769,9 @@ function createGrepTool(cwd, options) {
             const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2);
             const formatPath = (filePath) => {
               if (isDirectory) {
-                const relative6 = path2.relative(searchPath, filePath);
-                if (relative6 && !relative6.startsWith("..")) {
-                  return relative6.replace(/\\/g, "/");
+                const relative7 = path2.relative(searchPath, filePath);
+                if (relative7 && !relative7.startsWith("..")) {
+                  return relative7.replace(/\\/g, "/");
                 }
               }
               return path2.basename(filePath);
@@ -1843,287 +1935,625 @@ function createGrepTool(cwd, options) {
 }
 var grepTool = createGrepTool(process.cwd());
 
-// src/tools/ast-grep.ts
-init_utils();
+// src/tools/code-search.ts
+init_database();
 import { Type as Type5 } from "@sinclair/typebox";
-import path3 from "path";
-import { existsSync as existsSync4, readdirSync } from "fs";
-import { fileURLToPath } from "url";
-var astGrepSchema = Type5.Object({
-  command: Type5.Union([Type5.Literal("run"), Type5.Literal("scan")], {
-    description: "Mode: 'run' for simple pattern search, 'scan' for complex rule-based search"
-  }),
+
+// src/tools/code-search-indexer.ts
+init_database();
+import { readFileSync as readFileSync2 } from "fs";
+import { readFile, opendir } from "fs/promises";
+import { join as join3, relative as relative2, extname } from "path";
+import ignore from "ignore";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "coverage",
+  "__pycache__",
+  "target",
+  "vendor",
+  ".gradle",
+  "Pods",
+  ".cache",
+  ".tox"
+]);
+var SKIP_FILENAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "bun.lock",
+  "yarn.lock",
+  "Cargo.lock",
+  "poetry.lock",
+  "Gemfile.lock",
+  "pnpm-lock.yaml",
+  "composer.lock"
+]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".php",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".sql",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".json",
+  ".xml",
+  ".html",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less"
+]);
+var MAX_FILE_SIZE = 512 * 1024;
+var BATCH_SIZE = 50;
+function readGitignore(dirPath) {
+  const ig = ignore();
+  try {
+    const content = readFileSync2(join3(dirPath, ".gitignore"), "utf8");
+    ig.add(content);
+  } catch {
+  }
+  return ig;
+}
+async function collectFiles(rootPath, signal) {
+  const results = [];
+  const ignoreStack = [
+    { prefix: "", ig: readGitignore(rootPath) }
+  ];
+  async function walk(dirPath) {
+    if (signal?.aborted) return;
+    const dirHandle = await opendir(dirPath, {}).catch(() => null);
+    if (!dirHandle) return;
+    const relDir = relative2(rootPath, dirPath);
+    let pushedIgnore = false;
+    if (relDir) {
+      const ig = readGitignore(dirPath);
+      ignoreStack.push({ prefix: relDir, ig });
+      pushedIgnore = true;
+    }
+    function isIgnored(relPath) {
+      for (const { prefix, ig } of ignoreStack) {
+        const testPath = prefix ? relPath.slice(prefix.length + 1) : relPath;
+        if (testPath && ig.ignores(testPath)) return true;
+      }
+      return false;
+    }
+    for await (const entry of dirHandle) {
+      if (signal?.aborted) break;
+      const entryPath = join3(dirPath, entry.name);
+      const relPath = relative2(rootPath, entryPath);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (isIgnored(relPath)) continue;
+        await walk(entryPath);
+      } else if (entry.isFile()) {
+        if (SKIP_FILENAMES.has(entry.name)) continue;
+        if (!TEXT_EXTENSIONS.has(extname(entry.name))) continue;
+        if (isIgnored(relPath)) continue;
+        results.push(entryPath);
+      }
+    }
+    if (pushedIgnore) ignoreStack.pop();
+  }
+  await walk(rootPath);
+  return results;
+}
+async function ensureThreadIndex(db, threadId, threadPath, signal) {
+  const meta = await db.execute("SELECT thread_id FROM code_index_meta WHERE thread_id = ?", [
+    threadId
+  ]);
+  if (meta.rows.length > 0) return;
+  console.log(`[code-search] indexing ${threadId}: scanning files...`);
+  const start = Date.now();
+  const files = await collectFiles(threadPath, signal);
+  if (signal?.aborted) return;
+  let fileCount = 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let i = 0;
+  while (i < files.length) {
+    if (signal?.aborted) return;
+    const chunk = files.slice(i, i + BATCH_SIZE);
+    const rows = [];
+    for (const filePath of chunk) {
+      let content;
+      try {
+        const buf = await readFile(filePath);
+        if (buf.length > MAX_FILE_SIZE) continue;
+        content = buf.toString("utf8");
+        if (content.includes("\0")) continue;
+      } catch {
+        continue;
+      }
+      const relPath = relative2(threadPath, filePath);
+      rows.push({
+        sql: "INSERT OR REPLACE INTO code_files (thread_id, file_path, content, indexed_at) VALUES (?, ?, ?, ?)",
+        args: [threadId, relPath, content, now]
+      });
+      fileCount++;
+    }
+    if (rows.length > 0) {
+      await db.batch(rows);
+    }
+    i += BATCH_SIZE;
+  }
+  await db.execute("INSERT INTO code_index(code_index) VALUES('rebuild')");
+  await db.execute(
+    "INSERT OR REPLACE INTO code_index_meta (thread_id, indexed_at, file_count) VALUES (?, ?, ?)",
+    [threadId, now, fileCount]
+  );
+  console.log(`[code-search] indexed ${fileCount} files in ${Date.now() - start}ms`);
+}
+async function clearThreadIndex(db, threadId) {
+  await db.execute(
+    "DELETE FROM code_index WHERE rowid IN (SELECT id FROM code_files WHERE thread_id = ?)",
+    [threadId]
+  );
+  await db.execute("DELETE FROM code_files WHERE thread_id = ?", [threadId]);
+  await db.execute("DELETE FROM code_index_meta WHERE thread_id = ?", [threadId]);
+}
+async function invalidateThreadIndex(threadId) {
+  const db = await getDatabase();
+  await clearThreadIndex(db, threadId);
+}
+
+// src/tools/code-search.ts
+var DEFAULT_LIMIT3 = 100;
+var codeSearchSchema = Type5.Object({
+  query: Type5.Optional(
+    Type5.String({
+      description: 'FTS5 full-text search on plain identifier/word tokens (e.g. "validateEmail", "email validation"). Multi-word queries use proximity matching automatically. Supports "quoted phrases", prefix*, and boolean operators (A OR B, A NOT B). Special characters (backslashes, brackets, dots) are stripped \u2014 do NOT put regex patterns here. For regex use `pattern`.'
+    })
+  ),
   pattern: Type5.Optional(
     Type5.String({
-      description: "AST pattern for 'run' command. Use metavariables like $NAME, $$$ARGS. Example: 'console.log($ARG)'"
+      description: "JavaScript regex for searching file content, e.g. 'function\\s+\\w+\\s*\\(' or 'class\\s+\\w+Service'. Works standalone (scans all indexed files) or combined with `query` to pre-filter by FTS first. By default matched line by line; set `multiline: true` for cross-line patterns. Case-insensitive unless the pattern contains uppercase letters."
     })
   ),
-  lang: Type5.String({
-    description: "Language to parse: javascript, typescript, python, rust, go, java, css, html, etc."
-  }),
-  rule: Type5.Optional(
+  filePath: Type5.Optional(
     Type5.String({
-      description: "YAML rule for 'scan' command. Supports kind, has, inside, all, any, not. Example: 'id: test\\nlanguage: javascript\\nrule:\\n  kind: function_declaration\\n  has:\\n    pattern: await $EXPR\\n    stopBy: end'"
+      description: "Search by file path pattern, e.g. 'camp.page.ts', 'src/app/camp', or 'src/**/camp/*.ts'. Supports glob wildcards (* and **). Returns all lines from matching files."
     })
   ),
-  path: Type5.Optional(
+  fileGlob: Type5.Optional(
     Type5.String({
-      description: "Directory or file to search (default: current directory)"
+      description: "Restrict FTS/regex results to files matching this glob, e.g. '*.ts', '**/camp/*.ts'. Applied before the result limit."
     })
   ),
   limit: Type5.Optional(
     Type5.Number({
-      description: "Maximum number of matches to return (default: 50)"
+      description: `Maximum number of file matches to return (default: ${DEFAULT_LIMIT3})`
+    })
+  ),
+  offset: Type5.Optional(
+    Type5.Number({
+      description: "Number of file matches to skip for pagination (default: 0). Use with `limit` to page through results when the match limit or output size is reached."
+    })
+  ),
+  multiline: Type5.Optional(
+    Type5.Boolean({
+      description: "When true, apply `pattern` to the full file content rather than line by line, so patterns can span multiple lines. Use `[\\s\\S]` instead of `.` to match newlines within the pattern (e.g. '@Component\\({[\\s\\S]*?templateUrl:' or 'templateUrl:[\\s\\S]*?styleUrl:'). Has no effect without `pattern`."
     })
   )
 });
-var DEFAULT_LIMIT3 = 50;
-var PLATFORM_PACKAGES = {
-  "darwin-arm64": "@ast-grep/cli-darwin-arm64",
-  "darwin-x64": "@ast-grep/cli-darwin-x64",
-  "linux-arm64": "@ast-grep/cli-linux-arm64-gnu",
-  "linux-x64": "@ast-grep/cli-linux-x64-gnu",
-  "win32-arm64": "@ast-grep/cli-win32-arm64-msvc",
-  "win32-ia32": "@ast-grep/cli-win32-ia32-msvc",
-  "win32-x64": "@ast-grep/cli-win32-x64-msvc"
-};
-function findBinInNodeModules(startDir, pkg, binName) {
-  const pkgPath = pkg.replace("/", path3.sep);
-  let dir = startDir;
-  while (true) {
-    const nmDir = path3.join(dir, "node_modules");
-    const standardPath = path3.join(nmDir, pkgPath, binName);
-    if (existsSync4(standardPath)) return standardPath;
-    const bunDir = path3.join(nmDir, ".bun");
-    if (existsSync4(bunDir)) {
-      const bunPrefix = pkg.replace("/", "+");
-      try {
-        const entries = readdirSync(bunDir);
-        const match = entries.find((e) => e.startsWith(bunPrefix + "@"));
-        if (match) {
-          const bunPath = path3.join(bunDir, match, "node_modules", pkgPath, binName);
-          if (existsSync4(bunPath)) return bunPath;
-        }
-      } catch {
+function globToLike(glob3) {
+  return glob3.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_").replace(/\*\*/g, "%").replace(/\*/g, "%").replace(/\?/g, "_");
+}
+function filePathToLike(filePath) {
+  if (filePath.includes("*") || filePath.includes("?")) {
+    return globToLike(filePath);
+  }
+  return `%${filePath.replace(/%/g, "\\%").replace(/_/g, "\\_")}%`;
+}
+function sanitizeQuery(raw) {
+  const parts = [];
+  const phraseRe = /"[^"]*"/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = phraseRe.exec(raw)) !== null) {
+    const before = raw.slice(lastIndex, match.index).trim();
+    if (before) parts.push(cleanTokens(before));
+    parts.push(match[0]);
+    lastIndex = match.index + match[0].length;
+  }
+  const remaining = raw.slice(lastIndex).trim();
+  if (remaining) parts.push(cleanTokens(remaining));
+  return parts.filter(Boolean).join(" ").trim();
+}
+function cleanTokens(text) {
+  return text.split(/\s+/).map((token) => {
+    if (/^(AND|OR|NOT)$/i.test(token)) return token;
+    const hasTrailingStar = token.endsWith("*");
+    const cleaned = token.replace(/[^a-zA-Z0-9_]/g, " ").trim();
+    const tokens = cleaned.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) return "";
+    if (hasTrailingStar) tokens[tokens.length - 1] += "*";
+    return tokens.join(" ");
+  }).filter(Boolean).join(" ");
+}
+function buildNearQuery(sanitized) {
+  if (/["()|]|^\s*(AND|OR|NOT)\s/i.test(sanitized)) return null;
+  let tokens = sanitized.split(/\s+/).filter((t) => !/^(AND|OR|NOT)$/i.test(t) && t.length > 0);
+  if (tokens.length < 2) return null;
+  if (tokens.length > 5) {
+    tokens = [...tokens].sort((a, b) => b.length - a.length).slice(0, 5);
+  }
+  const nearDistance = Math.max(10, tokens.length * 10);
+  return `NEAR(${tokens.join(" ")}, ${nearDistance})`;
+}
+function buildOrQuery(sanitized) {
+  if (/["()|]|^\s*(AND|OR|NOT)\s/i.test(sanitized)) return null;
+  const tokens = sanitized.split(/\s+/).filter((t) => !/^(AND|OR|NOT)$/i.test(t) && t.length > 0);
+  if (tokens.length < 2) return null;
+  return tokens.join(" OR ");
+}
+function extractTokens(query) {
+  return query.replace(/["()*]/g, " ").split(/\s+/).map(
+    (t) => t.replace(/^(AND|OR|NOT)$/i, "").replace(/[^a-zA-Z0-9_]/g, "").trim()
+  ).filter(Boolean).map((t) => t.toLowerCase());
+}
+function findLinesByTokens(content, tokens) {
+  if (tokens.length === 0) return [];
+  const lines = content.split("\n");
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lower = lines[i].toLowerCase();
+    if (tokens.some((t) => lower.includes(t))) {
+      results.push({ line: i + 1, text: lines[i] });
+    }
+  }
+  return results;
+}
+function findLinesByRegex(content, re, multiline = false) {
+  const lines = content.split("\n");
+  if (!multiline) {
+    const results = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        results.push({ line: i + 1, text: lines[i] });
       }
     }
-    const parent = path3.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
+    return results;
   }
-  return null;
+  const lineStarts = Array.from({ length: lines.length }).fill(0);
+  let pos = 0;
+  for (let i = 0; i < lines.length; i++) {
+    lineStarts[i] = pos;
+    pos += lines[i].length + 1;
+  }
+  let flags = re.flags;
+  if (!flags.includes("g")) flags += "g";
+  const fullRe = new RegExp(re.source, flags);
+  const matchedLines = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = fullRe.exec(content)) !== null) {
+    const matchStart = match.index;
+    const matchEnd = matchStart + match[0].length;
+    for (let i = 0; i < lines.length; i++) {
+      const lineStart = lineStarts[i];
+      const lineEnd = lineStart + lines[i].length;
+      if (lineStart <= matchEnd && lineEnd >= matchStart) {
+        matchedLines.add(i);
+      }
+      if (lineStart > matchEnd) break;
+    }
+    if (match[0].length === 0) fullRe.lastIndex++;
+  }
+  return Array.from(matchedLines).sort((a, b) => a - b).map((i) => ({ line: i + 1, text: lines[i] }));
+}
+function formatOutput(rows, tokens, regex, limit, multiline = false) {
+  const outputLines = [];
+  let linesTruncated = false;
+  const matchLimitReached = rows.length >= limit ? rows.length : void 0;
+  for (const { file_path, content } of rows) {
+    const matchingLines = regex ? findLinesByRegex(content, regex, multiline) : findLinesByTokens(content, tokens);
+    for (const { line, text } of matchingLines) {
+      const { text: truncated, wasTruncated } = truncateLine(text.replace(/\r/g, ""));
+      if (wasTruncated) linesTruncated = true;
+      outputLines.push(`${file_path}:${line}: ${truncated}`);
+    }
+  }
+  return { outputLines, linesTruncated, matchLimitReached };
+}
+function buildResult(outputLines, linesTruncated, matchLimitReached, limit, offset) {
+  if (outputLines.length === 0) {
+    const text2 = offset > 0 ? `No matches found at offset ${offset}` : "No matches found";
+    return { content: [{ type: "text", text: text2 }], details: void 0 };
+  }
+  const rawOutput = outputLines.join("\n");
+  const truncation = truncateHead(rawOutput, { maxBytes: DEFAULT_MAX_BYTES });
+  const finalOutput = truncation.content;
+  const nextOffset = offset + limit;
+  const notices = [];
+  if (matchLimitReached) {
+    notices.push(
+      `Note: result limit of ${limit} files reached \u2014 use offset=${nextOffset} to get the next page, or use a more specific query`
+    );
+  }
+  if (linesTruncated) {
+    notices.push(`Note: some lines were truncated at ${GREP_MAX_LINE_LENGTH} characters`);
+  }
+  if (truncation.truncated) {
+    notices.push(
+      `Note: output truncated at ${formatSize(DEFAULT_MAX_BYTES)} \u2014 use offset=${nextOffset} to get the next page`
+    );
+  }
+  const text = notices.length > 0 ? `${finalOutput}
+
+${notices.join("\n")}` : finalOutput;
+  return {
+    content: [{ type: "text", text }],
+    details: { truncation, matchLimitReached, linesTruncated, offset }
+  };
 }
-var APP_DIR = path3.resolve(fileURLToPath(import.meta.url), "../../..");
-function resolveAstGrepBin(cwd) {
-  const key = `${process.platform}-${process.arch}`;
-  const pkg = PLATFORM_PACKAGES[key];
-  if (!pkg) return null;
-  const binName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-  console.log(`[ast-grep] resolving binary: platform=${key}, pkg=${pkg}, APP_DIR=${APP_DIR}`);
-  const appResult = findBinInNodeModules(APP_DIR, pkg, binName);
-  if (appResult) return appResult;
-  return findBinInNodeModules(cwd, pkg, binName);
-}
-function createAstGrepTool(cwd) {
+function createCodeSearchTool(cwd, threadId) {
   return {
-    name: "ast_grep",
+    name: "code_search",
     label: "Code Search",
-    description: `Structural code search using AST patterns. Matches code by structure, not text. Use 'run' for simple pattern matching (e.g. 'console.log($ARG)') or 'scan' for complex YAML rules with kind/has/inside/all/any/not. Output truncated to ${DEFAULT_LIMIT3} matches or ${DEFAULT_MAX_BYTES / 1024}KB.`,
-    parameters: astGrepSchema,
-    execute: async (_toolCallId, { command, pattern, lang, rule, path: searchDir, limit }, signal) => {
-      return new Promise((resolve6, reject) => {
-        if (signal?.aborted) {
-          reject(new Error("Operation aborted"));
-          return;
-        }
-        let settled = false;
-        const settle = (fn) => {
-          if (!settled) {
-            settled = true;
-            fn();
-          }
+    description: 'Search the codebase with FTS5 (BM25 ranking) + optional regex. Use `query` for token/semantic search \u2014 multi-word queries automatically use proximity matching. Use `pattern` for regex (e.g. "function\\s+\\w+"). Use `filePath` to find files by name/path (supports globs). Use `fileGlob` to restrict results to a directory.',
+    parameters: codeSearchSchema,
+    execute: async (_toolCallId, inputs, signal) => {
+      const {
+        query,
+        pattern,
+        filePath,
+        fileGlob,
+        limit = DEFAULT_LIMIT3,
+        offset = 0,
+        multiline = false
+      } = inputs;
+      if (!threadId) {
+        return {
+          content: [
+            { type: "text", text: "code_search: no threadId \u2014 cannot search index" }
+          ],
+          details: void 0
         };
-        void (async () => {
-          try {
-            if (command === "run" && !pattern) {
-              settle(() => reject(new Error("'pattern' is required when command is 'run'")));
-              return;
-            }
-            if (command === "scan" && !rule) {
-              settle(() => reject(new Error("'rule' is required when command is 'scan'")));
-              return;
+      }
+      if (!query && !pattern && !filePath) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Provide at least one of: `query`, `pattern`, or `filePath`"
             }
-            const searchPath = resolveToCwd(searchDir ?? ".", cwd);
-            validatePathWithinCwd(searchPath, cwd);
-            const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT3);
-            const args2 = [];
-            if (command === "run") {
-              args2.push("run", "--pattern", pattern, "--lang", lang, "--json", searchPath);
-            } else {
-              args2.push("scan", "--inline-rules", rule, "--json", searchPath);
+          ],
+          details: void 0
+        };
+      }
+      const REGEX_IN_QUERY = /\\[swdWSDbBAZ]|[[\]{}]|\(\?/;
+      if (query && !pattern && REGEX_IN_QUERY.test(query)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `The \`query\` field received what looks like a regex pattern ("${query}"). \`query\` is for plain token/FTS search only \u2014 backslashes and special characters are stripped, so the regex will not work. Move the pattern to the \`pattern\` field instead (and omit \`query\`).`
             }
-            const binPath = resolveAstGrepBin(cwd);
-            if (!binPath) {
-              settle(
-                () => reject(
-                  new Error("ast-grep is not available. Install @ast-grep/cli or add it to PATH.")
-                )
-              );
-              return;
+          ],
+          details: void 0
+        };
+      }
+      let compiledRegex = null;
+      if (pattern) {
+        try {
+          const flags = pattern === pattern.toLowerCase() ? "i" : "";
+          compiledRegex = new RegExp(pattern, flags);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Invalid regex pattern: ${msg}` }],
+            details: void 0
+          };
+        }
+      }
+      const db = await getDatabase();
+      await ensureThreadIndex(db, threadId, cwd, signal);
+      if (signal?.aborted) {
+        return {
+          content: [{ type: "text", text: "Operation aborted" }],
+          details: void 0
+        };
+      }
+      const likeFilter = fileGlob ? globToLike(fileGlob) : null;
+      if (filePath && !query && !pattern) {
+        const likePattern = filePathToLike(filePath);
+        const result = await db.execute(
+          `SELECT file_path, content FROM code_files
+           WHERE thread_id = ?
+           AND file_path LIKE ? ESCAPE '\\'
+           LIMIT ? OFFSET ?`,
+          [threadId, likePattern, limit, offset]
+        );
+        const rows2 = result.rows;
+        const { outputLines: outputLines2, linesTruncated: linesTruncated2, matchLimitReached: matchLimitReached2 } = formatOutput(
+          rows2,
+          [],
+          null,
+          limit
+        );
+        if (outputLines2.length === 0) {
+          const names = rows2.map((r) => r.file_path).join("\n");
+          return buildResult(names ? names.split("\n") : [], false, void 0, limit, offset);
+        }
+        return buildResult(outputLines2, linesTruncated2, matchLimitReached2, limit, offset);
+      }
+      if (filePath && (query || pattern)) {
+        const likePattern = filePathToLike(filePath);
+        const result = await db.execute(
+          `SELECT file_path, content FROM code_files
+           WHERE thread_id = ?
+           AND file_path LIKE ? ESCAPE '\\'
+           LIMIT ? OFFSET ?`,
+          [threadId, likePattern, limit, offset]
+        );
+        const rows2 = result.rows;
+        const tokens2 = query ? extractTokens(query) : [];
+        const { outputLines: outputLines2, linesTruncated: linesTruncated2, matchLimitReached: matchLimitReached2 } = formatOutput(
+          rows2,
+          tokens2,
+          compiledRegex,
+          limit,
+          multiline
+        );
+        return buildResult(outputLines2, linesTruncated2, matchLimitReached2, limit, offset);
+      }
+      if (pattern && !query) {
+        const sql = likeFilter ? `SELECT file_path, content FROM code_files
+             WHERE thread_id = ?
+             AND file_path LIKE ? ESCAPE '\\'` : `SELECT file_path, content FROM code_files
+             WHERE thread_id = ?`;
+        const args2 = likeFilter ? [threadId, likeFilter] : [threadId];
+        const result = await db.execute(sql, args2);
+        const allRows = result.rows;
+        const outputLines2 = [];
+        let linesTruncated2 = false;
+        let matchedFiles = 0;
+        for (const { file_path, content } of allRows) {
+          const matchingLines = findLinesByRegex(content, compiledRegex, multiline);
+          if (matchingLines.length === 0) continue;
+          matchedFiles++;
+          if (matchedFiles <= offset) continue;
+          if (matchedFiles > offset + limit) break;
+          for (const { line, text } of matchingLines) {
+            const { text: truncated, wasTruncated } = truncateLine(text.replace(/\r/g, ""));
+            if (wasTruncated) linesTruncated2 = true;
+            outputLines2.push(`${file_path}:${line}: ${truncated}`);
+          }
+        }
+        const matchLimitReached2 = matchedFiles > offset + limit ? matchedFiles : void 0;
+        return buildResult(outputLines2, linesTruncated2, matchLimitReached2, limit, offset);
+      }
+      const rawQuery = query;
+      async function runFtsQuery(ftsQuery) {
+        const sql = likeFilter ? `SELECT cf.file_path, cf.content
+             FROM code_index
+             JOIN code_files cf ON cf.id = code_index.rowid
+             WHERE code_index MATCH ?
+             AND cf.thread_id = ?
+             AND cf.file_path LIKE ? ESCAPE '\\'
+             ORDER BY rank
+             LIMIT ? OFFSET ?` : `SELECT cf.file_path, cf.content
+             FROM code_index
+             JOIN code_files cf ON cf.id = code_index.rowid
+             WHERE code_index MATCH ?
+             AND cf.thread_id = ?
+             ORDER BY rank
+             LIMIT ? OFFSET ?`;
+        const args2 = likeFilter ? [ftsQuery, threadId, likeFilter, limit, offset] : [ftsQuery, threadId, limit, offset];
+        const result = await db.execute(sql, args2);
+        return result.rows;
+      }
+      let rows;
+      let effectiveQuery = rawQuery;
+      try {
+        const sanitized = sanitizeQuery(rawQuery);
+        const nearQuery = buildNearQuery(sanitized);
+        if (nearQuery) {
+          try {
+            rows = await runFtsQuery(nearQuery);
+            effectiveQuery = nearQuery;
+            if (rows.length === 0) {
+              rows = await runFtsQuery(sanitized);
+              effectiveQuery = sanitized;
             }
-            console.log(`[ast-grep] ${binPath} ${args2.join(" ")}`);
-            const child = spawnProcess(binPath, args2, {
-              stdio: ["ignore", "pipe", "pipe"]
-            });
-            const MAX_STDOUT_BYTES = 2 * 1024 * 1024;
-            let stdout = "";
-            let stdoutBytes = 0;
-            let stderr = "";
-            let aborted = false;
-            let killedDueToCap = false;
-            const onAbort = () => {
-              aborted = true;
-              if (!child.killed) child.kill();
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
-            child.stdout?.on("data", (chunk) => {
-              if (killedDueToCap) return;
-              stdoutBytes += chunk.length;
-              if (stdoutBytes > MAX_STDOUT_BYTES) {
-                killedDueToCap = true;
-                if (!child.killed) child.kill();
-                return;
-              }
-              stdout += chunk.toString();
-            });
-            child.stderr?.on("data", (chunk) => {
-              stderr += chunk.toString();
-            });
-            child.on("error", (error) => {
-              signal?.removeEventListener("abort", onAbort);
-              settle(() => reject(new Error(`Failed to run ast-grep: ${error.message}`)));
-            });
-            child.on("close", (code) => {
-              signal?.removeEventListener("abort", onAbort);
-              console.log(
-                `[ast-grep] exit code: ${code}, stdout: ${stdout.length} bytes, stderr: ${stderr.length} bytes`
-              );
-              if (stderr.trim()) console.log(`[ast-grep] stderr: ${stderr.trim()}`);
-              if (aborted) {
-                settle(() => reject(new Error("Operation aborted")));
-                return;
-              }
-              if (!killedDueToCap && code !== 0 && code !== 1) {
-                const errMsg = stderr.trim() || `ast-grep exited with code ${code}`;
-                settle(() => reject(new Error(errMsg)));
-                return;
-              }
-              let matches;
-              try {
-                matches = JSON.parse(stdout || "[]");
-              } catch {
-                if (killedDueToCap) {
-                  const lastBrace = stdout.lastIndexOf("}");
-                  if (lastBrace > 0) {
-                    try {
-                      matches = JSON.parse(stdout.slice(0, lastBrace + 1) + "]");
-                    } catch {
-                      matches = [];
-                    }
-                  } else {
-                    matches = [];
-                  }
-                } else if (!stdout.trim()) {
-                  settle(
-                    () => resolve6({
-                      content: [{ type: "text", text: "No matches found" }],
-                      details: void 0
-                    })
-                  );
-                  return;
-                } else {
-                  settle(
-                    () => reject(
-                      new Error(`Failed to parse ast-grep JSON output: ${stdout.slice(0, 200)}`)
-                    )
-                  );
-                  return;
-                }
-              }
-              if (!Array.isArray(matches) || matches.length === 0) {
-                settle(
-                  () => resolve6({
-                    content: [{ type: "text", text: "No matches found" }],
-                    details: void 0
-                  })
-                );
-                return;
-              }
-              const matchLimitReached = matches.length > effectiveLimit;
-              if (matchLimitReached) {
-                matches = matches.slice(0, effectiveLimit);
-              }
-              let linesTruncated = false;
-              const outputLines = [];
-              for (const match of matches) {
-                const filePath = match.file ?? "unknown";
-                const relativePath = path3.relative(searchPath, filePath).replace(/\\/g, "/") || filePath;
-                const lineNum = (match.range?.start?.line ?? 0) + 1;
-                const matchText = (match.lines ?? match.text ?? "").trimEnd();
-                const firstLine = matchText.split("\n")[0] ?? "";
-                const { text: truncatedText, wasTruncated } = truncateLine(firstLine);
-                if (wasTruncated) linesTruncated = true;
-                outputLines.push(`${relativePath}:${lineNum}: ${truncatedText}`);
-              }
-              const rawOutput = outputLines.join("\n");
-              const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-              let output = truncation.content;
-              const details = {};
-              const notices = [];
-              if (killedDueToCap) {
-                notices.push(
-                  `Output exceeded 2MB cap. Refine your pattern for more precise results`
-                );
-              }
-              if (matchLimitReached) {
-                notices.push(
-                  `${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`
-                );
-                details.matchLimitReached = effectiveLimit;
+            if (rows.length === 0) {
+              const orQuery = buildOrQuery(sanitized);
+              if (orQuery) {
+                rows = await runFtsQuery(orQuery);
+                effectiveQuery = orQuery;
               }
-              if (truncation.truncated) {
-                notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-                details.truncation = truncation;
-              }
-              if (linesTruncated) {
-                notices.push(
-                  `Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`
-                );
-                details.linesTruncated = true;
-              }
-              if (notices.length > 0) output += `
-
-[${notices.join(". ")}]`;
-              settle(
-                () => resolve6({
-                  content: [{ type: "text", text: output }],
-                  details: Object.keys(details).length > 0 ? details : void 0
-                })
-              );
-            });
+            }
           } catch {
-            settle(() => reject(new Error("Error processing ast-grep request")));
+            rows = await runFtsQuery(sanitized);
+            effectiveQuery = sanitized;
           }
-        })();
-      });
+        } else {
+          rows = await runFtsQuery(rawQuery);
+        }
+      } catch {
+        effectiveQuery = sanitizeQuery(rawQuery);
+        if (!effectiveQuery) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Query "${rawQuery}" contains only special characters \u2014 no searchable tokens remain. Try using filePath or pattern instead.`
+              }
+            ],
+            details: void 0
+          };
+        }
+        try {
+          rows = await runFtsQuery(effectiveQuery);
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `FTS query error even after sanitization.
+Original: "${rawQuery}"
+Sanitized: "${effectiveQuery}"
+
+Details: ${msg}`
+              }
+            ],
+            details: void 0
+          };
+        }
+      }
+      if (rows.length === 0) {
+        return {
+          content: [{ type: "text", text: "No matches found" }],
+          details: void 0
+        };
+      }
+      const tokens = compiledRegex ? [] : extractTokens(effectiveQuery);
+      const { outputLines, linesTruncated, matchLimitReached } = formatOutput(
+        rows,
+        tokens,
+        compiledRegex,
+        limit,
+        multiline
+      );
+      return buildResult(outputLines, linesTruncated, matchLimitReached, limit, offset);
     }
   };
 }
-var astGrepTool = createAstGrepTool(process.cwd());
+var codeSearchTool = createCodeSearchTool(
+  process.cwd(),
+  ""
+);
 
 // src/tools/ls.ts
 import { Type as Type6 } from "@sinclair/typebox";
-import { existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync, statSync as statSync2 } from "fs";
 import nodePath from "path";
 var lsSchema = Type6.Object({
   path: Type6.Optional(
@@ -2135,9 +2565,9 @@ var lsSchema = Type6.Object({
 });
 var DEFAULT_LIMIT4 = 500;
 var defaultLsOperations = {
-  exists: existsSync5,
+  exists: existsSync4,
   stat: statSync2,
-  readdir: readdirSync2
+  readdir: readdirSync
 };
 function createLsTool(cwd, options) {
   const ops = options?.operations ?? defaultLsOperations;
@@ -2246,8 +2676,8 @@ var readSchema = Type7.Object({
   limit: Type7.Optional(Type7.Number({ description: "Maximum number of lines to read" }))
 });
 var defaultReadOperations = {
-  readFile: (path7) => fsReadFile2(path7),
-  access: (path7) => fsAccess2(path7, constants3.R_OK)
+  readFile: (path6) => fsReadFile2(path6),
+  access: (path6) => fsAccess2(path6, constants3.R_OK)
 };
 function createReadTool(cwd, options) {
   const ops = options?.operations ?? defaultReadOperations;
@@ -2256,8 +2686,8 @@ function createReadTool(cwd, options) {
     label: "read",
     description: `Read the contents of a text file. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files.`,
     parameters: readSchema,
-    execute: async (_toolCallId, { path: path7, offset, limit }, signal) => {
-      const absolutePath = resolveReadPath(path7, cwd);
+    execute: async (_toolCallId, { path: path6, offset, limit }, signal) => {
+      const absolutePath = resolveReadPath(path6, cwd);
       validatePathWithinCwd(absolutePath, cwd);
       return withAbortSignal(signal, async (isAborted) => {
         await ops.access(absolutePath);
@@ -2286,7 +2716,7 @@ function createReadTool(cwd, options) {
         let outputText;
         let details;
         if (truncation.firstLineExceedsLimit) {
-          outputText = `[Line ${startLineDisplay} is ${formatSize(Buffer.byteLength(allLines[startLine], "utf-8"))}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path7} | head -c ${DEFAULT_MAX_BYTES}]`;
+          outputText = `[Line ${startLineDisplay} is ${formatSize(Buffer.byteLength(allLines[startLine], "utf-8"))}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path6} | head -c ${DEFAULT_MAX_BYTES}]`;
           details = { truncation };
         } else if (truncation.truncated) {
           const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
@@ -2329,7 +2759,7 @@ var writeSchema = Type8.Object({
   content: Type8.String({ description: "Content to write to the file" })
 });
 var defaultWriteOperations = {
-  writeFile: (path7, content) => fsWriteFile2(path7, content, "utf-8"),
+  writeFile: (path6, content) => fsWriteFile2(path6, content, "utf-8"),
   mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => {
   })
 };
@@ -2340,8 +2770,8 @@ function createWriteTool(cwd, options) {
     label: "write",
     description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
     parameters: writeSchema,
-    execute: async (_toolCallId, { path: path7, content }, signal) => {
-      const absolutePath = resolveToCwd(path7, cwd);
+    execute: async (_toolCallId, { path: path6, content }, signal) => {
+      const absolutePath = resolveToCwd(path6, cwd);
       validatePathWithinCwd(absolutePath, cwd);
       const dir = dirname(absolutePath);
       return new Promise(
@@ -2365,7 +2795,7 @@ function createWriteTool(cwd, options) {
               if (signal) signal.removeEventListener("abort", onAbort);
               resolve6({
                 content: [
-                  { type: "text", text: `Successfully wrote ${content.length} bytes to ${path7}` }
+                  { type: "text", text: `Successfully wrote ${content.length} bytes to ${path6}` }
                 ],
                 details: void 0
               });
@@ -2384,11 +2814,11 @@ var writeTool = createWriteTool(process.cwd());
 // src/tools/skill-tool.ts
 init_utils();
 import { readdir } from "fs/promises";
-import { join as join2, extname } from "path";
-import { existsSync as existsSync6, statSync as statSync3 } from "fs";
+import { join as join4, extname as extname2 } from "path";
+import { existsSync as existsSync5, statSync as statSync3 } from "fs";
 import { Type as Type9 } from "@sinclair/typebox";
 function getInterpreter(scriptPath) {
-  const ext = extname(scriptPath);
+  const ext = extname2(scriptPath);
   switch (ext) {
     case ".sh":
     case ".bash":
@@ -2478,8 +2908,8 @@ function createSkillScriptTool(skills, cwd) {
           details: void 0
         };
       }
-      const scriptsDir = join2(skill.skillPath, "scripts");
-      if (!existsSync6(scriptsDir)) {
+      const scriptsDir = join4(skill.skillPath, "scripts");
+      if (!existsSync5(scriptsDir)) {
         return {
           content: [
             { type: "text", text: `Skill '${skillName}' has no scripts directory` }
@@ -2487,8 +2917,8 @@ function createSkillScriptTool(skills, cwd) {
           details: void 0
         };
       }
-      const scriptPath = join2(scriptsDir, scriptName);
-      if (!existsSync6(scriptPath)) {
+      const scriptPath = join4(scriptsDir, scriptName);
+      if (!existsSync5(scriptPath)) {
         try {
           const availableScripts = await readdir(scriptsDir);
           return {
@@ -2547,14 +2977,14 @@ ${result.stderr}
 }
 
 // src/tools/skill-reference-tool.ts
-import { readFile, readdir as readdir2 } from "fs/promises";
-import { join as join3, normalize, relative as relative2 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join5, normalize, relative as relative3 } from "path";
+import { existsSync as existsSync6 } from "fs";
 import { Type as Type10 } from "@sinclair/typebox";
 function isPathSafe(basePath, requestedPath) {
   const normalized = normalize(requestedPath);
-  const fullPath = join3(basePath, normalized);
-  const relativePath = relative2(basePath, fullPath);
+  const fullPath = join5(basePath, normalized);
+  const relativePath = relative3(basePath, fullPath);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/");
 }
 var skillReferenceSchema = Type10.Object({
@@ -2582,8 +3012,8 @@ function createSkillReferenceTool(skills) {
           details: void 0
         };
       }
-      const referencesDir = join3(skill.skillPath, "references");
-      if (!existsSync7(referencesDir)) {
+      const referencesDir = join5(skill.skillPath, "references");
+      if (!existsSync6(referencesDir)) {
         return {
           content: [
             { type: "text", text: `Skill '${skillName}' has no references directory` }
@@ -2602,8 +3032,8 @@ function createSkillReferenceTool(skills) {
           details: void 0
         };
       }
-      const fullPath = join3(referencesDir, referencePath);
-      if (!existsSync7(fullPath)) {
+      const fullPath = join5(referencesDir, referencePath);
+      if (!existsSync6(fullPath)) {
         try {
           const availableRefs = await listReferencesRecursive(referencesDir);
           return {
@@ -2629,7 +3059,7 @@ ${availableRefs.join("\n")}`
         }
       }
       try {
-        const content = await readFile(fullPath, "utf-8");
+        const content = await readFile2(fullPath, "utf-8");
         return {
           content: [{ type: "text", text: content }],
           details: void 0
@@ -2653,9 +3083,9 @@ async function listReferencesRecursive(dir, prefix = "") {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const relativePath = prefix ? join3(prefix, entry.name) : entry.name;
+      const relativePath = prefix ? join5(prefix, entry.name) : entry.name;
       if (entry.isDirectory()) {
-        const subFiles = await listReferencesRecursive(join3(dir, entry.name), relativePath);
+        const subFiles = await listReferencesRecursive(join5(dir, entry.name), relativePath);
         files.push(...subFiles);
       } else {
         files.push(relativePath);
@@ -2750,13 +3180,14 @@ async function fetchAllTodos(db, threadId) {
 }
 async function addTodos(threadId, descriptions, assignedTo = "agent") {
   const db = await getDatabase();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const desc of descriptions) {
+  const baseTime = Date.now();
+  for (let i = 0; i < descriptions.length; i++) {
     const id = randomUUID();
+    const ts = new Date(baseTime + i).toISOString();
     await db.execute({
       sql: `INSERT INTO todos (id, threadId, description, status, assignedTo, createdAt, updatedAt)
 			      VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
-      args: [id, threadId, desc.trim(), assignedTo, now, now]
+      args: [id, threadId, descriptions[i].trim(), assignedTo, ts, ts]
     });
   }
   return fetchAllTodos(db, threadId);
@@ -2876,18 +3307,11 @@ function createTodoTool(threadId) {
             };
           }
           const todosAfterUpdate = await fetchAllTodos(db, threadId);
-          const allDone = todosAfterUpdate.length > 0 && todosAfterUpdate.every((t) => t.status === "done");
-          if (allDone) {
-            await db.execute({
-              sql: `DELETE FROM todos WHERE threadId = ?`,
-              args: [threadId]
-            });
-          }
           return {
             content: [
               {
                 type: "text",
-                text: JSON.stringify({ todos: allDone ? [] : todosAfterUpdate })
+                text: JSON.stringify({ todos: todosAfterUpdate })
               }
             ],
             details: void 0
@@ -2946,16 +3370,16 @@ function createTodoTool(threadId) {
 var todoTool = createTodoTool("");
 
 // src/features/mcp/mcp.config.ts
-import { readFile as readFile2, stat, access } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile3, stat, access } from "fs/promises";
+import { join as join6 } from "path";
 var MCP_CONFIG_PATHS = [".agents/mcp.json", "mcp.json"];
 async function loadMCPConfig(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS) {
-    const fullPath = join5(projectPath, configPath);
+    const fullPath = join6(projectPath, configPath);
     try {
       await access(fullPath);
       const fileStats = await stat(fullPath);
-      const fileContent = await readFile2(fullPath, "utf-8");
+      const fileContent = await readFile3(fullPath, "utf-8");
       const rawConfig = JSON.parse(fileContent);
       const serversData = rawConfig.servers || rawConfig.mcpServers || {};
       const config = {
@@ -2980,7 +3404,7 @@ async function loadMCPConfig(projectPath) {
 }
 async function getMCPConfigModificationTime(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS) {
-    const fullPath = join5(projectPath, configPath);
+    const fullPath = join6(projectPath, configPath);
     try {
       await access(fullPath);
       const fileStats = await stat(fullPath);
@@ -4013,11 +4437,15 @@ var runWebWorkerSchema = Type15.Object({
   })
 });
 var pendingTasks = /* @__PURE__ */ new Map();
+var bufferedResults = /* @__PURE__ */ new Map();
 function submitWebWorkerResult(toolCallId, result) {
   const pending = pendingTasks.get(toolCallId);
-  if (!pending) return false;
-  pending.resolve(result);
-  pendingTasks.delete(toolCallId);
+  if (pending) {
+    pending.resolve(result);
+    pendingTasks.delete(toolCallId);
+    return true;
+  }
+  bufferedResults.set(toolCallId, result);
   return true;
 }
 function cancelPendingWebWorker(toolCallId) {
@@ -4027,6 +4455,7 @@ function cancelPendingWebWorker(toolCallId) {
   pendingTasks.delete(toolCallId);
   return true;
 }
+var DEFAULT_RUN_JS_TIMEOUT_MS = 3e4;
 function buildDescription(tools) {
   let desc = "Execute javascript code in a web worker (not nodejs). Use this when running JS code is the easiest way to accomplish the goal, such as data transformations, calculations, or orchestrating multiple tool calls programmatically. Returns the result of the execution. You can call other tools by using `await callTool('toolName', { arg: 'value' })`. callTool always returns `{ text: string | null, error: string | null }`. On success `text` contains the result and `error` is null. On failure `error` contains the error message and `text` is null. Example: `const r = await callTool('read', { path: 'foo.ts' }); if (r.error) return r.error; return r.text;`. Write the most compact code possible: no comments, short variable names, minimal whitespace.";
   if (tools && tools.length > 0) {
@@ -4039,6 +4468,7 @@ ${signatures}`;
   return desc;
 }
 function createRunWebWorkerTool(options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_RUN_JS_TIMEOUT_MS;
   return {
     name: "run_js",
     label: "run_js",
@@ -4050,16 +4480,55 @@ function createRunWebWorkerTool(options) {
         throw new Error("Operation aborted");
       }
       const result = await new Promise((resolve6, reject) => {
-        pendingTasks.set(toolCallId, {
-          resolve: resolve6,
-          reject,
-          code
-        });
+        const earlyResult = bufferedResults.get(toolCallId);
+        if (earlyResult !== void 0) {
+          bufferedResults.delete(toolCallId);
+          resolve6(earlyResult);
+          return;
+        }
+        let timeoutHandle = null;
         const onAbort = () => {
           cancelPendingWebWorker(toolCallId);
         };
+        function cleanup() {
+          signal?.removeEventListener("abort", onAbort);
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+        }
+        const wrappedResolve = (value) => {
+          cleanup();
+          resolve6(value);
+        };
+        const wrappedReject = (error) => {
+          cleanup();
+          reject(error);
+        };
+        pendingTasks.set(toolCallId, {
+          resolve: wrappedResolve,
+          reject: wrappedReject,
+          code
+        });
         signal?.addEventListener("abort", onAbort, { once: true });
+        timeoutHandle = setTimeout(() => {
+          const pending = pendingTasks.get(toolCallId);
+          if (!pending) return;
+          pendingTasks.delete(toolCallId);
+          wrappedReject(
+            new Error(
+              `run_js timed out after ${timeoutMs}ms while waiting for browser worker response`
+            )
+          );
+        }, timeoutMs);
       });
+      if (isRunJsErrorPayload(result)) {
+        throw new Error(`run_js execution failed: ${result.error}`);
+      }
+      if (result === void 0 && looksLikeMissingReturn(code)) {
+        throw new Error(
+          "run_js result was undefined. The script likely forgot to return a value (for example: `return JSON.stringify(...)`)."
+        );
+      }
       return {
         content: [
           {
@@ -4072,6 +4541,28 @@ function createRunWebWorkerTool(options) {
     }
   };
 }
+function isRunJsErrorPayload(result) {
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  if (!("error" in result)) {
+    return false;
+  }
+  const error = result.error;
+  return typeof error === "string" && error.length > 0;
+}
+function looksLikeMissingReturn(code) {
+  if (/\breturn\b/.test(code)) {
+    return false;
+  }
+  if (/\bJSON\.stringify\s*\(/.test(code)) {
+    return true;
+  }
+  if (/\bawait\s+callTool\b/.test(code) && /;\s*$/.test(code.trim())) {
+    return true;
+  }
+  return false;
+}
 var runWebWorkerTool = createRunWebWorkerTool();
 
 // src/tools/tool-search.ts
@@ -4182,13 +4673,52 @@ ${schemaBlocks}
     }
   };
 }
-function formatDeferredToolsList(deferredTools) {
-  if (deferredTools.size === 0) return "";
-  const names = Array.from(deferredTools.keys()).join(", ");
-  return "\n\n# Deferred Tools\n\nThe following tools are available but deferred. Use the `tool_search` tool to fetch their full definitions before calling them:\n" + names;
+function formatDeferredToolsList(deferredTools) {
+  if (deferredTools.size === 0) return "";
+  const names = Array.from(deferredTools.keys()).join(", ");
+  return "\n\n# Deferred Tools\n\nThe following tools are available but deferred. Use the `tool_search` tool to fetch their full definitions before calling them:\n" + names;
+}
+
+// src/tools/index.ts
+var INDEX_INVALIDATING_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "edit", "write"]);
+function shouldInvalidateCodeSearchIndex(toolName) {
+  return INDEX_INVALIDATING_TOOL_NAMES.has(toolName);
+}
+function shouldInvalidateCodeSearchIndexOnError(toolName) {
+  return toolName === "bash";
+}
+async function invalidateCodeSearchIndexSafely(threadId, toolName) {
+  try {
+    await invalidateThreadIndex(threadId);
+    console.log(`[code-search] invalidated thread index after ${toolName}`);
+  } catch (error) {
+    console.warn(`[code-search] failed to invalidate thread index after ${toolName}:`, error);
+  }
+}
+function wrapToolWithCodeSearchInvalidation(tool, threadId) {
+  if (!threadId || !shouldInvalidateCodeSearchIndex(tool.name)) {
+    return tool;
+  }
+  const originalExecute = tool.execute.bind(tool);
+  return {
+    ...tool,
+    execute: async (toolCallId, inputs, signal, onUpdate) => {
+      let success = false;
+      try {
+        const result = await originalExecute(toolCallId, inputs, signal, onUpdate);
+        success = true;
+        return result;
+      } finally {
+        if (success || shouldInvalidateCodeSearchIndexOnError(tool.name)) {
+          await invalidateCodeSearchIndexSafely(threadId, tool.name);
+        }
+      }
+    }
+  };
+}
+function applyCodeSearchInvalidationHooks(tools, threadId) {
+  return tools.map((tool) => wrapToolWithCodeSearchInvalidation(tool, threadId));
 }
-
-// src/tools/index.ts
 async function createCodingTools(cwd, options) {
   const deferOption = options?.deferTools ?? true;
   const coreTools = [
@@ -4199,7 +4729,7 @@ async function createCodingTools(cwd, options) {
     createAskUserTool(),
     createTodoTool(options?.threadId ?? ""),
     createFindTool(cwd),
-    createAstGrepTool(cwd),
+    createCodeSearchTool(cwd, options?.threadId ?? ""),
     createRunWebWorkerTool()
   ];
   const optionalTools = [];
@@ -4247,7 +4777,8 @@ async function createCodingTools(cwd, options) {
       `[Tools] ${deferredTools.size} tool(s) deferred behind tool_search: ${Array.from(deferredTools.keys()).join(", ")}`
     );
   }
-  return { tools, deferredToolNames: deferredTools };
+  const wrappedTools = applyCodeSearchInvalidationHooks(tools, options?.threadId);
+  return { tools: wrappedTools, deferredToolNames: deferredTools };
 }
 function createAllTools(cwd, options) {
   const tools = {
@@ -4256,7 +4787,7 @@ function createAllTools(cwd, options) {
     edit: createEditTool(cwd),
     write: createWriteTool(cwd),
     grep: createGrepTool(cwd),
-    ast_grep: createAstGrepTool(cwd),
+    code_search: createCodeSearchTool(cwd, options?.threadId ?? ""),
     find: createFindTool(cwd),
     ask_user: createAskUserTool(),
     ls: createLsTool(cwd),
@@ -4269,6 +4800,11 @@ function createAllTools(cwd, options) {
     });
   }
   tools.find_images = createFindImagesTool(cwd);
+  if (options?.threadId) {
+    for (const [name, tool] of Object.entries(tools)) {
+      tools[name] = wrapToolWithCodeSearchInvalidation(tool, options.threadId);
+    }
+  }
   return tools;
 }
 
@@ -4731,21 +5267,21 @@ function createAgentTool(options) {
 }
 
 // src/core/paths.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir3 } from "os";
-var APP_SUPPORT_DIR = join6(homedir3(), "Library", "Application Support", "Tarsk");
-var DATA_DIR = join6(APP_SUPPORT_DIR, "data");
+var APP_SUPPORT_DIR = join7(homedir3(), "Library", "Application Support", "Tarsk");
+var DATA_DIR = join7(APP_SUPPORT_DIR, "data");
 function getDataDir() {
   return DATA_DIR;
 }
 
 // src/agent/agent.prompt-loader.ts
 import { resolve } from "path";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 
 // src/project-analyzer.ts
-import { readFileSync as readFileSync2, existsSync as existsSync8 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
 var ProjectAnalyzer = class {
   projectPath;
   constructor(projectPath = process.cwd()) {
@@ -4756,10 +5292,10 @@ var ProjectAnalyzer = class {
     return this.generateDescription(info);
   }
   getProjectInfo() {
-    const packageJsonPath = join7(this.projectPath, "package.json");
+    const packageJsonPath = join8(this.projectPath, "package.json");
     const info = { description: "" };
-    if (existsSync8(packageJsonPath)) {
-      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    if (existsSync7(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
       const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
       this.detectFramework(allDeps, info);
       this.detectBuildTool(packageJson.scripts, allDeps, info);
@@ -4798,15 +5334,15 @@ var ProjectAnalyzer = class {
     }
   }
   detectBuildTool(_scripts = {}, deps, info) {
-    if (deps.vite || existsSync8(join7(this.projectPath, "vite.config.js")) || existsSync8(join7(this.projectPath, "vite.config.ts"))) {
+    if (deps.vite || existsSync7(join8(this.projectPath, "vite.config.js")) || existsSync7(join8(this.projectPath, "vite.config.ts"))) {
       info.buildTool = "Vite";
       return;
     }
-    if (deps.webpack || existsSync8(join7(this.projectPath, "webpack.config.js"))) {
+    if (deps.webpack || existsSync7(join8(this.projectPath, "webpack.config.js"))) {
       info.buildTool = "Webpack";
       return;
     }
-    if (deps.rollup || existsSync8(join7(this.projectPath, "rollup.config.js"))) {
+    if (deps.rollup || existsSync7(join8(this.projectPath, "rollup.config.js"))) {
       info.buildTool = "Rollup";
       return;
     }
@@ -4856,40 +5392,40 @@ var ProjectAnalyzer = class {
     info.uiLibraries = [...new Set(uiLibs)].filter(Boolean);
   }
   detectProjectType(info) {
-    if (existsSync8(join7(this.projectPath, ".xcodeproj")) || existsSync8(join7(this.projectPath, ".xcworkspace")) || existsSync8(join7(this.projectPath, "project.pbxproj"))) {
+    if (existsSync7(join8(this.projectPath, ".xcodeproj")) || existsSync7(join8(this.projectPath, ".xcworkspace")) || existsSync7(join8(this.projectPath, "project.pbxproj"))) {
       info.projectType = "Xcode";
-    } else if (existsSync8(join7(this.projectPath, "build.gradle")) || existsSync8(join7(this.projectPath, "build.gradle.kts")) || existsSync8(join7(this.projectPath, "app/build.gradle")) || existsSync8(join7(this.projectPath, "settings.gradle"))) {
+    } else if (existsSync7(join8(this.projectPath, "build.gradle")) || existsSync7(join8(this.projectPath, "build.gradle.kts")) || existsSync7(join8(this.projectPath, "app/build.gradle")) || existsSync7(join8(this.projectPath, "settings.gradle"))) {
       info.projectType = "Android Studio";
-    } else if (existsSync8(join7(this.projectPath, "pubspec.yaml"))) {
+    } else if (existsSync7(join8(this.projectPath, "pubspec.yaml"))) {
       info.projectType = "Flutter";
-    } else if (existsSync8(join7(this.projectPath, "go.mod"))) {
+    } else if (existsSync7(join8(this.projectPath, "go.mod"))) {
       info.projectType = "Go";
-    } else if (existsSync8(join7(this.projectPath, "Cargo.toml"))) {
+    } else if (existsSync7(join8(this.projectPath, "Cargo.toml"))) {
       info.projectType = "Rust";
-    } else if (existsSync8(join7(this.projectPath, "requirements.txt")) || existsSync8(join7(this.projectPath, "pyproject.toml")) || existsSync8(join7(this.projectPath, "setup.py"))) {
+    } else if (existsSync7(join8(this.projectPath, "requirements.txt")) || existsSync7(join8(this.projectPath, "pyproject.toml")) || existsSync7(join8(this.projectPath, "setup.py"))) {
       info.projectType = "Python";
-    } else if (existsSync8(join7(this.projectPath, "Gemfile"))) {
+    } else if (existsSync7(join8(this.projectPath, "Gemfile"))) {
       info.projectType = "Ruby";
-    } else if (existsSync8(join7(this.projectPath, "composer.json"))) {
+    } else if (existsSync7(join8(this.projectPath, "composer.json"))) {
       info.projectType = "PHP";
-    } else if (existsSync8(join7(this.projectPath, "pom.xml")) || existsSync8(join7(this.projectPath, "build.xml"))) {
+    } else if (existsSync7(join8(this.projectPath, "pom.xml")) || existsSync7(join8(this.projectPath, "build.xml"))) {
       info.projectType = "Java";
-    } else if (existsSync8(join7(this.projectPath, ".csproj")) || existsSync8(join7(this.projectPath, "project.json"))) {
+    } else if (existsSync7(join8(this.projectPath, ".csproj")) || existsSync7(join8(this.projectPath, "project.json"))) {
       info.projectType = ".NET";
     }
   }
   detectPackageManager(info) {
-    if (existsSync8(join7(this.projectPath, "bun.lockb"))) {
+    if (existsSync7(join8(this.projectPath, "bun.lockb"))) {
       info.packageManager = "Bun";
-    } else if (existsSync8(join7(this.projectPath, "bun.lock"))) {
+    } else if (existsSync7(join8(this.projectPath, "bun.lock"))) {
       info.packageManager = "Bun";
-    } else if (existsSync8(join7(this.projectPath, "pnpm-lock.yaml"))) {
+    } else if (existsSync7(join8(this.projectPath, "pnpm-lock.yaml"))) {
       info.packageManager = "pnpm";
-    } else if (existsSync8(join7(this.projectPath, "yarn.lock"))) {
+    } else if (existsSync7(join8(this.projectPath, "yarn.lock"))) {
       info.packageManager = "Yarn";
-    } else if (existsSync8(join7(this.projectPath, "package-lock.json"))) {
+    } else if (existsSync7(join8(this.projectPath, "package-lock.json"))) {
       info.packageManager = "npm";
-    } else if (existsSync8(join7(this.projectPath, "npm-shrinkwrap.json"))) {
+    } else if (existsSync7(join8(this.projectPath, "npm-shrinkwrap.json"))) {
       info.packageManager = "npm";
     }
   }
@@ -4951,9 +5487,9 @@ function analyzeProject(projectPath) {
 }
 
 // src/features/rules/rules.manager.ts
-import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
-import { join as join8, relative as relative3 } from "path";
-import { existsSync as existsSync9 } from "fs";
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { join as join9, relative as relative4 } from "path";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir4 } from "os";
 function parseRuleFrontmatter(markdown) {
   const lines = markdown.split("\n");
@@ -4996,10 +5532,10 @@ function parseRuleFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalRulesDir() {
-  return join8(homedir4(), ".agents", "rules");
+  return join9(homedir4(), ".agents", "rules");
 }
 function getProjectRulesDir(threadPath) {
-  return join8(threadPath, ".agents", "rules");
+  return join9(threadPath, ".agents", "rules");
 }
 var RuleManager = class {
   /**
@@ -5009,14 +5545,14 @@ var RuleManager = class {
   async loadRules(threadPath) {
     const rules = /* @__PURE__ */ new Map();
     const globalDir = getGlobalRulesDir();
-    if (existsSync9(globalDir)) {
+    if (existsSync8(globalDir)) {
       const globalRules = await this.loadRulesFromDir(globalDir, threadPath, "global");
       for (const rule of globalRules) {
         rules.set(rule.name, rule);
       }
     }
     const projectDir = getProjectRulesDir(threadPath);
-    if (existsSync9(projectDir)) {
+    if (existsSync8(projectDir)) {
       const projectRules = await this.loadRulesFromDir(projectDir, threadPath, "project");
       for (const rule of projectRules) {
         rules.set(rule.name, rule);
@@ -5032,16 +5568,16 @@ var RuleManager = class {
     try {
       const entries = await readdir3(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join8(dir, entry.name);
+        const fullPath = join9(dir, entry.name);
         if (entry.isDirectory()) {
           const subRules = await this.loadRulesFromDir(fullPath, threadPath, scope);
           rules.push(...subRules);
         } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
           try {
-            const fileContent = await readFile3(fullPath, "utf-8");
+            const fileContent = await readFile4(fullPath, "utf-8");
             const { metadata, content } = parseRuleFrontmatter(fileContent);
             const ruleName = entry.name.replace(/\.(md|mdc)$/, "");
-            const relativePath = relative3(threadPath, fullPath);
+            const relativePath = relative4(threadPath, fullPath);
             const rule = {
               name: ruleName,
               content,
@@ -5200,7 +5736,7 @@ Remember: You are ONLY planning. Do NOT execute any changes.`;
 function loadDeveloperContext(threadPath) {
   try {
     const agentsPath = resolve(threadPath, "agents.md");
-    const agentsContent = readFileSync3(agentsPath, "utf-8").trim();
+    const agentsContent = readFileSync4(agentsPath, "utf-8").trim();
     console.log("[ai] Successfully loaded agents.md from thread path for developer context");
     return agentsContent;
   } catch (error) {
@@ -5913,9 +6449,9 @@ import { Hono as Hono2 } from "hono";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/features/skills/skills.manager.ts
-import { readdir as readdir4, readFile as readFile4 } from "fs/promises";
-import { join as join9 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { join as join10 } from "path";
+import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir5 } from "os";
 function parseFrontmatter(markdown) {
   const lines = markdown.split("\n");
@@ -5962,10 +6498,10 @@ function parseFrontmatter(markdown) {
   return { metadata, content };
 }
 function getGlobalSkillsDir() {
-  return join9(homedir5(), ".agents", "skills");
+  return join10(homedir5(), ".agents", "skills");
 }
 function getProjectSkillsDir(threadPath) {
-  return join9(threadPath, ".agents", "skills");
+  return join10(threadPath, ".agents", "skills");
 }
 function validateSkillName(name) {
   if (!name || name.length === 0 || name.length > 64) {
@@ -5993,14 +6529,14 @@ var SkillManager = class {
   async loadSkills(threadPath) {
     const skills = /* @__PURE__ */ new Map();
     const globalDir = getGlobalSkillsDir();
-    if (existsSync10(globalDir)) {
+    if (existsSync9(globalDir)) {
       const globalSkills = await this.loadSkillsFromDir(globalDir, "global");
       for (const skill of globalSkills) {
         skills.set(skill.name, skill);
       }
     }
     const projectDir = getProjectSkillsDir(threadPath);
-    if (existsSync10(projectDir)) {
+    if (existsSync9(projectDir)) {
       const projectSkills = await this.loadSkillsFromDir(projectDir, "project");
       for (const skill of projectSkills) {
         skills.set(skill.name, skill);
@@ -6018,14 +6554,14 @@ var SkillManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const skillDirName = entry.name;
-        const skillPath = join9(dir, skillDirName);
-        const skillFilePath = join9(skillPath, "SKILL.md");
-        if (!existsSync10(skillFilePath)) {
+        const skillPath = join10(dir, skillDirName);
+        const skillFilePath = join10(skillPath, "SKILL.md");
+        if (!existsSync9(skillFilePath)) {
           console.warn(`Skipping skill directory ${skillDirName}: SKILL.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile4(skillFilePath, "utf-8");
+          const fileContent = await readFile5(skillFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter(fileContent);
           if (!metadata.name) {
             console.warn(`Skipping skill in ${skillDirName}: missing 'name' in frontmatter`);
@@ -6198,9 +6734,9 @@ async function activateSkills(allSkills, taskDescription, thread, options) {
 }
 
 // src/features/agents/agents.manager.ts
-import { readdir as readdir5, readFile as readFile5 } from "fs/promises";
-import { join as join10 } from "path";
-import { existsSync as existsSync11 } from "fs";
+import { readdir as readdir5, readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir6 } from "os";
 function parseFrontmatter2(markdown) {
   const lines = markdown.split("\n");
@@ -6257,10 +6793,10 @@ function validateDescription2(description) {
   return !!description && description.length > 0 && description.length <= 1024;
 }
 function getGlobalAgentsDir() {
-  return join10(homedir6(), ".agents", "agents");
+  return join11(homedir6(), ".agents", "agents");
 }
 function getProjectAgentsDir(threadPath) {
-  return join10(threadPath, ".agents", "agents");
+  return join11(threadPath, ".agents", "agents");
 }
 var AgentsManager = class {
   /**
@@ -6270,14 +6806,14 @@ var AgentsManager = class {
   async loadAgents(threadPath) {
     const agents = /* @__PURE__ */ new Map();
     const globalDir = getGlobalAgentsDir();
-    if (existsSync11(globalDir)) {
+    if (existsSync10(globalDir)) {
       const globalAgents = await this.loadAgentsFromDir(globalDir, "global");
       for (const agent of globalAgents) {
         agents.set(agent.name, agent);
       }
     }
     const projectDir = getProjectAgentsDir(threadPath);
-    if (existsSync11(projectDir)) {
+    if (existsSync10(projectDir)) {
       const projectAgents = await this.loadAgentsFromDir(projectDir, "project");
       for (const agent of projectAgents) {
         agents.set(agent.name, agent);
@@ -6292,14 +6828,14 @@ var AgentsManager = class {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const agentDirName = entry.name;
-        const agentPath = join10(dir, agentDirName);
-        const agentFilePath = join10(agentPath, "AGENT.md");
-        if (!existsSync11(agentFilePath)) {
+        const agentPath = join11(dir, agentDirName);
+        const agentFilePath = join11(agentPath, "AGENT.md");
+        if (!existsSync10(agentFilePath)) {
           console.warn(`[agents] Skipping agent directory ${agentDirName}: AGENT.md not found`);
           continue;
         }
         try {
-          const fileContent = await readFile5(agentFilePath, "utf-8");
+          const fileContent = await readFile6(agentFilePath, "utf-8");
           const { metadata, content } = parseFrontmatter2(fileContent);
           if (!metadata.name) {
             console.warn(
@@ -6479,8 +7015,8 @@ function extractAssistantContent(events, fallback) {
 
 // src/features/chat/chat-post.route.ts
 init_database();
-import { readFile as readFile6, unlink } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile7, unlink } from "fs/promises";
+import { join as join12 } from "path";
 
 // src/features/project-todos/project-todos.database.ts
 init_database();
@@ -7072,9 +7608,9 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
           try {
             const todo = await getTodoByThreadId(db, threadId);
             if (todo && todo.status === "Plan") {
-              const planFilePath = join11(threadPath, `${todo.id}-plan.md`);
+              const planFilePath = join12(threadPath, `${todo.id}-plan.md`);
               try {
-                const planContent = await readFile6(planFilePath, "utf-8");
+                const planContent = await readFile7(planFilePath, "utf-8");
                 await updateTodo(db, todo.id, { description: planContent.trim() });
                 await unlink(planFilePath);
               } catch {
@@ -8451,28 +8987,35 @@ async function getAllProjects(db) {
   try {
     const result = await db.execute("SELECT * FROM projects ORDER BY createdAt DESC");
     const rows = result.rows;
-    return await Promise.all(rows.map((row) => deserializeProject(db, row)));
+    const threadResult = await db.execute(
+      "SELECT id, projectId FROM threads ORDER BY createdAt DESC"
+    );
+    const threadRows = threadResult.rows;
+    const threadIdsByProject = /* @__PURE__ */ new Map();
+    for (const row of threadRows) {
+      const ids = threadIdsByProject.get(row.projectId);
+      if (ids) {
+        ids.push(row.id);
+      } else {
+        threadIdsByProject.set(row.projectId, [row.id]);
+      }
+    }
+    return rows.map(
+      (row) => deserializeProjectWithThreads(row, threadIdsByProject.get(row.id) ?? [])
+    );
   } catch (error) {
     console.error("Failed to get all projects:", error);
     throw error;
   }
 }
-async function getProjectThreadIds(db, projectId) {
-  const result = await db.execute(
-    "SELECT id FROM threads WHERE projectId = ? ORDER BY createdAt DESC",
-    [projectId]
-  );
-  const rows = result.rows;
-  return rows.map((row) => row.id);
-}
-async function deserializeProject(db, row) {
+function deserializeProjectWithThreads(row, threadIds) {
   return {
     id: row.id,
     name: row.name,
     gitUrl: row.gitUrl,
     path: row.path,
     createdAt: new Date(row.createdAt),
-    threads: await getProjectThreadIds(db, row.id),
+    threads: threadIds,
     openWith: row.openWith ?? void 0,
     commands: row.commands ? JSON.parse(row.commands) : void 0,
     setupScript: row.setupScript ?? void 0,
@@ -8569,6 +9112,12 @@ async function updateThread(db, id, updates) {
 async function deleteThread(db, id) {
   try {
     await markConversationHistoryAsDeleted(db, id);
+    await db.execute(
+      "DELETE FROM code_index WHERE rowid IN (SELECT id FROM code_files WHERE thread_id = ?)",
+      [id]
+    );
+    await db.execute("DELETE FROM code_files WHERE thread_id = ?", [id]);
+    await db.execute("DELETE FROM code_index_meta WHERE thread_id = ?", [id]);
     await db.execute("UPDATE threads SET status = ? WHERE id = ?", ["deleted", id]);
   } catch (error) {
     console.error("Failed to mark thread as deleted:", error);
@@ -9430,34 +9979,58 @@ async function handleOpenFolderProject(c, projectManager) {
 }
 
 // src/features/projects/projects-list.route.ts
-async function handleListProjects(c, projectManager, threadManager) {
+function computeGitStatusDot(status) {
+  if (status.hasChanges) return true;
+  if (status.commitsAheadOfDefault && !status.prExists) return true;
+  if (status.status === "Behind" || status.status === "Diverged") return true;
+  return false;
+}
+async function handleListProjects(c, projectManager, threadManager, db) {
   try {
     const projects = await projectManager.listProjects();
     const selectedThreadId = await threadManager.getSelectedThreadId();
-    const expandedProjects = await Promise.all(
-      projects.map(async (project) => {
-        const threads = await threadManager.listThreads(project.id);
-        return {
-          projectId: project.id,
-          name: project.name,
-          gitUrl: project.gitUrl,
-          projectPath: project.path,
-          openWith: project.openWith,
-          commands: project.commands ?? [],
-          setupScript: project.setupScript,
-          runCommand: project.runCommand,
-          commitMethod: project.commitMethod,
-          threads: threads.map((thread) => ({
+    const allThreads = await threadManager.listAllThreads();
+    const threadsByProject = /* @__PURE__ */ new Map();
+    for (const thread of allThreads) {
+      const list = threadsByProject.get(thread.projectId);
+      if (list) {
+        list.push(thread);
+      } else {
+        threadsByProject.set(thread.projectId, [thread]);
+      }
+    }
+    const allThreadIds = allThreads.map((t) => t.id);
+    const statusCache = db ? await getGitStatusCacheBulk(db, allThreadIds) : /* @__PURE__ */ new Map();
+    const expandedProjects = projects.map((project) => {
+      const threads = threadsByProject.get(project.id) ?? [];
+      return {
+        projectId: project.id,
+        name: project.name,
+        gitUrl: project.gitUrl,
+        projectPath: project.path,
+        openWith: project.openWith,
+        commands: project.commands ?? [],
+        setupScript: project.setupScript,
+        runCommand: project.runCommand,
+        commitMethod: project.commitMethod,
+        planPrompt: project.planPrompt,
+        testPrompt: project.testPrompt,
+        reviewPrompt: project.reviewPrompt,
+        threads: threads.map((thread) => {
+          const cached = statusCache.get(thread.id);
+          const gitStatusDot = cached ? computeGitStatusDot(cached) : false;
+          return {
             threadId: thread.id,
             title: thread.title,
             path: thread.path,
             isSelected: thread.id === selectedThreadId,
             model: thread.model,
-            modelProvider: thread.modelProvider
-          }))
-        };
-      })
-    );
+            modelProvider: thread.modelProvider,
+            gitStatusDot
+          };
+        })
+      };
+    });
     return c.json(expandedProjects);
   } catch (error) {
     return errorResponse(
@@ -9928,12 +10501,12 @@ async function handleCheckRunning(c, projectManager) {
 }
 
 // src/core/run-command-detector.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join13 } from "path";
 async function detectPackageManager(projectPath) {
   try {
-    const packageJsonPath = join12(projectPath, "package.json");
-    const content = await readFile7(packageJsonPath, "utf-8");
+    const packageJsonPath = join13(projectPath, "package.json");
+    const content = await readFile8(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     if (packageJson.packageManager) {
       const pm = packageJson.packageManager.split("@")[0];
@@ -9948,8 +10521,8 @@ async function detectPackageManager(projectPath) {
 }
 async function detectRunScripts(projectPath) {
   try {
-    const packageJsonPath = join12(projectPath, "package.json");
-    const content = await readFile7(packageJsonPath, "utf-8");
+    const packageJsonPath = join13(projectPath, "package.json");
+    const content = await readFile8(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(content);
     const scripts = packageJson.scripts ?? {};
     return {
@@ -9994,8 +10567,8 @@ async function suggestRunCommand(projectPath) {
 }
 
 // src/features/projects/projects-package-scripts.route.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join14 } from "path";
 import { glob } from "glob";
 function formatScriptName(scriptName) {
   return scriptName.replace(/[-:_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
@@ -10023,8 +10596,8 @@ async function findPackageScripts(projectPath) {
     const packageManager = await detectPackageManager(projectPath);
     for (const filePath of packageJsonFiles) {
       try {
-        const fullPath = join13(projectPath, filePath);
-        const content = await readFile8(fullPath, "utf-8");
+        const fullPath = join14(projectPath, filePath);
+        const content = await readFile9(fullPath, "utf-8");
         const packageJson = JSON.parse(content);
         if (packageJson.scripts) {
           for (const [scriptName] of Object.entries(packageJson.scripts)) {
@@ -10071,9 +10644,9 @@ async function handleGetPackageScripts(c, projectManager) {
 }
 
 // src/features/projects/projects-ai-files.route.ts
-import { readdir as readdir6, readFile as readFile9, writeFile, mkdir, access as access2, rm } from "fs/promises";
-import { join as join14, extname as extname2, basename } from "path";
-import { existsSync as existsSync12 } from "fs";
+import { readdir as readdir6, readFile as readFile10, writeFile, mkdir, access as access2, rm } from "fs/promises";
+import { join as join15, extname as extname3, basename } from "path";
+import { existsSync as existsSync11 } from "fs";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -10091,8 +10664,8 @@ async function buildFullTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join14(relativeDirPath, entry.name);
-      const entryAbsPath = join14(dirPath, entry.name);
+      const entryRelPath = join15(relativeDirPath, entry.name);
+      const entryAbsPath = join15(dirPath, entry.name);
       if (entry.isDirectory()) {
         const children = await buildFullTree(entryAbsPath, entryRelPath);
         nodes.push({
@@ -10120,8 +10693,8 @@ async function buildMarkdownFilteredTree(dirPath, relativeDirPath) {
   try {
     const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryRelPath = join14(relativeDirPath, entry.name);
-      const entryAbsPath = join14(dirPath, entry.name);
+      const entryRelPath = join15(relativeDirPath, entry.name);
+      const entryAbsPath = join15(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         const children = await buildMarkdownFilteredTree(entryAbsPath, entryRelPath);
@@ -10134,10 +10707,10 @@ async function buildMarkdownFilteredTree(dirPath, relativeDirPath) {
             children
           });
         }
-      } else if (entry.isFile() && MARKDOWN_EXTS.has(extname2(entry.name))) {
+      } else if (entry.isFile() && MARKDOWN_EXTS.has(extname3(entry.name))) {
         nodes.push({
           id: entryRelPath,
-          name: basename(entry.name, extname2(entry.name)),
+          name: basename(entry.name, extname3(entry.name)),
           type: "file",
           path: entryRelPath
         });
@@ -10156,9 +10729,9 @@ async function buildAIFileTree(projectPath) {
     { key: "agents", label: "Agents" }
   ];
   for (const { key, label } of agentsFolders) {
-    const relPath = join14(".agents", key);
-    const absPath = join14(projectPath, relPath);
-    const exists = existsSync12(absPath);
+    const relPath = join15(".agents", key);
+    const absPath = join15(projectPath, relPath);
+    const exists = existsSync11(absPath);
     if (exists) {
       const children = await buildFullTree(absPath, relPath);
       nodes.push({
@@ -10192,11 +10765,11 @@ async function buildAIFileTree(projectPath) {
       if (entry.name === ".agents" || entry.name === "AGENTS.md" || IGNORED_DIRS.has(entry.name))
         continue;
       const entryRelPath = entry.name;
-      const entryAbsPath = join14(projectPath, entry.name);
-      if (entry.isFile() && MARKDOWN_EXTS.has(extname2(entry.name))) {
+      const entryAbsPath = join15(projectPath, entry.name);
+      if (entry.isFile() && MARKDOWN_EXTS.has(extname3(entry.name))) {
         nodes.push({
           id: entryRelPath,
-          name: basename(entry.name, extname2(entry.name)),
+          name: basename(entry.name, extname3(entry.name)),
           type: "file",
           path: entryRelPath
         });
@@ -10219,7 +10792,7 @@ async function buildAIFileTree(projectPath) {
 }
 function validateFilePath(projectPath, filePath) {
   if (!filePath) return null;
-  const abs = join14(projectPath, filePath);
+  const abs = join15(projectPath, filePath);
   if (!abs.startsWith(projectPath + "/") && abs !== projectPath) return null;
   return abs;
 }
@@ -10300,7 +10873,7 @@ Links to important documentation, tools, or references.
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
     }
-    const content = await readFile9(absPath, "utf-8");
+    const content = await readFile10(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -10336,7 +10909,7 @@ async function handleSaveAIFile(c, projectManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join14(absPath, "..");
+    const parentDir = join15(absPath, "..");
     await mkdir(parentDir, { recursive: true });
     await writeFile(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
@@ -10430,11 +11003,11 @@ async function handleCreateSkill(c, projectManager) {
     if (!project) {
       return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
     }
-    const skillRelPath = join14(".agents", "skills", name);
-    const skillAbsPath = join14(project.path, skillRelPath);
-    const skillFileRelPath = join14(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join14(skillAbsPath, "SKILL.md");
-    if (existsSync12(skillAbsPath)) {
+    const skillRelPath = join15(".agents", "skills", name);
+    const skillAbsPath = join15(project.path, skillRelPath);
+    const skillFileRelPath = join15(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join15(skillAbsPath, "SKILL.md");
+    if (existsSync11(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
         409
@@ -10475,7 +11048,9 @@ function createProjectRoutes(projectManager, threadManager) {
     return handleOpenFolderProject(c, projectManager);
   });
   router.get("/", async (c) => {
-    return handleListProjects(c, projectManager, threadManager);
+    const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const db = await getDatabase2();
+    return handleListProjects(c, projectManager, threadManager, db);
   });
   router.get("/:id", async (c) => {
     return handleGetProject(c, projectManager);
@@ -10533,7 +11108,7 @@ function createProjectRoutes(projectManager, threadManager) {
 
 // src/features/projects/projects.manager.ts
 init_utils();
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
 import { rm as rm3 } from "fs/promises";
 
@@ -10610,11 +11185,13 @@ var ProcessManager = class extends EventEmitter {
       });
     };
     try {
-      const [cmd, ...args2] = command.split(" ");
-      console.log("CLI ProcessManager: Spawning process:", cmd, "with args:", args2);
-      const childProcess = spawnProcess(cmd, args2, {
+      const { shell, args: shellArgs } = getShellConfig();
+      console.log("CLI ProcessManager: Spawning process:", shell, "with command:", command);
+      const childProcess = spawnProcess(shell, [...shellArgs, command], {
         cwd,
-        shell: true,
+        env: Object.fromEntries(
+          Object.entries(getShellEnv()).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+        ),
         stdio: ["ignore", "pipe", "pipe"]
       });
       this.processes.set(projectId, childProcess);
@@ -10752,13 +11329,13 @@ var ProcessManager = class extends EventEmitter {
 // src/features/projects/projects.creator.ts
 init_utils();
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, join as join16, relative as relative4 } from "path";
+import { basename as basename2, join as join17, relative as relative5 } from "path";
 import { access as access3, stat as stat3, readdir as readdir8 } from "fs/promises";
 
 // src/features/scaffold/scaffold.runner.ts
 init_utils();
-import { existsSync as existsSync13 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join16 } from "path";
 import { mkdir as mkdir2, readdir as readdir7, stat as stat2, rename, rm as rm2 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
 
@@ -11423,10 +12000,12 @@ function buildCommandList(template, options) {
   return withPm;
 }
 async function* runCommandStreaming(cwd, command) {
-  const [bin, ...args2] = command.split(/\s+/);
-  const child = spawnProcess(bin, args2, {
+  const { shell, args: shellArgs } = getShellConfig();
+  const child = spawnProcess(shell, [...shellArgs, command], {
     cwd,
-    shell: true,
+    env: Object.fromEntries(
+      Object.entries(getShellEnv()).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+    ),
     stdio: ["ignore", "pipe", "pipe"]
   });
   const queue = [];
@@ -11471,8 +12050,8 @@ async function* runCommandStreaming(cwd, command) {
   }
 }
 async function* createScaffoldedProjectStreaming(options) {
-  const projectPath = join15(options.parentDir, options.threadId);
-  if (!existsSync13(options.parentDir)) {
+  const projectPath = join16(options.parentDir, options.threadId);
+  if (!existsSync12(options.parentDir)) {
     yield {
       type: "result",
       result: {
@@ -11559,7 +12138,7 @@ async function* createScaffoldedProjectStreaming(options) {
   }
   try {
     const projectName2 = getProjectName(options.projectName);
-    const projectSubDir = join15(projectPath, projectName2);
+    const projectSubDir = join16(projectPath, projectName2);
     try {
       const subDirStat = await stat2(projectSubDir);
       if (subDirStat.isDirectory()) {
@@ -11569,8 +12148,8 @@ async function* createScaffoldedProjectStreaming(options) {
         };
         const items = await readdir7(projectSubDir);
         for (const item of items) {
-          const oldPath = join15(projectSubDir, item);
-          const newPath = join15(projectPath, item);
+          const oldPath = join16(projectSubDir, item);
+          const newPath = join16(projectPath, item);
           await rename(oldPath, newPath);
         }
         await rm2(projectSubDir, { recursive: true, force: true });
@@ -11586,7 +12165,7 @@ async function* createScaffoldedProjectStreaming(options) {
     };
   }
   const installCwd = scaffoldOptions.projectPath;
-  if (existsSync13(installCwd)) {
+  if (existsSync12(installCwd)) {
     const installCmd = getInstallCommand(options.packageManager);
     for await (const event of runCommandStreaming(installCwd, installCmd)) {
       if (event.type === "output") {
@@ -12030,7 +12609,7 @@ var ProjectCreator = class {
     return name;
   }
   generateThreadPath(_projectId, threadId) {
-    return join16(this.rootFolder, threadId);
+    return join17(this.rootFolder, threadId);
   }
   async *createProjectFromFolder() {
     await loadUtils();
@@ -12180,19 +12759,19 @@ var ProjectCreator = class {
   }
   async findAllPackageJsonFiles(rootPath, currentPath, setupScripts) {
     try {
-      await access3(join16(currentPath, "package.json"));
-      const relativePath = relative4(rootPath, currentPath);
+      await access3(join17(currentPath, "package.json"));
+      const relativePath = relative5(rootPath, currentPath);
       let installCommand = "";
       try {
-        await access3(join16(currentPath, "yarn.lock"));
+        await access3(join17(currentPath, "yarn.lock"));
         installCommand = "yarn install";
       } catch {
         try {
-          await access3(join16(currentPath, "bun.lock"));
+          await access3(join17(currentPath, "bun.lock"));
           installCommand = "bun install";
         } catch {
           try {
-            await access3(join16(currentPath, "pnpm-lock.yaml"));
+            await access3(join17(currentPath, "pnpm-lock.yaml"));
             installCommand = "pnpm install";
           } catch {
             installCommand = "npm install";
@@ -12209,7 +12788,7 @@ var ProjectCreator = class {
     try {
       const entries = await readdir8(currentPath);
       for (const entry of entries) {
-        const entryPath = join16(currentPath, entry);
+        const entryPath = join17(currentPath, entry);
         try {
           const stats = await stat3(entryPath);
           if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
@@ -12528,7 +13107,7 @@ var ProjectManagerImpl = class {
     const session = this.terminalSessionManager.getOrCreateSession(threadId, thread.path);
     let workingDir;
     if (cwd) {
-      workingDir = cwd.startsWith("/") ? cwd : join17(thread.path, cwd);
+      workingDir = cwd.startsWith("/") ? cwd : join18(thread.path, cwd);
       this.terminalSessionManager.updateWorkingDirectory(threadId, workingDir);
     } else {
       workingDir = session.currentWorkingDirectory;
@@ -12733,9 +13312,9 @@ import { Hono as Hono7 } from "hono";
 
 // src/core/env-manager.ts
 import { promises as fs } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function updateEnvFile(keyNames) {
-  const envPath = join18(process.cwd(), ".env");
+  const envPath = join19(process.cwd(), ".env");
   let content = "";
   try {
     content = await fs.readFile(envPath, "utf-8");
@@ -12764,7 +13343,7 @@ async function updateEnvFile(keyNames) {
   await fs.writeFile(envPath, newLines.join("\n") + "\n", "utf-8");
 }
 async function readEnvFile() {
-  const envPath = join18(process.cwd(), ".env");
+  const envPath = join19(process.cwd(), ".env");
   const envMap = {};
   try {
     const content = await fs.readFile(envPath, "utf-8");
@@ -13183,9 +13762,9 @@ function createScaffoldRoutes(projectManager) {
 }
 
 // src/features/slash-commands/slash-commands.manager.ts
-import { readdir as readdir9, readFile as readFile10, mkdir as mkdir3, writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
-import { join as join19, basename as basename3, extname as extname3 } from "path";
-import { existsSync as existsSync14 } from "fs";
+import { readdir as readdir9, readFile as readFile11, mkdir as mkdir3, writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
+import { join as join20, basename as basename3, extname as extname4 } from "path";
+import { existsSync as existsSync13 } from "fs";
 import { homedir as homedir7 } from "os";
 function slugify(filename) {
   return filename.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
@@ -13230,10 +13809,10 @@ function parseFrontmatter3(markdown) {
   return { metadata, content };
 }
 function getGlobalCommandsDir() {
-  return join19(homedir7(), ".agents", "commands");
+  return join20(homedir7(), ".agents", "commands");
 }
 function getProjectCommandsDir(threadPath) {
-  return join19(threadPath, ".agents", "commands");
+  return join20(threadPath, ".agents", "commands");
 }
 var SlashCommandManager = class _SlashCommandManager {
   /**
@@ -13248,14 +13827,14 @@ var SlashCommandManager = class _SlashCommandManager {
   async loadCommands(threadPath) {
     const commands = /* @__PURE__ */ new Map();
     const globalDir = getGlobalCommandsDir();
-    if (existsSync14(globalDir)) {
+    if (existsSync13(globalDir)) {
       const globalCommands = await this.loadCommandsFromDir(globalDir, "global");
       for (const cmd of globalCommands) {
         commands.set(cmd.name, cmd);
       }
     }
     const projectDir = getProjectCommandsDir(threadPath);
-    if (existsSync14(projectDir)) {
+    if (existsSync13(projectDir)) {
       const projectCommands = await this.loadCommandsFromDir(projectDir, "project");
       for (const cmd of projectCommands) {
         if (!_SlashCommandManager.BUILT_IN_COMMANDS.has(cmd.name)) {
@@ -13274,10 +13853,10 @@ var SlashCommandManager = class _SlashCommandManager {
       const files = await readdir9(dir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = join19(dir, file);
-        const fileContent = await readFile10(filePath, "utf-8");
+        const filePath = join20(dir, file);
+        const fileContent = await readFile11(filePath, "utf-8");
         const { metadata, content } = parseFrontmatter3(fileContent);
-        const nameWithoutExt = basename3(file, extname3(file));
+        const nameWithoutExt = basename3(file, extname4(file));
         const commandName = slugify(nameWithoutExt);
         if (!commandName) continue;
         commands.push({
@@ -13305,12 +13884,12 @@ var SlashCommandManager = class _SlashCommandManager {
     if (!dir) {
       throw new Error("threadPath required for project-scoped commands");
     }
-    if (!existsSync14(dir)) {
+    if (!existsSync13(dir)) {
       await mkdir3(dir, { recursive: true });
     }
     const filename = `${name}.md`;
-    const filePath = join19(dir, filename);
-    if (existsSync14(filePath)) {
+    const filePath = join20(dir, filename);
+    if (existsSync13(filePath)) {
       throw new Error(`Command already exists: ${name}`);
     }
     let markdown = "";
@@ -13344,7 +13923,7 @@ var SlashCommandManager = class _SlashCommandManager {
    * Update an existing command
    */
   async updateCommand(filePath, content, metadata) {
-    if (!existsSync14(filePath)) {
+    if (!existsSync13(filePath)) {
       throw new Error(`Command file not found: ${filePath}`);
     }
     let markdown = "";
@@ -13371,7 +13950,7 @@ var SlashCommandManager = class _SlashCommandManager {
    * Delete a command
    */
   async deleteCommand(filePath) {
-    if (!existsSync14(filePath)) {
+    if (!existsSync13(filePath)) {
       throw new Error(`Command file not found: ${filePath}`);
     }
     await unlink2(filePath);
@@ -13717,7 +14296,7 @@ function createSlashCommandRoutes(router, threadManager) {
 
 // src/features/rules/rules-post.route.ts
 import { promises as fs2 } from "fs";
-import path4 from "path";
+import path3 from "path";
 async function createRule(c, projectManager) {
   try {
     const body = await c.req.json();
@@ -13772,7 +14351,7 @@ async function createRule(c, projectManager) {
       );
     }
     const projectPath = project.path;
-    const rulesDir = path4.join(projectPath, ".agents", "rules");
+    const rulesDir = path3.join(projectPath, ".agents", "rules");
     await fs2.mkdir(rulesDir, { recursive: true });
     const ruleContent = `---
 description: ${description.replace(/"/g, '\\"')}
@@ -13780,7 +14359,7 @@ alwaysApply: ${alwaysApply}
 ---
 
 Describe your rules here as markdown which will be used when Tarsk sees is prompted with a request that is related to the description of this rule.`;
-    const ruleFilePath = path4.join(rulesDir, `${name}.md`);
+    const ruleFilePath = path3.join(rulesDir, `${name}.md`);
     await fs2.writeFile(ruleFilePath, ruleContent, "utf-8");
     return c.json(
       {
@@ -13904,7 +14483,7 @@ function createRuleRoutes(router, projectManager) {
 // src/features/threads/threads.manager.ts
 init_utils();
 import { randomUUID as randomUUID8 } from "crypto";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { execSync as execSync3 } from "child_process";
 import { rm as rm4, stat as stat4, mkdir as mkdir4 } from "fs/promises";
 init_database();
@@ -14141,6 +14720,13 @@ var ThreadManagerImpl = class {
     const threads = await this.metadataManager.loadThreads();
     return threads.filter((t) => t.projectId === projectId);
   }
+  /**
+   * Lists all active threads across all projects in a single query
+   * @returns Array of all active threads
+   */
+  async listAllThreads() {
+    return this.metadataManager.loadThreads();
+  }
   /**
    * Deletes a thread and removes its directory
    *
@@ -14234,9 +14820,12 @@ var ThreadManagerImpl = class {
    * @yields ThreadEvent progress events
    */
   async *runSetupScript(threadPath, commandLine) {
-    const child = spawnProcess(commandLine, [], {
-      shell: true,
-      cwd: threadPath
+    const { shell, args: shellArgs } = getShellConfig();
+    const child = spawnProcess(shell, [...shellArgs, commandLine], {
+      cwd: threadPath,
+      env: Object.fromEntries(
+        Object.entries(getShellEnv()).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+      )
     });
     const decoder = new TextDecoder();
     let resolveNext = () => {
@@ -14298,7 +14887,7 @@ var ThreadManagerImpl = class {
    * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
    */
   generateThreadPath(_projectId, threadId) {
-    return join20(this.rootFolder, threadId);
+    return join21(this.rootFolder, threadId);
   }
   /**
    * Generates a thread title if not provided
@@ -14424,7 +15013,7 @@ async function handleCreateThread(c, threadManager, gitManager) {
 }
 
 // src/features/threads/threads-list.route.ts
-function computeGitStatusDot(status) {
+function computeGitStatusDot2(status) {
   if (status.hasChanges) return true;
   if (status.commitsAheadOfDefault && !status.prExists) return true;
   if (status.status === "Behind" || status.status === "Diverged") return true;
@@ -14451,7 +15040,7 @@ async function handleListThreads(c, threadManager, db) {
     );
     const threadsWithStatus = threads.map((thread) => {
       const cached = statusCache.get(thread.id);
-      const gitStatusDot = cached ? computeGitStatusDot(cached) : false;
+      const gitStatusDot = cached ? computeGitStatusDot2(cached) : false;
       return { ...thread, gitStatusDot };
     });
     return c.json(threadsWithStatus);
@@ -14491,26 +15080,63 @@ async function handleDeleteThread(c, threadManager) {
 }
 
 // src/core/project-inspector.ts
-import { readFile as readFile11, readdir as readdir10, writeFile as writeFile3, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
-import { join as join21, basename as basename4, relative as relative5 } from "path";
+import { readFile as readFile12, readdir as readdir10 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import { join as join22, basename as basename4, relative as relative6 } from "path";
 import { glob as glob2 } from "glob";
-async function inspectProject(projectPath) {
+
+// src/features/project-scripts/project-scripts.database.ts
+init_database();
+import { randomUUID as randomUUID9 } from "crypto";
+async function getScriptsByProject(db, projectId) {
+  const result = await db.execute({
+    sql: `SELECT id, projectId, workspace, name, command, friendlyName, updatedAt
+          FROM project_scripts WHERE projectId = ? ORDER BY workspace ASC, name ASC`,
+    args: [projectId]
+  });
+  return result.rows;
+}
+async function upsertProjectScripts(projectId, scripts) {
+  const db = await getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `DELETE FROM project_scripts WHERE projectId = ?`,
+    args: [projectId]
+  });
+  for (const script of scripts) {
+    await db.execute({
+      sql: `INSERT INTO project_scripts (id, projectId, workspace, name, command, friendlyName, updatedAt)
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        randomUUID9(),
+        projectId,
+        script.workspace,
+        script.name,
+        script.command,
+        script.friendlyName,
+        now
+      ]
+    });
+  }
+}
+
+// src/core/project-inspector.ts
+async function inspectProject(projectPath, projectId) {
   const packageManager = await detectPackageManager2(projectPath);
   const repoType = await detectMonoRepoType(projectPath);
   const workspaces = await resolveWorkspaces(projectPath, repoType);
   const scripts = await collectScripts(projectPath, workspaces, packageManager, repoType);
-  await writeProjectScripts(projectPath, scripts);
+  await upsertProjectScripts(projectId, scripts);
   return scripts;
 }
 async function detectPackageManager2(projectPath) {
-  if (existsSync15(join21(projectPath, "bun.lockb")) || existsSync15(join21(projectPath, "bun.lock"))) {
+  if (existsSync14(join22(projectPath, "bun.lockb")) || existsSync14(join22(projectPath, "bun.lock"))) {
     return "bun";
   }
-  if (existsSync15(join21(projectPath, "pnpm-lock.yaml"))) {
+  if (existsSync14(join22(projectPath, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync15(join21(projectPath, "yarn.lock"))) {
+  if (existsSync14(join22(projectPath, "yarn.lock"))) {
     return "yarn";
   }
   try {
@@ -14529,8 +15155,8 @@ async function detectPackageManager2(projectPath) {
   return "npm";
 }
 async function detectMonoRepoType(projectPath) {
-  const hasPnpmWorkspace = existsSync15(join21(projectPath, "pnpm-workspace.yaml"));
-  if (existsSync15(join21(projectPath, "nx.json"))) {
+  const hasPnpmWorkspace = existsSync14(join22(projectPath, "pnpm-workspace.yaml"));
+  if (existsSync14(join22(projectPath, "nx.json"))) {
     return "nx";
   }
   const pkg = await readPackageJson(projectPath);
@@ -14544,10 +15170,10 @@ async function detectMonoRepoType(projectPath) {
   if (hasPnpmWorkspace) {
     return "pnpm";
   }
-  if (existsSync15(join21(projectPath, "lerna.json"))) {
+  if (existsSync14(join22(projectPath, "lerna.json"))) {
     return "lerna";
   }
-  if (existsSync15(join21(projectPath, "turbo.json"))) {
+  if (existsSync14(join22(projectPath, "turbo.json"))) {
     return "turbo";
   }
   const folderWorkspaces = await detectFolderBasedWorkspaces(projectPath);
@@ -14588,8 +15214,8 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   });
   const workspaces = [];
   for (const folder of folders) {
-    const absPath = join21(projectPath, folder);
-    if (existsSync15(join21(absPath, "package.json"))) {
+    const absPath = join22(projectPath, folder);
+    if (existsSync14(join22(absPath, "package.json"))) {
       const wsPkg = await readPackageJson(absPath);
       workspaces.push({
         name: wsPkg?.name ?? basename4(folder),
@@ -14605,12 +15231,12 @@ async function resolvePackageJsonWorkspaces(projectPath) {
   return workspaces;
 }
 async function resolvePnpmWorkspaces(projectPath) {
-  const yamlPath = join21(projectPath, "pnpm-workspace.yaml");
-  if (!existsSync15(yamlPath)) {
+  const yamlPath = join22(projectPath, "pnpm-workspace.yaml");
+  if (!existsSync14(yamlPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const yaml = await readFile11(yamlPath, "utf-8");
+    const yaml = await readFile12(yamlPath, "utf-8");
     const patterns = [];
     for (const line of yaml.split("\n")) {
       const trimmed = line.trim();
@@ -14631,8 +15257,8 @@ async function resolvePnpmWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join21(projectPath, folder);
-      if (existsSync15(join21(absPath, "package.json"))) {
+      const absPath = join22(projectPath, folder);
+      if (existsSync14(join22(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -14651,12 +15277,12 @@ async function resolvePnpmWorkspaces(projectPath) {
   }
 }
 async function resolveLernaWorkspaces(projectPath) {
-  const lernaPath = join21(projectPath, "lerna.json");
-  if (!existsSync15(lernaPath)) {
+  const lernaPath = join22(projectPath, "lerna.json");
+  if (!existsSync14(lernaPath)) {
     return [{ name: "root", folder: projectPath, relativePath: "." }];
   }
   try {
-    const content = await readFile11(lernaPath, "utf-8");
+    const content = await readFile12(lernaPath, "utf-8");
     const lerna = JSON.parse(content);
     const patterns = lerna.packages ?? ["packages/*"];
     const folders = await glob2(patterns, {
@@ -14665,8 +15291,8 @@ async function resolveLernaWorkspaces(projectPath) {
     });
     const workspaces = [];
     for (const folder of folders) {
-      const absPath = join21(projectPath, folder);
-      if (existsSync15(join21(absPath, "package.json"))) {
+      const absPath = join22(projectPath, folder);
+      if (existsSync14(join22(absPath, "package.json"))) {
         const wsPkg = await readPackageJson(absPath);
         workspaces.push({
           name: wsPkg?.name ?? basename4(folder),
@@ -14686,17 +15312,17 @@ async function resolveLernaWorkspaces(projectPath) {
 }
 async function resolveNxWorkspaces(projectPath) {
   const workspaces = [];
-  const workspaceJsonPath = join21(projectPath, "workspace.json");
-  if (existsSync15(workspaceJsonPath)) {
+  const workspaceJsonPath = join22(projectPath, "workspace.json");
+  if (existsSync14(workspaceJsonPath)) {
     try {
-      const content = await readFile11(workspaceJsonPath, "utf-8");
+      const content = await readFile12(workspaceJsonPath, "utf-8");
       const wsJson = JSON.parse(content);
       for (const [name, value] of Object.entries(wsJson.projects ?? {})) {
         const folder = typeof value === "string" ? value : value.root;
         if (folder) {
           workspaces.push({
             name,
-            folder: join21(projectPath, folder),
+            folder: join22(projectPath, folder),
             relativePath: folder
           });
         }
@@ -14711,13 +15337,13 @@ async function resolveNxWorkspaces(projectPath) {
   });
   for (const file of projectJsonFiles) {
     try {
-      const content = await readFile11(join21(projectPath, file), "utf-8");
+      const content = await readFile12(join22(projectPath, file), "utf-8");
       const project = JSON.parse(content);
       if (project.name) {
         const folder = file.replace(/\/project\.json$/, "");
         workspaces.push({
           name: project.name,
-          folder: join21(projectPath, folder),
+          folder: join22(projectPath, folder),
           relativePath: folder
         });
       }
@@ -14725,15 +15351,15 @@ async function resolveNxWorkspaces(projectPath) {
     }
   }
   if (workspaces.length > 0) return workspaces;
-  const appsDir = join21(projectPath, "apps");
-  if (existsSync15(appsDir)) {
+  const appsDir = join22(projectPath, "apps");
+  if (existsSync14(appsDir)) {
     const entries = await readdir10(appsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const folder = join21("apps", entry.name);
+        const folder = join22("apps", entry.name);
         workspaces.push({
           name: entry.name,
-          folder: join21(projectPath, folder),
+          folder: join22(projectPath, folder),
           relativePath: folder
         });
       }
@@ -14768,13 +15394,13 @@ async function detectFolderBasedWorkspaces(projectPath) {
     const results = [];
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
-        const pkgPath = join21(projectPath, entry.name, "package.json");
-        if (existsSync15(pkgPath)) {
+        const pkgPath = join22(projectPath, entry.name, "package.json");
+        if (existsSync14(pkgPath)) {
           try {
-            const content = await readFile11(pkgPath, "utf-8");
+            const content = await readFile12(pkgPath, "utf-8");
             const pkg = JSON.parse(content);
             if (pkg.dependencies || pkg.devDependencies || pkg.scripts) {
-              results.push({ name: entry.name, absPath: join21(projectPath, entry.name) });
+              results.push({ name: entry.name, absPath: join22(projectPath, entry.name) });
             }
           } catch {
           }
@@ -14812,7 +15438,7 @@ function buildRunCommand(scriptName, workspace, packageManager, repoType, projec
     return `npm run ${scriptName} --workspace=${workspace.relativePath}`;
   }
   if (!isRoot) {
-    const relPath = relative5(projectPath, workspace.folder);
+    const relPath = relative6(projectPath, workspace.folder);
     return `cd ${relPath} && ${runCmd}`;
   }
   return runCmd;
@@ -14830,7 +15456,7 @@ function pmRunCommand(packageManager, scriptName) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile11(join21(dir, "package.json"), "utf-8");
+    const content = await readFile12(join22(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -14849,17 +15475,6 @@ function getWorkspaceGlobs(pkg) {
 function toFriendlyName(scriptName) {
   return scriptName.replace(/[-:_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
-async function writeProjectScripts(projectPath, scripts) {
-  const agentsDir = join21(projectPath, ".agents");
-  if (!existsSync15(agentsDir)) {
-    await mkdir5(agentsDir, { recursive: true });
-  }
-  await writeFile3(
-    join21(agentsDir, "project-scripts.json"),
-    JSON.stringify(scripts, null, 2),
-    "utf-8"
-  );
-}
 
 // src/features/threads/threads-select.route.ts
 async function handleSelectThread(c, threadManager) {
@@ -14873,7 +15488,7 @@ async function handleSelectThread(c, threadManager) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
     await threadManager.selectThread(threadId);
-    inspectProject(thread.path).catch((err) => {
+    inspectProject(thread.path, thread.projectId).catch((err) => {
       console.error(`Failed to inspect project scripts for thread ${threadId}:`, err);
     });
     return successResponse(c, { success: true, message: "Thread selected successfully", threadId });
@@ -15044,8 +15659,8 @@ async function handleListThreadFiles(c, threadManager) {
 }
 
 // src/features/threads/threads-explorer.route.ts
-import { readdir as readdir11, readFile as readFile12, rename as rename2, writeFile as writeFile4, mkdir as mkdir6, rm as rm5, access as access4 } from "fs/promises";
-import { join as join22 } from "path";
+import { readdir as readdir11, readFile as readFile13, rename as rename2, writeFile as writeFile3, mkdir as mkdir5, rm as rm5, access as access4 } from "fs/promises";
+import { join as join23 } from "path";
 import { spawn as spawn2 } from "child_process";
 var Utils3 = null;
 var utilsLoaded3 = false;
@@ -15105,7 +15720,7 @@ async function handleListThreadExplorerDir(c, threadManager) {
     const entries = dirents.filter((d) => !(isRoot && d.name === ".git")).map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "folder" : "file",
-      path: queryPath ? join22(queryPath, d.name) : d.name
+      path: queryPath ? join23(queryPath, d.name) : d.name
     })).sort((a, b) => {
       if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
       return a.name.localeCompare(b.name);
@@ -15241,8 +15856,8 @@ async function handleCreateExplorerFile(c, threadManager) {
       }
       absParent = validated;
     }
-    await mkdir6(absParent, { recursive: true });
-    await writeFile4(join22(absParent, name), "", "utf-8");
+    await mkdir5(absParent, { recursive: true });
+    await writeFile3(join23(absParent, name), "", "utf-8");
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -15296,7 +15911,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     }
     const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
     const contentType = MEDIA_MIME_TYPES[ext] ?? "application/octet-stream";
-    const data = await readFile12(absPath);
+    const data = await readFile13(absPath);
     return new Response(data, { headers: { "Content-Type": contentType } });
   } catch (error) {
     return errorResponse(
@@ -15338,7 +15953,7 @@ async function handleCreateExplorerFolder(c, threadManager) {
       }
       absParent = validated;
     }
-    await mkdir6(join22(absParent, name), { recursive: true });
+    await mkdir5(join23(absParent, name), { recursive: true });
     const relPath = dirPath ? `${dirPath}/${name}` : name;
     return c.json({ success: true, path: relPath });
   } catch (error) {
@@ -15448,15 +16063,15 @@ async function handleOpenThread(c, threadManager) {
 }
 
 // src/features/threads/threads-conversation-folder-path.route.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function handleGetConversationFolderPath(c) {
   try {
     const threadId = c.req.param("id");
     if (!threadId) {
       return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
     }
-    const path7 = join23(getDataDir(), threadId);
-    return successResponse(c, { path: path7 });
+    const path6 = join24(getDataDir(), threadId);
+    return successResponse(c, { path: path6 });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return errorResponse(
@@ -15509,13 +16124,13 @@ async function handleFixComments(c, threadManager) {
 }
 
 // src/features/threads/threads-ai-files.route.ts
-import { readFile as readFile13, writeFile as writeFile6, mkdir as mkdir8, access as access5, rm as rm6 } from "fs/promises";
-import { join as join25 } from "path";
-import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile14, writeFile as writeFile5, mkdir as mkdir7, access as access5, rm as rm6 } from "fs/promises";
+import { join as join26 } from "path";
+import { existsSync as existsSync15 } from "fs";
 
 // src/features/git/git-download-folder.ts
-import { mkdir as mkdir7, writeFile as writeFile5 } from "fs/promises";
-import { join as join24, dirname as dirname4 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile4 } from "fs/promises";
+import { join as join25, dirname as dirname4 } from "path";
 async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   const { token, ref } = options;
   const match = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
@@ -15551,8 +16166,8 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   await Promise.all(
     files.map(async (file) => {
       const relativePath = file.path.slice(prefix.length);
-      const localPath = join24(destPath, relativePath);
-      await mkdir7(dirname4(localPath), { recursive: true });
+      const localPath = join25(destPath, relativePath);
+      await mkdir6(dirname4(localPath), { recursive: true });
       const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${file.path}`;
       const fileRes = await fetch(rawUrl, { headers });
       if (!fileRes.ok) {
@@ -15560,7 +16175,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
       }
       let content = Buffer.from(await fileRes.arrayBuffer()).toString("utf8");
       content = content.replace(/Claude/gi, "Tarsk");
-      await writeFile5(localPath, content, "utf8");
+      await writeFile4(localPath, content, "utf8");
       console.log(`  \u2713 ${relativePath}`);
     })
   );
@@ -15645,7 +16260,7 @@ Links to important documentation, tools, or references.
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
     }
-    const content = await readFile13(absPath, "utf-8");
+    const content = await readFile14(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -15681,9 +16296,9 @@ async function handleSaveThreadAIFile(c, threadManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join25(absPath, "..");
-    await mkdir8(parentDir, { recursive: true });
-    await writeFile6(absPath, content, "utf-8");
+    const parentDir = join26(absPath, "..");
+    await mkdir7(parentDir, { recursive: true });
+    await writeFile5(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -15764,17 +16379,17 @@ async function handleCreateThreadAgent(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const agentRelPath = join25(".agents", "agents", name);
-    const agentAbsPath = join25(thread.path, agentRelPath);
-    const agentFileRelPath = join25(agentRelPath, "AGENT.md");
-    const agentFileAbsPath = join25(agentAbsPath, "AGENT.md");
-    if (existsSync16(agentAbsPath)) {
+    const agentRelPath = join26(".agents", "agents", name);
+    const agentAbsPath = join26(thread.path, agentRelPath);
+    const agentFileRelPath = join26(agentRelPath, "AGENT.md");
+    const agentFileAbsPath = join26(agentAbsPath, "AGENT.md");
+    if (existsSync15(agentAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Agent '${name}' already exists` } },
         409
       );
     }
-    await mkdir8(agentAbsPath, { recursive: true });
+    await mkdir7(agentAbsPath, { recursive: true });
     const toolsLine = tools ? `
 tools: ${tools}` : "";
     const agentContent = `---
@@ -15784,7 +16399,7 @@ description: ${description}${toolsLine}
 
 Place your agent system prompt here as markdown. This will be used as the system prompt when this agent is invoked as a subagent.
 `;
-    await writeFile6(agentFileAbsPath, agentContent, "utf-8");
+    await writeFile5(agentFileAbsPath, agentContent, "utf-8");
     return c.json({
       success: true,
       path: agentFileRelPath,
@@ -15831,17 +16446,17 @@ async function handleCreateThreadSkill(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const skillRelPath = join25(".agents", "skills", name);
-    const skillAbsPath = join25(thread.path, skillRelPath);
-    const skillFileRelPath = join25(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join25(skillAbsPath, "SKILL.md");
-    if (existsSync16(skillAbsPath)) {
+    const skillRelPath = join26(".agents", "skills", name);
+    const skillAbsPath = join26(thread.path, skillRelPath);
+    const skillFileRelPath = join26(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join26(skillAbsPath, "SKILL.md");
+    if (existsSync15(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
         409
       );
     }
-    await mkdir8(skillAbsPath, { recursive: true });
+    await mkdir7(skillAbsPath, { recursive: true });
     const skillContent = `---
 name: ${name}
 description: ${description}
@@ -15849,7 +16464,7 @@ description: ${description}
 
 Place your skill instructions here as markdown. This will be used when Tarsk is prompted with a request related to the description of this skill.
 `;
-    await writeFile6(skillFileAbsPath, skillContent, "utf-8");
+    await writeFile5(skillFileAbsPath, skillContent, "utf-8");
     return c.json({
       success: true,
       path: skillFileRelPath,
@@ -15908,9 +16523,7 @@ async function handleInstallGithubFolder(c, threadManager) {
 }
 
 // src/features/threads/threads-project-scripts.route.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join26 } from "path";
-import { existsSync as existsSync17 } from "fs";
+init_database();
 
 // src/features/projects/script-process-manager.ts
 init_utils();
@@ -15928,9 +16541,13 @@ var ScriptProcessManager = class {
     if (this.processes.has(key)) {
       this.stopScript(key);
     }
-    const child = spawnShell(command, {
+    const { shell, args: shellArgs } = getShellConfig();
+    const child = spawnProcess(shell, [...shellArgs, command], {
       cwd,
       detached: true,
+      env: Object.fromEntries(
+        Object.entries(getShellEnv()).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+      ),
       stdio: ["pipe", "pipe", "pipe"]
     });
     if (child.pid !== void 0) {
@@ -16017,12 +16634,8 @@ async function handleGetProjectScripts(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const scriptsPath = join26(thread.path, ".agents", "project-scripts.json");
-    if (!existsSync17(scriptsPath)) {
-      return successResponse(c, { scripts: [] });
-    }
-    const content = await readFile14(scriptsPath, "utf-8");
-    const scripts = JSON.parse(content);
+    const db = await getDatabase();
+    const scripts = await getScriptsByProject(db, thread.projectId);
     const enrichedScripts = scripts.map((s) => ({
       ...s,
       isRunning: scriptProcessManager.isRunning(`${thread.projectId}:${s.name}`)
@@ -16187,7 +16800,7 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
 
 // src/features/git/git.manager.ts
 init_utils();
-import { mkdir as mkdir9 } from "fs/promises";
+import { mkdir as mkdir8 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 var GitManagerImpl = class {
   /**
@@ -16259,7 +16872,7 @@ var GitManagerImpl = class {
     }
     try {
       const parentDir = dirname5(targetPath);
-      await mkdir9(parentDir, { recursive: true });
+      await mkdir8(parentDir, { recursive: true });
       const gitProcess = spawnProcess("git", ["clone", "--progress", gitUrl, targetPath]);
       const eventQueue = [];
       let processExited = false;
@@ -16465,7 +17078,7 @@ var GitManagerImpl = class {
   }
   async initRepository(repoPath) {
     try {
-      await mkdir9(repoPath, { recursive: true });
+      await mkdir8(repoPath, { recursive: true });
     } catch (error) {
       if (error.code !== "EEXIST") {
         throw error;
@@ -16512,11 +17125,11 @@ async function gitUserHandler(c) {
 }
 
 // src/features/git/git-status.route.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 
 // src/features/git/git.utils.ts
 init_utils();
-import { existsSync as existsSync18, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve3, join as join27 } from "path";
 import {
   completeSimple,
@@ -16881,10 +17494,10 @@ async function getUntrackedFilesDiff(gitRoot) {
   const maxFileSize = 1e5;
   for (const relPath of untrackedPaths) {
     const fullPath = join27(gitRoot, relPath);
-    if (!existsSync18(fullPath)) continue;
+    if (!existsSync16(fullPath)) continue;
     try {
       if (statSync4(fullPath).isDirectory()) continue;
-      const content = readFileSync4(fullPath, "utf-8");
+      const content = readFileSync5(fullPath, "utf-8");
       const safeContent = content.length > maxFileSize ? content.slice(0, maxFileSize) + "\n...(truncated)" : content;
       const linesForDiff = safeContent.split(/\r?\n/).map((l) => `+${l}`).join("\n");
       parts.push(
@@ -17420,7 +18033,7 @@ async function gitStatusHandler(c, metadataManager) {
       return c.json({ error: "Thread path not found" }, 404);
     }
     const absolutePath = resolveThreadPath(repoPath);
-    if (!existsSync19(absolutePath)) {
+    if (!existsSync17(absolutePath)) {
       return c.json(
         {
           error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
@@ -17464,7 +18077,7 @@ async function gitStatusHandler(c, metadataManager) {
 
 // src/features/git/git-diff.route.ts
 init_utils();
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve4 } from "path";
 async function gitDiffHandler(c, metadataManager) {
   try {
@@ -17527,7 +18140,7 @@ async function gitDiffHandler(c, metadataManager) {
         oldContent = content;
       } else if (file.status === "added" && file.path.startsWith("(new)")) {
         try {
-          newContent = readFileSync5(resolve4(gitRoot, file.path.replace("(new) ", "")), "utf-8");
+          newContent = readFileSync6(resolve4(gitRoot, file.path.replace("(new) ", "")), "utf-8");
         } catch {
           newContent = "";
         }
@@ -17560,7 +18173,7 @@ async function gitDiffHandler(c, metadataManager) {
         });
         oldContent = oldContentOutput;
         try {
-          newContent = readFileSync5(resolve4(gitRoot, file.path), "utf-8");
+          newContent = readFileSync6(resolve4(gitRoot, file.path), "utf-8");
         } catch {
           newContent = "";
         }
@@ -17624,7 +18237,7 @@ async function gitDiffHandler(c, metadataManager) {
 }
 
 // src/features/git/git-generate-commit-message.route.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 async function gitGenerateCommitMessageHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
@@ -17650,7 +18263,7 @@ async function gitGenerateCommitMessageHandler(c, metadataManager) {
     const absolutePath = resolveThreadPath(repoPath);
     process.stdout.write(`[generate-commit-message] resolved path: ${absolutePath}
 `);
-    if (!existsSync20(absolutePath)) {
+    if (!existsSync18(absolutePath)) {
       process.stdout.write(`[generate-commit-message] path does not exist: ${absolutePath}
 `);
       return c.json(
@@ -18130,7 +18743,7 @@ async function gitGithubStatusHandler(c, metadataManager) {
 }
 
 // src/features/git/git-unified-status.route.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 async function gitUnifiedStatusHandler(c, metadataManager, db) {
   try {
     const threadId = c.req.param("threadId");
@@ -18150,7 +18763,7 @@ async function gitUnifiedStatusHandler(c, metadataManager, db) {
       return c.json({ error: "Thread path not found" }, 404);
     }
     const absolutePath = resolveThreadPath(repoPath);
-    if (!existsSync21(absolutePath)) {
+    if (!existsSync19(absolutePath)) {
       return c.json(
         {
           error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
@@ -18496,7 +19109,7 @@ async function gitCreateBranchHandler(c, metadataManager) {
 }
 
 // src/features/git/git-sync-branch.route.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 async function gitSyncBranchHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
@@ -18513,7 +19126,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
     }
     const absolutePath = resolveThreadPath(repoPath);
     console.log(`[sync-branch] Resolved path: ${absolutePath}`);
-    if (!existsSync22(absolutePath)) {
+    if (!existsSync20(absolutePath)) {
       console.log(`[sync-branch] Path does not exist: ${absolutePath}`);
       return c.json(
         {
@@ -18920,6 +19533,168 @@ async function gitRevertFileHandler(c, metadataManager) {
   }
 }
 
+// src/features/git/git-checkpoint.route.ts
+init_utils();
+function stashWithLabel(gitRoot, label) {
+  return new Promise((resolve6, reject) => {
+    const proc = spawnProcess("git", ["stash", "push", "--include-untracked", "-m", label], {
+      cwd: gitRoot
+    });
+    let out = "";
+    let err = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (d) => {
+        out += d.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve6(!out.includes("No local changes to save"));
+      } else {
+        reject(new Error(err || "Failed to create checkpoint"));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+async function gitCheckpointHandler(c, metadataManager) {
+  try {
+    const threadId = c.req.param("threadId");
+    const body = await c.req.json();
+    const { messageId } = body;
+    if (!messageId) {
+      return c.json({ error: "messageId is required" }, 400);
+    }
+    const threads = await metadataManager.loadThreads();
+    const thread = threads.find((t) => t.id === threadId);
+    if (!thread) {
+      return c.json({ error: "Thread not found" }, 404);
+    }
+    const repoPath = thread.path;
+    if (!repoPath) {
+      return c.json({ success: false, reason: "no_path" });
+    }
+    const absolutePath = resolveThreadPath(repoPath);
+    let gitRoot;
+    try {
+      gitRoot = await getGitRoot(absolutePath);
+    } catch {
+      return c.json({ success: false, reason: "not_a_git_repo" });
+    }
+    const label = `tarsk-checkpoint:${messageId}`;
+    const stashed = await stashWithLabel(gitRoot, label);
+    return c.json({ success: true, stashed, checkpointRef: label });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to create checkpoint";
+    return c.json({ error: message }, 500);
+  }
+}
+
+// src/features/git/git-checkpoint-restore.route.ts
+init_utils();
+function listStashes(gitRoot) {
+  return new Promise((resolve6, reject) => {
+    const proc = spawnProcess("git", ["stash", "list", "--format=%gd %s"], { cwd: gitRoot });
+    let out = "";
+    let err = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (d) => {
+        out += d.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(err || "Failed to list stashes"));
+        return;
+      }
+      const entries = out.trim().split("\n").filter((l) => l.length > 0).map((line) => {
+        const match = line.match(/^stash@\{(\d+)\}\s+(?:On \S+:|WIP on \S+:)?\s*(.*)$/);
+        if (!match) return null;
+        return { index: parseInt(match[1], 10), label: match[2].trim() };
+      }).filter((e) => e !== null);
+      resolve6(entries);
+    });
+    proc.on("error", reject);
+  });
+}
+function discardWorkingChanges(gitRoot) {
+  return new Promise((resolve6, reject) => {
+    const proc = spawnProcess("git", ["checkout", "--", "."], { cwd: gitRoot });
+    proc.on("close", () => {
+      const clean = spawnProcess("git", ["clean", "-fd"], { cwd: gitRoot });
+      clean.on("close", (code) => {
+        if (code === 0) resolve6();
+        else reject(new Error("Failed to clean working tree"));
+      });
+      clean.on("error", reject);
+    });
+    proc.on("error", reject);
+  });
+}
+function applyStash(gitRoot, index) {
+  return new Promise((resolve6, reject) => {
+    const proc = spawnProcess("git", ["stash", "apply", `stash@{${index}}`], { cwd: gitRoot });
+    let err = "";
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) resolve6();
+      else reject(new Error(err || "Failed to apply stash"));
+    });
+    proc.on("error", reject);
+  });
+}
+async function gitCheckpointRestoreHandler(c, metadataManager) {
+  try {
+    const threadId = c.req.param("threadId");
+    const body = await c.req.json();
+    const { checkpointRef } = body;
+    if (!checkpointRef) {
+      return c.json({ error: "checkpointRef is required" }, 400);
+    }
+    const threads = await metadataManager.loadThreads();
+    const thread = threads.find((t) => t.id === threadId);
+    if (!thread) {
+      return c.json({ error: "Thread not found" }, 404);
+    }
+    const repoPath = thread.path;
+    if (!repoPath) {
+      return c.json({ error: "Thread has no path" }, 400);
+    }
+    const absolutePath = resolveThreadPath(repoPath);
+    let gitRoot;
+    try {
+      gitRoot = await getGitRoot(absolutePath);
+    } catch {
+      return c.json({ error: "Not a git repository" }, 400);
+    }
+    const stashes = await listStashes(gitRoot);
+    const match = stashes.find((s) => s.label === checkpointRef);
+    if (!match) {
+      return c.json({ error: "Checkpoint not found in stash list" }, 404);
+    }
+    await discardWorkingChanges(gitRoot);
+    await applyStash(gitRoot, match.index);
+    return c.json({ success: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to restore checkpoint";
+    return c.json({ error: message }, 500);
+  }
+}
+
 // src/features/git/git.routes.ts
 function createGitRoutes(metadataManager) {
   const router = new Hono11();
@@ -19008,6 +19783,12 @@ function createGitRoutes(metadataManager) {
     await invalidateGitStatusCache(db, c.req.param("threadId"));
     return gitRevertFileHandler(c, metadataManager);
   });
+  router.post("/checkpoint/:threadId", async (c) => {
+    return gitCheckpointHandler(c, metadataManager);
+  });
+  router.post("/checkpoint-restore/:threadId", async (c) => {
+    return gitCheckpointRestoreHandler(c, metadataManager);
+  });
   return router;
 }
 
@@ -19052,7 +19833,7 @@ function createUpdateRoutes(updater) {
 
 // src/features/mcp/mcp.routes.ts
 import { Hono as Hono13 } from "hono";
-import { readFile as readFile15, writeFile as writeFile7, mkdir as mkdir10, access as access6 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile6, mkdir as mkdir9, access as access6 } from "fs/promises";
 import { join as join28, dirname as dirname6 } from "path";
 
 // src/features/mcp/mcp.popular.json
@@ -19179,8 +19960,8 @@ async function readMCPConfig(projectPath) {
 async function writeMCPConfig(projectPath, config) {
   const existing = await readMCPConfig(projectPath);
   const targetPath = existing?.filePath ?? join28(projectPath, ".agents/mcp.json");
-  await mkdir10(dirname6(targetPath), { recursive: true });
-  await writeFile7(targetPath, JSON.stringify(config, null, 2), "utf-8");
+  await mkdir9(dirname6(targetPath), { recursive: true });
+  await writeFile6(targetPath, JSON.stringify(config, null, 2), "utf-8");
 }
 function createMCPRoutes() {
   const router = new Hono13();
@@ -19895,15 +20676,7 @@ function createBrowserJsRoutes(threadManager) {
           400
         );
       }
-      const resolved = submitWebWorkerResult(toolCallId, result);
-      if (!resolved) {
-        return errorResponse(
-          c,
-          ErrorCodes.INVALID_REQUEST,
-          "No pending web worker execution found for this toolCallId",
-          404
-        );
-      }
+      submitWebWorkerResult(toolCallId, result);
       return c.json({ success: true });
     } catch (error) {
       return errorResponse(
@@ -19956,8 +20729,8 @@ function createBrowserJsRoutes(threadManager) {
 }
 
 // src/server.ts
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path5.dirname(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
 async function startTarskServer(options) {
   const { isDebug: isDebug2, publicDir: publicDirOverride } = options;
   const port = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
@@ -20036,16 +20809,16 @@ async function startTarskServer(options) {
   app.route("/api/update", createUpdateRoutes(options.updater));
   createSlashCommandRoutes(app, threadManager);
   createRuleRoutes(app, projectManager);
-  const prodPublicDir = path5.join(__dirname, "public");
-  const devCopiedPublicDir = path5.join(process.cwd(), "dist", "public");
-  const appDistDir = path5.join(process.cwd(), "..", "app", "dist");
+  const prodPublicDir = path4.join(__dirname, "public");
+  const devCopiedPublicDir = path4.join(process.cwd(), "dist", "public");
+  const appDistDir = path4.join(process.cwd(), "..", "app", "dist");
   const resolvedPublicDir = publicDirOverride ?? [prodPublicDir, devCopiedPublicDir, appDistDir].find((dirPath) => fs3.existsSync(dirPath));
   if (!resolvedPublicDir) {
     throw new Error(
       `No static frontend assets found. Expected one of: ${prodPublicDir}, ${devCopiedPublicDir}, ${appDistDir}. Build the app first with \`cd ../app && bun run build\`.`
     );
   }
-  const staticRoot = path5.relative(process.cwd(), resolvedPublicDir);
+  const staticRoot = path4.relative(process.cwd(), resolvedPublicDir);
   app.use("/*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
       return next();
@@ -20057,7 +20830,7 @@ async function startTarskServer(options) {
       return next();
     }
     return serveStatic({
-      path: path5.relative(process.cwd(), path5.join(resolvedPublicDir, "index.html"))
+      path: path4.relative(process.cwd(), path4.join(resolvedPublicDir, "index.html"))
     })(c, next);
   });
   app.all("*", (c) => {
@@ -20090,8 +20863,8 @@ async function startTarskServer(options) {
 
 // src/index.ts
 import fs4 from "fs";
-import path6 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var args = process.argv.slice(2);
 var isDebug = args.includes("--debug");
 var shouldOpenBrowser = args.includes("--open");
@@ -20099,9 +20872,9 @@ if (!isDebug) {
   console.log = () => {
   };
 } else {
-  const __filename2 = fileURLToPath3(import.meta.url);
-  const cliDir = path6.resolve(path6.dirname(__filename2), "..");
-  const logFilePath = path6.join(cliDir, "logs.txt");
+  const __filename2 = fileURLToPath2(import.meta.url);
+  const cliDir = path5.resolve(path5.dirname(__filename2), "..");
+  const logFilePath = path5.join(cliDir, "logs.txt");
   try {
     fs4.writeFileSync(logFilePath, "");
   } catch {