npm - @kody-ade/kody-engine-lite - Versions diffs - 0.1.127 → 0.1.129 - Mend

@kody-ade/kody-engine-lite 0.1.127 → 0.1.129

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/bin/cli.js CHANGED Viewed

@@ -180,8 +180,8 @@ var init_validators = __esm({
 });
 // src/config.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 function resolveStageConfig(config, stageName, modelTier) {
   const stageOverride = config.agent.stages?.[stageName];
   if (stageOverride) return stageOverride;
@@ -225,10 +225,10 @@ function setConfigDir(dir) {
 }
 function getProjectConfig() {
   if (_config) return _config;
-  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs8.existsSync(configPath)) {
+  const configPath = path6.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs7.existsSync(configPath)) {
     try {
-      const result2 = parseJsonSafe(fs8.readFileSync(configPath, "utf-8"));
+      const result2 = parseJsonSafe(fs7.readFileSync(configPath, "utf-8"));
       if (!result2.ok) {
         logger.warn(`kody.config.json: ${result2.error} \u2014 using defaults`);
         _config = { ...DEFAULT_CONFIG };
@@ -302,24 +302,24 @@ var init_config = __esm({
 });
 // src/agent-runner.ts
-import { spawn, execFileSync as execFileSync6 } from "child_process";
+import { spawn, execFileSync as execFileSync5 } from "child_process";
 function writeStdin(child, prompt) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     if (!child.stdin) {
-      resolve6();
+      resolve5();
       return;
     }
     child.stdin.write(prompt, (err) => {
       if (err) reject(err);
       else {
         child.stdin.end();
-        resolve6();
+        resolve5();
       }
     });
   });
 }
 function waitForProcess(child, timeout) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
@@ -332,7 +332,7 @@ function waitForProcess(child, timeout) {
     }, timeout);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve6({
+      resolve5({
         code,
         stdout: Buffer.concat(stdoutChunks).toString(),
         stderr: Buffer.concat(stderrChunks).toString()
@@ -340,7 +340,7 @@ function waitForProcess(child, timeout) {
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve6({ code: -1, stdout: "", stderr: err.message });
+      resolve5({ code: -1, stdout: "", stderr: err.message });
     });
   });
 }
@@ -376,7 +376,7 @@ ${errDetail}`
 }
 function checkCommand2(command2, args2) {
   try {
-    execFileSync6(command2, args2, { timeout: 1e4, stdio: "pipe" });
+    execFileSync5(command2, args2, { timeout: 1e4, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -521,7 +521,7 @@ var init_mcp_config = __esm({
 });
 // src/github-api.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 function isGhExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -545,7 +545,7 @@ function ghToken() {
 function gh(args2, options) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync7("gh", args2, {
+  return execFileSync6("gh", args2, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd: _ghCwd,
@@ -949,18 +949,18 @@ var init_github_api = __esm({
 });
 // src/cli/task-resolution.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
-import { execFileSync as execFileSync8 } from "child_process";
+import * as fs9 from "fs";
+import * as path8 from "path";
+import { execFileSync as execFileSync7 } from "child_process";
 function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path9.join(projectDir, ".kody", "tasks");
-  if (!fs10.existsSync(tasksDir)) return null;
-  const allDirs = fs10.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const tasksDir = path8.join(projectDir, ".kody", "tasks");
+  if (!fs9.existsSync(tasksDir)) return null;
+  const allDirs = fs9.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
   const prefix = `${issueNumber}-`;
   const direct = allDirs.find((d) => d.startsWith(prefix));
   if (direct) return direct;
   try {
-    const branch = execFileSync8("git", ["branch", "--show-current"], {
+    const branch = execFileSync7("git", ["branch", "--show-current"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -999,14 +999,14 @@ function resolveTaskIdFromComments(issueNumber) {
   }
 }
 function findPausedTaskifyForIssue(issueNumber, projectDir) {
-  const tasksDir = path9.join(projectDir, ".kody", "tasks");
-  if (!fs10.existsSync(tasksDir)) return null;
-  const allDirs = fs10.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const tasksDir = path8.join(projectDir, ".kody", "tasks");
+  if (!fs9.existsSync(tasksDir)) return null;
+  const allDirs = fs9.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
   for (const dir of allDirs) {
-    const markerPath = path9.join(tasksDir, dir, "taskify.marker");
-    if (!fs10.existsSync(markerPath)) continue;
+    const markerPath = path8.join(tasksDir, dir, "taskify.marker");
+    if (!fs9.existsSync(markerPath)) continue;
     try {
-      const marker = JSON.parse(fs10.readFileSync(markerPath, "utf-8"));
+      const marker = JSON.parse(fs9.readFileSync(markerPath, "utf-8"));
       if (marker.issueNumber === issueNumber) return dir;
     } catch {
     }
@@ -1030,10 +1030,10 @@ var init_task_resolution = __esm({
 });
 // src/cli/litellm.ts
-import * as fs11 from "fs";
+import * as fs10 from "fs";
 import * as os from "os";
-import * as path10 from "path";
-import { execFileSync as execFileSync9 } from "child_process";
+import * as path9 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -1132,17 +1132,17 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
     logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
     return null;
   }
-  const configPath = path10.join(os.tmpdir(), "kody-litellm-config.yaml");
-  fs11.writeFileSync(configPath, generatedConfig);
+  const configPath = path9.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs10.writeFileSync(configPath, generatedConfig);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
   try {
-    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync8("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     litellmFound = true;
   } catch {
     try {
-      execFileSync9("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync8("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
       litellmFound = true;
     } catch {
     }
@@ -1155,17 +1155,17 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
   let cmd;
   let args2;
   try {
-    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync8("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     cmd = "litellm";
     args2 = ["--config", configPath, "--port", port];
   } catch {
     cmd = "python3";
     args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-  const dotenvPath = path10.join(projectDir, ".env");
+  const dotenvPath = path9.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs11.existsSync(dotenvPath)) {
-    for (const rawLine of fs11.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  if (fs10.existsSync(dotenvPath)) {
+    for (const rawLine of fs10.readFileSync(dotenvPath, "utf-8").split("\n")) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#")) continue;
       const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -1225,8 +1225,8 @@ __export(taskify_command_exports, {
   taskifyCommand: () => taskifyCommand,
   topoSort: () => topoSort
 });
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 function topoSort(tasks) {
@@ -1270,10 +1270,10 @@ function hasFlag(args2, flag) {
 async function runTaskifyCommand() {
   const args2 = process.argv.slice(3);
   const cwdArg = getArg(args2, "--cwd") ?? process.cwd();
-  const projectDir = path11.resolve(cwdArg);
+  const projectDir = path10.resolve(cwdArg);
   const ticketId = getArg(args2, "--ticket") ?? process.env.TICKET_ID;
   const prdFileArg = getArg(args2, "--file") ?? process.env.PRD_FILE;
-  const prdFile = prdFileArg ? path11.resolve(projectDir, prdFileArg) : void 0;
+  const prdFile = prdFileArg ? path10.resolve(projectDir, prdFileArg) : void 0;
   const issueNumberStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER ?? "";
   const issueNumber = issueNumberStr ? parseInt(issueNumberStr, 10) : void 0;
   const feedback = getArg(args2, "--feedback") ?? process.env.FEEDBACK;
@@ -1284,7 +1284,7 @@ async function runTaskifyCommand() {
     logger.error("Usage: kody taskify --ticket <ticket-id>  OR  kody taskify --file <prd.md>  OR  kody taskify --issue-number <n>");
     process.exit(1);
   }
-  if (prdFile && !fs12.existsSync(prdFile)) {
+  if (prdFile && !fs11.existsSync(prdFile)) {
     logger.error(`File not found: ${prdFile}`);
     process.exit(1);
   }
@@ -1325,8 +1325,8 @@ async function runTaskifyCommand() {
 async function taskifyCommand(opts) {
   const { ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId } = opts;
   const config = getProjectConfig();
-  const taskDir = path11.join(projectDir, ".kody", "tasks", taskId);
-  fs12.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path10.join(projectDir, ".kody", "tasks", taskId);
+  fs11.mkdirSync(taskDir, { recursive: true });
   const mode = prdFile ? "file" : ticketId ? "ticket" : "issue";
   logger.info(`[taskify] mode=${mode} source=${ticketId ?? prdFile ?? `issue#${issueNumber}`} issue=${issueNumber ?? "none"} task=${taskId}`);
   let mcpConfigJson;
@@ -1350,7 +1350,7 @@ Add the required MCP server config to \`kody.config.json\` and try again.`
   }
   const sc = resolveStageConfig(config, "taskify", "strong");
   const model = sc.model;
-  const fileContent = prdFile ? fs12.readFileSync(prdFile, "utf-8") : void 0;
+  const fileContent = prdFile ? fs11.readFileSync(prdFile, "utf-8") : void 0;
   let issueBody;
   if (mode === "issue" && issueNumber) {
     const issue = getIssue(issueNumber);
@@ -1366,10 +1366,10 @@ ${issue.body}`;
   let projectContext;
   {
     const parts = [];
-    const memoryPath = path11.join(projectDir, ".kody", "memory.md");
-    if (fs12.existsSync(memoryPath)) {
+    const memoryPath = path10.join(projectDir, ".kody", "memory.md");
+    if (fs11.existsSync(memoryPath)) {
       try {
-        const content = fs12.readFileSync(memoryPath, "utf-8").slice(0, 2e3);
+        const content = fs11.readFileSync(memoryPath, "utf-8").slice(0, 2e3);
         if (content.trim()) parts.push(`### Project Memory
 ${content}`);
       } catch {
@@ -1388,14 +1388,14 @@ ${lines.join("\n")}
   }
   const prompt = buildPrompt({ ticketId, fileContent, issueBody, taskDir, feedback, projectContext });
   if (issueNumber && !local) {
-    const src = mode === "file" ? `file \`${path11.basename(prdFile)}\`` : mode === "ticket" ? `ticket **${ticketId}**` : `issue #${issueNumber} description`;
+    const src = mode === "file" ? `file \`${path10.basename(prdFile)}\`` : mode === "ticket" ? `ticket **${ticketId}**` : `issue #${issueNumber} description`;
     const runUrl = process.env.RUN_URL ? ` ([logs](${process.env.RUN_URL}))` : "";
     postComment(issueNumber, `\u{1F680} Kody pipeline started: \`${taskId}\`${runUrl}
 Kody is decomposing ${src} into tasks...`);
     setLifecycleLabel(issueNumber, "planning");
   }
-  fs12.writeFileSync(path11.join(taskDir, MARKER_FILE), JSON.stringify({ ticketId, prdFile, issueNumber }));
+  fs11.writeFileSync(path10.join(taskDir, MARKER_FILE), JSON.stringify({ ticketId, prdFile, issueNumber }));
   const runner = opts.runner ?? createClaudeCodeRunner();
   logger.info(`  model=${model} timeout=${TASKIFY_TIMEOUT_MS / 1e3}s`);
   const result2 = await runner.run("taskify", prompt, model, TASKIFY_TIMEOUT_MS, taskDir, {
@@ -1413,8 +1413,8 @@ Kody is decomposing ${src} into tasks...`);
     }
     throw new TaskifyError(errMsg);
   }
-  const resultPath = path11.join(taskDir, RESULT_FILE);
-  if (!fs12.existsSync(resultPath)) {
+  const resultPath = path10.join(taskDir, RESULT_FILE);
+  if (!fs11.existsSync(resultPath)) {
     const errMsg = `Claude did not write ${RESULT_FILE}. Output:
 ${result2.output?.slice(0, 500) ?? "(none)"}`;
@@ -1428,7 +1428,7 @@ ${errMsg}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs12.readFileSync(resultPath, "utf-8"));
+    parsed = JSON.parse(fs11.readFileSync(resultPath, "utf-8"));
   } catch {
     const errMsg = `Could not parse ${RESULT_FILE} as JSON.`;
     if (issueNumber && !local) {
@@ -1437,7 +1437,7 @@ ${errMsg}`);
     }
     throw new TaskifyError(errMsg);
   }
-  const sourceLabel = ticketId ?? (prdFile ? path11.basename(prdFile) : issueNumber ? `issue #${issueNumber}` : "spec");
+  const sourceLabel = ticketId ?? (prdFile ? path10.basename(prdFile) : issueNumber ? `issue #${issueNumber}` : "spec");
   if (parsed.status === "questions") {
     handleQuestions(parsed, sourceLabel, issueNumber, local ?? false);
   } else if (parsed.status === "ready") {
@@ -1537,15 +1537,15 @@ function buildPrompt(opts) {
   const { ticketId, fileContent, issueBody, taskDir, feedback, projectContext } = opts;
   const scriptDir = new URL(".", import.meta.url).pathname;
   const candidates = [
-    path11.resolve(scriptDir, "..", "prompts", "taskify-ticket.md"),
-    path11.resolve(scriptDir, "..", "..", "prompts", "taskify-ticket.md"),
-    path11.resolve(__dirname, "..", "..", "prompts", "taskify-ticket.md"),
-    path11.resolve(__dirname, "..", "prompts", "taskify-ticket.md")
+    path10.resolve(scriptDir, "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(scriptDir, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "prompts", "taskify-ticket.md")
   ];
   let template = "";
   for (const candidate of candidates) {
-    if (fs12.existsSync(candidate)) {
-      template = fs12.readFileSync(candidate, "utf-8");
+    if (fs11.existsSync(candidate)) {
+      template = fs11.readFileSync(candidate, "utf-8");
       break;
     }
   }
@@ -1569,13 +1569,13 @@ function buildPrompt(opts) {
   return template;
 }
 function isTaskifyRun(taskDir) {
-  return fs12.existsSync(path11.join(taskDir, MARKER_FILE));
+  return fs11.existsSync(path10.join(taskDir, MARKER_FILE));
 }
 function readTaskifyMarker(taskDir) {
-  const markerPath = path11.join(taskDir, MARKER_FILE);
-  if (!fs12.existsSync(markerPath)) return null;
+  const markerPath = path10.join(taskDir, MARKER_FILE);
+  if (!fs11.existsSync(markerPath)) return null;
   try {
-    return JSON.parse(fs12.readFileSync(markerPath, "utf-8"));
+    return JSON.parse(fs11.readFileSync(markerPath, "utf-8"));
   } catch {
     return null;
   }
@@ -1591,7 +1591,7 @@ var init_taskify_command = __esm({
     init_logger();
     init_task_resolution();
     init_litellm();
-    __dirname = path11.dirname(fileURLToPath(import.meta.url));
+    __dirname = path10.dirname(fileURLToPath(import.meta.url));
     TaskifyError = class extends Error {
       constructor(message) {
         super(message);
@@ -1607,9 +1607,9 @@ var init_taskify_command = __esm({
 });
 // src/cli/test-model-tests.ts
-import * as fs13 from "fs";
+import * as fs12 from "fs";
 import * as os2 from "os";
-import * as path12 from "path";
+import * as path11 from "path";
 import * as zlib from "zlib";
 import { spawnSync, execSync as execSync2 } from "child_process";
 function canRunApiTests(ctx) {
@@ -1937,8 +1937,8 @@ async function testExtendedThinking(ctx) {
 async function testToolRead(ctx) {
   if (!canRunApiTests(ctx)) {
     const t2 = Date.now();
-    const testFile2 = path12.join(os2.tmpdir(), "kody-test-model-read.txt");
-    fs13.writeFileSync(testFile2, "KODY_SECRET_CONTENT_42");
+    const testFile2 = path11.join(os2.tmpdir(), "kody-test-model-read.txt");
+    fs12.writeFileSync(testFile2, "KODY_SECRET_CONTENT_42");
     try {
       const r = runClaudeTest(ctx, `Read the file ${testFile2} and tell me its exact contents. Reply with ONLY the file contents.`);
       const ok = r.stdout.includes("KODY_SECRET_CONTENT_42");
@@ -1952,12 +1952,12 @@ async function testToolRead(ctx) {
         { toolSelection: ok ? 100 : 0 }
       );
     } finally {
-      fs13.rmSync(testFile2, { force: true });
+      fs12.rmSync(testFile2, { force: true });
     }
   }
   const t = Date.now();
-  const testFile = path12.join(os2.tmpdir(), "kody-test-model-read.txt");
-  fs13.writeFileSync(testFile, "KODY_SECRET_CONTENT_42");
+  const testFile = path11.join(os2.tmpdir(), "kody-test-model-read.txt");
+  fs12.writeFileSync(testFile, "KODY_SECRET_CONTENT_42");
   try {
     const conv = await runToolConversation(
       ctx,
@@ -1986,17 +1986,17 @@ async function testToolRead(ctx) {
       { toolSelection: calledRead ? 100 : 0 }
     );
   } finally {
-    fs13.rmSync(testFile, { force: true });
+    fs12.rmSync(testFile, { force: true });
   }
 }
 async function testToolEdit(ctx) {
   if (!canRunApiTests(ctx)) {
     const t2 = Date.now();
-    const testFile = path12.join(os2.tmpdir(), "kody-test-model-edit.txt");
-    fs13.writeFileSync(testFile, "hello world");
+    const testFile = path11.join(os2.tmpdir(), "kody-test-model-edit.txt");
+    fs12.writeFileSync(testFile, "hello world");
     try {
       const r = runClaudeTest(ctx, `Use the Edit tool to replace "hello" with "goodbye" in ${testFile}. Do nothing else.`);
-      const content = fs13.existsSync(testFile) ? fs13.readFileSync(testFile, "utf-8") : "";
+      const content = fs12.existsSync(testFile) ? fs12.readFileSync(testFile, "utf-8") : "";
       const ok = content.includes("goodbye");
       return result(
         "tool_edit",
@@ -2008,7 +2008,7 @@ async function testToolEdit(ctx) {
         { toolSelection: ok ? 100 : 0 }
       );
     } finally {
-      fs13.rmSync(testFile, { force: true });
+      fs12.rmSync(testFile, { force: true });
     }
   }
   const t = Date.now();
@@ -2082,8 +2082,8 @@ async function testToolBash(ctx) {
 async function testImageAttachment(ctx) {
   if (!canRunApiTests(ctx)) {
     const t2 = Date.now();
-    const tmpPng = path12.join(os2.tmpdir(), "kody-test-image.png");
-    fs13.writeFileSync(tmpPng, createRedPng());
+    const tmpPng = path11.join(os2.tmpdir(), "kody-test-image.png");
+    fs12.writeFileSync(tmpPng, createRedPng());
     try {
       const r = runClaudeTest(ctx, `Read the image file at ${tmpPng} and tell me what color it is. Reply with just the color name.`);
       const text2 = r.stdout.toLowerCase();
@@ -2097,7 +2097,7 @@ async function testImageAttachment(ctx) {
         ok ? "Image processed correctly via CLI" : `Got: ${text2.slice(0, 80)}`
       );
     } finally {
-      fs13.rmSync(tmpPng, { force: true });
+      fs12.rmSync(tmpPng, { force: true });
     }
   }
   const t = Date.now();
@@ -2312,10 +2312,10 @@ async function testReviewStage(ctx) {
 }
 async function testMcpTools(ctx) {
   const t = Date.now();
-  const mcpConfig = path12.join(os2.tmpdir(), `kody-test-mcp-${Date.now()}.json`);
-  const testFile = path12.join(ctx.projectDir, "kody-mcp-compat-test.txt");
+  const mcpConfig = path11.join(os2.tmpdir(), `kody-test-mcp-${Date.now()}.json`);
+  const testFile = path11.join(ctx.projectDir, "kody-mcp-compat-test.txt");
   try {
-    fs13.writeFileSync(mcpConfig, JSON.stringify({
+    fs12.writeFileSync(mcpConfig, JSON.stringify({
       mcpServers: {
         filesystem: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", ctx.projectDir] }
       }
@@ -2326,8 +2326,8 @@ async function testMcpTools(ctx) {
       ["--mcp-config", mcpConfig],
       12e4
     );
-    const created = fs13.existsSync(testFile);
-    const content = created ? fs13.readFileSync(testFile, "utf-8").trim() : "";
+    const created = fs12.existsSync(testFile);
+    const content = created ? fs12.readFileSync(testFile, "utf-8").trim() : "";
     const correct = content.includes("mcp-ok");
     return result(
       "mcp_tools",
@@ -2340,8 +2340,8 @@ async function testMcpTools(ctx) {
   } catch (err) {
     return result("mcp_tools", "advanced", "warn", 0, Date.now() - t, `MCP test error: ${err instanceof Error ? err.message : String(err)}`);
   } finally {
-    fs13.rmSync(mcpConfig, { force: true });
-    fs13.rmSync(testFile, { force: true });
+    fs12.rmSync(mcpConfig, { force: true });
+    fs12.rmSync(testFile, { force: true });
     revertChanges(ctx.projectDir);
   }
 }
@@ -2522,10 +2522,10 @@ var test_model_command_exports = {};
 __export(test_model_command_exports, {
   runTestModelCommand: () => runTestModelCommand
 });
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 import * as os3 from "os";
-import * as path13 from "path";
-import { execFileSync as execFileSync10 } from "child_process";
+import * as path12 from "path";
+import { execFileSync as execFileSync9 } from "child_process";
 function parseTestModelArgs() {
   const args2 = process.argv.slice(3);
   function getArg3(flag) {
@@ -2598,16 +2598,16 @@ function generateConfig(provider, model, dropParams) {
 }
 async function startProxy(config, url) {
   try {
-    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
   } catch {
     try {
-      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync9("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
     } catch {
       logger.error("litellm not installed. Install: pip install 'litellm[proxy]'");
       return null;
     }
   }
-  fs14.writeFileSync(CONFIG_PATH, config);
+  fs13.writeFileSync(CONFIG_PATH, config);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4099";
   const { spawn: spawn2 } = await import("child_process");
@@ -2649,7 +2649,7 @@ async function quickApiTest(url, model, apiKey) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function runTestModelCommand() {
   const opts = parseTestModelArgs();
@@ -2663,7 +2663,7 @@ async function runTestModelCommand() {
       proxyProcess.kill();
       proxyProcess = null;
     }
-    fs14.rmSync(CONFIG_PATH, { force: true });
+    fs13.rmSync(CONFIG_PATH, { force: true });
   };
   process.on("SIGINT", () => {
     cleanup();
@@ -2757,7 +2757,7 @@ var init_test_model_command = __esm({
     init_test_model_report();
     TEST_PORT = 4099;
     TEST_URL = `http://localhost:${TEST_PORT}`;
-    CONFIG_PATH = path13.join(os3.tmpdir(), "kody-test-model-config.yaml");
+    CONFIG_PATH = path12.join(os3.tmpdir(), "kody-test-model-config.yaml");
   }
 });
@@ -2768,7 +2768,7 @@ __export(parse_inputs_exports, {
   runCiParse: () => runCiParse,
   writeOutputs: () => writeOutputs
 });
-import * as fs15 from "fs";
+import * as fs14 from "fs";
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const pad2 = (n) => String(n).padStart(2, "0");
@@ -2917,12 +2917,12 @@ function writeOutputs(result2) {
   function output(key, value) {
     if (outputFile) {
       if (value.includes("\n")) {
-        fs15.appendFileSync(outputFile, `${key}<<KODY_EOF
+        fs14.appendFileSync(outputFile, `${key}<<KODY_EOF
 ${value}
 KODY_EOF
 `);
       } else {
-        fs15.appendFileSync(outputFile, `${key}=${value}
+        fs14.appendFileSync(outputFile, `${key}=${value}
 `);
       }
     }
@@ -3047,7 +3047,7 @@ var init_definitions = __esm({
 });
 // src/git-utils.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 function getHookSafeEnv() {
   if (!_hookSafeEnv) {
     _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
@@ -3055,7 +3055,7 @@ function getHookSafeEnv() {
   return _hookSafeEnv;
 }
 function git(args2, options) {
-  return execFileSync11("git", args2, {
+  return execFileSync10("git", args2, {
     encoding: "utf-8",
     timeout: options?.timeout ?? 3e4,
     cwd: options?.cwd,
@@ -3241,14 +3241,14 @@ var init_git_utils = __esm({
 });
 // src/pipeline/state.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function loadState(taskId, taskDir) {
-  const p = path14.join(taskDir, "status.json");
-  if (!fs16.existsSync(p)) return null;
+  const p = path13.join(taskDir, "status.json");
+  if (!fs15.existsSync(p)) return null;
   try {
     const result2 = parseJsonSafe(
-      fs16.readFileSync(p, "utf-8"),
+      fs15.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
     if (!result2.ok) {
@@ -3266,10 +3266,10 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path14.join(taskDir, "status.json");
+  const target = path13.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs16.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs16.renameSync(tmp, target);
+  fs15.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs15.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -3310,16 +3310,16 @@ var init_complexity = __esm({
 });
 // src/memory.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path15.join(projectDir, ".kody", "memory");
-  if (!fs17.existsSync(memoryDir)) return "";
-  const files = fs17.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path14.join(projectDir, ".kody", "memory");
+  if (!fs16.existsSync(memoryDir)) return "";
+  const files = fs16.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs17.readFileSync(path15.join(memoryDir, file), "utf-8").trim();
+    const content = fs16.readFileSync(path14.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -3338,8 +3338,8 @@ var init_memory = __esm({
 });
 // src/context-tiers.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path15 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -3430,7 +3430,7 @@ function generateL1Json(content) {
   }
 }
 function getTieredContent(filePath, content) {
-  const key = path16.basename(filePath);
+  const key = path15.basename(filePath);
   return {
     source: filePath,
     L0: generateL0(content, key),
@@ -3442,15 +3442,15 @@ function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path16.join(projectDir, ".kody", "memory");
-  if (!fs18.existsSync(memoryDir)) return "";
-  const files = fs18.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path15.join(projectDir, ".kody", "memory");
+  if (!fs17.existsSync(memoryDir)) return "";
+  const files = fs17.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const tierLabel2 = tier === "L2" ? "full" : tier === "L1" ? "overview" : "abstract";
   const sections = [];
   for (const file of files) {
-    const filePath = path16.join(memoryDir, file);
-    const content = fs18.readFileSync(filePath, "utf-8").trim();
+    const filePath = path15.join(memoryDir, file);
+    const content = fs17.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
     const tiered = getTieredContent(filePath, content);
     const selected = selectTier(tiered, tier);
@@ -3473,9 +3473,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path16.join(taskDir, "task.md");
-  if (fs18.existsSync(taskMdPath)) {
-    const content = fs18.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path15.join(taskDir, "task.md");
+  if (fs17.existsSync(taskMdPath)) {
+    const content = fs17.readFileSync(taskMdPath, "utf-8");
     const selected = selectContent(taskMdPath, content, policy.taskDescription);
     const label = tierLabel("Task Description", policy.taskDescription);
     context += `
@@ -3483,9 +3483,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 ${selected}
 `;
   }
-  const taskJsonPath = path16.join(taskDir, "task.json");
-  if (fs18.existsSync(taskJsonPath)) {
-    const content = fs18.readFileSync(taskJsonPath, "utf-8");
+  const taskJsonPath = path15.join(taskDir, "task.json");
+  if (fs17.existsSync(taskJsonPath)) {
+    const content = fs17.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -3511,9 +3511,9 @@ ${selected}
       }
     }
   }
-  const specPath = path16.join(taskDir, "spec.md");
-  if (fs18.existsSync(specPath)) {
-    const content = fs18.readFileSync(specPath, "utf-8");
+  const specPath = path15.join(taskDir, "spec.md");
+  if (fs17.existsSync(specPath)) {
+    const content = fs17.readFileSync(specPath, "utf-8");
     const selected = selectContent(specPath, content, policy.spec);
     const label = tierLabel("Spec", policy.spec);
     context += `
@@ -3521,9 +3521,9 @@ ${selected}
 ${selected}
 `;
   }
-  const planPath = path16.join(taskDir, "plan.md");
-  if (fs18.existsSync(planPath)) {
-    const content = fs18.readFileSync(planPath, "utf-8");
+  const planPath = path15.join(taskDir, "plan.md");
+  if (fs17.existsSync(planPath)) {
+    const content = fs17.readFileSync(planPath, "utf-8");
     const selected = selectContent(planPath, content, policy.plan);
     const label = tierLabel("Plan", policy.plan);
     context += `
@@ -3531,9 +3531,9 @@ ${selected}
 ${selected}
 `;
   }
-  const contextMdPath = path16.join(taskDir, "context.md");
-  if (fs18.existsSync(contextMdPath)) {
-    const content = fs18.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path15.join(taskDir, "context.md");
+  if (fs17.existsSync(contextMdPath)) {
+    const content = fs17.readFileSync(contextMdPath, "utf-8");
     const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
     const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
@@ -3618,117 +3618,25 @@ var init_context_tiers = __esm({
   }
 });
-// src/tools.ts
-import * as fs19 from "fs";
-import * as path17 from "path";
-import { execSync as execSync3 } from "child_process";
-import { parse as parseYaml } from "yaml";
-function loadToolDeclarations(projectDir) {
-  const toolsPath = path17.join(projectDir, ".kody", "tools.yml");
-  if (!fs19.existsSync(toolsPath)) return [];
-  try {
-    const raw = fs19.readFileSync(toolsPath, "utf-8");
-    const parsed = parseYaml(raw);
-    if (!parsed || typeof parsed !== "object") return [];
-    return Object.entries(parsed).map(([name, value]) => {
-      const v = value;
-      return {
-        name,
-        detect: Array.isArray(v.detect) ? v.detect : [],
-        stages: Array.isArray(v.stages) ? v.stages : [],
-        setup: typeof v.setup === "string" ? v.setup : "",
-        skill: typeof v.skill === "string" ? v.skill : ""
-      };
-    });
-  } catch (err) {
-    logger.warn(`Failed to parse .kody/tools.yml: ${err instanceof Error ? err.message : String(err)}`);
-    return [];
-  }
-}
-function resolveSkillContent(skillFilename, projectDir) {
-  if (!skillFilename) return "";
-  const projectSkill = path17.join(projectDir, ".kody", "skills", skillFilename);
-  if (fs19.existsSync(projectSkill)) {
-    return fs19.readFileSync(projectSkill, "utf-8");
-  }
-  const scriptDir = new URL(".", import.meta.url).pathname;
-  const candidates = [
-    path17.resolve(scriptDir, "..", "skills", skillFilename),
-    path17.resolve(scriptDir, "..", "..", "skills", skillFilename)
-  ];
-  for (const candidate of candidates) {
-    if (fs19.existsSync(candidate)) {
-      return fs19.readFileSync(candidate, "utf-8");
-    }
-  }
-  logger.warn(`Skill file not found: ${skillFilename}`);
-  return "";
-}
-function detectTools(declarations, projectDir) {
-  const resolved = [];
-  for (const decl of declarations) {
-    const detected = decl.detect.some((pattern) => fs19.existsSync(path17.join(projectDir, pattern)));
-    if (!detected) continue;
-    const skillContent = resolveSkillContent(decl.skill, projectDir);
-    resolved.push({
-      name: decl.name,
-      stages: decl.stages,
-      setup: decl.setup,
-      skillContent
-    });
-  }
-  return resolved;
-}
-function runToolSetup(tools, projectDir) {
-  for (const tool of tools) {
-    if (!tool.setup) continue;
-    try {
-      logger.info(`  Setting up ${tool.name}: ${tool.setup}`);
-      execSync3(tool.setup, { cwd: projectDir, timeout: 12e4, stdio: "pipe" });
-      logger.info(`  \u2713 ${tool.name} setup complete`);
-    } catch (err) {
-      logger.warn(`  \u26A0 ${tool.name} setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-}
-function getToolSkillsForStage(tools, stageName) {
-  const matched = tools.filter((t) => t.stages.includes(stageName) && t.skillContent);
-  if (matched.length === 0) return "";
-  const sections = matched.map((t) => `### ${t.name}
-${t.skillContent}`);
-  return `## Available Tools
-The following tools are installed and ready to use in this environment.
-${sections.join("\n\n")}`;
-}
-var init_tools = __esm({
-  "src/tools.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
 // src/context.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs18 from "fs";
+import * as path16 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path18.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs20.existsSync(stepFile)) {
-      return fs20.readFileSync(stepFile, "utf-8");
+    const stepFile = path16.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs18.existsSync(stepFile)) {
+      return fs18.readFileSync(stepFile, "utf-8");
     }
     console.warn(`  \u26A0 No step file at ${stepFile}, falling back to engine defaults. Run 'kody-engine-lite init --force' to generate step files.`);
   }
   const scriptDir = new URL(".", import.meta.url).pathname;
   const candidates = [
-    path18.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path18.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path16.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path16.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs20.existsSync(candidate)) {
-      return fs20.readFileSync(candidate, "utf-8");
+    if (fs18.existsSync(candidate)) {
+      return fs18.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -3740,18 +3648,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path18.join(taskDir, "task.md");
-  if (fs20.existsSync(taskMdPath)) {
-    const taskMd = fs20.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path16.join(taskDir, "task.md");
+  if (fs18.existsSync(taskMdPath)) {
+    const taskMd = fs18.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
-  const taskJsonPath = path18.join(taskDir, "task.json");
-  if (fs20.existsSync(taskJsonPath)) {
+  const taskJsonPath = path16.join(taskDir, "task.json");
+  if (fs18.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs20.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs18.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -3764,27 +3672,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path18.join(taskDir, "spec.md");
-  if (fs20.existsSync(specPath)) {
-    const spec = fs20.readFileSync(specPath, "utf-8");
+  const specPath = path16.join(taskDir, "spec.md");
+  if (fs18.existsSync(specPath)) {
+    const spec = fs18.readFileSync(specPath, "utf-8");
     const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
     context += `
 ## Spec Summary
 ${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
 `;
   }
-  const planPath = path18.join(taskDir, "plan.md");
-  if (fs20.existsSync(planPath)) {
-    const plan = fs20.readFileSync(planPath, "utf-8");
+  const planPath = path16.join(taskDir, "plan.md");
+  if (fs18.existsSync(planPath)) {
+    const plan = fs18.readFileSync(planPath, "utf-8");
     const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
     context += `
 ## Plan Summary
 ${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
 `;
   }
-  const contextMdPath = path18.join(taskDir, "context.md");
-  if (fs20.existsSync(contextMdPath)) {
-    const accumulated = fs20.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path16.join(taskDir, "context.md");
+  if (fs18.existsSync(contextMdPath)) {
+    const accumulated = fs18.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -3802,17 +3710,17 @@ ${feedback}
 }
 function inferHasUIFromScope(scope) {
   return scope.some((filePath) => {
-    const ext = path18.extname(filePath).toLowerCase();
+    const ext = path16.extname(filePath).toLowerCase();
     if (UI_EXTENSIONS.has(ext)) return true;
     const normalized = filePath.replace(/\\/g, "/");
     return UI_PATH_SEGMENTS.some((seg) => normalized.includes(seg));
   });
 }
 function taskHasUI(taskDir) {
-  const taskJsonPath = path18.join(taskDir, "task.json");
-  if (!fs20.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path16.join(taskDir, "task.json");
+  if (!fs18.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs20.readFileSync(taskJsonPath, "utf-8"));
+    const taskDef = JSON.parse(fs18.readFileSync(taskJsonPath, "utf-8"));
     const scope = Array.isArray(taskDef.scope) ? taskDef.scope : [];
     if (scope.length === 0) return true;
     return inferHasUIFromScope(scope);
@@ -3837,23 +3745,51 @@ function getBrowserToolGuidance(stageName, taskDir) {
 ### Dev Server Setup (REQUIRED before browsing)
 You MUST start the dev server before using any browser navigation tools:
 \`\`\`bash
-# Start the dev server in the background
-${devServer.command} &
-# Wait for it to be ready (look for "${devServer.readyPattern}" in output)
-sleep 5
+# Start the dev server in the background with output redirected to a log file
+nohup ${devServer.command} > /tmp/dev-server.log 2>&1 &
+DEV_PID=$!
+# Wait up to ${devServer.readyTimeout}s for the server to be ready
+for i in $(seq 1 ${devServer.readyTimeout}); do
+  if curl -s -o /dev/null -w "%{http_code}" ${devServer.url} 2>/dev/null | grep -qE "^[23]"; then
+    echo "Dev server is ready"
+    break
+  fi
+  if ! kill -0 $DEV_PID 2>/dev/null; then
+    echo "Dev server process died. Last 20 lines:"
+    tail -20 /tmp/dev-server.log
+    break
+  fi
+  sleep 1
+done
 \`\`\`
 The dev server URL is: ${devServer.url}
-After you are done browsing, kill the dev server: \`kill %1 2>/dev/null || true\`` : `
+If the dev server fails to start (e.g. DB connection issues), skip browser verification and proceed with code-only changes. Do NOT hang waiting for it.
+After you are done browsing, kill the dev server: \`kill $DEV_PID 2>/dev/null || true\`` : `
 ### Dev Server Setup (REQUIRED before browsing)
 You MUST start the project's dev server before using any browser navigation tools.
 Check package.json for the dev command (usually \`pnpm dev\` or \`npm run dev\`).
 \`\`\`bash
-# Start the dev server in the background
-pnpm dev &
-# Wait for it to be ready
-sleep 5
+# Start the dev server in the background with output redirected
+nohup pnpm dev > /tmp/dev-server.log 2>&1 &
+DEV_PID=$!
+# Wait up to 30s for the server to be ready
+for i in $(seq 1 30); do
+  if curl -s -o /dev/null -w "%{http_code}" http://localhost:3000 2>/dev/null | grep -qE "^[23]"; then
+    echo "Dev server is ready"
+    break
+  fi
+  if ! kill -0 $DEV_PID 2>/dev/null; then
+    echo "Dev server process died. Last 20 lines:"
+    tail -20 /tmp/dev-server.log
+    break
+  fi
+  sleep 1
+done
 \`\`\`
-After you are done browsing, kill the dev server: \`kill %1 2>/dev/null || true\``;
+If the dev server fails to start (e.g. DB connection issues), skip browser verification and proceed with code-only changes. Do NOT hang waiting for it.
+After you are done browsing, kill the dev server: \`kill $DEV_PID 2>/dev/null || true\``;
   if (stageName === "build" || stageName === "review-fix") {
     return `## Browser Visual Verification (MANDATORY for UI tasks)
@@ -3918,7 +3854,7 @@ ${devServerBlock}
 Use browser tools to navigate to pages and take snapshots to verify UI output.`;
 }
-function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback, tools) {
+function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
   const config = getProjectConfig();
   let assembled;
   if (config.contextTiers?.enabled) {
@@ -3934,18 +3870,12 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path18.join(projectDir, ".kody", "qa-guide.md");
-    if (fs20.existsSync(qaGuidePath)) {
-      const qaGuide = fs20.readFileSync(qaGuidePath, "utf-8").trim();
+    const qaGuidePath = path16.join(projectDir, ".kody", "qa-guide.md");
+    if (fs18.existsSync(qaGuidePath)) {
+      const qaGuide = fs18.readFileSync(qaGuidePath, "utf-8").trim();
       assembled = assembled + "\n\n" + qaGuide;
     }
   }
-  if (tools?.length) {
-    const toolSkills = getToolSkillsForStage(tools, stageName);
-    if (toolSkills) {
-      assembled = assembled + "\n\n" + toolSkills;
-    }
-  }
   return assembled;
 }
 function buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback) {
@@ -3985,7 +3915,6 @@ var init_context = __esm({
     init_config();
     init_context_tiers();
     init_mcp_config();
-    init_tools();
     MAX_TASK_CONTEXT_PLAN = 1500;
     MAX_TASK_CONTEXT_SPEC = 2e3;
     MAX_ACCUMULATED_CONTEXT = 4e3;
@@ -4035,8 +3964,8 @@ var init_runner_selection = __esm({
 });
 // src/stages/agent.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -4065,7 +3994,7 @@ async function executeAgentStage(ctx, def) {
     logger.info(`  [dry-run] skipping ${def.name}`);
     return { outcome: "completed", retries: 0 };
   }
-  const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback, ctx.tools);
+  const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
   let currentModelTier = def.modelTier;
   if (ctx.input.feedback && def.name === "build") {
     logger.info(`  feedback: ${ctx.input.feedback.slice(0, 200)}${ctx.input.feedback.length > 200 ? "..." : ""}`);
@@ -4123,27 +4052,27 @@ async function executeAgentStage(ctx, def) {
   }
   const result2 = lastResult;
   if (def.outputFile && result2.output) {
-    fs21.writeFileSync(path19.join(ctx.taskDir, def.outputFile), result2.output);
+    fs19.writeFileSync(path17.join(ctx.taskDir, def.outputFile), result2.output);
   }
   if (def.outputFile) {
-    const outputPath = path19.join(ctx.taskDir, def.outputFile);
-    if (!fs21.existsSync(outputPath)) {
-      const ext = path19.extname(def.outputFile);
-      const base = path19.basename(def.outputFile, ext);
-      const files = fs21.readdirSync(ctx.taskDir);
+    const outputPath = path17.join(ctx.taskDir, def.outputFile);
+    if (!fs19.existsSync(outputPath)) {
+      const ext = path17.extname(def.outputFile);
+      const base = path17.basename(def.outputFile, ext);
+      const files = fs19.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs21.renameSync(path19.join(ctx.taskDir, variant), outputPath);
+        fs19.renameSync(path17.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path19.join(ctx.taskDir, def.outputFile);
-    if (fs21.existsSync(outputPath)) {
-      const content = fs21.readFileSync(outputPath, "utf-8");
+    const outputPath = path17.join(ctx.taskDir, def.outputFile);
+    if (fs19.existsSync(outputPath)) {
+      const content = fs19.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -4157,7 +4086,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs21.writeFileSync(outputPath, retryResult.output);
+              fs19.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -4170,7 +4099,7 @@ async function executeAgentStage(ctx, def) {
                 risk_level: "low",
                 questions: []
               }, null, 2);
-              fs21.writeFileSync(outputPath, fallback);
+              fs19.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -4184,7 +4113,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path19.join(taskDir, "context.md");
+  const contextPath = path17.join(taskDir, "context.md");
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
   let summary;
   if (output && output.trim()) {
@@ -4197,7 +4126,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs21.appendFileSync(contextPath, entry);
+  fs19.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -4220,7 +4149,7 @@ var init_agent = __esm({
 });
 // src/verify-runner.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -4256,7 +4185,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync12(parts[0], parts.slice(1), {
+    const output = execFileSync11(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -4345,7 +4274,7 @@ var init_verify_runner = __esm({
 });
 // src/observer.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -4428,13 +4357,13 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync13("git", ["diff", "--name-only", "--cached"], {
+    const staged = execFileSync12("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const unstaged = execFileSync13("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync12("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -4477,8 +4406,8 @@ Error context:
 });
 // src/stages/gate.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -4521,7 +4450,7 @@ ${output}
 `);
     }
   }
-  fs22.writeFileSync(path20.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs20.writeFileSync(path18.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -4536,9 +4465,9 @@ var init_gate = __esm({
 });
 // src/stages/verify.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
-import { execFileSync as execFileSync14 } from "child_process";
+import * as fs21 from "fs";
+import * as path19 from "path";
+import { execFileSync as execFileSync13 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
@@ -4548,8 +4477,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path21.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs23.existsSync(verifyPath) ? fs23.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const verifyPath = path19.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs21.existsSync(verifyPath) ? fs21.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -4592,7 +4521,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync14(parts[0], parts.slice(1), {
+          execFileSync13(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -4645,8 +4574,8 @@ var init_verify = __esm({
 });
 // src/review-standalone.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -4670,8 +4599,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path22.join(input.projectDir, ".kody", "tasks", taskId);
-  fs24.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path20.join(input.projectDir, ".kody", "tasks", taskId);
+  fs22.mkdirSync(taskDir, { recursive: true });
   let diffInstruction = "";
   let filesChangedSection = "";
   if (input.baseBranch) {
@@ -4698,7 +4627,7 @@ ${fileList}`;
   const taskContent = `# ${input.prTitle}
 ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
-  fs24.writeFileSync(path22.join(taskDir, "task.md"), taskContent);
+  fs22.writeFileSync(path20.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -4720,10 +4649,10 @@ ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
       error: result2.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path22.join(taskDir, "review.md");
+  const reviewPath = path20.join(taskDir, "review.md");
   let reviewContent;
-  if (fs24.existsSync(reviewPath)) {
-    reviewContent = fs24.readFileSync(reviewPath, "utf-8");
+  if (fs22.existsSync(reviewPath)) {
+    reviewContent = fs22.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -4763,8 +4692,8 @@ var init_review_standalone = __esm({
 });
 // src/stages/review.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -4778,11 +4707,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path23.join(ctx.taskDir, "review.md");
-    if (!fs25.existsSync(reviewFile)) {
+    const reviewFile = path21.join(ctx.taskDir, "review.md");
+    if (!fs23.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs25.readFileSync(reviewFile, "utf-8");
+    const content = fs23.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -4811,15 +4740,15 @@ var init_review = __esm({
 });
 // src/stages/ship.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
-import { execFileSync as execFileSync15 } from "child_process";
+import * as fs24 from "fs";
+import * as path22 from "path";
+import { execFileSync as execFileSync14 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path24.join(ctx.taskDir, "task.json");
-  if (fs26.existsSync(taskJsonPath)) {
+  const taskJsonPath = path22.join(ctx.taskDir, "task.json");
+  if (fs24.existsSync(taskJsonPath)) {
     try {
-      const raw = fs26.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs24.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -4838,9 +4767,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path24.join(ctx.taskDir, "review.md");
-  if (fs26.existsSync(reviewPath)) {
-    const review = fs26.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path22.join(ctx.taskDir, "review.md");
+  if (fs24.existsSync(reviewPath)) {
+    const review = fs24.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -4857,14 +4786,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path24.join(ctx.taskDir, "verify.md");
-  if (fs26.existsSync(verifyPath)) {
-    const verify = fs26.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path22.join(ctx.taskDir, "verify.md");
+  if (fs24.existsSync(verifyPath)) {
+    const verify = fs24.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path24.join(ctx.taskDir, "plan.md");
-  if (fs26.existsSync(planPath)) {
-    const plan = fs26.readFileSync(planPath, "utf-8").trim();
+  const planPath = path22.join(ctx.taskDir, "plan.md");
+  if (fs24.existsSync(planPath)) {
+    const plan = fs24.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -4884,25 +4813,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path24.join(ctx.taskDir, "ship.md");
+  const shipPath = path22.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs26.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs24.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   if (ctx.input.local && !ctx.input.issueNumber) {
-    fs26.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs24.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
     const head = getCurrentBranch(ctx.projectDir);
     const base = getDefaultBranch(ctx.projectDir);
     try {
-      execFileSync15("git", ["add", ctx.taskDir], {
+      execFileSync14("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync15("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync14("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
@@ -4916,7 +4845,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync15("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync14("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -4937,28 +4866,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path24.join(ctx.taskDir, "task.json");
-    if (fs26.existsSync(taskJsonPath)) {
+    const taskJsonPath = path22.join(ctx.taskDir, "task.json");
+    if (fs24.existsSync(taskJsonPath)) {
       try {
-        const raw = fs26.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs24.readFileSync(taskJsonPath, "utf-8");
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         prefix = TYPE_PREFIX[task.task_type] ?? "chore";
       } catch {
       }
     }
-    const taskMdPath = path24.join(ctx.taskDir, "task.md");
-    if (fs26.existsSync(taskMdPath)) {
-      const content = fs26.readFileSync(taskMdPath, "utf-8");
+    const taskMdPath = path22.join(ctx.taskDir, "task.md");
+    if (fs24.existsSync(taskMdPath)) {
+      const content = fs24.readFileSync(taskMdPath, "utf-8");
       const heading = content.split("\n").find((l) => l.startsWith("# "));
       if (heading) {
         title = `${prefix}: ${heading.replace(/^#\s*/, "").trim()}`.slice(0, 72);
       }
     }
     if (title === "Update") {
-      if (fs26.existsSync(taskJsonPath)) {
+      if (fs24.existsSync(taskJsonPath)) {
         try {
-          const raw = fs26.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs24.readFileSync(taskJsonPath, "utf-8");
           const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
           const task = JSON.parse(cleaned);
           if (task.title) title = `${prefix}: ${task.title}`.slice(0, 72);
@@ -4981,7 +4910,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs26.writeFileSync(shipPath, `# Ship
+      fs24.writeFileSync(shipPath, `# Ship
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -5002,20 +4931,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs26.writeFileSync(shipPath, `# Ship
+        fs24.writeFileSync(shipPath, `# Ship
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs26.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs24.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
       }
     }
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     try {
-      fs26.writeFileSync(shipPath, `# Ship
+      fs24.writeFileSync(shipPath, `# Ship
 Failed: ${msg}
 `);
@@ -5064,15 +4993,15 @@ var init_executor_registry = __esm({
 });
 // src/pipeline/questions.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path25.join(ctx.taskDir, "task.json");
-      if (!fs27.existsSync(taskJsonPath)) return false;
-      const raw = fs27.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path23.join(ctx.taskDir, "task.json");
+      if (!fs25.existsSync(taskJsonPath)) return false;
+      const raw = fs25.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const taskJson = JSON.parse(cleaned);
       if (taskJson.questions && Array.isArray(taskJson.questions) && taskJson.questions.length > 0) {
@@ -5087,9 +5016,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path25.join(ctx.taskDir, "plan.md");
-      if (!fs27.existsSync(planPath)) return false;
-      const plan = fs27.readFileSync(planPath, "utf-8");
+      const planPath = path23.join(ctx.taskDir, "plan.md");
+      if (!fs25.existsSync(planPath)) return false;
+      const plan = fs25.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -5118,8 +5047,8 @@ var init_questions = __esm({
 });
 // src/pipeline/hooks.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "plan") setLifecycleLabel(ctx.input.issueNumber, "planning");
@@ -5160,9 +5089,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path26.join(ctx.taskDir, "task.json");
-    if (!fs28.existsSync(taskJsonPath)) return null;
-    const raw = fs28.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path24.join(ctx.taskDir, "task.json");
+    if (!fs26.existsSync(taskJsonPath)) return null;
+    const raw = fs26.readFileSync(taskJsonPath, "utf-8");
     const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const taskJson = JSON.parse(cleaned);
     if (!taskJson.risk_level || !isValidComplexity(taskJson.risk_level)) return null;
@@ -5192,8 +5121,8 @@ function checkRiskGate(ctx, def, state, complexity) {
   if (ctx.input.dryRun || ctx.input.local) return null;
   if (ctx.input.mode === "rerun") return null;
   if (!ctx.input.issueNumber) return null;
-  const planPath = path26.join(ctx.taskDir, "plan.md");
-  const plan = fs28.existsSync(planPath) ? fs28.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path24.join(ctx.taskDir, "plan.md");
+  const plan = fs26.existsSync(planPath) ? fs26.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -5260,22 +5189,22 @@ var init_hooks = __esm({
 });
 // src/learning/auto-learn.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path27.join(ctx.projectDir, ".kody", "memory");
-    if (!fs29.existsSync(memoryDir)) {
-      fs29.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path25.join(ctx.projectDir, ".kody", "memory");
+    if (!fs27.existsSync(memoryDir)) {
+      fs27.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path27.join(ctx.taskDir, "verify.md");
-    if (fs29.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs29.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path25.join(ctx.taskDir, "verify.md");
+    if (fs27.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs27.readFileSync(verifyPath, "utf-8"));
       if (/vitest/i.test(verify)) learnings.push("- Uses vitest for testing");
       if (/jest/i.test(verify)) learnings.push("- Uses jest for testing");
       if (/eslint/i.test(verify)) learnings.push("- Uses eslint for linting");
@@ -5284,18 +5213,18 @@ function autoLearn(ctx) {
       if (/jsdom/i.test(verify)) learnings.push("- Test environment: jsdom");
       if (/node/i.test(verify) && /environment/i.test(verify)) learnings.push("- Test environment: node");
     }
-    const reviewPath = path27.join(ctx.taskDir, "review.md");
-    if (fs29.existsSync(reviewPath)) {
-      const review = fs29.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path25.join(ctx.taskDir, "review.md");
+    if (fs27.existsSync(reviewPath)) {
+      const review = fs27.readFileSync(reviewPath, "utf-8");
       if (/\.js extension/i.test(review)) learnings.push("- Imports use .js extensions (ESM)");
       if (/barrel export/i.test(review)) learnings.push("- Uses barrel exports (index.ts)");
       if (/timezone/i.test(review)) learnings.push("- Timezone handling is a concern in this codebase");
       if (/UTC/i.test(review)) learnings.push("- Date operations should consider UTC vs local time");
     }
-    const taskJsonPath = path27.join(ctx.taskDir, "task.json");
-    if (fs29.existsSync(taskJsonPath)) {
+    const taskJsonPath = path25.join(ctx.taskDir, "task.json");
+    if (fs27.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs29.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs27.readFileSync(taskJsonPath, "utf-8"));
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         if (task.scope && Array.isArray(task.scope)) {
@@ -5306,12 +5235,12 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path27.join(memoryDir, "conventions.md");
+      const conventionsPath = path25.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs29.appendFileSync(conventionsPath, entry);
+      fs27.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -5319,8 +5248,8 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path27.join(memoryDir, "architecture.md");
-  if (fs29.existsSync(archPath)) return;
+  const archPath = path25.join(memoryDir, "architecture.md");
+  if (fs27.existsSync(archPath)) return;
   const detected = detectArchitectureBasic(projectDir);
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
@@ -5328,7 +5257,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs29.writeFileSync(archPath, content);
+    fs27.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -5341,13 +5270,13 @@ var init_auto_learn = __esm({
 });
 // src/retrospective.ts
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path28.join(taskDir, filename);
-  if (!fs30.existsSync(p)) return null;
+  const p = path26.join(taskDir, filename);
+  if (!fs28.existsSync(p)) return null;
   try {
-    const content = fs30.readFileSync(p, "utf-8");
+    const content = fs28.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -5400,13 +5329,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path28.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path26.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs30.existsSync(logPath)) return [];
+  if (!fs28.existsSync(logPath)) return [];
   try {
-    const content = fs30.readFileSync(logPath, "utf-8");
+    const content = fs28.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -5433,11 +5362,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path28.dirname(logPath);
-  if (!fs30.existsSync(dir)) {
-    fs30.mkdirSync(dir, { recursive: true });
+  const dir = path26.dirname(logPath);
+  if (!fs28.existsSync(dir)) {
+    fs28.mkdirSync(dir, { recursive: true });
   }
-  fs30.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs28.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -5604,9 +5533,75 @@ var init_summary = __esm({
   }
 });
+// src/tools.ts
+import * as fs29 from "fs";
+import * as path27 from "path";
+import { execSync as execSync3 } from "child_process";
+import { parse as parseYaml } from "yaml";
+function loadToolDeclarations(projectDir) {
+  const toolsPath = path27.join(projectDir, ".kody", "tools.yml");
+  if (!fs29.existsSync(toolsPath)) return [];
+  try {
+    const raw = fs29.readFileSync(toolsPath, "utf-8");
+    const parsed = parseYaml(raw);
+    if (!parsed || typeof parsed !== "object") return [];
+    return Object.entries(parsed).map(([name, value]) => {
+      const v = value;
+      return {
+        name,
+        detect: Array.isArray(v.detect) ? v.detect : [],
+        stages: Array.isArray(v.stages) ? v.stages : [],
+        setup: typeof v.setup === "string" ? v.setup : ""
+      };
+    });
+  } catch (err) {
+    logger.warn(`Failed to parse .kody/tools.yml: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+}
+function detectTools(declarations, projectDir) {
+  const resolved = [];
+  for (const decl of declarations) {
+    const detected = decl.detect.some((pattern) => fs29.existsSync(path27.join(projectDir, pattern)));
+    if (!detected) continue;
+    resolved.push({
+      name: decl.name,
+      stages: decl.stages,
+      setup: decl.setup
+    });
+  }
+  return resolved;
+}
+function runToolSetup(tools, projectDir) {
+  for (const tool of tools) {
+    if (tool.setup) {
+      try {
+        logger.info(`  Setting up ${tool.name}: ${tool.setup}`);
+        execSync3(tool.setup, { cwd: projectDir, timeout: 12e4, stdio: "pipe" });
+        logger.info(`  \u2713 ${tool.name} setup complete`);
+      } catch (err) {
+        logger.warn(`  \u26A0 ${tool.name} setup failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    try {
+      logger.info(`  Installing skill for ${tool.name} from skills.sh`);
+      execSync3(`npx skills add --skill ${tool.name} --yes`, { cwd: projectDir, timeout: 6e4, stdio: "pipe" });
+      logger.info(`  \u2713 ${tool.name} skill installed`);
+    } catch (err) {
+      logger.warn(`  \u26A0 ${tool.name} skill install failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+var init_tools = __esm({
+  "src/tools.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
 // src/pipeline.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -5619,8 +5614,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path29.join(ctx.taskDir, "task.md");
-    const title = fs31.existsSync(taskMdPath) ? fs31.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path28.join(ctx.taskDir, "task.md");
+    const title = fs30.existsSync(taskMdPath) ? fs30.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -5634,10 +5629,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path29.join(taskDir, ".lock");
-  if (fs31.existsSync(lockPath)) {
+  const lockPath = path28.join(taskDir, ".lock");
+  if (fs30.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs31.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs30.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -5654,14 +5649,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs31.unlinkSync(lockPath);
+      fs30.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs31.openSync(lockPath, fs31.constants.O_WRONLY | fs31.constants.O_CREAT | fs31.constants.O_EXCL);
-    fs31.writeSync(fd, String(process.pid));
-    fs31.closeSync(fd);
+    const fd = fs30.openSync(lockPath, fs30.constants.O_WRONLY | fs30.constants.O_CREAT | fs30.constants.O_EXCL);
+    fs30.writeSync(fd, String(process.pid));
+    fs30.closeSync(fd);
   } catch (err) {
     if (err.code === "EEXIST") {
       throw new Error("Pipeline already running (lock acquired by another process)");
@@ -5671,7 +5666,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs31.unlinkSync(path29.join(taskDir, ".lock"));
+    fs30.unlinkSync(path28.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -5885,8 +5880,8 @@ var init_pipeline = __esm({
 });
 // src/preflight.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs32 from "fs";
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs31 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -5898,7 +5893,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync16("claude", ["--version"], {
+      const v = execFileSync15("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5906,14 +5901,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync16("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync15("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync16("pnpm", ["--version"], {
+      const v = execFileSync15("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5921,7 +5916,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync16("node", ["--version"], {
+      const v = execFileSync15("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5931,7 +5926,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync16("gh", ["--version"], {
+      const v = execFileSync15("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5939,7 +5934,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs32.existsSync("package.json")) throw new Error("not found");
+      if (!fs31.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -6016,8 +6011,8 @@ var init_args = __esm({
 });
 // src/cli/task-state.ts
-import * as fs33 from "fs";
-import * as path30 from "path";
+import * as fs32 from "fs";
+import * as path29 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -6049,11 +6044,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path30.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path29.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs33.existsSync(statusPath)) {
+    if (fs32.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs33.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs32.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -6086,12 +6081,12 @@ var resolve_exports = {};
 __export(resolve_exports, {
   runResolve: () => runResolve
 });
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 function getConflictContext(cwd, files) {
   const parts = [];
   for (const file of files.slice(0, 10)) {
     try {
-      const content = execFileSync17("git", ["diff", file], {
+      const content = execFileSync16("git", ["diff", file], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -6210,8 +6205,8 @@ var init_resolve = __esm({
 // src/entry.ts
 var entry_exports = {};
-import * as fs34 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path30 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!anyStageNeedsProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
@@ -6266,9 +6261,9 @@ async function runModelHealthCheck(config) {
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path31.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path30.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs34.existsSync(projectDir)) {
+    if (!fs33.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -6328,8 +6323,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path31.join(projectDir, ".kody", "tasks", taskId);
-  fs34.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path30.join(projectDir, ".kody", "tasks", taskId);
+  fs33.mkdirSync(taskDir, { recursive: true });
   if (input.command === "rerun" && isTaskifyRun(taskDir)) {
     const marker = readTaskifyMarker(taskDir);
     if (marker) {
@@ -6461,31 +6456,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs34.writeFileSync(path31.join(taskDir, "task.md"), input.task);
+    fs33.writeFileSync(path30.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path31.join(taskDir, "task.md");
-  if (!fs34.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  const taskMdPath = path30.join(taskDir, "task.md");
+  if (!fs33.existsSync(taskMdPath) && isPRFix && input.prNumber) {
     logger.info(`Fetching PR #${input.prNumber} details as task context...`);
     const prDetails = getPRDetails(input.prNumber);
     if (prDetails) {
       const taskContent = `# ${prDetails.title}
 ${prDetails.body ?? ""}`;
-      fs34.writeFileSync(taskMdPath, taskContent);
+      fs33.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs34.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs33.existsSync(taskMdPath) && input.issueNumber) {
     logger.info(`Fetching issue #${input.issueNumber} body as task...`);
     const issue = getIssue(input.issueNumber);
     if (issue) {
       const taskContent = `# ${issue.title}
 ${issue.body ?? ""}`;
-      fs34.writeFileSync(taskMdPath, taskContent);
+      fs33.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs34.existsSync(taskMdPath)) {
+  if (!fs33.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -6629,7 +6624,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs34.readdirSync(taskDir);
+  const files = fs33.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -6695,8 +6690,8 @@ var init_entry = __esm({
 });
 // src/bin/cli.ts
-import * as fs35 from "fs";
-import * as path32 from "path";
+import * as fs34 from "fs";
+import * as path31 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // src/bin/commands/init.ts
@@ -7068,9 +7063,9 @@ function initCommand(opts, pkgRoot) {
 // src/bin/commands/bootstrap.ts
 init_architecture_detection();
-import * as fs9 from "fs";
-import * as path8 from "path";
-import { execFileSync as execFileSync5 } from "child_process";
+import * as fs8 from "fs";
+import * as path7 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
 // src/bin/qa-guide.ts
 import * as fs6 from "fs";
@@ -7580,100 +7575,6 @@ Required env vars: ${discovery.envVars.join(", ")}`);
   return result2;
 }
-// src/bin/skills.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
-import { execFileSync as execFileSync4 } from "child_process";
-var SKILL_MAPPINGS = [
-  {
-    detect: (deps) => "next" in deps,
-    skills: [
-      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
-    ]
-  },
-  {
-    detect: (deps) => "react" in deps && !("next" in deps),
-    skills: [
-      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
-    ]
-  },
-  {
-    detect: (deps) => FRONTEND_DEPS.some((d) => d in deps),
-    skills: [
-      { package: "microsoft/playwright-cli@playwright-cli", label: "Playwright browser automation" }
-    ]
-  }
-];
-function detectSkillsForProject(cwd) {
-  const pkgPath = path6.join(cwd, "package.json");
-  if (!fs7.existsSync(pkgPath)) return [];
-  try {
-    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const seen = /* @__PURE__ */ new Set();
-    const skills = [];
-    for (const mapping of SKILL_MAPPINGS) {
-      if (mapping.detect(allDeps)) {
-        for (const skill of mapping.skills) {
-          if (!seen.has(skill.package)) {
-            seen.add(skill.package);
-            skills.push(skill);
-          }
-        }
-      }
-    }
-    return skills;
-  } catch {
-    return [];
-  }
-}
-function installSkillsForProject(cwd) {
-  const skills = detectSkillsForProject(cwd);
-  if (skills.length === 0) {
-    console.log("  \u25CB No skills to install (no frontend framework detected)");
-    return [];
-  }
-  let installedSkills = {};
-  const lockPath = path6.join(cwd, "skills-lock.json");
-  if (fs7.existsSync(lockPath)) {
-    try {
-      const lock = JSON.parse(fs7.readFileSync(lockPath, "utf-8"));
-      installedSkills = lock.skills ?? {};
-    } catch {
-    }
-  }
-  const installedPaths = [];
-  for (const skill of skills) {
-    const skillName = skill.package.split("@").pop() ?? "";
-    if (skillName in installedSkills) {
-      console.log(`  \u25CB ${skill.label} \u2014 already installed`);
-      const agentPath = `.agents/skills/${skillName}`;
-      const claudePath = `.claude/skills/${skillName}`;
-      if (fs7.existsSync(path6.join(cwd, agentPath))) installedPaths.push(agentPath);
-      if (fs7.existsSync(path6.join(cwd, claudePath))) installedPaths.push(claudePath);
-      continue;
-    }
-    try {
-      console.log(`  Installing: ${skill.label} (${skill.package})`);
-      execFileSync4("npx", ["skills", "add", skill.package, "--yes"], {
-        cwd,
-        encoding: "utf-8",
-        timeout: 6e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const installedName = skill.package.split("@").pop() ?? "";
-      const agentPath = `.agents/skills/${installedName}`;
-      const claudePath = `.claude/skills/${installedName}`;
-      if (fs7.existsSync(path6.join(cwd, agentPath))) installedPaths.push(agentPath);
-      if (fs7.existsSync(path6.join(cwd, claudePath))) installedPaths.push(claudePath);
-      console.log(`  \u2713 ${skill.label}`);
-    } catch {
-      console.log(`  \u2717 ${skill.label} \u2014 failed to install`);
-    }
-  }
-  return installedPaths;
-}
 // src/bin/commands/bootstrap.ts
 init_config();
@@ -7703,20 +7604,20 @@ ${content}
 // src/bin/commands/bootstrap.ts
 var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path8.join(cwd, "src");
-  const baseDir = fs9.existsSync(srcDir) ? srcDir : cwd;
+  const srcDir = path7.join(cwd, "src");
+  const baseDir = fs8.existsSync(srcDir) ? srcDir : cwd;
   const results = [];
   function walk(dir) {
     const entries = [];
     try {
-      for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path8.join(dir, entry.name);
+        const full = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           entries.push(...walk(full));
         } else if (/\.(ts|js)$/.test(entry.name) && !/\.(test|spec|config|d)\.(ts|js)$/.test(entry.name)) {
           try {
-            const stat = fs9.statSync(full);
+            const stat = fs8.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -7730,8 +7631,8 @@ function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
   }
   const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
   for (const { filePath } of files) {
-    const rel = path8.relative(cwd, filePath);
-    const content = fs9.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    const rel = path7.relative(cwd, filePath);
+    const content = fs8.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
     results.push(`### File: ${rel}
 \`\`\`typescript
 ${content}
@@ -7743,9 +7644,9 @@ function ghComment(issueNumber, body, cwd) {
   try {
     let repoSlug = "";
     try {
-      const configPath = path8.join(cwd, "kody.config.json");
-      if (fs9.existsSync(configPath)) {
-        const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+      const configPath = path7.join(cwd, "kody.config.json");
+      if (fs8.existsSync(configPath)) {
+        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -7753,7 +7654,7 @@ function ghComment(issueNumber, body, cwd) {
     } catch {
     }
     if (!repoSlug) return;
-    execFileSync5("gh", [
+    execFileSync4("gh", [
       "issue",
       "comment",
       String(issueNumber),
@@ -7782,8 +7683,8 @@ function bootstrapCommand(opts, pkgRoot) {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path8.join(cwd, rel);
-    if (fs9.existsSync(p)) return fs9.readFileSync(p, "utf-8").slice(0, maxChars);
+    const p = path7.join(cwd, rel);
+    if (fs8.existsSync(p)) return fs8.readFileSync(p, "utf-8").slice(0, maxChars);
     return null;
   };
   let repoContext = "";
@@ -7818,14 +7719,14 @@ ${sampleFiles}
 `;
   try {
-    const topDirs = fs9.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs8.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     repoContext += `## Top-level directories
 ${topDirs.join(", ")}
 `;
-    const srcDir = path8.join(cwd, "src");
-    if (fs9.existsSync(srcDir)) {
-      const srcDirs = fs9.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path7.join(cwd, "src");
+    if (fs8.existsSync(srcDir)) {
+      const srcDirs = fs8.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) repoContext += `## src/ subdirectories
 ${srcDirs.join(", ")}
@@ -7835,19 +7736,19 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs9.existsSync(path8.join(cwd, f))) existingFiles.push(f);
+    if (fs8.existsSync(path7.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) repoContext += `## Config files present
 ${existingFiles.join(", ")}
 `;
   console.log("\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path8.join(cwd, ".kody", "memory");
-  fs9.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path8.join(memoryDir, "architecture.md");
-  const conventionsPath = path8.join(memoryDir, "conventions.md");
-  const existingArch = fs9.existsSync(archPath) ? fs9.readFileSync(archPath, "utf-8") : "";
-  const existingConv = fs9.existsSync(conventionsPath) ? fs9.readFileSync(conventionsPath, "utf-8") : "";
+  const memoryDir = path7.join(cwd, ".kody", "memory");
+  fs8.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path7.join(memoryDir, "architecture.md");
+  const conventionsPath = path7.join(memoryDir, "conventions.md");
+  const existingArch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
+  const existingConv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
   const hasExisting = !!(existingArch || existingConv);
   const extendInstruction = hasExisting && !opts.force ? buildExtendInstruction(
     `### architecture.md:
@@ -7882,7 +7783,7 @@ Output ONLY valid JSON. No markdown fences. No explanation.
 ${repoContext}`;
   console.log("  \u23F3 Analyzing project...");
   try {
-    const output = execFileSync5("claude", [
+    const output = execFileSync4("claude", [
       "--print",
       "--model",
       bootstrapModel,
@@ -7897,12 +7798,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs9.writeFileSync(archPath, parsed.architecture);
+      fs8.writeFileSync(archPath, parsed.architecture);
       const lineCount = parsed.architecture.split("\n").length;
       console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines)`);
     }
     if (parsed.conventions) {
-      fs9.writeFileSync(conventionsPath, parsed.conventions);
+      fs8.writeFileSync(conventionsPath, parsed.conventions);
       const lineCount = parsed.conventions.split("\n").length;
       console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines)`);
     }
@@ -7911,37 +7812,37 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs9.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs8.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 ## Overview
 ${detected.join("\n")}
 `);
       console.log(`  \u2713 .kody/memory/architecture.md (${detected.length} items, basic detection)`);
     }
-    fs9.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs8.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
   console.log("\n\u2500\u2500 Step Files \u2500\u2500");
-  const stepsDir = path8.join(cwd, ".kody", "steps");
-  fs9.mkdirSync(stepsDir, { recursive: true });
-  const arch = fs9.existsSync(archPath) ? fs9.readFileSync(archPath, "utf-8") : "";
-  const conv = fs9.existsSync(conventionsPath) ? fs9.readFileSync(conventionsPath, "utf-8") : "";
+  const stepsDir = path7.join(cwd, ".kody", "steps");
+  fs8.mkdirSync(stepsDir, { recursive: true });
+  const arch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
+  const conv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
   console.log("  \u23F3 Customizing step files...");
   let stepCount = 0;
   for (const stage of STEP_STAGES) {
-    const templatePath = path8.join(pkgRoot, "prompts", `${stage}.md`);
-    if (!fs9.existsSync(templatePath)) {
+    const templatePath = path7.join(pkgRoot, "prompts", `${stage}.md`);
+    if (!fs8.existsSync(templatePath)) {
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
-    const stepOutputPath = path8.join(stepsDir, `${stage}.md`);
-    const existingStep = fs9.existsSync(stepOutputPath) ? fs9.readFileSync(stepOutputPath, "utf-8") : "";
+    const stepOutputPath = path7.join(stepsDir, `${stage}.md`);
+    const existingStep = fs8.existsSync(stepOutputPath) ? fs8.readFileSync(stepOutputPath, "utf-8") : "";
     const isExtend = !!existingStep && !opts.force;
-    const defaultPrompt = fs9.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs8.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs9.copyFileSync(templatePath, stepOutputPath);
+      fs8.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -7984,7 +7885,7 @@ ${repoContext}
 REMINDER: Output the full prompt template first (unchanged), then your three appended sections. Do NOT include "${contextPlaceholder}".`;
     try {
-      const output = execFileSync5("claude", [
+      const output = execFileSync4("claude", [
         "--print",
         "--model",
         bootstrapModel,
@@ -7999,13 +7900,13 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       let cleaned = output.replace(/^```(?:markdown|md)?\s*\n?/, "").replace(/\n?```\s*$/, "");
       cleaned = cleaned.replace(/\n*\{\{TASK_CONTEXT\}\}\s*$/, "").trimEnd();
       const finalPrompt = cleaned + "\n\n" + afterPlaceholder;
-      fs9.writeFileSync(stepOutputPath, finalPrompt);
+      fs8.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md (${isExtend ? "extended" : "generated"})`);
     } catch {
       if (!isExtend) {
         console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-        fs9.copyFileSync(templatePath, stepOutputPath);
+        fs8.copyFileSync(templatePath, stepOutputPath);
         stepCount++;
       } else {
         console.log(`  \u26A0 ${stage}.md \u2014 extend failed, keeping existing`);
@@ -8014,11 +7915,11 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   }
   console.log(`  \u2713 Generated ${stepCount} step files in .kody/steps/`);
   console.log("\n\u2500\u2500 QA Guide \u2500\u2500");
-  const qaGuidePath = path8.join(cwd, ".kody", "qa-guide.md");
+  const qaGuidePath = path7.join(cwd, ".kody", "qa-guide.md");
   const discovery = discoverQaContext(cwd);
   const hasRoutes = discovery.routes.length > 0 || discovery.collections.length > 0;
   if (hasRoutes) {
-    const existingQaGuide = fs9.existsSync(qaGuidePath) ? fs9.readFileSync(qaGuidePath, "utf-8") : "";
+    const existingQaGuide = fs8.existsSync(qaGuidePath) ? fs8.readFileSync(qaGuidePath, "utf-8") : "";
     const isQaExtend = !!existingQaGuide && !opts.force;
     const serializedDiscovery = serializeDiscoveryForLLM(discovery);
     const qaExtendBlock = isQaExtend ? buildExtendInstruction(existingQaGuide, "QA guide") : "";
@@ -8087,7 +7988,7 @@ Command and URL.
 - Output ONLY the markdown. No explanation before or after.`;
     console.log("  \u23F3 Generating QA guide...");
     try {
-      const output = execFileSync5("claude", [
+      const output = execFileSync4("claude", [
         "--print",
         "--model",
         bootstrapModel,
@@ -8100,12 +8001,12 @@ Command and URL.
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
       const cleaned = output.replace(/^```(?:markdown|md)?\s*\n?/, "").replace(/\n?```\s*$/, "");
-      fs9.writeFileSync(qaGuidePath, cleaned);
+      fs8.writeFileSync(qaGuidePath, cleaned);
       console.log(`  \u2713 .kody/qa-guide.md (${isQaExtend ? "extended" : "generated"}, ${discovery.routes.length} routes, ${discovery.collections.length} collections)`);
     } catch {
       console.log("  \u26A0 LLM QA generation failed \u2014 using template fallback");
       const qaGuide = generateQaGuideFallback(discovery);
-      fs9.writeFileSync(qaGuidePath, qaGuide);
+      fs8.writeFileSync(qaGuidePath, qaGuide);
       console.log(`  \u2713 .kody/qa-guide.md (fallback, ${discovery.routes.length} routes)`);
     }
     if (discovery.loginPage) console.log(`  \u2713 Login page detected: ${discovery.loginPage}`);
@@ -8120,9 +8021,9 @@ Command and URL.
   try {
     let repoSlug = "";
     try {
-      const configPath = path8.join(cwd, "kody.config.json");
-      if (fs9.existsSync(configPath)) {
-        const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+      const configPath = path7.join(cwd, "kody.config.json");
+      if (fs8.existsSync(configPath)) {
+        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -8152,7 +8053,7 @@ Command and URL.
       ];
       for (const label of labels) {
         try {
-          execFileSync5("gh", [
+          execFileSync4("gh", [
             "label",
             "create",
             label.name,
@@ -8172,7 +8073,7 @@ Command and URL.
           console.log(`  \u2713 ${label.name}`);
         } catch {
           try {
-            execFileSync5("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+            execFileSync4("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
               cwd,
               encoding: "utf-8",
               timeout: 1e4,
@@ -8191,47 +8092,40 @@ Command and URL.
     console.log("  \u25CB Label creation skipped");
   }
   console.log("\n\u2500\u2500 Tools \u2500\u2500");
-  const toolsYmlPath = path8.join(cwd, ".kody", "tools.yml");
-  if (!fs9.existsSync(toolsYmlPath) || opts.force) {
+  const toolsYmlPath = path7.join(cwd, ".kody", "tools.yml");
+  if (!fs8.existsSync(toolsYmlPath) || opts.force) {
     const toolsTemplate = `# Kody Tools Configuration
 # Uncomment and configure tools that your project uses.
-# The engine will detect, install, and inject tool skills into pipeline stages.
+# The engine detects tools, runs setup commands, and installs matching skills from skills.sh.
 #
 # playwright:
 #   detect: ["playwright.config.ts", "playwright.config.js"]
 #   stages: [verify]
 #   setup: "npx playwright install --with-deps chromium"
-#   skill: playwright-cli.md
 `;
-    fs9.writeFileSync(toolsYmlPath, toolsTemplate);
+    fs8.writeFileSync(toolsYmlPath, toolsTemplate);
     console.log("  \u2713 .kody/tools.yml (template created)");
   } else {
     console.log("  \u25CB .kody/tools.yml (already exists, keeping)");
   }
-  console.log("\n\u2500\u2500 Skills \u2500\u2500");
-  const installedSkillPaths = installSkillsForProject(cwd);
   console.log("\n\u2500\u2500 Git \u2500\u2500");
   const filesToCommit = [
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md",
     ".kody/qa-guide.md",
-    ".kody/tools.yml",
-    ...installedSkillPaths
-  ].filter((f) => fs9.existsSync(path8.join(cwd, f)));
-  if (fs9.existsSync(path8.join(cwd, "skills-lock.json"))) {
-    filesToCommit.push("skills-lock.json");
-  }
+    ".kody/tools.yml"
+  ].filter((f) => fs8.existsSync(path7.join(cwd, f)));
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs9.existsSync(path8.join(cwd, stepFile))) {
+    if (fs8.existsSync(path7.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path8.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path7.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
-        execFileSync5("npx", ["prettier", "--write", ...fullPaths], {
+        execFileSync4("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
           encoding: "utf-8",
           timeout: 3e4,
@@ -8247,24 +8141,24 @@ Command and URL.
     try {
       if (isCI3) {
         const branchName = `kody-bootstrap-${Date.now()}`;
-        execFileSync5("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
-        execFileSync5("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync5("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync4("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
+        execFileSync4("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync4("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync5("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
-          execFileSync5("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync4("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync4("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path8.join(cwd, "kody.config.json");
-            if (fs9.existsSync(configPath)) {
-              const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+            const configPath = path7.join(cwd, "kody.config.json");
+            if (fs8.existsSync(configPath)) {
+              const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
               baseBranch = config.git?.defaultBranch ?? "main";
             }
           } catch {
           }
           try {
-            const prUrl = execFileSync5("gh", [
+            const prUrl = execFileSync4("gh", [
               "pr",
               "create",
               "--title",
@@ -8303,13 +8197,13 @@ Create it manually.`, cwd);
           console.log("  \u25CB No new changes to commit");
         }
       } else {
-        execFileSync5("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync5("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync4("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync4("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync5("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync4("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
           console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
           try {
-            execFileSync5("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+            execFileSync4("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
             console.log("  \u2713 Pushed to origin");
           } catch {
             console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -8332,11 +8226,11 @@ Create it manually.`, cwd);
 // src/bin/cli.ts
 init_architecture_detection();
-var __dirname2 = path32.dirname(fileURLToPath2(import.meta.url));
-var PKG_ROOT = path32.resolve(__dirname2, "..", "..");
+var __dirname2 = path31.dirname(fileURLToPath2(import.meta.url));
+var PKG_ROOT = path31.resolve(__dirname2, "..", "..");
 function getVersion() {
-  const pkgPath = path32.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path31.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 var args = process.argv.slice(2);
@@ -8364,6 +8258,5 @@ export {
   checkGhRepoAccess,
   checkGhSecret,
   detectArchitectureBasic,
-  detectBasicConfig,
-  detectSkillsForProject
+  detectBasicConfig
 };