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

package/dist/bin/cli.js

@@ -9,8 +9,250 @@ 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/ci/parse-inputs.ts
+var parse_inputs_exports = {};
+__export(parse_inputs_exports, {
+  parseCommentInputs: () => parseCommentInputs,
+  runCiParse: () => runCiParse,
+  writeOutputs: () => writeOutputs
+});
+import * as fs8 from "fs";
+function generateTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const y = String(now.getFullYear()).slice(2);
+  const m = pad(now.getMonth() + 1);
+  const d = pad(now.getDate());
+  const H = pad(now.getHours());
+  const M = pad(now.getMinutes());
+  const S = pad(now.getSeconds());
+  return `${y}${m}${d}-${H}${M}${S}`;
+}
+function parseCommentInputs() {
+  const triggerType = process.env.TRIGGER_TYPE ?? "dispatch";
+  if (triggerType === "dispatch") {
+    const taskId2 = process.env.INPUT_TASK_ID ?? "";
+    return {
+      task_id: taskId2,
+      mode: process.env.INPUT_MODE ?? "full",
+      from_stage: process.env.INPUT_FROM_STAGE ?? "",
+      issue_number: process.env.INPUT_ISSUE_NUMBER ?? "",
+      pr_number: "",
+      feedback: process.env.INPUT_FEEDBACK ?? "",
+      complexity: "",
+      ci_run_id: "",
+      dry_run: false,
+      valid: !!taskId2,
+      trigger_type: "dispatch"
+    };
+  }
+  const commentBody = (process.env.COMMENT_BODY ?? "").replace(/\r/g, "");
+  const issueNumber = process.env.ISSUE_NUMBER ?? "";
+  const isPR = !!process.env.ISSUE_IS_PR;
+  const kodyMatch = commentBody.match(/(?:@kody|\/kody)\s*(.*)/i);
+  if (!kodyMatch) {
+    return {
+      task_id: "",
+      mode: "full",
+      from_stage: "",
+      issue_number: issueNumber,
+      pr_number: "",
+      feedback: "",
+      complexity: "",
+      ci_run_id: "",
+      dry_run: false,
+      valid: false,
+      trigger_type: "comment"
+    };
+  }
+  const argsLine = kodyMatch[1].trim();
+  let fromStage = "";
+  let feedback = "";
+  let complexity = "";
+  let dryRun = false;
+  let ciRunId = "";
+  const fromMatch = argsLine.match(/--from\s+(\S+)/);
+  if (fromMatch) fromStage = fromMatch[1];
+  const feedbackMatch = argsLine.match(/--feedback\s+"([^"]*)"/);
+  if (feedbackMatch) feedback = feedbackMatch[1];
+  const complexityMatch = argsLine.match(/--complexity\s+(\S+)/);
+  if (complexityMatch) complexity = complexityMatch[1];
+  if (/--dry-run/.test(argsLine)) dryRun = true;
+  const ciRunIdMatch = argsLine.match(/--ci-run-id\s+(\S+)/);
+  if (ciRunIdMatch) ciRunId = ciRunIdMatch[1];
+  const positional = argsLine.replace(/--from\s+\S+/g, "").replace(/--feedback\s+"[^"]*"/g, "").replace(/--complexity\s+\S+/g, "").replace(/--dry-run/g, "").replace(/--ci-run-id\s+\S+/g, "").replace(/\s+/g, " ").trim();
+  const parts = positional ? positional.split(/\s+/) : [];
+  let mode = "full";
+  let taskId = "";
+  let idx = 0;
+  if (parts[idx] && VALID_MODES.includes(parts[idx])) {
+    mode = parts[idx];
+    idx++;
+  }
+  if (parts[idx] && !parts[idx].startsWith("--")) {
+    taskId = parts[idx];
+    idx++;
+  } else if (parts[0] && !VALID_MODES.includes(parts[0]) && !parts[0].startsWith("--")) {
+    taskId = parts[0];
+  }
+  const kodyLineIdx = commentBody.search(/(?:@kody|\/kody)/i);
+  const afterKodyLine = commentBody.slice(kodyLineIdx);
+  const newlineIdx = afterKodyLine.indexOf("\n");
+  const bodyAfterCommand = newlineIdx !== -1 ? afterKodyLine.slice(newlineIdx + 1) : "";
+  if (mode === "approve") {
+    mode = "rerun";
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+    }
+  }
+  if (mode === "fix") {
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+    }
+  }
+  if (mode === "fix-ci") {
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+      const runIdFromBody = bodyAfterCommand.match(/Run ID:\s*(\d+)/);
+      if (runIdFromBody) {
+        ciRunId = runIdFromBody[1];
+      }
+    }
+  }
+  if (mode === "bootstrap") {
+    taskId = `bootstrap-${generateTimestamp()}`;
+  }
+  const prNumber = isPR ? issueNumber : "";
+  if (mode === "review" && prNumber) {
+    taskId = `review-pr-${prNumber}-${generateTimestamp()}`;
+  }
+  if (!taskId && mode === "full") {
+    taskId = `${issueNumber}-${generateTimestamp()}`;
+  }
+  const modesWithoutTaskId = ["fix", "fix-ci", "status", "review", "resolve", "rerun"];
+  const valid = !!taskId || modesWithoutTaskId.includes(mode);
+  return {
+    task_id: taskId,
+    mode,
+    from_stage: fromStage,
+    issue_number: issueNumber,
+    pr_number: prNumber,
+    feedback,
+    complexity,
+    ci_run_id: ciRunId,
+    dry_run: dryRun,
+    valid,
+    trigger_type: "comment"
+  };
+}
+function writeOutputs(result) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  function output(key, value) {
+    if (outputFile) {
+      if (value.includes("\n")) {
+        fs8.appendFileSync(outputFile, `${key}<<KODY_EOF
+${value}
+KODY_EOF
+`);
+      } else {
+        fs8.appendFileSync(outputFile, `${key}=${value}
+`);
+      }
+    }
+    const display = value.includes("\n") ? value.split("\n")[0] + "..." : value;
+    console.log(`${key}=${display}`);
+  }
+  output("task_id", result.task_id);
+  output("mode", result.mode);
+  output("from_stage", result.from_stage);
+  output("issue_number", result.issue_number);
+  output("pr_number", result.pr_number);
+  output("feedback", result.feedback);
+  output("complexity", result.complexity);
+  output("ci_run_id", result.ci_run_id);
+  output("dry_run", result.dry_run ? "true" : "false");
+  output("valid", result.valid ? "true" : "false");
+  output("trigger_type", result.trigger_type);
+}
+function runCiParse() {
+  const result = parseCommentInputs();
+  writeOutputs(result);
+}
+var VALID_MODES;
+var init_parse_inputs = __esm({
+  "src/ci/parse-inputs.ts"() {
+    "use strict";
+    VALID_MODES = [
+      "full",
+      "rerun",
+      "fix",
+      "fix-ci",
+      "status",
+      "approve",
+      "review",
+      "resolve",
+      "bootstrap"
+    ];
+  }
+});
+
 // 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 +324,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 +356,7 @@ function createClaudeCodeRunner() {
       return runSubprocess("claude", args2, prompt, timeout, options);
     },
     async healthCheck() {
-      return checkCommand("claude", ["--version"]);
+      return checkCommand2("claude", ["--version"]);
     }
   };
 }
@@ -271,12 +513,105 @@ 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 fs9 from "fs";
+import * as path7 from "path";
+function resolveStageConfig(config, stageName, modelTier) {
+  const stageOverride = config.agent.stages?.[stageName];
+  if (stageOverride) return stageOverride;
+  if (config.agent.default) return config.agent.default;
+  const model = config.agent.modelMap[modelTier];
+  if (!model) {
+    throw new Error(`No model configured for stage '${stageName}' (tier: ${modelTier}). Set agent.stages.${stageName} or agent.default in kody.config.json`);
+  }
+  return {
+    provider: config.agent.provider ?? "claude",
+    model
+  };
+}
 function needsLitellmProxy(config) {
   return !!(config.agent.provider && config.agent.provider !== "anthropic");
 }
+function stageNeedsProxy(stageConfig) {
+  return stageConfig.provider !== "claude" && stageConfig.provider !== "anthropic";
+}
+function anyStageNeedsProxy(config) {
+  if (config.agent.stages) {
+    for (const sc of Object.values(config.agent.stages)) {
+      if (stageNeedsProxy(sc)) return true;
+    }
+  }
+  if (config.agent.default && stageNeedsProxy(config.agent.default)) return true;
+  return needsLitellmProxy(config);
+}
 function getLitellmUrl() {
   return LITELLM_DEFAULT_URL;
 }
@@ -290,10 +625,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 (fs9.existsSync(configPath)) {
     try {
-      const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      const result = parseJsonSafe(fs9.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 },
@@ -305,7 +646,13 @@ function getProjectConfig() {
         },
         timeouts: raw.timeouts ?? void 0,
         contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
-        mcp: raw.mcp ? { enabled: false, servers: {}, stages: ["build", "verify", "review", "review-fix"], ...raw.mcp } : void 0
+        mcp: raw.mcp ? {
+          servers: {},
+          stages: ["build", "verify", "review", "review-fix"],
+          ...raw.mcp,
+          // Auto-enable when devServer is configured (user can still set enabled: false to override)
+          enabled: raw.mcp.enabled ?? !!raw.mcp.devServer
+        } : void 0
       };
     } catch {
       logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
@@ -321,6 +668,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
+    init_validators();
     DEFAULT_CONFIG = {
       quality: {
         typecheck: "pnpm -s tsc --noEmit",
@@ -354,7 +702,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" };
@@ -362,7 +710,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,
@@ -417,8 +765,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 });
@@ -450,8 +799,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 {
@@ -460,7 +810,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`);
   }
@@ -471,8 +822,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 {
@@ -487,7 +839,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";
   }
@@ -511,6 +864,17 @@ function commitAll(message, cwd) {
   logger.info(`  Committed: ${hash} ${message}`);
   return { success: true, hash, message };
 }
+function getDiffFiles(baseBranch, cwd) {
+  try {
+    const output = git(["diff", "--name-only", `origin/${baseBranch}...HEAD`], { cwd });
+    if (!output) return [];
+    return output.split("\n").filter((f) => f && !f.startsWith(".kody/"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to get diff files: ${msg}`);
+    return [];
+  }
+}
 function pushBranch(cwd) {
   try {
     git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
@@ -532,7 +896,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;
 }
@@ -542,7 +920,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,
@@ -560,12 +938,34 @@ 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;
   }
 }
+function getIssueComments(issueNumber) {
+  try {
+    const output = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${issueNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at}]"
+    ]);
+    return output ? JSON.parse(output) : [];
+  } catch {
+    return [];
+  }
+}
 function getIssueLabels(issueNumber) {
   try {
     const output = gh(["issue", "view", String(issueNumber), "--json", "labels", "--jq", ".labels[].name"]);
@@ -603,8 +1003,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;
   }
 }
@@ -642,8 +1049,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;
   }
@@ -714,9 +1120,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;
   }
 }
@@ -758,7 +1177,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;
   }
 }
@@ -780,7 +1199,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;
   }
 }
@@ -861,7 +1280,7 @@ var init_github_api = __esm({
     "use strict";
     init_logger();
     API_TIMEOUT_MS = 3e4;
-    LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed", "waiting", "low", "medium", "high"];
+    LIFECYCLE_LABELS = ["planning", "building", "review", "shipping", "done", "failed", "waiting", "low", "medium", "high"];
     KODY_MARKERS = [
       "Kody Review",
       "\u{1F916} Generated by Kody",
@@ -876,15 +1295,22 @@ var init_github_api = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs10 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 (!fs10.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(
+      fs10.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;
   }
@@ -894,11 +1320,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;
+  fs10.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs10.renameSync(tmp, target);
+  return updated;
 }
 function initState(taskId) {
   const stages = {};
@@ -912,6 +1338,8 @@ var init_state = __esm({
   "src/pipeline/state.ts"() {
     "use strict";
     init_definitions();
+    init_validators();
+    init_logger();
   }
 });
 
@@ -936,16 +1364,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs11 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 (!fs11.existsSync(memoryDir)) return "";
+  const files = fs11.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 = fs11.readFileSync(path9.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -964,15 +1392,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 fs12 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];
@@ -1059,61 +1483,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 (!fs12.existsSync(memoryDir)) return "";
+  const files = fs12.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 = fs12.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", "")}
@@ -1128,26 +1521,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 (fs12.existsSync(taskMdPath)) {
+    const content = fs12.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 (fs12.existsSync(taskJsonPath)) {
+    const content = fs12.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -1163,7 +1555,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 += `
@@ -1173,30 +1565,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 (fs12.existsSync(specPath)) {
+    const content = fs12.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 (fs12.existsSync(planPath)) {
+    const content = fs12.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 (fs12.existsSync(contextMdPath)) {
+    const content = fs12.readFileSync(contextMdPath, "utf-8");
+    const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
     const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
 ## ${label}
@@ -1211,9 +1603,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) {
@@ -1281,6 +1673,20 @@ var init_context_tiers = __esm({
 });
 
 // src/mcp-config.ts
+function withPlaywrightIfNeeded(mcpConfig, hasUI) {
+  if (!mcpConfig?.enabled || !hasUI) return mcpConfig;
+  const hasPlaywright = Object.keys(mcpConfig.servers).some(
+    (name) => name.toLowerCase().includes("playwright")
+  );
+  if (hasPlaywright) return mcpConfig;
+  return {
+    ...mcpConfig,
+    servers: {
+      ...mcpConfig.servers,
+      playwright: PLAYWRIGHT_SERVER
+    }
+  };
+}
 function buildMcpConfigJson(mcpConfig) {
   if (!mcpConfig?.enabled) return void 0;
   if (Object.keys(mcpConfig.servers).length === 0) return void 0;
@@ -1297,37 +1703,40 @@ function buildMcpConfigJson(mcpConfig) {
 }
 function isMcpEnabledForStage(stageName, mcpConfig) {
   if (!mcpConfig?.enabled) return false;
-  if (Object.keys(mcpConfig.servers).length === 0) return false;
   const allowedStages = mcpConfig.stages ?? DEFAULT_MCP_STAGES;
   return allowedStages.includes(stageName);
 }
-var DEFAULT_MCP_STAGES;
+var DEFAULT_MCP_STAGES, PLAYWRIGHT_SERVER;
 var init_mcp_config = __esm({
   "src/mcp-config.ts"() {
     "use strict";
     DEFAULT_MCP_STAGES = ["build", "verify", "review", "review-fix"];
+    PLAYWRIGHT_SERVER = {
+      command: "npx",
+      args: ["-y", "@anthropic-ai/mcp-playwright"]
+    };
   }
 });
 
 // src/context.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs13 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 (fs13.existsSync(stepFile)) {
+      return fs13.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 (fs13.existsSync(candidate)) {
+      return fs13.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -1339,18 +1748,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 (fs13.existsSync(taskMdPath)) {
+    const taskMd = fs13.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 (fs13.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs13.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -1363,27 +1772,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 (fs13.existsSync(specPath)) {
+    const spec = fs13.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 (fs13.existsSync(planPath)) {
+    const plan = fs13.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 (fs13.existsSync(contextMdPath)) {
+    const accumulated = fs13.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -1399,12 +1808,22 @@ ${feedback}
   }
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
+function inferHasUIFromScope(scope) {
+  return scope.some((filePath) => {
+    const ext = path11.extname(filePath).toLowerCase();
+    if (UI_EXTENSIONS.has(ext)) return true;
+    const normalized = filePath.replace(/\\/g, "/");
+    return UI_PATH_SEGMENTS.some((seg) => normalized.includes(seg));
+  });
+}
 function taskHasUI(taskDir) {
-  const taskJsonPath = path5.join(taskDir, "task.json");
-  if (!fs5.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path11.join(taskDir, "task.json");
+  if (!fs13.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
-    return taskDef.hasUI !== false;
+    const taskDef = JSON.parse(fs13.readFileSync(taskJsonPath, "utf-8"));
+    const scope = Array.isArray(taskDef.scope) ? taskDef.scope : [];
+    if (scope.length === 0) return true;
+    return inferHasUIFromScope(scope);
   } catch {
     return true;
   }
@@ -1523,6 +1942,11 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
+    const qaGuidePath = path11.join(projectDir, ".kody", "qa-guide.md");
+    if (fs13.existsSync(qaGuidePath)) {
+      const qaGuide = fs13.readFileSync(qaGuidePath, "utf-8").trim();
+      assembled = assembled + "\n\n" + qaGuide;
+    }
   }
   return assembled;
 }
@@ -1544,13 +1968,16 @@ ${prompt}` : prompt;
   }
   return assembled;
 }
+function escalateModelTier(currentTier) {
+  return TIER_ESCALATION[currentTier] ?? "strong";
+}
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
   const mapped = config.agent.modelMap[modelTier];
   if (mapped) return mapped;
   return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
 }
-var DEFAULT_MODEL_MAP, MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT;
+var DEFAULT_MODEL_MAP, MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT, UI_EXTENSIONS, UI_PATH_SEGMENTS, TIER_ESCALATION;
 var init_context = __esm({
   "src/context.ts"() {
     "use strict";
@@ -1566,69 +1993,43 @@ var init_context = __esm({
     MAX_TASK_CONTEXT_PLAN = 1500;
     MAX_TASK_CONTEXT_SPEC = 2e3;
     MAX_ACCUMULATED_CONTEXT = 4e3;
+    UI_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".tsx",
+      ".jsx",
+      ".vue",
+      ".svelte",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".html"
+    ]);
+    UI_PATH_SEGMENTS = [
+      "/components/",
+      "/pages/",
+      "/layouts/",
+      "/styles/",
+      "/views/"
+    ];
+    TIER_ESCALATION = {
+      cheap: "mid",
+      mid: "strong",
+      strong: "strong"
+    };
   }
 });
 
-// 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();
-  const runnerName = config.agent.stageRunners?.[stageName] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
-  const runner = ctx.runners[runnerName];
-  if (!runner) {
-    throw new Error(
-      `Runner "${runnerName}" not found for stage ${stageName}. Available: ${Object.keys(ctx.runners).join(", ")}`
-    );
-  }
-  return runner;
+// src/pipeline/runner-selection.ts
+function getRunnerForStage(ctx, stageName) {
+  const config = getProjectConfig();
+  const runnerName = config.agent.stageRunners?.[stageName] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
+  const runner = ctx.runners[runnerName];
+  if (!runner) {
+    throw new Error(
+      `Runner "${runnerName}" not found for stage ${stageName}. Available: ${Object.keys(ctx.runners).join(", ")}`
+    );
+  }
+  return runner;
 }
 var init_runner_selection = __esm({
   "src/pipeline/runner-selection.ts"() {
@@ -1638,8 +2039,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -1669,15 +2070,19 @@ async function executeAgentStage(ctx, def) {
     return { outcome: "completed", retries: 0 };
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
-  const model = resolveModel(def.modelTier, def.name);
+  let currentModelTier = def.modelTier;
   if (ctx.input.feedback && def.name === "build") {
     logger.info(`  feedback: ${ctx.input.feedback.slice(0, 200)}${ctx.input.feedback.length > 200 ? "..." : ""}`);
   }
   const config = getProjectConfig();
+  const sc = resolveStageConfig(config, def.name, def.modelTier);
+  let model = sc.model;
+  const useProxy = stageNeedsProxy(sc);
+  const escalateEnabled = config.agent.escalateOnTimeout !== false;
   const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
-  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
+  logger.info(`  runner=${runnerName} provider=${sc.provider} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
-  if (needsLitellmProxy(config)) {
+  if (useProxy) {
     extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
   }
   const sessions = ctx.sessions ?? {};
@@ -1685,42 +2090,64 @@ async function executeAgentStage(ctx, def) {
   if (sessionInfo) {
     logger.info(`  session: ${SESSION_GROUP[def.name]} (${sessionInfo.resumeSession ? "resume" : "new"})`);
   }
-  const mcpConfigJson = isMcpEnabledForStage(def.name, config.mcp) ? buildMcpConfigJson(config.mcp) : void 0;
+  const mcpForStage = isMcpEnabledForStage(def.name, config.mcp) ? withPlaywrightIfNeeded(config.mcp, taskHasUI(ctx.taskDir)) : void 0;
+  const mcpConfigJson = buildMcpConfigJson(mcpForStage);
   if (mcpConfigJson) {
     logger.info(`  MCP servers enabled for ${def.name}`);
   }
   const runner = getRunnerForStage(ctx, def.name);
-  const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+  const maxRetries = def.maxRetries ?? 0;
+  let lastResult = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
     cwd: ctx.projectDir,
     env: extraEnv,
     ...sessionInfo,
     mcpConfigJson
   });
-  if (result.outcome !== "completed") {
-    return { outcome: result.outcome, error: result.error, retries: 0 };
+  let retries = 0;
+  while (lastResult.outcome !== "completed" && retries < maxRetries) {
+    retries++;
+    const isTimeout = lastResult.outcome === "timed_out";
+    if (isTimeout && escalateEnabled) {
+      const nextTier = escalateModelTier(currentModelTier);
+      if (nextTier !== currentModelTier) {
+        logger.info(`  Escalating model from ${currentModelTier} to ${nextTier} after timeout`);
+        currentModelTier = nextTier;
+        model = resolveModel(currentModelTier, def.name);
+      }
+    }
+    logger.info(`  retry ${retries}/${maxRetries} with model=${model}`);
+    lastResult = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+      cwd: ctx.projectDir,
+      env: extraEnv,
+      mcpConfigJson
+    });
+  }
+  if (lastResult.outcome !== "completed") {
+    return { outcome: lastResult.outcome, error: lastResult.error, retries };
   }
+  const result = lastResult;
   if (def.outputFile && result.output) {
-    fs6.writeFileSync(path6.join(ctx.taskDir, def.outputFile), result.output);
+    fs14.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 (!fs14.existsSync(outputPath)) {
+      const ext = path12.extname(def.outputFile);
+      const base = path12.basename(def.outputFile, ext);
+      const files = fs14.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs6.renameSync(path6.join(ctx.taskDir, variant), outputPath);
+        fs14.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 (fs14.existsSync(outputPath)) {
+      const content = fs14.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -1734,7 +2161,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs6.writeFileSync(outputPath, retryResult.output);
+              fs14.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -1745,10 +2172,9 @@ async function executeAgentStage(ctx, def) {
                 description: plainText.slice(0, 500),
                 scope: [],
                 risk_level: "low",
-                hasUI: false,
                 questions: []
               }, null, 2);
-              fs6.writeFileSync(outputPath, fallback);
+              fs14.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -1759,10 +2185,10 @@ async function executeAgentStage(ctx, def) {
     }
   }
   appendStageContext(ctx.taskDir, def.name, result.output);
-  return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+  return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 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()) {
@@ -1775,7 +2201,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs6.appendFileSync(contextPath, entry);
+  fs14.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -1798,7 +2224,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;
 }
@@ -1834,7 +2260,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",
@@ -1905,7 +2331,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}`,
@@ -1930,42 +2356,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,
@@ -1974,7 +2406,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 [];
   }
 }
@@ -1983,6 +2416,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.
@@ -2006,8 +2440,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -2050,7 +2484,7 @@ ${output}
 `);
     }
   }
-  fs7.writeFileSync(path7.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs15.writeFileSync(path13.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -2065,9 +2499,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 fs16 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++) {
@@ -2077,8 +2511,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 = fs16.existsSync(verifyPath) ? fs16.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -2121,7 +2555,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
           });
@@ -2174,18 +2608,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 fs17 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 (!fs17.existsSync(tasksDir)) return null;
+  const allDirs = fs17.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
   const prefix = `${issueNumber}-`;
   const direct = allDirs.find((d) => d.startsWith(prefix));
   if (direct) return direct;
   try {
-    const branch = execFileSync7("git", ["branch", "--show-current"], {
+    const branch = execFileSync12("git", ["branch", "--show-current"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2207,15 +2641,39 @@ function generateTaskId() {
   const pad = (n) => String(n).padStart(2, "0");
   return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
 }
+function resolveTaskIdFromComments(issueNumber) {
+  try {
+    const comments = getIssueComments(issueNumber);
+    const pattern = /pipeline started: `([^`]+)`/;
+    let latestTaskId = null;
+    for (const comment of comments) {
+      const match = comment.body.match(pattern);
+      if (match) {
+        latestTaskId = match[1];
+      }
+    }
+    return latestTaskId;
+  } catch {
+    return null;
+  }
+}
+function resolveTaskIdForCommand(issueNumber, projectDir) {
+  const fromTasks = findLatestTaskForIssue(issueNumber, projectDir);
+  if (fromTasks) return fromTasks;
+  const fromComments = resolveTaskIdFromComments(issueNumber);
+  if (fromComments) return fromComments;
+  return null;
+}
 var init_task_resolution = __esm({
   "src/cli/task-resolution.ts"() {
     "use strict";
+    init_github_api();
   }
 });
 
 // src/review-standalone.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs18 from "fs";
+import * as path16 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -2239,17 +2697,35 @@ 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 diffInstruction = input.baseBranch ? `
+  const taskDir = path16.join(input.projectDir, ".kody", "tasks", taskId);
+  fs18.mkdirSync(taskDir, { recursive: true });
+  let diffInstruction = "";
+  let filesChangedSection = "";
+  if (input.baseBranch) {
+    diffInstruction = `
 
 ## Diff Command
 Run: \`git diff origin/${input.baseBranch}...HEAD\` to see the PR changes.
-Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree changes, not the PR diff.` : "";
+Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree changes, not the PR diff.`;
+    const diffFiles = getDiffFiles(input.baseBranch, input.projectDir);
+    if (diffFiles.length > 0) {
+      logger.info(`[review] Review scope: git diff origin/${input.baseBranch}...HEAD (${diffFiles.length} files)`);
+      const fileList = diffFiles.map((f) => `- ${f}`).join("\n");
+      filesChangedSection = `
+
+## Files Changed
+Only review the following ${diffFiles.length} files (these are the files changed in this PR):
+${fileList}`;
+    } else {
+      logger.info(`[review] Review scope: git diff origin/${input.baseBranch}...HEAD (0 files)`);
+    }
+  } else {
+    logger.warn(`[review] No baseBranch provided \u2014 reviewing all files (no diff scope)`);
+  }
   const taskContent = `# ${input.prTitle}
 
-${input.prBody ?? ""}${diffInstruction}`;
-  fs10.writeFileSync(path10.join(taskDir, "task.md"), taskContent);
+${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
+  fs18.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2271,10 +2747,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 (fs18.existsSync(reviewPath)) {
+    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2309,12 +2785,13 @@ var init_review_standalone = __esm({
     init_agent();
     init_task_resolution();
     init_logger();
+    init_git_utils();
   }
 });
 
 // src/stages/review.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -2328,11 +2805,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 (!fs19.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs11.readFileSync(reviewFile, "utf-8");
+    const content = fs19.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -2361,15 +2838,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 fs20 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 (fs20.existsSync(taskJsonPath)) {
     try {
-      const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs20.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2388,9 +2865,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 (fs20.existsSync(reviewPath)) {
+    const review = fs20.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2407,14 +2884,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 (fs20.existsSync(verifyPath)) {
+    const verify = fs20.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 (fs20.existsSync(planPath)) {
+    const plan = fs20.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2434,25 +2911,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");
+    fs20.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");
+    fs20.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"
@@ -2466,7 +2943,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();
@@ -2487,28 +2964,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 (fs20.existsSync(taskJsonPath)) {
       try {
-        const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs20.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 (fs20.existsSync(taskMdPath)) {
+      const content = fs20.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 (fs20.existsSync(taskJsonPath)) {
         try {
-          const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs20.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);
@@ -2531,7 +3008,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs12.writeFileSync(shipPath, `# Ship
+      fs20.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2552,22 +3029,26 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs12.writeFileSync(shipPath, `# Ship
+        fs20.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs12.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs20.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 {
+      fs20.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
+    } catch {
+      logger.warn(`  Failed to write ship.md artifact`);
+    }
     return { outcome: "failed", retries: 0, error: msg };
   }
 }
@@ -2610,15 +3091,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs21 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 (!fs21.existsSync(taskJsonPath)) return false;
+      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.questions && Array.isArray(taskJson.questions) && taskJson.questions.length > 0) {
@@ -2633,9 +3114,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 (!fs21.existsSync(planPath)) return false;
+      const plan = fs21.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2664,12 +3145,13 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs22 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");
   if (def.name === "review") setLifecycleLabel(ctx.input.issueNumber, "review");
+  if (def.name === "ship") setLifecycleLabel(ctx.input.issueNumber, "shipping");
 }
 function checkQuestionsAfterStage(ctx, def, state) {
   if (def.name !== "taskify" && def.name !== "plan") return null;
@@ -2702,9 +3184,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 (!fs22.existsSync(taskJsonPath)) return null;
+    const raw = fs22.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;
@@ -2734,8 +3216,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 = fs22.existsSync(planPath) ? fs22.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2802,22 +3284,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs23 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 (!fs23.existsSync(memoryDir)) {
+      fs23.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 (fs23.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs23.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");
@@ -2826,18 +3308,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 (fs23.existsSync(reviewPath)) {
+      const review = fs23.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 (fs23.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs15.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs23.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)) {
@@ -2848,135 +3330,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"));
+      fs23.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 (fs23.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"));
+    fs23.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 fs24 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 (!fs24.existsSync(p)) return null;
   try {
-    const content = fs16.readFileSync(p, "utf-8");
+    const content = fs24.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -3029,13 +3424,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 (!fs24.existsSync(logPath)) return [];
   try {
-    const content = fs16.readFileSync(logPath, "utf-8");
+    const content = fs24.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -3062,11 +3457,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 (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
   }
-  fs16.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs24.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -3176,9 +3571,66 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
   }
 });
 
+// src/pipeline/summary.ts
+function formatDuration(ms) {
+  const totalSec = Math.round(ms / 1e3);
+  if (totalSec < 60) return `${totalSec}s`;
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return `${min}m ${sec}s`;
+}
+function stageDuration(stage) {
+  if (!stage.startedAt) return "-";
+  const start = new Date(stage.startedAt).getTime();
+  const end = stage.completedAt ? new Date(stage.completedAt).getTime() : Date.now();
+  if (isNaN(start) || isNaN(end)) return "-";
+  return formatDuration(end - start);
+}
+function formatPipelineSummary(state, options) {
+  const lines = [];
+  lines.push(`## Pipeline Summary: \`${state.taskId}\``);
+  lines.push("");
+  lines.push("| Stage | Status | Duration | Retries |");
+  lines.push("|-------|--------|----------|---------|");
+  for (const def of STAGES) {
+    const s = state.stages[def.name];
+    if (!s) continue;
+    const status = STATUS_ICONS[s.state] ?? s.state;
+    const duration = stageDuration(s);
+    const retries = s.retries ?? 0;
+    lines.push(`| ${def.name} | ${status} | ${duration} | ${retries} |`);
+  }
+  const totalMs = new Date(state.updatedAt).getTime() - new Date(state.createdAt).getTime();
+  const totalStr = isNaN(totalMs) || totalMs < 0 ? "-" : formatDuration(totalMs);
+  lines.push("");
+  const footerParts = [`**Total:** ${totalStr}`];
+  if (options?.complexity) {
+    footerParts.push(`**Complexity:** ${options.complexity}`);
+  }
+  if (options?.model) {
+    footerParts.push(`**Model:** ${options.model}`);
+  }
+  lines.push(footerParts.join(" | "));
+  return lines.join("\n");
+}
+var STATUS_ICONS;
+var init_summary = __esm({
+  "src/pipeline/summary.ts"() {
+    "use strict";
+    init_definitions();
+    STATUS_ICONS = {
+      completed: "completed",
+      failed: "failed",
+      timeout: "timeout",
+      running: "running",
+      pending: "pending"
+    };
+  }
+});
+
 // src/pipeline.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -3191,34 +3643,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 = fs25.existsSync(taskMdPath) ? fs25.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 (fs25.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(fs25.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 {
+      fs25.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+  try {
+    const fd = fs25.openSync(lockPath, fs25.constants.O_WRONLY | fs25.constants.O_CREAT | fs25.constants.O_EXCL);
+    fs25.writeSync(fd, String(process.pid));
+    fs25.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"));
+    fs25.unlinkSync(path23.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3230,17 +3707,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 {
     }
@@ -3365,8 +3842,27 @@ 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)}`);
   });
+  if (ctx.input.issueNumber && !ctx.input.dryRun) {
+    const config = getProjectConfig();
+    const isCI3 = !!process.env.GITHUB_ACTIONS;
+    const shouldPost = config.github.postSummary ?? (isCI3 ? true : false);
+    if (shouldPost) {
+      try {
+        const summaryOpts = {};
+        if (complexity) summaryOpts.complexity = complexity;
+        const modelMap = config.agent?.modelMap;
+        if (modelMap?.mid) summaryOpts.model = modelMap.mid;
+        const summary = formatPipelineSummary(state, summaryOpts);
+        postComment(ctx.input.issueNumber, summary);
+        logger.info("Pipeline summary posted on issue");
+      } catch (err) {
+        logger.warn(`  Failed to post pipeline summary: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
   return state;
 }
 function printStatus(taskId, taskDir) {
@@ -3401,12 +3897,14 @@ var init_pipeline = __esm({
     init_hooks();
     init_auto_learn();
     init_retrospective();
+    init_summary();
+    init_config();
   }
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync9 } from "child_process";
-import * as fs18 from "fs";
+import { execFileSync as execFileSync14 } from "child_process";
+import * as fs26 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3418,7 +3916,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"]
@@ -3426,14 +3924,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"]
@@ -3441,7 +3939,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"]
@@ -3451,7 +3949,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"]
@@ -3459,7 +3957,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs18.existsSync("package.json")) throw new Error("not found");
+      if (!fs26.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3536,10 +4034,10 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs19 from "fs";
+import * as fs27 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) });
@@ -3594,22 +4092,49 @@ function generateLitellmConfig(provider, modelMap) {
   }
   return entries.join("\n") + "\n";
 }
+function generateLitellmConfigFromStages(defaultConfig, stages) {
+  const proxyModels = [];
+  if (defaultConfig && defaultConfig.provider !== "claude" && defaultConfig.provider !== "anthropic") {
+    proxyModels.push(defaultConfig);
+  }
+  if (stages) {
+    for (const sc of Object.values(stages)) {
+      if (sc.provider !== "claude" && sc.provider !== "anthropic") {
+        proxyModels.push(sc);
+      }
+    }
+  }
+  if (proxyModels.length === 0) return void 0;
+  const entries = ["model_list:"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { provider, model } of proxyModels) {
+    const key = `${provider}/${model}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const apiKeyVar = providerApiKeyEnvVar(provider);
+    entries.push(`  - model_name: ${model}`);
+    entries.push(`    litellm_params:`);
+    entries.push(`      model: ${provider}/${model}`);
+    entries.push(`      api_key: os.environ/${apiKeyVar}`);
+  }
+  return entries.join("\n") + "\n";
+}
 async function tryStartLitellm(url, projectDir, generatedConfig) {
   if (!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");
+  fs27.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 {
     }
@@ -3622,19 +4147,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];
+    args2 = ["--config", configPath, "--port", port, "--no_db"];
   } catch {
     cmd = "python3";
-    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port, "--no_db"];
   }
-  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 (fs27.existsSync(dotenvPath)) {
+    for (const rawLine of fs27.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(", ")}`);
@@ -3673,8 +4208,8 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs28 from "fs";
+import * as path25 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -3706,11 +4241,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 (fs28.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs20.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs28.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -3743,12 +4278,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"]
@@ -3867,10 +4402,10 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 async function ensureLitellmProxy(config, projectDir) {
-  if (!needsLitellmProxy(config)) return null;
+  if (!anyStageNeedsProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
   const proxyRunning = await checkLitellmHealth(litellmUrl);
   let litellmProcess = null;
@@ -3883,7 +4418,9 @@ async function ensureLitellmProxy(config, projectDir) {
       }
     }
     let generatedConfig;
-    if (config.agent.provider && config.agent.provider !== "anthropic") {
+    if (config.agent.stages || config.agent.default) {
+      generatedConfig = generateLitellmConfigFromStages(config.agent.default, config.agent.stages);
+    } else if (config.agent.provider && config.agent.provider !== "anthropic") {
       generatedConfig = generateLitellmConfig(config.agent.provider, config.agent.modelMap);
     }
     litellmProcess = await tryStartLitellm(litellmUrl, projectDir, generatedConfig);
@@ -3894,10 +4431,9 @@ async function ensureLitellmProxy(config, projectDir) {
   } else {
     logger.info(`LiteLLM proxy already running at ${litellmUrl}`);
   }
-  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";
+  logger.info(`LiteLLM proxy available at ${litellmUrl}`);
+  if (!process.env.ANTHROPIC_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = `sk-ant-api03-${"0".repeat(64)}`;
   }
   return litellmProcess;
 }
@@ -3922,9 +4458,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 (!fs29.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -3958,15 +4494,26 @@ 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}`);
     }
   }
   let taskId = input.taskId;
   if (!taskId) {
-    if (isPRFix) {
+    if ((input.command === "rerun" || input.command === "status") && input.issueNumber) {
+      const resolved = resolveTaskIdForCommand(input.issueNumber, projectDir);
+      if (resolved) {
+        taskId = resolved;
+        logger.info(`Auto-resolved task-id: ${taskId} (from issue #${input.issueNumber})`);
+      } else {
+        console.error(`No task found for issue #${input.issueNumber}. Provide --task-id explicitly.`);
+        process.exit(1);
+      }
+    } else if (isPRFix) {
       taskId = `${input.command === "fix-ci" ? "fixci" : "fix"}-pr-${input.prNumber}-${generateTaskId()}`;
     } else if (input.issueNumber) {
       taskId = `${input.issueNumber}-${generateTaskId()}`;
@@ -3979,8 +4526,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);
+  fs29.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -4085,7 +4632,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);
@@ -4096,31 +4643,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs21.writeFileSync(path20.join(taskDir, "task.md"), input.task);
+    fs29.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 (!fs29.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);
+      fs29.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs21.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs29.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);
+      fs29.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs21.existsSync(taskMdPath)) {
+  if (!fs29.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -4192,7 +4739,7 @@ ${input.feedback}`);
   await runModelHealthCheck(config);
   const cleanupLitellm = () => {
     if (litellmProcess) {
-      litellmProcess.kill?.();
+      litellmProcess.kill();
       litellmProcess = null;
     }
   };
@@ -4258,7 +4805,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs21.readdirSync(taskDir);
+  const files = fs29.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -4322,20 +4869,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 fs30 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"]
@@ -4346,14 +4894,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,
@@ -4371,7 +4919,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,
@@ -4382,7 +4930,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,
@@ -4395,7 +4943,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"]
@@ -4416,14 +4964,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,
@@ -4432,7 +4986,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,
@@ -4445,7 +4999,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,
@@ -4463,7 +5017,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 {};
     }
@@ -4495,7 +5049,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);
@@ -4507,12 +5060,7 @@ function detectMcpConfig(cwd, pm, pkg) {
   const defaultPort = isNext ? 3e3 : isVite ? 5173 : 3e3;
   const mcp = {
     enabled: true,
-    servers: {
-      playwright: {
-        command: "npx",
-        args: ["@playwright/mcp@latest"]
-      }
-    },
+    servers: {},
     stages: ["build", "review"]
   };
   if (hasDevScript) {
@@ -4523,7 +5071,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
@@ -4531,35 +5081,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)");
@@ -4567,10 +5117,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) {
@@ -4584,26 +5134,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}` });
@@ -4633,11 +5176,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,
@@ -4648,13 +5191,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");
@@ -4696,22 +5239,300 @@ function initCommand(opts) {
     console.log("");
   }
 }
+
+// src/bin/commands/bootstrap.ts
+init_architecture_detection();
+import * as fs7 from "fs";
+import * as path6 from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+
+// src/bin/qa-guide.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+function discoverQaContext(cwd) {
+  const result = {
+    routes: [],
+    authFiles: [],
+    loginPage: null,
+    adminPath: null,
+    roles: [],
+    devCommand: "",
+    devPort: 3e3
+  };
+  try {
+    const pkg = JSON.parse(fs5.readFileSync(path4.join(cwd, "package.json"), "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const pm = fs5.existsSync(path4.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs5.existsSync(path4.join(cwd, "yarn.lock")) ? "yarn" : "npm";
+    if (pkg.scripts?.dev) result.devCommand = `${pm} dev`;
+    if (allDeps.next || allDeps.nuxt) result.devPort = 3e3;
+    else if (allDeps.vite) result.devPort = 5173;
+  } catch {
+  }
+  const appDirs = ["src/app", "app"];
+  for (const appDir of appDirs) {
+    const fullAppDir = path4.join(cwd, appDir);
+    if (!fs5.existsSync(fullAppDir)) continue;
+    scanRoutes(fullAppDir, appDir, "", result);
+    break;
+  }
+  const authPatterns = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js"];
+  for (const p of authPatterns) {
+    if (fs5.existsSync(path4.join(cwd, p))) result.authFiles.push(p);
+  }
+  const authConfigGlobs = [
+    "src/app/api/auth",
+    "src/auth",
+    "src/lib/auth",
+    "auth.config.ts",
+    "auth.ts",
+    "src/app/api/oauth"
+  ];
+  for (const g of authConfigGlobs) {
+    if (fs5.existsSync(path4.join(cwd, g))) result.authFiles.push(g);
+  }
+  try {
+    const rolePaths = [
+      "src/types",
+      "src/lib",
+      "src/utils",
+      "src/constants",
+      "src/access",
+      "src/collections"
+    ];
+    for (const rp of rolePaths) {
+      const dir = path4.join(cwd, rp);
+      if (!fs5.existsSync(dir)) continue;
+      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      for (const f of files) {
+        try {
+          const content = fs5.readFileSync(path4.join(dir, f), "utf-8").slice(0, 5e3);
+          const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
+          if (roleMatches) {
+            for (const m of roleMatches) {
+              const val = m.match(/['"](\w+)['"]/);
+              if (val && !result.roles.includes(val[1])) result.roles.push(val[1]);
+            }
+          }
+          const enumMatch = content.match(/(?:enum|type)\s+\w*[Rr]ole\w*\s*[={]([^}]+)/s);
+          if (enumMatch) {
+            const vals = enumMatch[1].match(/['"](\w+)['"]/g);
+            if (vals) {
+              for (const v of vals) {
+                const clean = v.replace(/['"]/g, "");
+                if (!result.roles.includes(clean)) result.roles.push(clean);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function scanRoutes(dir, baseDir, prefix, result) {
+  let entries;
+  try {
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const hasPage = entries.some((e) => e.isFile() && /^page\.(tsx?|jsx?)$/.test(e.name));
+  if (hasPage) {
+    const routePath = prefix || "/";
+    const group = prefix.startsWith("/admin") ? "admin" : prefix.includes("/login") ? "auth" : prefix.includes("/signup") ? "auth" : prefix.includes("/api") ? "api" : "frontend";
+    result.routes.push({ path: routePath, group });
+    if (prefix.includes("/login")) result.loginPage = routePath;
+    if (prefix.startsWith("/admin") && !result.adminPath) result.adminPath = prefix;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "node_modules" || entry.name === ".next") continue;
+    let segment = entry.name;
+    if (segment.startsWith("(") && segment.endsWith(")")) {
+      scanRoutes(path4.join(dir, entry.name), baseDir, prefix, result);
+      continue;
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      segment = `:${segment.slice(1, -1)}`;
+    }
+    if (segment.startsWith("[[") && segment.endsWith("]]")) {
+      segment = `:${segment.slice(2, -2)}?`;
+    }
+    scanRoutes(path4.join(dir, entry.name), baseDir, `${prefix}/${segment}`, result);
+  }
+}
+function generateQaGuide(discovery) {
+  const lines = ["# QA Guide", "", "## Authentication", ""];
+  if (discovery.loginPage) {
+    lines.push(`- Login page: \`${discovery.loginPage}\``);
+  }
+  lines.push(
+    "",
+    "### Test Accounts",
+    "<!-- Fill in your test/preview environment credentials below -->",
+    "| Role | Email | Password |",
+    "|------|-------|----------|",
+    "| Admin | admin@example.com | CHANGE_ME |",
+    "| User | user@example.com | CHANGE_ME |",
+    "",
+    "### Login Steps",
+    `1. Navigate to \`${discovery.loginPage ?? "/login"}\``,
+    "2. Enter credentials from the test accounts table above",
+    "3. Submit the login form",
+    "4. Verify redirect to dashboard or home page"
+  );
+  if (discovery.authFiles.length > 0) {
+    lines.push("", "### Auth Files");
+    for (const f of discovery.authFiles) {
+      lines.push(`- \`${f}\``);
+    }
+  }
+  if (discovery.roles.length > 0) {
+    lines.push("", "## Roles", "");
+    for (const role of discovery.roles) {
+      lines.push(`- \`${role}\``);
+    }
+  }
+  lines.push("", "## Key Pages", "");
+  const groups = {};
+  for (const route of discovery.routes) {
+    if (!groups[route.group]) groups[route.group] = [];
+    groups[route.group].push(route.path);
+  }
+  for (const [group, routes] of Object.entries(groups)) {
+    lines.push(`### ${group.charAt(0).toUpperCase() + group.slice(1)}`);
+    const sorted = routes.sort();
+    for (const r of sorted.slice(0, 20)) {
+      lines.push(`- \`${r}\``);
+    }
+    if (sorted.length > 20) {
+      lines.push(`- ... and ${sorted.length - 20} more`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    "## Dev Server",
+    "",
+    `- Command: \`${discovery.devCommand || "pnpm dev"}\``,
+    `- URL: \`http://localhost:${discovery.devPort}\``,
+    ""
+  );
+  return lines.join("\n");
+}
+
+// src/bin/skills.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+var SKILL_MAPPINGS = [
+  {
+    detect: (deps) => "next" in deps,
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => "react" in deps && !("next" in deps),
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => FRONTEND_DEPS.some((d) => d in deps),
+    skills: [
+      { package: "microsoft/playwright-cli@playwright-cli", label: "Playwright browser automation" }
+    ]
+  }
+];
+function detectSkillsForProject(cwd) {
+  const pkgPath = path5.join(cwd, "package.json");
+  if (!fs6.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    for (const mapping of SKILL_MAPPINGS) {
+      if (mapping.detect(allDeps)) {
+        for (const skill of mapping.skills) {
+          if (!seen.has(skill.package)) {
+            seen.add(skill.package);
+            skills.push(skill);
+          }
+        }
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function installSkillsForProject(cwd) {
+  const skills = detectSkillsForProject(cwd);
+  if (skills.length === 0) {
+    console.log("  \u25CB No skills to install (no frontend framework detected)");
+    return [];
+  }
+  let installedSkills = {};
+  const lockPath = path5.join(cwd, "skills-lock.json");
+  if (fs6.existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(fs6.readFileSync(lockPath, "utf-8"));
+      installedSkills = lock.skills ?? {};
+    } catch {
+    }
+  }
+  const installedPaths = [];
+  for (const skill of skills) {
+    const skillName = skill.package.split("@").pop() ?? "";
+    if (skillName in installedSkills) {
+      console.log(`  \u25CB ${skill.label} \u2014 already installed`);
+      const agentPath = `.agents/skills/${skillName}`;
+      const claudePath = `.claude/skills/${skillName}`;
+      if (fs6.existsSync(path5.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs6.existsSync(path5.join(cwd, claudePath))) installedPaths.push(claudePath);
+      continue;
+    }
+    try {
+      console.log(`  Installing: ${skill.label} (${skill.package})`);
+      execFileSync4("npx", ["skills", "add", skill.package, "--yes"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const installedName = skill.package.split("@").pop() ?? "";
+      const agentPath = `.agents/skills/${installedName}`;
+      const claudePath = `.claude/skills/${installedName}`;
+      if (fs6.existsSync(path5.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs6.existsSync(path5.join(cwd, claudePath))) installedPaths.push(claudePath);
+      console.log(`  \u2713 ${skill.label}`);
+    } catch {
+      console.log(`  \u2717 ${skill.label} \u2014 failed to install`);
+    }
+  }
+  return installedPaths;
+}
+
+// src/bin/commands/bootstrap.ts
 var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path21.join(cwd, "src");
-  const baseDir = fs22.existsSync(srcDir) ? srcDir : cwd;
+  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 fs22.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path21.join(dir, entry.name);
+        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 = fs22.statSync(full);
+            const stat = fs7.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -4725,8 +5546,8 @@ function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
   }
   const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
   for (const { filePath } of files) {
-    const rel = path21.relative(cwd, filePath);
-    const content = fs22.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    const rel = path6.relative(cwd, filePath);
+    const content = fs7.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
     results.push(`### File: ${rel}
 \`\`\`typescript
 ${content}
@@ -4738,9 +5559,9 @@ function ghComment(issueNumber, body, cwd) {
   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}`;
         }
@@ -4748,7 +5569,7 @@ function ghComment(issueNumber, body, cwd) {
     } catch {
     }
     if (!repoSlug) return;
-    execFileSync12("gh", [
+    execFileSync5("gh", [
       "issue",
       "comment",
       String(issueNumber),
@@ -4765,7 +5586,7 @@ function ghComment(issueNumber, body, cwd) {
   } catch {
   }
 }
-function bootstrapCommand(opts = { force: false }) {
+function bootstrapCommand(opts, pkgRoot) {
   const cwd = process.cwd();
   const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
   console.log(`
@@ -4775,8 +5596,8 @@ function bootstrapCommand(opts = { force: false }) {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path21.join(cwd, rel);
-    if (fs22.existsSync(p)) return fs22.readFileSync(p, "utf-8").slice(0, maxChars);
+    const p = path6.join(cwd, rel);
+    if (fs7.existsSync(p)) return fs7.readFileSync(p, "utf-8").slice(0, maxChars);
     return null;
   };
   let repoContext = "";
@@ -4811,14 +5632,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(", ")}
 
@@ -4828,19 +5649,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)
@@ -4881,7 +5702,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",
@@ -4896,12 +5717,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)`);
     }
@@ -4910,39 +5731,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;
@@ -4984,7 +5805,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",
@@ -4999,23 +5820,40 @@ 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 = path6.join(cwd, ".kody", "qa-guide.md");
+  if (!fs7.existsSync(qaGuidePath) || opts.force) {
+    const discovery = discoverQaContext(cwd);
+    if (discovery.routes.length > 0) {
+      const qaGuide = generateQaGuide(discovery);
+      fs7.writeFileSync(qaGuidePath, qaGuide);
+      console.log(`  \u2713 .kody/qa-guide.md (${discovery.routes.length} routes, ${discovery.roles.length} roles)`);
+      if (discovery.loginPage) console.log(`  \u2713 Login page detected: ${discovery.loginPage}`);
+      if (discovery.adminPath) console.log(`  \u2713 Admin panel detected: ${discovery.adminPath}`);
+      console.log("  \u2139 Add QA_ADMIN_EMAIL, QA_ADMIN_PASSWORD, QA_USER_EMAIL, QA_USER_PASSWORD as GitHub secrets");
+    } else {
+      console.log("  \u25CB No routes detected \u2014 skipping QA guide");
+    }
+  } else {
+    console.log("  \u25CB .kody/qa-guide.md already exists (use --force to regenerate)");
+  }
   console.log("\n\u2500\u2500 Labels \u2500\u2500");
   try {
     let repoSlug = "";
     try {
-      const configPath = 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}`;
         }
@@ -5027,6 +5865,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
         { name: "kody:planning", color: "c5def5", description: "Kody is analyzing and planning" },
         { name: "kody:building", color: "0e8a16", description: "Kody is building code" },
         { name: "kody:review", color: "fbca04", description: "Kody is reviewing code" },
+        { name: "kody:shipping", color: "1d76db", description: "Kody is creating the pull request" },
         { name: "kody:done", color: "0e8a16", description: "Kody completed successfully" },
         { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" },
         { name: "kody:waiting", color: "fef2c0", description: "Kody is waiting for answers" },
@@ -5041,7 +5880,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,
@@ -5061,7 +5900,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,
@@ -5085,22 +5924,23 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   const filesToCommit = [
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md",
+    ".kody/qa-guide.md",
     ...installedSkillPaths
-  ].filter((f) => 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,
@@ -5116,24 +5956,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",
@@ -5172,13 +6012,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");
@@ -5198,131 +6038,24 @@ Create it manually.`, cwd);
   console.log("  \u2713 Project bootstrap complete!");
   console.log("  Kody now has project-specific memory and customized step files.\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(fs30.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 === "ci-parse") {
+  Promise.resolve().then(() => (init_parse_inputs(), parse_inputs_exports)).then(({ runCiParse: runCiParse2 }) => runCiParse2());
 } else if (command === "version" || command === "--version" || command === "-v") {
   console.log(getVersion());
 } else {
@@ -5330,7 +6063,7 @@ if (command === "init") {
 }
 export {
   buildConfig,
-  checkCommand2 as checkCommand,
+  checkCommand,
   checkFile,
   checkGhAuth,
   checkGhRepoAccess,