tarsk 0.5.62 → 0.5.63

package/dist/index.js

@@ -413,6 +413,12 @@ function billablePromptTokensFromCounts(inputTokens, cacheReadTokens = 0, cacheW
   }
   return input + cachedInput;
 }
+function calculatePromptCacheHitRate(cacheReadTokens, totalPromptTokens) {
+  if (!Number.isFinite(cacheReadTokens) || !Number.isFinite(totalPromptTokens) || totalPromptTokens <= 0 || cacheReadTokens <= 0) {
+    return 0;
+  }
+  return Math.min(1, cacheReadTokens / totalPromptTokens);
+}
 function billableTotalTokens(usage) {
   if ((usage.totalTokens ?? 0) > 0) {
     return usage.totalTokens ?? 0;
@@ -2037,7 +2043,7 @@ function toBufferedLogData(data) {
   return toJsonSafeLogData(data);
 }
 function createLogger(event) {
-  function log123(level, message, data) {
+  function log124(level, message, data) {
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       level,
@@ -2053,10 +2059,10 @@ function createLogger(event) {
     emit(entry);
   }
   return {
-    debug: (message, data) => log123(LogLevel.DEBUG, message, data),
-    info: (message, data) => log123(LogLevel.INFO, message, data),
-    warn: (message, data) => log123(LogLevel.WARN, message, data),
-    error: (message, data) => log123(LogLevel.ERROR, message, data)
+    debug: (message, data) => log124(LogLevel.DEBUG, message, data),
+    info: (message, data) => log124(LogLevel.INFO, message, data),
+    warn: (message, data) => log124(LogLevel.WARN, message, data),
+    error: (message, data) => log124(LogLevel.ERROR, message, data)
   };
 }
 var LogLevel, LOG_BUFFER_CAPACITY, LOG_BUFFER_MIN_LEVEL, LOG_LEVEL_NAMES, globalLevel, transports, nextBufferId, logBuffer, logBufferListeners, LEVEL_CONSOLE;
@@ -13755,7 +13761,8 @@ async function initializeSchema(db) {
         setupScript TEXT,
         runCommand TEXT,
         commitMethod TEXT,
-        eventToken TEXT
+        eventToken TEXT,
+        projectIcon TEXT
       )
     `);
     await db.execute(`
@@ -14646,6 +14653,14 @@ async function runMigrations(db) {
         `ALTER TABLE projects ADD COLUMN useBuiltInBrowser INTEGER NOT NULL DEFAULT 1`
       );
     }
+    const projectIconProjectsInfo = await db.execute(`PRAGMA table_info(projects)`);
+    const hasProjectIcon = projectIconProjectsInfo.rows.some(
+      (col) => col.name === "projectIcon"
+    );
+    if (!hasProjectIcon) {
+      tarskDebugLog("[db] Running migration: Adding projectIcon column to projects");
+      await db.execute(`ALTER TABLE projects ADD COLUMN projectIcon TEXT`);
+    }
     const smartJsProjectsInfo = await db.execute(`PRAGMA table_info(projects)`);
     const hasSmartJsEnabled = smartJsProjectsInfo.rows.some(
       (col) => col.name === "smartJsEnabled"
@@ -18780,7 +18795,7 @@ var init_bash = __esm({
 var edit_default;
 var init_edit = __esm({
   "src/tools/descriptions/edit.md"() {
-    edit_default = "Replace exact text (unique unless replaceAll/line/occurrenceIndex). Prefer fewer large hunks; batch with replacements. Prefer mutate-in-place imports (`import { A }` \u2192 `import { A, B }`) over insert-before-anchor \u2014 insert-style retries duplicate lines and are skipped when already present. On ambiguous match, retry with occurrenceIndex/line (error lists ready values)\u2014not re-read or longer oldText. Parallelize independent files.\n";
+    edit_default = "Replace exact text (unique unless replaceAll/line/occurrenceIndex). Prefer fewer large hunks; batch with replacements. Prefer mutate-in-place imports (`import { A }` \u2192 `import { A, B }`) over insert-before-anchor \u2014 insert-style retries duplicate lines and are skipped when already present. On ambiguous match, retry with occurrenceIndex/line (error lists ready values)\u2014not re-read or longer oldText. Parallelize independent files. Concurrent edits to the same path are rejected \u2014 batch those hunks in one replacements call.\n";
   }
 });
 
@@ -18796,7 +18811,7 @@ var init_read = __esm({
 var todo_default;
 var init_todo = __esm({
   "src/tools/descriptions/todo.md"() {
-    todo_default = "Break work into todos (~2 when planning). Actions: add/update/list/delete/learnings. Status pending\u2192working\u2192done\u2014update each item as you go; don't batch-complete or leave pending while working it. Mark verify/check todos done only after checks pass. Ralph: passes=true after checks; learnings appends progress.txt. list = full checklist; update/delete = short ack.\n";
+    todo_default = "Break work into todos (~2 when planning). Actions: add (descriptions), update/delete (ids), list, learnings. Status pending\u2192working\u2192done. Mark each item done as soon as that work is finished; don't batch-complete, leave an item pending while working it, or send the final reply while any todo is pending or working. Mark verify/check todos done only after checks pass. Ralph: passes=true after checks; learnings appends progress.txt. list = full checklist; update/delete = short ack plus remaining incomplete items.\n";
   }
 });
 
@@ -19517,8 +19532,8 @@ async function runRipgrepMulti(args2, searchPaths, cwd) {
 function sortFilesByMtime(files) {
   return files.map((filePath) => {
     try {
-      const stat8 = statSync3(filePath);
-      return [filePath, stat8.mtimeMs ?? 0];
+      const stat9 = statSync3(filePath);
+      return [filePath, stat9.mtimeMs ?? 0];
     } catch {
       return [filePath, 0];
     }
@@ -19645,7 +19660,7 @@ function createRipGrepTool(cwd) {
   return {
     name: "grep",
     label: "Search",
-    description: "Search file contents with ripgrep (regex). Supports output_mode (content, files_with_matches, count), glob/type filters, context lines, multiline patterns, and pagination via head_limit/offset. Respects .gitignore. Scope with path (file or directory); use glob for extension/name filters (e.g. *.ts, **/*.tsx)\u2014not as a substitute for path.",
+    description: GREP_TOOL_DESCRIPTION,
     parameters: ripGrepSchema,
     execute: async (_toolCallId, input, signal) => {
       if (signal?.aborted) {
@@ -19719,7 +19734,7 @@ ${output}`;
     details: Object.keys(details).length > 0 ? details : void 0
   };
 }
-var VCS_DIRECTORIES_TO_EXCLUDE, DEFAULT_HEAD_LIMIT, ripGrepSchema, log13, PATHLESS_CONTENT_LINE2, REGEX_PARSE_ERROR_RE, REGEX_PARSE_HINT, ripGrepTool;
+var VCS_DIRECTORIES_TO_EXCLUDE, DEFAULT_HEAD_LIMIT, GREP_TOOL_DESCRIPTION, ripGrepSchema, log13, PATHLESS_CONTENT_LINE2, REGEX_PARSE_ERROR_RE, REGEX_PARSE_HINT, ripGrepTool;
 var init_rip_grep = __esm({
   "src/tools/rip-grep.ts"() {
     "use strict";
@@ -19732,76 +19747,34 @@ var init_rip_grep = __esm({
     init_log();
     VCS_DIRECTORIES_TO_EXCLUDE = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"];
     DEFAULT_HEAD_LIMIT = 250;
+    GREP_TOOL_DESCRIPTION = "Search file contents with ripgrep (regex). output_mode: content (default; -A/-B/-C/context/-n apply here, -n defaults true), files_with_matches, count. Scope with path; glob for name/extension (*.ts, **/*.tsx)\u2014not a path substitute. type = rg --type. head_limit default 250 (0=unlimited); offset skips. multiline: . matches newlines. Respects .gitignore.";
     ripGrepSchema = Type3.Object({
-      pattern: Type3.String({
-        description: "Regex pattern to search for"
-      }),
-      path: Type3.Optional(
-        Type3.String({
-          description: "File or directory to search in (rg PATH). Defaults to current working directory."
-        })
-      ),
+      pattern: Type3.String(),
+      path: Type3.Optional(Type3.String()),
       glob: Type3.Optional(
         Type3.String({
-          description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}", "**/foo/*.ts"). Prefer path for a directory or file scope; use **/-prefixed globs when matching under a repo-relative folder.'
+          description: "name/extension filter, e.g. *.ts. Prefer path for a directory."
         })
       ),
       output_mode: Type3.Optional(
-        Type3.Union(
-          [Type3.Literal("content"), Type3.Literal("files_with_matches"), Type3.Literal("count")],
-          {
-            description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "content".'
-          }
-        )
-      ),
-      "-B": Type3.Optional(
-        Type3.Number({
-          description: 'Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.'
-        })
-      ),
-      "-A": Type3.Optional(
-        Type3.Number({
-          description: 'Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.'
-        })
-      ),
-      "-C": Type3.Optional(
-        Type3.Number({
-          description: "Alias for context; requires output_mode: content."
-        })
-      ),
-      context: Type3.Optional(
-        Type3.Number({
-          description: 'Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.'
-        })
-      ),
-      "-n": Type3.Optional(
-        Type3.Boolean({
-          description: 'Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.'
-        })
-      ),
-      "-i": Type3.Optional(
-        Type3.Boolean({
-          description: "Case-insensitive search (rg -i)"
-        })
-      ),
-      type: Type3.Optional(
-        Type3.String({
-          description: "File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types."
-        })
-      ),
-      head_limit: Type3.Optional(
-        Type3.Number({
-          description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes. Defaults to 250 when unspecified. Pass 0 for unlimited.'
-        })
-      ),
-      offset: Type3.Optional(
-        Type3.Number({
-          description: 'Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0.'
-        })
+        Type3.Union([
+          Type3.Literal("content"),
+          Type3.Literal("files_with_matches"),
+          Type3.Literal("count")
+        ])
       ),
+      "-B": Type3.Optional(Type3.Number()),
+      "-A": Type3.Optional(Type3.Number()),
+      "-C": Type3.Optional(Type3.Number()),
+      context: Type3.Optional(Type3.Number()),
+      "-n": Type3.Optional(Type3.Boolean()),
+      "-i": Type3.Optional(Type3.Boolean()),
+      type: Type3.Optional(Type3.String()),
+      head_limit: Type3.Optional(Type3.Number()),
+      offset: Type3.Optional(Type3.Number()),
       multiline: Type3.Optional(
         Type3.Boolean({
-          description: "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false."
+          description: ". matches newlines"
         })
       )
     });
@@ -20968,8 +20941,275 @@ var init_bash3 = __esm({
   }
 });
 
+// ../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/base.js
+var Diff;
+var init_base = __esm({
+  "../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/base.js"() {
+    Diff = class {
+      diff(oldStr, newStr, options = {}) {
+        let callback;
+        if (typeof options === "function") {
+          callback = options;
+          options = {};
+        } else if ("callback" in options) {
+          callback = options.callback;
+        }
+        const oldString = this.castInput(oldStr, options);
+        const newString = this.castInput(newStr, options);
+        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+        const newTokens = this.removeEmpty(this.tokenize(newString, options));
+        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+      }
+      diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+        var _a;
+        const done = (value) => {
+          value = this.postProcess(value, options);
+          if (callback) {
+            setTimeout(function() {
+              callback(value);
+            }, 0);
+            return void 0;
+          } else {
+            return value;
+          }
+        };
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let editLength = 1;
+        let maxEditLength = newLen + oldLen;
+        if (options.maxEditLength != null) {
+          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        }
+        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+        const abortAfterTimestamp = Date.now() + maxExecutionTime;
+        const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+        let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+        }
+        let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+        const execEditLength = () => {
+          for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+            let basePath;
+            const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+            if (removePath) {
+              bestPath[diagonalPath - 1] = void 0;
+            }
+            let canAdd = false;
+            if (addPath) {
+              const addPathNewPos = addPath.oldPos - diagonalPath;
+              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+            }
+            const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+            if (!canAdd && !canRemove) {
+              bestPath[diagonalPath] = void 0;
+              continue;
+            }
+            if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+              basePath = this.addToPath(addPath, true, false, 0, options);
+            } else {
+              basePath = this.addToPath(removePath, false, true, 1, options);
+            }
+            newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+              return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+            } else {
+              bestPath[diagonalPath] = basePath;
+              if (basePath.oldPos + 1 >= oldLen) {
+                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+              }
+              if (newPos + 1 >= newLen) {
+                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+              }
+            }
+          }
+          editLength++;
+        };
+        if (callback) {
+          (function exec() {
+            setTimeout(function() {
+              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                return callback(void 0);
+              }
+              if (!execEditLength()) {
+                exec();
+              }
+            }, 0);
+          })();
+        } else {
+          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+            const ret = execEditLength();
+            if (ret) {
+              return ret;
+            }
+          }
+        }
+      }
+      addToPath(path7, added, removed, oldPosInc, options) {
+        const last = path7.lastComponent;
+        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+          return {
+            oldPos: path7.oldPos + oldPosInc,
+            lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+          };
+        } else {
+          return {
+            oldPos: path7.oldPos + oldPosInc,
+            lastComponent: { count: 1, added, removed, previousComponent: last }
+          };
+        }
+      }
+      extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+          newPos++;
+          oldPos++;
+          commonCount++;
+          if (options.oneChangePerToken) {
+            basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+          }
+        }
+        if (commonCount && !options.oneChangePerToken) {
+          basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+        }
+        basePath.oldPos = oldPos;
+        return newPos;
+      }
+      equals(left, right, options) {
+        if (options.comparator) {
+          return options.comparator(left, right);
+        } else {
+          return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+        }
+      }
+      removeEmpty(array) {
+        const ret = [];
+        for (let i = 0; i < array.length; i++) {
+          if (array[i]) {
+            ret.push(array[i]);
+          }
+        }
+        return ret;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      castInput(value, options) {
+        return value;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      tokenize(value, options) {
+        return Array.from(value);
+      }
+      join(chars) {
+        return chars.join("");
+      }
+      postProcess(changeObjects, options) {
+        return changeObjects;
+      }
+      get useLongestToken() {
+        return false;
+      }
+      buildValues(lastComponent, newTokens, oldTokens) {
+        const components = [];
+        let nextComponent;
+        while (lastComponent) {
+          components.push(lastComponent);
+          nextComponent = lastComponent.previousComponent;
+          delete lastComponent.previousComponent;
+          lastComponent = nextComponent;
+        }
+        components.reverse();
+        const componentLen = components.length;
+        let componentPos = 0, newPos = 0, oldPos = 0;
+        for (; componentPos < componentLen; componentPos++) {
+          const component = components[componentPos];
+          if (!component.removed) {
+            if (!component.added && this.useLongestToken) {
+              let value = newTokens.slice(newPos, newPos + component.count);
+              value = value.map(function(value2, i) {
+                const oldValue = oldTokens[oldPos + i];
+                return oldValue.length > value2.length ? oldValue : value2;
+              });
+              component.value = this.join(value);
+            } else {
+              component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+            }
+            newPos += component.count;
+            if (!component.added) {
+              oldPos += component.count;
+            }
+          } else {
+            component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+            oldPos += component.count;
+          }
+        }
+        return components;
+      }
+    };
+  }
+});
+
+// ../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/line.js
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+var LineDiff, lineDiff;
+var init_line = __esm({
+  "../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/line.js"() {
+    init_base();
+    LineDiff = class extends Diff {
+      constructor() {
+        super(...arguments);
+        this.tokenize = tokenize;
+      }
+      equals(left, right, options) {
+        if (options.ignoreWhitespace) {
+          if (!options.newlineIsToken || !left.includes("\n")) {
+            left = left.trim();
+          }
+          if (!options.newlineIsToken || !right.includes("\n")) {
+            right = right.trim();
+          }
+        } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+          if (left.endsWith("\n")) {
+            left = left.slice(0, -1);
+          }
+          if (right.endsWith("\n")) {
+            right = right.slice(0, -1);
+          }
+        }
+        return super.equals(left, right, options);
+      }
+    };
+    lineDiff = new LineDiff();
+  }
+});
+
+// ../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/index.js
+var init_libesm = __esm({
+  "../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/index.js"() {
+    init_line();
+  }
+});
+
 // src/tools/edit-diff.ts
-import * as Diff from "diff";
 function detectLineEnding(content) {
   const crlfIdx = content.indexOf("\r\n");
   const lfIdx = content.indexOf("\n");
@@ -21244,7 +21484,7 @@ 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 parts = diffLines(oldContent, newContent);
   const output = [];
   const oldLines = oldContent.split("\n");
   const newLines = newContent.split("\n");
@@ -21314,6 +21554,7 @@ var EDIT_MISS_COMMON_TOKENS;
 var init_edit_diff = __esm({
   "src/tools/edit-diff.ts"() {
     "use strict";
+    init_libesm();
     EDIT_MISS_COMMON_TOKENS = /* @__PURE__ */ new Set([
       "name",
       "type",
@@ -21490,6 +21731,33 @@ var init_edit_after_proof = __esm({
   }
 });
 
+// src/tools/edit-path-lock.ts
+import { resolve as resolvePath2 } from "node:path";
+function editPathLockKey(absolutePath) {
+  return resolvePath2(absolutePath);
+}
+function tryAcquireEditPathLock(absolutePath) {
+  const key = editPathLockKey(absolutePath);
+  if (heldPaths.has(key)) {
+    return false;
+  }
+  heldPaths.add(key);
+  return true;
+}
+function releaseEditPathLock(absolutePath) {
+  heldPaths.delete(editPathLockKey(absolutePath));
+}
+function formatSameFileEditInProgressError(path7) {
+  return `Another edit is already in progress for ${path7}. Do not issue parallel edit calls on the same file \u2014 batch hunks in one call with replacements: [{ oldText, newText }, \u2026]. Parallelize only independent files.`;
+}
+var heldPaths;
+var init_edit_path_lock = __esm({
+  "src/tools/edit-path-lock.ts"() {
+    "use strict";
+    heldPaths = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/tools/edit-occurrences.ts
 function lineNumberAtIndex(content, index) {
   if (index <= 0) {
@@ -21822,115 +22090,122 @@ function createEditTool(cwd, options) {
       const absolutePath = resolveToCwd(path7, cwd);
       validatePathWithinCwd(absolutePath, cwd);
       const hunks = resolveReplacements(input);
-      return withAbortSignal(signal, async (isAborted) => {
-        try {
-          await ops.access(absolutePath);
-        } catch (error) {
-          rethrowIfFileNotFound(error, cwd, absolutePath, path7);
-        }
-        if (isAborted()) return { content: [], details: void 0 };
-        const buffer = await ops.readFile(absolutePath);
-        const rawContent = buffer.toString("utf-8");
-        if (isAborted()) return { content: [], details: void 0 };
-        const { bom, text: content } = stripBom(rawContent);
-        const originalEnding = detectLineEnding(content);
-        const baseContent = normalizeToLF(content);
-        let newContent = baseContent;
-        let appliedCount = 0;
-        let skippedAlreadyApplied = 0;
-        for (const hunk of hunks) {
-          if (isEditAlreadyApplied(newContent, hunk.oldText, hunk.newText)) {
-            skippedAlreadyApplied++;
-            continue;
+      if (!tryAcquireEditPathLock(absolutePath)) {
+        throw new Error(formatSameFileEditInProgressError(path7));
+      }
+      try {
+        return await withAbortSignal(signal, async (isAborted) => {
+          try {
+            await ops.access(absolutePath);
+          } catch (error) {
+            rethrowIfFileNotFound(error, cwd, absolutePath, path7);
           }
-          const contentBeforeHunk = newContent;
-          newContent = applyReplacement(
-            newContent,
-            path7,
-            hunk.oldText,
-            hunk.newText,
-            hunk.replaceAll,
-            { line: hunk.line, occurrenceIndex: hunk.occurrenceIndex }
-          );
-          appliedCount++;
-          if (hunk.newText.includes(hunk.oldText)) {
-            const dupLine = findConsecutiveDuplicateInsertedLine(
+          if (isAborted()) return { content: [], details: void 0 };
+          const buffer = await ops.readFile(absolutePath);
+          const rawContent = buffer.toString("utf-8");
+          if (isAborted()) return { content: [], details: void 0 };
+          const { bom, text: content } = stripBom(rawContent);
+          const originalEnding = detectLineEnding(content);
+          const baseContent = normalizeToLF(content);
+          let newContent = baseContent;
+          let appliedCount = 0;
+          let skippedAlreadyApplied = 0;
+          for (const hunk of hunks) {
+            if (isEditAlreadyApplied(newContent, hunk.oldText, hunk.newText)) {
+              skippedAlreadyApplied++;
+              continue;
+            }
+            const contentBeforeHunk = newContent;
+            newContent = applyReplacement(
               newContent,
+              path7,
               hunk.oldText,
               hunk.newText,
-              contentBeforeHunk
+              hunk.replaceAll,
+              { line: hunk.line, occurrenceIndex: hunk.occurrenceIndex }
             );
-            if (dupLine) {
-              if (shouldTreatIntegrityDupAsAlreadyApplied(
-                contentBeforeHunk,
+            appliedCount++;
+            if (hunk.newText.includes(hunk.oldText)) {
+              const dupLine = findConsecutiveDuplicateInsertedLine(
+                newContent,
                 hunk.oldText,
-                hunk.newText
-              )) {
-                newContent = contentBeforeHunk;
-                appliedCount--;
-                skippedAlreadyApplied++;
-                continue;
+                hunk.newText,
+                contentBeforeHunk
+              );
+              if (dupLine) {
+                if (shouldTreatIntegrityDupAsAlreadyApplied(
+                  contentBeforeHunk,
+                  hunk.oldText,
+                  hunk.newText
+                )) {
+                  newContent = contentBeforeHunk;
+                  appliedCount--;
+                  skippedAlreadyApplied++;
+                  continue;
+                }
+                throw new Error(formatEditIntegrityDuplicateError(path7, dupLine));
               }
-              throw new Error(formatEditIntegrityDuplicateError(path7, dupLine));
             }
-          }
-          if (isAborted()) return { content: [], details: void 0 };
-        }
-        if (baseContent === newContent) {
-          if (skippedAlreadyApplied > 0 && appliedCount === 0) {
-            const proof2 = appendAfterProof(
-              path7,
-              newContent,
-              hunks.map((hunk) => hunk.newText),
-              `already applied (skipped): ${path7}`
-            );
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: proof2.text
+            if (isAborted()) return { content: [], details: void 0 };
+          }
+          if (baseContent === newContent) {
+            if (skippedAlreadyApplied > 0 && appliedCount === 0) {
+              const proof2 = appendAfterProof(
+                path7,
+                newContent,
+                hunks.map((hunk) => hunk.newText),
+                `already applied (skipped): ${path7}`
+              );
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: proof2.text
+                  }
+                ],
+                details: {
+                  diff: "",
+                  replacementCount: 0,
+                  afterProof: proof2.afterProof,
+                  proved: proof2.proved
                 }
-              ],
-              details: {
-                diff: "",
-                replacementCount: 0,
-                afterProof: proof2.afterProof,
-                proved: proof2.proved
-              }
-            };
+              };
+            }
+            throw new Error(
+              `No changes made to ${path7}. The replacement produced identical content.`
+            );
           }
-          throw new Error(
-            `No changes made to ${path7}. The replacement produced identical content.`
+          const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+          await ops.writeFile(absolutePath, finalContent);
+          if (isAborted()) return { content: [], details: void 0 };
+          rememberSessionMutatedPath(threadId, path7);
+          const diffResult = generateDiffString(baseContent, newContent);
+          const hunkLabel = hunks.length === 1 ? "text" : `${hunks.length} hunks`;
+          const proof = appendAfterProof(
+            path7,
+            newContent,
+            hunks.map((hunk) => hunk.newText),
+            `Successfully replaced ${hunkLabel} in ${path7}.`
           );
-        }
-        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-        await ops.writeFile(absolutePath, finalContent);
-        if (isAborted()) return { content: [], details: void 0 };
-        rememberSessionMutatedPath(threadId, path7);
-        const diffResult = generateDiffString(baseContent, newContent);
-        const hunkLabel = hunks.length === 1 ? "text" : `${hunks.length} hunks`;
-        const proof = appendAfterProof(
-          path7,
-          newContent,
-          hunks.map((hunk) => hunk.newText),
-          `Successfully replaced ${hunkLabel} in ${path7}.`
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: proof.text
+          return {
+            content: [
+              {
+                type: "text",
+                text: proof.text
+              }
+            ],
+            details: {
+              diff: diffResult.diff,
+              firstChangedLine: diffResult.firstChangedLine,
+              replacementCount: hunks.length,
+              afterProof: proof.afterProof,
+              proved: proof.proved
             }
-          ],
-          details: {
-            diff: diffResult.diff,
-            firstChangedLine: diffResult.firstChangedLine,
-            replacementCount: hunks.length,
-            afterProof: proof.afterProof,
-            proved: proof.proved
-          }
-        };
-      });
+          };
+        });
+      } finally {
+        releaseEditPathLock(absolutePath);
+      }
     }
   };
 }
@@ -21961,65 +22236,48 @@ var init_edit2 = __esm({
     init_edit_diff();
     init_edit_already_applied();
     init_edit_after_proof();
+    init_edit_path_lock();
     init_edit_occurrences();
     init_load_tool_description();
     init_path_utils();
     init_tool_helpers();
     replacementSchema = Type5.Object({
-      oldText: Type5.String({
-        description: "Exact text to find and replace (must match exactly; unique unless replaceAll is true)"
-      }),
-      newText: Type5.String({ description: "Replacement text" }),
-      replaceAll: Type5.Optional(
-        Type5.Boolean({
-          description: "When true, replace every occurrence of oldText in the file."
-        })
-      ),
+      oldText: Type5.String(),
+      newText: Type5.String(),
+      replaceAll: Type5.Optional(Type5.Boolean()),
       line: Type5.Optional(
         Type5.Integer({
-          description: "1-based source line where the occurrence starts (from ambiguous-edit error). Use instead of widening oldText.",
+          description: "1-based start line",
           minimum: 1
         })
       ),
       occurrenceIndex: Type5.Optional(
         Type5.Integer({
-          description: "1-based occurrence index when oldText matches multiple times (first match is 1).",
+          description: "1-based; first match is 1",
           minimum: 1
         })
       )
     });
     editSchema = Type5.Object({
-      path: Type5.String({ description: "Path to the file to edit (relative or absolute)" }),
-      oldText: Type5.Optional(
-        Type5.String({
-          description: "Exact text to find and replace (must match exactly). Required unless replacements is set."
-        })
-      ),
-      newText: Type5.Optional(
-        Type5.String({
-          description: "New text to replace oldText with. Required unless replacements is set."
-        })
-      ),
-      replaceAll: Type5.Optional(
-        Type5.Boolean({
-          description: "When true with oldText/newText, replace every occurrence. Per-hunk replaceAll in replacements overrides this."
-        })
-      ),
+      path: Type5.String(),
+      oldText: Type5.Optional(Type5.String()),
+      newText: Type5.Optional(Type5.String()),
+      replaceAll: Type5.Optional(Type5.Boolean()),
       replacements: Type5.Optional(
         Type5.Array(replacementSchema, {
           minItems: 1,
-          description: "Multiple hunks to apply in one call (applied in order). Prefer this over serial single-hunk edits on the same file."
+          description: "batch hunks, applied in order"
         })
       ),
       line: Type5.Optional(
         Type5.Integer({
-          description: "Default line target for single oldText/newText edits when oldText is ambiguous.",
+          description: "1-based start line",
           minimum: 1
         })
       ),
       occurrenceIndex: Type5.Optional(
         Type5.Integer({
-          description: "Default occurrenceIndex for single oldText/newText edits when ambiguous.",
+          description: "1-based; first match is 1",
           minimum: 1
         })
       )
@@ -22052,8 +22310,8 @@ function createLsTool(cwd, options) {
         if (!await ops.exists(dirPath)) {
           throw new Error(`Path not found: ${dirPath}`);
         }
-        const stat8 = await ops.stat(dirPath);
-        if (!stat8.isDirectory()) {
+        const stat9 = await ops.stat(dirPath);
+        if (!stat9.isDirectory()) {
           throw new Error(`Not a directory: ${dirPath}`);
         }
         let entries;
@@ -23416,6 +23674,20 @@ function formatDeletedTodosAck(items) {
   const parts = items.map((item) => `"${truncateTodoDescription(item.description)}"`);
   return `Deleted ${items.length} todos: ${parts.join("; ")}`;
 }
+function formatRemainingTodosSuffix(todos) {
+  const remaining = todos.filter((todo) => todo.status !== "done").map((todo) => ({
+    id: todo.id,
+    description: todo.description,
+    status: todo.status
+  }));
+  if (remaining.length === 0) {
+    return "All todos complete.";
+  }
+  return `Remaining: ${JSON.stringify(remaining)}`;
+}
+function formatTodoMutationResult(ack, todos) {
+  return `${ack} ${formatRemainingTodosSuffix(todos)}`;
+}
 async function fetchTodosByIds(db, threadId, ids) {
   const rows = /* @__PURE__ */ new Map();
   for (const id of ids) {
@@ -23455,10 +23727,10 @@ function createTodoTool(threadId, threadPath) {
             content: [
               {
                 type: "text",
-                text: JSON.stringify({ todos: todosAfterAdd })
+                text: JSON.stringify({ todos: todosAfterAdd, note: ADD_TODOS_NOTE })
               }
             ],
-            details: void 0
+            details: { todos: todosAfterAdd }
           };
         }
         case "update": {
@@ -23510,14 +23782,18 @@ function createTodoTool(threadId, threadPath) {
               status: status ?? existing.status
             });
           }
+          const todosAfterUpdate = await fetchAllTodos(db, threadId);
           return {
             content: [
               {
                 type: "text",
-                text: formatUpdatedTodosAck(updatedItems)
+                text: formatTodoMutationResult(
+                  formatUpdatedTodosAck(updatedItems),
+                  todosAfterUpdate
+                )
               }
             ],
-            details: void 0
+            details: { todos: todosAfterUpdate }
           };
         }
         case "list": {
@@ -23529,7 +23805,7 @@ function createTodoTool(threadId, threadPath) {
                 text: JSON.stringify({ todos })
               }
             ],
-            details: void 0
+            details: { todos }
           };
         }
         case "delete": {
@@ -23547,14 +23823,18 @@ function createTodoTool(threadId, threadPath) {
               args: [id, threadId]
             });
           }
+          const todosAfterDelete = await fetchAllTodos(db, threadId);
           return {
             content: [
               {
                 type: "text",
-                text: formatDeletedTodosAck(deletedItems)
+                text: formatTodoMutationResult(
+                  formatDeletedTodosAck(deletedItems),
+                  todosAfterDelete
+                )
               }
             ],
-            details: void 0
+            details: { todos: todosAfterDelete }
           };
         }
         case "learnings": {
@@ -23605,7 +23885,7 @@ function createTodoTool(threadId, threadPath) {
     }
   };
 }
-var todoSchema, todoTool;
+var todoSchema, ADD_TODOS_NOTE, todoTool;
 var init_todo2 = __esm({
   "src/tools/todo.ts"() {
     "use strict";
@@ -23614,49 +23894,39 @@ var init_todo2 = __esm({
     init_ralph_progress();
     init_load_tool_description();
     todoSchema = Type13.Object({
-      action: Type13.Union(
-        [
-          Type13.Literal("add"),
-          Type13.Literal("update"),
-          Type13.Literal("list"),
-          Type13.Literal("delete"),
-          Type13.Literal("learnings")
-        ],
-        {
-          description: "Operation to perform: 'add' creates new items, 'update' changes status, 'list' returns all items, 'delete' removes items, 'learnings' appends text to progress.txt for cross-iteration memory."
-        }
-      ),
+      action: Type13.Union([
+        Type13.Literal("add"),
+        Type13.Literal("update"),
+        Type13.Literal("list"),
+        Type13.Literal("delete"),
+        Type13.Literal("learnings")
+      ]),
       descriptions: Type13.Optional(
         Type13.Array(Type13.String(), {
-          description: "Todo item descriptions. Required for 'add'. Provide one or more descriptions to create multiple items at once."
+          description: "required for add"
         })
       ),
       ids: Type13.Optional(
         Type13.Array(Type13.String(), {
-          description: "Todo item IDs. Required for 'update' and 'delete'. Provide one or more IDs to update or delete multiple items at once."
+          description: "required for update/delete"
         })
       ),
       status: Type13.Optional(
-        Type13.Union([Type13.Literal("pending"), Type13.Literal("working"), Type13.Literal("done")], {
-          description: "New status for 'update'. Applied to all specified IDs. 'pending' = not started, 'working' = in progress, 'done' = complete."
-        })
-      ),
-      assignedTo: Type13.Optional(
-        Type13.String({
-          description: "Who items are assigned to. Defaults to 'agent'. Applied to all specified items."
-        })
+        Type13.Union([Type13.Literal("pending"), Type13.Literal("working"), Type13.Literal("done")])
       ),
+      assignedTo: Type13.Optional(Type13.String()),
       passes: Type13.Optional(
         Type13.Boolean({
-          description: "Whether the story's quality checks passed. Used in Ralph mode to mark stories as verified. Set to true when checks pass after implementation."
+          description: "Ralph: true after checks"
         })
       ),
       learnings: Type13.Optional(
         Type13.String({
-          description: "Text to append to progress.txt. Required for 'learnings' action. Records patterns, gotchas, and context discovered during implementation."
+          description: "required for learnings; appends progress.txt"
         })
       )
     });
+    ADD_TODOS_NOTE = "Mark each item done as you finish it. Do not end the turn with pending todos.";
     todoTool = createTodoTool("");
   }
 });
@@ -24425,24 +24695,29 @@ var init_skills_manager = __esm({
         );
       }
       /**
-       * Load all available skills for a given thread
-       * Project skills override global ones with the same name
+       * Load all available skills for a thread.
+       *
+       * Project settings install skills in the project root, while a thread may
+       * use a separate checkout (for example, a git-backed thread). Load both
+       * locations so a project-installed skill is available in every thread.
+       * Thread-local skills override project skills, which override global ones.
        */
-      async loadSkills(threadPath) {
+      async loadSkills(threadPath, projectPath = threadPath) {
         const skills = /* @__PURE__ */ new Map();
         const globalDir = getGlobalSkillsDir();
         if (existsSync12(globalDir)) {
           const globalSkills = await this.loadSkillsFromDir(globalDir, "global");
-          for (const skill of globalSkills) {
-            skills.set(skill.name, skill);
-          }
+          for (const skill of globalSkills) skills.set(skill.name, skill);
         }
-        const projectDir = getProjectSkillsDir(threadPath);
+        const projectDir = getProjectSkillsDir(projectPath);
         if (existsSync12(projectDir)) {
           const projectSkills = await this.loadSkillsFromDir(projectDir, "project");
-          for (const skill of projectSkills) {
-            skills.set(skill.name, skill);
-          }
+          for (const skill of projectSkills) skills.set(skill.name, skill);
+        }
+        const threadDir = getProjectSkillsDir(threadPath);
+        if (threadDir !== projectDir && existsSync12(threadDir)) {
+          const threadSkills = await this.loadSkillsFromDir(threadDir, "project");
+          for (const skill of threadSkills) skills.set(skill.name, skill);
         }
         return Array.from(skills.values()).sort((a, b) => a.name.localeCompare(b.name));
       }
@@ -27019,7 +27294,7 @@ function createGitHubRepo(gitRoot, repoName, description, isPrivate) {
     );
   });
 }
-function runGhPrCreateOnce(gitRoot, branchName, title, description) {
+function runGhPrCreateOnce(gitRoot, branchName, title, description, baseBranch) {
   return new Promise((resolve9, reject) => {
     const args2 = [
       "pr",
@@ -27029,7 +27304,8 @@ function runGhPrCreateOnce(gitRoot, branchName, title, description) {
       "--title",
       title ?? "",
       "--body",
-      description ?? ""
+      description ?? "",
+      ...baseBranch ? ["--base", baseBranch] : []
     ];
     log28.info("Executing gh pr create", { args: args2 });
     const proc = spawnProcess("gh", args2, { cwd: gitRoot });
@@ -27068,10 +27344,10 @@ function runGhPrCreateOnce(gitRoot, branchName, title, description) {
     });
   });
 }
-async function createPullRequest(gitRoot, branchName, title, description) {
+async function createPullRequest(gitRoot, branchName, title, description, baseBranch) {
   for (let attempt = 0; ; attempt++) {
     try {
-      return await runGhPrCreateOnce(gitRoot, branchName, title, description);
+      return await runGhPrCreateOnce(gitRoot, branchName, title, description, baseBranch);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const waitMs = PR_CREATE_RACE_RETRY_DELAYS_MS[attempt];
@@ -27212,10 +27488,6 @@ async function resolveCompactModel(model, provider, metadataManager) {
       if (resolved) return { ...resolved, providerName: providerCandidate };
     }
   }
-  for (const [slug, defaultModel] of Object.entries(DEFAULT_COMPACT_MODELS)) {
-    const resolved = await resolveModelAndKey(slug, defaultModel, metadataManager);
-    if (resolved) return { ...resolved, providerName: slug };
-  }
   return null;
 }
 function normalizeCompactModelId(model, provider, fallbackModelId) {
@@ -27343,7 +27615,7 @@ async function compactConversationUnlocked(params, dependencies) {
     summary
   };
 }
-var COMPACT_SUMMARY_PROMPT, DEFAULT_COMPACT_MODELS, CompactError;
+var COMPACT_SUMMARY_PROMPT, CompactError;
 var init_chat_compact_service = __esm({
   "src/features/chat/chat-compact.service.ts"() {
     "use strict";
@@ -27354,13 +27626,6 @@ var init_chat_compact_service = __esm({
     init_conversations_database();
     init_git_utils();
     COMPACT_SUMMARY_PROMPT = `Summarize this coding conversation for continuation. Preserve: project goals, technical decisions, files changed, current state, and outstanding tasks. Omit: debugging noise, failed attempts, and verbose tool output.`;
-    DEFAULT_COMPACT_MODELS = {
-      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"
-    };
     CompactError = class extends Error {
       code;
       constructor(code, message) {
@@ -28003,10 +28268,107 @@ var init_rules_manager = __esm({
   }
 });
 
+// src/tools/compact-json-schema.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNullTypeSchema(value) {
+  return isPlainObject(value) && value.type === "null" && !("const" in value) && !("enum" in value);
+}
+function isBareStringSchema(value) {
+  return isPlainObject(value) && value.type === "string" && !("const" in value) && !("enum" in value) && !("anyOf" in value) && !("oneOf" in value);
+}
+function readStringConst(value) {
+  if (!isPlainObject(value) || typeof value.const !== "string") {
+    return void 0;
+  }
+  if (value.type !== void 0 && value.type !== "string") {
+    return void 0;
+  }
+  return value.const;
+}
+function compactLiteralAnyOf(anyOf) {
+  if (anyOf.length === 0) {
+    return null;
+  }
+  const stringConsts = [];
+  let hasNull = false;
+  let hasBareString = false;
+  for (const item of anyOf) {
+    if (isNullTypeSchema(item)) {
+      hasNull = true;
+      continue;
+    }
+    const literal = readStringConst(item);
+    if (literal !== void 0) {
+      stringConsts.push(literal);
+      continue;
+    }
+    if (isBareStringSchema(item)) {
+      hasBareString = true;
+      continue;
+    }
+    return null;
+  }
+  if (stringConsts.length > 0 && !hasBareString) {
+    return {
+      type: hasNull ? ["string", "null"] : "string",
+      enum: hasNull ? [...stringConsts, null] : stringConsts
+    };
+  }
+  if (hasBareString && hasNull && stringConsts.length === 0) {
+    return { type: ["string", "null"] };
+  }
+  return null;
+}
+function compactJsonSchemaForModel(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => compactJsonSchemaForModel(item));
+  }
+  if (!isPlainObject(schema)) {
+    return schema;
+  }
+  const compactedAnyOf = Array.isArray(schema.anyOf) ? compactLiteralAnyOf(schema.anyOf) : null;
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (compactedAnyOf && key === "anyOf") {
+      continue;
+    }
+    result[key] = compactJsonSchemaForModel(value);
+  }
+  if (compactedAnyOf) {
+    result.type = compactedAnyOf.type;
+    if (compactedAnyOf.enum) {
+      result.enum = compactedAnyOf.enum;
+    }
+  }
+  return result;
+}
+function compactToolSchemasInPayload(payload) {
+  if (!isPlainObject(payload)) {
+    return payload;
+  }
+  let next;
+  if (Array.isArray(payload.tools)) {
+    next = next ?? { ...payload };
+    next.tools = payload.tools.map((tool) => compactJsonSchemaForModel(tool));
+  }
+  if (isPlainObject(payload.toolConfig)) {
+    next = next ?? { ...payload };
+    next.toolConfig = compactJsonSchemaForModel(payload.toolConfig);
+  }
+  return next ?? payload;
+}
+var init_compact_json_schema = __esm({
+  "src/tools/compact-json-schema.ts"() {
+    "use strict";
+  }
+});
+
 // src/tools/tool-search.ts
 import { Type as Type14 } from "@sinclair/typebox";
 function formatToolSchema(tool) {
-  const schema = JSON.stringify(tool.parameters, null, 2);
+  const schema = JSON.stringify(compactJsonSchemaForModel(tool.parameters), null, 2);
   return `<function>{"name": "${tool.name}", "description": ${JSON.stringify(tool.description)}, "parameters": ${schema}}</function>`;
 }
 function parseQuery(query) {
@@ -28114,6 +28476,7 @@ var toolSearchSchema;
 var init_tool_search = __esm({
   "src/tools/tool-search.ts"() {
     "use strict";
+    init_compact_json_schema();
     toolSearchSchema = Type14.Object({
       query: Type14.String({
         description: 'Search query to find tools. Use "select:name1,name2" to fetch exact tools by name, or keywords to search by description.'
@@ -28651,8 +29014,8 @@ async function insertProject(db, project) {
   try {
     await db.execute(
       `
-      INSERT INTO projects (id, name, gitUrl, path, createdAt, openWith, commands, setupScript, validationScript, runCommand, commitMethod, planPrompt, testPrompt, reviewPrompt, customSystemPrompt, useCustomSystemPrompt, allowAllCommands, allowedCommandPatterns, allowedFetchDomains, modelAliases, defaultChatMode, eventToken, disabledTools, smartJsEnabled, useBuiltInBrowser)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, name, gitUrl, path, createdAt, openWith, commands, setupScript, validationScript, runCommand, commitMethod, planPrompt, testPrompt, reviewPrompt, customSystemPrompt, useCustomSystemPrompt, allowAllCommands, allowedCommandPatterns, allowedFetchDomains, modelAliases, defaultChatMode, eventToken, disabledTools, smartJsEnabled, useBuiltInBrowser, projectIcon)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
       [
         project.id,
@@ -28679,7 +29042,8 @@ async function insertProject(db, project) {
         project.eventToken ?? null,
         project.disabledTools?.length ? JSON.stringify(project.disabledTools) : null,
         project.smartJsEnabled ? 1 : 0,
-        project.useBuiltInBrowser === false ? 0 : 1
+        project.useBuiltInBrowser === false ? 0 : 1,
+        project.projectIcon ?? null
       ]
     );
   } catch (error) {
@@ -28787,6 +29151,10 @@ async function updateProject(db, id, updates) {
       fields.push("useBuiltInBrowser = ?");
       values.push(updates.useBuiltInBrowser ? 1 : 0);
     }
+    if (updates.projectIcon !== void 0) {
+      fields.push("projectIcon = ?");
+      values.push(updates.projectIcon ?? null);
+    }
     if (fields.length === 0) {
       return;
     }
@@ -28917,6 +29285,7 @@ function deserializeProjectWithThreads(row, threadIds) {
     disabledTools: row.disabledTools ? JSON.parse(row.disabledTools) : void 0,
     smartJsEnabled: Boolean(row.smartJsEnabled),
     useBuiltInBrowser: row.useBuiltInBrowser === null ? true : Boolean(row.useBuiltInBrowser),
+    projectIcon: row.projectIcon ?? void 0,
     tasksModifiedCount: row.tasksModifiedCount ?? 0
   };
 }
@@ -29639,9 +30008,9 @@ function extractToolResultText(result) {
   }
   return content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
 }
-function logToolCallFailed(log123, event, pending2) {
+function logToolCallFailed(log124, event, pending2) {
   const errorMessage2 = extractToolResultText(event.result).trim() || "Unknown tool error";
-  log123.warn("Tool call failed", {
+  log124.warn("Tool call failed", {
     toolName: event.toolName,
     toolCallId: event.toolCallId,
     arguments: serializeArgumentsForLog(pending2?.args),
@@ -29649,7 +30018,7 @@ function logToolCallFailed(log123, event, pending2) {
   });
 }
 function createAgentEventLogger(event) {
-  const log123 = createLogger(event);
+  const log124 = createLogger(event);
   const pendingToolCalls = /* @__PURE__ */ new Map();
   let sequence = 0;
   function logPiEvent(piEvent) {
@@ -29665,15 +30034,15 @@ function createAgentEventLogger(event) {
       const pending2 = pendingToolCalls.get(piEvent.toolCallId);
       pendingToolCalls.delete(piEvent.toolCallId);
       if (piEvent.isError) {
-        logToolCallFailed(log123, piEvent, pending2);
+        logToolCallFailed(log124, piEvent, pending2);
       }
     }
-    log123.debug(`Agent event ${piEvent.type}`, {
+    log124.debug(`Agent event ${piEvent.type}`, {
       sequence: sequence++,
       detail: formatPiAgentEventDetail(piEvent)
     });
   }
-  return { log: log123, logPiEvent };
+  return { log: log124, logPiEvent };
 }
 var PI_AGENT_EVENT_DETAIL_MAX_CHARS;
 var init_agent_event_log = __esm({
@@ -29838,6 +30207,9 @@ var init_agent_event_transformer = __esm({
           if (isObservationRef(resultDetails?.observation)) {
             toolResultBlock.observation = resultDetails.observation;
           }
+          if (event.toolName === "todo" && Array.isArray(resultDetails?.todos)) {
+            toolResultBlock.todos = resultDetails.todos;
+          }
           if (event.toolName === "generate_image" || event.toolName === "find_images" || event.toolName === "browser") {
             toolResultBlock.content = stripGeneratedImageText(resultContent);
             const details = event.result?.details;
@@ -30005,6 +30377,9 @@ async function executeSubagent(options) {
     tools,
     streamOptions: HARNESS_STREAM_OPTIONS
   });
+  harness.on("before_provider_payload", (event) => ({
+    payload: compactToolSchemasInPayload(event.payload)
+  }));
   const eventQueue = new EventQueue();
   let done = false;
   let aborted = false;
@@ -30098,6 +30473,7 @@ var init_agent_subagent_executor = __esm({
     "use strict";
     init_dist();
     init_agent_executor();
+    init_compact_json_schema();
     init_agent_event_transformer();
     init_agent_event_log();
     init_agent_error_utils();
@@ -30363,21 +30739,18 @@ var init_agent_tool = __esm({
 import {
   estimateContextTokens as estimateSessionContextTokens
 } from "@earendil-works/pi-agent-core";
-function serializeToolForEstimate(tool) {
-  return JSON.stringify({
+function toModelToolDefinition(tool) {
+  return {
     name: tool.name,
     description: tool.description,
-    parameters: tool.parameters
-  });
+    parameters: compactJsonSchemaForModel(tool.parameters ?? {})
+  };
+}
+function serializeToolForEstimate(tool) {
+  return JSON.stringify(toModelToolDefinition(tool));
 }
 function serializeToolsForEstimate(tools) {
-  return JSON.stringify(
-    tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    }))
-  );
+  return JSON.stringify(tools.map((item) => toModelToolDefinition(item)));
 }
 function formatToolDescription(description) {
   if (typeof description === "string") {
@@ -30393,7 +30766,7 @@ function buildToolDefinitionsBreakdown(tools) {
     name: tool.name,
     tokens: estimateTokenCount(serializeToolForEstimate(tool)),
     description: formatToolDescription(tool.description),
-    parameters: tool.parameters ?? {}
+    parameters: compactJsonSchemaForModel(tool.parameters ?? {})
   }));
   toolDetails.sort((left, right) => right.tokens - left.tokens);
   const totalTokens = toolDetails.reduce((sum, tool) => sum + tool.tokens, 0);
@@ -30499,14 +30872,14 @@ async function loadToolsForDefinitionEstimate(thread, threadId, messages, metada
   const latestMessage = messages[messages.length - 1];
   const planMode = latestMessage.request.planMode === true;
   const ralphMode = latestMessage.request.ralphMode === true;
+  const db = await getDatabase();
+  const project = await getProject(db, thread.projectId);
   const skillManager2 = new SkillManager();
-  const allSkills = await skillManager2.loadSkills(threadPath);
+  const allSkills = await skillManager2.loadSkills(threadPath, project?.path);
   const bundledSkills = await skillManager2.loadBundledSkills();
   const availableSkills = getAvailableSkills(allSkills, thread, bundledSkills);
   const agentsManager = new AgentsManager();
   const agents = await agentsManager.loadAgents(threadPath);
-  const db = await getDatabase();
-  const project = await getProject(db, thread.projectId);
   const { tools, deferredToolNames } = await createCodingTools(threadPath, {
     skills: availableSkills,
     threadId,
@@ -30614,17 +30987,17 @@ async function computeContextBreakdown(threadId, conversationId, conversationMan
   const latestMessage = messages[messages.length - 1];
   const planMode = latestMessage.request.planMode === true;
   const ralphMode = latestMessage.request.ralphMode === true;
+  const db = await getDatabase();
+  const project = await getProject(db, thread.projectId);
   const skillManager2 = new SkillManager();
-  const allSkills = await skillManager2.loadSkills(threadPath);
+  const allSkills = await skillManager2.loadSkills(threadPath, project?.path);
   const bundledSkills = await skillManager2.loadBundledSkills();
   const availableSkills = getAvailableSkills(allSkills, thread, bundledSkills);
   const agentsManager = new AgentsManager();
   const agents = await agentsManager.loadAgents(threadPath);
-  const db = await getDatabase();
   const sessionRepo = new LibsqlSessionRepo(db);
   const sessionMetadata = await sessionRepo.findByConversation(threadId, conversationId);
   const session = sessionMetadata ? await sessionRepo.open(sessionMetadata) : void 0;
-  const project = await getProject(db, thread.projectId);
   const { tools, deferredToolNames } = await createCodingTools(threadPath, {
     skills: availableSkills,
     threadId,
@@ -30727,6 +31100,7 @@ var init_context_breakdown = __esm({
     init_agents_manager();
     init_models_manager();
     init_agent_session_repo();
+    init_compact_json_schema();
   }
 });
 
@@ -31853,7 +32227,9 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     }
     let smartAliasModelSettings;
     const skillManager2 = new SkillManager();
-    const allSkills = await skillManager2.loadSkills(threadPath);
+    const skillDb = await getDatabase();
+    const skillProject = await getProject(skillDb, thread.projectId);
+    const allSkills = await skillManager2.loadSkills(threadPath, skillProject?.path);
     const bundledSkills = await skillManager2.loadBundledSkills();
     const availableSkills = getAvailableSkills(allSkills, thread, bundledSkills);
     const activatedSkills = await activateSkills(allSkills, userContent, thread, bundledSkills);
@@ -32705,7 +33081,7 @@ function createTasksTool(projectId, threadId, executionDeps) {
   return {
     name: "tasks",
     label: "tasks",
-    description: `Tasks: add, schedule (one-off/recurring), list (returns task id, title and status; filter by query/status/tags), get (full details of a single task), tags (project tag vocabulary with counts), update, implement (this chat), runNow (new thread), delete. Store intent + optional skills; load skills only when the task runs. When looking up a task by ticket id or phrase, call list with query to find its id, filter by status/tags to triage the queue, or call get for a task's full details instead of listing everything.`,
+    description: TASKS_TOOL_DESCRIPTION,
     parameters: tasksSchema,
     execute: async (_toolCallId, {
       action,
@@ -32985,7 +33361,7 @@ function createTasksTool(projectId, threadId, executionDeps) {
     }
   };
 }
-var VALID_STATUSES, tasksSchema, tasksTool;
+var VALID_STATUSES, TASKS_TOOL_DESCRIPTION, tasksSchema, tasksTool;
 var init_tasks = __esm({
   "src/tools/tasks.ts"() {
     "use strict";
@@ -32995,101 +33371,72 @@ var init_tasks = __esm({
     init_task_execution();
     init_task_trigger_validation();
     VALID_STATUSES = ["Ready", "Plan", "Build", "Test", "Review", "Done"];
+    TASKS_TOOL_DESCRIPTION = "Project tasks. add/schedule: title+description required; optional tags, skillRef, trigger. list: id/title/status, hides Done; filter query/status/tags. get: full task. tags: vocabulary+counts. update any field (null clears trigger/skill). implement this chat; runNow new thread (scheduled/event only). delete. Target by id or unique reference. Skills load only at run.";
     tasksSchema = Type16.Object({
-      action: Type16.Union(
-        [
-          Type16.Literal("add"),
-          Type16.Literal("schedule"),
-          Type16.Literal("list"),
-          Type16.Literal("get"),
-          Type16.Literal("tags"),
-          Type16.Literal("update"),
-          Type16.Literal("implement"),
-          Type16.Literal("runNow"),
-          Type16.Literal("delete")
-        ],
-        {
-          description: "Action: add, schedule, list, get, tags, update, implement, runNow, or delete."
-        }
-      ),
-      description: Type16.Optional(
-        Type16.String({
-          description: "Task description or future-run prompt. Required for 'add'/'schedule'; optional for 'update'."
-        })
-      ),
-      title: Type16.Optional(
-        Type16.String({
-          description: "Task title. Required for 'add'/'schedule'; optional for 'update'."
-        })
-      ),
+      action: Type16.Union([
+        Type16.Literal("add"),
+        Type16.Literal("schedule"),
+        Type16.Literal("list"),
+        Type16.Literal("get"),
+        Type16.Literal("tags"),
+        Type16.Literal("update"),
+        Type16.Literal("implement"),
+        Type16.Literal("runNow"),
+        Type16.Literal("delete")
+      ]),
+      description: Type16.Optional(Type16.String()),
+      title: Type16.Optional(Type16.String()),
       query: Type16.Optional(
         Type16.String({
-          description: "For 'list', case-insensitive title/description substring. Prefer this to find a task; combine with 'status'/'tags'. Omit to list all non-Done tasks."
+          description: "list: title/description substring"
         })
       ),
       status: Type16.Optional(
-        Type16.Union(
-          [
-            Type16.Literal("Ready"),
-            Type16.Literal("Plan"),
-            Type16.Literal("Build"),
-            Type16.Literal("Test"),
-            Type16.Literal("Review"),
-            Type16.Literal("Done")
-          ],
-          {
-            description: "For 'list', filter by status; for 'update', set status. Done tasks are excluded from lists."
-          }
-        )
-      ),
-      id: Type16.Optional(
-        Type16.String({
-          description: "Task ID. Required for 'update'/'get'/'implement'/'runNow'/'delete' unless 'reference' is given."
-        })
+        Type16.Union([
+          Type16.Literal("Ready"),
+          Type16.Literal("Plan"),
+          Type16.Literal("Build"),
+          Type16.Literal("Test"),
+          Type16.Literal("Review"),
+          Type16.Literal("Done")
+        ])
       ),
+      id: Type16.Optional(Type16.String()),
       reference: Type16.Optional(
         Type16.String({
-          description: "Task name or ticket, e.g. 'oc-2', resolved case-insensitively from title/description. Must match one task. Use 'list'/'query' to browse."
+          description: "unique title/ticket, e.g. oc-2"
         })
       ),
       tags: Type16.Optional(
         Type16.Array(Type16.String(), {
-          description: "For 'add'/'schedule'/'update', set tags; for 'list', require all tags. Unknown tags are created automatically. Max 10 tags, 40 chars each."
+          description: "set on write; AND-filter on list; auto-create; max 10 tags, 40 chars"
         })
       ),
       triggerType: Type16.Optional(
         Type16.Union([Type16.Literal("schedule"), Type16.Literal("event"), Type16.Null()], {
-          description: "`schedule` for one-shot, `event` for webhook, or `null` to clear."
+          description: "null clears"
         })
       ),
       scheduledAt: Type16.Optional(
         Type16.Union([Type16.String(), Type16.Null()], {
-          description: "ISO timestamp for a one-shot schedule. Required for 'schedule' unless `scheduleCron` is set."
+          description: "ISO one-shot"
         })
       ),
       scheduleCron: Type16.Optional(
         Type16.Union([Type16.String(), Type16.Null()], {
-          description: "Cron expression for recurring schedules."
-        })
-      ),
-      timezone: Type16.Optional(
-        Type16.Union([Type16.String(), Type16.Null()], {
-          description: "IANA timezone for schedules."
-        })
-      ),
-      enabled: Type16.Optional(
-        Type16.Boolean({
-          description: "Whether the automated trigger is active."
+          description: "cron"
         })
       ),
+      timezone: Type16.Optional(Type16.Union([Type16.String(), Type16.Null()])),
+      enabled: Type16.Optional(Type16.Boolean()),
       skillRef: Type16.Optional(
         Type16.Union([Type16.String(), Type16.Null()], {
-          description: "Skill to activate: `//skill-name` for bundled or `/skill-name` for project/global."
+          description: "//bundled or /project-or-global"
         })
       ),
       eventKey: Type16.Optional(
         Type16.Union([Type16.String(), Type16.Null()], {
-          description: "Webhook event key. Required when `triggerType` is `event`."
+          description: "required for event"
         })
       )
     });
@@ -35933,7 +36280,7 @@ function getProxyCatalogForThread(threadId) {
     (tool) => buildSmartJsToolCatalogEntry({
       name: tool.name,
       description: tool.description,
-      parameters: tool.parameters
+      parameters: compactJsonSchemaForModel(tool.parameters)
     })
   ).sort((left, right) => left.name.localeCompare(right.name));
 }
@@ -36291,6 +36638,7 @@ var init_execute_browser_js = __esm({
     "use strict";
     init_dist();
     init_tarsk_debug();
+    init_compact_json_schema();
     init_try_path_from_error();
     init_try_path_from_error();
     runJsPatchSchema = Type20.Object({
@@ -37990,7 +38338,7 @@ async function createProxyToolCatalog(cwd, options) {
       buildSmartJsToolCatalogEntry({
         name: tool.name,
         description: tool.description,
-        parameters: tool.parameters
+        parameters: compactJsonSchemaForModel(tool.parameters)
       })
     );
   }
@@ -38078,6 +38426,7 @@ var init_tools = __esm({
     init_tarsk_debug();
     init_tool_registry();
     init_skills_allowed_tools();
+    init_compact_json_schema();
     init_wrap_tool_input_repair();
     init_skill_tool();
     init_skill_reference_tool();
@@ -38974,7 +39323,7 @@ function estimateMicrocompactFixedOverhead(systemPrompt, tools) {
     tools.map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: tool.parameters
+      parameters: compactJsonSchemaForModel(tool.parameters)
     }))
   );
   return estimatePaddedTokens(`${systemPrompt}
@@ -39041,6 +39390,20 @@ async function microcompactMessages(messages, options = {}) {
   const agentTurnCount = countAssistantTurns(messages);
   const proactiveTrigger = agentTurnCount >= proactiveTurnThreshold || tokensBefore >= proactivePayloadTokens;
   const nearWindowCeiling = tokensBefore >= effectiveWindow - triggerMargin;
+  const cacheProtectedMessageCount = options.frozenToolCallIds ? messages.filter(
+    (message) => isToolResultMessage2(message) && options.frozenToolCallIds?.has(message.toolCallId) === true
+  ).length : 0;
+  const cacheProtectedTokens = options.frozenToolCallIds ? messages.reduce(
+    (sum, message) => isToolResultMessage2(message) && options.frozenToolCallIds?.has(message.toolCallId) === true ? sum + estimateMessageTokens(message) : sum,
+    0
+  ) : 0;
+  if (cacheProtectedMessageCount > 0) {
+    log62.debug("Preserving cache-protected prompt prefix", {
+      cacheProtectedMessageCount,
+      cacheProtectedTokens,
+      tokensBefore
+    });
+  }
   if (!nearWindowCeiling && !proactiveTrigger) {
     return {
       messages,
@@ -39138,7 +39501,12 @@ async function microcompactMessages(messages, options = {}) {
     applied: clearedCount > 0
   };
   if (stats.applied) {
-    log62.info("Applied micro-compaction", stats);
+    log62.info("Applied micro-compaction", {
+      ...stats,
+      cacheProtectedMessageCount,
+      cacheProtectedTokens,
+      cacheRewriteAvoided: cacheProtectedMessageCount > 0
+    });
   }
   return { messages: next, stats };
 }
@@ -39247,55 +39615,48 @@ var init_microcompact2 = __esm({
     init_observations_config();
     init_microcompact_config();
     init_microcompact_prefix_freeze();
+    init_compact_json_schema();
     log62 = createLogger("microcompact");
     OBSERVATION_ID_IN_TEXT = /obs_[a-f0-9]{64}/;
     TODO_DUPLICATE_OMITTED_PREFIX = "[Duplicate todo result omitted; identical to toolCallId=";
   }
 });
 
-// src/agent/agent-harness.adapters.ts
-function createHarnessContextHandler(transform) {
-  return async function handleContext(event) {
-    const messages = await transform(event.messages.slice());
-    return { messages };
-  };
-}
-function adaptHarnessToolResult(event) {
-  return {
-    toolCall: {
-      type: "toolCall",
-      id: event.toolCallId,
-      name: event.toolName,
-      arguments: event.input
-    },
-    result: {
-      content: event.content,
-      details: event.details,
-      usage: event.usage
-    },
-    isError: event.isError
-  };
+// src/agent/prompt-cache-fingerprint.ts
+import { createHash as createHash7 } from "node:crypto";
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
-function createHarnessToolResultHandler(consumers) {
-  return async function handleToolResult(event) {
-    const adaptedEvent = adaptHarnessToolResult(event);
-    for (const consumer of consumers) {
-      const result = await consumer(adaptedEvent);
-      if (result) {
-        return result;
-      }
+function findUsage(value, depth = 0) {
+  if (depth > 4 || !value || typeof value !== "object") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const result = findUsage(item, depth + 1);
+      if (result) return result;
     }
     return void 0;
-  };
-}
-var init_agent_harness_adapters = __esm({
-  "src/agent/agent-harness.adapters.ts"() {
-    "use strict";
   }
-});
-
-// src/agent/prompt-cache-fingerprint.ts
-import { createHash as createHash7 } from "node:crypto";
+  const record = value;
+  if ("input" in record || "inputTokens" in record || "cacheRead" in record || "cacheReadTokens" in record || "cacheWrite" in record || "cacheWriteTokens" in record) {
+    return record;
+  }
+  for (const nested of Object.values(record)) {
+    const result = findUsage(nested, depth + 1);
+    if (result) return result;
+  }
+  return void 0;
+}
+function usageTotalsFromEvent(event) {
+  const usage = findUsage(event);
+  if (!usage) return void 0;
+  const inputTokens = readNumber(usage.inputTokens ?? usage.input);
+  const cacheReadTokens = readNumber(usage.cacheReadTokens ?? usage.cacheRead);
+  const cacheWriteTokens = readNumber(usage.cacheWriteTokens ?? usage.cacheWrite);
+  if (inputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) return void 0;
+  return { inputTokens, cacheReadTokens, cacheWriteTokens };
+}
 function canonicalize(value) {
   if (Array.isArray(value)) {
     return value.map((item) => canonicalize(item));
@@ -39335,6 +39696,52 @@ function extractPayloadSections(payload) {
 function hashMessages(messages) {
   return Array.isArray(messages) ? messages.map((message) => hash(message)) : [];
 }
+function isOpenAIPromptCacheProvider(provider) {
+  return typeof provider === "string" && provider.includes("openai");
+}
+function extractPromptCacheKey(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return void 0;
+  }
+  const key = payload.prompt_cache_key;
+  return typeof key === "string" && key.length > 0 ? key : void 0;
+}
+function createStablePromptCacheKey(model, payload, provider) {
+  const sections = extractPayloadSections(payload);
+  const digest = hash({
+    provider: provider ?? "",
+    model,
+    system: sections.system,
+    tools: sections.tools
+  });
+  const key = `tarsk-${digest}`;
+  return key.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH ? key : key.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH);
+}
+function applyStablePromptCacheKey(payload, model, provider) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return payload;
+  }
+  const record = payload;
+  if (!("prompt_cache_key" in record) && !isOpenAIPromptCacheProvider(provider)) {
+    return payload;
+  }
+  return {
+    ...record,
+    prompt_cache_key: createStablePromptCacheKey(model, payload, provider)
+  };
+}
+function promptCacheTurnMetrics(usage, firstTurn) {
+  const billablePromptTokens2 = billablePromptTokensFromCounts(
+    usage.inputTokens,
+    usage.cacheReadTokens,
+    usage.cacheWriteTokens
+  );
+  return {
+    billablePromptTokens: billablePromptTokens2,
+    cacheHitRate: calculatePromptCacheHitRate(usage.cacheReadTokens, billablePromptTokens2),
+    firstTurnMiss: firstTurn && usage.cacheReadTokens === 0
+  };
+}
 function comparePromptCacheFingerprints(previous, next) {
   return prefixDiffFromHashes({
     toolsChanged: previous.tools !== next.tools,
@@ -39368,10 +39775,71 @@ function createPromptCacheFingerprint(payload) {
     messageHashes: hashMessages(sections.messages)
   };
 }
+function recordPromptCacheUsage(sessionId, event) {
+  const usage = usageTotalsFromEvent(event);
+  if (!usage) return;
+  const totals = usageBySession.get(sessionId) ?? {
+    calls: 0,
+    inputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+  totals.calls += 1;
+  totals.inputTokens += usage.inputTokens;
+  totals.cacheReadTokens += usage.cacheReadTokens;
+  totals.cacheWriteTokens += usage.cacheWriteTokens;
+  usageBySession.set(sessionId, totals);
+  const last = lastFingerprintBySession.get(sessionId);
+  const metrics = promptCacheTurnMetrics(usage, last?.firstTurn === true);
+  if (last?.firstTurn) {
+    lastFingerprintBySession.set(sessionId, { ...last, firstTurn: false });
+  }
+  log63.debug("Prompt cache usage", {
+    sessionId,
+    ...usage,
+    ...metrics,
+    promptCacheKey: last?.promptCacheKey,
+    system: last?.fingerprint.system,
+    tools: last?.fingerprint.tools,
+    messages: last?.fingerprint.messages,
+    payloadBytes: last?.fingerprint.payloadBytes,
+    messageCount: last?.fingerprint.messageHashes.length
+  });
+}
+function logPromptCacheDiagnostics(sessionId) {
+  const usage = usageBySession.get(sessionId);
+  const last = lastFingerprintBySession.get(sessionId);
+  if (!usage && !last) return void 0;
+  const totals = usage ?? { calls: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+  const fingerprint = last?.fingerprint;
+  const billablePromptTokens2 = billablePromptTokensFromCounts(
+    totals.inputTokens,
+    totals.cacheReadTokens,
+    totals.cacheWriteTokens
+  );
+  const diagnostics = {
+    sessionId,
+    calls: totals.calls,
+    inputTokens: totals.inputTokens,
+    cacheReadTokens: totals.cacheReadTokens,
+    cacheWriteTokens: totals.cacheWriteTokens,
+    billablePromptTokens: billablePromptTokens2,
+    cacheHitRate: calculatePromptCacheHitRate(totals.cacheReadTokens, billablePromptTokens2),
+    promptCacheKey: last?.promptCacheKey,
+    finalPayloadBytes: fingerprint?.payloadBytes ?? 0,
+    finalMessageCount: fingerprint?.messageHashes.length ?? 0
+  };
+  log63.info("Prompt cache session diagnostics", diagnostics);
+  usageBySession.delete(sessionId);
+  lastFingerprintBySession.delete(sessionId);
+  return diagnostics;
+}
 function recordPromptCacheFingerprint(sessionId, provider, model, payload) {
   const fingerprint = createPromptCacheFingerprint(payload);
   const key = `${provider}:${model}:${sessionId}`;
   const previous = previousBySession.get(key);
+  const promptCacheKey = extractPromptCacheKey(payload);
+  const firstTurn = previous === void 0;
   previousBySession.delete(key);
   previousBySession.set(key, fingerprint);
   if (previousBySession.size > MAX_TRACKED_SESSIONS2) {
@@ -39380,11 +39848,14 @@ function recordPromptCacheFingerprint(sessionId, provider, model, payload) {
       previousBySession.delete(oldest);
     }
   }
+  lastFingerprintBySession.set(sessionId, { fingerprint, promptCacheKey, firstTurn });
   const prefix = previous ? comparePromptCacheFingerprints(previous, fingerprint) : void 0;
   log63.debug("Prompt cache fingerprint", {
     sessionId,
     provider,
     model,
+    promptCacheKey,
+    firstTurn,
     full: fingerprint.full,
     system: fingerprint.system,
     tools: fingerprint.tools,
@@ -39403,7 +39874,7 @@ function recordPromptCacheFingerprint(sessionId, provider, model, payload) {
   });
   return fingerprint;
 }
-var log63, MAX_TRACKED_SESSIONS2, previousBySession;
+var log63, MAX_TRACKED_SESSIONS2, previousBySession, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, usageBySession, lastFingerprintBySession;
 var init_prompt_cache_fingerprint = __esm({
   "src/agent/prompt-cache-fingerprint.ts"() {
     "use strict";
@@ -39411,6 +39882,50 @@ var init_prompt_cache_fingerprint = __esm({
     log63 = createLogger("agent.prompt-cache");
     MAX_TRACKED_SESSIONS2 = 500;
     previousBySession = /* @__PURE__ */ new Map();
+    OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+    usageBySession = /* @__PURE__ */ new Map();
+    lastFingerprintBySession = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/agent/agent-harness.adapters.ts
+function createHarnessContextHandler(transform) {
+  return async function handleContext(event) {
+    const messages = await transform(event.messages.slice());
+    return { messages };
+  };
+}
+function adaptHarnessToolResult(event) {
+  return {
+    toolCall: {
+      type: "toolCall",
+      id: event.toolCallId,
+      name: event.toolName,
+      arguments: event.input
+    },
+    result: {
+      content: event.content,
+      details: event.details,
+      usage: event.usage
+    },
+    isError: event.isError
+  };
+}
+function createHarnessToolResultHandler(consumers) {
+  return async function handleToolResult(event) {
+    const adaptedEvent = adaptHarnessToolResult(event);
+    for (const consumer of consumers) {
+      const result = await consumer(adaptedEvent);
+      if (result) {
+        return result;
+      }
+    }
+    return void 0;
+  };
+}
+var init_agent_harness_adapters = __esm({
+  "src/agent/agent-harness.adapters.ts"() {
+    "use strict";
   }
 });
 
@@ -39605,6 +40120,7 @@ var init_agent_executor = __esm({
     init_load_coding_tools();
     init_tool_registry();
     init_agent_tool();
+    init_compact_json_schema();
     init_tools();
     init_database();
     init_paths();
@@ -39621,13 +40137,13 @@ var init_agent_executor = __esm({
     init_user_message_prompt();
     init_observations_config();
     init_microcompact2();
+    init_prompt_cache_fingerprint();
     init_microcompact_config();
     init_agent_harness_adapters();
     init_agent_harness_runtime();
     init_agent_session_repo();
     init_agent_session_lock();
     init_conversations_database();
-    init_prompt_cache_fingerprint();
     init_conversation_prompt_snapshot();
     log64 = createLogger("agent.executor");
     toolCallFailureLog = createLogger("agent.executor.toolcall.failure");
@@ -39945,13 +40461,18 @@ var init_agent_executor = __esm({
             );
           }
           harness.on("before_provider_payload", (event) => {
+            const payload = applyStablePromptCacheKey(
+              compactToolSchemasInPayload(event.payload),
+              event.model.id,
+              event.model.provider
+            );
             recordPromptCacheFingerprint(
               sessionMetadata.id,
               event.model.provider,
               event.model.id,
-              event.payload
+              payload
             );
-            return void 0;
+            return { payload };
           });
           harness.on("tool_result", async (event) => {
             const observationOverride = await observationHandler(event);
@@ -40005,6 +40526,9 @@ var init_agent_executor = __esm({
             if (!isPiAgentEvent(event)) {
               return;
             }
+            if (event.type === "message_end") {
+              recordPromptCacheUsage(sessionMetadata.id, event);
+            }
             logPiEvent(event);
             eventQueue.handlePiEvent(event);
           });
@@ -40091,6 +40615,7 @@ ${finalPrompt}`;
                 if (assistantMessage.stopReason === "error") {
                   throw new Error(assistantMessage.errorMessage ?? "Agent prompt failed");
                 }
+                logPromptCacheDiagnostics(sessionMetadata.id);
                 log64.info("Agent prompt completed successfully");
                 done = true;
                 eventQueue.notify();
@@ -44174,6 +44699,7 @@ async function handleListProjects(c, projectManager, threadManager, db) {
         disabledTools: project.disabledTools ?? [],
         smartJsEnabled: project.smartJsEnabled === true,
         useBuiltInBrowser: project.useBuiltInBrowser !== false,
+        projectIcon: project.projectIcon,
         tasksModifiedCount: project.tasksModifiedCount ?? 0,
         threads: threads.map((thread) => {
           const cached = statusCache.get(thread.id);
@@ -44536,7 +45062,8 @@ async function handleUpdateProject(c, projectManager, metadataManager) {
       lastSelectedModelProvider,
       disabledTools,
       smartJsEnabled,
-      useBuiltInBrowser
+      useBuiltInBrowser,
+      projectIcon
     } = body;
     const resolved = await requireProject(c, projectManager);
     if (!resolved.ok) {
@@ -44646,6 +45173,17 @@ async function handleUpdateProject(c, projectManager, metadataManager) {
     if (useBuiltInBrowser !== void 0) {
       await projectManager.updateBuiltInBrowserSetting(projectId, useBuiltInBrowser === true);
     }
+    if (projectIcon !== void 0) {
+      if (projectIcon !== null && typeof projectIcon !== "string") {
+        return errorResponse(
+          c,
+          ErrorCodes.INVALID_REQUEST,
+          "Project icon must be a PNG data URL or null",
+          400
+        );
+      }
+      await projectManager.updateProjectIcon(projectId, projectIcon);
+    }
     if (name !== void 0) {
       if (!name?.trim()) {
         return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project name is required", 400);
@@ -45888,7 +46426,7 @@ var init_plugin_export_ops = __esm({
 // src/features/plugin-export/plugin-import.ops.ts
 import AdmZip2 from "adm-zip";
 import { lookup } from "dns/promises";
-import { access as access4, mkdtemp, mkdir as mkdir4, rename as rename2, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { access as access4, cp, mkdtemp, mkdir as mkdir4, readdir as readdir8, rename as rename2, rm as rm2, stat as stat4, writeFile as writeFile5 } from "fs/promises";
 import { isIP } from "net";
 import { dirname as dirname11, join as join30, normalize as normalize3, relative as relative4, sep as sep3 } from "path";
 function safeArchivePath(path7) {
@@ -46011,7 +46549,39 @@ async function previewPluginImport(projectPath, archive) {
     }))
   };
 }
-async function installPluginImport(projectPath, archive, selectedSkills, selectedMcpServers, replace) {
+async function sweepStalePluginStagingDirs(projectPath, minimumAgeMs = STALE_STAGING_MIN_AGE_MS) {
+  const entries = await readdir8(projectPath, { withFileTypes: true }).catch(() => []);
+  const now = Date.now();
+  await Promise.all(
+    entries.filter(
+      (entry) => entry.isDirectory() && entry.name.startsWith(STAGING_PREFIX) && entry.name.length > STAGING_PREFIX.length
+    ).map(async (entry) => {
+      const dirPath = join30(projectPath, entry.name);
+      try {
+        const info = await stat4(dirPath);
+        const age = Math.max(0, now - info.mtimeMs);
+        if (age < minimumAgeMs) return;
+        await rm2(dirPath, { recursive: true, force: true });
+        log77.warn("Removed stale plugin import staging directory", { path: dirPath });
+      } catch (error) {
+        log77.warn("Failed to remove stale plugin import staging directory", {
+          path: dirPath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    })
+  );
+}
+async function moveStagedSkill(stagedPath, target) {
+  try {
+    await rename2(stagedPath, target);
+  } catch (error) {
+    if (error.code !== "EXDEV") throw error;
+    await cp(stagedPath, target, { recursive: true });
+    await rm2(stagedPath, { recursive: true, force: true });
+  }
+}
+async function installPluginImport(projectPath, archive, selectedSkills, selectedMcpServers, replace, threadPaths = []) {
   const preview = await previewPluginImport(projectPath, archive);
   const skillNames = new Set(preview.skills.map(({ name }) => name));
   const mcpNames = new Set(preview.mcpServers.map(({ name }) => name));
@@ -46019,8 +46589,9 @@ async function installPluginImport(projectPath, archive, selectedSkills, selecte
     throw new Error("Selected skill is not present in the plugin archive");
   if (selectedMcpServers.some((name) => !mcpNames.has(name)))
     throw new Error("Selected MCP server is not present in the plugin archive");
+  await sweepStalePluginStagingDirs(projectPath);
   const zip = new AdmZip2(archive);
-  const stagingRoot = await mkdtemp(join30(projectPath, ".plugin-import-"));
+  const stagingRoot = await mkdtemp(join30(projectPath, STAGING_PREFIX));
   try {
     const stagedSkills = [];
     for (const skill of preview.skills.filter(({ name }) => selectedSkills.includes(name))) {
@@ -46051,29 +46622,51 @@ async function installPluginImport(projectPath, archive, selectedSkills, selecte
     for (const skill of stagedSkills) {
       const target = join30(agentsRoot, "skills", skill.name);
       if (skill.conflict) await rm2(target, { recursive: true, force: true });
-      await rename2(skill.path, target);
+      await moveStagedSkill(skill.path, target);
+      for (const threadPath of new Set(threadPaths)) {
+        if (threadPath === projectPath) continue;
+        const threadTarget = join30(threadPath, ".agents", "skills", skill.name);
+        let threadExists = true;
+        try {
+          await access4(threadTarget);
+        } catch {
+          threadExists = false;
+        }
+        if (threadExists && !replace) continue;
+        if (threadExists) await rm2(threadTarget, { recursive: true, force: true });
+        await mkdir4(dirname11(threadTarget), { recursive: true });
+        await cp(target, threadTarget, { recursive: true });
+      }
     }
     if (selectedMcpServers.length) {
       const configPath = join30(agentsRoot, "mcp.json");
       const stagedConfigPath = join30(stagingRoot, "mcp.json");
       await writeFile5(stagedConfigPath, JSON.stringify({ mcpServers: current }, null, 2) + "\n");
-      await rm2(configPath, { force: true });
       await rename2(stagedConfigPath, configPath);
     }
   } finally {
-    await rm2(stagingRoot, { recursive: true, force: true });
+    await rm2(stagingRoot, { recursive: true, force: true }).catch((error) => {
+      log77.warn("Failed to remove plugin import staging directory", {
+        path: stagingRoot,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
   }
 }
-var MAX_ARCHIVE_BYTES, MAX_FILES, MAX_FILE_BYTES, MAX_UNCOMPRESSED_BYTES, PLUGIN_FETCH_TIMEOUT_MS;
+var log77, MAX_ARCHIVE_BYTES, MAX_FILES, MAX_FILE_BYTES, MAX_UNCOMPRESSED_BYTES, PLUGIN_FETCH_TIMEOUT_MS, STAGING_PREFIX, STALE_STAGING_MIN_AGE_MS;
 var init_plugin_import_ops = __esm({
   "src/features/plugin-export/plugin-import.ops.ts"() {
     "use strict";
+    init_dist();
     init_mcp_config();
+    log77 = createLogger("features.plugin-export.plugin-import");
     MAX_ARCHIVE_BYTES = 25 * 1024 * 1024;
     MAX_FILES = 500;
     MAX_FILE_BYTES = 2 * 1024 * 1024;
     MAX_UNCOMPRESSED_BYTES = 100 * 1024 * 1024;
     PLUGIN_FETCH_TIMEOUT_MS = 15e3;
+    STAGING_PREFIX = ".plugin-import-";
+    STALE_STAGING_MIN_AGE_MS = 5e3;
   }
 });
 
@@ -46116,7 +46709,7 @@ async function readAuthToken() {
     const session = await getState(db, KEY_SESSION);
     return typeof session?.token === "string" && session.token.length > 0 ? session.token : null;
   } catch (error) {
-    log77.error("[plugin] Failed to read auth session:", error);
+    log78.error("[plugin] Failed to read auth session:", error);
     return null;
   }
 }
@@ -46135,7 +46728,7 @@ async function handlePluginExport(c, projectManager) {
       manifest
     });
     const filename = `${normalizePluginName(manifest.name)}.zip`;
-    log77.info(`[plugin] Exporting ${filename}`);
+    log78.info(`[plugin] Exporting ${filename}`);
     const encoded = encodeURIComponent(filename);
     return new Response(new Uint8Array(zipBuffer), {
       status: 200,
@@ -46147,7 +46740,7 @@ async function handlePluginExport(c, projectManager) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    log77.error("[plugin] Failed to export plugin:", error);
+    log78.error("[plugin] Failed to export plugin:", error);
     return errorResponse(c, ErrorCodes.INTERNAL_ERROR, `Failed to export plugin: ${message}`, 500);
   }
 }
@@ -46165,7 +46758,7 @@ async function handlePluginImportPreview(c, projectManager) {
     return errorResponse(c, ErrorCodes.INVALID_REQUEST, message, 400);
   }
 }
-async function handlePluginImport(c, projectManager) {
+async function handlePluginImport(c, projectManager, threadManager) {
   try {
     const resolved = await requireProject(c, projectManager);
     if (!resolved.ok) return resolved.response;
@@ -46173,12 +46766,14 @@ async function handlePluginImport(c, projectManager) {
     if (typeof body.url !== "string")
       return errorResponse(c, ErrorCodes.INVALID_REQUEST, "url is required", 400);
     const archive = await fetchPluginArchive(body.url);
+    const threads = await threadManager.listThreads(resolved.project.id);
     await installPluginImport(
       resolved.project.path,
       archive,
       Array.isArray(body.skills) ? body.skills.filter((item) => typeof item === "string") : [],
       Array.isArray(body.mcpServers) ? body.mcpServers.filter((item) => typeof item === "string") : [],
-      body.replace === true
+      body.replace === true,
+      threads.map((thread) => thread.path)
     );
     return c.json({ success: true });
   } catch (error) {
@@ -46206,7 +46801,7 @@ async function handlePluginUpload(c, projectManager) {
     });
     const filename = `${normalizePluginName(manifest.name)}.zip`;
     const result = await uploadPluginZip(zipBuffer, token);
-    log77.info(
+    log78.info(
       `[plugin] Uploaded ${filename}: valid=${result.valid}, errors=${result.errors.length}, warnings=${result.warnings.length}`
     );
     return c.json({
@@ -46218,16 +46813,16 @@ async function handlePluginUpload(c, projectManager) {
     });
   } catch (error) {
     if (error instanceof PluginUploadError) {
-      log77.error(`[plugin] Upload failed (${error.status}):`, error.message);
+      log78.error(`[plugin] Upload failed (${error.status}):`, error.message);
       const status = error.status >= 400 && error.status < 500 ? error.status : 502;
       return errorResponse(c, ErrorCodes.INTERNAL_ERROR, error.message, status);
     }
     const message = error instanceof Error ? error.message : String(error);
-    log77.error("[plugin] Failed to upload plugin:", error);
+    log78.error("[plugin] Failed to upload plugin:", error);
     return errorResponse(c, ErrorCodes.INTERNAL_ERROR, `Failed to upload plugin: ${message}`, 500);
   }
 }
-var log77, KEY_SESSION;
+var log78, KEY_SESSION;
 var init_plugin_export_routes = __esm({
   "src/features/plugin-export/plugin-export.routes.ts"() {
     "use strict";
@@ -46239,7 +46834,7 @@ var init_plugin_export_routes = __esm({
     init_database_state();
     init_plugin_export_ops();
     init_plugin_import_ops();
-    log77 = createLogger("features.plugin-export.route");
+    log78 = createLogger("features.plugin-export.route");
     KEY_SESSION = "AuthSession";
   }
 });
@@ -46641,7 +47236,7 @@ function createProjectRoutes(projectManager, threadManager, metadataManager, upg
     return handlePluginImportPreview(c, projectManager);
   });
   router.post("/:id/plugin-import", async (c) => {
-    return handlePluginImport(c, projectManager);
+    return handlePluginImport(c, projectManager, threadManager);
   });
   router.post("/:id/plugin-upload", async (c) => {
     return handlePluginUpload(c, projectManager);
@@ -47659,7 +48254,7 @@ var init_scaffold_templates = __esm({
 // src/features/scaffold/scaffold.runner.ts
 import { existsSync as existsSync21 } from "fs";
 import { join as join31 } from "path";
-import { mkdir as mkdir5, readdir as readdir8, stat as stat4, rename as rename3, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir5, readdir as readdir9, stat as stat5, rename as rename3, rm as rm3, writeFile as writeFile6 } from "fs/promises";
 import { createInterface } from "readline";
 function registerScaffoldHandler(handlerName, callback) {
   HANDLERS.set(handlerName, callback);
@@ -47927,13 +48522,13 @@ async function* createScaffoldedProjectStreaming(options) {
     const projectName2 = getProjectName(options.projectName);
     const projectSubDir = join31(projectPath, projectName2);
     try {
-      const subDirStat = await stat4(projectSubDir);
+      const subDirStat = await stat5(projectSubDir);
       if (subDirStat.isDirectory()) {
         yield {
           type: "progress",
           message: `Moving project files from ${projectName2}/ to thread folder...`
         };
-        const items = await readdir8(projectSubDir);
+        const items = await readdir9(projectSubDir);
         for (const item of items) {
           const oldPath = join31(projectSubDir, item);
           const newPath = join31(projectPath, item);
@@ -47995,7 +48590,7 @@ async function* createScaffoldedProjectStreaming(options) {
 function getScaffoldTemplates() {
   return loadCatalog();
 }
-var log78, HANDLERS;
+var log79, HANDLERS;
 var init_scaffold_runner = __esm({
   "src/features/scaffold/scaffold.runner.ts"() {
     "use strict";
@@ -48003,7 +48598,7 @@ var init_scaffold_runner = __esm({
     init_shell();
     init_dist();
     init_scaffold_templates();
-    log78 = createLogger("features.scaffold.scaffold.runner");
+    log79 = createLogger("features.scaffold.scaffold.runner");
     HANDLERS = /* @__PURE__ */ new Map();
     registerScaffoldHandler("capacitor-plugin", capacitorPluginHandler);
   }
@@ -48019,9 +48614,9 @@ var init_random_words = __esm({
 
 // src/features/projects/projects.creator.ts
 import { randomUUID as randomUUID14 } from "crypto";
-import { basename as basename4, join as join32, relative as relative5, resolve as resolvePath2 } from "path";
+import { basename as basename4, join as join32, relative as relative5, resolve as resolvePath3 } from "path";
 import { realpathSync as realpathSync2 } from "fs";
-import { access as access5, mkdir as mkdir6, rm as rm4, stat as stat5, readdir as readdir9 } from "fs/promises";
+import { access as access5, mkdir as mkdir6, rm as rm4, stat as stat6, readdir as readdir10 } from "fs/promises";
 async function loadUtils() {
   if (utilsLoaded) return;
   utilsLoaded = true;
@@ -48032,7 +48627,7 @@ async function loadUtils() {
   }
 }
 function normalizeFolderPath(folderPath) {
-  const resolved = resolvePath2(folderPath);
+  const resolved = resolvePath3(folderPath);
   try {
     return realpathSync2(resolved);
   } catch {
@@ -48445,7 +49040,7 @@ var init_projects_creator = __esm({
       }
       async folderExists(folderPath) {
         try {
-          await stat5(folderPath);
+          await stat6(folderPath);
           return true;
         } catch {
           return false;
@@ -48484,7 +49079,7 @@ var init_projects_creator = __esm({
       async *createProjectFromPath(folderPath) {
         const normalizedPath = normalizeFolderPath(folderPath);
         try {
-          const stats = await stat5(normalizedPath);
+          const stats = await stat6(normalizedPath);
           if (!stats.isDirectory()) {
             yield { type: "error", message: `Selected path is not a directory: ${normalizedPath}` };
             return;
@@ -48660,11 +49255,11 @@ var init_projects_creator = __esm({
         } catch {
         }
         try {
-          const entries = await readdir9(currentPath);
+          const entries = await readdir10(currentPath);
           for (const entry of entries) {
             const entryPath = join32(currentPath, entry);
             try {
-              const stats = await stat5(entryPath);
+              const stats = await stat6(entryPath);
               if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
                 await this.findAllPackageJsonFiles(rootPath, entryPath, setupScripts);
               }
@@ -48768,7 +49363,7 @@ var init_terminal_session_manager = __esm({
 import { join as join33 } from "path";
 import { realpathSync as realpathSync4 } from "fs";
 import { rm as rm5 } from "fs/promises";
-var log79, ProjectManagerImpl;
+var log80, ProjectManagerImpl;
 var init_projects_manager = __esm({
   "src/features/projects/projects.manager.ts"() {
     "use strict";
@@ -48779,7 +49374,7 @@ var init_projects_manager = __esm({
     init_projects_open_with();
     init_projects_creator();
     init_terminal_session_manager();
-    log79 = createLogger("projects.manager");
+    log80 = createLogger("projects.manager");
     ProjectManagerImpl = class {
       rootFolder;
       metadataManager;
@@ -49255,6 +49850,15 @@ ___CWD___%s
         project.useBuiltInBrowser = useBuiltInBrowser;
         await this.metadataManager.saveProjects(projects);
       }
+      async updateProjectIcon(projectId, projectIcon) {
+        const projects = await this.metadataManager.loadProjects();
+        const project = projects.find((p) => p.id === projectId);
+        if (!project) {
+          throw new Error(`Project not found: ${projectId}`);
+        }
+        project.projectIcon = projectIcon ?? void 0;
+        await this.metadataManager.saveProjects(projects);
+      }
       /**
        * Starts running a dev server process for a project
        * @param projectId - The project ID
@@ -49262,7 +49866,7 @@ ___CWD___%s
        */
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async *startRunningProcess(projectId, threadId) {
-        log79.info("Starting running process for project", { projectId, threadId });
+        log80.info("Starting running process for project", { projectId, threadId });
         const project = await this.getProject(projectId);
         if (!project) {
           throw new Error(`Project not found: ${projectId}`);
@@ -49278,7 +49882,7 @@ ___CWD___%s
           const threads = await this.metadataManager.loadThreads();
           const thread = threads.find((t) => t.id === targetThreadId);
           if (!thread) {
-            log79.warn("Thread not found for project while starting process", {
+            log80.warn("Thread not found for project while starting process", {
               projectId,
               targetThreadId,
               availableThreadIds: project.threads
@@ -49287,7 +49891,7 @@ ___CWD___%s
               `Thread not found for project: ${projectId} with threadId: ${targetThreadId}`
             );
           }
-          log79.info("Launching project run command", {
+          log80.info("Launching project run command", {
             projectId,
             threadId: targetThreadId,
             command: project.runCommand,
@@ -49300,7 +49904,7 @@ ___CWD___%s
             targetThreadId
           );
         } catch (error) {
-          log79.error("Failed to start running process", { projectId, threadId: targetThreadId, error });
+          log80.error("Failed to start running process", { projectId, threadId: targetThreadId, error });
           throw error;
         }
       }
@@ -49704,12 +50308,12 @@ async function getOpenRouterCredits(apiKey) {
     return { balance: null, status: "unknown", reason: String(error) };
   }
 }
-var log80;
+var log81;
 var init_model_info_openrouter = __esm({
   "src/features/models/model-info-openrouter.ts"() {
     "use strict";
     init_dist();
-    log80 = createLogger("features.models.model-info-openrouter");
+    log81 = createLogger("features.models.model-info-openrouter");
   }
 });
 
@@ -49736,12 +50340,12 @@ async function getAIHubMixCredits(apiKey) {
     return { balance: null, status: "unknown", reason: String(error) };
   }
 }
-var log81;
+var log82;
 var init_model_info_aihubmix = __esm({
   "src/features/models/model-info-aihubmix.ts"() {
     "use strict";
     init_dist();
-    log81 = createLogger("features.models.model-info-aihubmix");
+    log82 = createLogger("features.models.model-info-aihubmix");
   }
 });
 
@@ -49891,31 +50495,31 @@ function openUrlWithSystemBrowser(url) {
 async function openExternalUrlInSystemBrowser(url) {
   const utils = getElectrobunUtils();
   if (utils) {
-    log82.debug("Trying Utils.openExternal", { url });
+    log83.debug("Trying Utils.openExternal", { url });
     try {
       const opened = utils.openExternal(url);
       if (opened) {
-        log82.info("Opened external URL via Utils.openExternal", { url });
+        log83.info("Opened external URL via Utils.openExternal", { url });
         return;
       }
-      log82.warn("Utils.openExternal returned false, falling back to system command", { url });
+      log83.warn("Utils.openExternal returned false, falling back to system command", { url });
     } catch (error) {
-      log82.warn("Utils.openExternal threw, falling back to system command", { url, error });
+      log83.warn("Utils.openExternal threw, falling back to system command", { url, error });
     }
   } else {
-    log82.debug("Electrobun Utils unavailable, using system command", { url });
+    log83.debug("Electrobun Utils unavailable, using system command", { url });
   }
   await openUrlWithSystemBrowser(url);
-  log82.info("Opened external URL via system command", { url, platform: process.platform });
+  log83.info("Opened external URL via system command", { url, platform: process.platform });
 }
-var log82;
+var log83;
 var init_open_external_url = __esm({
   "src/core/open-external-url.ts"() {
     "use strict";
     init_dist();
     init_electrobun_utils();
     init_utils();
-    log82 = createLogger("providers.open-external");
+    log83 = createLogger("providers.open-external");
   }
 });
 
@@ -49934,18 +50538,18 @@ async function openExternalUrl(c) {
     await openExternalUrlInSystemBrowser(url);
     return c.json({ success: true });
   } catch (error) {
-    log83.error("Failed to open external URL", error);
+    log84.error("Failed to open external URL", error);
     const message = error instanceof Error ? error.message : "Failed to open URL";
     return c.json({ error: message }, 500);
   }
 }
-var log83;
+var log84;
 var init_providers_open_external_route = __esm({
   "src/features/providers/providers-open-external.route.ts"() {
     "use strict";
     init_dist();
     init_open_external_url();
-    log83 = createLogger("providers.open-external");
+    log84 = createLogger("providers.open-external");
   }
 });
 
@@ -50234,7 +50838,7 @@ async function checkVp(c) {
     const installed = result.status === 0;
     return c.json({ installed });
   } catch (error) {
-    log84.error("Failed to check vp installation:", error);
+    log85.error("Failed to check vp installation:", error);
     return c.json({ installed: false });
   }
 }
@@ -50262,14 +50866,14 @@ async function installVp(c) {
     );
   }
 }
-var log84;
+var log85;
 var init_scaffold_vp_route = __esm({
   "src/features/scaffold/scaffold-vp.route.ts"() {
     "use strict";
     init_utils();
     init_shell();
     init_dist();
-    log84 = createLogger("features.scaffold.scaffold-vp");
+    log85 = createLogger("features.scaffold.scaffold-vp");
   }
 });
 
@@ -50293,7 +50897,7 @@ var init_scaffold_routes = __esm({
 });
 
 // src/features/slash-commands/slash-commands.manager.ts
-import { readdir as readdir10, readFile as readFile15, mkdir as mkdir7, writeFile as writeFile7, unlink as unlink4 } from "fs/promises";
+import { readdir as readdir11, readFile as readFile15, mkdir as mkdir7, writeFile as writeFile7, unlink as unlink4 } from "fs/promises";
 import { join as join35, basename as basename5, extname as extname5, relative as relative6 } from "path";
 import { existsSync as existsSync22 } from "fs";
 import { homedir as homedir9 } from "os";
@@ -50330,13 +50934,13 @@ function getGlobalCommandsDir() {
 function getProjectCommandsDir(threadPath) {
   return join35(threadPath, ".agents", "commands");
 }
-var log85, SlashCommandManager;
+var log86, SlashCommandManager;
 var init_slash_commands_manager = __esm({
   "src/features/slash-commands/slash-commands.manager.ts"() {
     "use strict";
     init_dist();
     init_frontmatter();
-    log85 = createLogger("features.slash-commands.slash-commands.manager");
+    log86 = createLogger("features.slash-commands.slash-commands.manager");
     SlashCommandManager = class _SlashCommandManager {
       /**
        * Built-in commands that cannot be overridden
@@ -50434,7 +51038,7 @@ var init_slash_commands_manager = __esm({
       async loadCommandsFromDir(dir, threadPath, scope) {
         const commands = [];
         try {
-          const files = await readdir10(dir);
+          const files = await readdir11(dir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
             const filePath = join35(dir, file);
@@ -50452,7 +51056,7 @@ var init_slash_commands_manager = __esm({
             });
           }
         } catch (error) {
-          log85.error(`Failed to load commands from ${dir}:`, error);
+          log86.error(`Failed to load commands from ${dir}:`, error);
         }
         return commands;
       }
@@ -50580,7 +51184,9 @@ async function getSlashCommands(c, threadManager) {
       );
     }
     const commands = await slashCommandManager.loadCommands(thread.path);
-    const skills = await skillManager.loadSkills(thread.path);
+    const db = await getDatabase();
+    const project = await getProject(db, thread.projectId);
+    const skills = await skillManager.loadSkills(thread.path, project?.path);
     const bundledSkills = await skillManager.loadBundledSkills();
     const response = {
       commands,
@@ -50589,7 +51195,7 @@ async function getSlashCommands(c, threadManager) {
     };
     return c.json(response);
   } catch (error) {
-    log86.error("Failed to load slash commands:", error);
+    log87.error("Failed to load slash commands:", error);
     return c.json(
       {
         error: {
@@ -50603,14 +51209,16 @@ async function getSlashCommands(c, threadManager) {
     );
   }
 }
-var log86, slashCommandManager, skillManager;
+var log87, slashCommandManager, skillManager;
 var init_slash_commands_get_route = __esm({
   "src/features/slash-commands/slash-commands-get.route.ts"() {
     "use strict";
     init_slash_commands_manager();
     init_skills_manager();
     init_dist();
-    log86 = createLogger("features.slash-commands.slash-commands-get");
+    init_database();
+    init_projects_database();
+    log87 = createLogger("features.slash-commands.slash-commands-get");
     slashCommandManager = new SlashCommandManager();
     skillManager = new SkillManager();
   }
@@ -50683,7 +51291,7 @@ async function createSlashCommand(c, threadManager) {
     );
     return c.json(command, 201);
   } catch (error) {
-    log87.error("Failed to create slash command:", error);
+    log88.error("Failed to create slash command:", error);
     return c.json(
       {
         error: {
@@ -50697,13 +51305,13 @@ async function createSlashCommand(c, threadManager) {
     );
   }
 }
-var log87, slashCommandManager2;
+var log88, slashCommandManager2;
 var init_slash_commands_post_route = __esm({
   "src/features/slash-commands/slash-commands-post.route.ts"() {
     "use strict";
     init_slash_commands_manager();
     init_dist();
-    log87 = createLogger("features.slash-commands.slash-commands-post");
+    log88 = createLogger("features.slash-commands.slash-commands-post");
     slashCommandManager2 = new SlashCommandManager();
   }
 });
@@ -50728,7 +51336,7 @@ async function updateSlashCommand(c) {
     await slashCommandManager3.updateCommand(filePath, content, metadata ?? {});
     return c.json({ success: true });
   } catch (error) {
-    log88.error("Failed to update slash command:", error);
+    log89.error("Failed to update slash command:", error);
     return c.json(
       {
         error: {
@@ -50742,13 +51350,13 @@ async function updateSlashCommand(c) {
     );
   }
 }
-var log88, slashCommandManager3;
+var log89, slashCommandManager3;
 var init_slash_commands_put_route = __esm({
   "src/features/slash-commands/slash-commands-put.route.ts"() {
     "use strict";
     init_slash_commands_manager();
     init_dist();
-    log88 = createLogger("features.slash-commands.slash-commands-put");
+    log89 = createLogger("features.slash-commands.slash-commands-put");
     slashCommandManager3 = new SlashCommandManager();
   }
 });
@@ -50773,7 +51381,7 @@ async function deleteSlashCommand(c) {
     await slashCommandManager4.deleteCommand(filePath);
     return c.json({ success: true });
   } catch (error) {
-    log89.error("Failed to delete slash command:", error);
+    log90.error("Failed to delete slash command:", error);
     return c.json(
       {
         error: {
@@ -50787,13 +51395,13 @@ async function deleteSlashCommand(c) {
     );
   }
 }
-var log89, slashCommandManager4;
+var log90, slashCommandManager4;
 var init_slash_commands_delete_route = __esm({
   "src/features/slash-commands/slash-commands-delete.route.ts"() {
     "use strict";
     init_slash_commands_manager();
     init_dist();
-    log89 = createLogger("features.slash-commands.slash-commands-delete");
+    log90 = createLogger("features.slash-commands.slash-commands-delete");
     slashCommandManager4 = new SlashCommandManager();
   }
 });
@@ -51015,7 +51623,7 @@ Describe your rules here as markdown which will be used when Tarsk sees is promp
       201
     );
   } catch (error) {
-    log90.error("Failed to create rule:", error);
+    log91.error("Failed to create rule:", error);
     return c.json(
       {
         error: {
@@ -51029,12 +51637,12 @@ Describe your rules here as markdown which will be used when Tarsk sees is promp
     );
   }
 }
-var log90;
+var log91;
 var init_rules_post_route = __esm({
   "src/features/rules/rules-post.route.ts"() {
     "use strict";
     init_dist();
-    log90 = createLogger("features.rules.rules-post");
+    log91 = createLogger("features.rules.rules-post");
   }
 });
 
@@ -51183,7 +51791,7 @@ var init_thread_folder_name = __esm({
 import { randomUUID as randomUUID15 } from "crypto";
 import { join as join36 } from "path";
 import { execSync as execSync3 } from "child_process";
-import { rm as rm6, stat as stat6, mkdir as mkdir8 } from "fs/promises";
+import { rm as rm6, stat as stat7, mkdir as mkdir8 } from "fs/promises";
 async function* removePathWithKeepalive(path7, threadId) {
   const removePromise = rm6(path7, { recursive: true, force: true });
   while (true) {
@@ -51199,7 +51807,7 @@ async function* removePathWithKeepalive(path7, threadId) {
     yield { type: "progress", message: `Still removing ${path7}...`, threadId };
   }
 }
-var log91, DELETE_REMOVE_HEARTBEAT_MS, ThreadManagerImpl;
+var log92, DELETE_REMOVE_HEARTBEAT_MS, ThreadManagerImpl;
 var init_threads_manager = __esm({
   "src/features/threads/threads.manager.ts"() {
     "use strict";
@@ -51210,7 +51818,7 @@ var init_threads_manager = __esm({
     init_database();
     init_threads_database();
     init_thread_folder_name();
-    log91 = createLogger("features.threads.threads.manager");
+    log92 = createLogger("features.threads.threads.manager");
     DELETE_REMOVE_HEARTBEAT_MS = 1e4;
     ThreadManagerImpl = class {
       metadataManager;
@@ -51270,7 +51878,7 @@ var init_threads_manager = __esm({
             return;
           }
           try {
-            await stat6(project.path);
+            await stat7(project.path);
           } catch {
             await mkdir8(project.path, { recursive: true });
           }
@@ -51318,7 +51926,7 @@ var init_threads_manager = __esm({
             };
             try {
               try {
-                await stat6(project.path);
+                await stat7(project.path);
               } catch {
                 await mkdir8(project.path, { recursive: true });
               }
@@ -51556,7 +52164,7 @@ var init_threads_manager = __esm({
           const db = await getDatabase();
           await deleteThread(db, threadId);
         } catch (error) {
-          log91.error(
+          log92.error(
             `Failed to mark thread as deleted in database: ${error instanceof Error ? error.message : String(error)}`
           );
         }
@@ -51933,7 +52541,7 @@ var init_project_scripts_database = __esm({
 });
 
 // src/core/project-inspector.ts
-import { readFile as readFile16, readdir as readdir11 } from "fs/promises";
+import { readFile as readFile16, readdir as readdir12 } from "fs/promises";
 import { existsSync as existsSync23 } from "fs";
 import { join as join37, basename as basename7, relative as relative7 } from "path";
 import { glob as glob2 } from "glob";
@@ -52135,7 +52743,7 @@ async function resolveNxWorkspaces(projectPath) {
   if (workspaces.length > 0) return workspaces;
   const appsDir = join37(projectPath, "apps");
   if (existsSync23(appsDir)) {
-    const entries = await readdir11(appsDir, { withFileTypes: true });
+    const entries = await readdir12(appsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         const folder = join37("apps", entry.name);
@@ -52171,7 +52779,7 @@ async function resolveFolderWorkspaces(projectPath) {
 }
 async function detectFolderBasedWorkspaces(projectPath) {
   try {
-    const entries = await readdir11(projectPath, { withFileTypes: true });
+    const entries = await readdir12(projectPath, { withFileTypes: true });
     const results = [];
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
@@ -52276,7 +52884,7 @@ async function handleSelectThread(c, threadManager) {
     }
     await threadManager.selectThread(threadId);
     inspectProject(thread.path, thread.projectId).catch((err) => {
-      log92.error(`Failed to inspect project scripts for thread ${threadId}:`, err);
+      log93.error(`Failed to inspect project scripts for thread ${threadId}:`, err);
     });
     return successResponse(c, { success: true, message: "Thread selected successfully", threadId });
   } catch (error) {
@@ -52289,7 +52897,7 @@ async function handleSelectThread(c, threadManager) {
     );
   }
 }
-var log92;
+var log93;
 var init_threads_select_route = __esm({
   "src/features/threads/threads-select.route.ts"() {
     "use strict";
@@ -52297,7 +52905,7 @@ var init_threads_select_route = __esm({
     init_error_responses();
     init_project_inspector();
     init_dist();
-    log92 = createLogger("features.threads.threads-select");
+    log93 = createLogger("features.threads.threads-select");
   }
 });
 
@@ -52472,7 +53080,7 @@ var init_threads_files_route = __esm({
 });
 
 // src/features/threads/threads-explorer.route.ts
-import { readdir as readdir12, readFile as readFile17, rename as rename4, writeFile as writeFile8, mkdir as mkdir9, access as access6, open as open2, stat as stat7, rm as rm7 } from "fs/promises";
+import { readdir as readdir13, readFile as readFile17, rename as rename4, writeFile as writeFile8, mkdir as mkdir9, access as access6, open as open2, stat as stat8, rm as rm7 } from "fs/promises";
 import { isAbsolute as isAbsolute6, join as join38, resolve as resolve5, basename as basename8 } from "path";
 import { spawn as spawn2 } from "child_process";
 import openFilePath from "open";
@@ -52529,7 +53137,7 @@ async function openExportPath(outputPath) {
       const openResult = await Utils2.openPath(outputPath);
       opened = openResult !== false;
     } catch (error) {
-      log93.warn("Failed to open explorer export with electrobun", { outputPath, error });
+      log94.warn("Failed to open explorer export with electrobun", { outputPath, error });
       opened = false;
     }
   }
@@ -52545,7 +53153,7 @@ async function openExportPath(outputPath) {
   }
 }
 async function listExplorerEntriesRecursive(rootPath, currentPath, relativePath) {
-  const dirents = await readdir12(currentPath, { withFileTypes: true });
+  const dirents = await readdir13(currentPath, { withFileTypes: true });
   const isRoot = relativePath.length === 0;
   const entries = dirents.filter((d) => !(isRoot && d.name === ".git") && d.name !== "node_modules").map((d) => {
     const entryPath = relativePath ? join38(relativePath, d.name) : d.name;
@@ -52589,7 +53197,7 @@ async function handleListThreadExplorerDir(c, threadManager) {
     }
     let dirents;
     try {
-      dirents = await readdir12(absDir, { withFileTypes: true });
+      dirents = await readdir13(absDir, { withFileTypes: true });
     } catch {
       return c.json({ error: { code: "NOT_FOUND", message: "Directory not found" } }, 404);
     }
@@ -52863,7 +53471,7 @@ function resolveExplorerMediaAbsolutePath(threadPath, filePath) {
   return validateFilePath(threadPath, filePath);
 }
 async function buildExplorerMediaResponse(absPath, contentType, rangeHeader) {
-  const { size: fileSize } = await stat7(absPath);
+  const { size: fileSize } = await stat8(absPath);
   if (rangeHeader?.startsWith("bytes=")) {
     const [startStr, endStr] = rangeHeader.slice(6).split("-", 2);
     const start = Number.parseInt(startStr, 10);
@@ -52937,7 +53545,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     }
     const absPath = resolveExplorerMediaAbsolutePath(thread.path, filePath);
     if (!absPath) {
-      log93.warn("[explorer-media] Invalid media path", {
+      log94.warn("[explorer-media] Invalid media path", {
         threadId,
         filePath,
         threadPath: thread.path
@@ -52947,7 +53555,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     try {
       await access6(absPath);
     } catch {
-      log93.warn("[explorer-media] Media file not found", {
+      log94.warn("[explorer-media] Media file not found", {
         threadId,
         filePath,
         absPath
@@ -52958,7 +53566,7 @@ async function handleGetExplorerMedia(c, threadManager) {
     const contentType = MEDIA_MIME_TYPES[ext] ?? "application/octet-stream";
     const rangeHeader = c.req.header("range");
     const response = await buildExplorerMediaResponse(absPath, contentType, rangeHeader);
-    log93.info("[explorer-media] Served media file", {
+    log94.info("[explorer-media] Served media file", {
       threadId,
       filePath,
       absPath,
@@ -53003,7 +53611,7 @@ async function handleUploadExplorerFile(c, threadManager) {
       absParent = validated;
     }
     try {
-      const parentStat = await stat7(absParent);
+      const parentStat = await stat8(absParent);
       if (!parentStat.isDirectory()) {
         return c.json({ error: { code: "NOT_FOUND", message: "Directory not found" } }, 404);
       }
@@ -53031,7 +53639,7 @@ async function handleUploadExplorerFile(c, threadManager) {
       throw error;
     }
     const relPath = dirPath ? `${dirPath}/${name}` : name;
-    log93.info("[explorer-upload] Uploaded dropped file", {
+    log94.info("[explorer-upload] Uploaded dropped file", {
       threadId,
       dirPath,
       name,
@@ -53094,7 +53702,7 @@ async function handleCreateExplorerFolder(c, threadManager) {
     );
   }
 }
-var log93, Utils2, utilsLoaded2, MEDIA_MIME_TYPES, EXPLORER_MEDIA_RESPONSE_HEADERS;
+var log94, Utils2, utilsLoaded2, MEDIA_MIME_TYPES, EXPLORER_MEDIA_RESPONSE_HEADERS;
 var init_threads_explorer_route = __esm({
   "src/features/threads/threads-explorer.route.ts"() {
     "use strict";
@@ -53103,7 +53711,7 @@ var init_threads_explorer_route = __esm({
     init_error_responses();
     init_ai_files_ops();
     init_paths();
-    log93 = createLogger("threads.explorer");
+    log94 = createLogger("threads.explorer");
     Utils2 = null;
     utilsLoaded2 = false;
     MEDIA_MIME_TYPES = EXPLORER_MEDIA_MIME_TYPES;
@@ -53182,7 +53790,7 @@ async function handleOpenThread(c, threadManager) {
         422
       );
     }
-    log94.info("Opening thread in external program", {
+    log95.info("Opening thread in external program", {
       threadId,
       program,
       threadPath
@@ -53191,10 +53799,10 @@ async function handleOpenThread(c, threadManager) {
       await open3(threadPath, {
         app: { name: appNames }
       });
-      log94.info("[POST /api/threads/:id/open] Successfully opened thread in %s", program);
+      log95.info("[POST /api/threads/:id/open] Successfully opened thread in %s", program);
     } catch (openError) {
       const message = openError instanceof Error ? openError.message : String(openError);
-      log94.error("[POST /api/threads/:id/open] Failed to open thread:", message);
+      log95.error("[POST /api/threads/:id/open] Failed to open thread:", message);
       return errorResponse(
         c,
         ErrorCodes.OPEN_PROGRAM_ERROR,
@@ -53214,7 +53822,7 @@ async function handleOpenThread(c, threadManager) {
     );
   }
 }
-var log94;
+var log95;
 var init_threads_open_route = __esm({
   "src/features/threads/threads-open.route.ts"() {
     "use strict";
@@ -53222,7 +53830,7 @@ var init_threads_open_route = __esm({
     init_projects_open_with();
     init_route_helpers();
     init_error_responses();
-    log94 = createLogger("features.threads.threads-open");
+    log95 = createLogger("features.threads.threads-open");
   }
 });
 
@@ -53396,7 +54004,7 @@ async function listGithubFolderFiles(repoUrl, srcPath, options = {}) {
   const refParam = ref ?? "HEAD";
   const tree = await fetchGithubTree(owner, repo, refParam, token);
   if (tree.truncated) {
-    log95.warn(
+    log96.warn(
       "Warning: the repository tree was truncated by GitHub. Large repos may be incomplete."
     );
   }
@@ -53421,12 +54029,12 @@ async function fetchGithubFolderFile(repoUrl, srcPath, relativePath, options = {
   content = content.replace(/Claude/gi, "Tarsk");
   return content;
 }
-var log95;
+var log96;
 var init_github_folder = __esm({
   "src/features/git/github-folder.ts"() {
     "use strict";
     init_dist();
-    log95 = createLogger("features.git.github-folder");
+    log96 = createLogger("features.git.github-folder");
   }
 });
 
@@ -53437,7 +54045,7 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   const { ref, excludeRelativePrefixes = [] } = options;
   const { files, ref: refParam } = await listGithubFolderFiles(repoUrl, srcPath, options);
   const { owner, repo } = parseGithubRepoUrl(repoUrl);
-  log96.info(`Downloading ${files.length} file(s) from ${owner}/${repo}/${srcPath} \u2192 ${destPath}`);
+  log97.info(`Downloading ${files.length} file(s) from ${owner}/${repo}/${srcPath} \u2192 ${destPath}`);
   await Promise.all(
     files.map(async (relativePath) => {
       const localPath = join39(destPath, relativePath);
@@ -53448,18 +54056,18 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
         excludeRelativePrefixes
       });
       await writeFile9(localPath, content, "utf8");
-      log96.info(`  \u2713 ${relativePath}`);
+      log97.info(`  \u2713 ${relativePath}`);
     })
   );
-  log96.info("Done.");
+  log97.info("Done.");
 }
-var log96;
+var log97;
 var init_git_download_folder = __esm({
   "src/features/git/git-download-folder.ts"() {
     "use strict";
     init_dist();
     init_github_folder();
-    log96 = createLogger("features.git.git-download-folder");
+    log97 = createLogger("features.git.git-download-folder");
   }
 });
 
@@ -53753,7 +54361,7 @@ var init_skills_sources = __esm({
 });
 
 // src/features/skills/skills.catalog-cache.ts
-import { cp, mkdtemp as mkdtemp2, readdir as readdir13, readFile as readFile18, rm as rm9 } from "fs/promises";
+import { cp as cp2, mkdtemp as mkdtemp2, readdir as readdir14, readFile as readFile18, rm as rm9 } from "fs/promises";
 import { join as join40, relative as relative8, sep as sep4 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 function getBundledSkillSourceById(sourceId) {
@@ -53774,7 +54382,7 @@ function normalizeSkillContent(content) {
   return content.replace(/Claude/gi, "Tarsk");
 }
 async function listFilesRecursive(dir, rootDir = dir) {
-  const entries = await readdir13(dir, { withFileTypes: true });
+  const entries = await readdir14(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = join40(dir, entry.name);
@@ -53912,7 +54520,7 @@ async function readCachedCatalogSkillFile(sourceId, skillId, relativePath) {
 }
 async function copyCachedCatalogSkillToDirectory(sourceId, skillId, destPath) {
   const skillDir = await getSkillDirEnsured(sourceId, skillId);
-  await cp(skillDir, destPath, { recursive: true });
+  await cp2(skillDir, destPath, { recursive: true });
 }
 var inFlightRefreshes;
 var init_skills_catalog_cache = __esm({
@@ -55310,50 +55918,50 @@ var init_git_commit_route = __esm({
 async function gitPushHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
-    log97.info("Starting push", { threadId });
+    log98.info("Starting push", { threadId });
     const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
     if (!thread) {
-      log97.warn("Thread not found", { threadId });
+      log98.warn("Thread not found", { threadId });
       return c.json({ error: "Thread not found" }, 404);
     }
-    log97.info("Thread found", { threadId, title: thread.title });
+    log98.info("Thread found", { threadId, title: thread.title });
     const repoPath = thread.path;
     if (!repoPath) {
-      log97.warn("Thread path not found", { threadId });
+      log98.warn("Thread path not found", { threadId });
       return c.json({ error: "Thread path not found" }, 404);
     }
     const absolutePath = resolveThreadPath(repoPath);
-    log97.info("Resolved thread path", { absolutePath });
+    log98.info("Resolved thread path", { absolutePath });
     let gitRoot;
     try {
       gitRoot = await getGitRoot(absolutePath);
-      log97.info("Resolved git root", { gitRoot });
+      log98.info("Resolved git root", { gitRoot });
     } catch {
-      log97.warn("Path is not a git repository", { absolutePath });
+      log98.warn("Path is not a git repository", { absolutePath });
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
     const currentBranch = await getCurrentBranch(gitRoot);
-    log97.info("Resolved current branch", { currentBranch });
-    log97.info("Pushing branch to origin", { currentBranch });
+    log98.info("Resolved current branch", { currentBranch });
+    log98.info("Pushing branch to origin", { currentBranch });
     await pushToOrigin(gitRoot, currentBranch);
-    log97.info("Successfully pushed branch to origin", { currentBranch });
+    log98.info("Successfully pushed branch to origin", { currentBranch });
     return c.json({ success: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to push changes";
-    log97.error("Push failed", { message });
-    log97.error("Push failed stack", {
+    log98.error("Push failed", { message });
+    log98.error("Push failed stack", {
       stack: error instanceof Error ? error.stack : "No stack available"
     });
     return c.json({ error: message }, 500);
   }
 }
-var log97;
+var log98;
 var init_git_push_route = __esm({
   "src/features/git/git-push.route.ts"() {
     "use strict";
     init_logger2();
     init_git_utils();
-    log97 = createLogger("git.push");
+    log98 = createLogger("git.push");
   }
 });
 
@@ -55407,16 +56015,16 @@ var init_git_fetch_route = __esm({
 async function gitGeneratePrInfoHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
-    log98.info("Starting PR info generation", { threadId });
+    log99.info("Starting PR info generation", { threadId });
     if (!threadId) {
       return c.json({ error: "Thread ID is required" }, 400);
     }
     const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
     if (!thread) {
-      log98.warn("Thread not found", { threadId });
+      log99.warn("Thread not found", { threadId });
       return c.json({ error: "Thread not found" }, 404);
     }
-    log98.info("Thread found", {
+    log99.info("Thread found", {
       threadId,
       title: thread.title,
       model: thread.model,
@@ -55424,13 +56032,13 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
     });
     const repoPath = thread.path;
     if (!repoPath) {
-      log98.warn("Thread path not found", { threadId });
+      log99.warn("Thread path not found", { threadId });
       return c.json({ error: "Thread path not found" }, 404);
     }
     const body = await c.req.json().catch(() => ({}));
     const provider = body.provider ?? thread.modelProvider;
     if (!provider) {
-      log98.warn("Provider not found in request or thread metadata", { threadId });
+      log99.warn("Provider not found in request or thread metadata", { threadId });
       return c.json(
         {
           title: "Update",
@@ -55441,30 +56049,30 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
       );
     }
     const model = body.model ?? thread.model;
-    log98.info("Using provider and model", { provider, model });
+    log99.info("Using provider and model", { provider, model });
     const absolutePath = resolveThreadPath(repoPath);
-    log98.info("Resolved thread path", { absolutePath });
+    log99.info("Resolved thread path", { absolutePath });
     let gitRoot;
     try {
       gitRoot = await getGitRoot(absolutePath);
-      log98.info("Resolved git root", { gitRoot });
+      log99.info("Resolved git root", { gitRoot });
     } catch {
-      log98.warn("Path is not a git repository", { absolutePath });
+      log99.warn("Path is not a git repository", { absolutePath });
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
     const currentBranch = await getCurrentBranch(gitRoot);
-    log98.info("Resolved current branch", { currentBranch });
-    log98.info("Collecting uncommitted git diff", { gitRoot });
+    log99.info("Resolved current branch", { currentBranch });
+    log99.info("Collecting uncommitted git diff", { gitRoot });
     const uncommittedDiff = await new Promise((resolveDiff, reject) => {
       const runPlainDiff = () => {
-        log98.info("No HEAD found, using plain git diff", { gitRoot });
+        log99.info("No HEAD found, using plain git diff", { gitRoot });
         const proc2 = spawnProcess("git", ["diff"], { cwd: gitRoot });
         let out2 = "";
         proc2.stdout?.on("data", (d) => {
           out2 += d.toString();
         });
         proc2.on("close", () => {
-          log98.info("Collected plain diff", { length: out2.length });
+          log99.info("Collected plain diff", { length: out2.length });
           resolveDiff(out2);
         });
         proc2.on("error", reject);
@@ -55480,46 +56088,46 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          log98.info("Collected HEAD diff", { length: out.length });
+          log99.info("Collected HEAD diff", { length: out.length });
           resolveDiff(out);
         } else {
           const noHead = /HEAD|revision|unknown revision/i.test(err);
           if (noHead) runPlainDiff();
           else {
-            log98.error("Failed to get git diff", { error: err });
+            log99.error("Failed to get git diff", { error: err });
             reject(new Error(err || "Failed to get git diff"));
           }
         }
       });
       proc.on("error", reject);
     });
-    log98.info("Finding base branch", { gitRoot });
+    log99.info("Finding base branch", { gitRoot });
     const baseBranch = await getDefaultBranch(gitRoot);
-    log98.info("Resolved default branch result", { baseBranch });
+    log99.info("Resolved default branch result", { baseBranch });
     const effectiveBaseBranch = baseBranch ?? await findDefaultBranch(gitRoot);
-    log98.info("Resolved effective base branch", { effectiveBaseBranch });
+    log99.info("Resolved effective base branch", { effectiveBaseBranch });
     let commitLog = "";
     if (effectiveBaseBranch && currentBranch !== effectiveBaseBranch) {
-      log98.info("Collecting commit log", { effectiveBaseBranch, currentBranch });
+      log99.info("Collecting commit log", { effectiveBaseBranch, currentBranch });
       commitLog = await getCommitLog(gitRoot, effectiveBaseBranch, currentBranch);
-      log98.info("Collected commit log", { length: commitLog.length });
+      log99.info("Collected commit log", { length: commitLog.length });
     } else {
-      log98.info("No commit log needed", { effectiveBaseBranch, currentBranch });
+      log99.info("No commit log needed", { effectiveBaseBranch, currentBranch });
     }
     let detailedCommits = "";
     if (effectiveBaseBranch && currentBranch !== effectiveBaseBranch && commitLog) {
-      log98.info("Collecting detailed commits", { effectiveBaseBranch, currentBranch });
+      log99.info("Collecting detailed commits", { effectiveBaseBranch, currentBranch });
       detailedCommits = await getDetailedCommits(gitRoot, effectiveBaseBranch, currentBranch);
-      log98.info("Collected detailed commits", { length: detailedCommits.length });
+      log99.info("Collected detailed commits", { length: detailedCommits.length });
     }
     let branchDiff = "";
     if (effectiveBaseBranch && currentBranch !== effectiveBaseBranch) {
-      log98.info("Collecting PR branch diff", { effectiveBaseBranch });
+      log99.info("Collecting PR branch diff", { effectiveBaseBranch });
       branchDiff = await getPrBranchDiff(gitRoot, effectiveBaseBranch);
-      log98.info("Collected PR branch diff", { length: branchDiff.length });
+      log99.info("Collected PR branch diff", { length: branchDiff.length });
     }
     if (!uncommittedDiff.trim() && !commitLog.trim() && !branchDiff.trim()) {
-      log98.warn("No changes found for PR generation", {
+      log99.warn("No changes found for PR generation", {
         uncommittedDiffLength: uncommittedDiff.length,
         commitLogLength: commitLog.length,
         branchDiffLength: branchDiff.length
@@ -55531,7 +56139,7 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
         400
       );
     }
-    log98.info("Calling AI to generate PR info", { provider, model });
+    log99.info("Calling AI to generate PR info", { provider, model });
     const prInfo = await generatePRInfoWithAI(
       commitLog,
       detailedCommits,
@@ -55543,7 +56151,7 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
       model,
       provider
     );
-    log98.info("Generated PR info", {
+    log99.info("Generated PR info", {
       title: prInfo.title,
       descriptionLength: prInfo.description.length
     });
@@ -55559,14 +56167,14 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
         metadataManager
       );
       if (newBranch !== branchBeforeRename) {
-        log98.info("Renamed branch for PR", { oldBranch: branchBeforeRename, newBranch });
+        log99.info("Renamed branch for PR", { oldBranch: branchBeforeRename, newBranch });
       }
     } catch (branchError) {
-      log98.warn("Failed to rename branch during PR info generation", {
+      log99.warn("Failed to rename branch during PR info generation", {
         error: branchError instanceof Error ? branchError.message : String(branchError)
       });
     }
-    log98.info("PR generation completed successfully", {
+    log99.info("PR generation completed successfully", {
       threadId,
       currentBranch: newBranch,
       baseBranch: effectiveBaseBranch
@@ -55578,10 +56186,10 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
       currentBranch: newBranch
     });
   } catch (error) {
-    log98.error("Error during PR generation", {
+    log99.error("Error during PR generation", {
       message: error instanceof Error ? error.message : String(error)
     });
-    log98.error("PR generation stack", {
+    log99.error("PR generation stack", {
       stack: error instanceof Error ? error.stack : "No stack available"
     });
     return c.json({
@@ -55593,14 +56201,14 @@ async function gitGeneratePrInfoHandler(c, metadataManager) {
     });
   }
 }
-var log98;
+var log99;
 var init_git_generate_pr_info_route = __esm({
   "src/features/git/git-generate-pr-info.route.ts"() {
     "use strict";
     init_utils();
     init_git_utils();
     init_logger2();
-    log98 = createLogger("git.generate-pr-info");
+    log99 = createLogger("git.generate-pr-info");
   }
 });
 
@@ -55635,36 +56243,36 @@ async function gitCreatePrHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
     const body = await c.req.json();
-    const { title, description } = body;
-    log99.info("Starting PR creation", { threadId });
-    log99.info("Received PR title", { title });
-    log99.info("Received PR description", { descriptionLength: description?.length ?? 0 });
+    const { title, description, baseBranch } = body;
+    log100.info("Starting PR creation", { threadId });
+    log100.info("Received PR title", { title });
+    log100.info("Received PR description", { descriptionLength: description?.length ?? 0 });
     const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
     if (!threadId) {
       return c.json({ error: "Thread ID is required" }, 400);
     }
     if (!thread) {
-      log99.warn("Thread not found", { threadId });
+      log100.warn("Thread not found", { threadId });
       return c.json({ error: "Thread not found" }, 404);
     }
-    log99.info("Thread found", { threadId, title: thread.title });
+    log100.info("Thread found", { threadId, title: thread.title });
     const repoPath = thread.path;
     if (!repoPath) {
-      log99.warn("Thread path not found", { threadId });
+      log100.warn("Thread path not found", { threadId });
       return c.json({ error: "Thread path not found" }, 404);
     }
     const absolutePath = resolveThreadPath(repoPath);
-    log99.info("Resolved thread path", { absolutePath });
+    log100.info("Resolved thread path", { absolutePath });
     let gitRoot;
     try {
       gitRoot = await getGitRoot(absolutePath);
-      log99.info("Resolved git root", { gitRoot });
+      log100.info("Resolved git root", { gitRoot });
     } catch {
-      log99.warn("Path is not a git repository", { absolutePath });
+      log100.warn("Path is not a git repository", { absolutePath });
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
     const currentBranch = await getCurrentBranch(gitRoot);
-    log99.info("Resolved current branch", { currentBranch });
+    log100.info("Resolved current branch", { currentBranch });
     const trimmedTitle = title?.trim();
     const prTitle = trimmedTitle ? trimmedTitle : currentBranch;
     const prDescription = description ?? "";
@@ -55676,33 +56284,33 @@ async function gitCreatePrHandler(c, metadataManager) {
       prDescription,
       metadataManager
     ) : await pushBranchForPr(gitRoot, currentBranch);
-    log99.info("Resolved branch name for PR", { branchName });
-    log99.info("Creating pull request with GitHub CLI", { branchName });
-    const prUrl = await createPullRequest(gitRoot, branchName, prTitle, prDescription);
-    log99.info("Pull request created successfully", { prUrl });
+    log100.info("Resolved branch name for PR", { branchName });
+    log100.info("Creating pull request with GitHub CLI", { branchName });
+    const prUrl = baseBranch ? await createPullRequest(gitRoot, branchName, prTitle, prDescription, baseBranch) : await createPullRequest(gitRoot, branchName, prTitle, prDescription);
+    log100.info("Pull request created successfully", { prUrl });
     const normalizedPrTitle = normalizeThreadTitle(prTitle);
     if (normalizedPrTitle !== thread.title) {
       const threadUpdates = { title: normalizedPrTitle };
       await metadataManager.updateThreadFields(threadId, threadUpdates);
-      log99.info("Updated thread title to PR title", { normalizedPrTitle });
+      log100.info("Updated thread title to PR title", { normalizedPrTitle });
     }
     return c.json({ success: true, prUrl, title: normalizedPrTitle, branchName });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to create PR";
-    log99.error("Pull request creation failed", { message });
-    log99.error("Pull request creation stack", {
+    log100.error("Pull request creation failed", { message });
+    log100.error("Pull request creation stack", {
       stack: error instanceof Error ? error.stack : "No stack available"
     });
     return c.json({ error: message }, 500);
   }
 }
-var log99;
+var log100;
 var init_git_create_pr_route = __esm({
   "src/features/git/git-create-pr.route.ts"() {
     "use strict";
     init_logger2();
     init_git_utils();
-    log99 = createLogger("git.create-pr");
+    log100 = createLogger("git.create-pr");
   }
 });
 
@@ -55735,7 +56343,7 @@ async function gitGithubStatusHandler(c, metadataManager) {
           status = await getGitSyncStatus(gitRoot, currentBranch);
         }
       } catch (error) {
-        log100.warn(
+        log101.warn(
           `Failed to check git sync status: ${error instanceof Error ? error.message : String(error)}`
         );
         status = "Up to date";
@@ -55753,14 +56361,14 @@ async function gitGithubStatusHandler(c, metadataManager) {
     return c.json({ error: message }, 500);
   }
 }
-var log100;
+var log101;
 var init_git_github_status_route = __esm({
   "src/features/git/git-github-status.route.ts"() {
     "use strict";
     init_dist();
     init_git_utils();
     init_git_route_context();
-    log100 = createLogger("features.git.git-github-status");
+    log101 = createLogger("features.git.git-github-status");
   }
 });
 
@@ -55786,12 +56394,12 @@ function createServerStepTracker(threadId) {
       return await fn();
     } finally {
       const ms = Date.now() - start;
-      log101.info(`[gitops-timing] unified-status thread=${threadId} step=${name} ${ms}ms`);
+      log102.info(`[gitops-timing] unified-status thread=${threadId} step=${name} ${ms}ms`);
     }
   }
   function record(name, start, extra) {
     const ms = Date.now() - start;
-    log101.info(
+    log102.info(
       `[gitops-timing] unified-status thread=${threadId} step=${name} ${ms}ms${extra ? ` ${extra}` : ""}`
     );
   }
@@ -55903,7 +56511,7 @@ function runUnifiedGitStatusRefresh(db, threadId, fresh) {
       }
       await refreshTracker.step("db-cache-write", () => setGitStatusCache(db, threadId, result));
     } catch (error) {
-      log101.error("Failed to refresh unified git status in background:", error);
+      log102.error("Failed to refresh unified git status in background:", error);
     } finally {
       stopLagMonitor();
     }
@@ -55991,7 +56599,7 @@ async function gitUnifiedStatusHandler(c, _metadataManager, db) {
     return c.json({ error: message }, 500);
   }
 }
-var log101;
+var log102;
 var init_git_unified_status_route = __esm({
   "src/features/git/git-unified-status.route.ts"() {
     "use strict";
@@ -56002,7 +56610,7 @@ var init_git_unified_status_route = __esm({
     init_threads_database();
     init_git_utils();
     init_git_subprocess_timing();
-    log101 = createLogger("features.git.git-unified-status");
+    log102 = createLogger("features.git.git-unified-status");
   }
 });
 
@@ -56056,19 +56664,19 @@ async function gitPrStatusHandler(c, metadataManager) {
     const prStatus = await getPullRequestStatus(resolved.context.gitRoot);
     return c.json({ success: true, ...prStatus });
   } catch (error) {
-    log102.error("Failed to check PR status:", error);
+    log103.error("Failed to check PR status:", error);
     const message = error instanceof Error ? error.message : "Failed to check PR status";
     return c.json({ error: message }, 500);
   }
 }
-var log102;
+var log103;
 var init_git_pr_status_route = __esm({
   "src/features/git/git-pr-status.route.ts"() {
     "use strict";
     init_git_utils();
     init_git_route_context();
     init_dist();
-    log102 = createLogger("features.git.git-pr-status");
+    log103 = createLogger("features.git.git-pr-status");
   }
 });
 
@@ -56128,21 +56736,21 @@ import { existsSync as existsSync27 } from "fs";
 async function gitSyncBranchHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
-    log103.info("Starting branch sync", { threadId });
+    log104.info("Starting branch sync", { threadId });
     const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
     if (!thread) {
-      log103.warn("Thread not found", { threadId });
+      log104.warn("Thread not found", { threadId });
       return c.json({ error: "Thread not found" }, 404);
     }
     const repoPath = thread.path;
     if (!repoPath) {
-      log103.warn("Thread path not found", { threadId });
+      log104.warn("Thread path not found", { threadId });
       return c.json({ error: "Thread path not found" }, 404);
     }
     const absolutePath = resolveThreadPath(repoPath);
-    log103.info("Resolved thread path", { absolutePath });
+    log104.info("Resolved thread path", { absolutePath });
     if (!existsSync27(absolutePath)) {
-      log103.warn("Thread repo path does not exist", { absolutePath });
+      log104.warn("Thread repo path does not exist", { absolutePath });
       return c.json(
         {
           error: `Thread repo path does not exist: ${absolutePath}`
@@ -56153,10 +56761,10 @@ async function gitSyncBranchHandler(c, metadataManager) {
     let gitRoot;
     try {
       gitRoot = await getGitRoot(absolutePath);
-      log103.info("Resolved git root", { gitRoot });
+      log104.info("Resolved git root", { gitRoot });
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log103.warn("Path is not a git repository", { message: msg });
+      log104.warn("Path is not a git repository", { message: msg });
       return c.json(
         {
           error: `Path is not a git repository: ${msg}`
@@ -56166,9 +56774,9 @@ async function gitSyncBranchHandler(c, metadataManager) {
     }
     const currentBranch = await getCurrentBranch(gitRoot);
     const defaultBranch = await findDefaultBranch(gitRoot);
-    log103.info("Resolved branches for sync", { currentBranch, defaultBranch });
+    log104.info("Resolved branches for sync", { currentBranch, defaultBranch });
     if (!defaultBranch) {
-      log103.warn("Could not determine default branch", { gitRoot });
+      log104.warn("Could not determine default branch", { gitRoot });
       return c.json(
         {
           error: "Could not determine default branch"
@@ -56178,12 +56786,12 @@ async function gitSyncBranchHandler(c, metadataManager) {
     }
     const { spawnProcess: spawnProcess2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
     return new Promise((resolve9) => {
-      log103.info("Checking branch status", { gitRoot, currentBranch });
+      log104.info("Checking branch status", { gitRoot, currentBranch });
       const statusProc = spawnProcess2("git", ["status", "-sb"], { cwd: gitRoot });
       let statusOutput = "";
       statusProc.on("close", (statusCode) => {
         if (statusCode !== 0) {
-          log103.warn("Failed to get git status", { statusCode });
+          log104.warn("Failed to get git status", { statusCode });
           resolve9(
             c.json(
               {
@@ -56196,28 +56804,28 @@ async function gitSyncBranchHandler(c, metadataManager) {
           return;
         }
         statusOutput = statusOutput.trim();
-        log103.debug("Git status output", { statusOutput });
+        log104.debug("Git status output", { statusOutput });
         const isDiverged = statusOutput.includes("ahead") && statusOutput.includes("behind");
         if (isDiverged) {
-          log103.info("Branch is diverged, pushing commits first", { currentBranch });
+          log104.info("Branch is diverged, pushing commits first", { currentBranch });
           const pushProc = spawnProcess2("git", ["push", "origin", currentBranch], { cwd: gitRoot });
           let pushOut = "";
           let pushErr = "";
           if (pushProc.stdout) {
             pushProc.stdout.on("data", (d) => {
               pushOut += d.toString();
-              log103.debug("Push stdout", { output: d.toString().trim() });
+              log104.debug("Push stdout", { output: d.toString().trim() });
             });
           }
           if (pushProc.stderr) {
             pushProc.stderr.on("data", (d) => {
               pushErr += d.toString();
-              log103.debug("Push stderr", { output: d.toString().trim() });
+              log104.debug("Push stderr", { output: d.toString().trim() });
             });
           }
           pushProc.on("close", (pushCode) => {
             if (pushCode !== 0) {
-              log103.warn("Failed to push commits before sync", { pushCode });
+              log104.warn("Failed to push commits before sync", { pushCode });
               resolve9(
                 c.json(
                   {
@@ -56229,11 +56837,11 @@ async function gitSyncBranchHandler(c, metadataManager) {
               );
               return;
             }
-            log103.info("Pushed commits successfully before sync", { currentBranch });
+            log104.info("Pushed commits successfully before sync", { currentBranch });
             performSync();
           });
           pushProc.on("error", (error) => {
-            log103.error("Push process error", {
+            log104.error("Push process error", {
               message: error instanceof Error ? error.message : String(error)
             });
             resolve9(
@@ -56246,7 +56854,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             );
           });
         } else {
-          log103.info("Branch is not diverged, proceeding with sync", {
+          log104.info("Branch is not diverged, proceeding with sync", {
             currentBranch,
             defaultBranch
           });
@@ -56264,7 +56872,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
         });
       }
       statusProc.on("error", (error) => {
-        log103.error("Status process error", {
+        log104.error("Status process error", {
           message: error instanceof Error ? error.message : String(error)
         });
         resolve9(
@@ -56277,11 +56885,11 @@ async function gitSyncBranchHandler(c, metadataManager) {
         );
       });
       function performSync() {
-        log103.info("Configuring git pull strategy to rebase", { gitRoot });
+        log104.info("Configuring git pull strategy to rebase", { gitRoot });
         const configProc = spawnProcess2("git", ["config", "pull.rebase", "true"], { cwd: gitRoot });
         configProc.on("close", (configCode) => {
           if (configCode !== 0) {
-            log103.warn("Failed to configure git pull strategy", { configCode });
+            log104.warn("Failed to configure git pull strategy", { configCode });
             resolve9(
               c.json(
                 {
@@ -56293,8 +56901,8 @@ async function gitSyncBranchHandler(c, metadataManager) {
             );
             return;
           }
-          log103.info("Configured git pull strategy", { gitRoot });
-          log103.info("Starting git pull rebase", { defaultBranch });
+          log104.info("Configured git pull strategy", { gitRoot });
+          log104.info("Starting git pull rebase", { defaultBranch });
           const pullProc = spawnProcess2("git", ["pull", "--rebase", "origin", defaultBranch], {
             cwd: gitRoot
           });
@@ -56303,19 +56911,19 @@ async function gitSyncBranchHandler(c, metadataManager) {
           if (pullProc.stdout) {
             pullProc.stdout.on("data", (d) => {
               out += d.toString();
-              log103.debug("Pull stdout", { output: d.toString().trim() });
+              log104.debug("Pull stdout", { output: d.toString().trim() });
             });
           }
           if (pullProc.stderr) {
             pullProc.stderr.on("data", (d) => {
               err += d.toString();
-              log103.debug("Pull stderr", { output: d.toString().trim() });
+              log104.debug("Pull stderr", { output: d.toString().trim() });
             });
           }
           pullProc.on("close", (code) => {
             if (code === 0) {
               const message = currentBranch === defaultBranch ? `Successfully pulled latest changes from origin/${defaultBranch}` : `Successfully synced ${currentBranch} with ${defaultBranch}`;
-              log103.info("Branch sync completed successfully", {
+              log104.info("Branch sync completed successfully", {
                 message,
                 branch: currentBranch,
                 defaultBranch
@@ -56329,8 +56937,8 @@ async function gitSyncBranchHandler(c, metadataManager) {
                 })
               );
             } else {
-              log103.warn("Failed to sync branch", { code, defaultBranch });
-              log103.warn("Branch sync error output", { output: err || out });
+              log104.warn("Failed to sync branch", { code, defaultBranch });
+              log104.warn("Branch sync error output", { output: err || out });
               resolve9(
                 c.json(
                   {
@@ -56343,7 +56951,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
             }
           });
           pullProc.on("error", (error) => {
-            log103.error("Branch sync process error", {
+            log104.error("Branch sync process error", {
               message: error instanceof Error ? error.message : String(error)
             });
             resolve9(
@@ -56357,7 +56965,7 @@ async function gitSyncBranchHandler(c, metadataManager) {
           });
         });
         configProc.on("error", (error) => {
-          log103.error("Git config process error", {
+          log104.error("Git config process error", {
             message: error instanceof Error ? error.message : String(error)
           });
           resolve9(
@@ -56373,17 +56981,17 @@ async function gitSyncBranchHandler(c, metadataManager) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to sync branch";
-    log103.error("Unexpected branch sync error", { message });
+    log104.error("Unexpected branch sync error", { message });
     return c.json({ error: message }, 500);
   }
 }
-var log103;
+var log104;
 var init_git_sync_branch_route = __esm({
   "src/features/git/git-sync-branch.route.ts"() {
     "use strict";
     init_logger2();
     init_git_utils();
-    log103 = createLogger("git.sync-branch");
+    log104 = createLogger("git.sync-branch");
   }
 });
 
@@ -56689,7 +57297,7 @@ async function gitCheckpointHandler(c, metadataManager) {
     }
     const repoPath = thread.path;
     if (!repoPath) {
-      log104.debug("Checkpoint skipped: thread has no path", { threadId });
+      log105.debug("Checkpoint skipped: thread has no path", { threadId });
       return c.json({ success: false, reason: "no_path" });
     }
     const absolutePath = resolveThreadPath(repoPath);
@@ -56697,36 +57305,36 @@ async function gitCheckpointHandler(c, metadataManager) {
     try {
       gitRoot = await getGitRoot(absolutePath);
     } catch {
-      log104.debug("Checkpoint skipped: not a git repository", { threadId, absolutePath });
+      log105.debug("Checkpoint skipped: not a git repository", { threadId, absolutePath });
       return c.json({ success: false, reason: "not_a_git_repo" });
     }
     const commitCount = await getCommitCount(gitRoot);
     if (commitCount === 0) {
-      log104.debug("Checkpoint skipped: repository has no commits", { threadId, gitRoot });
+      log105.debug("Checkpoint skipped: repository has no commits", { threadId, gitRoot });
       return c.json({ success: true, stashed: false, reason: "no_commits" });
     }
     const label = `tarsk-checkpoint:${messageId}`;
     const stashed = await stashWithLabel(gitRoot, label);
     if (stashed) {
-      log104.info("Checkpoint created", { threadId, messageId, gitRoot });
+      log105.info("Checkpoint created", { threadId, messageId, gitRoot });
     } else {
-      log104.info("Checkpoint recorded with clean working tree", { threadId, messageId, gitRoot });
+      log105.info("Checkpoint recorded with clean working tree", { threadId, messageId, gitRoot });
     }
     return c.json({ success: true, stashed, checkpointRef: label });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to create checkpoint";
-    log104.error("Checkpoint creation failed", { threadId: c.req.param("threadId"), error: message });
+    log105.error("Checkpoint creation failed", { threadId: c.req.param("threadId"), error: message });
     return c.json({ error: message }, 500);
   }
 }
-var log104;
+var log105;
 var init_git_checkpoint_route = __esm({
   "src/features/git/git-checkpoint.route.ts"() {
     "use strict";
     init_dist();
     init_git_utils();
     init_utils();
-    log104 = createLogger("git.checkpoint");
+    log105 = createLogger("git.checkpoint");
   }
 });
 
@@ -56822,15 +57430,15 @@ async function gitCheckpointRestoreHandler(c, metadataManager, conversationManag
     const match = stashes.find((s) => s.label === checkpointRef);
     if (!match) {
       if (checkpointRef.startsWith(TARSK_CHECKPOINT_PREFIX)) {
-        log105.info("Restoring clean-tree checkpoint", { threadId, checkpointRef, gitRoot });
+        log106.info("Restoring clean-tree checkpoint", { threadId, checkpointRef, gitRoot });
         await discardWorkingChanges(gitRoot);
         await truncateConversationFromCheckpoint(conversationManager, threadId, checkpointRef);
         return c.json({ success: true });
       }
-      log105.warn("Checkpoint not found in stash list", { threadId, checkpointRef, gitRoot });
+      log106.warn("Checkpoint not found in stash list", { threadId, checkpointRef, gitRoot });
       return c.json({ error: "Checkpoint not found in stash list" }, 404);
     }
-    log105.info("Restoring stash checkpoint", {
+    log106.info("Restoring stash checkpoint", {
       threadId,
       checkpointRef,
       gitRoot,
@@ -56842,26 +57450,26 @@ async function gitCheckpointRestoreHandler(c, metadataManager, conversationManag
     return c.json({ success: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to restore checkpoint";
-    log105.error("Checkpoint restore failed", { threadId: c.req.param("threadId"), error: message });
+    log106.error("Checkpoint restore failed", { threadId: c.req.param("threadId"), error: message });
     return c.json({ error: message }, 500);
   }
 }
 async function truncateConversationFromCheckpoint(conversationManager, threadId, checkpointRef) {
   const deletedCount = await conversationManager.truncateFromCheckpoint(threadId, checkpointRef);
-  log105.info("Removed conversation messages after checkpoint restore", {
+  log106.info("Removed conversation messages after checkpoint restore", {
     threadId,
     checkpointRef,
     deletedCount
   });
 }
-var log105, TARSK_CHECKPOINT_PREFIX;
+var log106, TARSK_CHECKPOINT_PREFIX;
 var init_git_checkpoint_restore_route = __esm({
   "src/features/git/git-checkpoint-restore.route.ts"() {
     "use strict";
     init_dist();
     init_git_utils();
     init_utils();
-    log105 = createLogger("git.checkpoint-restore");
+    log106 = createLogger("git.checkpoint-restore");
     TARSK_CHECKPOINT_PREFIX = "tarsk-checkpoint:";
   }
 });
@@ -57146,7 +57754,7 @@ function createUpdateRoutes(updater) {
         supported: true
       });
     } catch (error) {
-      log106.error("Failed to check for update", error);
+      log107.error("Failed to check for update", error);
       return c.json({ updateAvailable: false, supported: true, error: "Check failed" });
     }
   });
@@ -57163,18 +57771,18 @@ function createUpdateRoutes(updater) {
       }
       return c.json({ success: false, message: "Update downloaded but not ready to apply" });
     } catch (error) {
-      log106.error("Failed to apply update", error);
+      log107.error("Failed to apply update", error);
       return c.json({ error: "Failed to apply update" }, 500);
     }
   });
   return app;
 }
-var log106;
+var log107;
 var init_updates_routes = __esm({
   "src/features/updates/updates.routes.ts"() {
     "use strict";
     init_dist();
-    log106 = createLogger("updates.routes");
+    log107 = createLogger("updates.routes");
   }
 });
 
@@ -57350,12 +57958,12 @@ async function performMCPOAuthFlow(options) {
     onRedirect: async (authorizationUrl) => {
       const url = authorizationUrl.toString();
       onAuthorizationUrl?.(url);
-      log107.info("Opening MCP OAuth authorization URL", { serverName });
+      log108.info("Opening MCP OAuth authorization URL", { serverName });
       await openExternalUrlInSystemBrowser(url);
     }
   });
   if (!oauthConfig?.clientId) {
-    log107.debug("No pre-registered OAuth clientId; will attempt DCR or CIMD", {
+    log108.debug("No pre-registered OAuth clientId; will attempt DCR or CIMD", {
       serverName
     });
   }
@@ -57479,7 +58087,7 @@ async function performMCPOAuthFlow(options) {
           try {
             const result2 = await sdkAuth(provider, { serverUrl });
             if (result2 !== "REDIRECT") {
-              log107.warn("Unexpected MCP OAuth auth result before redirect", {
+              log108.warn("Unexpected MCP OAuth auth result before redirect", {
                 serverName,
                 result: result2
               });
@@ -57512,7 +58120,7 @@ async function performMCPOAuthFlow(options) {
     if (result !== "AUTHORIZED") {
       throw new Error(`Unexpected MCP OAuth result: ${result}`);
     }
-    log107.info("MCP OAuth authorization succeeded", { serverName });
+    log108.info("MCP OAuth authorization succeeded", { serverName });
     return {
       authorized: true,
       authorizationUrl: provider.authorizationUrl
@@ -57521,7 +58129,7 @@ async function performMCPOAuthFlow(options) {
     cleanup();
   }
 }
-var log107, AUTH_TIMEOUT_MS;
+var log108, AUTH_TIMEOUT_MS;
 var init_mcp_oauth_flow = __esm({
   "src/features/mcp/mcp.oauth-flow.ts"() {
     "use strict";
@@ -57529,7 +58137,7 @@ var init_mcp_oauth_flow = __esm({
     init_open_external_url();
     init_mcp_oauth_provider();
     init_mcp_oauth_port();
-    log107 = createLogger("mcp.oauth.flow");
+    log108 = createLogger("mcp.oauth.flow");
     AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
   }
 });
@@ -57699,7 +58307,7 @@ function createMCPRoutes() {
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      log108.warn("MCP OAuth authorize failed", { projectPath, serverName, error: message });
+      log109.warn("MCP OAuth authorize failed", { projectPath, serverName, error: message });
       return c.json({ error: { code: "OAUTH_ERROR", message } }, 500);
     }
   });
@@ -57784,12 +58392,12 @@ function createMCPRoutes() {
     const limit = c.req.query("limit") ?? "10";
     const url = `https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(q)}&limit=${encodeURIComponent(limit)}`;
     try {
-      log108.debug("Fetching MCP registry search results", { url, query: q, limit });
+      log109.debug("Fetching MCP registry search results", { url, query: q, limit });
       const response = await fetch(url, {
         headers: { Accept: "application/json" }
       });
       if (!response.ok) {
-        log108.warn("MCP registry returned non-OK response", {
+        log109.warn("MCP registry returned non-OK response", {
           status: response.status,
           statusText: response.statusText,
           url
@@ -57800,7 +58408,7 @@ function createMCPRoutes() {
         );
       }
       const data = await response.json();
-      log108.debug("Received MCP registry search response", {
+      log109.debug("Received MCP registry search response", {
         url,
         resultCount: data.servers?.length,
         data
@@ -57808,7 +58416,7 @@ function createMCPRoutes() {
       return c.json(data);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      log108.error("Failed to fetch MCP registry search results", {
+      log109.error("Failed to fetch MCP registry search results", {
         url,
         query: q,
         limit,
@@ -57819,7 +58427,7 @@ function createMCPRoutes() {
   });
   return router;
 }
-var MCP_CONFIG_PATHS2, log108;
+var MCP_CONFIG_PATHS2, log109;
 var init_mcp_routes = __esm({
   "src/features/mcp/mcp.routes.ts"() {
     "use strict";
@@ -57830,7 +58438,7 @@ var init_mcp_routes = __esm({
     init_mcp_oauth_store();
     init_mcp_tools();
     MCP_CONFIG_PATHS2 = [".agents/mcp.json", "mcp.json"];
-    log108 = createLogger("mcp.routes");
+    log109 = createLogger("mcp.routes");
   }
 });
 
@@ -57935,7 +58543,7 @@ var init_skills_popular = __esm({
 });
 
 // src/features/skills/skills.catalog.ts
-import { readdir as readdir14, readFile as readFile20 } from "fs/promises";
+import { readdir as readdir15, readFile as readFile20 } from "fs/promises";
 import { join as join43 } from "path";
 function getSkillSources() {
   const sources = skills_sources_default;
@@ -57949,7 +58557,7 @@ async function getAllSkillSources() {
   return [...bundled, ...uniqueCustom].sort((a, b) => a.title.localeCompare(b.title));
 }
 async function scanDownloadedSkillCatalog(tmpDir, parsed, sourceId) {
-  const entries = await readdir14(tmpDir, { withFileTypes: true });
+  const entries = await readdir15(tmpDir, { withFileTypes: true });
   const catalogItems = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
@@ -58392,12 +59000,6 @@ async function resolvePreferredTaskTitleModel(metadataManager, options) {
       return resolveModelAndKey(thread.modelProvider, thread.model, metadataManager);
     }
   }
-  for (const [slug, defaultModel] of Object.entries(DEFAULT_MODELS)) {
-    const resolved = await resolveModelAndKey(slug, defaultModel, metadataManager);
-    if (resolved) {
-      return resolved;
-    }
-  }
   return null;
 }
 async function generateProjectTaskTitle(description, metadataManager, options) {
@@ -58425,11 +59027,11 @@ Todo description: ${trimmed}`;
     return title || fallbackTitle;
   } catch (error) {
     const details = error instanceof Error ? error.stack ?? error.message : String(error);
-    log109.error("[project-tasks.title] Failed to generate task title:", details);
+    log110.error("[project-tasks.title] Failed to generate task title:", details);
     return fallbackTitle;
   }
 }
-var log109, DEFAULT_MODELS;
+var log110;
 var init_project_tasks_title = __esm({
   "src/features/project-tasks/project-tasks.title.ts"() {
     "use strict";
@@ -58438,14 +59040,7 @@ var init_project_tasks_title = __esm({
     init_database();
     init_threads_database();
     init_dist();
-    log109 = createLogger("features.project-tasks.project-tasks.title");
-    DEFAULT_MODELS = {
-      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"
-    };
+    log110 = createLogger("features.project-tasks.project-tasks.title");
   }
 });
 
@@ -58711,7 +59306,7 @@ function removeFileIfPresent(filePath) {
       fs4.unlinkSync(filePath);
     }
   } catch (error) {
-    log110.warn(`Failed to remove ${filePath}:`, error);
+    log111.warn(`Failed to remove ${filePath}:`, error);
   }
 }
 async function deleteAccount(c) {
@@ -58724,22 +59319,22 @@ async function deleteAccount(c) {
     clearLogBuffer();
     clearFileLog();
     removeFileIfPresent(getFileLoggingPath());
-    log110.info("Account deleted: database and logs removed");
+    log111.info("Account deleted: database and logs removed");
     return c.json({ success: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to delete account";
-    log110.error("Failed to delete account:", error);
+    log111.error("Failed to delete account:", error);
     return c.json({ error: message }, 500);
   }
 }
-var log110, DB_SIDECAR_SUFFIXES;
+var log111, DB_SIDECAR_SUFFIXES;
 var init_account_delete_route = __esm({
   "src/features/account/account-delete.route.ts"() {
     "use strict";
     init_dist();
     init_database();
     init_file_log_transport();
-    log110 = createLogger("features.account.account-delete");
+    log111 = createLogger("features.account.account-delete");
     DB_SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
   }
 });
@@ -59176,13 +59771,13 @@ async function runChannelPrompt(params) {
       })
     });
   } catch (error) {
-    log111.error("Failed to reach chat API from Control Channel", { error, threadId });
+    log112.error("Failed to reach chat API from Control Channel", { error, threadId });
     return { reply: "", error: formatChatConnectionError(error) };
   }
   if (response.status === 409) {
     const resumeThreadId = await readResumeThreadId(response);
     if (resumeThreadId) {
-      log111.warn("Chat POST conflict; resuming accepted turn via subscribe", {
+      log112.warn("Chat POST conflict; resuming accepted turn via subscribe", {
         threadId: resumeThreadId,
         idempotencyKey
       });
@@ -59224,7 +59819,7 @@ async function runChannelPrompt(params) {
     });
   }
   const interruptError = initial.error;
-  log111.warn("Chat stream interrupted before complete; starting recovery", {
+  log112.warn("Chat stream interrupted before complete; starting recovery", {
     threadId,
     interruptedByError: initial.interruptedByError,
     error: interruptError
@@ -59245,7 +59840,7 @@ async function runChannelPrompt(params) {
       needsUiInput: handlerCtx.needsUiInput
     });
   }
-  log111.error("Chat stream recovery exhausted for Control Channel", {
+  log112.error("Chat stream recovery exhausted for Control Channel", {
     error: interruptError ?? recovered.error,
     threadId
   });
@@ -59309,7 +59904,7 @@ async function recoverChatStreamViaSubscribe(params) {
       response = await fetch(subscribeUrl);
     } catch (error) {
       lastError = error;
-      log111.warn("Chat stream subscribe recovery attempt failed", {
+      log112.warn("Chat stream subscribe recovery attempt failed", {
         threadId,
         attempt: attempt + 1,
         error
@@ -59317,7 +59912,7 @@ async function recoverChatStreamViaSubscribe(params) {
       return { ok: false, done: false };
     }
     if (response.status === 404) {
-      log111.info("Chat stream recovery: turn finished before subscribe", {
+      log112.info("Chat stream recovery: turn finished before subscribe", {
         threadId,
         attempt: attempt + 1
       });
@@ -59325,7 +59920,7 @@ async function recoverChatStreamViaSubscribe(params) {
     }
     if (!response.ok) {
       lastError = new Error(`Subscribe failed (${response.status})`);
-      log111.warn("Chat stream subscribe recovery attempt returned error", {
+      log112.warn("Chat stream subscribe recovery attempt returned error", {
         threadId,
         attempt: attempt + 1,
         status: response.status
@@ -59339,14 +59934,14 @@ async function recoverChatStreamViaSubscribe(params) {
     streamEvents.length = 0;
     const consumed = await consumeNdjsonChatStream(response.body, handleEvent);
     if (consumed.sawComplete) {
-      log111.info("Chat stream recovery succeeded via subscribe", {
+      log112.info("Chat stream recovery succeeded via subscribe", {
         threadId,
         attempt: attempt + 1
       });
       return { ok: true, done: true };
     }
     lastError = consumed.error ?? new Error("Subscribe stream ended without complete");
-    log111.warn("Chat stream subscribe recovery ended before complete", {
+    log112.warn("Chat stream subscribe recovery ended before complete", {
       threadId,
       attempt: attempt + 1,
       error: lastError
@@ -59456,7 +60051,7 @@ async function pollBufferedGateEvents(params) {
       try {
         response = await fetch(`${baseUrl}/api/chat/buffer/${encodeURIComponent(threadId)}`);
       } catch (error) {
-        log111.warn("Buffered gate poll failed", { threadId, error });
+        log112.warn("Buffered gate poll failed", { threadId, error });
         await sleep2(pollIntervalMs);
         continue;
       }
@@ -59473,7 +60068,7 @@ async function pollBufferedGateEvents(params) {
           handleEvent
         });
         if (gateCount > 0) {
-          log111.info("Buffered gate poll: new gates", {
+          log112.info("Buffered gate poll: new gates", {
             threadId,
             gateCount,
             scanned: newEvents.length,
@@ -59485,7 +60080,7 @@ async function pollBufferedGateEvents(params) {
       await promptPendingAskUserFromApi({ baseUrl, handleEvent });
       if (body.processing === false) {
         appendSummaryEventsFromBuffer(handlerCtx.streamEvents, events);
-        log111.info("Buffered gate poll: turn finished", { threadId, totalEvents: events.length });
+        log112.info("Buffered gate poll: turn finished", { threadId, totalEvents: events.length });
         return true;
       }
       await sleep2(pollIntervalMs);
@@ -59504,7 +60099,7 @@ async function watchChannelTurnUntilComplete(params) {
     needsUiInput: false
   };
   const handleEvent = createChannelStreamHandler({ onNeedsUi }, handlerCtx);
-  log111.info("Background Control Channel recovery: polling for gates", { threadId });
+  log112.info("Background Control Channel recovery: polling for gates", { threadId });
   const bufferFinished = await pollBufferedGateEvents({
     baseUrl,
     threadId,
@@ -59512,14 +60107,14 @@ async function watchChannelTurnUntilComplete(params) {
     handlerCtx
   });
   if (bufferFinished) {
-    log111.info("Background Control Channel recovery: turn finished", { threadId });
+    log112.info("Background Control Channel recovery: turn finished", { threadId });
     return finalizeChannelPromptResult({
       streamEvents,
       streamError: handlerCtx.streamError,
       needsUiInput: handlerCtx.needsUiInput
     });
   }
-  log111.error("Background Control Channel recovery exhausted", { threadId });
+  log112.error("Background Control Channel recovery exhausted", { threadId });
   const partial = assistantTextFromChatStreamEvents(streamEvents).trim();
   return {
     reply: partial,
@@ -59679,17 +60274,17 @@ async function stopChannelThread(baseUrl, threadId) {
     });
     return response.ok;
   } catch (error) {
-    log111.warn("Failed to stop thread from Control Channel", { error, threadId });
+    log112.warn("Failed to stop thread from Control Channel", { error, threadId });
     return false;
   }
 }
-var log111, CHAT_STREAM_INITIAL_RECOVERY_BACKOFF_MS, CHAT_STREAM_EXTENDED_RETRY_MS, CHAT_STREAM_RECOVERY_MAX_MS, CHAT_BUFFER_GATE_POLL_MS;
+var log112, CHAT_STREAM_INITIAL_RECOVERY_BACKOFF_MS, CHAT_STREAM_EXTENDED_RETRY_MS, CHAT_STREAM_RECOVERY_MAX_MS, CHAT_BUFFER_GATE_POLL_MS;
 var init_slack_chat = __esm({
   "src/features/slack/slack.chat.ts"() {
     "use strict";
     init_dist();
     init_conversations_content();
-    log111 = createLogger("slack.chat");
+    log112 = createLogger("slack.chat");
     CHAT_STREAM_INITIAL_RECOVERY_BACKOFF_MS = [1e3, 2e3, 4e3];
     CHAT_STREAM_EXTENDED_RETRY_MS = 3e4;
     CHAT_STREAM_RECOVERY_MAX_MS = 30 * 60 * 1e3;
@@ -59814,7 +60409,7 @@ async function fetchSlackChannelHistoryMessages(params) {
     });
     return history.map((message) => toCatchUpMessage(channelId, message)).filter((message) => message !== null).sort((a, b) => compareSlackTs(a.ts, b.ts));
   } catch (error) {
-    log112.warn("conversations.history failed during Slack catch-up", {
+    log113.warn("conversations.history failed during Slack catch-up", {
       teamId,
       channelId,
       error
@@ -59848,7 +60443,7 @@ async function fetchSlackThreadRawReplies(params) {
       });
       byThread.set(map.slackThreadTs, replies);
     } catch (error) {
-      log112.warn("conversations.replies failed during Slack catch-up", {
+      log113.warn("conversations.replies failed during Slack catch-up", {
         teamId,
         channelId,
         slackThreadTs: map.slackThreadTs,
@@ -59878,7 +60473,7 @@ async function fetchSlackThreadRawRepliesForRoot(params) {
       }
     });
   } catch (error) {
-    log112.warn("conversations.replies failed during Slack catch-up lookup", {
+    log113.warn("conversations.replies failed during Slack catch-up lookup", {
       channelId,
       threadTs,
       error
@@ -59980,7 +60575,7 @@ async function catchUpSlackMissedMessages(deps) {
         await deps.ingest(message, deps.teamId);
         messagesIngested += 1;
       } catch (error) {
-        log112.error("Failed to ingest Slack catch-up history message", {
+        log113.error("Failed to ingest Slack catch-up history message", {
           teamId: deps.teamId,
           channelId,
           ts: message.ts,
@@ -60014,7 +60609,7 @@ async function catchUpSlackMissedMessages(deps) {
         await deps.ingest(message, deps.teamId);
         messagesIngested += 1;
       } catch (error) {
-        log112.error("Failed to ingest Slack catch-up reply message", {
+        log113.error("Failed to ingest Slack catch-up reply message", {
           teamId: deps.teamId,
           channelId,
           ts: message.ts,
@@ -60031,13 +60626,13 @@ async function catchUpSlackMissedMessages(deps) {
   }
   return { channelsScanned: bindings.length, messagesIngested };
 }
-var log112, SLACK_CATCH_UP_MAX_LOOKBACK_MS, MAX_PAGES_PER_FETCH, PAGE_SIZE;
+var log113, SLACK_CATCH_UP_MAX_LOOKBACK_MS, MAX_PAGES_PER_FETCH, PAGE_SIZE;
 var init_slack_catch_up = __esm({
   "src/features/slack/slack.catch-up.ts"() {
     "use strict";
     init_dist();
     init_slack_chat();
-    log112 = createLogger("slack.catch-up");
+    log113 = createLogger("slack.catch-up");
     SLACK_CATCH_UP_MAX_LOOKBACK_MS = 60 * 60 * 1e3;
     MAX_PAGES_PER_FETCH = 5;
     PAGE_SIZE = 200;
@@ -60374,7 +60969,7 @@ async function getEncryptedSecret(key) {
     }
     return stored;
   } catch (error) {
-    log113.error("Failed to decrypt Slack secret", { key, error });
+    log114.error("Failed to decrypt Slack secret", { key, error });
     return null;
   }
 }
@@ -60693,7 +61288,7 @@ async function clearSlackHandledPrompts() {
   const db = await getDatabase();
   await deleteState(db, HANDLED_PROMPTS_KEY);
 }
-var log113, BOT_TOKEN_KEY, APP_TOKEN_KEY, BINDINGS_KEY, THREAD_MAPS_KEY, CATCH_UP_CURSORS_KEY, HANDLED_PROMPTS_KEY, HANDLED_PROMPT_RETENTION_MS, handledPromptClaimChain;
+var log114, BOT_TOKEN_KEY, APP_TOKEN_KEY, BINDINGS_KEY, THREAD_MAPS_KEY, CATCH_UP_CURSORS_KEY, HANDLED_PROMPTS_KEY, HANDLED_PROMPT_RETENTION_MS, handledPromptClaimChain;
 var init_slack_state = __esm({
   "src/features/slack/slack.state.ts"() {
     "use strict";
@@ -60701,7 +61296,7 @@ var init_slack_state = __esm({
     init_database();
     init_database_state();
     init_database_encryption();
-    log113 = createLogger("slack.state");
+    log114 = createLogger("slack.state");
     BOT_TOKEN_KEY = "SlackBotToken";
     APP_TOKEN_KEY = "SlackAppToken";
     BINDINGS_KEY = "SlackChannelBindings";
@@ -60889,7 +61484,7 @@ function resolveMappedSlackMode(map, defaultTarskThreadId) {
 function slackMessageDedupeKey(teamId, channelId, messageTs) {
   return `${teamId}:${channelId}:${messageTs}`;
 }
-var log114, MESSAGE_DEDUPE_TTL_MS, SlackBridge;
+var log115, MESSAGE_DEDUPE_TTL_MS, SlackBridge;
 var init_slack_bridge = __esm({
   "src/features/slack/slack.bridge.ts"() {
     "use strict";
@@ -60904,7 +61499,7 @@ var init_slack_bridge = __esm({
     init_slack_skills();
     init_slack_state();
     init_slack_tasks();
-    log114 = createLogger("slack.bridge");
+    log115 = createLogger("slack.bridge");
     MESSAGE_DEDUPE_TTL_MS = 5 * 60 * 1e3;
     SlackBridge = class {
       deps;
@@ -60963,7 +61558,7 @@ var init_slack_bridge = __esm({
         const botToken = await getSlackBotToken();
         const appToken = await getSlackAppToken();
         if (!botToken || !appToken) {
-          log114.info("Slack bridge not started (missing bot or app token)");
+          log115.info("Slack bridge not started (missing bot or app token)");
           return;
         }
         const web = new WebClient(botToken);
@@ -60984,20 +61579,20 @@ var init_slack_bridge = __esm({
         });
         this.socket = socket;
         socket.on("connected", () => {
-          log114.info("Slack Socket Mode connected", {
+          log115.info("Slack Socket Mode connected", {
             botUserId: this.botUserId,
             teamId: this.teamId
           });
           this.requestCatchUp();
         });
         socket.on("disconnected", () => {
-          log114.warn("Slack Socket Mode disconnected");
+          log115.warn("Slack Socket Mode disconnected");
         });
         socket.on("reconnecting", () => {
-          log114.warn("Slack Socket Mode reconnecting");
+          log115.warn("Slack Socket Mode reconnecting");
         });
         socket.on("error", (error) => {
-          log114.error("Slack Socket Mode error", { error });
+          log115.error("Slack Socket Mode error", { error });
         });
         socket.on(
           "slack_event",
@@ -61006,7 +61601,7 @@ var init_slack_bridge = __esm({
             try {
               await ack();
             } catch (error) {
-              log114.warn("Failed to ack Slack Socket Mode envelope", { type, error });
+              log115.warn("Failed to ack Slack Socket Mode envelope", { type, error });
             }
             if (!body || !type) {
               return;
@@ -61014,10 +61609,10 @@ var init_slack_bridge = __esm({
             if (type === "events_api") {
               const event = body.event;
               if (!event) {
-                log114.debug("events_api envelope missing event payload", { bodyKeys: Object.keys(body) });
+                log115.debug("events_api envelope missing event payload", { bodyKeys: Object.keys(body) });
                 return;
               }
-              log114.info("Slack events_api received", {
+              log115.info("Slack events_api received", {
                 eventType: event.type,
                 channel: event.channel,
                 user: event.user,
@@ -61025,21 +61620,21 @@ var init_slack_bridge = __esm({
                 threadTs: event.thread_ts
               });
               void this.handleEvent(event, body).catch((error) => {
-                log114.error("Unhandled Slack event error", { error, eventType: event.type });
+                log115.error("Unhandled Slack event error", { error, eventType: event.type });
               });
               return;
             }
             if (type === "interactive") {
-              log114.info("Slack interactive received", { interactiveType: body.type });
+              log115.info("Slack interactive received", { interactiveType: body.type });
               void this.handleInteractive(body).catch((error) => {
-                log114.error("Unhandled Slack interactive error", { error });
+                log115.error("Unhandled Slack interactive error", { error });
               });
             }
           }
         );
         await socket.start();
         this.running = true;
-        log114.info("Slack bridge started", {
+        log115.info("Slack bridge started", {
           botUsername: this.botUsername,
           teamName: this.teamName
         });
@@ -61062,7 +61657,7 @@ var init_slack_bridge = __esm({
           try {
             await socket.disconnect();
           } catch (error) {
-            log114.warn("Error disconnecting Slack Socket Mode", { error });
+            log115.warn("Error disconnecting Slack Socket Mode", { error });
           }
         }
       }
@@ -61077,7 +61672,7 @@ var init_slack_bridge = __esm({
         }
         this.catchUpRunning = true;
         void this.runCatchUp().catch((error) => {
-          log114.error("Slack reconnect catch-up failed", { error });
+          log115.error("Slack reconnect catch-up failed", { error });
         }).finally(() => {
           this.catchUpRunning = false;
           if (this.catchUpQueued && this.socket) {
@@ -61092,7 +61687,7 @@ var init_slack_bridge = __esm({
         if (!web || !teamId) {
           return;
         }
-        log114.info("Slack reconnect catch-up started", { teamId });
+        log115.info("Slack reconnect catch-up started", { teamId });
         const result = await catchUpSlackMissedMessages({
           web,
           teamId,
@@ -61107,7 +61702,7 @@ var init_slack_bridge = __esm({
           }
         });
         if (result.channelsScanned > 0 || result.messagesIngested > 0) {
-          log114.info("Slack reconnect catch-up complete", result);
+          log115.info("Slack reconnect catch-up complete", result);
         }
       }
       noteLiveMessageSeen(teamId, channelId, messageTs) {
@@ -61116,7 +61711,7 @@ var init_slack_bridge = __esm({
           slackChannelId: channelId,
           seenTs: messageTs
         }).catch((error) => {
-          log114.debug("Failed to advance Slack catch-up cursor", {
+          log115.debug("Failed to advance Slack catch-up cursor", {
             teamId,
             channelId,
             messageTs,
@@ -61220,7 +61815,7 @@ var init_slack_bridge = __esm({
         }
         const binding = await getSlackBinding(teamId, channelId);
         if (!binding) {
-          log114.info("Ignoring @mention in unbound channel", { teamId, channelId });
+          log115.info("Ignoring @mention in unbound channel", { teamId, channelId });
           await this.postEphemeralOrThread(
             channelId,
             userId,
@@ -61229,7 +61824,7 @@ var init_slack_bridge = __esm({
           );
           return;
         }
-        log114.info("Dispatching Slack @mention as Channel Prompt", {
+        log115.info("Dispatching Slack @mention as Channel Prompt", {
           teamId,
           channelId,
           projectId: binding.projectId,
@@ -61258,7 +61853,7 @@ var init_slack_bridge = __esm({
               currentConversationId: conversationId2
             });
           } catch (error) {
-            log114.warn("Failed to point channel default thread at new Slack conversation", {
+            log115.warn("Failed to point channel default thread at new Slack conversation", {
               error,
               tarskThreadId: defaultTarget.tarskThreadId,
               conversationId: conversationId2
@@ -61702,7 +62297,7 @@ var init_slack_bridge = __esm({
         let conversationId = params.conversationId;
         let slackMode = params.slackMode;
         if (createTarskThread && !explicitBranchCommand && !claimChannelDefault) {
-          log114.error(
+          log115.error(
             "dispatchChannelPrompt: createTarskThread requires explicitBranchCommand or claimChannelDefault",
             {
               channelId,
@@ -61716,11 +62311,11 @@ var init_slack_bridge = __esm({
         try {
           claimed = await claimSlackPromptHandled(idempotencyKey);
         } catch (error) {
-          log114.error("Failed to claim Slack prompt idempotency key", { idempotencyKey, error });
+          log115.error("Failed to claim Slack prompt idempotency key", { idempotencyKey, error });
           return;
         }
         if (!claimed) {
-          log114.info("Skipping already-handled Slack prompt", { idempotencyKey });
+          log115.info("Skipping already-handled Slack prompt", { idempotencyKey });
           return;
         }
         if (ackReaction && (content.trim().length > 0 || attachments.length > 0)) {
@@ -61807,7 +62402,7 @@ var init_slack_bridge = __esm({
               currentConversationId: conversationId
             });
           } catch (error) {
-            log114.warn("Failed to set conversation id on new Slack Tarsk thread", {
+            log115.warn("Failed to set conversation id on new Slack Tarsk thread", {
               error,
               tarskThreadId,
               conversationId
@@ -61824,7 +62419,7 @@ var init_slack_bridge = __esm({
               try {
                 await this.deps.threadManager.deleteThread(tarskThreadId);
               } catch (error) {
-                log114.warn("Failed to delete duplicate channel default clone", { error, tarskThreadId });
+                log115.warn("Failed to delete duplicate channel default clone", { error, tarskThreadId });
               }
               tarskThreadId = claim.existing.defaultTarskThreadId;
               conversationId = randomUUID17();
@@ -61844,7 +62439,7 @@ var init_slack_bridge = __esm({
                   currentConversationId: conversationId
                 });
               } catch (error) {
-                log114.warn("Failed to point winning channel default at Slack conversation", {
+                log115.warn("Failed to point winning channel default at Slack conversation", {
                   error,
                   tarskThreadId,
                   conversationId
@@ -61887,7 +62482,7 @@ var init_slack_bridge = __esm({
               currentConversationId: conversationId
             });
           } catch (error) {
-            log114.warn("Failed to sync Tarsk currentConversationId for Slack prompt", {
+            log115.warn("Failed to sync Tarsk currentConversationId for Slack prompt", {
               error,
               tarskThreadId,
               conversationId
@@ -62126,7 +62721,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
               mimeType
             });
           } catch (error) {
-            log114.warn("Failed to download Slack file", { fileId: file.id, error });
+            log115.warn("Failed to download Slack file", { fileId: file.id, error });
           }
         }
         return attachments;
@@ -62143,7 +62738,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
               currentConversationId: existingConversationId
             });
           } catch (error) {
-            log114.warn("Failed to sync Tarsk currentConversationId for Slack follow-up", {
+            log115.warn("Failed to sync Tarsk currentConversationId for Slack follow-up", {
               error,
               tarskThreadId,
               existingConversationId
@@ -62178,7 +62773,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
           if (code === "already_reacted" || code === "too_many_emoji") {
             return;
           }
-          log114.warn("Failed to add Slack reaction", { error, channelId, messageTs, emoji });
+          log115.warn("Failed to add Slack reaction", { error, channelId, messageTs, emoji });
         }
       }
       async postInThread(channelId, threadTs, text, blocks) {
@@ -62195,7 +62790,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
           });
           return typeof result.ts === "string" ? result.ts : null;
         } catch (error) {
-          log114.error("Failed to post Slack message", { error, channelId });
+          log115.error("Failed to post Slack message", { error, channelId });
           return null;
         }
       }
@@ -62206,7 +62801,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
         try {
           await this.web.chat.update({ channel: channelId, ts, text });
         } catch (error) {
-          log114.warn("Failed to update Slack message; posting new one", { error });
+          log115.warn("Failed to update Slack message; posting new one", { error });
         }
       }
       async postEphemeralOrThread(channelId, userId, threadTs, text, blocks) {
@@ -62314,7 +62909,7 @@ _Warning: ${result.error}_` : result.reply || "Done (no text response).";
               provider: selected.provider
             });
           } catch (error) {
-            log114.error("Failed to switch Slack thread model", { error, selected, tarskThreadId });
+            log115.error("Failed to switch Slack thread model", { error, selected, tarskThreadId });
             await this.respondInteractive(responseUrl, "Failed to switch model. Try again from Tarsk.");
             return;
           }
@@ -62533,7 +63128,7 @@ async function startSlackBridge(deps) {
   try {
     await bridge.start();
   } catch (error) {
-    log115.error("Slack bridge failed to start", {
+    log116.error("Slack bridge failed to start", {
       bridgeRunning: bridge.isRunning(),
       error
     });
@@ -62553,13 +63148,13 @@ async function stopSlackBridge() {
   await bridge.stop();
   bridge = null;
 }
-var log115, bridge, lastDeps;
+var log116, bridge, lastDeps;
 var init_slack_service = __esm({
   "src/features/slack/slack.service.ts"() {
     "use strict";
     init_dist();
     init_slack_bridge();
-    log115 = createLogger("slack.service");
+    log116 = createLogger("slack.service");
     bridge = null;
     lastDeps = null;
   }
@@ -62992,7 +63587,7 @@ async function generateImage(c, metadataManager, conversationManager, threadMana
           // imageMode
         );
       } catch (err) {
-        log116.error("[image] Failed to persist request to conversation history:", err);
+        log117.error("[image] Failed to persist request to conversation history:", err);
       }
     }
     const isOpenRouter = provider.toLowerCase() === "openrouter";
@@ -63018,18 +63613,18 @@ async function generateImage(c, metadataManager, conversationManager, threadMana
           imageUrl
         );
       } catch (err) {
-        log116.error("[image] Failed to persist response to conversation history:", err);
+        log117.error("[image] Failed to persist response to conversation history:", err);
       }
     }
     return c.json({ imageUrl, imageData, text });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    log116.error(`[image] Error:`, error);
+    log117.error(`[image] Error:`, error);
     return c.json({ error: message }, 500);
   }
 }
 async function callOpenRouter(apiKey, model, prompt, options) {
-  log116.info(`[image] Generating via OpenRouter chat completions \u2014 model: ${model}`);
+  log117.info(`[image] Generating via OpenRouter chat completions \u2014 model: ${model}`);
   const result = await generateWithOpenRouter(apiKey, model, prompt, {
     aspectRatio: options.aspectRatio,
     imageSize: options.imageSize
@@ -63042,7 +63637,7 @@ async function callStandard(apiKey, baseUrl, rawModel, provider, prompt) {
   }
   const model = normalizeProviderModelId(provider, rawModel);
   const apiUrl = `${baseUrl.replace(/\/$/, "")}/images/generations`;
-  log116.info(`[image] Generating via ${provider} at ${apiUrl} \u2014 model: ${model}`);
+  log117.info(`[image] Generating via ${provider} at ${apiUrl} \u2014 model: ${model}`);
   const response = await fetch(apiUrl, {
     method: "POST",
     headers: {
@@ -63099,7 +63694,7 @@ async function callStandard(apiKey, baseUrl, rawModel, provider, prompt) {
   }
   return { imageUrl: imageResult.url, imageData: imageResult.b64_json };
 }
-var log116;
+var log117;
 var init_image_generate_route = __esm({
   "src/features/image/image-generate.route.ts"() {
     "use strict";
@@ -63107,7 +63702,7 @@ var init_image_generate_route = __esm({
     init_provider_resolver();
     init_agent_model_resolver();
     init_openrouter_image_client();
-    log116 = createLogger("features.image.image-generate");
+    log117 = createLogger("features.image.image-generate");
   }
 });
 
@@ -63169,17 +63764,17 @@ async function clipboardWriteImage(c) {
     Utils3.clipboardWriteImage(resolved.data);
     return c.json({ success: true });
   } catch (error) {
-    log117.error("[image] Failed to write image to clipboard:", error);
+    log118.error("[image] Failed to write image to clipboard:", error);
     return c.json({ error: "Failed to copy image to clipboard" }, 500);
   }
 }
-var log117, Utils3, utilsLoaded3;
+var log118, Utils3, utilsLoaded3;
 var init_image_clipboard_route = __esm({
   "src/features/image/image-clipboard.route.ts"() {
     "use strict";
     init_dist();
     init_image_bytes();
-    log117 = createLogger("features.image.image-clipboard");
+    log118 = createLogger("features.image.image-clipboard");
     Utils3 = null;
     utilsLoaded3 = false;
   }
@@ -63216,17 +63811,17 @@ async function saveImage(c) {
     await Bun.write(savePath, resolved.data);
     return c.json({ success: true, path: savePath });
   } catch (error) {
-    log118.error("[image] Failed to save image:", error);
+    log119.error("[image] Failed to save image:", error);
     return c.json({ error: "Failed to save image" }, 500);
   }
 }
-var log118, Utils4, utilsLoaded4;
+var log119, Utils4, utilsLoaded4;
 var init_image_save_route = __esm({
   "src/features/image/image-save.route.ts"() {
     "use strict";
     init_dist();
     init_image_bytes();
-    log118 = createLogger("features.image.image-save");
+    log119 = createLogger("features.image.image-save");
     Utils4 = null;
     utilsLoaded4 = false;
   }
@@ -63871,18 +64466,18 @@ function createLogsRoutes() {
   router.delete("/", (c) => {
     clearLogBuffer();
     clearFileLog();
-    log119.info("Log buffer cleared by client request");
+    log120.info("Log buffer cleared by client request");
     return c.json({ ok: true });
   });
   return router;
 }
-var log119, LOG_FEED_PING_INTERVAL_MS;
+var log120, LOG_FEED_PING_INTERVAL_MS;
 var init_logs_routes = __esm({
   "src/features/logs/logs.routes.ts"() {
     "use strict";
     init_dist();
     init_file_log_transport();
-    log119 = createLogger("logs.api");
+    log120 = createLogger("logs.api");
     LOG_FEED_PING_INTERVAL_MS = 25e3;
   }
 });
@@ -64007,13 +64602,13 @@ async function runScheduledTask(taskId, deps, task) {
       })
     });
   } catch (error) {
-    log120.error("Failed to run scheduled task", {
+    log121.error("Failed to run scheduled task", {
       error,
       taskId
     });
   }
 }
-var log120, POLL_INTERVAL_MS;
+var log121, POLL_INTERVAL_MS;
 var init_task_scheduler = __esm({
   "src/features/project-tasks/task-scheduler.ts"() {
     "use strict";
@@ -64023,7 +64618,7 @@ var init_task_scheduler = __esm({
     init_project_tasks_database();
     init_database();
     init_task_trigger_validation();
-    log120 = createLogger("task.scheduler");
+    log121 = createLogger("task.scheduler");
     POLL_INTERVAL_MS = 3e4;
   }
 });
@@ -64163,7 +64758,7 @@ var init_inbound_events_routes = __esm({
 async function openScreenRecordingSettings() {
   if (process.platform !== "darwin") {
     const message = "Screen recording settings are only available on macOS.";
-    log121.warn(`[ScreenRecordingSettings] ${message}`);
+    log122.warn(`[ScreenRecordingSettings] ${message}`);
     return {
       success: false,
       message,
@@ -64171,8 +64766,8 @@ async function openScreenRecordingSettings() {
     };
   }
   const settingsUrl = "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture";
-  log121.info(`[ScreenRecordingSettings] Opening System Settings to Screen Recording pane...`);
-  log121.info(`[ScreenRecordingSettings] URL: ${settingsUrl}`);
+  log122.info(`[ScreenRecordingSettings] Opening System Settings to Screen Recording pane...`);
+  log122.info(`[ScreenRecordingSettings] URL: ${settingsUrl}`);
   try {
     const { shell, args: args2 } = getShellConfig();
     const result = spawnSyncProcess(shell, [...args2, `open "${settingsUrl}"`], {
@@ -64181,17 +64776,17 @@ async function openScreenRecordingSettings() {
       timeout: 5e3
     });
     if (result.status === 0) {
-      log121.info(`[ScreenRecordingSettings] Successfully opened System Settings`);
+      log122.info(`[ScreenRecordingSettings] Successfully opened System Settings`);
       return {
         success: true,
         message: "System Settings opened to Screen & Audio Recording pane."
       };
     } else {
       const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "Unknown error";
-      log121.error(
+      log122.error(
         `[ScreenRecordingSettings] Failed to open System Settings. Exit code: ${result.status}`
       );
-      log121.error(`[ScreenRecordingSettings] stderr: ${stderr}`);
+      log122.error(`[ScreenRecordingSettings] stderr: ${stderr}`);
       return {
         success: false,
         message: "Failed to open System Settings. Please open it manually: System Settings > Privacy & Security > Screen & Audio Recording.",
@@ -64200,7 +64795,7 @@ async function openScreenRecordingSettings() {
     }
   } catch (error) {
     const errorMessage2 = error instanceof Error ? error.message : String(error);
-    log121.error(`[ScreenRecordingSettings] Exception while opening System Settings:`, error);
+    log122.error(`[ScreenRecordingSettings] Exception while opening System Settings:`, error);
     return {
       success: false,
       message: "Failed to open System Settings. Please open it manually: System Settings > Privacy & Security > Screen & Audio Recording.",
@@ -64208,14 +64803,14 @@ async function openScreenRecordingSettings() {
     };
   }
 }
-var log121;
+var log122;
 var init_screen_recording_settings_opener = __esm({
   "src/features/system-permissions/screen-recording-settings-opener.ts"() {
     "use strict";
     init_utils();
     init_shell();
     init_dist();
-    log121 = createLogger("features.system-permissions.screen-recording-settings-opener");
+    log122 = createLogger("features.system-permissions.screen-recording-settings-opener");
   }
 });
 
@@ -64383,7 +64978,7 @@ async function startTarskServerInternal(options) {
       const fullUrl = `${requestUrl.protocol}//${hostHeader}${reqPath}`;
       const isThreadMessages = reqPath.startsWith("/api/threads/") && reqPath.endsWith("/messages");
       if (!fullUrl.includes("processing") && !reqPath.startsWith("/api/logs") && !isThreadMessages) {
-        log122.info(`${method} ${fullUrl}`);
+        log123.info(`${method} ${fullUrl}`);
       }
     }
     return next();
@@ -64619,7 +65214,7 @@ function writePortFile(port, url) {
     fs5.writeFileSync(portFilePath, `${JSON.stringify({ port, url }, null, 2)}
 `, "utf8");
   } catch (error) {
-    log122.warn("Failed to write port.json", { error });
+    log123.warn("Failed to write port.json", { error });
   }
 }
 async function listenForTarskServer(options) {
@@ -64657,7 +65252,7 @@ async function listenForTarskServer(options) {
     port += 1;
   }
 }
-var log122, __filename, __dirname, startPromise;
+var log123, __filename, __dirname, startPromise;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
@@ -64712,7 +65307,7 @@ var init_server = __esm({
     init_server_bind_mode_store();
     init_server_bind_mode();
     init_cli_process_routes();
-    log122 = createLogger("server");
+    log123 = createLogger("server");
     __filename = fileURLToPath4(import.meta.url);
     __dirname = path5.dirname(__filename);
     startPromise = null;