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

package/dist/bin/cli.js

@@ -9,8 +9,63 @@ 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 } from "child_process";
+import { spawn, execFileSync as execFileSync6 } from "child_process";
 function writeStdin(child, prompt) {
   return new Promise((resolve4, reject) => {
     if (!child.stdin) {
@@ -82,9 +137,9 @@ async function runSubprocess(command2, args2, prompt, timeout, options) {
 ${errDetail}`
   };
 }
-function checkCommand(command2, args2) {
+function checkCommand2(command2, args2) {
   try {
-    execFileSync(command2, args2, { timeout: 1e4, stdio: "pipe" });
+    execFileSync6(command2, args2, { timeout: 1e4, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -114,7 +169,7 @@ function createClaudeCodeRunner() {
       return runSubprocess("claude", args2, prompt, timeout, options);
     },
     async healthCheck() {
-      return checkCommand("claude", ["--version"]);
+      return checkCommand2("claude", ["--version"]);
     }
   };
 }
@@ -271,9 +326,77 @@ 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 fs from "fs";
-import * as path from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 function needsLitellmProxy(config) {
   return !!(config.agent.provider && config.agent.provider !== "anthropic");
 }
@@ -290,10 +413,16 @@ function setConfigDir(dir) {
 }
 function getProjectConfig() {
   if (_config) return _config;
-  const configPath = path.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs.existsSync(configPath)) {
+  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs8.existsSync(configPath)) {
     try {
-      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      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;
       _config = {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
@@ -327,6 +456,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
+    init_validators();
     DEFAULT_CONFIG = {
       quality: {
         typecheck: "pnpm -s tsc --noEmit",
@@ -360,7 +490,7 @@ var init_config = __esm({
 });
 
 // src/git-utils.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 function getHookSafeEnv() {
   if (!_hookSafeEnv) {
     _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
@@ -368,7 +498,7 @@ function getHookSafeEnv() {
   return _hookSafeEnv;
 }
 function git(args2, options) {
-  return execFileSync2("git", args2, {
+  return execFileSync7("git", args2, {
     encoding: "utf-8",
     timeout: options?.timeout ?? 3e4,
     cwd: options?.cwd,
@@ -423,8 +553,9 @@ function ensureFeatureBranch(issueNumber, title, cwd) {
   }
   try {
     git(["fetch", "origin"], { cwd, timeout: 3e4 });
-  } catch {
-    logger.warn("  Failed to fetch origin");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch origin: ${msg}`);
   }
   try {
     git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
@@ -456,8 +587,9 @@ function syncWithDefault(cwd, branch) {
   if (current === defaultBranch) return;
   try {
     git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
-  } catch {
-    logger.warn("  Failed to fetch latest from origin");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
     return;
   }
   try {
@@ -466,7 +598,8 @@ function syncWithDefault(cwd, branch) {
   } catch {
     try {
       git(["merge", "--abort"], { cwd });
-    } catch {
+    } catch (abortErr) {
+      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
     }
     logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
   }
@@ -477,8 +610,9 @@ function mergeDefault(cwd) {
   if (current === defaultBranch) return "clean";
   try {
     git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
-  } catch {
-    logger.warn("  Failed to fetch latest from origin");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
     return "error";
   }
   try {
@@ -493,7 +627,8 @@ function mergeDefault(cwd) {
     }
     try {
       git(["merge", "--abort"], { cwd });
-    } catch {
+    } catch (abortErr) {
+      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
     }
     return "error";
   }
@@ -538,7 +673,21 @@ var init_git_utils = __esm({
 });
 
 // src/github-api.ts
-import { execFileSync as execFileSync3 } from "child_process";
+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");
+}
 function setGhCwd(cwd) {
   _ghCwd = cwd;
 }
@@ -548,7 +697,7 @@ function ghToken() {
 function gh(args2, options) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync3("gh", args2, {
+  return execFileSync8("gh", args2, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd: _ghCwd,
@@ -566,9 +715,18 @@ function getIssue(issueNumber) {
       "--json",
       "body,title"
     ]);
-    return JSON.parse(output);
+    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 };
   } catch (err) {
-    logger.error(`  Failed to get issue #${issueNumber}: ${err}`);
+    if (isNotFoundError(err)) {
+      logger.info(`  Issue #${issueNumber} not found`);
+    } else {
+      logger.error(`  Failed to get issue #${issueNumber}: ${ghErrorMessage(err)}`);
+    }
     return null;
   }
 }
@@ -609,8 +767,15 @@ 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 {
+  } catch (err) {
+    if (!isNotFoundError(err)) {
+      logger.warn(`  Failed to check PR for branch ${branch}: ${ghErrorMessage(err)}`);
+    }
     return null;
   }
 }
@@ -648,8 +813,7 @@ function createPR(head, base, title, body) {
     logger.info(`  PR created: ${url}`);
     return { number, url };
   } catch (err) {
-    const stderr = err?.stderr?.toString().trim();
-    const reason = stderr || (err instanceof Error ? err.message : String(err));
+    const reason = ghErrorMessage(err);
     logger.error(`  Failed to create PR: ${reason}`);
     return null;
   }
@@ -720,9 +884,22 @@ function getPRDetails(prNumber) {
       "title,body,headRefName,baseRefName"
     ]);
     const data = JSON.parse(output);
-    return { title: data.title, body: data.body, headBranch: data.headRefName, baseBranch: data.baseRefName };
+    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"
+    };
   } catch (err) {
-    logger.error(`  Failed to get PR #${prNumber}: ${err}`);
+    if (isNotFoundError(err)) {
+      logger.info(`  PR #${prNumber} not found`);
+    } else {
+      logger.error(`  Failed to get PR #${prNumber}: ${ghErrorMessage(err)}`);
+    }
     return null;
   }
 }
@@ -764,7 +941,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}: ${err}`);
+    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${ghErrorMessage(err)}`);
     return null;
   }
 }
@@ -786,7 +963,7 @@ function getLatestFailedRunForBranch(branch) {
     ]);
     return output.trim() || null;
   } catch (err) {
-    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${err}`);
+    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${ghErrorMessage(err)}`);
     return null;
   }
 }
@@ -882,15 +1059,22 @@ var init_github_api = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 function loadState(taskId, taskDir) {
-  const p = path2.join(taskDir, "status.json");
-  if (!fs2.existsSync(p)) return null;
+  const p = path8.join(taskDir, "status.json");
+  if (!fs9.existsSync(p)) return null;
   try {
-    const raw = JSON.parse(fs2.readFileSync(p, "utf-8"));
-    if (raw.taskId === taskId) return raw;
-    return null;
+    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;
   } catch {
     return null;
   }
@@ -900,11 +1084,11 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path2.join(taskDir, "status.json");
+  const target = path8.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs2.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs2.renameSync(tmp, target);
-  state.updatedAt = updated.updatedAt;
+  fs9.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs9.renameSync(tmp, target);
+  return updated;
 }
 function initState(taskId) {
   const stages = {};
@@ -918,6 +1102,8 @@ var init_state = __esm({
   "src/pipeline/state.ts"() {
     "use strict";
     init_definitions();
+    init_validators();
+    init_logger();
   }
 });
 
@@ -942,16 +1128,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path3.join(projectDir, ".kody", "memory");
-  if (!fs3.existsSync(memoryDir)) return "";
-  const files = fs3.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path9.join(projectDir, ".kody", "memory");
+  if (!fs10.existsSync(memoryDir)) return "";
+  const files = fs10.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs3.readFileSync(path3.join(memoryDir, file), "utf-8").trim();
+    const content = fs10.readFileSync(path9.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -970,15 +1156,11 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-import * as crypto2 from "crypto";
+import * as fs11 from "fs";
+import * as path10 from "path";
 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];
@@ -1065,61 +1247,30 @@ function generateL1Json(content) {
     return content.slice(0, L1_MAX_CHARS);
   }
 }
-function readCache(cacheDir) {
-  const cachePath = path4.join(cacheDir, "tier-cache.json");
-  if (!fs4.existsSync(cachePath)) return { version: 1, entries: {} };
-  try {
-    return JSON.parse(fs4.readFileSync(cachePath, "utf-8"));
-  } catch {
-    return { version: 1, entries: {} };
-  }
-}
-function writeCache(cacheDir, cache) {
-  fs4.mkdirSync(cacheDir, { recursive: true });
-  fs4.writeFileSync(path4.join(cacheDir, "tier-cache.json"), JSON.stringify(cache, null, 2));
-}
-function getTieredContent(filePath, content, cacheDir) {
-  const hash = contentHash(content);
-  const key = path4.basename(filePath);
-  const cache = readCache(cacheDir);
-  if (cache.entries[key] && cache.entries[key].hash === hash) {
-    return cache.entries[key];
-  }
-  const tiered = {
+function getTieredContent(filePath, content) {
+  const key = path10.basename(filePath);
+  return {
     source: filePath,
-    hash,
     L0: generateL0(content, key),
     L1: generateL1(content, key),
     L2: content
   };
-  cache.entries[key] = tiered;
-  writeCache(cacheDir, cache);
-  return tiered;
-}
-function invalidateCache(filePath, cacheDir) {
-  const key = path4.basename(filePath);
-  const cache = readCache(cacheDir);
-  if (cache.entries[key]) {
-    delete cache.entries[key];
-    writeCache(cacheDir, cache);
-  }
 }
 function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path4.join(projectDir, ".kody", "memory");
-  if (!fs4.existsSync(memoryDir)) return "";
-  const files = fs4.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path10.join(projectDir, ".kody", "memory");
+  if (!fs11.existsSync(memoryDir)) return "";
+  const files = fs11.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
-  const cacheDir = path4.join(memoryDir, ".tiers");
   const tierLabel2 = tier === "L2" ? "full" : tier === "L1" ? "overview" : "abstract";
   const sections = [];
   for (const file of files) {
-    const filePath = path4.join(memoryDir, file);
-    const content = fs4.readFileSync(filePath, "utf-8").trim();
+    const filePath = path10.join(memoryDir, file);
+    const content = fs11.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
-    const tiered = getTieredContent(filePath, content, cacheDir);
+    const tiered = getTieredContent(filePath, content);
     const selected = selectTier(tiered, tier);
     if (selected) {
       sections.push(`## ${file.replace(".md", "")}
@@ -1134,26 +1285,25 @@ ${sections.join("\n\n")}
 `;
 }
 function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
-  const cacheDir = path4.join(taskDir, ".tiers");
   let context = `## Task Context
 `;
   context += `Task ID: ${taskId}
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path4.join(taskDir, "task.md");
-  if (fs4.existsSync(taskMdPath)) {
-    const content = fs4.readFileSync(taskMdPath, "utf-8");
-    const selected = selectContent(taskMdPath, content, cacheDir, policy.taskDescription);
+  const 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 label = tierLabel("Task Description", policy.taskDescription);
     context += `
 ## ${label}
 ${selected}
 `;
   }
-  const taskJsonPath = path4.join(taskDir, "task.json");
-  if (fs4.existsSync(taskJsonPath)) {
-    const content = fs4.readFileSync(taskJsonPath, "utf-8");
+  const taskJsonPath = path10.join(taskDir, "task.json");
+  if (fs11.existsSync(taskJsonPath)) {
+    const content = fs11.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -1169,7 +1319,7 @@ ${selected}
       } catch {
       }
     } else {
-      const selected = selectContent(taskJsonPath, content, cacheDir, policy.taskClassification);
+      const selected = selectContent(taskJsonPath, content, policy.taskClassification);
       if (selected) {
         const label = tierLabel("Task Classification", policy.taskClassification);
         context += `
@@ -1179,30 +1329,30 @@ ${selected}
       }
     }
   }
-  const specPath = path4.join(taskDir, "spec.md");
-  if (fs4.existsSync(specPath)) {
-    const content = fs4.readFileSync(specPath, "utf-8");
-    const selected = selectContent(specPath, content, cacheDir, policy.spec);
+  const 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 label = tierLabel("Spec", policy.spec);
     context += `
 ## ${label}
 ${selected}
 `;
   }
-  const planPath = path4.join(taskDir, "plan.md");
-  if (fs4.existsSync(planPath)) {
-    const content = fs4.readFileSync(planPath, "utf-8");
-    const selected = selectContent(planPath, content, cacheDir, policy.plan);
+  const 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 label = tierLabel("Plan", policy.plan);
     context += `
 ## ${label}
 ${selected}
 `;
   }
-  const contextMdPath = path4.join(taskDir, "context.md");
-  if (fs4.existsSync(contextMdPath)) {
-    const content = fs4.readFileSync(contextMdPath, "utf-8");
-    const selected = selectContent(contextMdPath, content, cacheDir, policy.accumulatedContext);
+  const 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 label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
 ## ${label}
@@ -1217,9 +1367,9 @@ ${feedback}
   }
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
-function selectContent(filePath, content, cacheDir, tier) {
+function selectContent(filePath, content, tier) {
   if (tier === "L2") return content;
-  const tiered = getTieredContent(filePath, content, cacheDir);
+  const tiered = getTieredContent(filePath, content);
   return selectTier(tiered, tier);
 }
 function tierLabel(sectionName, tier) {
@@ -1333,24 +1483,24 @@ var init_mcp_config = __esm({
 });
 
 // src/context.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path5.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs5.existsSync(stepFile)) {
-      return fs5.readFileSync(stepFile, "utf-8");
+    const stepFile = path11.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs12.existsSync(stepFile)) {
+      return fs12.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 = [
-    path5.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path5.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path11.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path11.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs5.existsSync(candidate)) {
-      return fs5.readFileSync(candidate, "utf-8");
+    if (fs12.existsSync(candidate)) {
+      return fs12.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -1362,18 +1512,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path5.join(taskDir, "task.md");
-  if (fs5.existsSync(taskMdPath)) {
-    const taskMd = fs5.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path11.join(taskDir, "task.md");
+  if (fs12.existsSync(taskMdPath)) {
+    const taskMd = fs12.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
-  const taskJsonPath = path5.join(taskDir, "task.json");
-  if (fs5.existsSync(taskJsonPath)) {
+  const taskJsonPath = path11.join(taskDir, "task.json");
+  if (fs12.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -1386,27 +1536,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path5.join(taskDir, "spec.md");
-  if (fs5.existsSync(specPath)) {
-    const spec = fs5.readFileSync(specPath, "utf-8");
+  const specPath = path11.join(taskDir, "spec.md");
+  if (fs12.existsSync(specPath)) {
+    const spec = fs12.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 = path5.join(taskDir, "plan.md");
-  if (fs5.existsSync(planPath)) {
-    const plan = fs5.readFileSync(planPath, "utf-8");
+  const planPath = path11.join(taskDir, "plan.md");
+  if (fs12.existsSync(planPath)) {
+    const plan = fs12.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 = path5.join(taskDir, "context.md");
-  if (fs5.existsSync(contextMdPath)) {
-    const accumulated = fs5.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path11.join(taskDir, "context.md");
+  if (fs12.existsSync(contextMdPath)) {
+    const accumulated = fs12.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -1423,10 +1573,10 @@ ${feedback}
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
 function taskHasUI(taskDir) {
-  const taskJsonPath = path5.join(taskDir, "task.json");
-  if (!fs5.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path11.join(taskDir, "task.json");
+  if (!fs12.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
+    const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
     return taskDef.hasUI !== false;
   } catch {
     return true;
@@ -1546,9 +1696,9 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path5.join(projectDir, ".kody", "qa-guide.md");
-    if (fs5.existsSync(qaGuidePath)) {
-      const qaGuide = fs5.readFileSync(qaGuidePath, "utf-8").trim();
+    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;
     }
   }
@@ -1597,55 +1747,6 @@ 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();
@@ -1666,8 +1767,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs13 from "fs";
+import * as path12 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -1729,27 +1830,27 @@ async function executeAgentStage(ctx, def) {
     return { outcome: result.outcome, error: result.error, retries: 0 };
   }
   if (def.outputFile && result.output) {
-    fs6.writeFileSync(path6.join(ctx.taskDir, def.outputFile), result.output);
+    fs13.writeFileSync(path12.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    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 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 variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs6.renameSync(path6.join(ctx.taskDir, variant), outputPath);
+        fs13.renameSync(path12.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path6.join(ctx.taskDir, def.outputFile);
-    if (fs6.existsSync(outputPath)) {
-      const content = fs6.readFileSync(outputPath, "utf-8");
+    const outputPath = path12.join(ctx.taskDir, def.outputFile);
+    if (fs13.existsSync(outputPath)) {
+      const content = fs13.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -1763,7 +1864,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs6.writeFileSync(outputPath, retryResult.output);
+              fs13.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -1777,7 +1878,7 @@ async function executeAgentStage(ctx, def) {
                 hasUI: true,
                 questions: []
               }, null, 2);
-              fs6.writeFileSync(outputPath, fallback);
+              fs13.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -1791,7 +1892,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path6.join(taskDir, "context.md");
+  const contextPath = path12.join(taskDir, "context.md");
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
   let summary;
   if (output && output.trim()) {
@@ -1804,7 +1905,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs6.appendFileSync(contextPath, entry);
+  fs13.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -1827,7 +1928,7 @@ var init_agent = __esm({
 });
 
 // src/verify-runner.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -1863,7 +1964,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync4(parts[0], parts.slice(1), {
+    const output = execFileSync9(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -1934,7 +2035,7 @@ var init_verify_runner = __esm({
 });
 
 // src/observer.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -1959,42 +2060,48 @@ ${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 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 ?? ""
-        };
+      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}`);
       }
     }
   } catch (err) {
     logger.warn(`  Diagnosis error: ${err instanceof Error ? err.message : err}`);
   }
-  logger.warn("  Diagnosis failed \u2014 defaulting to fixable");
+  logger.warn("  Diagnosis failed \u2014 defaulting to retry");
   return {
-    classification: "fixable",
-    reason: "Could not diagnose failure",
+    classification: "retry",
+    reason: "Could not diagnose failure \u2014 retrying gate",
     resolution: errorOutput.slice(-500)
   };
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync5("git", ["diff", "--name-only", "--cached"], {
+    const staged = execFileSync10("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const unstaged = execFileSync5("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync10("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2003,7 +2110,8 @@ function getModifiedFiles(projectDir) {
     const all = `${staged}
 ${unstaged}`.split("\n").filter(Boolean);
     return [...new Set(all)];
-  } catch {
+  } catch (err) {
+    logger.warn(`  Failed to get modified files: ${err instanceof Error ? err.message : String(err)}`);
     return [];
   }
 }
@@ -2012,6 +2120,7 @@ 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.
@@ -2035,8 +2144,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -2079,7 +2188,7 @@ ${output}
 `);
     }
   }
-  fs7.writeFileSync(path7.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs14.writeFileSync(path13.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -2094,9 +2203,9 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
-import { execFileSync as execFileSync6 } from "child_process";
+import * as fs15 from "fs";
+import * as path14 from "path";
+import { execFileSync as execFileSync11 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
@@ -2106,8 +2215,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path8.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs8.existsSync(verifyPath) ? fs8.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const verifyPath = path14.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs15.existsSync(verifyPath) ? fs15.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -2150,7 +2259,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync6(parts[0], parts.slice(1), {
+          execFileSync11(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -2203,18 +2312,18 @@ var init_verify = __esm({
 });
 
 // src/cli/task-resolution.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
-import { execFileSync as execFileSync7 } from "child_process";
+import * as fs16 from "fs";
+import * as path15 from "path";
+import { execFileSync as execFileSync12 } from "child_process";
 function findLatestTaskForIssue(issueNumber, projectDir) {
-  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 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 prefix = `${issueNumber}-`;
   const direct = allDirs.find((d) => d.startsWith(prefix));
   if (direct) return direct;
   try {
-    const branch = execFileSync7("git", ["branch", "--show-current"], {
+    const branch = execFileSync12("git", ["branch", "--show-current"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2243,8 +2352,8 @@ var init_task_resolution = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -2268,8 +2377,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path10.join(input.projectDir, ".kody", "tasks", taskId);
-  fs10.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path16.join(input.projectDir, ".kody", "tasks", taskId);
+  fs17.mkdirSync(taskDir, { recursive: true });
   const diffInstruction = input.baseBranch ? `
 
 ## Diff Command
@@ -2278,7 +2387,7 @@ Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree chang
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}`;
-  fs10.writeFileSync(path10.join(taskDir, "task.md"), taskContent);
+  fs17.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2300,10 +2409,10 @@ ${input.prBody ?? ""}${diffInstruction}`;
       error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path10.join(taskDir, "review.md");
+  const reviewPath = path16.join(taskDir, "review.md");
   let reviewContent;
-  if (fs10.existsSync(reviewPath)) {
-    reviewContent = fs10.readFileSync(reviewPath, "utf-8");
+  if (fs17.existsSync(reviewPath)) {
+    reviewContent = fs17.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2342,8 +2451,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -2357,11 +2466,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path11.join(ctx.taskDir, "review.md");
-    if (!fs11.existsSync(reviewFile)) {
+    const reviewFile = path17.join(ctx.taskDir, "review.md");
+    if (!fs18.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs11.readFileSync(reviewFile, "utf-8");
+    const content = fs18.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -2390,15 +2499,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
-import { execFileSync as execFileSync8 } from "child_process";
+import * as fs19 from "fs";
+import * as path18 from "path";
+import { execFileSync as execFileSync13 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path12.join(ctx.taskDir, "task.json");
-  if (fs12.existsSync(taskJsonPath)) {
+  const taskJsonPath = path18.join(ctx.taskDir, "task.json");
+  if (fs19.existsSync(taskJsonPath)) {
     try {
-      const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs19.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2417,9 +2526,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path12.join(ctx.taskDir, "review.md");
-  if (fs12.existsSync(reviewPath)) {
-    const review = fs12.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path18.join(ctx.taskDir, "review.md");
+  if (fs19.existsSync(reviewPath)) {
+    const review = fs19.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2436,14 +2545,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path12.join(ctx.taskDir, "verify.md");
-  if (fs12.existsSync(verifyPath)) {
-    const verify = fs12.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path18.join(ctx.taskDir, "verify.md");
+  if (fs19.existsSync(verifyPath)) {
+    const verify = fs19.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path12.join(ctx.taskDir, "plan.md");
-  if (fs12.existsSync(planPath)) {
-    const plan = fs12.readFileSync(planPath, "utf-8").trim();
+  const planPath = path18.join(ctx.taskDir, "plan.md");
+  if (fs19.existsSync(planPath)) {
+    const plan = fs19.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2463,25 +2572,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path12.join(ctx.taskDir, "ship.md");
+  const shipPath = path18.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs12.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs19.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) {
-    fs12.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs19.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 {
-      execFileSync8("git", ["add", ctx.taskDir], {
+      execFileSync13("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync8("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync13("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"
@@ -2495,7 +2604,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync8("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -2516,28 +2625,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
-    if (fs12.existsSync(taskJsonPath)) {
+    const taskJsonPath = path18.join(ctx.taskDir, "task.json");
+    if (fs19.existsSync(taskJsonPath)) {
       try {
-        const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs19.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 = path12.join(ctx.taskDir, "task.md");
-    if (fs12.existsSync(taskMdPath)) {
-      const content = fs12.readFileSync(taskMdPath, "utf-8");
+    const taskMdPath = path18.join(ctx.taskDir, "task.md");
+    if (fs19.existsSync(taskMdPath)) {
+      const content = fs19.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 (fs12.existsSync(taskJsonPath)) {
+      if (fs19.existsSync(taskJsonPath)) {
         try {
-          const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs19.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);
@@ -2560,7 +2669,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs12.writeFileSync(shipPath, `# Ship
+      fs19.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2581,22 +2690,26 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs12.writeFileSync(shipPath, `# Ship
+        fs19.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs12.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs19.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);
-    fs12.writeFileSync(shipPath, `# Ship
+    try {
+      fs19.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
+    } catch {
+      logger.warn(`  Failed to write ship.md artifact`);
+    }
     return { outcome: "failed", retries: 0, error: msg };
   }
 }
@@ -2639,15 +2752,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path13.join(ctx.taskDir, "task.json");
-      if (!fs13.existsSync(taskJsonPath)) return false;
-      const raw = fs13.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path19.join(ctx.taskDir, "task.json");
+      if (!fs20.existsSync(taskJsonPath)) return false;
+      const raw = fs20.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) {
@@ -2662,9 +2775,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path13.join(ctx.taskDir, "plan.md");
-      if (!fs13.existsSync(planPath)) return false;
-      const plan = fs13.readFileSync(planPath, "utf-8");
+      const planPath = path19.join(ctx.taskDir, "plan.md");
+      if (!fs20.existsSync(planPath)) return false;
+      const plan = fs20.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2693,8 +2806,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
@@ -2732,9 +2845,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path14.join(ctx.taskDir, "task.json");
-    if (!fs14.existsSync(taskJsonPath)) return null;
-    const raw = fs14.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+    if (!fs21.existsSync(taskJsonPath)) return null;
+    const raw = fs21.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;
@@ -2764,8 +2877,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 = path14.join(ctx.taskDir, "plan.md");
-  const plan = fs14.existsSync(planPath) ? fs14.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path20.join(ctx.taskDir, "plan.md");
+  const plan = fs21.existsSync(planPath) ? fs21.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2832,22 +2945,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path15.join(ctx.projectDir, ".kody", "memory");
-    if (!fs15.existsSync(memoryDir)) {
-      fs15.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path21.join(ctx.projectDir, ".kody", "memory");
+    if (!fs22.existsSync(memoryDir)) {
+      fs22.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path15.join(ctx.taskDir, "verify.md");
-    if (fs15.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs15.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path21.join(ctx.taskDir, "verify.md");
+    if (fs22.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs22.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");
@@ -2856,18 +2969,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 = path15.join(ctx.taskDir, "review.md");
-    if (fs15.existsSync(reviewPath)) {
-      const review = fs15.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path21.join(ctx.taskDir, "review.md");
+    if (fs22.existsSync(reviewPath)) {
+      const review = fs22.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 = path15.join(ctx.taskDir, "task.json");
-    if (fs15.existsSync(taskJsonPath)) {
+    const taskJsonPath = path21.join(ctx.taskDir, "task.json");
+    if (fs22.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs15.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs22.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)) {
@@ -2878,135 +2991,48 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path15.join(memoryDir, "conventions.md");
+      const conventionsPath = path21.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs15.appendFileSync(conventionsPath, entry);
-      invalidateCache(conventionsPath, path15.join(memoryDir, ".tiers"));
+      fs22.appendFileSync(conventionsPath, entry);
       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 = 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 {
-    }
-  }
+  const archPath = path21.join(memoryDir, "architecture.md");
+  if (fs22.existsSync(archPath)) return;
+  const detected = detectArchitectureBasic(projectDir);
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `;
-    fs15.writeFileSync(archPath, content);
-    invalidateCache(archPath, path15.join(memoryDir, ".tiers"));
+    fs22.writeFileSync(archPath, content);
     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_context_tiers();
+    init_architecture_detection();
   }
 });
 
 // src/retrospective.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path16.join(taskDir, filename);
-  if (!fs16.existsSync(p)) return null;
+  const p = path22.join(taskDir, filename);
+  if (!fs23.existsSync(p)) return null;
   try {
-    const content = fs16.readFileSync(p, "utf-8");
+    const content = fs23.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -3059,13 +3085,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path16.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path22.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs16.existsSync(logPath)) return [];
+  if (!fs23.existsSync(logPath)) return [];
   try {
-    const content = fs16.readFileSync(logPath, "utf-8");
+    const content = fs23.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -3092,11 +3118,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path16.dirname(logPath);
-  if (!fs16.existsSync(dir)) {
-    fs16.mkdirSync(dir, { recursive: true });
+  const dir = path22.dirname(logPath);
+  if (!fs23.existsSync(dir)) {
+    fs23.mkdirSync(dir, { recursive: true });
   }
-  fs16.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs23.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -3207,8 +3233,8 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
 });
 
 // src/pipeline.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -3221,34 +3247,59 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    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;
+    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;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
-    logger.warn(`  Failed to create/sync feature branch: ${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}`);
+    }
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path17.join(taskDir, ".lock");
-  if (fs17.existsSync(lockPath)) {
+  const lockPath = path23.join(taskDir, ".lock");
+  if (fs24.existsSync(lockPath)) {
     try {
-      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;
+      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`);
       }
     } 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 {
-    fs17.unlinkSync(path17.join(taskDir, ".lock"));
+    fs24.unlinkSync(path23.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3260,17 +3311,17 @@ async function runPipeline(ctx) {
     try {
       const state = loadState(ctx.taskId, ctx.taskDir);
       if (state && state.state === "running") {
-        state.state = "failed";
+        const updatedStages = { ...state.stages };
         for (const stage of STAGES) {
-          if (state.stages[stage.name]?.state === "running") {
-            state.stages[stage.name] = {
-              ...state.stages[stage.name],
+          if (updatedStages[stage.name]?.state === "running") {
+            updatedStages[stage.name] = {
+              ...updatedStages[stage.name],
               state: "failed",
               error: "Pipeline crashed unexpectedly"
             };
           }
         }
-        writeState(state, ctx.taskDir);
+        writeState({ ...state, state: "failed", stages: updatedStages }, ctx.taskDir);
       }
     } catch {
     }
@@ -3395,7 +3446,8 @@ async function runPipelineInner(ctx) {
     }
     autoLearn(ctx);
   }
-  await runRetrospective(ctx, state, pipelineStartTime).catch(() => {
+  await runRetrospective(ctx, state, pipelineStartTime).catch((err) => {
+    logger.warn(`  Retrospective failed: ${err instanceof Error ? err.message : String(err)}`);
   });
   return state;
 }
@@ -3435,8 +3487,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync9 } from "child_process";
-import * as fs18 from "fs";
+import { execFileSync as execFileSync14 } from "child_process";
+import * as fs25 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3448,7 +3500,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync9("claude", ["--version"], {
+      const v = execFileSync14("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3456,14 +3508,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync9("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync14("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync9("pnpm", ["--version"], {
+      const v = execFileSync14("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3471,7 +3523,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync9("node", ["--version"], {
+      const v = execFileSync14("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3481,7 +3533,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync9("gh", ["--version"], {
+      const v = execFileSync14("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3489,7 +3541,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs18.existsSync("package.json")) throw new Error("not found");
+      if (!fs25.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3566,10 +3618,10 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs19 from "fs";
+import * as fs26 from "fs";
 import * as os from "os";
-import * as path18 from "path";
-import { execFileSync as execFileSync10 } from "child_process";
+import * as path24 from "path";
+import { execFileSync as execFileSync15 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -3629,17 +3681,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 = path18.join(os.tmpdir(), "kody-litellm-config.yaml");
-  fs19.writeFileSync(configPath, generatedConfig);
+  const configPath = path24.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs26.writeFileSync(configPath, generatedConfig);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
   try {
-    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     litellmFound = true;
   } catch {
     try {
-      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync15("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
       litellmFound = true;
     } catch {
     }
@@ -3652,19 +3704,29 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
   let cmd;
   let args2;
   try {
-    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync15("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 = path18.join(projectDir, ".env");
+  const dotenvPath = path24.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs19.existsSync(dotenvPath)) {
-    for (const line of fs19.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  if (fs26.existsSync(dotenvPath)) {
+    for (const rawLine of fs26.readFileSync(dotenvPath, "utf-8").split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
       const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
-      if (match) dotenvVars[match[1]] = match[2];
+      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 (Object.keys(dotenvVars).length > 0) {
       logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
@@ -3703,8 +3765,8 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -3736,11 +3798,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path19.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path25.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs20.existsSync(statusPath)) {
+    if (fs27.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs20.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs27.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -3773,12 +3835,12 @@ var resolve_exports = {};
 __export(resolve_exports, {
   runResolve: () => runResolve
 });
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 function getConflictContext(cwd, files) {
   const parts = [];
   for (const file of files.slice(0, 10)) {
     try {
-      const content = execFileSync11("git", ["diff", file], {
+      const content = execFileSync16("git", ["diff", file], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -3897,8 +3959,8 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!needsLitellmProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
@@ -3927,7 +3989,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-litellm-proxy-key-00000000000000000000000000000000000000000000000000000000000000000000";
+    process.env.ANTHROPIC_API_KEY = `sk-ant-api03-${"0".repeat(64)}`;
   }
   return litellmProcess;
 }
@@ -3952,9 +4014,9 @@ async function runModelHealthCheck(config) {
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path20.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path26.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs21.existsSync(projectDir)) {
+    if (!fs28.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -3988,9 +4050,11 @@ async function main() {
       process.exit(0);
     }
     if (taskAction.action === "resume") {
-      input.taskId = taskAction.taskId;
-      input.fromStage = taskAction.fromStage;
-      input.command = "rerun";
+      Object.assign(input, {
+        taskId: taskAction.taskId,
+        fromStage: taskAction.fromStage,
+        command: "rerun"
+      });
       logger.info(`Resuming task ${taskAction.taskId} from ${taskAction.fromStage}`);
     }
   }
@@ -4009,8 +4073,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path20.join(projectDir, ".kody", "tasks", taskId);
-  fs21.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path26.join(projectDir, ".kody", "tasks", taskId);
+  fs28.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -4115,7 +4179,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);
@@ -4126,31 +4190,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs21.writeFileSync(path20.join(taskDir, "task.md"), input.task);
+    fs28.writeFileSync(path26.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path20.join(taskDir, "task.md");
-  if (!fs21.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  const taskMdPath = path26.join(taskDir, "task.md");
+  if (!fs28.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 ?? ""}`;
-      fs21.writeFileSync(taskMdPath, taskContent);
+      fs28.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs21.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs28.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 ?? ""}`;
-      fs21.writeFileSync(taskMdPath, taskContent);
+      fs28.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs21.existsSync(taskMdPath)) {
+  if (!fs28.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -4222,7 +4286,7 @@ ${input.feedback}`);
   await runModelHealthCheck(config);
   const cleanupLitellm = () => {
     if (litellmProcess) {
-      litellmProcess.kill?.();
+      litellmProcess.kill();
       litellmProcess = null;
     }
   };
@@ -4288,7 +4352,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs21.readdirSync(taskDir);
+  const files = fs28.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -4352,20 +4416,21 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
-import { execFileSync as execFileSync12 } from "child_process";
+import * as fs29 from "fs";
+import * as path27 from "path";
 import { fileURLToPath } from "url";
-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) {
+
+// 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) {
   try {
-    const output = execFileSync12(name, args2, {
+    const output = execFileSync(name, args2, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4376,14 +4441,14 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs22.existsSync(filePath)) {
+  if (fs.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
 }
 function checkGhAuth(cwd) {
   try {
-    const output = execFileSync12("gh", ["auth", "status"], {
+    const output = execFileSync("gh", ["auth", "status"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4401,7 +4466,7 @@ function checkGhAuth(cwd) {
 }
 function checkGhRepoAccess(cwd) {
   try {
-    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4412,7 +4477,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]}`;
-    execFileSync12("gh", ["repo", "view", repoSlug, "--json", "name"], {
+    execFileSync("gh", ["repo", "view", repoSlug, "--json", "name"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4425,7 +4490,7 @@ function checkGhRepoAccess(cwd) {
 }
 function checkGhSecret(repoSlug, secretName) {
   try {
-    const output = execFileSync12("gh", ["secret", "list", "--repo", repoSlug], {
+    const output = execFileSync("gh", ["secret", "list", "--repo", repoSlug], {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4446,14 +4511,20 @@ 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 (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";
+  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";
   let defaultBranch = "main";
   try {
-    const ref = execFileSync12("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync2("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4462,7 +4533,7 @@ function detectBasicConfig(cwd) {
     defaultBranch = ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      execFileSync12("git", ["rev-parse", "--verify", "origin/dev"], {
+      execFileSync2("git", ["rev-parse", "--verify", "origin/dev"], {
         encoding: "utf-8",
         timeout: 5e3,
         cwd,
@@ -4475,7 +4546,7 @@ function detectBasicConfig(cwd) {
   let owner = "";
   let repo = "";
   try {
-    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync2("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4493,7 +4564,7 @@ function detectBasicConfig(cwd) {
 function buildConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs2.readFileSync(path.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -4525,7 +4596,6 @@ 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);
@@ -4548,7 +4618,9 @@ function detectMcpConfig(cwd, pm, pkg) {
   }
   return mcp;
 }
-function initCommand(opts) {
+
+// src/bin/commands/init.ts
+function initCommand(opts, pkgRoot) {
   const cwd = process.cwd();
   console.log(`
 \u{1F527} Kody Engine Lite \u2014 Init
@@ -4556,35 +4628,35 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path21.join(PKG_ROOT, "templates");
+  const templatesDir = path2.join(pkgRoot, "templates");
   const basic = detectBasicConfig(cwd);
-  const workflowSrc = path21.join(templatesDir, "kody.yml");
-  const workflowDest = path21.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs22.existsSync(workflowSrc)) {
+  const workflowSrc = path2.join(templatesDir, "kody.yml");
+  const workflowDest = path2.join(cwd, ".github", "workflows", "kody.yml");
+  if (!fs3.existsSync(workflowSrc)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs22.existsSync(workflowDest) && !opts.force) {
+  if (fs3.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs22.mkdirSync(path21.dirname(workflowDest), { recursive: true });
-    fs22.copyFileSync(workflowSrc, workflowDest);
+    fs3.mkdirSync(path2.dirname(workflowDest), { recursive: true });
+    fs3.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path21.join(cwd, "kody.config.json");
-  if (!fs22.existsSync(configDest) || opts.force) {
+  const configDest = path2.join(cwd, "kody.config.json");
+  if (!fs3.existsSync(configDest) || opts.force) {
     const config = buildConfig(cwd, basic);
-    fs22.writeFileSync(configDest, JSON.stringify(config, null, 2) + "\n");
+    fs3.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 = path21.join(cwd, ".gitignore");
-  if (fs22.existsSync(gitignorePath)) {
-    const content = fs22.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path2.join(cwd, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const content = fs3.readFileSync(gitignorePath, "utf-8");
     if (content.includes(".tasks/")) {
       const updated = content.replace(/\n?\.tasks\/\n?/g, "\n");
-      fs22.writeFileSync(gitignorePath, updated);
+      fs3.writeFileSync(gitignorePath, updated);
       console.log("  \u2713 .gitignore (removed legacy .tasks/ \u2014 tasks now committed in .kody/tasks/)");
     } else {
       console.log("  \u25CB .gitignore (ok)");
@@ -4592,10 +4664,10 @@ function initCommand(opts) {
   }
   console.log("\n\u2500\u2500 Prerequisites \u2500\u2500");
   const checks = [
-    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`)
+    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`)
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -4609,26 +4681,19 @@ function initCommand(opts) {
   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) {
-    repoSlug = ghRepo.detail;
-    const secretChecks = [
-      checkGhSecret(repoSlug, "ANTHROPIC_API_KEY")
-    ];
+    const repoSlug = ghRepo.detail;
+    const secretChecks = [checkGhSecret(repoSlug, "ANTHROPIC_API_KEY")];
     for (const c of secretChecks) {
-      if (c.ok) {
-        console.log(`  \u2713 ${c.name}`);
-      } else {
-        console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
-      }
+      console.log(c.ok ? `  \u2713 ${c.name}` : `  \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 (fs22.existsSync(configDest)) {
+  if (fs3.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs22.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs3.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}` });
@@ -4658,11 +4723,11 @@ function initCommand(opts) {
   const filesToCommit = [
     ".github/workflows/kody.yml",
     "kody.config.json"
-  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
+  ].filter((f) => fs3.existsSync(path2.join(cwd, f)));
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
-      execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
+      const fullPaths = filesToCommit.map((f) => path2.join(cwd, f));
+      execFileSync3("npx", ["prettier", "--write", ...fullPaths], {
         cwd,
         encoding: "utf-8",
         timeout: 3e4,
@@ -4673,13 +4738,13 @@ function initCommand(opts) {
   }
   if (filesToCommit.length > 0) {
     try {
-      execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-      const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+      execFileSync3("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+      const staged = execFileSync3("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
       if (staged) {
-        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" });
+        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" });
         console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
         try {
-          execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync3("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log("  \u2713 Pushed to origin");
         } catch {
           console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -4721,87 +4786,365 @@ function initCommand(opts) {
     console.log("");
   }
 }
-var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
-function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  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 fs22.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        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 = fs22.statSync(full);
-            if (stat.size >= 200 && stat.size <= 5e3) {
-              entries.push({ filePath: full, size: stat.size });
+
+// 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 {
         }
       }
-    } catch {
     }
-    return entries;
-  }
-  const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
-  for (const { filePath } of files) {
-    const rel = path21.relative(cwd, filePath);
-    const content = fs22.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
-    results.push(`### File: ${rel}
-\`\`\`typescript
-${content}
-\`\`\``);
+  } catch {
   }
-  return results.join("\n\n");
+  return result;
 }
-function ghComment(issueNumber, body, cwd) {
+function scanRoutes(dir, baseDir, prefix, result) {
+  let entries;
   try {
-    let repoSlug = "";
-    try {
-      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}`;
-        }
-      }
-    } catch {
-    }
-    if (!repoSlug) return;
-    execFileSync12("gh", [
-      "issue",
-      "comment",
-      String(issueNumber),
-      "--repo",
-      repoSlug,
-      "--body",
-      body
-    ], {
-      cwd,
-      encoding: "utf-8",
-      timeout: 15e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
   } catch {
+    return;
   }
-}
-function bootstrapCommand(opts = { force: false }) {
-  const cwd = process.cwd();
-  const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
-  console.log(`
-\u{1F527} Kody Bootstrap \u2014 Generating project memory + step files
-`);
-  if (issueNumber) {
-    ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
+  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;
   }
-  const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path21.join(cwd, rel);
-    if (fs22.existsSync(p)) return fs22.readFileSync(p, "utf-8").slice(0, maxChars);
+  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 results = [];
+  function walk(dir) {
+    const entries = [];
+    try {
+      for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        const full = path6.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);
+            if (stat.size >= 200 && stat.size <= 5e3) {
+              entries.push({ filePath: full, size: stat.size });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return entries;
+  }
+  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);
+    results.push(`### File: ${rel}
+\`\`\`typescript
+${content}
+\`\`\``);
+  }
+  return results.join("\n\n");
+}
+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"));
+        if (config.github?.owner && config.github?.repo) {
+          repoSlug = `${config.github.owner}/${config.github.repo}`;
+        }
+      }
+    } catch {
+    }
+    if (!repoSlug) return;
+    execFileSync5("gh", [
+      "issue",
+      "comment",
+      String(issueNumber),
+      "--repo",
+      repoSlug,
+      "--body",
+      body
+    ], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+function bootstrapCommand(opts, pkgRoot) {
+  const cwd = process.cwd();
+  const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
+  console.log(`
+\u{1F527} Kody Bootstrap \u2014 Generating project memory + step files
+`);
+  if (issueNumber) {
+    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);
     return null;
   };
   let repoContext = "";
@@ -4836,14 +5179,14 @@ ${sampleFiles}
 
 `;
   try {
-    const topDirs = fs22.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs7.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 = path21.join(cwd, "src");
-    if (fs22.existsSync(srcDir)) {
-      const srcDirs = fs22.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    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);
       if (srcDirs.length > 0) repoContext += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -4853,19 +5196,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 (fs22.existsSync(path21.join(cwd, f))) existingFiles.push(f);
+    if (fs7.existsSync(path6.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 = 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 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 hasExisting = !!(existingArch || existingConv);
   const extendInstruction = hasExisting && !opts.force ? `
 ## Existing Documentation (EXTEND, do not replace)
@@ -4906,7 +5249,7 @@ Output ONLY valid JSON. No markdown fences. No explanation.
 ${repoContext}`;
   console.log("  \u23F3 Analyzing project...");
   try {
-    const output = execFileSync12("claude", [
+    const output = execFileSync5("claude", [
       "--print",
       "--model",
       "haiku",
@@ -4921,12 +5264,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs22.writeFileSync(archPath, parsed.architecture);
+      fs7.writeFileSync(archPath, parsed.architecture);
       const lineCount = parsed.architecture.split("\n").length;
       console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines)`);
     }
     if (parsed.conventions) {
-      fs22.writeFileSync(conventionsPath, parsed.conventions);
+      fs7.writeFileSync(conventionsPath, parsed.conventions);
       const lineCount = parsed.conventions.split("\n").length;
       console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines)`);
     }
@@ -4935,39 +5278,39 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs22.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `);
       console.log(`  \u2713 .kody/memory/architecture.md (${detected.length} items, basic detection)`);
     }
-    fs22.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs7.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 = 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") : "";
+  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") : "";
   console.log("  \u23F3 Customizing step files...");
   let stepCount = 0;
   for (const stage of STEP_STAGES) {
-    const templatePath = path21.join(PKG_ROOT, "prompts", `${stage}.md`);
-    if (!fs22.existsSync(templatePath)) {
+    const templatePath = path6.join(pkgRoot, "prompts", `${stage}.md`);
+    if (!fs7.existsSync(templatePath)) {
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
-    const stepOutputPath = path21.join(stepsDir, `${stage}.md`);
-    if (fs22.existsSync(stepOutputPath) && !opts.force) {
+    const stepOutputPath = path6.join(stepsDir, `${stage}.md`);
+    if (fs7.existsSync(stepOutputPath) && !opts.force) {
       console.log(`  \u25CB ${stage}.md \u2014 already exists (use --force to regenerate)`);
       continue;
     }
-    const defaultPrompt = fs22.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs7.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs22.copyFileSync(templatePath, stepOutputPath);
+      fs7.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -5009,7 +5352,7 @@ ${repoContext}
 
 REMINDER: Output the full prompt template first (unchanged), then your three appended sections. Do NOT include "${contextPlaceholder}".`;
     try {
-      const output = execFileSync12("claude", [
+      const output = execFileSync5("claude", [
         "--print",
         "--model",
         "haiku",
@@ -5024,23 +5367,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;
-      fs22.writeFileSync(stepOutputPath, finalPrompt);
+      fs7.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs22.copyFileSync(templatePath, stepOutputPath);
+      fs7.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 = path21.join(cwd, ".kody", "qa-guide.md");
-  if (!fs22.existsSync(qaGuidePath) || opts.force) {
+  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);
-      fs22.writeFileSync(qaGuidePath, qaGuide);
+      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}`);
@@ -5055,9 +5398,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   try {
     let repoSlug = "";
     try {
-      const configPath = path21.join(cwd, "kody.config.json");
-      if (fs22.existsSync(configPath)) {
-        const config = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
+      const configPath = path6.join(cwd, "kody.config.json");
+      if (fs7.existsSync(configPath)) {
+        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -5084,7 +5427,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       ];
       for (const label of labels) {
         try {
-          execFileSync12("gh", [
+          execFileSync5("gh", [
             "label",
             "create",
             label.name,
@@ -5104,7 +5447,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 ${label.name}`);
         } catch {
           try {
-            execFileSync12("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+            execFileSync5("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
               cwd,
               encoding: "utf-8",
               timeout: 1e4,
@@ -5130,21 +5473,21 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     ".kody/memory/conventions.md",
     ".kody/qa-guide.md",
     ...installedSkillPaths
-  ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
-  if (fs22.existsSync(path21.join(cwd, "skills-lock.json"))) {
+  ].filter((f) => fs7.existsSync(path6.join(cwd, f)));
+  if (fs7.existsSync(path6.join(cwd, "skills-lock.json"))) {
     filesToCommit.push("skills-lock.json");
   }
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs22.existsSync(path21.join(cwd, stepFile))) {
+    if (fs7.existsSync(path6.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path6.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
-        execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
+        execFileSync5("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
           encoding: "utf-8",
           timeout: 3e4,
@@ -5160,24 +5503,24 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     try {
       if (isCI3) {
         const branchName = `kody-bootstrap-${Date.now()}`;
-        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();
+        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();
         if (staged) {
-          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 });
+          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 });
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path21.join(cwd, "kody.config.json");
-            if (fs22.existsSync(configPath)) {
-              const config = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
+            const configPath = path6.join(cwd, "kody.config.json");
+            if (fs7.existsSync(configPath)) {
+              const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
               baseBranch = config.git?.defaultBranch ?? "main";
             }
           } catch {
           }
           try {
-            const prUrl = execFileSync12("gh", [
+            const prUrl = execFileSync5("gh", [
               "pr",
               "create",
               "--title",
@@ -5216,13 +5559,13 @@ Create it manually.`, cwd);
           console.log("  \u25CB No new changes to commit");
         }
       } else {
-        execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync5("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync5("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          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" });
+          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" });
           console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
           try {
-            execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+            execFileSync5("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
             console.log("  \u2713 Pushed to origin");
           } catch {
             console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -5242,303 +5585,22 @@ Create it manually.`, cwd);
   console.log("  \u2713 Project bootstrap complete!");
   console.log("  Kody now has project-specific memory and customized step files.\n");
 }
-function discoverQaContext(cwd) {
-  const result = {
-    routes: [],
-    authFiles: [],
-    loginPage: null,
-    adminPath: null,
-    roles: [],
-    devCommand: "",
-    devPort: 3e3
-  };
-  try {
-    const pkg = JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs22.existsSync(path21.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 = path21.join(cwd, appDir);
-    if (!fs22.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 (fs22.existsSync(path21.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 (fs22.existsSync(path21.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 = path21.join(cwd, rp);
-      if (!fs22.existsSync(dir)) continue;
-      const files = fs22.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
-      for (const f of files) {
-        try {
-          const content = fs22.readFileSync(path21.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 = fs22.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(path21.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(path21.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");
-}
-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;
+
+// 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;
 }
 var args = process.argv.slice(2);
 var command = args[0];
 if (command === "init") {
-  initCommand({ force: args.includes("--force") });
+  initCommand({ force: args.includes("--force") }, PKG_ROOT);
 } else if (command === "bootstrap") {
-  bootstrapCommand({ force: args.includes("--force") });
+  bootstrapCommand({ force: args.includes("--force") }, PKG_ROOT);
 } else if (command === "version" || command === "--version" || command === "-v") {
   console.log(getVersion());
 } else {
@@ -5546,7 +5608,7 @@ if (command === "init") {
 }
 export {
   buildConfig,
-  checkCommand2 as checkCommand,
+  checkCommand,
   checkFile,
   checkGhAuth,
   checkGhRepoAccess,