@kody-ade/kody-engine-lite 0.1.146 → 0.1.148

package/dist/bin/cli.js

@@ -254,7 +254,12 @@ function getProjectConfig() {
           enabled: raw.mcp.enabled ?? !!raw.mcp.devServer
         } : void 0,
         // Top-level devServer takes precedence; fall back to mcp.devServer for backward compat
-        devServer: raw.devServer ?? raw.mcp?.devServer ?? void 0
+        devServer: raw.devServer ?? raw.mcp?.devServer ?? void 0,
+        watch: raw.watch ? {
+          enabled: raw.watch.enabled ?? false,
+          digestIssue: raw.watch.digestIssue,
+          model: raw.watch.model
+        } : void 0
       };
     } catch {
       logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
@@ -1193,13 +1198,11 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
   const child = spawn3(cmd, args2, {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
-    env: {
-      ...process.env,
-      ...dotenvVars,
-      // Remove DATABASE_URL so LiteLLM doesn't try to set up Prisma DB
-      // (DATABASE_URL may be set for the project's dev server, not for LiteLLM)
-      DATABASE_URL: ""
-    }
+    env: (() => {
+      const env = { ...process.env, ...dotenvVars };
+      delete env.DATABASE_URL;
+      return env;
+    })()
   });
   let proxyStderr = "";
   child.stderr?.on("data", (chunk) => {
@@ -3289,9 +3292,92 @@ var init_logger2 = __esm({
   }
 });
 
+// src/watch/agents/prompt-builder.ts
+function buildWatchAgentPrompt(agent, ctx) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const preamble = `You are a Kody Watch agent monitoring the GitHub repository **${ctx.repo}**.
+Your role is described below. Use the tools available to you to inspect the repository and take action.
+
+## Environment
+- Repository: ${ctx.repo}
+- Current date: ${now}
+- Watch cycle: #${ctx.cycleNumber}
+${ctx.digestIssue ? `- Digest issue: #${ctx.digestIssue}` : ""}
+
+## Tools
+Use \`gh\` CLI (via Bash) for all GitHub operations. Examples:
+- \`gh pr list --repo ${ctx.repo} --state open --json number,title,author,updatedAt,labels,createdAt\`
+- \`gh pr view 123 --repo ${ctx.repo} --json number,title,body,author,commits,files,comments,reviews,updatedAt\`
+- \`gh issue list --repo ${ctx.repo} --state open --json number,title,labels,updatedAt\`
+- \`gh issue create --repo ${ctx.repo} --title "..." --body "..." --label "kody:watch"\`
+- \`gh api repos/${ctx.repo}/actions/runs --jq '.workflow_runs[:10]'\`
+
+Use Read/Glob/Grep for inspecting repository files.
+
+## Guidelines
+- **Check before creating**: Always search for existing open issues with similar titles before creating new ones to avoid duplicates.
+- **Label issues**: Prefix all created issue labels with \`kody:watch:\` (e.g. \`kody:watch:stale-pr\`).
+- **Be concise**: Issue bodies should contain evidence and a suggested action, not lengthy explanations.
+- **Stay focused**: Only act on what your instructions below describe. Do not perform unrelated analysis.`;
+  const agentInstructions = `## Your Instructions
+
+${agent.systemPrompt}`;
+  return `${preamble}
+
+${agentInstructions}`;
+}
+var init_prompt_builder = __esm({
+  "src/watch/agents/prompt-builder.ts"() {
+    "use strict";
+  }
+});
+
+// src/watch/agents/run-agent.ts
+async function runWatchAgent(agent, ctx, options) {
+  const { model, provider, projectDir, timeoutMs = AGENT_TIMEOUT_MS } = options;
+  const prompt = buildWatchAgentPrompt(agent, {
+    repo: ctx.repo,
+    cycleNumber: ctx.cycleNumber,
+    digestIssue: ctx.digestIssue
+  });
+  const runner = createClaudeCodeRunner();
+  const extraEnv = {};
+  const stageConfig = { provider: provider ?? "claude", model };
+  if (stageNeedsProxy(stageConfig)) {
+    extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
+  }
+  const result2 = await runner.run(
+    `watch:${agent.config.name}`,
+    prompt,
+    model,
+    timeoutMs,
+    projectDir,
+    {
+      cwd: projectDir,
+      env: extraEnv
+    }
+  );
+  return {
+    agentName: agent.config.name,
+    outcome: result2.outcome,
+    output: result2.output,
+    error: result2.error
+  };
+}
+var AGENT_TIMEOUT_MS;
+var init_run_agent = __esm({
+  "src/watch/agents/run-agent.ts"() {
+    "use strict";
+    init_agent_runner();
+    init_config();
+    init_prompt_builder();
+    AGENT_TIMEOUT_MS = 2 * 60 * 1e3;
+  }
+});
+
 // src/watch/core/watch.ts
 async function runWatch(config) {
-  const { repo, dryRun, stateFile, plugins } = config;
+  const { repo, dryRun, stateFile, plugins, agents } = config;
   const token = process.env.GH_TOKEN || "";
   const github = createGitHubClient(repo, token);
   const state = createStateStore(stateFile, github, config.digestIssue);
@@ -3372,6 +3458,45 @@ async function runWatch(config) {
   } else {
     log2.info({ actionCount: dedupedActions.length }, "Dry run \u2014 skipping action execution");
   }
+  const scheduledAgents = agents.filter((agent) => {
+    return cycleNumber % agent.config.schedule.every === 0;
+  });
+  const agentResults = [];
+  if (scheduledAgents.length > 0 && !dryRun) {
+    log2.info(
+      { agentsTotal: agents.length, agentsScheduled: scheduledAgents.length },
+      "Running watch agents"
+    );
+    const provider = config.provider;
+    for (const agent of scheduledAgents) {
+      try {
+        log2.info({ agent: agent.config.name }, "Running watch agent");
+        const result3 = await runWatchAgent(agent, ctx, {
+          model: config.model,
+          provider,
+          projectDir: config.projectDir
+        });
+        agentResults.push(result3);
+        if (result3.outcome === "completed") {
+          log2.info({ agent: agent.config.name }, "Watch agent completed");
+        } else {
+          const errMsg = `Agent ${agent.config.name}: ${result3.outcome}${result3.error ? ` \u2014 ${result3.error}` : ""}`;
+          errors.push(errMsg);
+          log2.warn({ agent: agent.config.name, outcome: result3.outcome }, "Watch agent did not complete");
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`Agent ${agent.config.name}: ${message}`);
+        log2.error({ agent: agent.config.name, error: message }, "Watch agent failed");
+        agentResults.push({ agentName: agent.config.name, outcome: "failed", error: message });
+      }
+    }
+  } else if (scheduledAgents.length > 0 && dryRun) {
+    log2.info(
+      { agentCount: scheduledAgents.length },
+      "Dry run \u2014 skipping watch agent execution"
+    );
+  }
   state.save();
   const result2 = {
     cycleNumber,
@@ -3379,6 +3504,8 @@ async function runWatch(config) {
     actionsProduced: allActions.length,
     actionsExecuted,
     actionsDeduplicated,
+    agentsRun: scheduledAgents.length,
+    agentResults,
     errors
   };
   log2.info(
@@ -3388,6 +3515,7 @@ async function runWatch(config) {
       actionsProduced: result2.actionsProduced,
       actionsExecuted: result2.actionsExecuted,
       actionsDeduplicated: result2.actionsDeduplicated,
+      agentsRun: result2.agentsRun,
       errors: result2.errors.length
     },
     "Watch cycle completed"
@@ -3401,6 +3529,7 @@ var init_watch = __esm({
     init_dedup();
     init_github();
     init_logger2();
+    init_run_agent();
   }
 });
 
@@ -4111,27 +4240,134 @@ var init_config_health = __esm({
   }
 });
 
+// src/watch/agents/loader.ts
+import * as fs19 from "fs";
+import * as path17 from "path";
+function validateAgentConfig(raw, dirName) {
+  if (!raw || typeof raw !== "object") {
+    return `${dirName}: agent.json must be a JSON object`;
+  }
+  const obj = raw;
+  if (typeof obj.name !== "string" || !obj.name.trim()) {
+    return `${dirName}: agent.json missing required "name" (string)`;
+  }
+  if (typeof obj.description !== "string" || !obj.description.trim()) {
+    return `${dirName}: agent.json missing required "description" (string)`;
+  }
+  let every = 1;
+  if (obj.schedule && typeof obj.schedule === "object") {
+    const sched = obj.schedule;
+    if (sched.every !== void 0) {
+      if (typeof sched.every !== "number" || sched.every < 1 || !Number.isInteger(sched.every)) {
+        return `${dirName}: schedule.every must be an integer >= 1`;
+      }
+      every = sched.every;
+    }
+  }
+  return {
+    name: obj.name.trim(),
+    description: obj.description.trim(),
+    schedule: { every }
+  };
+}
+function loadWatchAgents(projectDir) {
+  const agentsDir = path17.join(projectDir, AGENTS_DIR);
+  const warnings = [];
+  const agents = [];
+  if (!fs19.existsSync(agentsDir)) {
+    return { agents, warnings };
+  }
+  let entries;
+  try {
+    entries = fs19.readdirSync(agentsDir, { withFileTypes: true });
+  } catch {
+    warnings.push(`Cannot read ${AGENTS_DIR}`);
+    return { agents, warnings };
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dirPath = path17.join(agentsDir, entry.name);
+    const jsonPath = path17.join(dirPath, "agent.json");
+    const mdPath = path17.join(dirPath, "agent.md");
+    if (!fs19.existsSync(jsonPath)) {
+      warnings.push(`${entry.name}: missing agent.json \u2014 skipped`);
+      continue;
+    }
+    if (!fs19.existsSync(mdPath)) {
+      warnings.push(`${entry.name}: missing agent.md \u2014 skipped`);
+      continue;
+    }
+    let rawJson;
+    try {
+      rawJson = JSON.parse(fs19.readFileSync(jsonPath, "utf-8"));
+    } catch {
+      warnings.push(`${entry.name}: agent.json is invalid JSON \u2014 skipped`);
+      continue;
+    }
+    const configOrError = validateAgentConfig(rawJson, entry.name);
+    if (typeof configOrError === "string") {
+      warnings.push(`${configOrError} \u2014 skipped`);
+      continue;
+    }
+    const systemPrompt = fs19.readFileSync(mdPath, "utf-8").trim();
+    if (!systemPrompt) {
+      warnings.push(`${entry.name}: agent.md is empty \u2014 skipped`);
+      continue;
+    }
+    agents.push({
+      config: configOrError,
+      systemPrompt,
+      dirPath
+    });
+  }
+  return { agents, warnings };
+}
+var AGENTS_DIR;
+var init_loader = __esm({
+  "src/watch/agents/loader.ts"() {
+    "use strict";
+    AGENTS_DIR = ".kody/watch/agents";
+  }
+});
+
 // src/watch/index.ts
 var watch_exports = {};
 __export(watch_exports, {
   runWatchCommand: () => runWatchCommand
 });
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 async function runWatchCommand(opts) {
   const cwd = process.cwd();
-  const configPath = path17.join(cwd, "kody.config.json");
+  let litellmProcess = null;
+  const configPath = path18.join(cwd, "kody.config.json");
   let repo = process.env.REPO || "";
   let digestIssue;
-  if (!repo && fs19.existsSync(configPath)) {
+  let watchModel;
+  let agentProvider;
+  let agentModelMap;
+  let defaultCheapModel = "claude-haiku-4-5-20251001";
+  if (!repo && fs20.existsSync(configPath)) {
     try {
-      const config2 = JSON.parse(fs19.readFileSync(configPath, "utf-8"));
+      const config2 = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
       if (config2.github?.owner && config2.github?.repo) {
         repo = `${config2.github.owner}/${config2.github.repo}`;
       }
       if (config2.watch?.digestIssue) {
         digestIssue = config2.watch.digestIssue;
       }
+      if (config2.watch?.model) {
+        watchModel = config2.watch.model;
+      }
+      if (config2.agent?.provider) {
+        agentProvider = config2.agent.provider;
+      }
+      if (config2.agent?.modelMap) {
+        agentModelMap = config2.agent.modelMap;
+      }
+      if (config2.agent?.modelMap?.cheap) {
+        defaultCheapModel = config2.agent.modelMap.cheap;
+      }
     } catch {
     }
   }
@@ -4150,12 +4386,43 @@ async function runWatchCommand(opts) {
   registry.register(pipelineHealthPlugin);
   registry.register(securityScanPlugin);
   registry.register(configHealthPlugin);
+  const { agents, warnings } = loadWatchAgents(cwd);
+  for (const w of warnings) {
+    console.warn(`  Agent warning: ${w}`);
+  }
+  const model = watchModel ?? defaultCheapModel;
+  const needsProxy = agentProvider && agentProvider !== "claude" && agentProvider !== "anthropic";
+  if (agents.length > 0) {
+    console.log(`  Found ${agents.length} watch agent(s): ${agents.map((a) => a.config.name).join(", ")}`);
+    console.log(`  Model: ${model}${agentProvider ? ` (provider: ${agentProvider})` : ""}`);
+    if (needsProxy && !opts.dryRun) {
+      const litellmUrl = LITELLM_DEFAULT_URL;
+      const isHealthy = await checkLitellmHealth(litellmUrl);
+      if (!isHealthy) {
+        const proxyModelMap = { ...agentModelMap, watch: model };
+        const generatedConfig = generateLitellmConfig(agentProvider, proxyModelMap);
+        console.log(`  Starting LiteLLM proxy for ${agentProvider}...`);
+        litellmProcess = await tryStartLitellm(litellmUrl, cwd, generatedConfig);
+        if (litellmProcess) {
+          console.log(`  LiteLLM proxy started`);
+        } else {
+          console.warn(`  LiteLLM proxy failed to start \u2014 agents using ${agentProvider} may fail`);
+        }
+      } else {
+        console.log(`  LiteLLM proxy already running`);
+      }
+    }
+  }
   const config = {
     repo,
     dryRun: opts.dryRun,
-    stateFile: path17.join(cwd, ".kody", "watch-state.json"),
+    stateFile: path18.join(cwd, ".kody", "watch-state.json"),
     plugins: registry.getAll(),
-    digestIssue
+    digestIssue,
+    agents,
+    model,
+    provider: agentProvider,
+    projectDir: cwd
   };
   console.log(`
 Kody Watch \u2014 repo: ${repo}, dry-run: ${opts.dryRun}
@@ -4167,13 +4434,17 @@ Kody Watch \u2014 repo: ${repo}, dry-run: ${opts.dryRun}
         console.warn(`  Warning: ${error}`);
       }
     }
+    const agentSummary = result2.agentsRun > 0 ? `, ${result2.agentsRun} agents` : "";
     console.log(`
-Cycle #${result2.cycleNumber} complete: ${result2.pluginsRun} plugins, ${result2.actionsExecuted} actions, ${result2.actionsDeduplicated} deduplicated`);
-    process.exit(0);
+Cycle #${result2.cycleNumber} complete: ${result2.pluginsRun} plugins${agentSummary}, ${result2.actionsExecuted} actions, ${result2.actionsDeduplicated} deduplicated`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`Watch failed: ${message}`);
-    process.exit(1);
+  } finally {
+    if (litellmProcess) {
+      litellmProcess.kill("SIGTERM");
+    }
+    process.exit(0);
   }
 }
 var init_watch2 = __esm({
@@ -4184,6 +4455,9 @@ var init_watch2 = __esm({
     init_pipeline_health();
     init_security_scan();
     init_config_health();
+    init_loader();
+    init_litellm();
+    init_config();
   }
 });
 
@@ -4462,14 +4736,14 @@ var init_git_utils = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 function loadState(taskId, taskDir) {
-  const p = path18.join(taskDir, "status.json");
-  if (!fs20.existsSync(p)) return null;
+  const p = path19.join(taskDir, "status.json");
+  if (!fs21.existsSync(p)) return null;
   try {
     const result2 = parseJsonSafe(
-      fs20.readFileSync(p, "utf-8"),
+      fs21.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
     if (!result2.ok) {
@@ -4487,10 +4761,10 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path18.join(taskDir, "status.json");
+  const target = path19.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs20.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs20.renameSync(tmp, target);
+  fs21.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs21.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -4531,16 +4805,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path19.join(projectDir, ".kody", "memory");
-  if (!fs21.existsSync(memoryDir)) return "";
-  const files = fs21.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path20.join(projectDir, ".kody", "memory");
+  if (!fs22.existsSync(memoryDir)) return "";
+  const files = fs22.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs21.readFileSync(path19.join(memoryDir, file), "utf-8").trim();
+    const content = fs22.readFileSync(path20.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -4559,8 +4833,8 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -4651,7 +4925,7 @@ function generateL1Json(content) {
   }
 }
 function getTieredContent(filePath, content) {
-  const key = path20.basename(filePath);
+  const key = path21.basename(filePath);
   return {
     source: filePath,
     L0: generateL0(content, key),
@@ -4663,15 +4937,15 @@ function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path20.join(projectDir, ".kody", "memory");
-  if (!fs22.existsSync(memoryDir)) return "";
-  const files = fs22.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path21.join(projectDir, ".kody", "memory");
+  if (!fs23.existsSync(memoryDir)) return "";
+  const files = fs23.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 = path20.join(memoryDir, file);
-    const content = fs22.readFileSync(filePath, "utf-8").trim();
+    const filePath = path21.join(memoryDir, file);
+    const content = fs23.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
     const tiered = getTieredContent(filePath, content);
     const selected = selectTier(tiered, tier);
@@ -4694,9 +4968,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path20.join(taskDir, "task.md");
-  if (fs22.existsSync(taskMdPath)) {
-    const content = fs22.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path21.join(taskDir, "task.md");
+  if (fs23.existsSync(taskMdPath)) {
+    const content = fs23.readFileSync(taskMdPath, "utf-8");
     const selected = selectContent(taskMdPath, content, policy.taskDescription);
     const label = tierLabel("Task Description", policy.taskDescription);
     context += `
@@ -4704,9 +4978,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 ${selected}
 `;
   }
-  const taskJsonPath = path20.join(taskDir, "task.json");
-  if (fs22.existsSync(taskJsonPath)) {
-    const content = fs22.readFileSync(taskJsonPath, "utf-8");
+  const taskJsonPath = path21.join(taskDir, "task.json");
+  if (fs23.existsSync(taskJsonPath)) {
+    const content = fs23.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -4732,9 +5006,9 @@ ${selected}
       }
     }
   }
-  const specPath = path20.join(taskDir, "spec.md");
-  if (fs22.existsSync(specPath)) {
-    const content = fs22.readFileSync(specPath, "utf-8");
+  const specPath = path21.join(taskDir, "spec.md");
+  if (fs23.existsSync(specPath)) {
+    const content = fs23.readFileSync(specPath, "utf-8");
     const selected = selectContent(specPath, content, policy.spec);
     const label = tierLabel("Spec", policy.spec);
     context += `
@@ -4742,9 +5016,9 @@ ${selected}
 ${selected}
 `;
   }
-  const planPath = path20.join(taskDir, "plan.md");
-  if (fs22.existsSync(planPath)) {
-    const content = fs22.readFileSync(planPath, "utf-8");
+  const planPath = path21.join(taskDir, "plan.md");
+  if (fs23.existsSync(planPath)) {
+    const content = fs23.readFileSync(planPath, "utf-8");
     const selected = selectContent(planPath, content, policy.plan);
     const label = tierLabel("Plan", policy.plan);
     context += `
@@ -4752,9 +5026,9 @@ ${selected}
 ${selected}
 `;
   }
-  const contextMdPath = path20.join(taskDir, "context.md");
-  if (fs22.existsSync(contextMdPath)) {
-    const content = fs22.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path21.join(taskDir, "context.md");
+  if (fs23.existsSync(contextMdPath)) {
+    const content = fs23.readFileSync(contextMdPath, "utf-8");
     const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
     const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
@@ -4840,24 +5114,24 @@ var init_context_tiers = __esm({
 });
 
 // src/context.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path21.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs23.existsSync(stepFile)) {
-      return fs23.readFileSync(stepFile, "utf-8");
+    const stepFile = path22.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs24.existsSync(stepFile)) {
+      return fs24.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 = [
-    path21.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path21.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path22.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path22.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs23.existsSync(candidate)) {
-      return fs23.readFileSync(candidate, "utf-8");
+    if (fs24.existsSync(candidate)) {
+      return fs24.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -4869,18 +5143,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path21.join(taskDir, "task.md");
-  if (fs23.existsSync(taskMdPath)) {
-    const taskMd = fs23.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path22.join(taskDir, "task.md");
+  if (fs24.existsSync(taskMdPath)) {
+    const taskMd = fs24.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
-  const taskJsonPath = path21.join(taskDir, "task.json");
-  if (fs23.existsSync(taskJsonPath)) {
+  const taskJsonPath = path22.join(taskDir, "task.json");
+  if (fs24.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs23.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs24.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -4893,27 +5167,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path21.join(taskDir, "spec.md");
-  if (fs23.existsSync(specPath)) {
-    const spec = fs23.readFileSync(specPath, "utf-8");
+  const specPath = path22.join(taskDir, "spec.md");
+  if (fs24.existsSync(specPath)) {
+    const spec = fs24.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 = path21.join(taskDir, "plan.md");
-  if (fs23.existsSync(planPath)) {
-    const plan = fs23.readFileSync(planPath, "utf-8");
+  const planPath = path22.join(taskDir, "plan.md");
+  if (fs24.existsSync(planPath)) {
+    const plan = fs24.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 = path21.join(taskDir, "context.md");
-  if (fs23.existsSync(contextMdPath)) {
-    const accumulated = fs23.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path22.join(taskDir, "context.md");
+  if (fs24.existsSync(contextMdPath)) {
+    const accumulated = fs24.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -4931,17 +5205,17 @@ ${feedback}
 }
 function inferHasUIFromScope(scope) {
   return scope.some((filePath) => {
-    const ext = path21.extname(filePath).toLowerCase();
+    const ext = path22.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 = path21.join(taskDir, "task.json");
-  if (!fs23.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path22.join(taskDir, "task.json");
+  if (!fs24.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs23.readFileSync(taskJsonPath, "utf-8"));
+    const taskDef = JSON.parse(fs24.readFileSync(taskJsonPath, "utf-8"));
     const scope = Array.isArray(taskDef.scope) ? taskDef.scope : [];
     if (scope.length === 0) return true;
     return inferHasUIFromScope(scope);
@@ -5127,9 +5401,9 @@ ${prompt}` : prompt;
   const hasBrowserTools = isMcpEnabledForStage(stageName, config.mcp) || config.devServer && browserStages.includes(stageName);
   if (hasBrowserTools && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path21.join(projectDir, ".kody", "qa-guide.md");
-    if (fs23.existsSync(qaGuidePath)) {
-      const qaGuide = fs23.readFileSync(qaGuidePath, "utf-8").trim();
+    const qaGuidePath = path22.join(projectDir, ".kody", "qa-guide.md");
+    if (fs24.existsSync(qaGuidePath)) {
+      const qaGuide = fs24.readFileSync(qaGuidePath, "utf-8").trim();
       assembled = assembled + "\n\n" + qaGuide;
     }
   }
@@ -5239,7 +5513,7 @@ async function waitForReady(url, timeoutSec, stdoutMatch) {
   while (Date.now() < deadline) {
     if (stdoutMatch()) {
       logger.info("  Dev server stdout matched ready pattern");
-      const httpTimeout = Math.min(15, Math.max(1, Math.floor((deadline - Date.now()) / 1e3)));
+      const httpTimeout = Math.max(1, Math.floor((deadline - Date.now()) / 1e3));
       return pollReady(url, httpTimeout);
     }
     await new Promise((r) => setTimeout(r, 500));
@@ -5317,8 +5591,8 @@ var init_dev_server = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -5440,27 +5714,27 @@ async function executeAgentStage(ctx, def) {
   }
   const result2 = lastResult;
   if (def.outputFile && result2.output) {
-    fs24.writeFileSync(path22.join(ctx.taskDir, def.outputFile), result2.output);
+    fs25.writeFileSync(path23.join(ctx.taskDir, def.outputFile), result2.output);
   }
   if (def.outputFile) {
-    const outputPath = path22.join(ctx.taskDir, def.outputFile);
-    if (!fs24.existsSync(outputPath)) {
-      const ext = path22.extname(def.outputFile);
-      const base = path22.basename(def.outputFile, ext);
-      const files = fs24.readdirSync(ctx.taskDir);
+    const outputPath = path23.join(ctx.taskDir, def.outputFile);
+    if (!fs25.existsSync(outputPath)) {
+      const ext = path23.extname(def.outputFile);
+      const base = path23.basename(def.outputFile, ext);
+      const files = fs25.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs24.renameSync(path22.join(ctx.taskDir, variant), outputPath);
+        fs25.renameSync(path23.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path22.join(ctx.taskDir, def.outputFile);
-    if (fs24.existsSync(outputPath)) {
-      const content = fs24.readFileSync(outputPath, "utf-8");
+    const outputPath = path23.join(ctx.taskDir, def.outputFile);
+    if (fs25.existsSync(outputPath)) {
+      const content = fs25.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -5474,7 +5748,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs24.writeFileSync(outputPath, retryResult.output);
+              fs25.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -5487,7 +5761,7 @@ async function executeAgentStage(ctx, def) {
                 risk_level: "low",
                 questions: []
               }, null, 2);
-              fs24.writeFileSync(outputPath, fallback);
+              fs25.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -5501,7 +5775,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path22.join(taskDir, "context.md");
+  const contextPath = path23.join(taskDir, "context.md");
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
   let summary;
   if (output && output.trim()) {
@@ -5514,7 +5788,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs24.appendFileSync(contextPath, entry);
+  fs25.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -5795,8 +6069,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -5839,7 +6113,7 @@ ${output}
 `);
     }
   }
-  fs25.writeFileSync(path23.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs26.writeFileSync(path24.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -5854,8 +6128,8 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 import { execFileSync as execFileSync16 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
@@ -5866,8 +6140,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path24.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs26.existsSync(verifyPath) ? fs26.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const verifyPath = path25.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs27.existsSync(verifyPath) ? fs27.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -5963,8 +6237,8 @@ var init_verify = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -5988,8 +6262,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path25.join(input.projectDir, ".kody", "tasks", taskId);
-  fs27.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path26.join(input.projectDir, ".kody", "tasks", taskId);
+  fs28.mkdirSync(taskDir, { recursive: true });
   let diffInstruction = "";
   let filesChangedSection = "";
   if (input.baseBranch) {
@@ -6016,7 +6290,7 @@ ${fileList}`;
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
-  fs27.writeFileSync(path25.join(taskDir, "task.md"), taskContent);
+  fs28.writeFileSync(path26.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -6038,10 +6312,10 @@ ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
       error: result2.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path25.join(taskDir, "review.md");
+  const reviewPath = path26.join(taskDir, "review.md");
   let reviewContent;
-  if (fs27.existsSync(reviewPath)) {
-    reviewContent = fs27.readFileSync(reviewPath, "utf-8");
+  if (fs28.existsSync(reviewPath)) {
+    reviewContent = fs28.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -6081,8 +6355,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -6096,11 +6370,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path26.join(ctx.taskDir, "review.md");
-    if (!fs28.existsSync(reviewFile)) {
+    const reviewFile = path27.join(ctx.taskDir, "review.md");
+    if (!fs29.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs28.readFileSync(reviewFile, "utf-8");
+    const content = fs29.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -6129,15 +6403,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 import { execFileSync as execFileSync17 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path27.join(ctx.taskDir, "task.json");
-  if (fs29.existsSync(taskJsonPath)) {
+  const taskJsonPath = path28.join(ctx.taskDir, "task.json");
+  if (fs30.existsSync(taskJsonPath)) {
     try {
-      const raw = fs29.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs30.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -6156,9 +6430,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path27.join(ctx.taskDir, "review.md");
-  if (fs29.existsSync(reviewPath)) {
-    const review = fs29.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path28.join(ctx.taskDir, "review.md");
+  if (fs30.existsSync(reviewPath)) {
+    const review = fs30.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -6175,14 +6449,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path27.join(ctx.taskDir, "verify.md");
-  if (fs29.existsSync(verifyPath)) {
-    const verify = fs29.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path28.join(ctx.taskDir, "verify.md");
+  if (fs30.existsSync(verifyPath)) {
+    const verify = fs30.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path27.join(ctx.taskDir, "plan.md");
-  if (fs29.existsSync(planPath)) {
-    const plan = fs29.readFileSync(planPath, "utf-8").trim();
+  const planPath = path28.join(ctx.taskDir, "plan.md");
+  if (fs30.existsSync(planPath)) {
+    const plan = fs30.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -6202,22 +6476,22 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path27.join(ctx.taskDir, "ship.md");
+  const shipPath = path28.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs29.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs30.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) {
-    fs29.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs30.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 {
-      const memoryDir = path27.join(ctx.projectDir, ".kody", "memory");
+      const memoryDir = path28.join(ctx.projectDir, ".kody", "memory");
       const addPaths = [ctx.taskDir];
-      if (fs29.existsSync(memoryDir)) addPaths.push(memoryDir);
+      if (fs30.existsSync(memoryDir)) addPaths.push(memoryDir);
       execFileSync17("git", ["add", ...addPaths], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -6258,28 +6532,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path27.join(ctx.taskDir, "task.json");
-    if (fs29.existsSync(taskJsonPath)) {
+    const taskJsonPath = path28.join(ctx.taskDir, "task.json");
+    if (fs30.existsSync(taskJsonPath)) {
       try {
-        const raw = fs29.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs30.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 = path27.join(ctx.taskDir, "task.md");
-    if (fs29.existsSync(taskMdPath)) {
-      const content = fs29.readFileSync(taskMdPath, "utf-8");
+    const taskMdPath = path28.join(ctx.taskDir, "task.md");
+    if (fs30.existsSync(taskMdPath)) {
+      const content = fs30.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 (fs29.existsSync(taskJsonPath)) {
+      if (fs30.existsSync(taskJsonPath)) {
         try {
-          const raw = fs29.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs30.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);
@@ -6302,7 +6576,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs29.writeFileSync(shipPath, `# Ship
+      fs30.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -6323,20 +6597,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs29.writeFileSync(shipPath, `# Ship
+        fs30.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs29.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs30.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 {
-      fs29.writeFileSync(shipPath, `# Ship
+      fs30.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -6385,15 +6659,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path28.join(ctx.taskDir, "task.json");
-      if (!fs30.existsSync(taskJsonPath)) return false;
-      const raw = fs30.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path29.join(ctx.taskDir, "task.json");
+      if (!fs31.existsSync(taskJsonPath)) return false;
+      const raw = fs31.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) {
@@ -6408,9 +6682,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path28.join(ctx.taskDir, "plan.md");
-      if (!fs30.existsSync(planPath)) return false;
-      const plan = fs30.readFileSync(planPath, "utf-8");
+      const planPath = path29.join(ctx.taskDir, "plan.md");
+      if (!fs31.existsSync(planPath)) return false;
+      const plan = fs31.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -6439,8 +6713,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "plan") setLifecycleLabel(ctx.input.issueNumber, "planning");
@@ -6481,9 +6755,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path29.join(ctx.taskDir, "task.json");
-    if (!fs31.existsSync(taskJsonPath)) return null;
-    const raw = fs31.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path30.join(ctx.taskDir, "task.json");
+    if (!fs32.existsSync(taskJsonPath)) return null;
+    const raw = fs32.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;
@@ -6513,8 +6787,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 = path29.join(ctx.taskDir, "plan.md");
-  const plan = fs31.existsSync(planPath) ? fs31.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path30.join(ctx.taskDir, "plan.md");
+  const plan = fs32.existsSync(planPath) ? fs32.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -6581,22 +6855,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path30.join(ctx.projectDir, ".kody", "memory");
-    if (!fs32.existsSync(memoryDir)) {
-      fs32.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path31.join(ctx.projectDir, ".kody", "memory");
+    if (!fs33.existsSync(memoryDir)) {
+      fs33.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path30.join(ctx.taskDir, "verify.md");
-    if (fs32.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs32.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path31.join(ctx.taskDir, "verify.md");
+    if (fs33.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs33.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");
@@ -6605,18 +6879,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 = path30.join(ctx.taskDir, "review.md");
-    if (fs32.existsSync(reviewPath)) {
-      const review = fs32.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path31.join(ctx.taskDir, "review.md");
+    if (fs33.existsSync(reviewPath)) {
+      const review = fs33.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 = path30.join(ctx.taskDir, "task.json");
-    if (fs32.existsSync(taskJsonPath)) {
+    const taskJsonPath = path31.join(ctx.taskDir, "task.json");
+    if (fs33.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs32.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs33.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)) {
@@ -6627,12 +6901,12 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path30.join(memoryDir, "conventions.md");
+      const conventionsPath = path31.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs32.appendFileSync(conventionsPath, entry);
+      fs33.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -6640,8 +6914,8 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path30.join(memoryDir, "architecture.md");
-  if (fs32.existsSync(archPath)) return;
+  const archPath = path31.join(memoryDir, "architecture.md");
+  if (fs33.existsSync(archPath)) return;
   const detected = detectArchitectureBasic(projectDir);
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
@@ -6649,7 +6923,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs32.writeFileSync(archPath, content);
+    fs33.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -6662,13 +6936,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path31.join(taskDir, filename);
-  if (!fs33.existsSync(p)) return null;
+  const p = path32.join(taskDir, filename);
+  if (!fs34.existsSync(p)) return null;
   try {
-    const content = fs33.readFileSync(p, "utf-8");
+    const content = fs34.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -6721,13 +6995,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path31.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path32.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs33.existsSync(logPath)) return [];
+  if (!fs34.existsSync(logPath)) return [];
   try {
-    const content = fs33.readFileSync(logPath, "utf-8");
+    const content = fs34.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -6754,11 +7028,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path31.dirname(logPath);
-  if (!fs33.existsSync(dir)) {
-    fs33.mkdirSync(dir, { recursive: true });
+  const dir = path32.dirname(logPath);
+  if (!fs34.existsSync(dir)) {
+    fs34.mkdirSync(dir, { recursive: true });
   }
-  fs33.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs34.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -6926,15 +7200,15 @@ var init_summary = __esm({
 });
 
 // src/tools.ts
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 import { execSync as execSync3 } from "child_process";
 import { parse as parseYaml } from "yaml";
 function loadToolDeclarations(projectDir) {
-  const toolsPath = path32.join(projectDir, ".kody", "tools.yml");
-  if (!fs34.existsSync(toolsPath)) return [];
+  const toolsPath = path33.join(projectDir, ".kody", "tools.yml");
+  if (!fs35.existsSync(toolsPath)) return [];
   try {
-    const raw = fs34.readFileSync(toolsPath, "utf-8");
+    const raw = fs35.readFileSync(toolsPath, "utf-8");
     const parsed = parseYaml(raw);
     if (!parsed || typeof parsed !== "object") return [];
     return Object.entries(parsed).map(([name, value]) => {
@@ -6955,7 +7229,7 @@ function loadToolDeclarations(projectDir) {
 function detectTools(declarations, projectDir) {
   const resolved = [];
   for (const decl of declarations) {
-    const detected = decl.detect.some((pattern) => fs34.existsSync(path32.join(projectDir, pattern)));
+    const detected = decl.detect.some((pattern) => fs35.existsSync(path33.join(projectDir, pattern)));
     if (!detected) continue;
     resolved.push({
       name: decl.name,
@@ -6996,8 +7270,8 @@ var init_tools = __esm({
 });
 
 // src/pipeline.ts
-import * as fs35 from "fs";
-import * as path33 from "path";
+import * as fs36 from "fs";
+import * as path34 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -7010,8 +7284,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path33.join(ctx.taskDir, "task.md");
-    const title = fs35.existsSync(taskMdPath) ? fs35.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path34.join(ctx.taskDir, "task.md");
+    const title = fs36.existsSync(taskMdPath) ? fs36.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -7025,10 +7299,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path33.join(taskDir, ".lock");
-  if (fs35.existsSync(lockPath)) {
+  const lockPath = path34.join(taskDir, ".lock");
+  if (fs36.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs35.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs36.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -7045,14 +7319,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs35.unlinkSync(lockPath);
+      fs36.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs35.openSync(lockPath, fs35.constants.O_WRONLY | fs35.constants.O_CREAT | fs35.constants.O_EXCL);
-    fs35.writeSync(fd, String(process.pid));
-    fs35.closeSync(fd);
+    const fd = fs36.openSync(lockPath, fs36.constants.O_WRONLY | fs36.constants.O_CREAT | fs36.constants.O_EXCL);
+    fs36.writeSync(fd, String(process.pid));
+    fs36.closeSync(fd);
   } catch (err) {
     if (err.code === "EEXIST") {
       throw new Error("Pipeline already running (lock acquired by another process)");
@@ -7062,7 +7336,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs35.unlinkSync(path33.join(taskDir, ".lock"));
+    fs36.unlinkSync(path34.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -7279,7 +7553,7 @@ var init_pipeline = __esm({
 
 // src/preflight.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -7332,7 +7606,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs36.existsSync("package.json")) throw new Error("not found");
+      if (!fs37.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -7409,8 +7683,8 @@ var init_args = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs37 from "fs";
-import * as path34 from "path";
+import * as fs38 from "fs";
+import * as path35 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -7442,11 +7716,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path34.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path35.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs37.existsSync(statusPath)) {
+    if (fs38.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs37.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs38.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -7642,8 +7916,8 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs38 from "fs";
-import * as path35 from "path";
+import * as fs39 from "fs";
+import * as path36 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!anyStageNeedsProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
@@ -7698,9 +7972,9 @@ async function runModelHealthCheck(config) {
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path35.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path36.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs38.existsSync(projectDir)) {
+    if (!fs39.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -7760,8 +8034,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path35.join(projectDir, ".kody", "tasks", taskId);
-  fs38.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path36.join(projectDir, ".kody", "tasks", taskId);
+  fs39.mkdirSync(taskDir, { recursive: true });
   if (input.command === "rerun" && isTaskifyRun(taskDir)) {
     const marker = readTaskifyMarker(taskDir);
     if (marker) {
@@ -7893,31 +8167,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs38.writeFileSync(path35.join(taskDir, "task.md"), input.task);
+    fs39.writeFileSync(path36.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path35.join(taskDir, "task.md");
-  if (!fs38.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  const taskMdPath = path36.join(taskDir, "task.md");
+  if (!fs39.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 ?? ""}`;
-      fs38.writeFileSync(taskMdPath, taskContent);
+      fs39.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs38.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs39.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 ?? ""}`;
-      fs38.writeFileSync(taskMdPath, taskContent);
+      fs39.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs38.existsSync(taskMdPath)) {
+  if (!fs39.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -8061,7 +8335,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs38.readdirSync(taskDir);
+  const files = fs39.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -8143,8 +8417,8 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs39 from "fs";
-import * as path36 from "path";
+import * as fs40 from "fs";
+import * as path37 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/bin/commands/init.ts
@@ -8475,6 +8749,24 @@ function initCommand(opts, pkgRoot) {
       console.log("  \u2139 Kody Watch will monitor pipeline health every 30 minutes");
       console.log("  \u2139 Digest issue will be created during bootstrap");
     }
+    const agentTemplatesDir = path2.join(templatesDir, "watch-agents");
+    const watchAgentsDir = path2.join(cwd, ".kody", "watch", "agents");
+    if (fs3.existsSync(agentTemplatesDir)) {
+      const agentDirs = fs3.readdirSync(agentTemplatesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+      for (const agentDir of agentDirs) {
+        const destDir = path2.join(watchAgentsDir, agentDir.name);
+        if (fs3.existsSync(destDir) && !opts.force) {
+          console.log(`  \u25CB .kody/watch/agents/${agentDir.name} (exists)`);
+          continue;
+        }
+        fs3.mkdirSync(destDir, { recursive: true });
+        const srcDir = path2.join(agentTemplatesDir, agentDir.name);
+        for (const file of fs3.readdirSync(srcDir)) {
+          fs3.copyFileSync(path2.join(srcDir, file), path2.join(destDir, file));
+        }
+        console.log(`  \u2713 .kody/watch/agents/${agentDir.name}`);
+      }
+    }
   } else {
     console.log("  \u25CB kody-watch.yml template not found \u2014 skipping");
   }
@@ -9984,11 +10276,11 @@ Create it manually.`, cwd);
 
 // src/bin/cli.ts
 init_architecture_detection();
-var __dirname2 = path36.dirname(fileURLToPath2(import.meta.url));
-var PKG_ROOT = path36.resolve(__dirname2, "..", "..");
+var __dirname2 = path37.dirname(fileURLToPath2(import.meta.url));
+var PKG_ROOT = path37.resolve(__dirname2, "..", "..");
 function getVersion() {
-  const pkgPath = path36.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs39.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path37.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs40.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 var args = process.argv.slice(2);