@kody-ade/kody-engine-lite 0.1.104 → 0.1.105

package/dist/bin/cli.js

@@ -9,63 +9,8 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/bin/architecture-detection.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
-function detectArchitectureBasic(cwd) {
-  const detected = [];
-  const pkgPath = path3.join(cwd, "package.json");
-  if (fs4.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs4.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}`);
-      else if (allDeps.express) detected.push(`- Framework: Express ${allDeps.express}`);
-      else if (allDeps.fastify) detected.push(`- Framework: Fastify ${allDeps.fastify}`);
-      else if (allDeps.hono) detected.push(`- Framework: Hono ${allDeps.hono}`);
-      if (allDeps.typescript) detected.push(`- Language: TypeScript ${allDeps.typescript}`);
-      if (allDeps.vitest) detected.push(`- Testing: vitest ${allDeps.vitest}`);
-      else if (allDeps.jest) detected.push(`- Testing: jest ${allDeps.jest}`);
-      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
-      if (allDeps.prettier) detected.push(`- Formatting: prettier ${allDeps.prettier}`);
-      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- ORM: Prisma");
-      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 (fs4.existsSync(path3.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs4.existsSync(path3.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs4.existsSync(path3.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs4.existsSync(path3.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
-      if (pkg.type === "module") detected.push("- Module system: ESM");
-      else detected.push("- Module system: CommonJS");
-      if (allDeps.pg || allDeps.postgres) detected.push("- Database: PostgreSQL");
-    } catch {
-    }
-  }
-  try {
-    const topDirs = fs4.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
-    if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
-  } catch {
-  }
-  const srcDir = path3.join(cwd, "src");
-  if (fs4.existsSync(srcDir)) {
-    try {
-      const srcDirs = fs4.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-      if (srcDirs.length > 0) detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
-    } catch {
-    }
-  }
-  return detected;
-}
-var init_architecture_detection = __esm({
-  "src/bin/architecture-detection.ts"() {
-    "use strict";
-  }
-});
-
 // src/agent-runner.ts
-import { spawn, execFileSync as execFileSync6 } from "child_process";
+import { spawn, execFileSync } from "child_process";
 function writeStdin(child, prompt) {
   return new Promise((resolve4, reject) => {
     if (!child.stdin) {
@@ -137,9 +82,9 @@ async function runSubprocess(command2, args2, prompt, timeout, options) {
 ${errDetail}`
   };
 }
-function checkCommand2(command2, args2) {
+function checkCommand(command2, args2) {
   try {
-    execFileSync6(command2, args2, { timeout: 1e4, stdio: "pipe" });
+    execFileSync(command2, args2, { timeout: 1e4, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -169,7 +114,7 @@ function createClaudeCodeRunner() {
       return runSubprocess("claude", args2, prompt, timeout, options);
     },
     async healthCheck() {
-      return checkCommand2("claude", ["--version"]);
+      return checkCommand("claude", ["--version"]);
     }
   };
 }
@@ -326,77 +271,9 @@ var init_logger = __esm({
   }
 });
 
-// src/validators.ts
-function stripFences(content) {
-  return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
-}
-function parseJsonSafe(raw, requiredFields) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    return { ok: false, error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}` };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return { ok: false, error: `Expected JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}` };
-  }
-  if (requiredFields) {
-    for (const field of requiredFields) {
-      if (!(field in parsed)) {
-        return { ok: false, error: `Missing required field: ${field}` };
-      }
-    }
-  }
-  return { ok: true, data: parsed };
-}
-function validateTaskJson(content) {
-  try {
-    const parsed = JSON.parse(stripFences(content));
-    for (const field of REQUIRED_TASK_FIELDS) {
-      if (!(field in parsed)) {
-        return { valid: false, error: `Missing field: ${field}` };
-      }
-    }
-    return { valid: true };
-  } catch (err) {
-    return {
-      valid: false,
-      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-function validatePlanMd(content) {
-  if (content.length < 10) {
-    return { valid: false, error: "Plan is too short (< 10 chars)" };
-  }
-  if (!/^##\s+\w+/m.test(content)) {
-    return { valid: false, error: "Plan has no markdown h2 sections" };
-  }
-  return { valid: true };
-}
-function validateReviewMd(content) {
-  if (/pass/i.test(content) || /fail/i.test(content)) {
-    return { valid: true };
-  }
-  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
-}
-var REQUIRED_TASK_FIELDS;
-var init_validators = __esm({
-  "src/validators.ts"() {
-    "use strict";
-    REQUIRED_TASK_FIELDS = [
-      "task_type",
-      "title",
-      "description",
-      "scope",
-      "risk_level"
-    ];
-  }
-});
-
 // src/config.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs from "fs";
+import * as path from "path";
 function needsLitellmProxy(config) {
   return !!(config.agent.provider && config.agent.provider !== "anthropic");
 }
@@ -413,16 +290,10 @@ function setConfigDir(dir) {
 }
 function getProjectConfig() {
   if (_config) return _config;
-  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs8.existsSync(configPath)) {
+  const configPath = path.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs.existsSync(configPath)) {
     try {
-      const result = parseJsonSafe(fs8.readFileSync(configPath, "utf-8"));
-      if (!result.ok) {
-        logger.warn(`kody.config.json: ${result.error} \u2014 using defaults`);
-        _config = { ...DEFAULT_CONFIG };
-        return _config;
-      }
-      const raw = result.data;
+      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       _config = {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
@@ -434,13 +305,7 @@ function getProjectConfig() {
         },
         timeouts: raw.timeouts ?? void 0,
         contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
-        mcp: raw.mcp ? {
-          servers: {},
-          stages: ["build", "verify", "review", "review-fix"],
-          ...raw.mcp,
-          // Auto-enable when devServer is configured (user can still set enabled: false to override)
-          enabled: raw.mcp.enabled ?? !!raw.mcp.devServer
-        } : void 0
+        mcp: raw.mcp ? { enabled: false, servers: {}, stages: ["build", "verify", "review", "review-fix"], ...raw.mcp } : void 0
       };
     } catch {
       logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
@@ -456,7 +321,6 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
-    init_validators();
     DEFAULT_CONFIG = {
       quality: {
         typecheck: "pnpm -s tsc --noEmit",
@@ -490,7 +354,7 @@ var init_config = __esm({
 });
 
 // src/git-utils.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function getHookSafeEnv() {
   if (!_hookSafeEnv) {
     _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
@@ -498,7 +362,7 @@ function getHookSafeEnv() {
   return _hookSafeEnv;
 }
 function git(args2, options) {
-  return execFileSync7("git", args2, {
+  return execFileSync2("git", args2, {
     encoding: "utf-8",
     timeout: options?.timeout ?? 3e4,
     cwd: options?.cwd,
@@ -553,9 +417,8 @@ function ensureFeatureBranch(issueNumber, title, cwd) {
   }
   try {
     git(["fetch", "origin"], { cwd, timeout: 3e4 });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch origin: ${msg}`);
+  } catch {
+    logger.warn("  Failed to fetch origin");
   }
   try {
     git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
@@ -587,9 +450,8 @@ function syncWithDefault(cwd, branch) {
   if (current === defaultBranch) return;
   try {
     git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
+  } catch {
+    logger.warn("  Failed to fetch latest from origin");
     return;
   }
   try {
@@ -598,8 +460,7 @@ function syncWithDefault(cwd, branch) {
   } catch {
     try {
       git(["merge", "--abort"], { cwd });
-    } catch (abortErr) {
-      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
+    } catch {
     }
     logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
   }
@@ -610,9 +471,8 @@ function mergeDefault(cwd) {
   if (current === defaultBranch) return "clean";
   try {
     git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
+  } catch {
+    logger.warn("  Failed to fetch latest from origin");
     return "error";
   }
   try {
@@ -627,8 +487,7 @@ function mergeDefault(cwd) {
     }
     try {
       git(["merge", "--abort"], { cwd });
-    } catch (abortErr) {
-      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
+    } catch {
     }
     return "error";
   }
@@ -673,21 +532,7 @@ var init_git_utils = __esm({
 });
 
 // src/github-api.ts
-import { execFileSync as execFileSync8 } from "child_process";
-function isGhExecError(err) {
-  return typeof err === "object" && err !== null;
-}
-function ghErrorMessage(err) {
-  if (isGhExecError(err)) {
-    const stderr = err.stderr?.toString().trim();
-    if (stderr) return stderr;
-  }
-  return err instanceof Error ? err.message : String(err);
-}
-function isNotFoundError(err) {
-  const msg = ghErrorMessage(err).toLowerCase();
-  return msg.includes("not found") || msg.includes("no pull requests") || msg.includes("could not resolve");
-}
+import { execFileSync as execFileSync3 } from "child_process";
 function setGhCwd(cwd) {
   _ghCwd = cwd;
 }
@@ -697,7 +542,7 @@ function ghToken() {
 function gh(args2, options) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync8("gh", args2, {
+  return execFileSync3("gh", args2, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd: _ghCwd,
@@ -715,18 +560,9 @@ function getIssue(issueNumber) {
       "--json",
       "body,title"
     ]);
-    const parsed = JSON.parse(output);
-    if (!parsed || typeof parsed.title !== "string") {
-      logger.warn(`  Issue #${issueNumber}: unexpected response shape`);
-      return null;
-    }
-    return { body: parsed.body ?? "", title: parsed.title };
+    return JSON.parse(output);
   } catch (err) {
-    if (isNotFoundError(err)) {
-      logger.info(`  Issue #${issueNumber} not found`);
-    } else {
-      logger.error(`  Failed to get issue #${issueNumber}: ${ghErrorMessage(err)}`);
-    }
+    logger.error(`  Failed to get issue #${issueNumber}: ${err}`);
     return null;
   }
 }
@@ -767,15 +603,8 @@ function getPRForBranch(branch) {
       "number,url"
     ]);
     const data = JSON.parse(output);
-    if (typeof data.number !== "number" || typeof data.url !== "string") {
-      logger.warn(`  PR for branch ${branch}: unexpected response shape`);
-      return null;
-    }
     return { number: data.number, url: data.url };
-  } catch (err) {
-    if (!isNotFoundError(err)) {
-      logger.warn(`  Failed to check PR for branch ${branch}: ${ghErrorMessage(err)}`);
-    }
+  } catch {
     return null;
   }
 }
@@ -813,7 +642,8 @@ function createPR(head, base, title, body) {
     logger.info(`  PR created: ${url}`);
     return { number, url };
   } catch (err) {
-    const reason = ghErrorMessage(err);
+    const stderr = err?.stderr?.toString().trim();
+    const reason = stderr || (err instanceof Error ? err.message : String(err));
     logger.error(`  Failed to create PR: ${reason}`);
     return null;
   }
@@ -884,22 +714,9 @@ function getPRDetails(prNumber) {
       "title,body,headRefName,baseRefName"
     ]);
     const data = JSON.parse(output);
-    if (typeof data.title !== "string" || typeof data.headRefName !== "string") {
-      logger.warn(`  PR #${prNumber}: unexpected response shape`);
-      return null;
-    }
-    return {
-      title: data.title,
-      body: data.body ?? "",
-      headBranch: data.headRefName,
-      baseBranch: data.baseRefName ?? "main"
-    };
+    return { title: data.title, body: data.body, headBranch: data.headRefName, baseBranch: data.baseRefName };
   } catch (err) {
-    if (isNotFoundError(err)) {
-      logger.info(`  PR #${prNumber} not found`);
-    } else {
-      logger.error(`  Failed to get PR #${prNumber}: ${ghErrorMessage(err)}`);
-    }
+    logger.error(`  Failed to get PR #${prNumber}: ${err}`);
     return null;
   }
 }
@@ -941,7 +758,7 @@ function getCIFailureLogs(runId, maxLength = 8e3) {
     const prefix = logsOutput.length > maxLength ? "...(earlier output truncated)\n" : "";
     return `${prefix}${truncated}`;
   } catch (err) {
-    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${ghErrorMessage(err)}`);
+    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${err}`);
     return null;
   }
 }
@@ -963,7 +780,7 @@ function getLatestFailedRunForBranch(branch) {
     ]);
     return output.trim() || null;
   } catch (err) {
-    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${ghErrorMessage(err)}`);
+    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${err}`);
     return null;
   }
 }
@@ -1044,7 +861,7 @@ var init_github_api = __esm({
     "use strict";
     init_logger();
     API_TIMEOUT_MS = 3e4;
-    LIFECYCLE_LABELS = ["planning", "building", "review", "shipping", "done", "failed", "waiting", "low", "medium", "high"];
+    LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed", "waiting", "low", "medium", "high"];
     KODY_MARKERS = [
       "Kody Review",
       "\u{1F916} Generated by Kody",
@@ -1059,22 +876,15 @@ var init_github_api = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 function loadState(taskId, taskDir) {
-  const p = path8.join(taskDir, "status.json");
-  if (!fs9.existsSync(p)) return null;
+  const p = path2.join(taskDir, "status.json");
+  if (!fs2.existsSync(p)) return null;
   try {
-    const result = parseJsonSafe(
-      fs9.readFileSync(p, "utf-8"),
-      ["taskId", "state", "stages", "createdAt", "updatedAt"]
-    );
-    if (!result.ok) {
-      logger.warn(`  Corrupt status.json: ${result.error}`);
-      return null;
-    }
-    if (result.data.taskId !== taskId) return null;
-    return result.data;
+    const raw = JSON.parse(fs2.readFileSync(p, "utf-8"));
+    if (raw.taskId === taskId) return raw;
+    return null;
   } catch {
     return null;
   }
@@ -1084,11 +894,11 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path8.join(taskDir, "status.json");
+  const target = path2.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs9.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs9.renameSync(tmp, target);
-  return updated;
+  fs2.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs2.renameSync(tmp, target);
+  state.updatedAt = updated.updatedAt;
 }
 function initState(taskId) {
   const stages = {};
@@ -1102,8 +912,6 @@ var init_state = __esm({
   "src/pipeline/state.ts"() {
     "use strict";
     init_definitions();
-    init_validators();
-    init_logger();
   }
 });
 
@@ -1128,16 +936,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path9.join(projectDir, ".kody", "memory");
-  if (!fs10.existsSync(memoryDir)) return "";
-  const files = fs10.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path3.join(projectDir, ".kody", "memory");
+  if (!fs3.existsSync(memoryDir)) return "";
+  const files = fs3.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs10.readFileSync(path9.join(memoryDir, file), "utf-8").trim();
+    const content = fs3.readFileSync(path3.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -1156,11 +964,15 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+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];
@@ -1247,30 +1059,61 @@ function generateL1Json(content) {
     return content.slice(0, L1_MAX_CHARS);
   }
 }
-function getTieredContent(filePath, content) {
-  const key = path10.basename(filePath);
-  return {
+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 = path10.join(projectDir, ".kody", "memory");
-  if (!fs11.existsSync(memoryDir)) return "";
-  const files = fs11.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  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 = path10.join(memoryDir, file);
-    const content = fs11.readFileSync(filePath, "utf-8").trim();
+    const filePath = path4.join(memoryDir, file);
+    const content = fs4.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
-    const tiered = getTieredContent(filePath, content);
+    const tiered = getTieredContent(filePath, content, cacheDir);
     const selected = selectTier(tiered, tier);
     if (selected) {
       sections.push(`## ${file.replace(".md", "")}
@@ -1285,25 +1128,26 @@ ${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 = path10.join(taskDir, "task.md");
-  if (fs11.existsSync(taskMdPath)) {
-    const content = fs11.readFileSync(taskMdPath, "utf-8");
-    const selected = selectContent(taskMdPath, content, policy.taskDescription);
+  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 = path10.join(taskDir, "task.json");
-  if (fs11.existsSync(taskJsonPath)) {
-    const content = fs11.readFileSync(taskJsonPath, "utf-8");
+  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, ""));
@@ -1319,7 +1163,7 @@ ${selected}
       } catch {
       }
     } else {
-      const selected = selectContent(taskJsonPath, content, policy.taskClassification);
+      const selected = selectContent(taskJsonPath, content, cacheDir, policy.taskClassification);
       if (selected) {
         const label = tierLabel("Task Classification", policy.taskClassification);
         context += `
@@ -1329,30 +1173,30 @@ ${selected}
       }
     }
   }
-  const specPath = path10.join(taskDir, "spec.md");
-  if (fs11.existsSync(specPath)) {
-    const content = fs11.readFileSync(specPath, "utf-8");
-    const selected = selectContent(specPath, content, policy.spec);
+  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 = path10.join(taskDir, "plan.md");
-  if (fs11.existsSync(planPath)) {
-    const content = fs11.readFileSync(planPath, "utf-8");
-    const selected = selectContent(planPath, content, policy.plan);
+  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 = path10.join(taskDir, "context.md");
-  if (fs11.existsSync(contextMdPath)) {
-    const content = fs11.readFileSync(contextMdPath, "utf-8");
-    const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
+  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}
@@ -1367,9 +1211,9 @@ ${feedback}
   }
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
-function selectContent(filePath, content, tier) {
+function selectContent(filePath, content, cacheDir, tier) {
   if (tier === "L2") return content;
-  const tiered = getTieredContent(filePath, content);
+  const tiered = getTieredContent(filePath, content, cacheDir);
   return selectTier(tiered, tier);
 }
 function tierLabel(sectionName, tier) {
@@ -1437,20 +1281,6 @@ var init_context_tiers = __esm({
 });
 
 // src/mcp-config.ts
-function withPlaywrightIfNeeded(mcpConfig, hasUI) {
-  if (!mcpConfig?.enabled || !hasUI) return mcpConfig;
-  const hasPlaywright = Object.keys(mcpConfig.servers).some(
-    (name) => name.toLowerCase().includes("playwright")
-  );
-  if (hasPlaywright) return mcpConfig;
-  return {
-    ...mcpConfig,
-    servers: {
-      ...mcpConfig.servers,
-      playwright: PLAYWRIGHT_SERVER
-    }
-  };
-}
 function buildMcpConfigJson(mcpConfig) {
   if (!mcpConfig?.enabled) return void 0;
   if (Object.keys(mcpConfig.servers).length === 0) return void 0;
@@ -1467,40 +1297,37 @@ function buildMcpConfigJson(mcpConfig) {
 }
 function isMcpEnabledForStage(stageName, mcpConfig) {
   if (!mcpConfig?.enabled) return false;
+  if (Object.keys(mcpConfig.servers).length === 0) return false;
   const allowedStages = mcpConfig.stages ?? DEFAULT_MCP_STAGES;
   return allowedStages.includes(stageName);
 }
-var DEFAULT_MCP_STAGES, PLAYWRIGHT_SERVER;
+var DEFAULT_MCP_STAGES;
 var init_mcp_config = __esm({
   "src/mcp-config.ts"() {
     "use strict";
     DEFAULT_MCP_STAGES = ["build", "verify", "review", "review-fix"];
-    PLAYWRIGHT_SERVER = {
-      command: "npx",
-      args: ["-y", "@anthropic-ai/mcp-playwright"]
-    };
   }
 });
 
 // src/context.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path11.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs12.existsSync(stepFile)) {
-      return fs12.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 = [
-    path11.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path11.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path5.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path5.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs12.existsSync(candidate)) {
-      return fs12.readFileSync(candidate, "utf-8");
+    if (fs5.existsSync(candidate)) {
+      return fs5.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -1512,18 +1339,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path11.join(taskDir, "task.md");
-  if (fs12.existsSync(taskMdPath)) {
-    const taskMd = fs12.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 = path11.join(taskDir, "task.json");
-  if (fs12.existsSync(taskJsonPath)) {
+  const taskJsonPath = path5.join(taskDir, "task.json");
+  if (fs5.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -1536,27 +1363,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path11.join(taskDir, "spec.md");
-  if (fs12.existsSync(specPath)) {
-    const spec = fs12.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 = path11.join(taskDir, "plan.md");
-  if (fs12.existsSync(planPath)) {
-    const plan = fs12.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 = path11.join(taskDir, "context.md");
-  if (fs12.existsSync(contextMdPath)) {
-    const accumulated = fs12.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 += `
@@ -1573,10 +1400,10 @@ ${feedback}
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
 function taskHasUI(taskDir) {
-  const taskJsonPath = path11.join(taskDir, "task.json");
-  if (!fs12.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path5.join(taskDir, "task.json");
+  if (!fs5.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
+    const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
     return taskDef.hasUI !== false;
   } catch {
     return true;
@@ -1696,11 +1523,6 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path11.join(projectDir, ".kody", "qa-guide.md");
-    if (fs12.existsSync(qaGuidePath)) {
-      const qaGuide = fs12.readFileSync(qaGuidePath, "utf-8").trim();
-      assembled = assembled + "\n\n" + qaGuide;
-    }
   }
   return assembled;
 }
@@ -1747,6 +1569,55 @@ var init_context = __esm({
   }
 });
 
+// src/validators.ts
+function stripFences(content) {
+  return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+}
+function validateTaskJson(content) {
+  try {
+    const parsed = JSON.parse(stripFences(content));
+    for (const field of REQUIRED_TASK_FIELDS) {
+      if (!(field in parsed)) {
+        return { valid: false, error: `Missing field: ${field}` };
+      }
+    }
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function validatePlanMd(content) {
+  if (content.length < 10) {
+    return { valid: false, error: "Plan is too short (< 10 chars)" };
+  }
+  if (!/^##\s+\w+/m.test(content)) {
+    return { valid: false, error: "Plan has no markdown h2 sections" };
+  }
+  return { valid: true };
+}
+function validateReviewMd(content) {
+  if (/pass/i.test(content) || /fail/i.test(content)) {
+    return { valid: true };
+  }
+  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
+}
+var REQUIRED_TASK_FIELDS;
+var init_validators = __esm({
+  "src/validators.ts"() {
+    "use strict";
+    REQUIRED_TASK_FIELDS = [
+      "task_type",
+      "title",
+      "description",
+      "scope",
+      "risk_level"
+    ];
+  }
+});
+
 // src/pipeline/runner-selection.ts
 function getRunnerForStage(ctx, stageName) {
   const config = getProjectConfig();
@@ -1767,8 +1638,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs13 from "fs";
-import * as path12 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;
@@ -1814,8 +1685,7 @@ async function executeAgentStage(ctx, def) {
   if (sessionInfo) {
     logger.info(`  session: ${SESSION_GROUP[def.name]} (${sessionInfo.resumeSession ? "resume" : "new"})`);
   }
-  const mcpForStage = isMcpEnabledForStage(def.name, config.mcp) ? withPlaywrightIfNeeded(config.mcp, taskHasUI(ctx.taskDir)) : void 0;
-  const mcpConfigJson = buildMcpConfigJson(mcpForStage);
+  const mcpConfigJson = isMcpEnabledForStage(def.name, config.mcp) ? buildMcpConfigJson(config.mcp) : void 0;
   if (mcpConfigJson) {
     logger.info(`  MCP servers enabled for ${def.name}`);
   }
@@ -1830,27 +1700,27 @@ async function executeAgentStage(ctx, def) {
     return { outcome: result.outcome, error: result.error, retries: 0 };
   }
   if (def.outputFile && result.output) {
-    fs13.writeFileSync(path12.join(ctx.taskDir, def.outputFile), result.output);
+    fs6.writeFileSync(path6.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path12.join(ctx.taskDir, def.outputFile);
-    if (!fs13.existsSync(outputPath)) {
-      const ext = path12.extname(def.outputFile);
-      const base = path12.basename(def.outputFile, ext);
-      const files = fs13.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) {
-        fs13.renameSync(path12.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 = path12.join(ctx.taskDir, def.outputFile);
-    if (fs13.existsSync(outputPath)) {
-      const content = fs13.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") {
@@ -1864,7 +1734,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs13.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}`);
@@ -1875,10 +1745,10 @@ async function executeAgentStage(ctx, def) {
                 description: plainText.slice(0, 500),
                 scope: [],
                 risk_level: "low",
-                hasUI: true,
+                hasUI: false,
                 questions: []
               }, null, 2);
-              fs13.writeFileSync(outputPath, fallback);
+              fs6.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -1892,7 +1762,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path12.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()) {
@@ -1905,7 +1775,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs13.appendFileSync(contextPath, entry);
+  fs6.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -1928,7 +1798,7 @@ var init_agent = __esm({
 });
 
 // src/verify-runner.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -1964,7 +1834,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync9(parts[0], parts.slice(1), {
+    const output = execFileSync4(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -2035,7 +1905,7 @@ var init_verify_runner = __esm({
 });
 
 // src/observer.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -2060,48 +1930,42 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
     );
     if (result.outcome === "completed" && result.output) {
       const cleaned = result.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
-      const parseResult = parseJsonSafe(cleaned, ["classification"]);
-      if (parseResult.ok) {
-        const { data } = parseResult;
-        const validClassifications = [
-          "fixable",
-          "infrastructure",
-          "pre-existing",
-          "retry",
-          "abort"
-        ];
-        if (validClassifications.includes(data.classification)) {
-          logger.info(`  Diagnosis: ${data.classification} \u2014 ${data.reason}`);
-          return {
-            classification: data.classification,
-            reason: data.reason ?? "Unknown reason",
-            resolution: data.resolution ?? ""
-          };
-        }
-        logger.warn(`  Diagnosis returned invalid classification: ${data.classification}`);
-      } else {
-        logger.warn(`  Diagnosis JSON invalid: ${parseResult.error}`);
+      const parsed = JSON.parse(cleaned);
+      const validClassifications = [
+        "fixable",
+        "infrastructure",
+        "pre-existing",
+        "retry",
+        "abort"
+      ];
+      if (validClassifications.includes(parsed.classification)) {
+        logger.info(`  Diagnosis: ${parsed.classification} \u2014 ${parsed.reason}`);
+        return {
+          classification: parsed.classification,
+          reason: parsed.reason ?? "Unknown reason",
+          resolution: parsed.resolution ?? ""
+        };
       }
     }
   } catch (err) {
     logger.warn(`  Diagnosis error: ${err instanceof Error ? err.message : err}`);
   }
-  logger.warn("  Diagnosis failed \u2014 defaulting to retry");
+  logger.warn("  Diagnosis failed \u2014 defaulting to fixable");
   return {
-    classification: "retry",
-    reason: "Could not diagnose failure \u2014 retrying gate",
+    classification: "fixable",
+    reason: "Could not diagnose failure",
     resolution: errorOutput.slice(-500)
   };
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync10("git", ["diff", "--name-only", "--cached"], {
+    const staged = execFileSync5("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const unstaged = execFileSync10("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync5("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2110,8 +1974,7 @@ function getModifiedFiles(projectDir) {
     const all = `${staged}
 ${unstaged}`.split("\n").filter(Boolean);
     return [...new Set(all)];
-  } catch (err) {
-    logger.warn(`  Failed to get modified files: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
     return [];
   }
 }
@@ -2120,7 +1983,6 @@ var init_observer = __esm({
   "src/observer.ts"() {
     "use strict";
     init_logger();
-    init_validators();
     DIAGNOSIS_PROMPT = `You are a pipeline failure diagnosis agent. Analyze the error and classify it.
 
 Output ONLY valid JSON. No markdown fences. No explanation.
@@ -2144,8 +2006,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs14 from "fs";
-import * as path13 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}`);
@@ -2188,7 +2050,7 @@ ${output}
 `);
     }
   }
-  fs14.writeFileSync(path13.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
@@ -2203,9 +2065,9 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
-import { execFileSync as execFileSync11 } from "child_process";
+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;
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
@@ -2215,8 +2077,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path14.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs15.existsSync(verifyPath) ? fs15.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();
@@ -2259,7 +2121,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync11(parts[0], parts.slice(1), {
+          execFileSync6(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -2312,18 +2174,18 @@ var init_verify = __esm({
 });
 
 // src/cli/task-resolution.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-import { execFileSync as execFileSync12 } from "child_process";
+import * as fs9 from "fs";
+import * as path9 from "path";
+import { execFileSync as execFileSync7 } 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 = path9.join(projectDir, ".kody", "tasks");
+  if (!fs9.existsSync(tasksDir)) return null;
+  const allDirs = fs9.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
   const prefix = `${issueNumber}-`;
   const direct = allDirs.find((d) => d.startsWith(prefix));
   if (direct) return direct;
   try {
-    const branch = execFileSync12("git", ["branch", "--show-current"], {
+    const branch = execFileSync7("git", ["branch", "--show-current"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2352,8 +2214,8 @@ var init_task_resolution = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -2377,8 +2239,8 @@ 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 = path10.join(input.projectDir, ".kody", "tasks", taskId);
+  fs10.mkdirSync(taskDir, { recursive: true });
   const diffInstruction = input.baseBranch ? `
 
 ## Diff Command
@@ -2387,7 +2249,7 @@ Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree chang
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}`;
-  fs17.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
+  fs10.writeFileSync(path10.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2409,10 +2271,10 @@ ${input.prBody ?? ""}${diffInstruction}`;
       error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path16.join(taskDir, "review.md");
+  const reviewPath = path10.join(taskDir, "review.md");
   let reviewContent;
-  if (fs17.existsSync(reviewPath)) {
-    reviewContent = fs17.readFileSync(reviewPath, "utf-8");
+  if (fs10.existsSync(reviewPath)) {
+    reviewContent = fs10.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2451,8 +2313,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -2466,11 +2328,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path17.join(ctx.taskDir, "review.md");
-    if (!fs18.existsSync(reviewFile)) {
+    const reviewFile = path11.join(ctx.taskDir, "review.md");
+    if (!fs11.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs18.readFileSync(reviewFile, "utf-8");
+    const content = fs11.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -2499,15 +2361,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
-import { execFileSync as execFileSync13 } from "child_process";
+import * as fs12 from "fs";
+import * as path12 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-  if (fs19.existsSync(taskJsonPath)) {
+  const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+  if (fs12.existsSync(taskJsonPath)) {
     try {
-      const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs12.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2526,9 +2388,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path18.join(ctx.taskDir, "review.md");
-  if (fs19.existsSync(reviewPath)) {
-    const review = fs19.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path12.join(ctx.taskDir, "review.md");
+  if (fs12.existsSync(reviewPath)) {
+    const review = fs12.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2545,14 +2407,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path18.join(ctx.taskDir, "verify.md");
-  if (fs19.existsSync(verifyPath)) {
-    const verify = fs19.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path12.join(ctx.taskDir, "verify.md");
+  if (fs12.existsSync(verifyPath)) {
+    const verify = fs12.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path18.join(ctx.taskDir, "plan.md");
-  if (fs19.existsSync(planPath)) {
-    const plan = fs19.readFileSync(planPath, "utf-8").trim();
+  const planPath = path12.join(ctx.taskDir, "plan.md");
+  if (fs12.existsSync(planPath)) {
+    const plan = fs12.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2572,25 +2434,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path18.join(ctx.taskDir, "ship.md");
+  const shipPath = path12.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs19.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs12.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) {
-    fs19.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs12.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 {
-      execFileSync13("git", ["add", ctx.taskDir], {
+      execFileSync8("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync13("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync8("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
@@ -2604,7 +2466,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync8("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -2625,28 +2487,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-    if (fs19.existsSync(taskJsonPath)) {
+    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+    if (fs12.existsSync(taskJsonPath)) {
       try {
-        const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs12.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 = path18.join(ctx.taskDir, "task.md");
-    if (fs19.existsSync(taskMdPath)) {
-      const content = fs19.readFileSync(taskMdPath, "utf-8");
+    const taskMdPath = path12.join(ctx.taskDir, "task.md");
+    if (fs12.existsSync(taskMdPath)) {
+      const content = fs12.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 (fs19.existsSync(taskJsonPath)) {
+      if (fs12.existsSync(taskJsonPath)) {
         try {
-          const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs12.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);
@@ -2669,7 +2531,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs19.writeFileSync(shipPath, `# Ship
+      fs12.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2690,26 +2552,22 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs19.writeFileSync(shipPath, `# Ship
+        fs12.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs19.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs12.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 {
-      fs19.writeFileSync(shipPath, `# Ship
+    fs12.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
-    } catch {
-      logger.warn(`  Failed to write ship.md artifact`);
-    }
     return { outcome: "failed", retries: 0, error: msg };
   }
 }
@@ -2752,15 +2610,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path19.join(ctx.taskDir, "task.json");
-      if (!fs20.existsSync(taskJsonPath)) return false;
-      const raw = fs20.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path13.join(ctx.taskDir, "task.json");
+      if (!fs13.existsSync(taskJsonPath)) return false;
+      const raw = fs13.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) {
@@ -2775,9 +2633,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path19.join(ctx.taskDir, "plan.md");
-      if (!fs20.existsSync(planPath)) return false;
-      const plan = fs20.readFileSync(planPath, "utf-8");
+      const planPath = path13.join(ctx.taskDir, "plan.md");
+      if (!fs13.existsSync(planPath)) return false;
+      const plan = fs13.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2806,13 +2664,12 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
   if (def.name === "review") setLifecycleLabel(ctx.input.issueNumber, "review");
-  if (def.name === "ship") setLifecycleLabel(ctx.input.issueNumber, "shipping");
 }
 function checkQuestionsAfterStage(ctx, def, state) {
   if (def.name !== "taskify" && def.name !== "plan") return null;
@@ -2845,9 +2702,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
-    if (!fs21.existsSync(taskJsonPath)) return null;
-    const raw = fs21.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path14.join(ctx.taskDir, "task.json");
+    if (!fs14.existsSync(taskJsonPath)) return null;
+    const raw = fs14.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;
@@ -2877,8 +2734,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 = path20.join(ctx.taskDir, "plan.md");
-  const plan = fs21.existsSync(planPath) ? fs21.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path14.join(ctx.taskDir, "plan.md");
+  const plan = fs14.existsSync(planPath) ? fs14.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2945,22 +2802,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path21.join(ctx.projectDir, ".kody", "memory");
-    if (!fs22.existsSync(memoryDir)) {
-      fs22.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path15.join(ctx.projectDir, ".kody", "memory");
+    if (!fs15.existsSync(memoryDir)) {
+      fs15.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path21.join(ctx.taskDir, "verify.md");
-    if (fs22.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs22.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path15.join(ctx.taskDir, "verify.md");
+    if (fs15.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs15.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");
@@ -2969,18 +2826,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 = path21.join(ctx.taskDir, "review.md");
-    if (fs22.existsSync(reviewPath)) {
-      const review = fs22.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path15.join(ctx.taskDir, "review.md");
+    if (fs15.existsSync(reviewPath)) {
+      const review = fs15.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 = path21.join(ctx.taskDir, "task.json");
-    if (fs22.existsSync(taskJsonPath)) {
+    const taskJsonPath = path15.join(ctx.taskDir, "task.json");
+    if (fs15.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs22.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs15.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)) {
@@ -2991,48 +2848,135 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path21.join(memoryDir, "conventions.md");
+      const conventionsPath = path15.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs22.appendFileSync(conventionsPath, entry);
+      fs15.appendFileSync(conventionsPath, entry);
+      invalidateCache(conventionsPath, path15.join(memoryDir, ".tiers"));
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
+    autoLearnDecisions(ctx.taskDir, memoryDir, ctx.taskId, timestamp2);
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
   } catch {
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path21.join(memoryDir, "architecture.md");
-  if (fs22.existsSync(archPath)) return;
-  const detected = detectArchitectureBasic(projectDir);
+  const archPath = path15.join(memoryDir, "architecture.md");
+  if (fs15.existsSync(archPath)) return;
+  const detected = [];
+  const pkgPath = path15.join(projectDir, "package.json");
+  if (fs15.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs15.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}`);
+      else if (allDeps.express) detected.push(`- Framework: Express ${allDeps.express}`);
+      else if (allDeps.fastify) detected.push(`- Framework: Fastify ${allDeps.fastify}`);
+      if (allDeps.typescript) detected.push(`- Language: TypeScript ${allDeps.typescript}`);
+      if (allDeps.vitest) detected.push(`- Testing: vitest ${allDeps.vitest}`);
+      else if (allDeps.jest) detected.push(`- Testing: jest ${allDeps.jest}`);
+      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
+      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- Database: Prisma ORM");
+      if (allDeps.drizzle || allDeps["drizzle-orm"]) detected.push("- Database: Drizzle ORM");
+      if (allDeps.pg || allDeps.postgres) detected.push("- Database: PostgreSQL");
+      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 (fs15.existsSync(path15.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs15.existsSync(path15.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs15.existsSync(path15.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
+    } catch {
+    }
+  }
+  const topDirs = [];
+  try {
+    const entries = fs15.readdirSync(projectDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        topDirs.push(entry.name);
+      }
+    }
+    if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
+  } catch {
+  }
+  const srcDir = path15.join(projectDir, "src");
+  if (fs15.existsSync(srcDir)) {
+    try {
+      const srcEntries = fs15.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 {
+    }
+  }
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `;
-    fs22.writeFileSync(archPath, content);
+    fs15.writeFileSync(archPath, content);
+    invalidateCache(archPath, path15.join(memoryDir, ".tiers"));
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
+function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
+  const reviewPath = path15.join(taskDir, "review.md");
+  if (!fs15.existsSync(reviewPath)) return;
+  const review = fs15.readFileSync(reviewPath, "utf-8");
+  const decisions = [];
+  const existingPatternRe = /(?:use|follow|reuse|match|adopt)\s+(?:the\s+)?existing\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(existingPatternRe)) {
+    decisions.push(`- Use existing ${match[1].trim()}`);
+  }
+  const insteadOfRe = /instead\s+of\s+(.+?),?\s+(?:use|prefer|adopt)\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(insteadOfRe)) {
+    decisions.push(`- Prefer ${match[2].trim()} over ${match[1].trim()}`);
+  }
+  const consistentRe = /(?:consistent\s+with|same\s+pattern\s+as|follow\s+the\s+pattern\s+(?:in|from))\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(consistentRe)) {
+    decisions.push(`- Follow pattern from ${match[1].trim()}`);
+  }
+  const avoidRe = /(?:don't|do\s+not|never|avoid)\s+(?:use\s+)?(.+?)\s+(?:for|when|in)\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(avoidRe)) {
+    decisions.push(`- Avoid ${match[1].trim()} for ${match[2].trim()}`);
+  }
+  if (decisions.length === 0) return;
+  const decisionsPath = path15.join(memoryDir, "decisions.md");
+  let existing = "";
+  if (fs15.existsSync(decisionsPath)) {
+    existing = fs15.readFileSync(decisionsPath, "utf-8");
+  } else {
+    existing = "# Architectural Decisions\n\nDecisions extracted from code reviews. The planning agent MUST follow these.\n";
+  }
+  const newDecisions = decisions.filter((d) => !existing.includes(d));
+  if (newDecisions.length === 0) return;
+  const entry = `
+## From task ${taskId} (${timestamp2})
+${newDecisions.join("\n")}
+`;
+  fs15.appendFileSync(decisionsPath, existing ? entry : existing + entry);
+  invalidateCache(decisionsPath, path15.join(memoryDir, ".tiers"));
+  logger.info(`Auto-learned ${newDecisions.length} architectural decision(s)`);
+}
 var init_auto_learn = __esm({
   "src/learning/auto-learn.ts"() {
     "use strict";
     init_logger();
-    init_architecture_detection();
+    init_context_tiers();
   }
 });
 
 // src/retrospective.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path22.join(taskDir, filename);
-  if (!fs23.existsSync(p)) return null;
+  const p = path16.join(taskDir, filename);
+  if (!fs16.existsSync(p)) return null;
   try {
-    const content = fs23.readFileSync(p, "utf-8");
+    const content = fs16.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -3085,13 +3029,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path22.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path16.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs23.existsSync(logPath)) return [];
+  if (!fs16.existsSync(logPath)) return [];
   try {
-    const content = fs23.readFileSync(logPath, "utf-8");
+    const content = fs16.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -3118,11 +3062,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path22.dirname(logPath);
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(logPath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs23.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs16.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -3233,8 +3177,8 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
 });
 
 // src/pipeline.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -3247,59 +3191,34 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path23.join(ctx.taskDir, "task.md");
-    const title = fs24.existsSync(taskMdPath) ? fs24.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path17.join(ctx.taskDir, "task.md");
+    const title = fs17.existsSync(taskMdPath) ? fs17.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("not a git repository")) {
-      logger.warn(`  Not a git repository \u2014 skipping feature branch setup`);
-    } else {
-      logger.error(`  Failed to create/sync feature branch: ${msg}`);
-      throw new Error(`Feature branch setup failed: ${msg}`);
-    }
+    logger.warn(`  Failed to create/sync feature branch: ${err}`);
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path23.join(taskDir, ".lock");
-  if (fs24.existsSync(lockPath)) {
+  const lockPath = path17.join(taskDir, ".lock");
+  if (fs17.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs24.readFileSync(lockPath, "utf-8").trim(), 10);
-      if (!isNaN(pid)) {
-        try {
-          process.kill(pid, 0);
-          throw new Error(`Pipeline already running (PID ${pid})`);
-        } catch (e) {
-          if (e.code !== "ESRCH") throw e;
-          logger.info(`  Removing stale lock (PID ${pid} no longer running)`);
-        }
-      } else {
-        logger.warn(`  Corrupt lock file (non-numeric PID) \u2014 overwriting`);
+      const pid = parseInt(fs17.readFileSync(lockPath, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, 0);
+        throw new Error(`Pipeline already running (PID ${pid})`);
+      } catch (e) {
+        if (e.code !== "ESRCH") throw e;
       }
     } catch (e) {
       if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
-      logger.warn(`  Corrupt lock file \u2014 overwriting`);
-    }
-    try {
-      fs24.unlinkSync(lockPath);
-    } catch {
     }
   }
-  try {
-    const fd = fs24.openSync(lockPath, fs24.constants.O_WRONLY | fs24.constants.O_CREAT | fs24.constants.O_EXCL);
-    fs24.writeSync(fd, String(process.pid));
-    fs24.closeSync(fd);
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      throw new Error("Pipeline already running (lock acquired by another process)");
-    }
-    throw err;
-  }
+  fs17.writeFileSync(lockPath, String(process.pid));
 }
 function releaseLock(taskDir) {
   try {
-    fs24.unlinkSync(path23.join(taskDir, ".lock"));
+    fs17.unlinkSync(path17.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3311,17 +3230,17 @@ async function runPipeline(ctx) {
     try {
       const state = loadState(ctx.taskId, ctx.taskDir);
       if (state && state.state === "running") {
-        const updatedStages = { ...state.stages };
+        state.state = "failed";
         for (const stage of STAGES) {
-          if (updatedStages[stage.name]?.state === "running") {
-            updatedStages[stage.name] = {
-              ...updatedStages[stage.name],
+          if (state.stages[stage.name]?.state === "running") {
+            state.stages[stage.name] = {
+              ...state.stages[stage.name],
               state: "failed",
               error: "Pipeline crashed unexpectedly"
             };
           }
         }
-        writeState({ ...state, state: "failed", stages: updatedStages }, ctx.taskDir);
+        writeState(state, ctx.taskDir);
       }
     } catch {
     }
@@ -3446,8 +3365,7 @@ async function runPipelineInner(ctx) {
     }
     autoLearn(ctx);
   }
-  await runRetrospective(ctx, state, pipelineStartTime).catch((err) => {
-    logger.warn(`  Retrospective failed: ${err instanceof Error ? err.message : String(err)}`);
+  await runRetrospective(ctx, state, pipelineStartTime).catch(() => {
   });
   return state;
 }
@@ -3487,8 +3405,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync14 } from "child_process";
-import * as fs25 from "fs";
+import { execFileSync as execFileSync9 } from "child_process";
+import * as fs18 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3500,7 +3418,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync14("claude", ["--version"], {
+      const v = execFileSync9("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3508,14 +3426,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync14("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync9("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync14("pnpm", ["--version"], {
+      const v = execFileSync9("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3523,7 +3441,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync14("node", ["--version"], {
+      const v = execFileSync9("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3533,7 +3451,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync14("gh", ["--version"], {
+      const v = execFileSync9("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3541,7 +3459,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs25.existsSync("package.json")) throw new Error("not found");
+      if (!fs18.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3618,10 +3536,10 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs26 from "fs";
+import * as fs19 from "fs";
 import * as os from "os";
-import * as path24 from "path";
-import { execFileSync as execFileSync15 } from "child_process";
+import * as path18 from "path";
+import { execFileSync as execFileSync10 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -3681,17 +3599,17 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
     logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
     return null;
   }
-  const configPath = path24.join(os.tmpdir(), "kody-litellm-config.yaml");
-  fs26.writeFileSync(configPath, generatedConfig);
+  const configPath = path18.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs19.writeFileSync(configPath, generatedConfig);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
   try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     litellmFound = true;
   } catch {
     try {
-      execFileSync15("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
       litellmFound = true;
     } catch {
     }
@@ -3704,29 +3622,19 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
   let cmd;
   let args2;
   try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     cmd = "litellm";
     args2 = ["--config", configPath, "--port", port];
   } catch {
     cmd = "python3";
     args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-  const dotenvPath = path24.join(projectDir, ".env");
+  const dotenvPath = path18.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs26.existsSync(dotenvPath)) {
-    for (const rawLine of fs26.readFileSync(dotenvPath, "utf-8").split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#")) continue;
+  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) {
-        let value = match[2].trim();
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
-        }
-        const commentIdx = value.indexOf(" #");
-        if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
-        if (value) dotenvVars[match[1]] = value;
-      }
+      if (match) dotenvVars[match[1]] = match[2];
     }
     if (Object.keys(dotenvVars).length > 0) {
       logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
@@ -3765,8 +3673,8 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs27 from "fs";
-import * as path25 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()}` };
@@ -3798,11 +3706,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path25.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path19.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs27.existsSync(statusPath)) {
+    if (fs20.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs27.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs20.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -3835,12 +3743,12 @@ var resolve_exports = {};
 __export(resolve_exports, {
   runResolve: () => runResolve
 });
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function getConflictContext(cwd, files) {
   const parts = [];
   for (const file of files.slice(0, 10)) {
     try {
-      const content = execFileSync16("git", ["diff", file], {
+      const content = execFileSync11("git", ["diff", file], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -3959,8 +3867,8 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!needsLitellmProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
@@ -3989,7 +3897,7 @@ async function ensureLitellmProxy(config, projectDir) {
   process.env.ANTHROPIC_BASE_URL = litellmUrl;
   logger.info(`ANTHROPIC_BASE_URL set to ${litellmUrl}`);
   if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
-    process.env.ANTHROPIC_API_KEY = `sk-ant-api03-${"0".repeat(64)}`;
+    process.env.ANTHROPIC_API_KEY = "sk-ant-api03-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
   }
   return litellmProcess;
 }
@@ -4014,9 +3922,9 @@ async function runModelHealthCheck(config) {
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path26.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path20.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs28.existsSync(projectDir)) {
+    if (!fs21.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -4050,11 +3958,9 @@ async function main() {
       process.exit(0);
     }
     if (taskAction.action === "resume") {
-      Object.assign(input, {
-        taskId: taskAction.taskId,
-        fromStage: taskAction.fromStage,
-        command: "rerun"
-      });
+      input.taskId = taskAction.taskId;
+      input.fromStage = taskAction.fromStage;
+      input.command = "rerun";
       logger.info(`Resuming task ${taskAction.taskId} from ${taskAction.fromStage}`);
     }
   }
@@ -4073,8 +3979,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path26.join(projectDir, ".kody", "tasks", taskId);
-  fs28.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;
@@ -4179,7 +4085,7 @@ async function main() {
       runners: runners2,
       local: input.local ?? true
     });
-    if (litellmProcess2) litellmProcess2.kill();
+    if (litellmProcess2) litellmProcess2.kill?.();
     if (result.outcome === "failed") {
       console.error(`Resolve failed: ${result.error}`);
       process.exit(1);
@@ -4190,31 +4096,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs28.writeFileSync(path26.join(taskDir, "task.md"), input.task);
+    fs21.writeFileSync(path20.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path26.join(taskDir, "task.md");
-  if (!fs28.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 ?? ""}`;
-      fs28.writeFileSync(taskMdPath, taskContent);
+      fs21.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs28.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 ?? ""}`;
-      fs28.writeFileSync(taskMdPath, taskContent);
+      fs21.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs28.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);
   }
@@ -4286,7 +4192,7 @@ ${input.feedback}`);
   await runModelHealthCheck(config);
   const cleanupLitellm = () => {
     if (litellmProcess) {
-      litellmProcess.kill();
+      litellmProcess.kill?.();
       litellmProcess = null;
     }
   };
@@ -4352,7 +4258,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs28.readdirSync(taskDir);
+  const files = fs21.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -4416,21 +4322,20 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
+import { execFileSync as execFileSync12 } from "child_process";
 import { fileURLToPath } from "url";
-
-// src/bin/commands/init.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { execFileSync as execFileSync3 } from "child_process";
-
-// src/bin/health-checks.ts
-import * as fs from "fs";
-import { execFileSync } from "child_process";
-function checkCommand(name, args2, fix) {
+var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path21.resolve(__dirname, "..", "..");
+function getVersion() {
+  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) {
   try {
-    const output = execFileSync(name, args2, {
+    const output = execFileSync12(name, args2, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4441,14 +4346,14 @@ function checkCommand(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs.existsSync(filePath)) {
+  if (fs22.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
 }
 function checkGhAuth(cwd) {
   try {
-    const output = execFileSync("gh", ["auth", "status"], {
+    const output = execFileSync12("gh", ["auth", "status"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4466,7 +4371,7 @@ function checkGhAuth(cwd) {
 }
 function checkGhRepoAccess(cwd) {
   try {
-    const remote = execFileSync("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4477,7 +4382,7 @@ function checkGhRepoAccess(cwd) {
       return { name: "GitHub repo", ok: false, fix: "Set git remote origin to a GitHub URL" };
     }
     const repoSlug = `${match[1]}/${match[2]}`;
-    execFileSync("gh", ["repo", "view", repoSlug, "--json", "name"], {
+    execFileSync12("gh", ["repo", "view", repoSlug, "--json", "name"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4490,7 +4395,7 @@ function checkGhRepoAccess(cwd) {
 }
 function checkGhSecret(repoSlug, secretName) {
   try {
-    const output = execFileSync("gh", ["secret", "list", "--repo", repoSlug], {
+    const output = execFileSync12("gh", ["secret", "list", "--repo", repoSlug], {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4511,20 +4416,14 @@ function checkGhSecret(repoSlug, secretName) {
     };
   }
 }
-
-// src/bin/config-detection.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-var FRONTEND_DEPS = ["next", "react", "vue", "svelte", "nuxt", "astro", "solid-js", "angular", "@angular/core"];
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs2.existsSync(path.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs2.existsSync(path.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs2.existsSync(path.join(cwd, "pnpm-lock.yaml")) && fs2.existsSync(path.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 = execFileSync2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync12("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4533,7 +4432,7 @@ function detectBasicConfig(cwd) {
     defaultBranch = ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      execFileSync2("git", ["rev-parse", "--verify", "origin/dev"], {
+      execFileSync12("git", ["rev-parse", "--verify", "origin/dev"], {
         encoding: "utf-8",
         timeout: 5e3,
         cwd,
@@ -4546,7 +4445,7 @@ function detectBasicConfig(cwd) {
   let owner = "";
   let repo = "";
   try {
-    const remote = execFileSync2("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4564,7 +4463,7 @@ function detectBasicConfig(cwd) {
 function buildConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs2.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -4596,6 +4495,7 @@ function buildConfig(cwd, basic) {
   if (mcp) config.mcp = mcp;
   return config;
 }
+var FRONTEND_DEPS = ["next", "react", "vue", "svelte", "nuxt", "astro", "solid-js", "angular", "@angular/core"];
 function detectMcpConfig(cwd, pm, pkg) {
   const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const hasFrontend = FRONTEND_DEPS.some((dep) => dep in allDeps);
@@ -4607,7 +4507,12 @@ function detectMcpConfig(cwd, pm, pkg) {
   const defaultPort = isNext ? 3e3 : isVite ? 5173 : 3e3;
   const mcp = {
     enabled: true,
-    servers: {},
+    servers: {
+      playwright: {
+        command: "npx",
+        args: ["@playwright/mcp@latest"]
+      }
+    },
     stages: ["build", "review"]
   };
   if (hasDevScript) {
@@ -4618,9 +4523,7 @@ function detectMcpConfig(cwd, pm, pkg) {
   }
   return mcp;
 }
-
-// src/bin/commands/init.ts
-function initCommand(opts, pkgRoot) {
+function initCommand(opts) {
   const cwd = process.cwd();
   console.log(`
 \u{1F527} Kody Engine Lite \u2014 Init
@@ -4628,35 +4531,35 @@ function initCommand(opts, pkgRoot) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path2.join(pkgRoot, "templates");
+  const templatesDir = path21.join(PKG_ROOT, "templates");
   const basic = detectBasicConfig(cwd);
-  const workflowSrc = path2.join(templatesDir, "kody.yml");
-  const workflowDest = path2.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs3.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 (fs3.existsSync(workflowDest) && !opts.force) {
+  if (fs22.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs3.mkdirSync(path2.dirname(workflowDest), { recursive: true });
-    fs3.copyFileSync(workflowSrc, workflowDest);
+    fs22.mkdirSync(path21.dirname(workflowDest), { recursive: true });
+    fs22.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path2.join(cwd, "kody.config.json");
-  if (!fs3.existsSync(configDest) || opts.force) {
+  const configDest = path21.join(cwd, "kody.config.json");
+  if (!fs22.existsSync(configDest) || opts.force) {
     const config = buildConfig(cwd, basic);
-    fs3.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 = path2.join(cwd, ".gitignore");
-  if (fs3.existsSync(gitignorePath)) {
-    const content = fs3.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");
-      fs3.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)");
@@ -4664,10 +4567,10 @@ function initCommand(opts, pkgRoot) {
   }
   console.log("\n\u2500\u2500 Prerequisites \u2500\u2500");
   const checks = [
-    checkCommand("gh", ["--version"], "Install: https://cli.github.com"),
-    checkCommand("git", ["--version"], "Install git"),
-    checkCommand("node", ["--version"], "Install Node.js >= 22"),
-    checkFile(path2.join(cwd, "package.json"), "package.json", `Run: ${basic.pm} init`)
+    checkCommand2("gh", ["--version"], "Install: https://cli.github.com"),
+    checkCommand2("git", ["--version"], "Install git"),
+    checkCommand2("node", ["--version"], "Install Node.js >= 22"),
+    checkFile(path21.join(cwd, "package.json"), "package.json", `Run: ${basic.pm} init`)
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -4681,19 +4584,26 @@ function initCommand(opts, pkgRoot) {
   console.log(ghAuth.ok ? `  \u2713 ${ghAuth.name} (${ghAuth.detail})` : `  \u2717 ${ghAuth.name} \u2014 ${ghAuth.fix}`);
   const ghRepo = checkGhRepoAccess(cwd);
   console.log(ghRepo.ok ? `  \u2713 ${ghRepo.name} (${ghRepo.detail})` : `  \u2717 ${ghRepo.name} \u2014 ${ghRepo.fix}`);
+  let repoSlug = "";
   if (ghRepo.ok && ghRepo.detail) {
-    const repoSlug = ghRepo.detail;
-    const secretChecks = [checkGhSecret(repoSlug, "ANTHROPIC_API_KEY")];
+    repoSlug = ghRepo.detail;
+    const secretChecks = [
+      checkGhSecret(repoSlug, "ANTHROPIC_API_KEY")
+    ];
     for (const c of secretChecks) {
-      console.log(c.ok ? `  \u2713 ${c.name}` : `  \u2717 ${c.name} \u2014 ${c.fix}`);
+      if (c.ok) {
+        console.log(`  \u2713 ${c.name}`);
+      } else {
+        console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
+      }
     }
     console.log("\n\u2500\u2500 Labels \u2500\u2500");
     console.log("  \u25CB Labels will be created automatically during bootstrap");
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs3.existsSync(configDest)) {
+  if (fs22.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs3.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}` });
@@ -4723,11 +4633,11 @@ function initCommand(opts, pkgRoot) {
   const filesToCommit = [
     ".github/workflows/kody.yml",
     "kody.config.json"
-  ].filter((f) => fs3.existsSync(path2.join(cwd, f)));
+  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path2.join(cwd, f));
-      execFileSync3("npx", ["prettier", "--write", ...fullPaths], {
+      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
+      execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
         cwd,
         encoding: "utf-8",
         timeout: 3e4,
@@ -4738,13 +4648,13 @@ function initCommand(opts, pkgRoot) {
   }
   if (filesToCommit.length > 0) {
     try {
-      execFileSync3("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-      const staged = execFileSync3("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+      execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+      const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
       if (staged) {
-        execFileSync3("git", ["commit", "-m", "chore: Add Kody Engine workflow and config\n\nAdd GitHub Actions workflow and auto-detected configuration for Kody Engine Lite."], { cwd, stdio: "pipe" });
+        execFileSync12("git", ["commit", "-m", "chore: Add Kody Engine workflow and config\n\nAdd GitHub Actions workflow and auto-detected configuration for Kody Engine Lite."], { cwd, stdio: "pipe" });
         console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
         try {
-          execFileSync3("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log("  \u2713 Pushed to origin");
         } catch {
           console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -4786,300 +4696,22 @@ function initCommand(opts, pkgRoot) {
     console.log("");
   }
 }
-
-// src/bin/commands/bootstrap.ts
-init_architecture_detection();
-import * as fs7 from "fs";
-import * as path6 from "path";
-import { execFileSync as execFileSync5 } from "child_process";
-
-// src/bin/qa-guide.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
-function discoverQaContext(cwd) {
-  const result = {
-    routes: [],
-    authFiles: [],
-    loginPage: null,
-    adminPath: null,
-    roles: [],
-    devCommand: "",
-    devPort: 3e3
-  };
-  try {
-    const pkg = JSON.parse(fs5.readFileSync(path4.join(cwd, "package.json"), "utf-8"));
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs5.existsSync(path4.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs5.existsSync(path4.join(cwd, "yarn.lock")) ? "yarn" : "npm";
-    if (pkg.scripts?.dev) result.devCommand = `${pm} dev`;
-    if (allDeps.next || allDeps.nuxt) result.devPort = 3e3;
-    else if (allDeps.vite) result.devPort = 5173;
-  } catch {
-  }
-  const appDirs = ["src/app", "app"];
-  for (const appDir of appDirs) {
-    const fullAppDir = path4.join(cwd, appDir);
-    if (!fs5.existsSync(fullAppDir)) continue;
-    scanRoutes(fullAppDir, appDir, "", result);
-    break;
-  }
-  const authPatterns = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js"];
-  for (const p of authPatterns) {
-    if (fs5.existsSync(path4.join(cwd, p))) result.authFiles.push(p);
-  }
-  const authConfigGlobs = [
-    "src/app/api/auth",
-    "src/auth",
-    "src/lib/auth",
-    "auth.config.ts",
-    "auth.ts",
-    "src/app/api/oauth"
-  ];
-  for (const g of authConfigGlobs) {
-    if (fs5.existsSync(path4.join(cwd, g))) result.authFiles.push(g);
-  }
-  try {
-    const rolePaths = [
-      "src/types",
-      "src/lib",
-      "src/utils",
-      "src/constants",
-      "src/access",
-      "src/collections"
-    ];
-    for (const rp of rolePaths) {
-      const dir = path4.join(cwd, rp);
-      if (!fs5.existsSync(dir)) continue;
-      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
-      for (const f of files) {
-        try {
-          const content = fs5.readFileSync(path4.join(dir, f), "utf-8").slice(0, 5e3);
-          const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
-          if (roleMatches) {
-            for (const m of roleMatches) {
-              const val = m.match(/['"](\w+)['"]/);
-              if (val && !result.roles.includes(val[1])) result.roles.push(val[1]);
-            }
-          }
-          const enumMatch = content.match(/(?:enum|type)\s+\w*[Rr]ole\w*\s*[={]([^}]+)/s);
-          if (enumMatch) {
-            const vals = enumMatch[1].match(/['"](\w+)['"]/g);
-            if (vals) {
-              for (const v of vals) {
-                const clean = v.replace(/['"]/g, "");
-                if (!result.roles.includes(clean)) result.roles.push(clean);
-              }
-            }
-          }
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-function scanRoutes(dir, baseDir, prefix, result) {
-  let entries;
-  try {
-    entries = fs5.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  const hasPage = entries.some((e) => e.isFile() && /^page\.(tsx?|jsx?)$/.test(e.name));
-  if (hasPage) {
-    const routePath = prefix || "/";
-    const group = prefix.startsWith("/admin") ? "admin" : prefix.includes("/login") ? "auth" : prefix.includes("/signup") ? "auth" : prefix.includes("/api") ? "api" : "frontend";
-    result.routes.push({ path: routePath, group });
-    if (prefix.includes("/login")) result.loginPage = routePath;
-    if (prefix.startsWith("/admin") && !result.adminPath) result.adminPath = prefix;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (entry.name === "node_modules" || entry.name === ".next") continue;
-    let segment = entry.name;
-    if (segment.startsWith("(") && segment.endsWith(")")) {
-      scanRoutes(path4.join(dir, entry.name), baseDir, prefix, result);
-      continue;
-    }
-    if (segment.startsWith("[") && segment.endsWith("]")) {
-      segment = `:${segment.slice(1, -1)}`;
-    }
-    if (segment.startsWith("[[") && segment.endsWith("]]")) {
-      segment = `:${segment.slice(2, -2)}?`;
-    }
-    scanRoutes(path4.join(dir, entry.name), baseDir, `${prefix}/${segment}`, result);
-  }
-}
-function generateQaGuide(discovery) {
-  const lines = ["# QA Guide", "", "## Authentication", ""];
-  if (discovery.loginPage) {
-    lines.push(`- Login page: \`${discovery.loginPage}\``);
-  }
-  lines.push(
-    "",
-    "### Test Accounts",
-    "<!-- Fill in your test/preview environment credentials below -->",
-    "| Role | Email | Password |",
-    "|------|-------|----------|",
-    "| Admin | admin@example.com | CHANGE_ME |",
-    "| User | user@example.com | CHANGE_ME |",
-    "",
-    "### Login Steps",
-    `1. Navigate to \`${discovery.loginPage ?? "/login"}\``,
-    "2. Enter credentials from the test accounts table above",
-    "3. Submit the login form",
-    "4. Verify redirect to dashboard or home page"
-  );
-  if (discovery.authFiles.length > 0) {
-    lines.push("", "### Auth Files");
-    for (const f of discovery.authFiles) {
-      lines.push(`- \`${f}\``);
-    }
-  }
-  if (discovery.roles.length > 0) {
-    lines.push("", "## Roles", "");
-    for (const role of discovery.roles) {
-      lines.push(`- \`${role}\``);
-    }
-  }
-  lines.push("", "## Key Pages", "");
-  const groups = {};
-  for (const route of discovery.routes) {
-    if (!groups[route.group]) groups[route.group] = [];
-    groups[route.group].push(route.path);
-  }
-  for (const [group, routes] of Object.entries(groups)) {
-    lines.push(`### ${group.charAt(0).toUpperCase() + group.slice(1)}`);
-    const sorted = routes.sort();
-    for (const r of sorted.slice(0, 20)) {
-      lines.push(`- \`${r}\``);
-    }
-    if (sorted.length > 20) {
-      lines.push(`- ... and ${sorted.length - 20} more`);
-    }
-    lines.push("");
-  }
-  lines.push(
-    "## Dev Server",
-    "",
-    `- Command: \`${discovery.devCommand || "pnpm dev"}\``,
-    `- URL: \`http://localhost:${discovery.devPort}\``,
-    ""
-  );
-  return lines.join("\n");
-}
-
-// src/bin/skills.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
-import { execFileSync as execFileSync4 } from "child_process";
-var SKILL_MAPPINGS = [
-  {
-    detect: (deps) => "next" in deps,
-    skills: [
-      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
-    ]
-  },
-  {
-    detect: (deps) => "react" in deps && !("next" in deps),
-    skills: [
-      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
-    ]
-  },
-  {
-    detect: (deps) => FRONTEND_DEPS.some((d) => d in deps),
-    skills: [
-      { package: "microsoft/playwright-cli@playwright-cli", label: "Playwright browser automation" }
-    ]
-  }
-];
-function detectSkillsForProject(cwd) {
-  const pkgPath = path5.join(cwd, "package.json");
-  if (!fs6.existsSync(pkgPath)) return [];
-  try {
-    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const seen = /* @__PURE__ */ new Set();
-    const skills = [];
-    for (const mapping of SKILL_MAPPINGS) {
-      if (mapping.detect(allDeps)) {
-        for (const skill of mapping.skills) {
-          if (!seen.has(skill.package)) {
-            seen.add(skill.package);
-            skills.push(skill);
-          }
-        }
-      }
-    }
-    return skills;
-  } catch {
-    return [];
-  }
-}
-function installSkillsForProject(cwd) {
-  const skills = detectSkillsForProject(cwd);
-  if (skills.length === 0) {
-    console.log("  \u25CB No skills to install (no frontend framework detected)");
-    return [];
-  }
-  let installedSkills = {};
-  const lockPath = path5.join(cwd, "skills-lock.json");
-  if (fs6.existsSync(lockPath)) {
-    try {
-      const lock = JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
-      installedSkills = lock.skills ?? {};
-    } catch {
-    }
-  }
-  const installedPaths = [];
-  for (const skill of skills) {
-    const skillName = skill.package.split("@").pop() ?? "";
-    if (skillName in installedSkills) {
-      console.log(`  \u25CB ${skill.label} \u2014 already installed`);
-      const agentPath = `.agents/skills/${skillName}`;
-      const claudePath = `.claude/skills/${skillName}`;
-      if (fs6.existsSync(path5.join(cwd, agentPath))) installedPaths.push(agentPath);
-      if (fs6.existsSync(path5.join(cwd, claudePath))) installedPaths.push(claudePath);
-      continue;
-    }
-    try {
-      console.log(`  Installing: ${skill.label} (${skill.package})`);
-      execFileSync4("npx", ["skills", "add", skill.package, "--yes"], {
-        cwd,
-        encoding: "utf-8",
-        timeout: 6e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const installedName = skill.package.split("@").pop() ?? "";
-      const agentPath = `.agents/skills/${installedName}`;
-      const claudePath = `.claude/skills/${installedName}`;
-      if (fs6.existsSync(path5.join(cwd, agentPath))) installedPaths.push(agentPath);
-      if (fs6.existsSync(path5.join(cwd, claudePath))) installedPaths.push(claudePath);
-      console.log(`  \u2713 ${skill.label}`);
-    } catch {
-      console.log(`  \u2717 ${skill.label} \u2014 failed to install`);
-    }
-  }
-  return installedPaths;
-}
-
-// src/bin/commands/bootstrap.ts
 var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path6.join(cwd, "src");
-  const baseDir = fs7.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 fs7.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path6.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 = fs7.statSync(full);
+            const stat = fs22.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -5093,8 +4725,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 = path6.relative(cwd, filePath);
-    const content = fs7.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}
@@ -5106,9 +4738,9 @@ function ghComment(issueNumber, body, cwd) {
   try {
     let repoSlug = "";
     try {
-      const configPath = path6.join(cwd, "kody.config.json");
-      if (fs7.existsSync(configPath)) {
-        const config = JSON.parse(fs7.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}`;
         }
@@ -5116,7 +4748,7 @@ function ghComment(issueNumber, body, cwd) {
     } catch {
     }
     if (!repoSlug) return;
-    execFileSync5("gh", [
+    execFileSync12("gh", [
       "issue",
       "comment",
       String(issueNumber),
@@ -5133,7 +4765,7 @@ function ghComment(issueNumber, body, cwd) {
   } catch {
   }
 }
-function bootstrapCommand(opts, pkgRoot) {
+function bootstrapCommand(opts = { force: false }) {
   const cwd = process.cwd();
   const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
   console.log(`
@@ -5143,8 +4775,8 @@ function bootstrapCommand(opts, pkgRoot) {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path6.join(cwd, rel);
-    if (fs7.existsSync(p)) return fs7.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 = "";
@@ -5179,14 +4811,14 @@ ${sampleFiles}
 
 `;
   try {
-    const topDirs = fs7.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 = path6.join(cwd, "src");
-    if (fs7.existsSync(srcDir)) {
-      const srcDirs = fs7.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(", ")}
 
@@ -5196,19 +4828,19 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs7.existsSync(path6.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 = path6.join(cwd, ".kody", "memory");
-  fs7.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path6.join(memoryDir, "architecture.md");
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  const existingArch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
-  const existingConv = fs7.existsSync(conventionsPath) ? fs7.readFileSync(conventionsPath, "utf-8") : "";
+  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 existingArch = fs22.existsSync(archPath) ? fs22.readFileSync(archPath, "utf-8") : "";
+  const existingConv = fs22.existsSync(conventionsPath) ? fs22.readFileSync(conventionsPath, "utf-8") : "";
   const hasExisting = !!(existingArch || existingConv);
   const extendInstruction = hasExisting && !opts.force ? `
 ## Existing Documentation (EXTEND, do not replace)
@@ -5249,7 +4881,7 @@ Output ONLY valid JSON. No markdown fences. No explanation.
 ${repoContext}`;
   console.log("  \u23F3 Analyzing project...");
   try {
-    const output = execFileSync5("claude", [
+    const output = execFileSync12("claude", [
       "--print",
       "--model",
       "haiku",
@@ -5264,12 +4896,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs7.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) {
-      fs7.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)`);
     }
@@ -5278,39 +4910,39 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs7.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)`);
     }
-    fs7.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 = path6.join(cwd, ".kody", "steps");
-  fs7.mkdirSync(stepsDir, { recursive: true });
-  const arch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
-  const conv = fs7.existsSync(conventionsPath) ? fs7.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 = path6.join(pkgRoot, "prompts", `${stage}.md`);
-    if (!fs7.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 stepOutputPath = path6.join(stepsDir, `${stage}.md`);
-    if (fs7.existsSync(stepOutputPath) && !opts.force) {
+    const stepOutputPath = path21.join(stepsDir, `${stage}.md`);
+    if (fs22.existsSync(stepOutputPath) && !opts.force) {
       console.log(`  \u25CB ${stage}.md \u2014 already exists (use --force to regenerate)`);
       continue;
     }
-    const defaultPrompt = fs7.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs22.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs7.copyFileSync(templatePath, stepOutputPath);
+      fs22.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -5352,7 +4984,7 @@ ${repoContext}
 
 REMINDER: Output the full prompt template first (unchanged), then your three appended sections. Do NOT include "${contextPlaceholder}".`;
     try {
-      const output = execFileSync5("claude", [
+      const output = execFileSync12("claude", [
         "--print",
         "--model",
         "haiku",
@@ -5367,40 +4999,23 @@ 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;
-      fs7.writeFileSync(stepOutputPath, finalPrompt);
+      fs22.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs7.copyFileSync(templatePath, stepOutputPath);
+      fs22.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
     }
   }
   console.log(`  \u2713 Generated ${stepCount} step files in .kody/steps/`);
-  console.log("\n\u2500\u2500 QA Guide \u2500\u2500");
-  const qaGuidePath = path6.join(cwd, ".kody", "qa-guide.md");
-  if (!fs7.existsSync(qaGuidePath) || opts.force) {
-    const discovery = discoverQaContext(cwd);
-    if (discovery.routes.length > 0) {
-      const qaGuide = generateQaGuide(discovery);
-      fs7.writeFileSync(qaGuidePath, qaGuide);
-      console.log(`  \u2713 .kody/qa-guide.md (${discovery.routes.length} routes, ${discovery.roles.length} roles)`);
-      if (discovery.loginPage) console.log(`  \u2713 Login page detected: ${discovery.loginPage}`);
-      if (discovery.adminPath) console.log(`  \u2713 Admin panel detected: ${discovery.adminPath}`);
-      console.log("  \u2139 Add QA_ADMIN_EMAIL, QA_ADMIN_PASSWORD, QA_USER_EMAIL, QA_USER_PASSWORD as GitHub secrets");
-    } else {
-      console.log("  \u25CB No routes detected \u2014 skipping QA guide");
-    }
-  } else {
-    console.log("  \u25CB .kody/qa-guide.md already exists (use --force to regenerate)");
-  }
   console.log("\n\u2500\u2500 Labels \u2500\u2500");
   try {
     let repoSlug = "";
     try {
-      const configPath = path6.join(cwd, "kody.config.json");
-      if (fs7.existsSync(configPath)) {
-        const config = JSON.parse(fs7.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}`;
         }
@@ -5412,7 +5027,6 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
         { name: "kody:planning", color: "c5def5", description: "Kody is analyzing and planning" },
         { name: "kody:building", color: "0e8a16", description: "Kody is building code" },
         { name: "kody:review", color: "fbca04", description: "Kody is reviewing code" },
-        { name: "kody:shipping", color: "1d76db", description: "Kody is creating the pull request" },
         { name: "kody:done", color: "0e8a16", description: "Kody completed successfully" },
         { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" },
         { name: "kody:waiting", color: "fef2c0", description: "Kody is waiting for answers" },
@@ -5427,7 +5041,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       ];
       for (const label of labels) {
         try {
-          execFileSync5("gh", [
+          execFileSync12("gh", [
             "label",
             "create",
             label.name,
@@ -5447,7 +5061,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 ${label.name}`);
         } catch {
           try {
-            execFileSync5("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+            execFileSync12("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
               cwd,
               encoding: "utf-8",
               timeout: 1e4,
@@ -5471,23 +5085,22 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   const filesToCommit = [
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md",
-    ".kody/qa-guide.md",
     ...installedSkillPaths
-  ].filter((f) => fs7.existsSync(path6.join(cwd, f)));
-  if (fs7.existsSync(path6.join(cwd, "skills-lock.json"))) {
+  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
+  if (fs22.existsSync(path21.join(cwd, "skills-lock.json"))) {
     filesToCommit.push("skills-lock.json");
   }
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs7.existsSync(path6.join(cwd, stepFile))) {
+    if (fs22.existsSync(path21.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path6.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
-        execFileSync5("npx", ["prettier", "--write", ...fullPaths], {
+        execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
           encoding: "utf-8",
           timeout: 3e4,
@@ -5503,24 +5116,24 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     try {
       if (isCI3) {
         const branchName = `kody-bootstrap-${Date.now()}`;
-        execFileSync5("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
-        execFileSync5("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync5("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync12("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
+        execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync5("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
-          execFileSync5("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync12("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync12("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path6.join(cwd, "kody.config.json");
-            if (fs7.existsSync(configPath)) {
-              const config = JSON.parse(fs7.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 {
           }
           try {
-            const prUrl = execFileSync5("gh", [
+            const prUrl = execFileSync12("gh", [
               "pr",
               "create",
               "--title",
@@ -5559,13 +5172,13 @@ Create it manually.`, cwd);
           console.log("  \u25CB No new changes to commit");
         }
       } else {
-        execFileSync5("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync5("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync5("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync12("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
           console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
           try {
-            execFileSync5("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+            execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
             console.log("  \u2713 Pushed to origin");
           } catch {
             console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -5585,22 +5198,131 @@ Create it manually.`, cwd);
   console.log("  \u2713 Project bootstrap complete!");
   console.log("  Kody now has project-specific memory and customized step files.\n");
 }
-
-// src/bin/cli.ts
-init_architecture_detection();
-var __dirname = path27.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path27.resolve(__dirname, "..", "..");
-function getVersion() {
-  const pkgPath = path27.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs29.readFileSync(pkgPath, "utf-8"));
-  return pkg.version;
+function detectArchitectureBasic(cwd) {
+  const detected = [];
+  const pkgPath = path21.join(cwd, "package.json");
+  if (fs22.existsSync(pkgPath)) {
+    try {
+      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}`);
+      else if (allDeps.express) detected.push(`- Framework: Express ${allDeps.express}`);
+      else if (allDeps.fastify) detected.push(`- Framework: Fastify ${allDeps.fastify}`);
+      else if (allDeps.hono) detected.push(`- Framework: Hono ${allDeps.hono}`);
+      if (allDeps.typescript) detected.push(`- Language: TypeScript ${allDeps.typescript}`);
+      if (allDeps.vitest) detected.push(`- Testing: vitest ${allDeps.vitest}`);
+      else if (allDeps.jest) detected.push(`- Testing: jest ${allDeps.jest}`);
+      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
+      if (allDeps.prettier) detected.push(`- Formatting: prettier ${allDeps.prettier}`);
+      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- ORM: Prisma");
+      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 (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 {
+    }
+  }
+  return detected;
+}
+var SKILL_MAPPINGS = [
+  {
+    detect: (deps) => "next" in deps,
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => "react" in deps && !("next" in deps),
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => FRONTEND_DEPS.some((d) => d in deps),
+    skills: [
+      { package: "microsoft/playwright-cli@playwright-cli", label: "Playwright browser automation" }
+    ]
+  }
+];
+function detectSkillsForProject(cwd) {
+  const pkgPath = path21.join(cwd, "package.json");
+  if (!fs22.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    for (const mapping of SKILL_MAPPINGS) {
+      if (mapping.detect(allDeps)) {
+        for (const skill of mapping.skills) {
+          if (!seen.has(skill.package)) {
+            seen.add(skill.package);
+            skills.push(skill);
+          }
+        }
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function installSkillsForProject(cwd) {
+  const skills = detectSkillsForProject(cwd);
+  if (skills.length === 0) {
+    console.log("  \u25CB No skills to install (no frontend framework detected)");
+    return [];
+  }
+  let installedSkills = {};
+  const lockPath = path21.join(cwd, "skills-lock.json");
+  if (fs22.existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(fs22.readFileSync(lockPath, "utf-8"));
+      installedSkills = lock.skills ?? {};
+    } catch {
+    }
+  }
+  const installedPaths = [];
+  for (const skill of skills) {
+    const skillName = skill.package.split("@").pop() ?? "";
+    if (skillName in installedSkills) {
+      console.log(`  \u25CB ${skill.label} \u2014 already installed`);
+      const agentPath = `.agents/skills/${skillName}`;
+      const claudePath = `.claude/skills/${skillName}`;
+      if (fs22.existsSync(path21.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs22.existsSync(path21.join(cwd, claudePath))) installedPaths.push(claudePath);
+      continue;
+    }
+    try {
+      console.log(`  Installing: ${skill.label} (${skill.package})`);
+      execFileSync12("npx", ["skills", "add", skill.package, "--yes"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const skillName2 = skill.package.split("@").pop() ?? "";
+      const agentPath = `.agents/skills/${skillName2}`;
+      const claudePath = `.claude/skills/${skillName2}`;
+      if (fs22.existsSync(path21.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs22.existsSync(path21.join(cwd, claudePath))) installedPaths.push(claudePath);
+      console.log(`  \u2713 ${skill.label}`);
+    } catch (err) {
+      console.log(`  \u2717 ${skill.label} \u2014 failed to install`);
+    }
+  }
+  return installedPaths;
 }
 var args = process.argv.slice(2);
 var command = args[0];
 if (command === "init") {
-  initCommand({ force: args.includes("--force") }, PKG_ROOT);
+  initCommand({ force: args.includes("--force") });
 } else if (command === "bootstrap") {
-  bootstrapCommand({ force: args.includes("--force") }, PKG_ROOT);
+  bootstrapCommand({ force: args.includes("--force") });
 } else if (command === "version" || command === "--version" || command === "-v") {
   console.log(getVersion());
 } else {
@@ -5608,7 +5330,7 @@ if (command === "init") {
 }
 export {
   buildConfig,
-  checkCommand,
+  checkCommand2 as checkCommand,
   checkFile,
   checkGhAuth,
   checkGhRepoAccess,