tarsk 0.3.36 → 0.3.37

package/dist/index.js

@@ -96,7 +96,7 @@ import { cors } from "hono/cors";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import path3 from "path";
-import open2 from "open";
+import open3 from "open";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/managers/project-manager.ts
@@ -1908,12 +1908,7 @@ class MetadataManager {
 
 // src/managers/pi-executor.ts
 import { Agent } from "@mariozechner/pi-agent-core";
-import {
-  getModel
-} from "@mariozechner/pi-ai";
-import { resolve, dirname as dirname5, isAbsolute as isAbsolute2 } from "path";
-import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
 
 // src/tools/bash.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
@@ -2563,6 +2558,38 @@ function resolveReadPath(filePath, cwd) {
   return resolved;
 }
 
+// src/tools/tool-helpers.ts
+async function withAbortSignal(signal, operation) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+    let aborted = false;
+    const onAbort = () => {
+      aborted = true;
+      reject(new Error("Operation aborted"));
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const cleanup = () => {
+      if (signal)
+        signal.removeEventListener("abort", onAbort);
+    };
+    const abortCheck = () => aborted;
+    operation(abortCheck).then((result) => {
+      cleanup();
+      if (!aborted)
+        resolve(result);
+    }).catch((error) => {
+      cleanup();
+      if (!aborted)
+        reject(error);
+    });
+  });
+}
+
 // src/tools/edit.ts
 var editSchema = Type2.Object({
   path: Type2.String({ description: "Path to the file to edit (relative or absolute)" }),
@@ -2584,83 +2611,49 @@ function createEditTool(cwd, options) {
     execute: async (_toolCallId, { path, oldText, newText }, signal) => {
       const absolutePath = resolveToCwd(path, cwd);
       validatePathWithinCwd(absolutePath, cwd);
-      return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-          reject(new Error("Operation aborted"));
-          return;
+      return withAbortSignal(signal, async (isAborted) => {
+        try {
+          await ops.access(absolutePath);
+        } catch {
+          throw new Error(`File not found: ${path}`);
         }
-        let aborted = false;
-        const onAbort = () => {
-          aborted = true;
-          reject(new Error("Operation aborted"));
+        if (isAborted())
+          return { content: [], details: undefined };
+        const buffer = await ops.readFile(absolutePath);
+        const rawContent = buffer.toString("utf-8");
+        if (isAborted())
+          return { content: [], details: undefined };
+        const { bom, text: content } = stripBom(rawContent);
+        const originalEnding = detectLineEnding(content);
+        const normalizedContent = normalizeToLF(content);
+        const normalizedOldText = normalizeToLF(oldText);
+        const normalizedNewText = normalizeToLF(newText);
+        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+        if (!matchResult.found) {
+          throw new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`);
+        }
+        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+        if (occurrences > 1) {
+          throw new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`);
+        }
+        if (isAborted())
+          return { content: [], details: undefined };
+        const baseContent = matchResult.contentForReplacement;
+        const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
+        if (baseContent === newContent) {
+          throw new Error(`No changes made to ${path}. The replacement produced identical content.`);
+        }
+        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+        await ops.writeFile(absolutePath, finalContent);
+        if (isAborted())
+          return { content: [], details: undefined };
+        const diffResult = generateDiffString(baseContent, newContent);
+        return {
+          content: [{ type: "text", text: `Successfully replaced text in ${path}.` }],
+          details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
         };
-        if (signal)
-          signal.addEventListener("abort", onAbort, { once: true });
-        (async () => {
-          try {
-            try {
-              await ops.access(absolutePath);
-            } catch {
-              if (signal)
-                signal.removeEventListener("abort", onAbort);
-              reject(new Error(`File not found: ${path}`));
-              return;
-            }
-            if (aborted)
-              return;
-            const buffer = await ops.readFile(absolutePath);
-            const rawContent = buffer.toString("utf-8");
-            if (aborted)
-              return;
-            const { bom, text: content } = stripBom(rawContent);
-            const originalEnding = detectLineEnding(content);
-            const normalizedContent = normalizeToLF(content);
-            const normalizedOldText = normalizeToLF(oldText);
-            const normalizedNewText = normalizeToLF(newText);
-            const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
-            if (!matchResult.found) {
-              if (signal)
-                signal.removeEventListener("abort", onAbort);
-              reject(new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`));
-              return;
-            }
-            const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
-            const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
-            const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
-            if (occurrences > 1) {
-              if (signal)
-                signal.removeEventListener("abort", onAbort);
-              reject(new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`));
-              return;
-            }
-            if (aborted)
-              return;
-            const baseContent = matchResult.contentForReplacement;
-            const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
-            if (baseContent === newContent) {
-              if (signal)
-                signal.removeEventListener("abort", onAbort);
-              reject(new Error(`No changes made to ${path}. The replacement produced identical content.`));
-              return;
-            }
-            const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-            await ops.writeFile(absolutePath, finalContent);
-            if (aborted)
-              return;
-            if (signal)
-              signal.removeEventListener("abort", onAbort);
-            const diffResult = generateDiffString(baseContent, newContent);
-            resolve({
-              content: [{ type: "text", text: `Successfully replaced text in ${path}.` }],
-              details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
-            });
-          } catch (error) {
-            if (signal)
-              signal.removeEventListener("abort", onAbort);
-            if (!aborted)
-              reject(error);
-          }
-        })();
       });
     }
   };
@@ -3147,87 +3140,64 @@ function createReadTool(cwd, options) {
     execute: async (_toolCallId, { path: path3, offset, limit }, signal) => {
       const absolutePath = resolveReadPath(path3, cwd);
       validatePathWithinCwd(absolutePath, cwd);
-      return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-          reject(new Error("Operation aborted"));
-          return;
-        }
-        let aborted = false;
-        const onAbort = () => {
-          aborted = true;
-          reject(new Error("Operation aborted"));
-        };
-        if (signal) {
-          signal.addEventListener("abort", onAbort, { once: true });
-        }
-        (async () => {
-          try {
-            await ops.access(absolutePath);
-            if (aborted)
-              return;
-            const buffer = await ops.readFile(absolutePath);
-            const textContent = buffer.toString("utf-8");
-            const allLines = textContent.split(`
+      return withAbortSignal(signal, async (isAborted) => {
+        await ops.access(absolutePath);
+        if (isAborted())
+          return { content: [], details: undefined };
+        const buffer = await ops.readFile(absolutePath);
+        const textContent = buffer.toString("utf-8");
+        const allLines = textContent.split(`
 `);
-            const totalFileLines = allLines.length;
-            const startLine = offset ? Math.max(0, offset - 1) : 0;
-            const startLineDisplay = startLine + 1;
-            if (startLine >= allLines.length) {
-              throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
-            }
-            let selectedContent;
-            let userLimitedLines;
-            if (limit !== undefined) {
-              const endLine = Math.min(startLine + limit, allLines.length);
-              selectedContent = allLines.slice(startLine, endLine).join(`
+        const totalFileLines = allLines.length;
+        const startLine = offset ? Math.max(0, offset - 1) : 0;
+        const startLineDisplay = startLine + 1;
+        if (startLine >= allLines.length) {
+          throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+        }
+        let selectedContent;
+        let userLimitedLines;
+        if (limit !== undefined) {
+          const endLine = Math.min(startLine + limit, allLines.length);
+          selectedContent = allLines.slice(startLine, endLine).join(`
 `);
-              userLimitedLines = endLine - startLine;
-            } else {
-              selectedContent = allLines.slice(startLine).join(`
+          userLimitedLines = endLine - startLine;
+        } else {
+          selectedContent = allLines.slice(startLine).join(`
 `);
-            }
-            const truncation = truncateHead(selectedContent);
-            let outputText;
-            let details;
-            if (truncation.firstLineExceedsLimit) {
-              outputText = `[Line ${startLineDisplay} is ${formatSize(Buffer.byteLength(allLines[startLine], "utf-8"))}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path3} | head -c ${DEFAULT_MAX_BYTES}]`;
-              details = { truncation };
-            } else if (truncation.truncated) {
-              const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
-              const nextOffset = endLineDisplay + 1;
-              outputText = truncation.content;
-              if (truncation.truncatedBy === "lines") {
-                outputText += `
+        }
+        const truncation = truncateHead(selectedContent);
+        let outputText;
+        let details;
+        if (truncation.firstLineExceedsLimit) {
+          outputText = `[Line ${startLineDisplay} is ${formatSize(Buffer.byteLength(allLines[startLine], "utf-8"))}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path3} | head -c ${DEFAULT_MAX_BYTES}]`;
+          details = { truncation };
+        } else if (truncation.truncated) {
+          const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+          const nextOffset = endLineDisplay + 1;
+          outputText = truncation.content;
+          if (truncation.truncatedBy === "lines") {
+            outputText += `
 
 [Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
-              } else {
-                outputText += `
+          } else {
+            outputText += `
 
 [Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
-              }
-              details = { truncation };
-            } else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
-              const remaining = allLines.length - (startLine + userLimitedLines);
-              const nextOffset = startLine + userLimitedLines + 1;
-              outputText = truncation.content;
-              outputText += `
+          }
+          details = { truncation };
+        } else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+          const remaining = allLines.length - (startLine + userLimitedLines);
+          const nextOffset = startLine + userLimitedLines + 1;
+          outputText = truncation.content;
+          outputText += `
 
 [${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
-            } else {
-              outputText = truncation.content;
-            }
-            if (aborted)
-              return;
-            if (signal)
-              signal.removeEventListener("abort", onAbort);
-            resolve({ content: [{ type: "text", text: outputText }], details });
-          } catch (error) {
-            if (signal)
-              signal.removeEventListener("abort", onAbort);
-            if (!aborted)
-              reject(error);
-          }
-        })();
+        } else {
+          outputText = truncation.content;
+        }
+        if (isAborted())
+          return { content: [], details: undefined };
+        return { content: [{ type: "text", text: outputText }], details };
       });
     }
   };
@@ -3296,14 +3266,239 @@ function createWriteTool(cwd, options) {
 }
 var writeTool = createWriteTool(process.cwd());
 
+// src/tools/skill-tool.ts
+import { readdir } from "fs/promises";
+import { join as join7, extname } from "path";
+import { existsSync as existsSync6, statSync as statSync3 } from "fs";
+import { Type as Type8 } from "@sinclair/typebox";
+import { spawn as spawn7 } from "child_process";
+function getInterpreter(scriptPath) {
+  const ext = extname(scriptPath);
+  switch (ext) {
+    case ".sh":
+    case ".bash":
+      return { command: "bash", args: [scriptPath] };
+    case ".py":
+      return { command: "python3", args: [scriptPath] };
+    case ".js":
+      return { command: "node", args: [scriptPath] };
+    case ".ts":
+      return { command: "bun", args: ["run", scriptPath] };
+    default:
+      try {
+        const stats = statSync3(scriptPath);
+        if (stats.mode & 73) {
+          return { command: scriptPath, args: [] };
+        }
+      } catch {}
+      return null;
+  }
+}
+async function executeScript(scriptPath, args, cwd, timeout = 30) {
+  const interpreter = getInterpreter(scriptPath);
+  if (!interpreter) {
+    throw new Error(`Unsupported script type: ${scriptPath}`);
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn7(interpreter.command, [...interpreter.args, ...args], {
+      cwd,
+      timeout: timeout * 1000
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    if (child.stdout) {
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, timeout * 1000);
+    child.on("error", (err) => {
+      clearTimeout(timeoutHandle);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeoutHandle);
+      if (timedOut) {
+        reject(new Error(`Script execution timed out after ${timeout}s`));
+        return;
+      }
+      resolve({ stdout, stderr, exitCode: code });
+    });
+  });
+}
+var skillScriptSchema = Type8.Object({
+  skillName: Type8.String({ description: "Name of the skill" }),
+  scriptName: Type8.String({ description: "Name of the script to execute (without path)" }),
+  args: Type8.Optional(Type8.Array(Type8.String(), { description: "Arguments to pass to the script" })),
+  timeout: Type8.Optional(Type8.Number({ description: "Timeout in seconds (default: 30)" }))
+});
+function createSkillScriptTool(skills, cwd) {
+  return {
+    name: "execute_skill_script",
+    description: "Execute a script from an activated skill. Skills provide executable scripts in their scripts/ directory.",
+    input_schema: skillScriptSchema,
+    execute: async (input) => {
+      const { skillName, scriptName, args = [], timeout = 30 } = input;
+      const skill = skills.find((s) => s.name === skillName);
+      if (!skill) {
+        return {
+          error: `Skill not found: ${skillName}. Available skills: ${skills.map((s) => s.name).join(", ")}`
+        };
+      }
+      const scriptsDir = join7(skill.skillPath, "scripts");
+      if (!existsSync6(scriptsDir)) {
+        return {
+          error: `Skill '${skillName}' has no scripts directory`
+        };
+      }
+      const scriptPath = join7(scriptsDir, scriptName);
+      if (!existsSync6(scriptPath)) {
+        try {
+          const availableScripts = await readdir(scriptsDir);
+          return {
+            error: `Script '${scriptName}' not found in skill '${skillName}'. Available scripts: ${availableScripts.join(", ")}`
+          };
+        } catch {
+          return {
+            error: `Script '${scriptName}' not found in skill '${skillName}'`
+          };
+        }
+      }
+      try {
+        const result = await executeScript(scriptPath, args, cwd, timeout);
+        let output = "";
+        if (result.stdout) {
+          output += `STDOUT:
+${result.stdout}
+`;
+        }
+        if (result.stderr) {
+          output += `STDERR:
+${result.stderr}
+`;
+        }
+        output += `Exit code: ${result.exitCode}
+`;
+        return output;
+      } catch (error) {
+        return {
+          error: `Failed to execute script: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+
+// src/tools/skill-reference-tool.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join8, normalize, relative as relative3 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { Type as Type9 } from "@sinclair/typebox";
+function isPathSafe(basePath, requestedPath) {
+  const normalized = normalize(requestedPath);
+  const fullPath = join8(basePath, normalized);
+  const relativePath = relative3(basePath, fullPath);
+  return !relativePath.startsWith("..") && !relativePath.startsWith("/");
+}
+var skillReferenceSchema = Type9.Object({
+  skillName: Type9.String({ description: "Name of the skill" }),
+  referencePath: Type9.String({
+    description: `Path to the reference file relative to the skill's references/ directory (e.g., "api-reference.md" or "guides/setup.md")`
+  })
+});
+function createSkillReferenceTool(skills) {
+  return {
+    name: "read_skill_reference",
+    description: "Read a reference file from an activated skill. Skills provide additional documentation in their references/ directory.",
+    input_schema: skillReferenceSchema,
+    execute: async (input) => {
+      const { skillName, referencePath } = input;
+      const skill = skills.find((s) => s.name === skillName);
+      if (!skill) {
+        return {
+          error: `Skill not found: ${skillName}. Available skills: ${skills.map((s) => s.name).join(", ")}`
+        };
+      }
+      const referencesDir = join8(skill.skillPath, "references");
+      if (!existsSync7(referencesDir)) {
+        return {
+          error: `Skill '${skillName}' has no references directory`
+        };
+      }
+      if (!isPathSafe(referencesDir, referencePath)) {
+        return {
+          error: `Invalid reference path: ${referencePath}. Path must be within the skill's references directory.`
+        };
+      }
+      const fullPath = join8(referencesDir, referencePath);
+      if (!existsSync7(fullPath)) {
+        try {
+          const availableRefs = await listReferencesRecursive(referencesDir);
+          return {
+            error: `Reference file '${referencePath}' not found in skill '${skillName}'. Available references:
+${availableRefs.join(`
+`)}`
+          };
+        } catch {
+          return {
+            error: `Reference file '${referencePath}' not found in skill '${skillName}'`
+          };
+        }
+      }
+      try {
+        const content = await readFile2(fullPath, "utf-8");
+        return content;
+      } catch (error) {
+        return {
+          error: `Failed to read reference file: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+  };
+}
+async function listReferencesRecursive(dir, prefix = "") {
+  const files = [];
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = prefix ? join8(prefix, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        const subFiles = await listReferencesRecursive(join8(dir, entry.name), relativePath);
+        files.push(...subFiles);
+      } else {
+        files.push(relativePath);
+      }
+    }
+  } catch (error) {
+    console.error(`Failed to list references in ${dir}:`, error);
+  }
+  return files;
+}
 // src/tools/index.ts
 function createCodingTools(cwd, options) {
-  return [
+  const baseTools = [
     createReadTool(cwd, options?.read),
     createBashTool(cwd, options?.bash),
     createEditTool(cwd),
     createWriteTool(cwd)
   ];
+  if (options?.skills && options.skills.length > 0) {
+    const skillTools = [
+      createSkillScriptTool(options.skills, cwd),
+      createSkillReferenceTool(options.skills)
+    ];
+    return [...baseTools, ...skillTools];
+  }
+  return baseTools;
 }
 
 // src/provider.ts
@@ -3493,15 +3688,16 @@ var PROVIDERS = [
 ];
 
 // src/paths.ts
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir2 } from "os";
-var APP_SUPPORT_DIR = join7(homedir2(), "Library", "Application Support", "Tarsk");
-var DATA_DIR = join7(APP_SUPPORT_DIR, "data");
+var APP_SUPPORT_DIR = join9(homedir2(), "Library", "Application Support", "Tarsk");
+var DATA_DIR = join9(APP_SUPPORT_DIR, "data");
 function getDataDir() {
   return DATA_DIR;
 }
 
-// src/managers/pi-executor.ts
+// src/managers/pi-model-resolver.ts
+import { getModel } from "@mariozechner/pi-ai";
 var PROVIDER_NAME_TO_PI = {
   anthropic: "anthropic",
   openai: "openai",
@@ -3549,32 +3745,185 @@ function resolveModel(providerName, modelId, providerConfig) {
     maxTokens: 16384
   };
 }
+
+// src/managers/pi-event-transformer.ts
 function extractTextFromAssistantMessage(msg) {
   return msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
 }
-var getErrorCode = (error) => {
-  if (error && typeof error === "object" && "code" in error) {
-    const code = error.code;
-    if (typeof code === "string")
-      return code;
+
+class EventQueue {
+  queue = [];
+  resolver = null;
+  finalContent = "";
+  errorOccurred = false;
+  handlePiEvent(event) {
+    if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+      const delta = event.assistantMessageEvent.delta;
+      this.finalContent += delta;
+      this.push({
+        type: "message",
+        role: "assistant",
+        content: delta
+      });
+    } else if (event.type === "tool_execution_start") {
+      this.push({
+        type: "message",
+        role: "tool",
+        content: JSON.stringify([
+          {
+            type: "tool_use",
+            name: event.toolName,
+            id: event.toolCallId,
+            input: event.args
+          }
+        ])
+      });
+    } else if (event.type === "tool_execution_end") {
+      const resultContent = event.result?.content?.filter((b) => b.type === "text").map((b) => b.text || "").join("") || JSON.stringify(event.result);
+      this.push({
+        type: "message",
+        role: "tool",
+        content: JSON.stringify([
+          {
+            type: "tool-result",
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            content: resultContent,
+            isError: event.isError
+          }
+        ])
+      });
+    } else if (event.type === "agent_end") {
+      const messages = event.messages;
+      const lastAssistant = [...messages].reverse().find((m) => ("role" in m) && m.role === "assistant");
+      if (lastAssistant) {
+        const extracted = extractTextFromAssistantMessage(lastAssistant);
+        if (extracted && extracted !== this.finalContent) {
+          this.finalContent = extracted;
+        }
+      }
+    }
+    this.notifyResolver();
   }
-  return;
-};
-function loadAgentSystemPrompt() {
-  const DEFAULT_PROMPT = "You are a helpful coding assistant. You have access to read, bash, edit, and write tools. Use them to explore and modify the codebase as needed.";
+  push(event) {
+    this.queue.push(event);
+  }
+  shift() {
+    return this.queue.shift();
+  }
+  get length() {
+    return this.queue.length;
+  }
+  setResolver(resolver) {
+    this.resolver = resolver;
+  }
+  clearResolver() {
+    this.resolver = null;
+  }
+  notifyResolver() {
+    if (this.resolver) {
+      this.resolver();
+      this.resolver = null;
+    }
+  }
+}
+
+// src/managers/pi-prompt-loader.ts
+import { resolve, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var DEFAULT_PROMPT = "You are a helpful coding assistant. You have access to read, bash, edit, and write tools. Use them to explore and modify the codebase as needed.";
+function loadAgentSystemPrompt(skills) {
+  let basePrompt;
   try {
     const __filename2 = fileURLToPath2(import.meta.url);
     const __dirname3 = dirname5(__filename2);
     const agentsPath = resolve(__dirname3, "../../agents.md");
     const content = readFileSync3(agentsPath, "utf-8");
     console.log("[ai] Successfully loaded agents.md for system prompt");
-    return content.trim();
+    basePrompt = content.trim();
   } catch (error) {
-    console.warn("[ai] Could not load agents.md, using default prompt:", error);
-    return DEFAULT_PROMPT;
+    const isFileNotFound = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+    if (isFileNotFound) {
+      console.log("[ai] agents.md not found, using default system prompt");
+    } else {
+      console.warn("[ai] Error loading agents.md, using default prompt:", error instanceof Error ? error.message : String(error));
+    }
+    basePrompt = DEFAULT_PROMPT;
+  }
+  if (!skills || skills.length === 0) {
+    return basePrompt;
+  }
+  let skillsSection = `
+
+# Available Skills
+
+`;
+  skillsSection += `The following skills are available for this session. Use them to enhance your capabilities:
+
+`;
+  for (const skill of skills) {
+    skillsSection += `## ${skill.name}
+
+`;
+    skillsSection += `**Description**: ${skill.description}
+
+`;
+    if (skill.compatibility) {
+      skillsSection += `**Compatibility**: ${skill.compatibility}
+
+`;
+    }
+    skillsSection += skill.instructions;
+    skillsSection += `
+
+---
+
+`;
+  }
+  console.log(`[ai] Injected ${skills.length} skill(s) into system prompt: ${skills.map((s) => s.name).join(", ")}`);
+  return basePrompt + skillsSection;
+}
+
+// src/managers/pi-error-utils.ts
+function getErrorCode(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    if (typeof code === "string")
+      return code;
   }
+  return;
+}
+function formatErrorEvent(error) {
+  let errCode;
+  let errMessage;
+  let errStack;
+  let errDetails;
+  if (error instanceof Error) {
+    errMessage = error.message || "Unknown error";
+    errStack = error.stack;
+    errCode = getErrorCode(error);
+  } else if (typeof error === "object" && error !== null) {
+    errMessage = error.message ? String(error.message) : JSON.stringify(error);
+    errCode = getErrorCode(error);
+    errDetails = error;
+  } else if (typeof error === "string") {
+    errMessage = error;
+  } else {
+    errMessage = String(error);
+  }
+  return {
+    type: "error",
+    content: errMessage,
+    error: {
+      code: errCode || "EXECUTION_ERROR",
+      message: errMessage || "An error occurred during execution",
+      details: { stack: errStack, originalError: errDetails }
+    }
+  };
 }
 
+// src/managers/pi-executor.ts
 class PiExecutorImpl {
   metadataManager;
   constructor(metadataManager) {
@@ -3591,7 +3940,7 @@ class PiExecutorImpl {
         throw new Error("No model specified in execution context");
       }
       model = model.replace(`${providerName.toLowerCase()}/`, "");
-      const cwd = isAbsolute2(context.threadPath) ? context.threadPath : resolve(getDataDir(), context.threadPath);
+      const cwd = isAbsolute2(context.threadPath) ? context.threadPath : resolve2(getDataDir(), context.threadPath);
       console.log("[ai] Execution context:", {
         model,
         cwd,
@@ -3619,9 +3968,9 @@ class PiExecutorImpl {
         api: resolvedModel.api,
         provider: resolvedModel.provider
       });
-      const tools = createCodingTools(cwd);
-      const systemPrompt = loadAgentSystemPrompt();
-      console.log("[ai] System prompt loaded from agents.md");
+      const tools = createCodingTools(cwd, { skills: context.skills });
+      const systemPrompt = loadAgentSystemPrompt(context.skills);
+      console.log("[ai] System prompt loaded from agents.md", context.skills && context.skills.length > 0 ? `with ${context.skills.length} skill(s)` : "");
       const agent = new Agent({
         initialState: {
           systemPrompt,
@@ -3630,74 +3979,19 @@ class PiExecutorImpl {
         },
         getApiKey: async () => apiKey
       });
-      const queue = [];
-      let resolver = null;
+      const eventQueue = new EventQueue;
       let done = false;
-      let finalContent = "";
-      let errorOccurred = false;
       const unsubscribe = agent.subscribe((event) => {
-        if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-          const delta = event.assistantMessageEvent.delta;
-          finalContent += delta;
-          queue.push({
-            type: "message",
-            role: "assistant",
-            content: delta
-          });
-        } else if (event.type === "tool_execution_start") {
-          queue.push({
-            type: "message",
-            role: "tool",
-            content: JSON.stringify([
-              {
-                type: "tool_use",
-                name: event.toolName,
-                id: event.toolCallId,
-                input: event.args
-              }
-            ])
-          });
-        } else if (event.type === "tool_execution_end") {
-          const resultContent = event.result?.content?.filter((b) => b.type === "text").map((b) => b.text || "").join("") || JSON.stringify(event.result);
-          queue.push({
-            type: "message",
-            role: "tool",
-            content: JSON.stringify([
-              {
-                type: "tool-result",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                content: resultContent,
-                isError: event.isError
-              }
-            ])
-          });
-        } else if (event.type === "agent_end") {
-          const messages = event.messages;
-          const lastAssistant = [...messages].reverse().find((m) => ("role" in m) && m.role === "assistant");
-          if (lastAssistant) {
-            const extracted = extractTextFromAssistantMessage(lastAssistant);
-            if (extracted && extracted !== finalContent) {
-              finalContent = extracted;
-            }
-          }
-        }
-        if (resolver) {
-          resolver();
-          resolver = null;
-        }
+        eventQueue.handlePiEvent(event);
       });
       const promptDone = agent.prompt(userPrompt).then(() => {
         done = true;
-        if (resolver) {
-          resolver();
-          resolver = null;
-        }
+        eventQueue.setResolver(() => {});
       }).catch((err) => {
-        if (!errorOccurred) {
-          errorOccurred = true;
+        if (!eventQueue.errorOccurred) {
+          eventQueue.errorOccurred = true;
           const errMessage = err instanceof Error ? err.message : String(err);
-          queue.push({
+          eventQueue.push({
             type: "error",
             content: errMessage,
             error: {
@@ -3710,68 +4004,40 @@ class PiExecutorImpl {
           });
         }
         done = true;
-        if (resolver) {
-          resolver();
-          resolver = null;
-        }
+        eventQueue.setResolver(() => {});
       });
       try {
-        while (!done || queue.length > 0) {
-          if (queue.length > 0) {
-            yield queue.shift();
+        while (!done || eventQueue.length > 0) {
+          if (eventQueue.length > 0) {
+            yield eventQueue.shift();
           } else {
-            await new Promise((r) => {
-              resolver = r;
+            await new Promise((resolve3) => {
+              eventQueue.setResolver(resolve3);
             });
           }
         }
         await promptDone;
-        if (!errorOccurred && finalContent) {
+        if (!eventQueue.errorOccurred && eventQueue.finalContent) {
           yield {
             type: "result",
-            content: finalContent
+            content: eventQueue.finalContent
           };
         }
       } finally {
         unsubscribe();
         agent.abort();
+        eventQueue.clearResolver();
       }
     } catch (error) {
       console.error("[ai] Error during execution:", error);
-      let errCode;
-      let errMessage;
-      let errStack;
-      let errDetails;
-      if (error instanceof Error) {
-        errMessage = error.message || "Unknown error";
-        errStack = error.stack;
-        errCode = getErrorCode(error);
-      } else if (typeof error === "object" && error !== null) {
-        errMessage = error.message ? String(error.message) : JSON.stringify(error);
-        errCode = getErrorCode(error);
-        errDetails = error;
-      } else if (typeof error === "string") {
-        errMessage = error;
-      } else {
-        errMessage = String(error);
-      }
-      console.error("[ai] Error details:", { errCode, errMessage, errStack });
-      yield {
-        type: "error",
-        content: errMessage,
-        error: {
-          code: errCode || "EXECUTION_ERROR",
-          message: errMessage || "An error occurred during execution",
-          details: { stack: errStack, originalError: errDetails }
-        }
-      };
+      yield formatErrorEvent(error);
     }
   }
 }
 
 // src/managers/conversation-manager.ts
 import { promises as fs2 } from "fs";
-import { join as join8, dirname as dirname6 } from "path";
+import { join as join10, dirname as dirname6 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var CONVERSATION_FILE = "conversation-history.json";
 
@@ -3860,8 +4126,8 @@ class ConversationManagerImpl {
   }
   getConversationFilePath(threadPath) {
     const threadId = threadPath.split(/[\\/]/).pop() || "unknown";
-    const conversationsDir = join8(this.metadataDir, "conversations");
-    return join8(conversationsDir, threadId, CONVERSATION_FILE);
+    const conversationsDir = join10(this.metadataDir, "conversations");
+    return join10(conversationsDir, threadId, CONVERSATION_FILE);
   }
 }
 
@@ -3908,6 +4174,9 @@ function streamAsyncGenerator(c, generator, options) {
   });
 }
 
+// src/routes/projects.ts
+init_dist();
+
 // src/lib/response-builder.ts
 class ResponseBuilder {
   static error(code, message, statusCode, details) {
@@ -3927,8 +4196,17 @@ class ResponseBuilder {
   }
 }
 
+// src/lib/route-helpers.ts
+function errorResponse(c, code, message, statusCode, details) {
+  const { response, statusCode: status } = ResponseBuilder.error(code, message, statusCode, details);
+  return c.json(response, status);
+}
+function successResponse(c, data, statusCode = 200) {
+  const { response, statusCode: status } = ResponseBuilder.success(data, statusCode);
+  return c.json(response, status);
+}
+
 // src/routes/projects.ts
-init_dist();
 function createProjectRoutes(projectManager, threadManager) {
   const router = new Hono;
   router.post("/", async (c) => {
@@ -3936,14 +4214,12 @@ function createProjectRoutes(projectManager, threadManager) {
       const body = await c.req.json();
       const { gitUrl, commitMethod } = body;
       if (!gitUrl || typeof gitUrl !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "gitUrl is required and must be a string", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "gitUrl is required and must be a string", 400);
       }
       const method = isValidCommitMethod(commitMethod) ? commitMethod : CommitMethods.PullRequest;
       return streamAsyncGenerator(c, projectManager.createProject(gitUrl, method));
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/", async (c) => {
@@ -3972,46 +4248,38 @@ function createProjectRoutes(projectManager, threadManager) {
       }));
       return c.json(expandedProjects);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("LIST_PROJECTS_ERROR", "Failed to list projects", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "LIST_PROJECTS_ERROR", "Failed to list projects", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/:id", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const project = await projectManager.getProject(projectId);
       if (!project) {
-        const { response, statusCode } = ResponseBuilder.error("PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
-        return c.json(response, statusCode);
+        return errorResponse(c, "PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
       }
       return c.json(project);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("GET_PROJECT_ERROR", "Failed to get project", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "GET_PROJECT_ERROR", "Failed to get project", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.delete("/:id", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       await projectManager.deleteProject(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Project deleted successfully" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Project deleted successfully" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("not found")) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("PROJECT_NOT_FOUND", errorMessage, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "PROJECT_NOT_FOUND", errorMessage, 404);
       }
-      const { response, statusCode } = ResponseBuilder.error("DELETE_PROJECT_ERROR", "Failed to delete project", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "DELETE_PROJECT_ERROR", "Failed to delete project", 500, errorMessage);
     }
   });
   router.post("/:id/open", async (c) => {
@@ -4021,31 +4289,25 @@ function createProjectRoutes(projectManager, threadManager) {
       const { program } = body;
       console.log("[POST /api/projects/:id/open] projectId=%s program=%s", projectId, program);
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       if (!program) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Program is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Program is required", 400);
       }
       if (!AVAILABLE_PROGRAMS.includes(program)) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(", ")}`, 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(", ")}`, 400);
       }
       const project = await projectManager.getProject(projectId);
       if (!project) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
       }
       console.log("[POST /api/projects/:id/open] Calling projectManager.openWith");
       await projectManager.openWith(projectId, program);
       console.log("[POST /api/projects/:id/open] openWith completed successfully");
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: `Project opened in ${program}` });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: `Project opened in ${program}` });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("OPEN_PROGRAM_ERROR", "Failed to open project", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "OPEN_PROGRAM_ERROR", "Failed to open project", 500, errorMessage);
     }
   });
   router.put("/:id", async (c) => {
@@ -4054,22 +4316,18 @@ function createProjectRoutes(projectManager, threadManager) {
       const body = await c.req.json();
       const { program, setupScript, name, runCommand, commitMethod, runNow } = body;
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const project = await projectManager.getProject(projectId);
       if (!project) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "PROJECT_NOT_FOUND", `Project not found: ${projectId}`, 404);
       }
       if (program !== undefined) {
         if (!program) {
-          const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Program cannot be empty", 400);
-          return c.json(response2, statusCode2);
+          return errorResponse(c, "INVALID_REQUEST", "Program cannot be empty", 400);
         }
         if (!AVAILABLE_PROGRAMS.includes(program)) {
-          const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(", ")}`, 400);
-          return c.json(response2, statusCode2);
+          return errorResponse(c, "INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(", ")}`, 400);
         }
         await projectManager.updateOpenWith(projectId, program);
       }
@@ -4087,24 +4345,20 @@ function createProjectRoutes(projectManager, threadManager) {
       if (commitMethod !== undefined) {
         if (!isValidCommitMethod(commitMethod)) {
           const validMethods = Object.values(CommitMethods).join('", "');
-          const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", `Commit method must be one of: "${validMethods}"`, 400);
-          return c.json(response2, statusCode2);
+          return errorResponse(c, "INVALID_REQUEST", `Commit method must be one of: "${validMethods}"`, 400);
         }
         await projectManager.updateCommitMethod(projectId, commitMethod);
       }
       if (name !== undefined) {
         if (!name || !name.trim()) {
-          const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project name is required", 400);
-          return c.json(response2, statusCode2);
+          return errorResponse(c, "INVALID_REQUEST", "Project name is required", 400);
         }
         await projectManager.updateProjectName(projectId, name);
       }
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Project updated" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Project updated" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("UPDATE_PROJECT_ERROR", "Failed to update project", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "UPDATE_PROJECT_ERROR", "Failed to update project", 500, errorMessage);
     }
   });
   router.post("/:id/commands", async (c) => {
@@ -4112,15 +4366,12 @@ function createProjectRoutes(projectManager, threadManager) {
       const projectId = c.req.param("id");
       const command = await c.req.json();
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       await projectManager.saveCommand(projectId, command);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Command saved" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Command saved" });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("SAVE_COMMAND_ERROR", "Failed to save command", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "SAVE_COMMAND_ERROR", "Failed to save command", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.delete("/:id/commands/:commandId", async (c) => {
@@ -4128,15 +4379,12 @@ function createProjectRoutes(projectManager, threadManager) {
       const projectId = c.req.param("id");
       const commandId = c.req.param("commandId");
       if (!projectId || !commandId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID and Command ID are required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID and Command ID are required", 400);
       }
       await projectManager.deleteCommand(projectId, commandId);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Command deleted" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Command deleted" });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("DELETE_COMMAND_ERROR", "Failed to delete command", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "DELETE_COMMAND_ERROR", "Failed to delete command", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.post("/:projectId/threads/:threadId/commands/run", async (c) => {
@@ -4144,71 +4392,58 @@ function createProjectRoutes(projectManager, threadManager) {
       const threadId = c.req.param("threadId");
       const { commandLine, cwd } = await c.req.json();
       if (!threadId || !commandLine) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID and commandLine are required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID and commandLine are required", 400);
       }
       return streamAsyncGenerator(c, projectManager.runCommand(threadId, commandLine, cwd));
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("RUN_COMMAND_ERROR", "Failed to run command", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "RUN_COMMAND_ERROR", "Failed to run command", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.post("/:id/run", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       return streamAsyncGenerator(c, projectManager.startRunningProcess(projectId));
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("START_PROCESS_ERROR", "Failed to start dev server", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "START_PROCESS_ERROR", "Failed to start dev server", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.post("/:id/run-suggest", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const runCommand = await projectManager.suggestRunCommand(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ runCommand });
-      return c.json(response, statusCode);
+      return successResponse(c, { runCommand });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("SUGGEST_RUN_COMMAND_ERROR", "Failed to suggest run command", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "SUGGEST_RUN_COMMAND_ERROR", "Failed to suggest run command", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.post("/:id/stop", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       await projectManager.stopRunningProcess(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Dev server stopped" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Dev server stopped" });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("STOP_PROCESS_ERROR", "Failed to stop dev server", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "STOP_PROCESS_ERROR", "Failed to stop dev server", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/:id/running", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const isRunning = await projectManager.isProcessRunning(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ isRunning });
-      return c.json(response, statusCode);
+      return successResponse(c, { isRunning });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("CHECK_PROCESS_ERROR", "Failed to check process status", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "CHECK_PROCESS_ERROR", "Failed to check process status", 500, error instanceof Error ? error.message : String(error));
     }
   });
   return router;
@@ -4328,6 +4563,7 @@ function extractAssistantContent(events, fallback) {
 }
 
 // src/routes/threads.ts
+import open2 from "open";
 var buildStructuredContentFromEvents = (events, fallbackContent) => {
   if (!events || events.length === 0) {
     return fallbackContent;
@@ -4378,98 +4614,81 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
       const body = await c.req.json();
       const { projectId, title } = body;
       if (!projectId || typeof projectId !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "projectId is required and must be a string", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "projectId is required and must be a string", 400);
       }
       if (title !== undefined && typeof title !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "title must be a string if provided", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "title must be a string if provided", 400);
       }
       if (title && title.trim() !== "") {
         const nameError = validateThreadName(title);
         if (nameError) {
-          const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", nameError, 400);
-          return c.json(response, statusCode);
+          return errorResponse(c, "INVALID_REQUEST", nameError, 400);
         }
         const existingThreads = await threadManager.listThreads(projectId);
         const sanitizedNewName = gitManager.sanitizeBranchName(title);
         const existingSanitized = existingThreads.map((t) => gitManager.sanitizeBranchName(t.title));
         if (existingSanitized.includes(sanitizedNewName)) {
-          const { response, statusCode } = ResponseBuilder.error("DUPLICATE_BRANCH", `A thread with branch name "${sanitizedNewName}" already exists`, 409);
-          return c.json(response, statusCode);
+          return errorResponse(c, "DUPLICATE_BRANCH", `A thread with branch name "${sanitizedNewName}" already exists`, 409);
         }
       }
       return streamAsyncGenerator(c, threadManager.createThread(projectId, title));
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/", async (c) => {
     try {
       const projectId = c.req.query("projectId");
       if (!projectId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "projectId query parameter is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "projectId query parameter is required", 400);
       }
       const threads = await threadManager.listThreads(projectId);
       return c.json(threads);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("LIST_THREADS_ERROR", "Failed to list threads", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "LIST_THREADS_ERROR", "Failed to list threads", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.delete("/:id", async (c) => {
     try {
       const threadId = c.req.param("id");
       if (!threadId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       await threadManager.deleteThread(threadId);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Thread deleted successfully" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Thread deleted successfully" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("not found")) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("THREAD_NOT_FOUND", errorMessage, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "THREAD_NOT_FOUND", errorMessage, 404);
       }
-      const { response, statusCode } = ResponseBuilder.error("DELETE_THREAD_ERROR", "Failed to delete thread", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "DELETE_THREAD_ERROR", "Failed to delete thread", 500, errorMessage);
     }
   });
   router.post("/:id/select", async (c) => {
     try {
       const threadId = c.req.param("id");
       if (!threadId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       const thread = await threadManager.getThread(threadId);
       if (!thread) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
       }
       await threadManager.selectThread(threadId);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Thread selected successfully", threadId });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Thread selected successfully", threadId });
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("SELECT_THREAD_ERROR", "Failed to select thread", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "SELECT_THREAD_ERROR", "Failed to select thread", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/:id/messages", async (c) => {
     try {
       const threadId = c.req.param("id");
       if (!threadId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       const thread = await threadManager.getThread(threadId);
       if (!thread) {
-        const { response, statusCode } = ResponseBuilder.error("THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
-        return c.json(response, statusCode);
+        return errorResponse(c, "THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
       }
       const history = await conversationManager.getConversationHistory(thread.path);
       if (!history || history.messages.length === 0) {
@@ -4504,22 +4723,19 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
       });
       return c.json(messages);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("GET_THREAD_MESSAGES_ERROR", "Failed to load thread messages", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "GET_THREAD_MESSAGES_ERROR", "Failed to load thread messages", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.get("/:id/files", async (c) => {
     try {
       const threadId = c.req.param("id");
       if (!threadId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       const files = await threadManager.listFiles(threadId);
       return c.json(files);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("LIST_THREAD_FILES_ERROR", "Failed to list thread files", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "LIST_THREAD_FILES_ERROR", "Failed to list thread files", 500, error instanceof Error ? error.message : String(error));
     }
   });
   router.patch("/:id", async (c) => {
@@ -4527,62 +4743,62 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
       const threadId = c.req.param("id");
       const body = await c.req.json();
       if (!threadId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       await threadManager.updateThread(threadId, body);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Thread updated successfully" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Thread updated successfully" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("UPDATE_THREAD_ERROR", "Failed to update thread", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "UPDATE_THREAD_ERROR", "Failed to update thread", 500, errorMessage);
     }
   });
+  const OPEN_APP_NAMES = {
+    "VS Code": ["Visual Studio Code", "code"],
+    Cursor: ["Cursor", "cursor"],
+    Windsurf: ["Windsurf", "windsurf"],
+    Xcode: "Xcode",
+    "Android Studio": ["Android Studio", "studio"],
+    Kiro: ["Kiro", "kiro"]
+  };
   router.post("/:id/open", async (c) => {
     try {
       const threadId = c.req.param("id");
       const body = await c.req.json();
       const { program } = body;
       if (!threadId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Thread ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Thread ID is required", 400);
       }
       if (!program) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Program is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Program is required", 400);
       }
       const { AVAILABLE_PROGRAMS: AVAILABLE_PROGRAMS2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
       if (!AVAILABLE_PROGRAMS2.includes(program)) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS2.join(", ")}`, 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS2.join(", ")}`, 400);
       }
       const thread = await threadManager.getThread(threadId);
       if (!thread) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
       }
-      const { spawn: spawn7 } = await import("child_process");
       const threadPath = thread.path;
-      if (program === "VS Code") {
-        spawn7("code", [threadPath], { detached: true });
-      } else if (program === "Cursor") {
-        spawn7("cursor", [threadPath], { detached: true });
-      } else if (program === "Windsurf") {
-        spawn7("windsurf", [threadPath], { detached: true });
-      } else if (program === "Xcode") {
-        spawn7("open", ["-a", "Xcode", threadPath], { detached: true });
-      } else if (program === "Android Studio") {
-        spawn7("open", ["-a", "Android Studio", threadPath], { detached: true });
-      } else if (program === "Kiro") {
-        spawn7("kiro", [threadPath], { detached: true });
-      }
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: `Thread opened in ${program}` });
-      return c.json(response, statusCode);
+      const appNames = OPEN_APP_NAMES[program];
+      if (!appNames) {
+        return errorResponse(c, "OPEN_PROGRAM_ERROR", `Unsupported program: ${program}`, 500);
+      }
+      console.log("[POST /api/threads/:id/open] threadId=%s program=%s threadPath=%s", threadId, program, threadPath);
+      try {
+        await open2(threadPath, {
+          app: { name: appNames }
+        });
+        console.log("[POST /api/threads/:id/open] Successfully opened thread in %s", program);
+      } catch (openError) {
+        const message = openError instanceof Error ? openError.message : String(openError);
+        console.error("[POST /api/threads/:id/open] Failed to open thread:", message);
+        return errorResponse(c, "OPEN_PROGRAM_ERROR", `Failed to open ${program}: ${message}`, 500);
+      }
+      return successResponse(c, { success: true, message: `Thread opened in ${program}` });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("OPEN_PROGRAM_ERROR", "Failed to open thread", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "OPEN_PROGRAM_ERROR", "Failed to open thread", 500, errorMessage);
     }
   });
   return router;
@@ -4591,9 +4807,274 @@ function createThreadRoutes(threadManager, gitManager, conversationManager) {
 // src/routes/chat.ts
 import { Hono as Hono3 } from "hono";
 
+// src/managers/skill-manager.ts
+import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
+import { join as join11 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir3 } from "os";
+function parseFrontmatter(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[0]?.trim() !== "---") {
+    return {
+      metadata: {},
+      content: markdown.trim()
+    };
+  }
+  let endIndex = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return {
+      metadata: {},
+      content: markdown.trim()
+    };
+  }
+  const frontmatterLines = lines.slice(1, endIndex);
+  const metadata = {};
+  for (const line of frontmatterLines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (key === "name") {
+      metadata.name = value;
+    } else if (key === "description") {
+      metadata.description = value;
+    } else if (key === "license") {
+      metadata.license = value;
+    } else if (key === "compatibility") {
+      metadata.compatibility = value;
+    } else if (key === "allowed-tools") {
+      metadata.allowedTools = value;
+    } else if (key === "metadata") {}
+  }
+  const content = lines.slice(endIndex + 1).join(`
+`).trim();
+  return { metadata, content };
+}
+function getGlobalSkillsDir() {
+  return join11(homedir3(), ".tarsk", "skills");
+}
+function getProjectSkillsDir(threadPath) {
+  return join11(threadPath, ".tarsk", "skills");
+}
+function validateSkillName(name) {
+  if (!name || name.length === 0 || name.length > 64) {
+    return false;
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return false;
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    return false;
+  }
+  if (name.includes("--")) {
+    return false;
+  }
+  return true;
+}
+function validateDescription(description) {
+  return description && description.length > 0 && description.length <= 1024;
+}
+
+class SkillManager {
+  async loadSkills(threadPath) {
+    const skills = new Map;
+    const globalDir = getGlobalSkillsDir();
+    if (existsSync8(globalDir)) {
+      const globalSkills = await this.loadSkillsFromDir(globalDir, "global");
+      for (const skill of globalSkills) {
+        skills.set(skill.name, skill);
+      }
+    }
+    const projectDir = getProjectSkillsDir(threadPath);
+    if (existsSync8(projectDir)) {
+      const projectSkills = await this.loadSkillsFromDir(projectDir, "project");
+      for (const skill of projectSkills) {
+        skills.set(skill.name, skill);
+      }
+    }
+    return Array.from(skills.values());
+  }
+  async loadSkillsFromDir(dir, scope) {
+    const skills = [];
+    try {
+      const entries = await readdir3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const skillDirName = entry.name;
+        const skillPath = join11(dir, skillDirName);
+        const skillFilePath = join11(skillPath, "SKILL.md");
+        if (!existsSync8(skillFilePath)) {
+          console.warn(`Skipping skill directory ${skillDirName}: SKILL.md not found`);
+          continue;
+        }
+        try {
+          const fileContent = await readFile3(skillFilePath, "utf-8");
+          const { metadata, content } = parseFrontmatter(fileContent);
+          if (!metadata.name) {
+            console.warn(`Skipping skill in ${skillDirName}: missing 'name' in frontmatter`);
+            continue;
+          }
+          if (!metadata.description) {
+            console.warn(`Skipping skill in ${skillDirName}: missing 'description' in frontmatter`);
+            continue;
+          }
+          if (!validateSkillName(metadata.name)) {
+            console.warn(`Skipping skill in ${skillDirName}: invalid name format '${metadata.name}'. ` + `Name must be 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.`);
+            continue;
+          }
+          if (!validateDescription(metadata.description)) {
+            console.warn(`Skipping skill in ${skillDirName}: description must be 1-1024 characters`);
+            continue;
+          }
+          if (metadata.name !== skillDirName) {
+            console.warn(`Skipping skill in ${skillDirName}: directory name must match frontmatter name '${metadata.name}'`);
+            continue;
+          }
+          const skill = {
+            name: metadata.name,
+            description: metadata.description,
+            scope,
+            skillPath,
+            instructions: content
+          };
+          if (metadata.license) {
+            skill.license = metadata.license;
+          }
+          if (metadata.compatibility) {
+            skill.compatibility = metadata.compatibility;
+          }
+          if (metadata.metadata) {
+            skill.metadata = metadata.metadata;
+          }
+          if (metadata.allowedTools) {
+            skill.allowedTools = metadata.allowedTools;
+          }
+          skills.push(skill);
+        } catch (error) {
+          console.error(`Failed to load skill from ${skillDirName}:`, error);
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to load skills from ${dir}:`, error);
+    }
+    return skills;
+  }
+  async getSkill(name, threadPath) {
+    const skills = await this.loadSkills(threadPath);
+    return skills.find((skill) => skill.name === name) || null;
+  }
+  validateSkillName(name) {
+    return validateSkillName(name);
+  }
+}
+
+// src/managers/skill-activation.ts
+var STOP_WORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "was",
+  "will",
+  "with",
+  "when",
+  "where",
+  "which",
+  "who",
+  "use",
+  "used",
+  "using",
+  "this",
+  "can",
+  "do",
+  "does",
+  "how",
+  "what",
+  "i",
+  "you",
+  "we",
+  "they",
+  "them",
+  "their",
+  "my",
+  "your",
+  "our"
+]);
+function extractKeywords(text) {
+  const keywords = new Set;
+  const words = text.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length >= 3);
+  for (const word of words) {
+    if (!STOP_WORDS.has(word)) {
+      keywords.add(word);
+    }
+  }
+  return keywords;
+}
+function calculateRelevanceScore(taskKeywords, skillDescription) {
+  const skillKeywords = extractKeywords(skillDescription);
+  if (skillKeywords.size === 0 || taskKeywords.size === 0) {
+    return 0;
+  }
+  let matches = 0;
+  for (const keyword of taskKeywords) {
+    if (skillKeywords.has(keyword)) {
+      matches++;
+    }
+  }
+  return matches / taskKeywords.size;
+}
+function autoDiscoverSkills(allSkills, taskDescription, relevanceThreshold = 0.1, maxSkills = 5) {
+  const taskKeywords = extractKeywords(taskDescription);
+  const scoredSkills = allSkills.map((skill) => ({
+    skill,
+    score: calculateRelevanceScore(taskKeywords, skill.description)
+  }));
+  const relevantSkills = scoredSkills.filter(({ score }) => score >= relevanceThreshold).sort((a, b) => b.score - a.score).slice(0, maxSkills).map(({ skill }) => skill);
+  return relevantSkills;
+}
+async function activateSkills(allSkills, taskDescription, thread, options) {
+  const { relevanceThreshold = 0.1, maxSkills = 5 } = options || {};
+  if (thread?.enabledSkills && thread.enabledSkills.length > 0) {
+    const enabledSet = new Set(thread.enabledSkills);
+    return allSkills.filter((skill) => enabledSet.has(skill.name));
+  }
+  const autoDiscovered = autoDiscoverSkills(allSkills, taskDescription, relevanceThreshold, maxSkills);
+  if (thread?.disabledSkills && thread.disabledSkills.length > 0) {
+    const disabledSet = new Set(thread.disabledSkills);
+    return autoDiscovered.filter((skill) => !disabledSet.has(skill.name));
+  }
+  return autoDiscovered;
+}
+
 // src/utils.ts
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/routes/chat.ts
@@ -4611,34 +5092,28 @@ function createChatRoutes(threadManager, agentExecutor, conversationManager, pro
         }
       }
       if (!threadId || typeof threadId !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "threadId is required and must be a string", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "threadId is required and must be a string", 400);
       }
       if (!content || typeof content !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "content is required and must be a string", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "content is required and must be a string", 400);
       }
       if (!model || typeof model !== "string") {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "model is required and must be a string", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "model is required and must be a string", 400);
       }
       const thread = await threadManager.getThread(threadId);
       if (!thread) {
-        const { response, statusCode } = ResponseBuilder.error("THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
-        return c.json(response, statusCode);
+        return errorResponse(c, "THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
       }
       const threadPath = thread.path;
       if (content.trim().toLowerCase() === "replay") {
         console.log("[ChatRoute] Replay request detected");
         const lastMessages = await conversationManager.getLastMessages(threadPath, 1);
         if (lastMessages.length === 0) {
-          const { response: response2, statusCode } = ResponseBuilder.error("NO_HISTORY", "No previous conversation found to replay", 404);
-          return c.json(response2, statusCode);
+          return errorResponse(c, "NO_HISTORY", "No previous conversation found to replay", 404);
         }
         const lastMessage = lastMessages[0];
         if (!lastMessage.response) {
-          const { response: response2, statusCode } = ResponseBuilder.error("NO_RESPONSE", "Previous message has no completed response to replay", 404);
-          return c.json(response2, statusCode);
+          return errorResponse(c, "NO_RESPONSE", "Previous message has no completed response to replay", 404);
         }
         console.log("[ChatRoute] Replaying message:", {
           messageId: lastMessage.id,
@@ -4669,13 +5144,20 @@ function createChatRoutes(threadManager, agentExecutor, conversationManager, pro
         }
         return streamAsyncGenerator(c, replayGenerator());
       }
+      const skillManager = new SkillManager;
+      const allSkills = await skillManager.loadSkills(threadPath);
+      const activatedSkills = await activateSkills(allSkills, content, thread);
+      if (activatedSkills.length > 0) {
+        console.log("[ChatRoute] Activated skills:", activatedSkills.map((s) => s.name).join(", "));
+      }
       const context = {
         threadId,
         threadPath,
         model,
         provider,
         attachments,
-        planMode
+        planMode,
+        skills: activatedSkills
       };
       console.log("[ChatRoute] Execution context:", {
         threadId,
@@ -4740,28 +5222,23 @@ User: ${content}` : content;
       }
       return streamAsyncGenerator(c, chatExecutionGenerator());
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
     }
   });
   router.delete("/:threadId", async (c) => {
     try {
       const threadId = c.req.param("threadId");
       if (!threadId || typeof threadId !== "string") {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "threadId is required and must be a string", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "threadId is required and must be a string", 400);
       }
       const thread = await threadManager.getThread(threadId);
       if (!thread) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "THREAD_NOT_FOUND", `Thread not found: ${threadId}`, 404);
       }
       await conversationManager.clearChatHistory(thread.path);
-      const { response, statusCode } = ResponseBuilder.success({ message: "Chat history cleared" }, 200);
-      return c.json(response, statusCode);
+      return successResponse(c, { message: "Chat history cleared" }, 200);
     } catch (error) {
-      const { response, statusCode } = ResponseBuilder.error("CLEAR_CHAT_ERROR", "Failed to clear chat history", 500, error instanceof Error ? error.message : String(error));
-      return c.json(response, statusCode);
+      return errorResponse(c, "CLEAR_CHAT_ERROR", "Failed to clear chat history", 500, error instanceof Error ? error.message : String(error));
     }
   });
   return router;
@@ -4934,9 +5411,9 @@ async function getAIHubMixCredits(apiKey) {
 
 // src/utils/env-manager.ts
 import { promises as fs3 } from "fs";
-import { join as join9 } from "path";
+import { join as join12 } from "path";
 async function updateEnvFile(keyNames) {
-  const envPath = join9(process.cwd(), ".env");
+  const envPath = join12(process.cwd(), ".env");
   let content = "";
   try {
     content = await fs3.readFile(envPath, "utf-8");
@@ -4967,7 +5444,7 @@ async function updateEnvFile(keyNames) {
 `, "utf-8");
 }
 async function readEnvFile() {
-  const envPath = join9(process.cwd(), ".env");
+  const envPath = join12(process.cwd(), ".env");
   const envMap = {};
   try {
     const content = await fs3.readFile(envPath, "utf-8");
@@ -5753,10 +6230,10 @@ function createModelRoutes(metadataManager) {
 
 // src/routes/git.ts
 import { Hono as Hono6 } from "hono";
-import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { join as join10 } from "path";
-import { isAbsolute as isAbsolute3, normalize, resolve as resolve2 } from "path";
+import { spawn as spawn8 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
+import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve3 } from "path";
 import {
   completeSimple,
   getModel as getModel2
@@ -5881,12 +6358,12 @@ Generate only the commit message, nothing else:`;
   }
 }
 function resolveThreadPath(repoPath) {
-  const base = isAbsolute3(repoPath) ? repoPath : resolve2(getDataDir(), repoPath);
-  return normalize(base);
+  const base = isAbsolute3(repoPath) ? repoPath : resolve3(getDataDir(), repoPath);
+  return normalize2(base);
 }
 function getGitRoot(cwd) {
   return new Promise((resolveRoot, reject) => {
-    const proc = spawn7("git", ["rev-parse", "--show-toplevel"], { cwd });
+    const proc = spawn8("git", ["rev-parse", "--show-toplevel"], { cwd });
     let out = "";
     let err = "";
     proc.stdout.on("data", (d) => {
@@ -5909,8 +6386,8 @@ function createGitRoutes(metadataManager) {
   const router = new Hono6;
   router.get("/username", async (c) => {
     try {
-      const name = await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["config", "user.name"]);
+      const name = await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["config", "user.name"]);
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -5921,7 +6398,7 @@ function createGitRoutes(metadataManager) {
         });
         proc.on("close", (code) => {
           if (code === 0) {
-            resolve3(out.trim());
+            resolve4(out.trim());
           } else {
             reject(new Error(err.trim() || `git exited ${code}`));
           }
@@ -5945,7 +6422,7 @@ function createGitRoutes(metadataManager) {
         return c.json({ error: "Thread path not found" }, 404);
       }
       const absolutePath = resolveThreadPath(repoPath);
-      if (!existsSync6(absolutePath)) {
+      if (!existsSync9(absolutePath)) {
         return c.json({
           error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
         }, 400);
@@ -5959,8 +6436,8 @@ function createGitRoutes(metadataManager) {
           error: `Path is not a git repository: ${absolutePath}. ${msg}`
         }, 400);
       }
-      const { hasChanges, changedFilesCount } = await new Promise((resolve3) => {
-        const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
+      const { hasChanges, changedFilesCount } = await new Promise((resolve4) => {
+        const proc = spawn8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
@@ -5968,34 +6445,34 @@ function createGitRoutes(metadataManager) {
         proc.on("close", () => {
           const lines = out.trim().split(`
 `).filter((line) => line.length > 0);
-          resolve3({
+          resolve4({
             hasChanges: lines.length > 0,
             changedFilesCount: lines.length
           });
         });
-        proc.on("error", () => resolve3({ hasChanges: false, changedFilesCount: 0 }));
+        proc.on("error", () => resolve4({ hasChanges: false, changedFilesCount: 0 }));
       });
-      const currentBranch = await new Promise((resolve3) => {
-        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
+      const currentBranch = await new Promise((resolve4) => {
+        const proc = spawn8("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
         });
         proc.on("close", () => {
-          resolve3(out.trim());
+          resolve4(out.trim());
         });
-        proc.on("error", () => resolve3(""));
+        proc.on("error", () => resolve4(""));
       });
-      const hasUnpushedCommits = await new Promise((resolve3) => {
-        const proc = spawn7("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], { cwd: gitRoot });
+      const hasUnpushedCommits = await new Promise((resolve4) => {
+        const proc = spawn8("git", ["log", `origin/${currentBranch}..HEAD`, "--oneline"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
         });
         proc.on("close", () => {
-          resolve3(out.trim().length > 0);
+          resolve4(out.trim().length > 0);
         });
-        proc.on("error", () => resolve3(false));
+        proc.on("error", () => resolve4(false));
       });
       return c.json({
         hasChanges,
@@ -6025,14 +6502,14 @@ function createGitRoutes(metadataManager) {
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      const statusOutput = await new Promise((resolve3) => {
-        const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
+      const statusOutput = await new Promise((resolve4) => {
+        const proc = spawn8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
         });
-        proc.on("close", () => resolve3(out));
-        proc.on("error", () => resolve3(""));
+        proc.on("close", () => resolve4(out));
+        proc.on("error", () => resolve4(""));
       });
       const changedFiles = [];
       const statusLines = statusOutput.trim().split(`
@@ -6066,51 +6543,51 @@ function createGitRoutes(metadataManager) {
         let newContent = "";
         const hunks = [];
         if (file.status === "deleted") {
-          const content = await new Promise((resolve3) => {
-            const proc = spawn7("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
+          const content = await new Promise((resolve4) => {
+            const proc = spawn8("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
             });
-            proc.on("close", () => resolve3(out));
-            proc.on("error", () => resolve3(""));
+            proc.on("close", () => resolve4(out));
+            proc.on("error", () => resolve4(""));
           });
           oldContent = content;
         } else if (file.status === "added" && file.path.startsWith("(new)")) {
           const fs4 = await import("fs");
           try {
-            newContent = fs4.readFileSync(resolve2(gitRoot, file.path.replace("(new) ", "")), "utf-8");
+            newContent = fs4.readFileSync(resolve3(gitRoot, file.path.replace("(new) ", "")), "utf-8");
           } catch {
             newContent = "";
           }
         } else {
-          const diffOutput = await new Promise((resolve3) => {
-            const proc = spawn7("git", file.status === "added" ? ["diff", "--cached", "--", file.path] : ["diff", "HEAD", "--", file.path], { cwd: gitRoot });
+          const diffOutput = await new Promise((resolve4) => {
+            const proc = spawn8("git", file.status === "added" ? ["diff", "--cached", "--", file.path] : ["diff", "HEAD", "--", file.path], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
             });
-            proc.on("close", () => resolve3(out));
-            proc.on("error", () => resolve3(""));
+            proc.on("close", () => resolve4(out));
+            proc.on("error", () => resolve4(""));
           });
           const lines = diffOutput.split(`
 `);
           let currentHunk = null;
           let oldLineNum = 0;
           let newLineNum = 0;
-          const oldContentOutput = await new Promise((resolve3) => {
-            const proc = spawn7("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
+          const oldContentOutput = await new Promise((resolve4) => {
+            const proc = spawn8("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
             let out = "";
             proc.stdout.on("data", (d) => {
               out += d.toString();
             });
-            proc.on("close", () => resolve3(out));
-            proc.on("error", () => resolve3(""));
+            proc.on("close", () => resolve4(out));
+            proc.on("error", () => resolve4(""));
           });
           oldContent = oldContentOutput;
           const fs4 = await import("fs");
           try {
-            newContent = fs4.readFileSync(resolve2(gitRoot, file.path), "utf-8");
+            newContent = fs4.readFileSync(resolve3(gitRoot, file.path), "utf-8");
           } catch {
             newContent = "";
           }
@@ -6193,7 +6670,7 @@ function createGitRoutes(metadataManager) {
       const absolutePath = resolveThreadPath(repoPath);
       process.stdout.write(`[generate-commit-message] resolved path: ${absolutePath}
 `);
-      if (!existsSync6(absolutePath)) {
+      if (!existsSync9(absolutePath)) {
         process.stdout.write(`[generate-commit-message] path does not exist: ${absolutePath}
 `);
         return c.json({
@@ -6217,7 +6694,7 @@ function createGitRoutes(metadataManager) {
         const runUnstagedDiff = () => {
           process.stdout.write(`[generate-commit-message] using unstaged diff (git diff)
 `);
-          const proc2 = spawn7("git", ["diff"], { cwd: gitRoot });
+          const proc2 = spawn8("git", ["diff"], { cwd: gitRoot });
           let out2 = "";
           proc2.stdout.on("data", (d) => {
             out2 += d.toString();
@@ -6227,7 +6704,7 @@ function createGitRoutes(metadataManager) {
           });
           proc2.on("error", reject);
         };
-        const proc = spawn7("git", ["diff", "--cached"], { cwd: gitRoot });
+        const proc = spawn8("git", ["diff", "--cached"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -6262,7 +6739,7 @@ function createGitRoutes(metadataManager) {
       });
       if (!diff.trim()) {
         const statusOut = await new Promise((resolveStatus) => {
-          const proc = spawn7("git", ["status", "--porcelain"], { cwd: gitRoot });
+          const proc = spawn8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: gitRoot });
           let out = "";
           proc.stdout.on("data", (d) => {
             out += d.toString();
@@ -6286,11 +6763,11 @@ function createGitRoutes(metadataManager) {
           const parts = [];
           const maxFileSize = 1e5;
           for (const relPath of untrackedPaths) {
-            const fullPath = join10(gitRoot, relPath);
-            if (!existsSync6(fullPath))
+            const fullPath = join13(gitRoot, relPath);
+            if (!existsSync9(fullPath))
               continue;
             try {
-              if (statSync3(fullPath).isDirectory())
+              if (statSync4(fullPath).isDirectory())
                 continue;
               const content = readFileSync4(fullPath, "utf-8");
               const safeContent = content.length > maxFileSize ? content.slice(0, maxFileSize) + `
@@ -6353,21 +6830,21 @@ new file mode 100644
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["add", "-A"], { cwd: gitRoot });
+      await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["add", "-A"], { cwd: gitRoot });
         proc.on("close", (code) => {
           if (code === 0)
-            resolve3();
+            resolve4();
           else
             reject(new Error("Failed to stage changes"));
         });
         proc.on("error", reject);
       });
-      await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["commit", "-m", message], { cwd: gitRoot });
+      await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["commit", "-m", message], { cwd: gitRoot });
         proc.on("close", (code) => {
           if (code === 0)
-            resolve3();
+            resolve4();
           else
             reject(new Error("Failed to commit changes"));
         });
@@ -6397,24 +6874,24 @@ new file mode 100644
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      const currentBranch = await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
+      const currentBranch = await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
         });
-        proc.on("close", () => resolve3(out.trim()));
+        proc.on("close", () => resolve4(out.trim()));
         proc.on("error", reject);
       });
-      await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
+      await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
         let err = "";
         proc.stderr.on("data", (d) => {
           err += d.toString();
         });
         proc.on("close", (code) => {
           if (code === 0)
-            resolve3();
+            resolve4();
           else
             reject(new Error(err || "Failed to push changes"));
         });
@@ -6444,15 +6921,15 @@ new file mode 100644
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["fetch", "origin"], { cwd: gitRoot });
+      await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["fetch", "origin"], { cwd: gitRoot });
         let err = "";
         proc.stderr.on("data", (d) => {
           err += d.toString();
         });
         proc.on("close", (code) => {
           if (code === 0)
-            resolve3();
+            resolve4();
           else
             reject(new Error(err || "Failed to fetch from origin"));
         });
@@ -6486,7 +6963,7 @@ new file mode 100644
       }
       const diff = await new Promise((resolveDiff, reject) => {
         const runPlainDiff = () => {
-          const proc2 = spawn7("git", ["diff"], { cwd: gitRoot });
+          const proc2 = spawn8("git", ["diff"], { cwd: gitRoot });
           let out2 = "";
           proc2.stdout.on("data", (d) => {
             out2 += d.toString();
@@ -6494,7 +6971,7 @@ new file mode 100644
           proc2.on("close", () => resolveDiff(out2));
           proc2.on("error", reject);
         };
-        const proc = spawn7("git", ["diff", "HEAD"], { cwd: gitRoot });
+        const proc = spawn8("git", ["diff", "HEAD"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -6578,8 +7055,8 @@ DESCRIPTION: <description here>`;
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      const commits = await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"], { cwd: gitRoot });
+      const commits = await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["log", "--oneline", "-n", limit.toString(), "--format=%H|%s|%an|%ai"], { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -6601,7 +7078,7 @@ DESCRIPTION: <description here>`;
                 date: parts[3] || ""
               };
             });
-            resolve3(parsed);
+            resolve4(parsed);
           } else {
             reject(new Error(err || "Failed to get git log"));
           }
@@ -6634,18 +7111,18 @@ DESCRIPTION: <description here>`;
       } catch {
         return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
       }
-      const currentBranch = await new Promise((resolve3, reject) => {
-        const proc = spawn7("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
+      const currentBranch = await new Promise((resolve4, reject) => {
+        const proc = spawn8("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
         let out = "";
         proc.stdout.on("data", (d) => {
           out += d.toString();
         });
-        proc.on("close", () => resolve3(out.trim()));
+        proc.on("close", () => resolve4(out.trim()));
         proc.on("error", reject);
       });
-      const prUrl = await new Promise((resolve3, reject) => {
+      const prUrl = await new Promise((resolve4, reject) => {
         const args = ["pr", "create", "--title", title || currentBranch, "--body", description || ""];
-        const proc = spawn7("gh", args, { cwd: gitRoot });
+        const proc = spawn8("gh", args, { cwd: gitRoot });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -6657,7 +7134,7 @@ DESCRIPTION: <description here>`;
         proc.on("close", (code) => {
           if (code === 0) {
             const urlMatch = out.match(/https:\/\/[^\s]+/);
-            resolve3(urlMatch ? urlMatch[0] : out.trim());
+            resolve4(urlMatch ? urlMatch[0] : out.trim());
           } else {
             reject(new Error(err || "Failed to create PR"));
           }
@@ -6681,84 +7158,69 @@ function createRunRoutes(projectManager) {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const runCommand = await projectManager.suggestRunCommand(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ runCommand });
-      return c.json(response, statusCode);
+      return successResponse(c, { runCommand });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("SUGGEST_RUN_COMMAND_ERROR", "Failed to suggest run command", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "SUGGEST_RUN_COMMAND_ERROR", "Failed to suggest run command", 500, errorMessage);
     }
   });
   router.post("/:id/run", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response, statusCode);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       return streamAsyncGenerator(c, projectManager.startRunningProcess(projectId));
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("RUN_PROCESS_ERROR", "Failed to start process", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "RUN_PROCESS_ERROR", "Failed to start process", 500, errorMessage);
     }
   });
   router.post("/:id/stop", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const stopped = await projectManager.stopRunningProcess(projectId);
       if (!stopped) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("NO_PROCESS_RUNNING", "No process running for this project", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "NO_PROCESS_RUNNING", "No process running for this project", 400);
       }
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Process stopped" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Process stopped" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("STOP_PROCESS_ERROR", "Failed to stop process", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "STOP_PROCESS_ERROR", "Failed to stop process", 500, errorMessage);
     }
   });
   router.get("/:id/running", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const isRunning = await projectManager.isProcessRunning(projectId);
-      const { response, statusCode } = ResponseBuilder.success({ isRunning });
-      return c.json(response, statusCode);
+      return successResponse(c, { isRunning });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("CHECK_RUNNING_ERROR", "Failed to check running status", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "CHECK_RUNNING_ERROR", "Failed to check running status", 500, errorMessage);
     }
   });
   router.put("/:id/run-command", async (c) => {
     try {
       const projectId = c.req.param("id");
       if (!projectId) {
-        const { response: response2, statusCode: statusCode2 } = ResponseBuilder.error("INVALID_REQUEST", "Project ID is required", 400);
-        return c.json(response2, statusCode2);
+        return errorResponse(c, "INVALID_REQUEST", "Project ID is required", 400);
       }
       const body = await c.req.json();
       const { runCommand } = body;
       await projectManager.updateRunCommand(projectId, runCommand || null);
-      const { response, statusCode } = ResponseBuilder.success({ success: true, message: "Run command updated" });
-      return c.json(response, statusCode);
+      return successResponse(c, { success: true, message: "Run command updated" });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const { response, statusCode } = ResponseBuilder.error("UPDATE_RUN_COMMAND_ERROR", "Failed to update run command", 500, errorMessage);
-      return c.json(response, statusCode);
+      return errorResponse(c, "UPDATE_RUN_COMMAND_ERROR", "Failed to update run command", 500, errorMessage);
     }
   });
   return router;
@@ -6766,7 +7228,7 @@ function createRunRoutes(projectManager) {
 
 // src/routes/onboarding.ts
 import { Hono as Hono8 } from "hono";
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 function createOnboardingRoutes(metadataManager) {
   const router = new Hono8;
   router.get("/status", async (c) => {
@@ -6780,17 +7242,17 @@ function createOnboardingRoutes(metadataManager) {
   });
   router.get("/git-check", async (c) => {
     try {
-      const gitInstalled = await new Promise((resolve3) => {
-        const proc = spawn8("git", ["--version"]);
+      const gitInstalled = await new Promise((resolve4) => {
+        const proc = spawn9("git", ["--version"]);
         let _err = "";
         proc.stderr.on("data", (d) => {
           _err += d.toString();
         });
         proc.on("close", (code) => {
-          resolve3(code === 0);
+          resolve4(code === 0);
         });
         proc.on("error", () => {
-          resolve3(false);
+          resolve4(false);
         });
       });
       return c.json({ gitInstalled });
@@ -6858,6 +7320,357 @@ function createScaffoldRoutes(projectManager) {
   return router;
 }
 
+// src/managers/slash-command-manager.ts
+import { readdir as readdir4, readFile as readFile4, mkdir as mkdir2, writeFile, unlink } from "fs/promises";
+import { join as join14, basename, extname as extname2 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir4 } from "os";
+function slugify(filename) {
+  return filename.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseFrontmatter2(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[0]?.trim() !== "---") {
+    return {
+      metadata: {},
+      content: markdown.trim()
+    };
+  }
+  let endIndex = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return {
+      metadata: {},
+      content: markdown.trim()
+    };
+  }
+  const frontmatterLines = lines.slice(1, endIndex);
+  const metadata = {};
+  for (const line of frontmatterLines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (key === "description") {
+      metadata.description = value;
+    } else if (key === "argument-hint") {
+      metadata.argumentHint = value;
+    } else if (key === "mode") {
+      metadata.mode = value;
+    }
+  }
+  const content = lines.slice(endIndex + 1).join(`
+`).trim();
+  return { metadata, content };
+}
+function getGlobalCommandsDir() {
+  return join14(homedir4(), ".tarsk", "commands");
+}
+function getProjectCommandsDir(threadPath) {
+  return join14(threadPath, ".tarsk", "commands");
+}
+
+class SlashCommandManager {
+  static BUILT_IN_COMMANDS = new Set(["init"]);
+  async loadCommands(threadPath) {
+    const commands = new Map;
+    const globalDir = getGlobalCommandsDir();
+    if (existsSync10(globalDir)) {
+      const globalCommands = await this.loadCommandsFromDir(globalDir, "global");
+      for (const cmd of globalCommands) {
+        commands.set(cmd.name, cmd);
+      }
+    }
+    const projectDir = getProjectCommandsDir(threadPath);
+    if (existsSync10(projectDir)) {
+      const projectCommands = await this.loadCommandsFromDir(projectDir, "project");
+      for (const cmd of projectCommands) {
+        if (!SlashCommandManager.BUILT_IN_COMMANDS.has(cmd.name)) {
+          commands.set(cmd.name, cmd);
+        }
+      }
+    }
+    return Array.from(commands.values());
+  }
+  async loadCommandsFromDir(dir, scope) {
+    const commands = [];
+    try {
+      const files = await readdir4(dir);
+      for (const file of files) {
+        if (!file.endsWith(".md"))
+          continue;
+        const filePath = join14(dir, file);
+        const fileContent = await readFile4(filePath, "utf-8");
+        const { metadata, content } = parseFrontmatter2(fileContent);
+        const nameWithoutExt = basename(file, extname2(file));
+        const commandName = slugify(nameWithoutExt);
+        if (!commandName)
+          continue;
+        commands.push({
+          name: commandName,
+          content,
+          metadata,
+          scope,
+          filePath
+        });
+      }
+    } catch (error) {
+      console.error(`Failed to load commands from ${dir}:`, error);
+    }
+    return commands;
+  }
+  async createCommand(name, content, metadata, scope, threadPath) {
+    if (SlashCommandManager.BUILT_IN_COMMANDS.has(name)) {
+      throw new Error(`Cannot create built-in command: ${name}`);
+    }
+    const dir = scope === "global" ? getGlobalCommandsDir() : threadPath ? getProjectCommandsDir(threadPath) : null;
+    if (!dir) {
+      throw new Error("threadPath required for project-scoped commands");
+    }
+    if (!existsSync10(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+    const filename = `${name}.md`;
+    const filePath = join14(dir, filename);
+    if (existsSync10(filePath)) {
+      throw new Error(`Command already exists: ${name}`);
+    }
+    let markdown = "";
+    if (metadata.description || metadata.argumentHint || metadata.mode) {
+      markdown += `---
+`;
+      if (metadata.description) {
+        markdown += `description: ${metadata.description}
+`;
+      }
+      if (metadata.argumentHint) {
+        markdown += `argument-hint: ${metadata.argumentHint}
+`;
+      }
+      if (metadata.mode) {
+        markdown += `mode: ${metadata.mode}
+`;
+      }
+      markdown += `---
+
+`;
+    }
+    markdown += content;
+    await writeFile(filePath, markdown, "utf-8");
+    return {
+      name,
+      content,
+      metadata,
+      scope,
+      filePath
+    };
+  }
+  async updateCommand(filePath, content, metadata) {
+    if (!existsSync10(filePath)) {
+      throw new Error(`Command file not found: ${filePath}`);
+    }
+    let markdown = "";
+    if (metadata.description || metadata.argumentHint || metadata.mode) {
+      markdown += `---
+`;
+      if (metadata.description) {
+        markdown += `description: ${metadata.description}
+`;
+      }
+      if (metadata.argumentHint) {
+        markdown += `argument-hint: ${metadata.argumentHint}
+`;
+      }
+      if (metadata.mode) {
+        markdown += `mode: ${metadata.mode}
+`;
+      }
+      markdown += `---
+
+`;
+    }
+    markdown += content;
+    await writeFile(filePath, markdown, "utf-8");
+  }
+  async deleteCommand(filePath) {
+    if (!existsSync10(filePath)) {
+      throw new Error(`Command file not found: ${filePath}`);
+    }
+    await unlink(filePath);
+  }
+  async getCommand(name, threadPath) {
+    const commands = await this.loadCommands(threadPath);
+    return commands.find((cmd) => cmd.name === name) || null;
+  }
+}
+
+// src/routes/slash-commands.ts
+var slashCommandManager = new SlashCommandManager;
+var skillManager = new SkillManager;
+function createSlashCommandRoutes(router, threadManager) {
+  router.get("/api/slash-commands", async (c) => {
+    const threadId = c.req.query("threadId");
+    if (!threadId) {
+      return c.json({
+        error: {
+          code: "MISSING_THREAD_ID",
+          message: "threadId query parameter is required",
+          timestamp: new Date().toISOString()
+        }
+      }, 400);
+    }
+    try {
+      const thread = await threadManager.getThread(threadId);
+      if (!thread) {
+        return c.json({
+          error: {
+            code: "THREAD_NOT_FOUND",
+            message: `Thread not found: ${threadId}`,
+            timestamp: new Date().toISOString()
+          }
+        }, 404);
+      }
+      const commands = await slashCommandManager.loadCommands(thread.path);
+      const skills = await skillManager.loadSkills(thread.path);
+      const response = {
+        commands,
+        skills
+      };
+      return c.json(response);
+    } catch (error) {
+      console.error("Failed to load slash commands:", error);
+      return c.json({
+        error: {
+          code: "LOAD_FAILED",
+          message: error instanceof Error ? error.message : "Failed to load slash commands",
+          details: error,
+          timestamp: new Date().toISOString()
+        }
+      }, 500);
+    }
+  });
+  router.post("/api/slash-commands", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { name, content, metadata, scope, threadId } = body;
+      if (!name || !content) {
+        return c.json({
+          error: {
+            code: "MISSING_FIELDS",
+            message: "name and content are required",
+            timestamp: new Date().toISOString()
+          }
+        }, 400);
+      }
+      if (scope !== "global" && scope !== "project") {
+        return c.json({
+          error: {
+            code: "INVALID_SCOPE",
+            message: 'scope must be either "global" or "project"',
+            timestamp: new Date().toISOString()
+          }
+        }, 400);
+      }
+      let threadPath;
+      if (scope === "project") {
+        if (!threadId) {
+          return c.json({
+            error: {
+              code: "MISSING_THREAD_ID",
+              message: "threadId is required for project-scoped commands",
+              timestamp: new Date().toISOString()
+            }
+          }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+          return c.json({
+            error: {
+              code: "THREAD_NOT_FOUND",
+              message: `Thread not found: ${threadId}`,
+              timestamp: new Date().toISOString()
+            }
+          }, 404);
+        }
+        threadPath = thread.path;
+      }
+      const command = await slashCommandManager.createCommand(name, content, metadata || {}, scope, threadPath);
+      return c.json(command, 201);
+    } catch (error) {
+      console.error("Failed to create slash command:", error);
+      return c.json({
+        error: {
+          code: "CREATE_FAILED",
+          message: error instanceof Error ? error.message : "Failed to create slash command",
+          details: error,
+          timestamp: new Date().toISOString()
+        }
+      }, 500);
+    }
+  });
+  router.put("/api/slash-commands", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { filePath, content, metadata } = body;
+      if (!filePath || !content) {
+        return c.json({
+          error: {
+            code: "MISSING_FIELDS",
+            message: "filePath and content are required",
+            timestamp: new Date().toISOString()
+          }
+        }, 400);
+      }
+      await slashCommandManager.updateCommand(filePath, content, metadata || {});
+      return c.json({ success: true });
+    } catch (error) {
+      console.error("Failed to update slash command:", error);
+      return c.json({
+        error: {
+          code: "UPDATE_FAILED",
+          message: error instanceof Error ? error.message : "Failed to update slash command",
+          details: error,
+          timestamp: new Date().toISOString()
+        }
+      }, 500);
+    }
+  });
+  router.delete("/api/slash-commands", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { filePath } = body;
+      if (!filePath) {
+        return c.json({
+          error: {
+            code: "MISSING_FILE_PATH",
+            message: "filePath is required",
+            timestamp: new Date().toISOString()
+          }
+        }, 400);
+      }
+      await slashCommandManager.deleteCommand(filePath);
+      return c.json({ success: true });
+    } catch (error) {
+      console.error("Failed to delete slash command:", error);
+      return c.json({
+        error: {
+          code: "DELETE_FAILED",
+          message: error instanceof Error ? error.message : "Failed to delete slash command",
+          details: error,
+          timestamp: new Date().toISOString()
+        }
+      }, 500);
+    }
+  });
+}
+
 // src/index.ts
 init_dist();
 var __filename2 = fileURLToPath3(import.meta.url);
@@ -6905,6 +7718,7 @@ app.route("/api/models", createModelRoutes(metadataManager));
 app.route("/api/git", createGitRoutes(metadataManager));
 app.route("/api/onboarding", createOnboardingRoutes(metadataManager));
 app.route("/api/scaffold", createScaffoldRoutes(projectManager));
+createSlashCommandRoutes(app, threadManager);
 var publicDir = path3.join(__dirname3, "public");
 var staticRoot = path3.relative(process.cwd(), publicDir);
 app.use("/*", async (c, next) => {
@@ -6922,14 +7736,14 @@ app.get("*", async (c, next) => {
   })(c, next);
 });
 app.all("*", (c) => {
-  const errorResponse = {
+  const errorResponse2 = {
     error: {
       code: "NOT_FOUND",
       message: `Route not found: ${c.req.method} ${c.req.path}`,
       timestamp: new Date().toISOString()
     }
   };
-  return c.json(errorResponse, 404);
+  return c.json(errorResponse2, 404);
 });
 var port = isDebug ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
 var url = `http://localhost:${port}`;
@@ -6941,6 +7755,6 @@ serve({
 }, () => {
   const isDevelopment = process.env.MODE === "development";
   if (shouldOpenBrowser || !isDevelopment) {
-    open2(url).catch(() => {});
+    open3(url).catch(() => {});
   }
 });