@kody-ade/kody-engine-lite 0.1.57 → 0.1.58

package/dist/bin/cli.js

@@ -267,7 +267,8 @@ function getProjectConfig() {
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
         github: { ...DEFAULT_CONFIG.github, ...raw.github },
         paths: { ...DEFAULT_CONFIG.paths, ...raw.paths },
-        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent }
+        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
+        contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers
       };
     } catch {
       logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
@@ -306,6 +307,10 @@ var init_config = __esm({
         runner: "claude-code",
         defaultRunner: "claude",
         modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+      },
+      contextTiers: {
+        enabled: true,
+        tokenBudget: 8e3
       }
     };
     VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -775,25 +780,342 @@ var init_memory = __esm({
   }
 });
 
-// src/context.ts
+// src/context-tiers.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+import * as crypto2 from "crypto";
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function contentHash(content) {
+  return crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function resolveStagePolicy(stageName, stageOverrides) {
+  const defaults = DEFAULT_STAGE_POLICIES[stageName] ?? DEFAULT_STAGE_POLICIES.build;
+  const overrides = stageOverrides?.[stageName];
+  return overrides ? { ...defaults, ...overrides } : { ...defaults };
+}
+function generateL0(content, filename) {
+  if (!content.trim()) return "";
+  if (filename.endsWith(".json")) {
+    return generateL0Json(content);
+  }
+  const lines = content.split("\n");
+  const parts = [];
+  const headingLine = lines.find((l) => l.startsWith("#"));
+  if (headingLine) parts.push(headingLine);
+  for (const line of lines) {
+    if (!line.trim() || line.startsWith("#")) continue;
+    if (line.startsWith("-") || line.startsWith("*")) continue;
+    const sentence = line.split(/\.\s/)[0];
+    if (sentence && sentence.length > 10) {
+      parts.push(sentence.endsWith(".") ? sentence : sentence + ".");
+      break;
+    }
+  }
+  const result = parts.join("\n");
+  return result.slice(0, L0_MAX_CHARS);
+}
+function generateL0Json(content) {
+  try {
+    const cleaned = content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+    const obj = JSON.parse(cleaned);
+    const fields = [];
+    if (obj.title) fields.push(`Title: ${obj.title}`);
+    if (obj.task_type) fields.push(`Type: ${obj.task_type}`);
+    if (obj.risk_level) fields.push(`Risk: ${obj.risk_level}`);
+    if (obj.estimated_complexity) fields.push(`Complexity: ${obj.estimated_complexity}`);
+    return fields.join(" | ") || content.slice(0, L0_MAX_CHARS);
+  } catch {
+    return content.slice(0, L0_MAX_CHARS);
+  }
+}
+function generateL1(content, filename) {
+  if (!content.trim()) return "";
+  if (filename.endsWith(".json")) {
+    return generateL1Json(content);
+  }
+  const lines = content.split("\n");
+  const parts = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (line.startsWith("#")) {
+      parts.push(line);
+      inSection = true;
+      continue;
+    }
+    if (line.match(/^\s*[-*]\s/)) {
+      const recentBullets = parts.slice(-5).filter((p) => p.match(/^\s*[-*]\s/)).length;
+      if (recentBullets < 5) {
+        parts.push(line);
+      }
+      continue;
+    }
+    if (inSection && line.trim()) {
+      parts.push(line);
+      inSection = false;
+    }
+  }
+  const result = parts.join("\n");
+  return result.slice(0, L1_MAX_CHARS);
+}
+function generateL1Json(content) {
+  try {
+    const cleaned = content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+    const obj = JSON.parse(cleaned);
+    const lines = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        lines.push(`- ${key}: ${value}`);
+      } else if (Array.isArray(value)) {
+        lines.push(`- ${key}: [${value.length} items] ${value.slice(0, 3).join(", ")}`);
+      }
+    }
+    return lines.join("\n").slice(0, L1_MAX_CHARS);
+  } catch {
+    return content.slice(0, L1_MAX_CHARS);
+  }
+}
+function readCache(cacheDir) {
+  const cachePath = path4.join(cacheDir, "tier-cache.json");
+  if (!fs4.existsSync(cachePath)) return { version: 1, entries: {} };
+  try {
+    return JSON.parse(fs4.readFileSync(cachePath, "utf-8"));
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+function writeCache(cacheDir, cache) {
+  fs4.mkdirSync(cacheDir, { recursive: true });
+  fs4.writeFileSync(path4.join(cacheDir, "tier-cache.json"), JSON.stringify(cache, null, 2));
+}
+function getTieredContent(filePath, content, cacheDir) {
+  const hash = contentHash(content);
+  const key = path4.basename(filePath);
+  const cache = readCache(cacheDir);
+  if (cache.entries[key] && cache.entries[key].hash === hash) {
+    return cache.entries[key];
+  }
+  const tiered = {
+    source: filePath,
+    hash,
+    L0: generateL0(content, key),
+    L1: generateL1(content, key),
+    L2: content
+  };
+  cache.entries[key] = tiered;
+  writeCache(cacheDir, cache);
+  return tiered;
+}
+function invalidateCache(filePath, cacheDir) {
+  const key = path4.basename(filePath);
+  const cache = readCache(cacheDir);
+  if (cache.entries[key]) {
+    delete cache.entries[key];
+    writeCache(cacheDir, cache);
+  }
+}
+function selectTier(tiered, tier) {
+  return tiered[tier];
+}
+function readProjectMemoryTiered(projectDir, tier) {
+  const memoryDir = path4.join(projectDir, ".kody", "memory");
+  if (!fs4.existsSync(memoryDir)) return "";
+  const files = fs4.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  if (files.length === 0) return "";
+  const cacheDir = path4.join(memoryDir, ".tiers");
+  const tierLabel2 = tier === "L2" ? "full" : tier === "L1" ? "overview" : "abstract";
+  const sections = [];
+  for (const file of files) {
+    const filePath = path4.join(memoryDir, file);
+    const content = fs4.readFileSync(filePath, "utf-8").trim();
+    if (!content) continue;
+    const tiered = getTieredContent(filePath, content, cacheDir);
+    const selected = selectTier(tiered, tier);
+    if (selected) {
+      sections.push(`## ${file.replace(".md", "")}
+${selected}`);
+    }
+  }
+  if (sections.length === 0) return "";
+  const header = tier === "L2" ? "# Project Memory\n" : `# Project Memory (${tierLabel2} \u2014 use Read tool for full details)
+`;
+  return `${header}
+${sections.join("\n\n")}
+`;
+}
+function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
+  const cacheDir = path4.join(taskDir, ".tiers");
+  let context = `## Task Context
+`;
+  context += `Task ID: ${taskId}
+`;
+  context += `Task Directory: ${taskDir}
+`;
+  const taskMdPath = path4.join(taskDir, "task.md");
+  if (fs4.existsSync(taskMdPath)) {
+    const content = fs4.readFileSync(taskMdPath, "utf-8");
+    const selected = selectContent(taskMdPath, content, cacheDir, policy.taskDescription);
+    const label = tierLabel("Task Description", policy.taskDescription);
+    context += `
+## ${label}
+${selected}
+`;
+  }
+  const taskJsonPath = path4.join(taskDir, "task.json");
+  if (fs4.existsSync(taskJsonPath)) {
+    const content = fs4.readFileSync(taskJsonPath, "utf-8");
+    if (policy.taskClassification === "L2") {
+      try {
+        const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
+        context += `
+## Task Classification
+`;
+        context += `Type: ${taskDef.task_type ?? "unknown"}
+`;
+        context += `Title: ${taskDef.title ?? "unknown"}
+`;
+        context += `Risk: ${taskDef.risk_level ?? "unknown"}
+`;
+      } catch {
+      }
+    } else {
+      const selected = selectContent(taskJsonPath, content, cacheDir, policy.taskClassification);
+      if (selected) {
+        const label = tierLabel("Task Classification", policy.taskClassification);
+        context += `
+## ${label}
+${selected}
+`;
+      }
+    }
+  }
+  const specPath = path4.join(taskDir, "spec.md");
+  if (fs4.existsSync(specPath)) {
+    const content = fs4.readFileSync(specPath, "utf-8");
+    const selected = selectContent(specPath, content, cacheDir, policy.spec);
+    const label = tierLabel("Spec", policy.spec);
+    context += `
+## ${label}
+${selected}
+`;
+  }
+  const planPath = path4.join(taskDir, "plan.md");
+  if (fs4.existsSync(planPath)) {
+    const content = fs4.readFileSync(planPath, "utf-8");
+    const selected = selectContent(planPath, content, cacheDir, policy.plan);
+    const label = tierLabel("Plan", policy.plan);
+    context += `
+## ${label}
+${selected}
+`;
+  }
+  const contextMdPath = path4.join(taskDir, "context.md");
+  if (fs4.existsSync(contextMdPath)) {
+    const content = fs4.readFileSync(contextMdPath, "utf-8");
+    const selected = selectContent(contextMdPath, content, cacheDir, policy.accumulatedContext);
+    const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
+    context += `
+## ${label}
+${selected}
+`;
+  }
+  if (feedback) {
+    context += `
+## Human Feedback
+${feedback}
+`;
+  }
+  return prompt.replace("{{TASK_CONTEXT}}", context);
+}
+function selectContent(filePath, content, cacheDir, tier) {
+  if (tier === "L2") return content;
+  const tiered = getTieredContent(filePath, content, cacheDir);
+  return selectTier(tiered, tier);
+}
+function tierLabel(sectionName, tier) {
+  if (tier === "L2") return sectionName;
+  if (tier === "L1") return `${sectionName} (overview)`;
+  return `${sectionName} (abstract)`;
+}
+var DEFAULT_STAGE_POLICIES, L0_MAX_CHARS, L1_MAX_CHARS;
+var init_context_tiers = __esm({
+  "src/context-tiers.ts"() {
+    "use strict";
+    DEFAULT_STAGE_POLICIES = {
+      taskify: {
+        memory: "L1",
+        taskDescription: "L2",
+        taskClassification: "L0",
+        spec: "L0",
+        plan: "L0",
+        accumulatedContext: "L0"
+      },
+      plan: {
+        memory: "L1",
+        taskDescription: "L2",
+        taskClassification: "L2",
+        spec: "L0",
+        plan: "L0",
+        accumulatedContext: "L1"
+      },
+      build: {
+        memory: "L1",
+        taskDescription: "L1",
+        taskClassification: "L1",
+        spec: "L1",
+        plan: "L2",
+        accumulatedContext: "L1"
+      },
+      autofix: {
+        memory: "L0",
+        taskDescription: "L0",
+        taskClassification: "L0",
+        spec: "L0",
+        plan: "L1",
+        accumulatedContext: "L2"
+      },
+      review: {
+        memory: "L1",
+        taskDescription: "L1",
+        taskClassification: "L1",
+        spec: "L0",
+        plan: "L2",
+        accumulatedContext: "L1"
+      },
+      "review-fix": {
+        memory: "L0",
+        taskDescription: "L0",
+        taskClassification: "L0",
+        spec: "L0",
+        plan: "L1",
+        accumulatedContext: "L2"
+      }
+    };
+    L0_MAX_CHARS = 400;
+    L1_MAX_CHARS = 1600;
+  }
+});
+
+// src/context.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path4.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs4.existsSync(stepFile)) {
-      return fs4.readFileSync(stepFile, "utf-8");
+    const stepFile = path5.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs5.existsSync(stepFile)) {
+      return fs5.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 = [
-    path4.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path4.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path5.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path5.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs4.existsSync(candidate)) {
-      return fs4.readFileSync(candidate, "utf-8");
+    if (fs5.existsSync(candidate)) {
+      return fs5.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -805,18 +1127,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path4.join(taskDir, "task.md");
-  if (fs4.existsSync(taskMdPath)) {
-    const taskMd = fs4.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path5.join(taskDir, "task.md");
+  if (fs5.existsSync(taskMdPath)) {
+    const taskMd = fs5.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
-  const taskJsonPath = path4.join(taskDir, "task.json");
-  if (fs4.existsSync(taskJsonPath)) {
+  const taskJsonPath = path5.join(taskDir, "task.json");
+  if (fs5.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs4.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -829,27 +1151,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path4.join(taskDir, "spec.md");
-  if (fs4.existsSync(specPath)) {
-    const spec = fs4.readFileSync(specPath, "utf-8");
+  const specPath = path5.join(taskDir, "spec.md");
+  if (fs5.existsSync(specPath)) {
+    const spec = fs5.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 = path4.join(taskDir, "plan.md");
-  if (fs4.existsSync(planPath)) {
-    const plan = fs4.readFileSync(planPath, "utf-8");
+  const planPath = path5.join(taskDir, "plan.md");
+  if (fs5.existsSync(planPath)) {
+    const plan = fs5.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 = path4.join(taskDir, "context.md");
-  if (fs4.existsSync(contextMdPath)) {
-    const accumulated = fs4.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path5.join(taskDir, "context.md");
+  if (fs5.existsSync(contextMdPath)) {
+    const accumulated = fs5.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -866,6 +1188,10 @@ ${feedback}
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
 function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
+  const config = getProjectConfig();
+  if (config.contextTiers?.enabled) {
+    return buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback);
+  }
   const memory = readProjectMemory(projectDir);
   const promptTemplate = readPromptFile(stageName, projectDir);
   const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
@@ -874,6 +1200,24 @@ function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
 
 ${prompt}` : prompt;
 }
+function buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback) {
+  const config = getProjectConfig();
+  const policy = resolveStagePolicy(stageName, config.contextTiers?.stageOverrides);
+  const tokenBudget = config.contextTiers?.tokenBudget ?? 8e3;
+  const memory = readProjectMemoryTiered(projectDir, policy.memory);
+  const promptTemplate = readPromptFile(stageName, projectDir);
+  const prompt = injectTaskContextTiered(promptTemplate, taskId, taskDir, policy, feedback);
+  let assembled = memory ? `${memory}
+---
+
+${prompt}` : prompt;
+  const tokens = estimateTokens(assembled);
+  if (tokens > tokenBudget) {
+    const maxChars = tokenBudget * 4;
+    assembled = assembled.slice(0, maxChars) + "\n...(context truncated to fit token budget)";
+  }
+  return assembled;
+}
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
   if (config.agent.usePerStageRouting && stageName) {
@@ -889,6 +1233,7 @@ var init_context = __esm({
     "use strict";
     init_memory();
     init_config();
+    init_context_tiers();
     DEFAULT_MODEL_MAP = {
       cheap: "haiku",
       mid: "sonnet",
@@ -969,8 +1314,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -1023,27 +1368,27 @@ async function executeAgentStage(ctx, def) {
     return { outcome: result.outcome, error: result.error, retries: 0 };
   }
   if (def.outputFile && result.output) {
-    fs5.writeFileSync(path5.join(ctx.taskDir, def.outputFile), result.output);
+    fs6.writeFileSync(path6.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path5.join(ctx.taskDir, def.outputFile);
-    if (!fs5.existsSync(outputPath)) {
-      const ext = path5.extname(def.outputFile);
-      const base = path5.basename(def.outputFile, ext);
-      const files = fs5.readdirSync(ctx.taskDir);
+    const outputPath = path6.join(ctx.taskDir, def.outputFile);
+    if (!fs6.existsSync(outputPath)) {
+      const ext = path6.extname(def.outputFile);
+      const base = path6.basename(def.outputFile, ext);
+      const files = fs6.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs5.renameSync(path5.join(ctx.taskDir, variant), outputPath);
+        fs6.renameSync(path6.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path5.join(ctx.taskDir, def.outputFile);
-    if (fs5.existsSync(outputPath)) {
-      const content = fs5.readFileSync(outputPath, "utf-8");
+    const outputPath = path6.join(ctx.taskDir, def.outputFile);
+    if (fs6.existsSync(outputPath)) {
+      const content = fs6.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -1057,7 +1402,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs5.writeFileSync(outputPath, retryResult.output);
+              fs6.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -1073,7 +1418,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path5.join(taskDir, "context.md");
+  const contextPath = path6.join(taskDir, "context.md");
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
   let summary;
   if (output && output.trim()) {
@@ -1086,7 +1431,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs5.appendFileSync(contextPath, entry);
+  fs6.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -1308,8 +1653,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -1352,7 +1697,7 @@ ${output}
 `);
     }
   }
-  fs6.writeFileSync(path6.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs7.writeFileSync(path7.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -1367,8 +1712,8 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import { execFileSync as execFileSync6 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
@@ -1379,8 +1724,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path7.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs7.existsSync(verifyPath) ? fs7.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const verifyPath = path8.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs8.existsSync(verifyPath) ? fs8.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -1476,8 +1821,8 @@ var init_verify = __esm({
 });
 
 // src/stages/review.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -1488,11 +1833,11 @@ async function executeReviewWithFix(ctx, def) {
   if (reviewResult.outcome !== "completed") {
     return reviewResult;
   }
-  const reviewFile = path8.join(ctx.taskDir, "review.md");
-  if (!fs8.existsSync(reviewFile)) {
+  const reviewFile = path9.join(ctx.taskDir, "review.md");
+  if (!fs9.existsSync(reviewFile)) {
     return { outcome: "failed", retries: 0, error: "review.md not found" };
   }
-  const content = fs8.readFileSync(reviewFile, "utf-8");
+  const content = fs9.readFileSync(reviewFile, "utf-8");
   const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
   if (!hasIssues) {
     return reviewResult;
@@ -1515,15 +1860,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 import { execFileSync as execFileSync7 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path9.join(ctx.taskDir, "task.json");
-  if (fs9.existsSync(taskJsonPath)) {
+  const taskJsonPath = path10.join(ctx.taskDir, "task.json");
+  if (fs10.existsSync(taskJsonPath)) {
     try {
-      const raw = fs9.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs10.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -1542,9 +1887,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path9.join(ctx.taskDir, "review.md");
-  if (fs9.existsSync(reviewPath)) {
-    const review = fs9.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path10.join(ctx.taskDir, "review.md");
+  if (fs10.existsSync(reviewPath)) {
+    const review = fs10.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -1561,14 +1906,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path9.join(ctx.taskDir, "verify.md");
-  if (fs9.existsSync(verifyPath)) {
-    const verify = fs9.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path10.join(ctx.taskDir, "verify.md");
+  if (fs10.existsSync(verifyPath)) {
+    const verify = fs10.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path9.join(ctx.taskDir, "plan.md");
-  if (fs9.existsSync(planPath)) {
-    const plan = fs9.readFileSync(planPath, "utf-8").trim();
+  const planPath = path10.join(ctx.taskDir, "plan.md");
+  if (fs10.existsSync(planPath)) {
+    const plan = fs10.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -1588,13 +1933,13 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path9.join(ctx.taskDir, "ship.md");
+  const shipPath = path10.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs9.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs10.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) {
-    fs9.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs10.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
@@ -1640,10 +1985,10 @@ function executeShipStage(ctx, _def) {
       docs: "docs",
       chore: "chore"
     };
-    const taskJsonPath = path9.join(ctx.taskDir, "task.json");
-    if (fs9.existsSync(taskJsonPath)) {
+    const taskJsonPath = path10.join(ctx.taskDir, "task.json");
+    if (fs10.existsSync(taskJsonPath)) {
       try {
-        const raw = fs9.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs10.readFileSync(taskJsonPath, "utf-8");
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         const prefix = TYPE_PREFIX[task.task_type] ?? "chore";
@@ -1653,9 +1998,9 @@ function executeShipStage(ctx, _def) {
       }
     }
     if (title === "Update") {
-      const taskMdPath = path9.join(ctx.taskDir, "task.md");
-      if (fs9.existsSync(taskMdPath)) {
-        const content = fs9.readFileSync(taskMdPath, "utf-8");
+      const taskMdPath = path10.join(ctx.taskDir, "task.md");
+      if (fs10.existsSync(taskMdPath)) {
+        const content = fs10.readFileSync(taskMdPath, "utf-8");
         const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("*"));
         if (firstLine) title = `chore: ${firstLine.trim()}`.slice(0, 72);
       }
@@ -1675,7 +2020,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs9.writeFileSync(shipPath, `# Ship
+      fs10.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -1689,19 +2034,19 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs9.writeFileSync(shipPath, `# Ship
+        fs10.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs9.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs10.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);
-    fs9.writeFileSync(shipPath, `# Ship
+    fs10.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -1747,15 +2092,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path10.join(ctx.taskDir, "task.json");
-      if (!fs10.existsSync(taskJsonPath)) return false;
-      const raw = fs10.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path11.join(ctx.taskDir, "task.json");
+      if (!fs11.existsSync(taskJsonPath)) return false;
+      const raw = fs11.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) {
@@ -1770,9 +2115,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path10.join(ctx.taskDir, "plan.md");
-      if (!fs10.existsSync(planPath)) return false;
-      const plan = fs10.readFileSync(planPath, "utf-8");
+      const planPath = path11.join(ctx.taskDir, "plan.md");
+      if (!fs11.existsSync(planPath)) return false;
+      const plan = fs11.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -1801,8 +2146,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
@@ -1828,9 +2173,9 @@ function autoDetectComplexity(ctx, def) {
   if (def.name !== "taskify") return null;
   if (ctx.input.complexity) return null;
   try {
-    const taskJsonPath = path11.join(ctx.taskDir, "task.json");
-    if (!fs11.existsSync(taskJsonPath)) return null;
-    const raw = fs11.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+    if (!fs12.existsSync(taskJsonPath)) return null;
+    const raw = fs12.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;
@@ -1860,8 +2205,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 = path11.join(ctx.taskDir, "plan.md");
-  const plan = fs11.existsSync(planPath) ? fs11.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path12.join(ctx.taskDir, "plan.md");
+  const plan = fs12.existsSync(planPath) ? fs12.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -1928,22 +2273,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path12.join(ctx.projectDir, ".kody", "memory");
-    if (!fs12.existsSync(memoryDir)) {
-      fs12.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path13.join(ctx.projectDir, ".kody", "memory");
+    if (!fs13.existsSync(memoryDir)) {
+      fs13.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path12.join(ctx.taskDir, "verify.md");
-    if (fs12.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs12.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path13.join(ctx.taskDir, "verify.md");
+    if (fs13.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs13.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");
@@ -1952,18 +2297,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 = path12.join(ctx.taskDir, "review.md");
-    if (fs12.existsSync(reviewPath)) {
-      const review = fs12.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path13.join(ctx.taskDir, "review.md");
+    if (fs13.existsSync(reviewPath)) {
+      const review = fs13.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 = path12.join(ctx.taskDir, "task.json");
-    if (fs12.existsSync(taskJsonPath)) {
+    const taskJsonPath = path13.join(ctx.taskDir, "task.json");
+    if (fs13.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs12.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs13.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)) {
@@ -1974,12 +2319,13 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path12.join(memoryDir, "conventions.md");
+      const conventionsPath = path13.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs12.appendFileSync(conventionsPath, entry);
+      fs13.appendFileSync(conventionsPath, entry);
+      invalidateCache(conventionsPath, path13.join(memoryDir, ".tiers"));
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -1987,13 +2333,13 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path12.join(memoryDir, "architecture.md");
-  if (fs12.existsSync(archPath)) return;
+  const archPath = path13.join(memoryDir, "architecture.md");
+  if (fs13.existsSync(archPath)) return;
   const detected = [];
-  const pkgPath = path12.join(projectDir, "package.json");
-  if (fs12.existsSync(pkgPath)) {
+  const pkgPath = path13.join(projectDir, "package.json");
+  if (fs13.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps.next) detected.push(`- Framework: Next.js ${allDeps.next}`);
       else if (allDeps.react) detected.push(`- Framework: React ${allDeps.react}`);
@@ -2009,15 +2355,15 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
       if (allDeps.payload || allDeps["@payloadcms/next"]) detected.push(`- CMS: Payload CMS`);
       if (pkg.type === "module") detected.push("- Module system: ESM");
       else detected.push("- Module system: CommonJS");
-      if (fs12.existsSync(path12.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs12.existsSync(path12.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs12.existsSync(path12.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs13.existsSync(path13.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs13.existsSync(path13.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs13.existsSync(path13.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }
   const topDirs = [];
   try {
-    const entries = fs12.readdirSync(projectDir, { withFileTypes: true });
+    const entries = fs13.readdirSync(projectDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         topDirs.push(entry.name);
@@ -2026,10 +2372,10 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
     if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path12.join(projectDir, "src");
-  if (fs12.existsSync(srcDir)) {
+  const srcDir = path13.join(projectDir, "src");
+  if (fs13.existsSync(srcDir)) {
     try {
-      const srcEntries = fs12.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs13.readdirSync(srcDir, { withFileTypes: true });
       const srcDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
     } catch {
@@ -2041,7 +2387,8 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs12.writeFileSync(archPath, content);
+    fs13.writeFileSync(archPath, content);
+    invalidateCache(archPath, path13.join(memoryDir, ".tiers"));
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -2049,17 +2396,18 @@ var init_auto_learn = __esm({
   "src/learning/auto-learn.ts"() {
     "use strict";
     init_logger();
+    init_context_tiers();
   }
 });
 
 // src/retrospective.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path13.join(taskDir, filename);
-  if (!fs13.existsSync(p)) return null;
+  const p = path14.join(taskDir, filename);
+  if (!fs14.existsSync(p)) return null;
   try {
-    const content = fs13.readFileSync(p, "utf-8");
+    const content = fs14.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -2112,13 +2460,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path13.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path14.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs13.existsSync(logPath)) return [];
+  if (!fs14.existsSync(logPath)) return [];
   try {
-    const content = fs13.readFileSync(logPath, "utf-8");
+    const content = fs14.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -2145,11 +2493,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path13.dirname(logPath);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  const dir = path14.dirname(logPath);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
-  fs13.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs14.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -2260,14 +2608,14 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
 });
 
 // src/pipeline.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.prNumber) return;
   if (!ctx.input.issueNumber || ctx.input.dryRun) return;
   try {
-    const taskMdPath = path14.join(ctx.taskDir, "task.md");
-    const title = fs14.existsSync(taskMdPath) ? fs14.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path15.join(ctx.taskDir, "task.md");
+    const title = fs15.existsSync(taskMdPath) ? fs15.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -2275,10 +2623,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path14.join(taskDir, ".lock");
-  if (fs14.existsSync(lockPath)) {
+  const lockPath = path15.join(taskDir, ".lock");
+  if (fs15.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs14.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs15.readFileSync(lockPath, "utf-8").trim(), 10);
       try {
         process.kill(pid, 0);
         throw new Error(`Pipeline already running (PID ${pid})`);
@@ -2289,11 +2637,11 @@ function acquireLock(taskDir) {
       if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
     }
   }
-  fs14.writeFileSync(lockPath, String(process.pid));
+  fs15.writeFileSync(lockPath, String(process.pid));
 }
 function releaseLock(taskDir) {
   try {
-    fs14.unlinkSync(path14.join(taskDir, ".lock"));
+    fs15.unlinkSync(path15.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -2462,7 +2810,7 @@ var init_pipeline = __esm({
 
 // src/preflight.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -2515,7 +2863,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs15.existsSync("package.json")) throw new Error("not found");
+      if (!fs16.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -2536,13 +2884,13 @@ var init_preflight = __esm({
 });
 
 // src/cli/task-resolution.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 import { execFileSync as execFileSync9 } from "child_process";
 function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path15.join(projectDir, ".kody", "tasks");
-  if (!fs16.existsSync(tasksDir)) return null;
-  const allDirs = fs16.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const tasksDir = path16.join(projectDir, ".kody", "tasks");
+  if (!fs17.existsSync(tasksDir)) return null;
+  const allDirs = fs17.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;
@@ -2576,8 +2924,8 @@ var init_task_resolution = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -2601,12 +2949,12 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path16.join(input.projectDir, ".kody", "tasks", taskId);
-  fs17.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path17.join(input.projectDir, ".kody", "tasks", taskId);
+  fs18.mkdirSync(taskDir, { recursive: true });
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}`;
-  fs17.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
+  fs18.writeFileSync(path17.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2628,10 +2976,10 @@ ${input.prBody ?? ""}`;
       error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path16.join(taskDir, "review.md");
+  const reviewPath = path17.join(taskDir, "review.md");
   let reviewContent;
-  if (fs17.existsSync(reviewPath)) {
-    reviewContent = fs17.readFileSync(reviewPath, "utf-8");
+  if (fs18.existsSync(reviewPath)) {
+    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2723,8 +3071,8 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 import { execFileSync as execFileSync10 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
@@ -2735,8 +3083,8 @@ async function checkLitellmHealth(url) {
   }
 }
 async function tryStartLitellm(url, projectDir) {
-  const configPath = path17.join(projectDir, "litellm-config.yaml");
-  if (!fs18.existsSync(configPath)) {
+  const configPath = path18.join(projectDir, "litellm-config.yaml");
+  if (!fs19.existsSync(configPath)) {
     logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
     return null;
   }
@@ -2768,10 +3116,10 @@ async function tryStartLitellm(url, projectDir) {
     cmd = "python3";
     args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-  const dotenvPath = path17.join(projectDir, ".env");
+  const dotenvPath = path18.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs18.existsSync(dotenvPath)) {
-    for (const line of fs18.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  if (fs19.existsSync(dotenvPath)) {
+    for (const line of fs19.readFileSync(dotenvPath, "utf-8").split("\n")) {
       const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
       if (match) dotenvVars[match[1]] = match[2];
     }
@@ -2811,8 +3159,8 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -2844,11 +3192,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path18.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path19.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs19.existsSync(statusPath)) {
+    if (fs20.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs19.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs20.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -2878,13 +3226,13 @@ var init_task_state = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path19.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path20.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs20.existsSync(projectDir)) {
+    if (!fs21.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -2938,8 +3286,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path19.join(projectDir, ".kody", "tasks", taskId);
-  fs20.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path20.join(projectDir, ".kody", "tasks", taskId);
+  fs21.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -2983,6 +3331,9 @@ async function main() {
         }
       }
       process.env.ANTHROPIC_BASE_URL = config2.agent.litellmUrl;
+      if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
+        process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
+      }
     }
     const runners2 = createRunners(config2);
     const defaultRunnerName2 = config2.agent.defaultRunner ?? Object.keys(runners2)[0] ?? "claude";
@@ -3027,31 +3378,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs20.writeFileSync(path19.join(taskDir, "task.md"), input.task);
+    fs21.writeFileSync(path20.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path19.join(taskDir, "task.md");
-  if (!fs20.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  const taskMdPath = path20.join(taskDir, "task.md");
+  if (!fs21.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 ?? ""}`;
-      fs20.writeFileSync(taskMdPath, taskContent);
+      fs21.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs20.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs21.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 ?? ""}`;
-      fs20.writeFileSync(taskMdPath, taskContent);
+      fs21.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs20.existsSync(taskMdPath)) {
+  if (!fs21.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -3102,6 +3453,9 @@ ${input.feedback}` : reviewContext;
     }
     process.env.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
     logger.info(`ANTHROPIC_BASE_URL set to ${config.agent.litellmUrl}`);
+    if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
+      process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
+    }
   }
   const runners = createRunners(config);
   const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
@@ -3148,7 +3502,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs20.readdirSync(taskDir);
+  const files = fs21.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -3211,15 +3565,15 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 import { fileURLToPath } from "url";
-var __dirname = path20.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path20.resolve(__dirname, "..", "..");
+var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path21.resolve(__dirname, "..", "..");
 function getVersion() {
-  const pkgPath = path20.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path21.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 function checkCommand2(name, args2, fix) {
@@ -3235,7 +3589,7 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs21.existsSync(filePath)) {
+  if (fs22.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
@@ -3307,9 +3661,9 @@ function checkGhSecret(repoSlug, secretName) {
 }
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs21.existsSync(path20.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs21.existsSync(path20.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs21.existsSync(path20.join(cwd, "pnpm-lock.yaml")) && fs21.existsSync(path20.join(cwd, "package-lock.json"))) pm = "npm";
+  if (fs22.existsSync(path21.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs22.existsSync(path21.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml")) && fs22.existsSync(path21.join(cwd, "package-lock.json"))) pm = "npm";
   let defaultBranch = "main";
   try {
     const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
@@ -3352,7 +3706,7 @@ function detectBasicConfig(cwd) {
 function buildConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs21.readFileSync(path20.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -3392,35 +3746,35 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path20.join(PKG_ROOT, "templates");
+  const templatesDir = path21.join(PKG_ROOT, "templates");
   const basic = detectBasicConfig(cwd);
-  const workflowSrc = path20.join(templatesDir, "kody.yml");
-  const workflowDest = path20.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs21.existsSync(workflowSrc)) {
+  const workflowSrc = path21.join(templatesDir, "kody.yml");
+  const workflowDest = path21.join(cwd, ".github", "workflows", "kody.yml");
+  if (!fs22.existsSync(workflowSrc)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs21.existsSync(workflowDest) && !opts.force) {
+  if (fs22.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs21.mkdirSync(path20.dirname(workflowDest), { recursive: true });
-    fs21.copyFileSync(workflowSrc, workflowDest);
+    fs22.mkdirSync(path21.dirname(workflowDest), { recursive: true });
+    fs22.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path20.join(cwd, "kody.config.json");
-  if (!fs21.existsSync(configDest) || opts.force) {
+  const configDest = path21.join(cwd, "kody.config.json");
+  if (!fs22.existsSync(configDest) || opts.force) {
     const config = buildConfig(cwd, basic);
-    fs21.writeFileSync(configDest, JSON.stringify(config, null, 2) + "\n");
+    fs22.writeFileSync(configDest, JSON.stringify(config, null, 2) + "\n");
     console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
-  const gitignorePath = path20.join(cwd, ".gitignore");
-  if (fs21.existsSync(gitignorePath)) {
-    const content = fs21.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path21.join(cwd, ".gitignore");
+  if (fs22.existsSync(gitignorePath)) {
+    const content = fs22.readFileSync(gitignorePath, "utf-8");
     if (content.includes(".tasks/")) {
       const updated = content.replace(/\n?\.tasks\/\n?/g, "\n");
-      fs21.writeFileSync(gitignorePath, updated);
+      fs22.writeFileSync(gitignorePath, updated);
       console.log("  \u2713 .gitignore (removed legacy .tasks/ \u2014 tasks now committed in .kody/tasks/)");
     } else {
       console.log("  \u25CB .gitignore (ok)");
@@ -3431,7 +3785,7 @@ function initCommand(opts) {
     checkCommand2("gh", ["--version"], "Install: https://cli.github.com"),
     checkCommand2("git", ["--version"], "Install git"),
     checkCommand2("node", ["--version"], "Install Node.js >= 22"),
-    checkFile(path20.join(cwd, "package.json"), "package.json", `Run: ${basic.pm} init`)
+    checkFile(path21.join(cwd, "package.json"), "package.json", `Run: ${basic.pm} init`)
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -3509,9 +3863,9 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs21.existsSync(configDest)) {
+  if (fs22.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs21.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs22.readFileSync(configDest, "utf-8"));
       const configChecks = [];
       if (config.github?.owner && config.github?.repo) {
         configChecks.push({ name: "github.owner/repo", ok: true, detail: `${config.github.owner}/${config.github.repo}` });
@@ -3541,10 +3895,10 @@ function initCommand(opts) {
   const filesToCommit = [
     ".github/workflows/kody.yml",
     "kody.config.json"
-  ].filter((f) => fs21.existsSync(path20.join(cwd, f)));
+  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path20.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
       execFileSync11("npx", ["prettier", "--write", ...fullPaths], {
         cwd,
         encoding: "utf-8",
@@ -3606,20 +3960,20 @@ function initCommand(opts) {
 }
 var STEP_STAGES = ["taskify", "plan", "build", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path20.join(cwd, "src");
-  const baseDir = fs21.existsSync(srcDir) ? srcDir : cwd;
+  const srcDir = path21.join(cwd, "src");
+  const baseDir = fs22.existsSync(srcDir) ? srcDir : cwd;
   const results = [];
   function walk(dir) {
     const entries = [];
     try {
-      for (const entry of fs21.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path20.join(dir, entry.name);
+        const full = path21.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 = fs21.statSync(full);
+            const stat = fs22.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -3633,8 +3987,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 = path20.relative(cwd, filePath);
-    const content = fs21.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    const rel = path21.relative(cwd, filePath);
+    const content = fs22.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
     results.push(`### File: ${rel}
 \`\`\`typescript
 ${content}
@@ -3646,9 +4000,9 @@ function ghComment(issueNumber, body, cwd) {
   try {
     let repoSlug = "";
     try {
-      const configPath = path20.join(cwd, "kody.config.json");
-      if (fs21.existsSync(configPath)) {
-        const config = JSON.parse(fs21.readFileSync(configPath, "utf-8"));
+      const configPath = path21.join(cwd, "kody.config.json");
+      if (fs22.existsSync(configPath)) {
+        const config = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -3683,8 +4037,8 @@ function bootstrapCommand() {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path20.join(cwd, rel);
-    if (fs21.existsSync(p)) return fs21.readFileSync(p, "utf-8").slice(0, maxChars);
+    const p = path21.join(cwd, rel);
+    if (fs22.existsSync(p)) return fs22.readFileSync(p, "utf-8").slice(0, maxChars);
     return null;
   };
   let repoContext = "";
@@ -3719,14 +4073,14 @@ ${sampleFiles}
 
 `;
   try {
-    const topDirs = fs21.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs22.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 = path20.join(cwd, "src");
-    if (fs21.existsSync(srcDir)) {
-      const srcDirs = fs21.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path21.join(cwd, "src");
+    if (fs22.existsSync(srcDir)) {
+      const srcDirs = fs22.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) repoContext += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -3736,17 +4090,17 @@ ${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 (fs21.existsSync(path20.join(cwd, f))) existingFiles.push(f);
+    if (fs22.existsSync(path21.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 = path20.join(cwd, ".kody", "memory");
-  fs21.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path20.join(memoryDir, "architecture.md");
-  const conventionsPath = path20.join(memoryDir, "conventions.md");
+  const memoryDir = path21.join(cwd, ".kody", "memory");
+  fs22.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path21.join(memoryDir, "architecture.md");
+  const conventionsPath = path21.join(memoryDir, "conventions.md");
   const memoryPrompt = `You are analyzing a project to generate documentation for an autonomous SDLC pipeline.
 
 Given this project context, output ONLY a JSON object with EXACTLY this structure:
@@ -3787,12 +4141,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs21.writeFileSync(archPath, parsed.architecture);
+      fs22.writeFileSync(archPath, parsed.architecture);
       const lineCount = parsed.architecture.split("\n").length;
       console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines)`);
     }
     if (parsed.conventions) {
-      fs21.writeFileSync(conventionsPath, parsed.conventions);
+      fs22.writeFileSync(conventionsPath, parsed.conventions);
       const lineCount = parsed.conventions.split("\n").length;
       console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines)`);
     }
@@ -3801,34 +4155,34 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs21.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs22.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `);
       console.log(`  \u2713 .kody/memory/architecture.md (${detected.length} items, basic detection)`);
     }
-    fs21.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs22.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 = path20.join(cwd, ".kody", "steps");
-  fs21.mkdirSync(stepsDir, { recursive: true });
-  const arch = fs21.existsSync(archPath) ? fs21.readFileSync(archPath, "utf-8") : "";
-  const conv = fs21.existsSync(conventionsPath) ? fs21.readFileSync(conventionsPath, "utf-8") : "";
+  const stepsDir = path21.join(cwd, ".kody", "steps");
+  fs22.mkdirSync(stepsDir, { recursive: true });
+  const arch = fs22.existsSync(archPath) ? fs22.readFileSync(archPath, "utf-8") : "";
+  const conv = fs22.existsSync(conventionsPath) ? fs22.readFileSync(conventionsPath, "utf-8") : "";
   console.log("  \u23F3 Customizing step files...");
   let stepCount = 0;
   for (const stage of STEP_STAGES) {
-    const templatePath = path20.join(PKG_ROOT, "prompts", `${stage}.md`);
-    if (!fs21.existsSync(templatePath)) {
+    const templatePath = path21.join(PKG_ROOT, "prompts", `${stage}.md`);
+    if (!fs22.existsSync(templatePath)) {
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
-    const defaultPrompt = fs21.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs22.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs21.copyFileSync(templatePath, path20.join(stepsDir, `${stage}.md`));
+      fs22.copyFileSync(templatePath, path21.join(stepsDir, `${stage}.md`));
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -3885,12 +4239,12 @@ 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;
-      fs21.writeFileSync(path20.join(stepsDir, `${stage}.md`), finalPrompt);
+      fs22.writeFileSync(path21.join(stepsDir, `${stage}.md`), finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs21.copyFileSync(templatePath, path20.join(stepsDir, `${stage}.md`));
+      fs22.copyFileSync(templatePath, path21.join(stepsDir, `${stage}.md`));
       stepCount++;
     }
   }
@@ -3899,16 +4253,16 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   const filesToCommit = [
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md"
-  ].filter((f) => fs21.existsSync(path20.join(cwd, f)));
+  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs21.existsSync(path20.join(cwd, stepFile))) {
+    if (fs22.existsSync(path21.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path20.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
         execFileSync11("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
@@ -3935,9 +4289,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path20.join(cwd, "kody.config.json");
-            if (fs21.existsSync(configPath)) {
-              const config = JSON.parse(fs21.readFileSync(configPath, "utf-8"));
+            const configPath = path21.join(cwd, "kody.config.json");
+            if (fs22.existsSync(configPath)) {
+              const config = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
               baseBranch = config.git?.defaultBranch ?? "main";
             }
           } catch {
@@ -4004,10 +4358,10 @@ Review and merge to activate project-specific pipeline configuration.`, cwd);
 }
 function detectArchitectureBasic(cwd) {
   const detected = [];
-  const pkgPath = path20.join(cwd, "package.json");
-  if (fs21.existsSync(pkgPath)) {
+  const pkgPath = path21.join(cwd, "package.json");
+  if (fs22.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps.next) detected.push(`- Framework: Next.js ${allDeps.next}`);
       else if (allDeps.react) detected.push(`- Framework: React ${allDeps.react}`);
@@ -4023,10 +4377,10 @@ function detectArchitectureBasic(cwd) {
       if (allDeps["drizzle-orm"]) detected.push("- ORM: Drizzle");
       if (allDeps.payload || allDeps["@payloadcms/next"]) detected.push("- CMS: Payload CMS");
       if (allDeps.tailwindcss) detected.push(`- CSS: Tailwind CSS ${allDeps.tailwindcss}`);
-      if (fs21.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs21.existsSync(path20.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs21.existsSync(path20.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs21.existsSync(path20.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs22.existsSync(path21.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs22.existsSync(path21.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
+      else if (fs22.existsSync(path21.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }