tarsk 0.3.25 → 0.3.28

package/dist/index.js

@@ -7,7 +7,7 @@ import { Hono as Hono10 } from "hono";
 import { cors } from "hono/cors";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import path from "path";
+import path3 from "path";
 import open2 from "open";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -1838,24 +1838,1404 @@ class MetadataManager {
     } else {
       state.enabledModels[provider] = modelIds;
     }
-    await this.saveState(state);
-  }
-  async setOnboardingCompleted(completed) {
-    const state = await this.loadState();
-    state.onboardingCompleted = completed;
-    await this.saveState(state);
-  }
-  async getOnboardingCompleted() {
-    const state = await this.loadState();
-    return state.onboardingCompleted;
-  }
+    await this.saveState(state);
+  }
+  async setOnboardingCompleted(completed) {
+    const state = await this.loadState();
+    state.onboardingCompleted = completed;
+    await this.saveState(state);
+  }
+  async getOnboardingCompleted() {
+    const state = await this.loadState();
+    return state.onboardingCompleted;
+  }
+}
+
+// src/managers/pi-executor.ts
+import { Agent } from "@mariozechner/pi-agent-core";
+import {
+  getModel
+} from "@mariozechner/pi-ai";
+import { resolve } from "path";
+
+// src/tools/bash.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createWriteStream, existsSync as existsSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join6 } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { spawn as spawn5 } from "child_process";
+
+// src/tools/shell.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { spawn as spawn4, spawnSync as spawnSync3 } from "node:child_process";
+var cachedShellConfig = null;
+function findBashOnPath() {
+  if (process.platform === "win32") {
+    try {
+      const result = spawnSync3("where", ["bash.exe"], { encoding: "utf-8", timeout: 5000 });
+      if (result.status === 0 && result.stdout) {
+        const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+        if (firstMatch && existsSync2(firstMatch)) {
+          return firstMatch;
+        }
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    const result = spawnSync3("which", ["bash"], { encoding: "utf-8", timeout: 5000 });
+    if (result.status === 0 && result.stdout) {
+      const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+      if (firstMatch)
+        return firstMatch;
+    }
+  } catch {}
+  return null;
+}
+function getShellConfig() {
+  if (cachedShellConfig) {
+    return cachedShellConfig;
+  }
+  if (process.platform === "win32") {
+    const paths = [];
+    if (process.env.ProgramFiles) {
+      paths.push(`${process.env.ProgramFiles}\\Git\\bin\\bash.exe`);
+    }
+    if (process.env["ProgramFiles(x86)"]) {
+      paths.push(`${process.env["ProgramFiles(x86)"]}\\Git\\bin\\bash.exe`);
+    }
+    for (const p of paths) {
+      if (existsSync2(p)) {
+        cachedShellConfig = { shell: p, args: ["-c"] };
+        return cachedShellConfig;
+      }
+    }
+    const bashOnPath2 = findBashOnPath();
+    if (bashOnPath2) {
+      cachedShellConfig = { shell: bashOnPath2, args: ["-c"] };
+      return cachedShellConfig;
+    }
+    throw new Error("No bash shell found. Install Git for Windows or add bash to PATH.");
+  }
+  if (existsSync2("/bin/bash")) {
+    cachedShellConfig = { shell: "/bin/bash", args: ["-c"] };
+    return cachedShellConfig;
+  }
+  const bashOnPath = findBashOnPath();
+  if (bashOnPath) {
+    cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
+    return cachedShellConfig;
+  }
+  cachedShellConfig = { shell: "sh", args: ["-c"] };
+  return cachedShellConfig;
+}
+function getShellEnv() {
+  return { ...process.env };
+}
+function killProcessTree(pid) {
+  if (process.platform === "win32") {
+    try {
+      spawn4("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore", detached: true });
+    } catch {}
+  } else {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {}
+    }
+  }
+}
+
+// src/tools/truncate.ts
+var DEFAULT_MAX_LINES = 2000;
+var DEFAULT_MAX_BYTES = 50 * 1024;
+var GREP_MAX_LINE_LENGTH = 500;
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes}B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+}
+function truncateHead(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = content.split(`
+`);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+  if (firstLineBytes > maxBytes) {
+    return {
+      content: "",
+      truncated: true,
+      truncatedBy: "bytes",
+      totalLines,
+      totalBytes,
+      outputLines: 0,
+      outputBytes: 0,
+      lastLinePartial: false,
+      firstLineExceedsLimit: true,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  for (let i = 0;i < lines.length && i < maxLines; i++) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      break;
+    }
+    outputLinesArr.push(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join(`
+`);
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial: false,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateTail(content, options = {}) {
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const lines = content.split(`
+`);
+  const totalLines = lines.length;
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content,
+      truncated: false,
+      truncatedBy: null,
+      totalLines,
+      totalBytes,
+      outputLines: totalLines,
+      outputBytes: totalBytes,
+      lastLinePartial: false,
+      firstLineExceedsLimit: false,
+      maxLines,
+      maxBytes
+    };
+  }
+  const outputLinesArr = [];
+  let outputBytesCount = 0;
+  let truncatedBy = "lines";
+  let lastLinePartial = false;
+  for (let i = lines.length - 1;i >= 0 && outputLinesArr.length < maxLines; i--) {
+    const line = lines[i];
+    const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+    if (outputBytesCount + lineBytes > maxBytes) {
+      truncatedBy = "bytes";
+      if (outputLinesArr.length === 0) {
+        const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+        outputLinesArr.unshift(truncatedLine);
+        outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+        lastLinePartial = true;
+      }
+      break;
+    }
+    outputLinesArr.unshift(line);
+    outputBytesCount += lineBytes;
+  }
+  if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+    truncatedBy = "lines";
+  }
+  const outputContent = outputLinesArr.join(`
+`);
+  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  return {
+    content: outputContent,
+    truncated: true,
+    truncatedBy,
+    totalLines,
+    totalBytes,
+    outputLines: outputLinesArr.length,
+    outputBytes: finalOutputBytes,
+    lastLinePartial,
+    firstLineExceedsLimit: false,
+    maxLines,
+    maxBytes
+  };
+}
+function truncateStringToBytesFromEnd(str, maxBytes) {
+  const buf = Buffer.from(str, "utf-8");
+  if (buf.length <= maxBytes) {
+    return str;
+  }
+  let start = buf.length - maxBytes;
+  while (start < buf.length && (buf[start] & 192) === 128) {
+    start++;
+  }
+  return buf.slice(start).toString("utf-8");
+}
+function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+  if (line.length <= maxChars) {
+    return { text: line, wasTruncated: false };
+  }
+  return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+
+// src/tools/bash.ts
+function getTempFilePath() {
+  return join6(tmpdir(), `tarsk-bash-${randomBytes2(8).toString("hex")}.log`);
+}
+var bashSchema = Type.Object({
+  command: Type.String({ description: "Bash command to execute" }),
+  timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" }))
+});
+var defaultBashOperations = {
+  exec: (command, cwd, { onData, signal, timeout, env }) => {
+    return new Promise((resolve, reject) => {
+      const { shell, args } = getShellConfig();
+      if (!existsSync3(cwd)) {
+        reject(new Error(`Working directory does not exist: ${cwd}`));
+        return;
+      }
+      const child = spawn5(shell, [...args, command], {
+        cwd,
+        detached: true,
+        env: env ?? getShellEnv(),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let timedOut = false;
+      let timeoutHandle;
+      if (timeout !== undefined && timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          timedOut = true;
+          if (child.pid)
+            killProcessTree(child.pid);
+        }, timeout * 1000);
+      }
+      if (child.stdout)
+        child.stdout.on("data", onData);
+      if (child.stderr)
+        child.stderr.on("data", onData);
+      child.on("error", (err) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
+        if (signal)
+          signal.removeEventListener("abort", onAbort);
+        reject(err);
+      });
+      const onAbort = () => {
+        if (child.pid)
+          killProcessTree(child.pid);
+      };
+      if (signal) {
+        if (signal.aborted)
+          onAbort();
+        else
+          signal.addEventListener("abort", onAbort, { once: true });
+      }
+      child.on("close", (code) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
+        if (signal)
+          signal.removeEventListener("abort", onAbort);
+        if (signal?.aborted) {
+          reject(new Error("aborted"));
+          return;
+        }
+        if (timedOut) {
+          reject(new Error(`timeout:${timeout}`));
+          return;
+        }
+        resolve({ exitCode: code });
+      });
+    });
+  }
+};
+function createBashTool(cwd, options) {
+  const ops = options?.operations ?? defaultBashOperations;
+  const commandPrefix = options?.commandPrefix;
+  return {
+    name: "bash",
+    label: "bash",
+    description: `Execute a bash command in the current working directory. Output truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. Optionally provide a timeout in seconds.`,
+    parameters: bashSchema,
+    execute: async (_toolCallId, { command, timeout }, signal, onUpdate) => {
+      const resolvedCommand = commandPrefix ? `${commandPrefix}
+${command}` : command;
+      return new Promise((resolve, reject) => {
+        let tempFilePath;
+        let tempFileStream;
+        let totalBytes = 0;
+        const chunks = [];
+        let chunksBytes = 0;
+        const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
+        const handleData = (data) => {
+          totalBytes += data.length;
+          if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+            tempFilePath = getTempFilePath();
+            tempFileStream = createWriteStream(tempFilePath);
+            for (const chunk of chunks)
+              tempFileStream.write(chunk);
+          }
+          if (tempFileStream)
+            tempFileStream.write(data);
+          chunks.push(data);
+          chunksBytes += data.length;
+          while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+            const removed = chunks.shift();
+            chunksBytes -= removed.length;
+          }
+          if (onUpdate) {
+            const fullText = Buffer.concat(chunks).toString("utf-8");
+            const truncation = truncateTail(fullText);
+            onUpdate({
+              content: [{ type: "text", text: truncation.content || "" }],
+              details: {
+                truncation: truncation.truncated ? truncation : undefined,
+                fullOutputPath: tempFilePath
+              }
+            });
+          }
+        };
+        ops.exec(resolvedCommand, cwd, { onData: handleData, signal, timeout, env: getShellEnv() }).then(({ exitCode }) => {
+          if (tempFileStream)
+            tempFileStream.end();
+          const fullOutput = Buffer.concat(chunks).toString("utf-8");
+          const truncation = truncateTail(fullOutput);
+          let outputText = truncation.content || "(no output)";
+          let details;
+          if (truncation.truncated) {
+            details = { truncation, fullOutputPath: tempFilePath };
+            const startLine = truncation.totalLines - truncation.outputLines + 1;
+            const endLine = truncation.totalLines;
+            if (truncation.lastLinePartial) {
+              outputText += `
+
+[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}. Full output: ${tempFilePath}]`;
+            } else if (truncation.truncatedBy === "lines") {
+              outputText += `
+
+[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+            } else {
+              outputText += `
+
+[Showing lines ${startLine}-${endLine} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+            }
+          }
+          if (exitCode !== 0 && exitCode !== null) {
+            outputText += `
+
+Command exited with code ${exitCode}`;
+            reject(new Error(outputText));
+          } else {
+            resolve({ content: [{ type: "text", text: outputText }], details });
+          }
+        }).catch((err) => {
+          if (tempFileStream)
+            tempFileStream.end();
+          const output = Buffer.concat(chunks).toString("utf-8");
+          if (err.message === "aborted") {
+            reject(new Error(output ? `${output}
+
+Command aborted` : "Command aborted"));
+          } else if (err.message.startsWith("timeout:")) {
+            const secs = err.message.split(":")[1];
+            reject(new Error(output ? `${output}
+
+Command timed out after ${secs} seconds` : `Command timed out after ${secs} seconds`));
+          } else {
+            reject(err);
+          }
+        });
+      });
+    }
+  };
+}
+var bashTool = createBashTool(process.cwd());
+
+// src/tools/edit.ts
+import { Type as Type2 } from "@sinclair/typebox";
+import { constants as constants2 } from "fs";
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+
+// src/tools/edit-diff.ts
+import * as Diff from "diff";
+function detectLineEnding(content) {
+  const crlfIdx = content.indexOf(`\r
+`);
+  const lfIdx = content.indexOf(`
+`);
+  if (lfIdx === -1)
+    return `
+`;
+  if (crlfIdx === -1)
+    return `
+`;
+  return crlfIdx < lfIdx ? `\r
+` : `
+`;
+}
+function normalizeToLF(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function restoreLineEndings(text, ending) {
+  return ending === `\r
+` ? text.replace(/\n/g, `\r
+`) : text;
+}
+function normalizeForFuzzyMatch(text) {
+  return text.split(`
+`).map((line) => line.trimEnd()).join(`
+`).replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function fuzzyFindText(content, oldText) {
+  const exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1) {
+    return {
+      found: true,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+  if (fuzzyIndex === -1) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content
+    };
+  }
+  return {
+    found: true,
+    index: fuzzyIndex,
+    matchLength: fuzzyOldText.length,
+    usedFuzzyMatch: true,
+    contentForReplacement: fuzzyContent
+  };
+}
+function stripBom(content) {
+  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  const parts = Diff.diffLines(oldContent, newContent);
+  const output = [];
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  const maxLineNum = Math.max(oldLines.length, newLines.length);
+  const lineNumWidth = String(maxLineNum).length;
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split(`
+`);
+    if (raw[raw.length - 1] === "") {
+      raw.pop();
+    }
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined) {
+        firstChangedLine = newLineNum;
+      }
+      for (const line of raw) {
+        if (part.added) {
+          output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
+          newLineNum++;
+        } else {
+          output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+    } else {
+      const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+      if (lastWasChange || nextPartIsChange) {
+        let linesToShow = raw;
+        let skipStart = 0;
+        let skipEnd = 0;
+        if (!lastWasChange) {
+          skipStart = Math.max(0, raw.length - contextLines);
+          linesToShow = raw.slice(skipStart);
+        }
+        if (!nextPartIsChange && linesToShow.length > contextLines) {
+          skipEnd = linesToShow.length - contextLines;
+          linesToShow = linesToShow.slice(0, contextLines);
+        }
+        if (skipStart > 0) {
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+          oldLineNum += skipStart;
+          newLineNum += skipStart;
+        }
+        for (const line of linesToShow) {
+          output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+        if (skipEnd > 0) {
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+          oldLineNum += skipEnd;
+          newLineNum += skipEnd;
+        }
+      } else {
+        oldLineNum += raw.length;
+        newLineNum += raw.length;
+      }
+      lastWasChange = false;
+    }
+  }
+  return { diff: output.join(`
+`), firstChangedLine };
+}
+
+// src/tools/path-utils.ts
+import { accessSync, constants } from "node:fs";
+import * as os from "node:os";
+import { isAbsolute, resolve as resolvePath } from "node:path";
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+var NARROW_NO_BREAK_SPACE = " ";
+function normalizeUnicodeSpaces(str) {
+  return str.replace(UNICODE_SPACES, " ");
+}
+function tryMacOSScreenshotPath(filePath) {
+  return filePath.replace(/ (AM|PM)\./g, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNFDVariant(filePath) {
+  return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+  return filePath.replace(/'/g, "’");
+}
+function fileExists(filePath) {
+  try {
+    accessSync(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeAtPrefix(filePath) {
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+function expandPath(filePath) {
+  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+  if (normalized === "~") {
+    return os.homedir();
+  }
+  if (normalized.startsWith("~/")) {
+    return os.homedir() + normalized.slice(1);
+  }
+  return normalized;
+}
+function resolveToCwd(filePath, cwd) {
+  const expanded = expandPath(filePath);
+  if (isAbsolute(expanded)) {
+    return expanded;
+  }
+  return resolvePath(cwd, expanded);
+}
+function resolveReadPath(filePath, cwd) {
+  const resolved = resolveToCwd(filePath, cwd);
+  if (fileExists(resolved)) {
+    return resolved;
+  }
+  const amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && fileExists(amPmVariant)) {
+    return amPmVariant;
+  }
+  const nfdVariant = tryNFDVariant(resolved);
+  if (nfdVariant !== resolved && fileExists(nfdVariant)) {
+    return nfdVariant;
+  }
+  const curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && fileExists(curlyVariant)) {
+    return curlyVariant;
+  }
+  const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
+    return nfdCurlyVariant;
+  }
+  return resolved;
+}
+
+// src/tools/edit.ts
+var editSchema = Type2.Object({
+  path: Type2.String({ description: "Path to the file to edit (relative or absolute)" }),
+  oldText: Type2.String({ description: "Exact text to find and replace (must match exactly)" }),
+  newText: Type2.String({ description: "New text to replace the old text with" })
+});
+var defaultEditOperations = {
+  readFile: (path) => fsReadFile(path),
+  writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+  access: (path) => fsAccess(path, constants2.R_OK | constants2.W_OK)
+};
+function createEditTool(cwd, options) {
+  const ops = options?.operations ?? defaultEditOperations;
+  return {
+    name: "edit",
+    label: "edit",
+    description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+    parameters: editSchema,
+    execute: async (_toolCallId, { path, oldText, newText }, signal) => {
+      const absolutePath = resolveToCwd(path, cwd);
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let aborted = false;
+        const onAbort = () => {
+          aborted = true;
+          reject(new Error("Operation aborted"));
+        };
+        if (signal)
+          signal.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            try {
+              await ops.access(absolutePath);
+            } catch {
+              if (signal)
+                signal.removeEventListener("abort", onAbort);
+              reject(new Error(`File not found: ${path}`));
+              return;
+            }
+            if (aborted)
+              return;
+            const buffer = await ops.readFile(absolutePath);
+            const rawContent = buffer.toString("utf-8");
+            if (aborted)
+              return;
+            const { bom, text: content } = stripBom(rawContent);
+            const originalEnding = detectLineEnding(content);
+            const normalizedContent = normalizeToLF(content);
+            const normalizedOldText = normalizeToLF(oldText);
+            const normalizedNewText = normalizeToLF(newText);
+            const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+            if (!matchResult.found) {
+              if (signal)
+                signal.removeEventListener("abort", onAbort);
+              reject(new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`));
+              return;
+            }
+            const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+            const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+            const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+            if (occurrences > 1) {
+              if (signal)
+                signal.removeEventListener("abort", onAbort);
+              reject(new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`));
+              return;
+            }
+            if (aborted)
+              return;
+            const baseContent = matchResult.contentForReplacement;
+            const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
+            if (baseContent === newContent) {
+              if (signal)
+                signal.removeEventListener("abort", onAbort);
+              reject(new Error(`No changes made to ${path}. The replacement produced identical content.`));
+              return;
+            }
+            const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+            await ops.writeFile(absolutePath, finalContent);
+            if (aborted)
+              return;
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            const diffResult = generateDiffString(baseContent, newContent);
+            resolve({
+              content: [{ type: "text", text: `Successfully replaced text in ${path}.` }],
+              details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+            });
+          } catch (error) {
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            if (!aborted)
+              reject(error);
+          }
+        })();
+      });
+    }
+  };
+}
+var editTool = createEditTool(process.cwd());
+
+// src/tools/find.ts
+import { Type as Type3 } from "@sinclair/typebox";
+import { existsSync as existsSync4 } from "fs";
+import path from "path";
+import { globSync } from "glob";
+var findSchema = Type3.Object({
+  pattern: Type3.String({
+    description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"
+  }),
+  path: Type3.Optional(Type3.String({ description: "Directory to search in (default: current directory)" })),
+  limit: Type3.Optional(Type3.Number({ description: "Maximum number of results (default: 1000)" }))
+});
+var DEFAULT_LIMIT = 1000;
+var defaultFindOperations = {
+  exists: existsSync4,
+  glob: async (pattern, searchCwd, { ignore, limit }) => {
+    const results = [];
+    try {
+      const found = globSync(pattern, {
+        cwd: searchCwd,
+        dot: true,
+        ignore: ["**/node_modules/**", "**/.git/**", ...ignore],
+        mark: false
+      });
+      for (let i = 0;i < Math.min(found.length, limit); i++) {
+        results.push(path.join(searchCwd, found[i]));
+      }
+    } catch {}
+    return results;
+  }
+};
+function createFindTool(cwd, options) {
+  const customOps = options?.operations;
+  return {
+    name: "find",
+    label: "find",
+    description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Output truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB.`,
+    parameters: findSchema,
+    execute: async (_toolCallId, { pattern, path: searchDir, limit }, signal) => {
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        const onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            const searchPath = resolveToCwd(searchDir || ".", cwd);
+            const effectiveLimit = limit ?? DEFAULT_LIMIT;
+            const ops = customOps ?? defaultFindOperations;
+            if (!await ops.exists(searchPath)) {
+              reject(new Error(`Path not found: ${searchPath}`));
+              return;
+            }
+            const results = await ops.glob(pattern, searchPath, {
+              ignore: ["**/node_modules/**", "**/.git/**"],
+              limit: effectiveLimit
+            });
+            signal?.removeEventListener("abort", onAbort);
+            if (results.length === 0) {
+              resolve({
+                content: [{ type: "text", text: "No files found matching pattern" }],
+                details: undefined
+              });
+              return;
+            }
+            const relativized = results.map((p) => {
+              if (p.startsWith(searchPath + path.sep) || p.startsWith(searchPath + "/")) {
+                return p.slice(searchPath.length + 1).replace(/\\/g, "/");
+              }
+              return path.relative(searchPath, p).replace(/\\/g, "/");
+            });
+            const resultLimitReached = relativized.length >= effectiveLimit;
+            const rawOutput = relativized.join(`
+`);
+            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+            let resultOutput = truncation.content;
+            const details = {};
+            const notices = [];
+            if (resultLimitReached) {
+              notices.push(`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+              details.resultLimitReached = effectiveLimit;
+            }
+            if (truncation.truncated) {
+              notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+              details.truncation = truncation;
+            }
+            if (notices.length > 0)
+              resultOutput += `
+
+[${notices.join(". ")}]`;
+            resolve({
+              content: [{ type: "text", text: resultOutput }],
+              details: Object.keys(details).length > 0 ? details : undefined
+            });
+          } catch (e) {
+            signal?.removeEventListener("abort", onAbort);
+            reject(e);
+          }
+        })();
+      });
+    }
+  };
+}
+var findTool = createFindTool(process.cwd());
+
+// src/tools/grep.ts
+import { createInterface as createInterface2 } from "node:readline";
+import { Type as Type4 } from "@sinclair/typebox";
+import { spawn as spawn6 } from "child_process";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import path2 from "path";
+
+// src/tools/resolve-bin.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+function resolveBin(name) {
+  return new Promise((resolve) => {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const args = process.platform === "win32" ? [name + ".exe", name] : [name];
+    try {
+      const result = spawnSync4(cmd, args, { encoding: "utf-8", timeout: 5000 });
+      if (result.status === 0 && result.stdout) {
+        const first = result.stdout.trim().split(/\r?\n/)[0]?.trim();
+        if (first) {
+          resolve(first);
+          return;
+        }
+      }
+    } catch {}
+    resolve(null);
+  });
+}
+
+// src/tools/grep.ts
+var grepSchema = Type4.Object({
+  pattern: Type4.String({ description: "Search pattern (regex or literal string)" }),
+  path: Type4.Optional(Type4.String({ description: "Directory or file to search (default: current directory)" })),
+  glob: Type4.Optional(Type4.String({ description: "Filter files by glob pattern, e.g. '*.ts'" })),
+  ignoreCase: Type4.Optional(Type4.Boolean({ description: "Case-insensitive search (default: false)" })),
+  literal: Type4.Optional(Type4.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })),
+  context: Type4.Optional(Type4.Number({ description: "Number of lines before/after each match (default: 0)" })),
+  limit: Type4.Optional(Type4.Number({ description: "Maximum number of matches to return (default: 100)" }))
+});
+var DEFAULT_LIMIT2 = 100;
+var defaultGrepOperations = {
+  isDirectory: (p) => statSync(p).isDirectory(),
+  readFile: (p) => readFileSync2(p, "utf-8")
+};
+function createGrepTool(cwd, options) {
+  const customOps = options?.operations;
+  return {
+    name: "grep",
+    label: "grep",
+    description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output truncated to ${DEFAULT_LIMIT2} matches or ${DEFAULT_MAX_BYTES / 1024}KB. Long lines truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+    parameters: grepSchema,
+    execute: async (_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit }, signal) => {
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let settled = false;
+        const settle = (fn) => {
+          if (!settled) {
+            settled = true;
+            fn();
+          }
+        };
+        (async () => {
+          try {
+            const rgPath = await resolveBin("rg");
+            if (!rgPath) {
+              settle(() => reject(new Error("ripgrep (rg) is not available. Install rg or add it to PATH.")));
+              return;
+            }
+            const searchPath = resolveToCwd(searchDir || ".", cwd);
+            const ops = customOps ?? defaultGrepOperations;
+            let isDirectory;
+            try {
+              isDirectory = await ops.isDirectory(searchPath);
+            } catch {
+              settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+              return;
+            }
+            const contextValue = context && context > 0 ? context : 0;
+            const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2);
+            const formatPath = (filePath) => {
+              if (isDirectory) {
+                const relative2 = path2.relative(searchPath, filePath);
+                if (relative2 && !relative2.startsWith("..")) {
+                  return relative2.replace(/\\/g, "/");
+                }
+              }
+              return path2.basename(filePath);
+            };
+            const fileCache = new Map;
+            const getFileLines = async (filePath) => {
+              let lines = fileCache.get(filePath);
+              if (!lines) {
+                try {
+                  const content = await ops.readFile(filePath);
+                  lines = content.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).split(`
+`);
+                } catch {
+                  lines = [];
+                }
+                fileCache.set(filePath, lines);
+              }
+              return lines;
+            };
+            const args = ["--json", "--line-number", "--color=never", "--hidden"];
+            if (ignoreCase)
+              args.push("--ignore-case");
+            if (literal)
+              args.push("--fixed-strings");
+            if (glob)
+              args.push("--glob", glob);
+            args.push(pattern, searchPath);
+            const child = spawn6(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+            const rl = createInterface2({ input: child.stdout });
+            let stderr = "";
+            let matchCount = 0;
+            let matchLimitReached = false;
+            let linesTruncated = false;
+            let aborted = false;
+            let killedDueToLimit = false;
+            const outputLines = [];
+            const cleanup = () => {
+              rl.close();
+              signal?.removeEventListener("abort", onAbort);
+            };
+            const stopChild = (dueToLimit = false) => {
+              if (!child.killed) {
+                killedDueToLimit = dueToLimit;
+                child.kill();
+              }
+            };
+            const onAbort = () => {
+              aborted = true;
+              stopChild();
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            child.stderr?.on("data", (chunk) => {
+              stderr += chunk.toString();
+            });
+            const formatBlock = async (filePath, lineNumber) => {
+              const relativePath = formatPath(filePath);
+              const lines = await getFileLines(filePath);
+              if (!lines.length) {
+                return [`${relativePath}:${lineNumber}: (unable to read file)`];
+              }
+              const block = [];
+              const start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber;
+              const end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
+              for (let current = start;current <= end; current++) {
+                const lineText = lines[current - 1] ?? "";
+                const sanitized = lineText.replace(/\r/g, "");
+                const { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                if (wasTruncated)
+                  linesTruncated = true;
+                const isMatchLine = current === lineNumber;
+                if (isMatchLine) {
+                  block.push(`${relativePath}:${current}: ${truncatedText}`);
+                } else {
+                  block.push(`${relativePath}-${current}- ${truncatedText}`);
+                }
+              }
+              return block;
+            };
+            const matches = [];
+            rl.on("line", (line) => {
+              if (!line.trim() || matchCount >= effectiveLimit)
+                return;
+              try {
+                const event = JSON.parse(line);
+                if (event.type === "match") {
+                  matchCount++;
+                  const filePath = event.data?.path?.text;
+                  const lineNumber = event.data?.line_number;
+                  if (filePath != null && typeof lineNumber === "number") {
+                    matches.push({ filePath, lineNumber });
+                  }
+                  if (matchCount >= effectiveLimit) {
+                    matchLimitReached = true;
+                    stopChild(true);
+                  }
+                }
+              } catch {}
+            });
+            child.on("error", (error) => {
+              cleanup();
+              settle(() => reject(new Error(`Failed to run ripgrep: ${error.message}`)));
+            });
+            child.on("close", async (code) => {
+              cleanup();
+              if (aborted) {
+                settle(() => reject(new Error("Operation aborted")));
+                return;
+              }
+              if (!killedDueToLimit && code !== 0 && code !== 1) {
+                settle(() => reject(new Error(stderr.trim() || `ripgrep exited with code ${code}`)));
+                return;
+              }
+              if (matchCount === 0) {
+                settle(() => resolve({ content: [{ type: "text", text: "No matches found" }], details: undefined }));
+                return;
+              }
+              for (const match of matches) {
+                const block = await formatBlock(match.filePath, match.lineNumber);
+                outputLines.push(...block);
+              }
+              const rawOutput = outputLines.join(`
+`);
+              const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+              let output = truncation.content;
+              const details = {};
+              const notices = [];
+              if (matchLimitReached) {
+                notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`);
+                details.matchLimitReached = effectiveLimit;
+              }
+              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(() => resolve({
+                content: [{ type: "text", text: output }],
+                details: Object.keys(details).length > 0 ? details : undefined
+              }));
+            });
+          } catch (err) {
+            settle(() => reject(err));
+          }
+        })();
+      });
+    }
+  };
+}
+var grepTool = createGrepTool(process.cwd());
+
+// src/tools/ls.ts
+import { Type as Type5 } from "@sinclair/typebox";
+import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
+import nodePath from "path";
+var lsSchema = Type5.Object({
+  path: Type5.Optional(Type5.String({ description: "Directory to list (default: current directory)" })),
+  limit: Type5.Optional(Type5.Number({ description: "Maximum number of entries to return (default: 500)" }))
+});
+var DEFAULT_LIMIT3 = 500;
+var defaultLsOperations = {
+  exists: existsSync5,
+  stat: statSync2,
+  readdir: readdirSync
+};
+function createLsTool(cwd, options) {
+  const ops = options?.operations ?? defaultLsOperations;
+  return {
+    name: "ls",
+    label: "ls",
+    description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Output truncated to ${DEFAULT_LIMIT3} entries or ${DEFAULT_MAX_BYTES / 1024}KB.`,
+    parameters: lsSchema,
+    execute: async (_toolCallId, { path: dirPathArg, limit }, signal) => {
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        const onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            const dirPath = resolveToCwd(dirPathArg || ".", cwd);
+            const effectiveLimit = limit ?? DEFAULT_LIMIT3;
+            if (!await ops.exists(dirPath)) {
+              reject(new Error(`Path not found: ${dirPath}`));
+              return;
+            }
+            const stat = await ops.stat(dirPath);
+            if (!stat.isDirectory()) {
+              reject(new Error(`Not a directory: ${dirPath}`));
+              return;
+            }
+            let entries;
+            try {
+              entries = await ops.readdir(dirPath);
+            } catch (e) {
+              reject(new Error(`Cannot read directory: ${e instanceof Error ? e.message : String(e)}`));
+              return;
+            }
+            entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            const results = [];
+            let entryLimitReached = false;
+            for (const entry of entries) {
+              if (results.length >= effectiveLimit) {
+                entryLimitReached = true;
+                break;
+              }
+              const fullPath = nodePath.join(dirPath, entry);
+              try {
+                const entryStat = await ops.stat(fullPath);
+                results.push(entry + (entryStat.isDirectory() ? "/" : ""));
+              } catch {
+                continue;
+              }
+            }
+            signal?.removeEventListener("abort", onAbort);
+            if (results.length === 0) {
+              resolve({ content: [{ type: "text", text: "(empty directory)" }], details: undefined });
+              return;
+            }
+            const rawOutput = results.join(`
+`);
+            const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+            let output = truncation.content;
+            const details = {};
+            const notices = [];
+            if (entryLimitReached) {
+              notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+              details.entryLimitReached = effectiveLimit;
+            }
+            if (truncation.truncated) {
+              notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+              details.truncation = truncation;
+            }
+            if (notices.length > 0)
+              output += `
+
+[${notices.join(". ")}]`;
+            resolve({
+              content: [{ type: "text", text: output }],
+              details: Object.keys(details).length > 0 ? details : undefined
+            });
+          } catch (e) {
+            signal?.removeEventListener("abort", onAbort);
+            reject(e);
+          }
+        })();
+      });
+    }
+  };
+}
+var lsTool = createLsTool(process.cwd());
+
+// src/tools/read.ts
+import { Type as Type6 } from "@sinclair/typebox";
+import { constants as constants3 } from "fs";
+import { access as fsAccess2, readFile as fsReadFile2 } from "fs/promises";
+var readSchema = Type6.Object({
+  path: Type6.String({ description: "Path to the file to read (relative or absolute)" }),
+  offset: Type6.Optional(Type6.Number({ description: "Line number to start reading from (1-indexed)" })),
+  limit: Type6.Optional(Type6.Number({ description: "Maximum number of lines to read" }))
+});
+var defaultReadOperations = {
+  readFile: (path3) => fsReadFile2(path3),
+  access: (path3) => fsAccess2(path3, constants3.R_OK)
+};
+function createReadTool(cwd, options) {
+  const ops = options?.operations ?? defaultReadOperations;
+  return {
+    name: "read",
+    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: path3, offset, limit }, signal) => {
+      const absolutePath = resolveReadPath(path3, cwd);
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let aborted = false;
+        const onAbort = () => {
+          aborted = true;
+          reject(new Error("Operation aborted"));
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        (async () => {
+          try {
+            await ops.access(absolutePath);
+            if (aborted)
+              return;
+            const buffer = await ops.readFile(absolutePath);
+            const textContent = buffer.toString("utf-8");
+            const allLines = textContent.split(`
+`);
+            const totalFileLines = allLines.length;
+            const startLine = offset ? Math.max(0, offset - 1) : 0;
+            const startLineDisplay = startLine + 1;
+            if (startLine >= allLines.length) {
+              throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+            }
+            let selectedContent;
+            let userLimitedLines;
+            if (limit !== undefined) {
+              const endLine = Math.min(startLine + limit, allLines.length);
+              selectedContent = allLines.slice(startLine, endLine).join(`
+`);
+              userLimitedLines = endLine - startLine;
+            } else {
+              selectedContent = allLines.slice(startLine).join(`
+`);
+            }
+            const truncation = truncateHead(selectedContent);
+            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' ${path3} | head -c ${DEFAULT_MAX_BYTES}]`;
+              details = { truncation };
+            } else if (truncation.truncated) {
+              const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+              const nextOffset = endLineDisplay + 1;
+              outputText = truncation.content;
+              if (truncation.truncatedBy === "lines") {
+                outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+              } else {
+                outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
+              }
+              details = { truncation };
+            } else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+              const remaining = allLines.length - (startLine + userLimitedLines);
+              const nextOffset = startLine + userLimitedLines + 1;
+              outputText = truncation.content;
+              outputText += `
+
+[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+            } else {
+              outputText = truncation.content;
+            }
+            if (aborted)
+              return;
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            resolve({ content: [{ type: "text", text: outputText }], details });
+          } catch (error) {
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            if (!aborted)
+              reject(error);
+          }
+        })();
+      });
+    }
+  };
 }
+var readTool = createReadTool(process.cwd());
 
-// src/managers/neovate-executor.ts
-import {
-  createSession
-} from "@neovate/code";
-import { resolve } from "path";
+// src/tools/write.ts
+import { Type as Type7 } from "@sinclair/typebox";
+import { mkdir as fsMkdir, writeFile as fsWriteFile2 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+var writeSchema = Type7.Object({
+  path: Type7.String({ description: "Path to the file to write (relative or absolute)" }),
+  content: Type7.String({ description: "Content to write to the file" })
+});
+var defaultWriteOperations = {
+  writeFile: (path3, content) => fsWriteFile2(path3, content, "utf-8"),
+  mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => {})
+};
+function createWriteTool(cwd, options) {
+  const ops = options?.operations ?? defaultWriteOperations;
+  return {
+    name: "write",
+    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: path3, content }, signal) => {
+      const absolutePath = resolveToCwd(path3, cwd);
+      const dir = dirname4(absolutePath);
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let aborted = false;
+        const onAbort = () => {
+          aborted = true;
+          reject(new Error("Operation aborted"));
+        };
+        if (signal)
+          signal.addEventListener("abort", onAbort, { once: true });
+        (async () => {
+          try {
+            await ops.mkdir(dir);
+            if (aborted)
+              return;
+            await ops.writeFile(absolutePath, content);
+            if (aborted)
+              return;
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            resolve({
+              content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path3}` }],
+              details: undefined
+            });
+          } catch (error) {
+            if (signal)
+              signal.removeEventListener("abort", onAbort);
+            if (!aborted)
+              reject(error);
+          }
+        })();
+      });
+    }
+  };
+}
+var writeTool = createWriteTool(process.cwd());
+
+// src/tools/index.ts
+function createCodingTools(cwd, options) {
+  return [
+    createReadTool(cwd, options?.read),
+    createBashTool(cwd, options?.bash),
+    createEditTool(cwd),
+    createWriteTool(cwd)
+  ];
+}
 
 // src/provider.ts
 var PROVIDERS = [
@@ -2043,33 +3423,79 @@ var PROVIDERS = [
   }
 ];
 
-// src/managers/neovate-executor.ts
+// src/managers/pi-executor.ts
+var PROVIDER_NAME_TO_PI = {
+  anthropic: "anthropic",
+  openai: "openai",
+  google: "google",
+  groq: "groq",
+  cerebras: "cerebras",
+  xai: "xai",
+  openrouter: "openrouter",
+  "github copilot": "github-copilot",
+  minimax: "minimax",
+  "kimi coding plan": "kimi-coding",
+  "hugging face": "huggingface",
+  codex: "openai-codex",
+  mistral: "mistral"
+};
+function determineApiType(apiUrl) {
+  if (apiUrl.includes("/anthropic/"))
+    return "anthropic-messages";
+  if (apiUrl.includes("api.anthropic.com"))
+    return "anthropic-messages";
+  return "openai-completions";
+}
+function resolveModel(providerName, modelId, providerConfig) {
+  const piProvider = PROVIDER_NAME_TO_PI[providerName.toLowerCase()];
+  if (piProvider) {
+    try {
+      return getModel(piProvider, modelId);
+    } catch {}
+  }
+  const baseUrl = providerConfig.api;
+  if (!baseUrl) {
+    throw new Error(`No API URL configured for provider: ${providerName}`);
+  }
+  const apiType = determineApiType(baseUrl);
+  return {
+    id: modelId,
+    name: modelId,
+    api: apiType,
+    provider: providerName.toLowerCase(),
+    baseUrl,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128000,
+    maxTokens: 16384
+  };
+}
+function extractTextFromAssistantMessage(msg) {
+  return msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
 var getErrorCode = (error) => {
   if (error && typeof error === "object" && "code" in error) {
     const code = error.code;
-    if (typeof code === "string") {
+    if (typeof code === "string")
       return code;
-    }
   }
   return;
 };
 
-class NeovateExecutorImpl {
+class PiExecutorImpl {
   metadataManager;
   constructor(metadataManager) {
     this.metadataManager = metadataManager;
   }
   async* execute(userPrompt, context) {
-    let session = null;
     try {
       const providerName = context.provider;
       if (!providerName) {
-        console.error(`[ai] No provider specified in context`);
         throw new Error("No provider specified in execution context");
       }
       let model = context.model?.trim();
       if (!model) {
-        console.warn("[ai] No model provided in context, using default");
         throw new Error("No model specified in execution context");
       }
       model = model.replace(`${providerName.toLowerCase()}/`, "");
@@ -2095,59 +3521,126 @@ class NeovateExecutorImpl {
         throw new Error(`No API key found for provider: ${providerName}. ` + `Set ${providerConfig.keyName || "an API key"} in environment variables or configuration.`);
       }
       console.log(`[ai] API key source for ${providerName}: ${apiKeySource}`);
-      const api = providerConfig.api;
-      if (!api) {
-        throw new Error(`No API URL configured for provider: ${providerName}`);
-      }
-      const providers = {
-        tarsk: {
-          api,
-          options: { apiKey },
-          models: { [model]: model }
-        }
-      };
-      const sessionConfig = {
-        model: `tarsk/${model}`,
-        cwd,
-        productName: "Tarsk.io",
-        providers
-      };
-      console.log("[ai] Creating session:", JSON.stringify(sessionConfig));
-      console.log("[ai] Creating session with model:", model);
-      console.log("[ai] Session config has model:", !!sessionConfig.model);
-      session = await createSession(sessionConfig);
-      if (!session) {
-        throw new Error("Failed to create session: createSession returned falsy value");
-      }
-      console.log("[ai] Session created:", session.sessionId);
-      console.log("[ai] Sending prompt to session...");
-      await session.send(userPrompt);
-      console.log("[ai] Prompt sent, waiting for responses...");
-      let lastMessageContent = null;
-      for await (const msg of session.receive()) {
-        const contentLength = typeof msg?.content === "string" ? msg.content.length : undefined;
-        console.log("[ai] Received msg:", { type: msg?.type, contentLength });
-        console.log("[ai] Msg:", msg);
-        if (msg?.type === "message") {
-          const messageContent = typeof msg.text === "string" ? msg.text : typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-          lastMessageContent = messageContent;
-          yield {
+      const resolvedModel = resolveModel(providerName, model, providerConfig);
+      console.log("[ai] Resolved model:", {
+        id: resolvedModel.id,
+        api: resolvedModel.api,
+        provider: resolvedModel.provider
+      });
+      const tools = createCodingTools(cwd);
+      const agent = new Agent({
+        initialState: {
+          systemPrompt: "You are a helpful coding assistant. You have access to read, bash, edit, and write tools. Use them to explore and modify the codebase as needed.",
+          model: resolvedModel,
+          tools
+        },
+        getApiKey: async () => apiKey
+      });
+      const queue = [];
+      let resolver = null;
+      let done = false;
+      let finalContent = "";
+      let errorOccurred = false;
+      const unsubscribe = agent.subscribe((event) => {
+        if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+          const delta = event.assistantMessageEvent.delta;
+          finalContent += delta;
+          queue.push({
             type: "message",
-            role: msg.role || "assistant",
-            content: messageContent
-          };
-        } else if (msg?.type === "result") {
-          const resultContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-          if (resultContent !== lastMessageContent) {
-            yield {
-              type: "result",
-              content: resultContent
-            };
+            role: "assistant",
+            content: delta
+          });
+        } else if (event.type === "tool_execution_start") {
+          queue.push({
+            type: "message",
+            role: "tool",
+            content: JSON.stringify([
+              {
+                type: "tool_use",
+                name: event.toolName,
+                id: event.toolCallId,
+                input: event.args
+              }
+            ])
+          });
+        } else if (event.type === "tool_execution_end") {
+          const resultContent = event.result?.content?.filter((b) => b.type === "text").map((b) => b.text || "").join("") || JSON.stringify(event.result);
+          queue.push({
+            type: "message",
+            role: "tool",
+            content: JSON.stringify([
+              {
+                type: "tool-result",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                content: resultContent,
+                isError: event.isError
+              }
+            ])
+          });
+        } else if (event.type === "agent_end") {
+          const messages = event.messages;
+          const lastAssistant = [...messages].reverse().find((m) => ("role" in m) && m.role === "assistant");
+          if (lastAssistant) {
+            const extracted = extractTextFromAssistantMessage(lastAssistant);
+            if (extracted && extracted !== finalContent) {
+              finalContent = extracted;
+            }
+          }
+        }
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      const promptDone = agent.prompt(userPrompt).then(() => {
+        done = true;
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      }).catch((err) => {
+        if (!errorOccurred) {
+          errorOccurred = true;
+          const errMessage = err instanceof Error ? err.message : String(err);
+          queue.push({
+            type: "error",
+            content: errMessage,
+            error: {
+              code: getErrorCode(err) || "EXECUTION_ERROR",
+              message: errMessage,
+              details: {
+                stack: err instanceof Error ? err.stack : undefined
+              }
+            }
+          });
+        }
+        done = true;
+        if (resolver) {
+          resolver();
+          resolver = null;
+        }
+      });
+      try {
+        while (!done || queue.length > 0) {
+          if (queue.length > 0) {
+            yield queue.shift();
           } else {
-            console.log("[ai] Skipping duplicate result event (same as message)");
+            await new Promise((r) => {
+              resolver = r;
+            });
           }
-          break;
         }
+        await promptDone;
+        if (!errorOccurred && finalContent) {
+          yield {
+            type: "result",
+            content: finalContent
+          };
+        }
+      } finally {
+        unsubscribe();
+        agent.abort();
       }
     } catch (error) {
       console.error("[ai] Error during execution:", error);
@@ -2178,22 +3671,13 @@ class NeovateExecutorImpl {
           details: { stack: errStack, originalError: errDetails }
         }
       };
-    } finally {
-      if (session) {
-        try {
-          await session.close?.();
-          console.log("[ai] Session closed");
-        } catch (closeError) {
-          console.error("[ai] Error closing session:", closeError);
-        }
-      }
     }
   }
 }
 
 // src/managers/conversation-manager.ts
 import { promises as fs2 } from "fs";
-import { join as join6, dirname as dirname4 } from "path";
+import { join as join7, dirname as dirname5 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var CONVERSATION_FILE = "conversation-history.json";
 
@@ -2267,13 +3751,13 @@ class ConversationManagerImpl {
   }
   async saveConversationHistory(threadPath, history) {
     const filePath = this.getConversationFilePath(threadPath);
-    await fs2.mkdir(dirname4(filePath), { recursive: true });
+    await fs2.mkdir(dirname5(filePath), { recursive: true });
     await fs2.writeFile(filePath, JSON.stringify(history, null, 2), "utf-8");
   }
   getConversationFilePath(threadPath) {
     const threadId = threadPath.split(/[\\/]/).pop() || "unknown";
-    const conversationsDir = join6(this.metadataDir, "conversations");
-    return join6(conversationsDir, threadId, CONVERSATION_FILE);
+    const conversationsDir = join7(this.metadataDir, "conversations");
+    return join7(conversationsDir, threadId, CONVERSATION_FILE);
   }
 }
 
@@ -2961,7 +4445,7 @@ function delay(ms) {
 }
 
 // src/routes/chat.ts
-function createChatRoutes(threadManager, neovateExecutor, conversationManager, processingStateManager) {
+function createChatRoutes(threadManager, agentExecutor, conversationManager, processingStateManager) {
   const router = new Hono3;
   router.post("/", async (c) => {
     try {
@@ -3061,7 +4545,7 @@ User: ${content}` : content;
         const capturedEvents = [];
         let fullContent = "";
         try {
-          for await (const event of neovateExecutor.execute(promptWithContext, context)) {
+          for await (const event of agentExecutor.execute(promptWithContext, context)) {
             capturedEvents.push(event);
             if (event.type === "message" && event.content) {
               fullContent += event.content;
@@ -3278,9 +4762,9 @@ async function getAIHubMixCredits(apiKey) {
 
 // src/utils/env-manager.ts
 import { promises as fs3 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function updateEnvFile(keyNames) {
-  const envPath = join7(process.cwd(), ".env");
+  const envPath = join8(process.cwd(), ".env");
   let content = "";
   try {
     content = await fs3.readFile(envPath, "utf-8");
@@ -3311,7 +4795,7 @@ async function updateEnvFile(keyNames) {
 `, "utf-8");
 }
 async function readEnvFile() {
-  const envPath = join7(process.cwd(), ".env");
+  const envPath = join8(process.cwd(), ".env");
   const envMap = {};
   try {
     const content = await fs3.readFile(envPath, "utf-8");
@@ -4097,9 +5581,106 @@ function createModelRoutes(metadataManager) {
 
 // src/routes/git.ts
 import { Hono as Hono6 } from "hono";
-import { spawn as spawn4 } from "child_process";
-import { resolve as resolve2 } from "path";
-import { createSession as createSession2 } from "@neovate/code";
+import { spawn as spawn7 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { join as join10 } from "path";
+import { isAbsolute as isAbsolute2, normalize, resolve as resolve2 } from "path";
+
+// src/paths.ts
+import { join as join9 } from "path";
+import { homedir as homedir2 } from "os";
+var APP_SUPPORT_DIR = join9(homedir2(), "Library", "Application Support", "Tarsk");
+var DATA_DIR = join9(APP_SUPPORT_DIR, "data");
+function getDataDir() {
+  return DATA_DIR;
+}
+
+// src/routes/git.ts
+import {
+  completeSimple,
+  getModel as getModel2
+} from "@mariozechner/pi-ai";
+var PROVIDER_NAME_TO_PI2 = {
+  anthropic: "anthropic",
+  openai: "openai",
+  google: "google",
+  groq: "groq",
+  cerebras: "cerebras",
+  xai: "xai",
+  openrouter: "openrouter",
+  "github copilot": "github-copilot",
+  minimax: "minimax",
+  "kimi coding plan": "kimi-coding",
+  "hugging face": "huggingface",
+  codex: "openai-codex",
+  mistral: "mistral"
+};
+function resolveModelForGit(providerName, modelId, apiUrl) {
+  const piProvider = PROVIDER_NAME_TO_PI2[providerName.toLowerCase()];
+  if (piProvider) {
+    try {
+      return getModel2(piProvider, modelId);
+    } catch {}
+  }
+  if (!apiUrl)
+    throw new Error(`No API URL configured for provider: ${providerName}`);
+  const apiType = apiUrl.includes("/anthropic/") || apiUrl.includes("api.anthropic.com") ? "anthropic-messages" : "openai-completions";
+  return {
+    id: modelId,
+    name: modelId,
+    api: apiType,
+    provider: providerName.toLowerCase(),
+    baseUrl: apiUrl,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128000,
+    maxTokens: 16384
+  };
+}
+function resolveProviderAndKey(metadataProviderKeys, preferredProvider) {
+  if (preferredProvider) {
+    const prov = PROVIDERS.find((p) => p.name.toLowerCase() === preferredProvider.toLowerCase());
+    if (prov) {
+      const envKey = prov.keyName ? process.env[prov.keyName] : undefined;
+      const key = envKey || metadataProviderKeys[prov.name];
+      if (key)
+        return { provider: prov, apiKey: key };
+    }
+  }
+  const providerPriority = ["Anthropic", "OpenAI", "OpenRouter", "Groq", "DeepSeek"];
+  for (const name of providerPriority) {
+    const prov = PROVIDERS.find((p) => p.name === name);
+    if (prov?.keyName) {
+      const envKey = process.env[prov.keyName];
+      if (envKey)
+        return { provider: prov, apiKey: envKey };
+    }
+  }
+  for (const name of providerPriority) {
+    const prov = PROVIDERS.find((p) => p.name === name);
+    if (prov && metadataProviderKeys[prov.name]) {
+      return { provider: prov, apiKey: metadataProviderKeys[prov.name] };
+    }
+  }
+  for (const prov of PROVIDERS) {
+    if (prov.api && prov.keyName) {
+      const envKey = process.env[prov.keyName];
+      if (envKey)
+        return { provider: prov, apiKey: envKey };
+      if (metadataProviderKeys[prov.name])
+        return { provider: prov, apiKey: metadataProviderKeys[prov.name] };
+    }
+  }
+  return null;
+}
+var DEFAULT_MODEL_MAP = {
+  Anthropic: "claude-3-5-sonnet-20241022",
+  OpenAI: "gpt-4o-mini",
+  OpenRouter: "anthropic/claude-3.5-sonnet",
+  Groq: "llama-3.3-70b-versatile",
+  DeepSeek: "deepseek-chat"
+};
 async function generateCommitMessageWithAI(diff, metadataManager, model, provider) {
   const truncatedDiff = diff.length > 3000 ? diff.substring(0, 3000) + `
 ...(truncated)` : diff;
@@ -4114,126 +5695,61 @@ Git diff:
 ${truncatedDiff}
 
 Generate only the commit message, nothing else:`;
-  let session = null;
   try {
     const providerKeys = await metadataManager.getProviderKeys();
-    let selectedProvider = null;
-    let apiKey = null;
-    let selectedModel = model;
-    if (provider) {
-      selectedProvider = PROVIDERS.find((p) => p.name.toLowerCase() === provider.toLowerCase()) || null;
-      if (selectedProvider) {
-        if (selectedProvider.keyName) {
-          apiKey = process.env[selectedProvider.keyName] || null;
-        }
-        if (!apiKey) {
-          apiKey = providerKeys[selectedProvider.name] || null;
-        }
-      }
-    }
-    if (!selectedProvider || !apiKey) {
-      const providerPriority = ["Anthropic", "OpenAI", "OpenRouter", "Groq", "DeepSeek"];
-      for (const providerName of providerPriority) {
-        const prov = PROVIDERS.find((p) => p.name === providerName);
-        if (prov?.keyName) {
-          const envKey = process.env[prov.keyName];
-          if (envKey) {
-            selectedProvider = prov;
-            apiKey = envKey;
-            break;
-          }
-        }
-      }
-      if (!selectedProvider || !apiKey) {
-        for (const providerName of providerPriority) {
-          const prov = PROVIDERS.find((p) => p.name === providerName);
-          if (prov && providerKeys[prov.name]) {
-            selectedProvider = prov;
-            apiKey = providerKeys[prov.name];
-            break;
-          }
-        }
-      }
-      if (!selectedProvider || !apiKey) {
-        for (const prov of PROVIDERS) {
-          if (prov.api && prov.keyName) {
-            const envKey = process.env[prov.keyName];
-            if (envKey) {
-              selectedProvider = prov;
-              apiKey = envKey;
-              break;
-            }
-            if (providerKeys[prov.name]) {
-              selectedProvider = prov;
-              apiKey = providerKeys[prov.name];
-              break;
-            }
-          }
-        }
-      }
-      if (!selectedModel) {
-        const modelMap = {
-          Anthropic: "claude-3-5-sonnet-20241022",
-          OpenAI: "gpt-4o-mini",
-          OpenRouter: "anthropic/claude-3.5-sonnet",
-          Groq: "llama-3.3-70b-versatile",
-          DeepSeek: "deepseek-chat"
-        };
-        selectedModel = modelMap[selectedProvider?.name || ""] || "default";
-      }
-    }
-    if (!selectedProvider || !apiKey || !selectedProvider.api) {
+    const resolved = resolveProviderAndKey(providerKeys, provider);
+    if (!resolved || !resolved.provider.api) {
       throw new Error("No AI provider configured. Please configure an API key in settings.");
     }
-    if (selectedModel && selectedProvider) {
-      selectedModel = selectedModel.replace(`${selectedProvider.name.toLowerCase()}/`, "");
-    }
-    const finalModel = selectedModel || "default";
-    const providers = {
-      tarsk: {
-        api: selectedProvider.api,
-        options: { apiKey },
-        models: { [finalModel]: finalModel }
-      }
-    };
-    const sessionConfig = {
-      model: `tarsk/${finalModel}`,
-      cwd: process.cwd(),
-      productName: "Tarsk.io",
-      providers
-    };
-    session = await createSession2(sessionConfig);
-    await session.send(prompt);
-    let commitMessage = "";
-    for await (const msg of session.receive()) {
-      if (msg?.type === "message" || msg?.type === "result") {
-        const content = typeof msg.text === "string" ? msg.text : typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-        commitMessage = content.trim();
-        if (msg?.type === "result")
-          break;
-      }
+    let selectedModel = model;
+    if (selectedModel) {
+      selectedModel = selectedModel.replace(`${resolved.provider.name.toLowerCase()}/`, "");
+    } else {
+      selectedModel = DEFAULT_MODEL_MAP[resolved.provider.name] || "default";
     }
+    const resolvedModel = resolveModelForGit(resolved.provider.name, selectedModel, resolved.provider.api);
+    const response = await completeSimple(resolvedModel, {
+      messages: [{ role: "user", content: prompt }]
+    }, { apiKey: resolved.apiKey });
+    let commitMessage = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
     commitMessage = commitMessage.replace(/^["']|["']$/g, "").trim();
     return commitMessage || "Update files";
   } catch (error) {
     console.error("Failed to generate AI commit message:", error);
     return "Update files";
-  } finally {
-    if (session) {
-      try {
-        await session.close?.();
-      } catch (closeError) {
-        console.error("Error closing session:", closeError);
-      }
-    }
   }
 }
+function resolveThreadPath(repoPath) {
+  const base = isAbsolute2(repoPath) ? repoPath : resolve2(getDataDir(), repoPath);
+  return normalize(base);
+}
+function getGitRoot(cwd) {
+  return new Promise((resolveRoot, reject) => {
+    const proc = spawn7("git", ["rev-parse", "--show-toplevel"], { cwd });
+    let out = "";
+    let err = "";
+    proc.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      err += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolveRoot(out.trim());
+      } else {
+        reject(new Error(err.trim() || "Not a git repository"));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
 function createGitRoutes(metadataManager) {
   const router = new Hono6;
   router.get("/username", async (c) => {
     try {
       const name = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["config", "user.name"]);
+        const proc = spawn7("git", ["config", "user.name"]);
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -4267,9 +5783,23 @@ function createGitRoutes(metadataManager) {
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      if (!existsSync6(absolutePath)) {
+        return c.json({
+          error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
+        }, 400);
+      }
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return c.json({
+          error: `Path is not a git repository: ${absolutePath}. ${msg}`
+        }, 400);
+      }
       const { hasChanges, changedFilesCount } = await new Promise((resolve3) => {
-        const proc = spawn4("git", ["status", "--porcelain"], { cwd: absolutePath });
+        const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4285,7 +5815,7 @@ function createGitRoutes(metadataManager) {
         proc.on("error", () => resolve3({ hasChanges: false, changedFilesCount: 0 }));
       });
       const currentBranch = await new Promise((resolve3) => {
-        const proc = spawn4("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: absolutePath });
+        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4296,7 +5826,7 @@ function createGitRoutes(metadataManager) {
         proc.on("error", () => resolve3(""));
       });
       const hasUnpushedCommits = await new Promise((resolve3) => {
-        const proc = spawn4("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], { cwd: absolutePath });
+        const proc = spawn7("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4327,9 +5857,15 @@ function createGitRoutes(metadataManager) {
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
       const statusOutput = await new Promise((resolve3) => {
-        const proc = spawn4("git", ["status", "--porcelain"], { cwd: absolutePath });
+        const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4370,7 +5906,7 @@ function createGitRoutes(metadataManager) {
         const hunks = [];
         if (file.status === "deleted") {
           const content = await new Promise((resolve3) => {
-            const proc = spawn4("git", ["show", `HEAD:${file.path}`], { cwd: absolutePath });
+            const proc = spawn7("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
@@ -4382,13 +5918,13 @@ function createGitRoutes(metadataManager) {
         } else if (file.status === "added" && file.path.startsWith("(new)")) {
           const fs4 = await import("fs");
           try {
-            newContent = fs4.readFileSync(`${absolutePath}/${file.path.replace("(new) ", "")}`, "utf-8");
+            newContent = fs4.readFileSync(resolve2(gitRoot, file.path.replace("(new) ", "")), "utf-8");
           } catch {
             newContent = "";
           }
         } else {
           const diffOutput = await new Promise((resolve3) => {
-            const proc = spawn4("git", file.status === "added" ? ["diff", "--cached", "--", file.path] : ["diff", "HEAD", "--", file.path], { cwd: absolutePath });
+            const proc = spawn7("git", file.status === "added" ? ["diff", "--cached", "--", file.path] : ["diff", "HEAD", "--", file.path], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
@@ -4402,7 +5938,7 @@ function createGitRoutes(metadataManager) {
           let oldLineNum = 0;
           let newLineNum = 0;
           const oldContentOutput = await new Promise((resolve3) => {
-            const proc = spawn4("git", ["show", `HEAD:${file.path}`], { cwd: absolutePath });
+            const proc = spawn7("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
@@ -4413,7 +5949,7 @@ function createGitRoutes(metadataManager) {
           oldContent = oldContentOutput;
           const fs4 = await import("fs");
           try {
-            newContent = fs4.readFileSync(`${absolutePath}/${file.path}`, "utf-8");
+            newContent = fs4.readFileSync(resolve2(gitRoot, file.path), "utf-8");
           } catch {
             newContent = "";
           }
@@ -4479,17 +6015,58 @@ function createGitRoutes(metadataManager) {
       const threadId = c.req.param("threadId");
       const body = await c.req.json().catch(() => ({}));
       const { model, provider } = body;
+      process.stdout.write(`[generate-commit-message] threadId=${threadId}
+`);
       const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
       if (!thread) {
+        process.stdout.write(`[generate-commit-message] thread not found
+`);
         return c.json({ error: "Thread not found" }, 404);
       }
       const repoPath = thread.path;
       if (!repoPath) {
+        process.stdout.write(`[generate-commit-message] thread path missing
+`);
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
-      const diff = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["diff", "--cached"], { cwd: absolutePath });
+      const absolutePath = resolveThreadPath(repoPath);
+      process.stdout.write(`[generate-commit-message] resolved path: ${absolutePath}
+`);
+      if (!existsSync6(absolutePath)) {
+        process.stdout.write(`[generate-commit-message] path does not exist: ${absolutePath}
+`);
+        return c.json({
+          error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
+        }, 400);
+      }
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+        process.stdout.write(`[generate-commit-message] git root: ${gitRoot}
+`);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.stdout.write(`[generate-commit-message] not a git repo: ${msg}
+`);
+        return c.json({
+          error: `Path is not a git repository: ${absolutePath}. ${msg}`
+        }, 400);
+      }
+      let diff = await new Promise((resolveDiff, reject) => {
+        const runUnstagedDiff = () => {
+          process.stdout.write(`[generate-commit-message] using unstaged diff (git diff)
+`);
+          const proc2 = spawn7("git", ["diff"], { cwd: gitRoot });
+          let out2 = "";
+          proc2.stdout.on("data", (d) => {
+            out2 += d.toString();
+          });
+          proc2.on("close", (code) => {
+            resolveDiff(code === 0 ? out2 : "");
+          });
+          proc2.on("error", reject);
+        };
+        const proc = spawn7("git", ["diff", "--cached"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -4501,26 +6078,91 @@ function createGitRoutes(metadataManager) {
         proc.on("close", (code) => {
           if (code === 0) {
             if (!out.trim()) {
-              const proc2 = spawn4("git", ["diff"], { cwd: absolutePath });
-              let out2 = "";
-              proc2.stdout.on("data", (d) => {
-                out2 += d.toString();
-              });
-              proc2.on("close", () => resolve3(out2));
-              proc2.on("error", reject);
+              process.stdout.write(`[generate-commit-message] no staged changes, checking unstaged
+`);
+              runUnstagedDiff();
             } else {
-              resolve3(out);
+              process.stdout.write(`[generate-commit-message] using staged diff (git diff --cached)
+`);
+              resolveDiff(out);
             }
           } else {
-            reject(new Error(err || "Failed to get git diff"));
+            const noHead = /HEAD|revision|unknown revision/i.test(err);
+            if (noHead) {
+              process.stdout.write(`[generate-commit-message] no HEAD (new repo), using working tree diff
+`);
+              runUnstagedDiff();
+            } else {
+              reject(new Error(err || "Failed to get git diff"));
+            }
           }
         });
         proc.on("error", reject);
       });
       if (!diff.trim()) {
+        const statusOut = await new Promise((resolveStatus) => {
+          const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
+          let out = "";
+          proc.stdout.on("data", (d) => {
+            out += d.toString();
+          });
+          proc.on("close", () => resolveStatus(out));
+          proc.on("error", () => resolveStatus(""));
+        });
+        const lines = statusOut.trim().split(`
+`).filter((l) => l.length > 0);
+        const untrackedPaths = [];
+        for (const line of lines) {
+          const code = line.slice(0, 2);
+          const pathPart = line.slice(3).trim();
+          if (code === "??") {
+            untrackedPaths.push(pathPart);
+          }
+        }
+        if (untrackedPaths.length > 0) {
+          process.stdout.write(`[generate-commit-message] building diff for ${untrackedPaths.length} untracked file(s)
+`);
+          const parts = [];
+          const maxFileSize = 1e5;
+          for (const relPath of untrackedPaths) {
+            const fullPath = join10(gitRoot, relPath);
+            if (!existsSync6(fullPath))
+              continue;
+            try {
+              if (statSync3(fullPath).isDirectory())
+                continue;
+              const content = readFileSync3(fullPath, "utf-8");
+              const safeContent = content.length > maxFileSize ? content.slice(0, maxFileSize) + `
+...(truncated)` : content;
+              const linesForDiff = safeContent.split(/\r?\n/).map((l) => `+${l}`).join(`
+`);
+              parts.push(`diff --git a/${relPath} b/${relPath}
+new file mode 100644
+--- /dev/null
++++ b/${relPath}
+${linesForDiff}`);
+            } catch {
+              parts.push(`diff --git a/${relPath} b/${relPath}
+new file mode 100644
+(Binary or unreadable file: ${relPath})`);
+            }
+          }
+          if (parts.length > 0) {
+            diff = parts.join(`
+`);
+          }
+        }
+      }
+      if (!diff.trim()) {
+        process.stdout.write(`[generate-commit-message] no changes to generate message for
+`);
         return c.json({ error: "No changes to generate commit message for" }, 400);
       }
+      process.stdout.write(`[generate-commit-message] diff length=${diff.length} chars, generating message with AI
+`);
       const commitMessage = await generateCommitMessageWithAI(diff, metadataManager, model, provider);
+      process.stdout.write(`[generate-commit-message] generated: ${commitMessage.replace(/\n/g, " ")}
+`);
       return c.json({ message: commitMessage });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to generate commit message";
@@ -4543,9 +6185,15 @@ function createGitRoutes(metadataManager) {
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
       await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["add", "-A"], { cwd: absolutePath });
+        const proc = spawn7("git", ["add", "-A"], { cwd: gitRoot });
         proc.on("close", (code) => {
           if (code === 0)
             resolve3();
@@ -4555,7 +6203,7 @@ function createGitRoutes(metadataManager) {
         proc.on("error", reject);
       });
       await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["commit", "-m", message], { cwd: absolutePath });
+        const proc = spawn7("git", ["commit", "-m", message], { cwd: gitRoot });
         proc.on("close", (code) => {
           if (code === 0)
             resolve3();
@@ -4581,9 +6229,15 @@ function createGitRoutes(metadataManager) {
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
       const currentBranch = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: absolutePath });
+        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4592,7 +6246,7 @@ function createGitRoutes(metadataManager) {
         proc.on("error", reject);
       });
       await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["push", "-u", "origin", currentBranch], { cwd: absolutePath });
+        const proc = spawn7("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
         let err = "";
         proc.stderr.on("data", (d) => {
           err += d.toString();
@@ -4624,9 +6278,24 @@ function createGitRoutes(metadataManager) {
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
-      const diff = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["diff", "HEAD"], { cwd: absolutePath });
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
+      const diff = await new Promise((resolveDiff, reject) => {
+        const runPlainDiff = () => {
+          const proc2 = spawn7("git", ["diff"], { cwd: gitRoot });
+          let out2 = "";
+          proc2.stdout.on("data", (d) => {
+            out2 += d.toString();
+          });
+          proc2.on("close", () => resolveDiff(out2));
+          proc2.on("error", reject);
+        };
+        const proc = spawn7("git", ["diff", "HEAD"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -4637,9 +6306,13 @@ function createGitRoutes(metadataManager) {
         });
         proc.on("close", (code) => {
           if (code === 0) {
-            resolve3(out);
+            resolveDiff(out);
           } else {
-            reject(new Error(err || "Failed to get git diff"));
+            const noHead = /HEAD|revision|unknown revision/i.test(err);
+            if (noHead)
+              runPlainDiff();
+            else
+              reject(new Error(err || "Failed to get git diff"));
           }
         });
         proc.on("error", reject);
@@ -4661,119 +6334,27 @@ ${truncatedDiff}
 Generate the response in this exact format:
 TITLE: <title here>
 DESCRIPTION: <description here>`;
-      let session = null;
-      try {
-        const providerKeys = await metadataManager.getProviderKeys();
-        let selectedProvider = null;
-        let apiKey = null;
-        let selectedModel = model;
-        if (provider) {
-          selectedProvider = PROVIDERS.find((p) => p.name.toLowerCase() === provider.toLowerCase()) || null;
-          if (selectedProvider) {
-            if (selectedProvider.keyName) {
-              apiKey = process.env[selectedProvider.keyName] || null;
-            }
-            if (!apiKey) {
-              apiKey = providerKeys[selectedProvider.name] || null;
-            }
-          }
-        }
-        if (!selectedProvider || !apiKey) {
-          const providerPriority = ["Anthropic", "OpenAI", "OpenRouter", "Groq", "DeepSeek"];
-          for (const providerName of providerPriority) {
-            const prov = PROVIDERS.find((p) => p.name === providerName);
-            if (prov?.keyName) {
-              const envKey = process.env[prov.keyName];
-              if (envKey) {
-                selectedProvider = prov;
-                apiKey = envKey;
-                break;
-              }
-            }
-          }
-          if (!selectedProvider || !apiKey) {
-            for (const providerName of providerPriority) {
-              const prov = PROVIDERS.find((p) => p.name === providerName);
-              if (prov && providerKeys[prov.name]) {
-                selectedProvider = prov;
-                apiKey = providerKeys[prov.name];
-                break;
-              }
-            }
-          }
-          if (!selectedProvider || !apiKey) {
-            for (const prov of PROVIDERS) {
-              if (prov.api && prov.keyName) {
-                const envKey = process.env[prov.keyName];
-                if (envKey) {
-                  selectedProvider = prov;
-                  apiKey = envKey;
-                  break;
-                }
-                if (providerKeys[prov.name]) {
-                  selectedProvider = prov;
-                  apiKey = providerKeys[prov.name];
-                  break;
-                }
-              }
-            }
-          }
-          if (!selectedModel) {
-            const modelMap = {
-              Anthropic: "claude-3-5-sonnet-20241022",
-              OpenAI: "gpt-4o-mini",
-              OpenRouter: "anthropic/claude-3.5-sonnet",
-              Groq: "llama-3.3-70b-versatile",
-              DeepSeek: "deepseek-chat"
-            };
-            selectedModel = modelMap[selectedProvider?.name || ""] || "default";
-          }
-        }
-        if (!selectedProvider || !apiKey || !selectedProvider.api) {
-          throw new Error("No AI provider configured. Please configure an API key in settings.");
-        }
-        if (selectedModel && selectedProvider) {
-          selectedModel = selectedModel.replace(`${selectedProvider.name.toLowerCase()}/`, "");
-        }
-        const finalModel = selectedModel || "default";
-        const providers = {
-          tarsk: {
-            api: selectedProvider.api,
-            options: { apiKey },
-            models: { [finalModel]: finalModel }
-          }
-        };
-        const sessionConfig = {
-          model: `tarsk/${finalModel}`,
-          cwd: process.cwd(),
-          productName: "Tarsk.io",
-          providers
-        };
-        session = await createSession2(sessionConfig);
-        await session.send(prompt);
-        let prInfo = "";
-        for await (const msg of session.receive()) {
-          if (msg?.type === "message" || msg?.type === "result") {
-            const content = typeof msg.text === "string" ? msg.text : typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-            prInfo = content.trim();
-            if (msg?.type === "result")
-              break;
-          }
-        }
-        const titleMatch = prInfo.match(/TITLE:\s*(.+?)(?:\nDESCRIPTION:|$)/s);
-        const descriptionMatch = prInfo.match(/DESCRIPTION:\s*(.+?)$/s);
-        const title = titleMatch ? titleMatch[1].trim() : "Update";
-        const description = descriptionMatch ? descriptionMatch[1].trim() : "";
-        return c.json({ title, description });
-      } finally {
-        if (session) {
-          try {
-            await session.close?.();
-          } catch (closeError) {
-            console.error("Error closing session:", closeError);
-          }
-        }
-      }
+      const providerKeys = await metadataManager.getProviderKeys();
+      const resolved = resolveProviderAndKey(providerKeys, provider);
+      if (!resolved || !resolved.provider.api) {
+        throw new Error("No AI provider configured. Please configure an API key in settings.");
+      }
+      let selectedModel = model;
+      if (selectedModel) {
+        selectedModel = selectedModel.replace(`${resolved.provider.name.toLowerCase()}/`, "");
+      } else {
+        selectedModel = DEFAULT_MODEL_MAP[resolved.provider.name] || "default";
+      }
+      const resolvedModel = resolveModelForGit(resolved.provider.name, selectedModel, resolved.provider.api);
+      const response = await completeSimple(resolvedModel, {
+        messages: [{ role: "user", content: prompt }]
+      }, { apiKey: resolved.apiKey });
+      const prInfo = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+      const titleMatch = prInfo.match(/TITLE:\s*(.+?)(?:\nDESCRIPTION:|$)/s);
+      const descriptionMatch = prInfo.match(/DESCRIPTION:\s*(.+?)$/s);
+      const title = titleMatch ? titleMatch[1].trim() : "Update";
+      const description = descriptionMatch ? descriptionMatch[1].trim() : "";
+      return c.json({ title, description });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to generate PR info";
       return c.json({ error: message }, 500);
@@ -4791,9 +6372,15 @@ DESCRIPTION: <description here>`;
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
       const commits = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"], { cwd: absolutePath });
+        const proc = spawn7("git", ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -4841,9 +6428,15 @@ DESCRIPTION: <description here>`;
       if (!repoPath) {
         return c.json({ error: "Thread path not found" }, 404);
       }
-      const absolutePath = resolve2(repoPath);
+      const absolutePath = resolveThreadPath(repoPath);
+      let gitRoot;
+      try {
+        gitRoot = await getGitRoot(absolutePath);
+      } catch {
+        return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
+      }
       const currentBranch = await new Promise((resolve3, reject) => {
-        const proc = spawn4("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: absolutePath });
+        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -4853,7 +6446,7 @@ DESCRIPTION: <description here>`;
       });
       const prUrl = await new Promise((resolve3, reject) => {
         const args = ["pr", "create", "--title", title || currentBranch, "--body", description || ""];
-        const proc = spawn4("gh", args, { cwd: absolutePath });
+        const proc = spawn7("gh", args, { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -4974,7 +6567,7 @@ function createRunRoutes(projectManager) {
 
 // src/routes/onboarding.ts
 import { Hono as Hono8 } from "hono";
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 function createOnboardingRoutes(metadataManager) {
   const router = new Hono8;
   router.get("/status", async (c) => {
@@ -4989,7 +6582,7 @@ function createOnboardingRoutes(metadataManager) {
   router.get("/git-check", async (c) => {
     try {
       const gitInstalled = await new Promise((resolve3) => {
-        const proc = spawn5("git", ["--version"]);
+        const proc = spawn8("git", ["--version"]);
         let _err = "";
         proc.stderr.on("data", (d) => {
           _err += d.toString();
@@ -5066,18 +6659,9 @@ function createScaffoldRoutes(projectManager) {
   return router;
 }
 
-// src/paths.ts
-import { join as join8 } from "path";
-import { homedir } from "os";
-var APP_SUPPORT_DIR = join8(homedir(), "Library", "Application Support", "Tarsk");
-var DATA_DIR = join8(APP_SUPPORT_DIR, "data");
-function getDataDir() {
-  return DATA_DIR;
-}
-
 // src/index.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname3 = path.dirname(__filename2);
+var __dirname3 = path3.dirname(__filename2);
 var args = process.argv.slice(2);
 var isDebug = args.includes("--debug");
 var shouldOpenBrowser = args.includes("--open");
@@ -5093,7 +6677,7 @@ var processingStateManager = new ProcessingStateManagerImpl;
 var projectManager = new ProjectManagerImpl(dataDir, metadataManager, gitManager, processingStateManager);
 var threadManager = new ThreadManagerImpl(metadataManager, gitManager, processingStateManager);
 var conversationManager = new ConversationManagerImpl(dataDir);
-var neovateExecutor = new NeovateExecutorImpl(metadataManager);
+var agentExecutor = new PiExecutorImpl(metadataManager);
 await metadataManager.initialize();
 app.get("/health", (c) => {
   return c.json({
@@ -5115,14 +6699,14 @@ app.get("/api/threads/processing", (c) => {
 app.route("/api/projects", createProjectRoutes(projectManager, threadManager));
 app.route("/api/projects", createRunRoutes(projectManager));
 app.route("/api/threads", createThreadRoutes(threadManager, gitManager, conversationManager));
-app.route("/api/chat", createChatRoutes(threadManager, neovateExecutor, conversationManager, processingStateManager));
+app.route("/api/chat", createChatRoutes(threadManager, agentExecutor, conversationManager, processingStateManager));
 app.route("/api/providers", createProviderRoutes(metadataManager));
 app.route("/api/models", createModelRoutes(metadataManager));
 app.route("/api/git", createGitRoutes(metadataManager));
 app.route("/api/onboarding", createOnboardingRoutes(metadataManager));
 app.route("/api/scaffold", createScaffoldRoutes(projectManager));
-var publicDir = path.join(__dirname3, "public");
-var staticRoot = path.relative(process.cwd(), publicDir);
+var publicDir = path3.join(__dirname3, "public");
+var staticRoot = path3.relative(process.cwd(), publicDir);
 app.use("/*", async (c, next) => {
   if (c.req.path.startsWith("/api/")) {
     return next();
@@ -5134,7 +6718,7 @@ app.get("*", async (c, next) => {
     return next();
   }
   return serveStatic({
-    path: path.relative(process.cwd(), path.join(publicDir, "index.html"))
+    path: path3.relative(process.cwd(), path3.join(publicDir, "index.html"))
   })(c, next);
 });
 app.all("*", (c) => {