@kody-ade/kody-engine-lite 0.1.112 → 0.1.113

package/dist/agent-runner.d.ts

@@ -0,0 +1,4 @@
+import type { AgentRunner } from "./types.js";
+import type { KodyConfig } from "./config.js";
+export declare function createClaudeCodeRunner(): AgentRunner;
+export declare function createRunners(config: KodyConfig): Record<string, AgentRunner>;

package/dist/agent-runner.js

@@ -0,0 +1,122 @@
+import { spawn, execFileSync } from "child_process";
+const SIGKILL_GRACE_MS = 5000;
+const STDERR_TAIL_CHARS = 500;
+function writeStdin(child, prompt) {
+    return new Promise((resolve, reject) => {
+        if (!child.stdin) {
+            resolve();
+            return;
+        }
+        child.stdin.write(prompt, (err) => {
+            if (err)
+                reject(err);
+            else {
+                child.stdin.end();
+                resolve();
+            }
+        });
+    });
+}
+function waitForProcess(child, timeout) {
+    return new Promise((resolve) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                if (!child.killed)
+                    child.kill("SIGKILL");
+            }, SIGKILL_GRACE_MS);
+        }, timeout);
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            resolve({
+                code,
+                stdout: Buffer.concat(stdoutChunks).toString(),
+                stderr: Buffer.concat(stderrChunks).toString(),
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({ code: -1, stdout: "", stderr: err.message });
+        });
+    });
+}
+async function runSubprocess(command, args, prompt, timeout, options) {
+    const child = spawn(command, args, {
+        cwd: options?.cwd ?? process.cwd(),
+        env: {
+            ...process.env,
+            SKIP_BUILD: "1",
+            SKIP_HOOKS: "1",
+            ...options?.env,
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    try {
+        await writeStdin(child, prompt);
+    }
+    catch (err) {
+        return {
+            outcome: "failed",
+            error: `Failed to send prompt: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const { code, stdout, stderr } = await waitForProcess(child, timeout);
+    if (code === 0) {
+        return { outcome: "completed", output: stdout };
+    }
+    return {
+        outcome: code === null ? "timed_out" : "failed",
+        error: `Exit code ${code}\n${stderr.slice(-STDERR_TAIL_CHARS)}`,
+    };
+}
+function checkCommand(command, args) {
+    try {
+        execFileSync(command, args, { timeout: 10_000, stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Claude Code Runner ──────────────────────────────────────────────────────
+export function createClaudeCodeRunner() {
+    return {
+        async run(_stageName, prompt, model, timeout, _taskDir, options) {
+            return runSubprocess("claude", [
+                "--print",
+                "--model", model,
+                "--dangerously-skip-permissions",
+                "--allowedTools", "Bash,Edit,Read,Write,Glob,Grep",
+            ], prompt, timeout, options);
+        },
+        async healthCheck() {
+            return checkCommand("claude", ["--version"]);
+        },
+    };
+}
+// ─── Runner Factory ──────────────────────────────────────────────────────────
+const RUNNER_FACTORIES = {
+    "claude-code": createClaudeCodeRunner,
+};
+export function createRunners(config) {
+    // New multi-runner config
+    if (config.agent.runners && Object.keys(config.agent.runners).length > 0) {
+        const runners = {};
+        for (const [name, runnerConfig] of Object.entries(config.agent.runners)) {
+            const factory = RUNNER_FACTORIES[runnerConfig.type];
+            if (factory) {
+                runners[name] = factory();
+            }
+        }
+        return runners;
+    }
+    // Legacy single-runner fallback
+    const runnerType = config.agent.runner ?? "claude-code";
+    const factory = RUNNER_FACTORIES[runnerType];
+    const defaultName = config.agent.defaultRunner ?? "claude";
+    return { [defaultName]: factory ? factory() : createClaudeCodeRunner() };
+}

package/dist/bin/cli.js

@@ -180,8 +180,8 @@ var init_validators = __esm({
 });
 
 // src/config.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 function resolveStageConfig(config, stageName, modelTier) {
   const stageOverride = config.agent.stages?.[stageName];
   if (stageOverride) return stageOverride;
@@ -223,10 +223,10 @@ function setConfigDir(dir) {
 }
 function getProjectConfig() {
   if (_config) return _config;
-  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs8.existsSync(configPath)) {
+  const configPath = path6.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs7.existsSync(configPath)) {
     try {
-      const result = parseJsonSafe(fs8.readFileSync(configPath, "utf-8"));
+      const result = parseJsonSafe(fs7.readFileSync(configPath, "utf-8"));
       if (!result.ok) {
         logger.warn(`kody.config.json: ${result.error} \u2014 using defaults`);
         _config = { ...DEFAULT_CONFIG };
@@ -283,7 +283,7 @@ var init_config = __esm({
         repo: ""
       },
       agent: {
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+        modelMap: { cheap: "claude-haiku-4-5-20251001", mid: "claude-sonnet-4-6", strong: "claude-opus-4-6" }
       },
       contextTiers: {
         enabled: true,
@@ -389,10 +389,11 @@ function createClaudeCodeRunner() {
         model,
         "--dangerously-skip-permissions"
       ];
+      const baseTools = "Bash,Edit,Read,Write,Glob,Grep";
       if (options?.mcpConfigJson) {
         args2.push("--mcp-config", options.mcpConfigJson);
       } else {
-        args2.push("--allowedTools", "Bash,Edit,Read,Write,Glob,Grep");
+        args2.push("--allowedTools", baseTools);
       }
       if (options?.sessionId) {
         if (options.resumeSession) {
@@ -1192,6 +1193,7 @@ var init_litellm = __esm({
 // src/cli/taskify-command.ts
 var taskify_command_exports = {};
 __export(taskify_command_exports, {
+  TaskifyError: () => TaskifyError,
   isTaskifyRun: () => isTaskifyRun,
   readTaskifyMarker: () => readTaskifyMarker,
   runTaskifyCommand: () => runTaskifyCommand,
@@ -1283,8 +1285,17 @@ async function runTaskifyCommand() {
       ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "dummy"
     };
   }
-  await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId, runnerEnv });
-  litellmProcess?.kill();
+  try {
+    await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId, runnerEnv });
+  } catch (err) {
+    if (err instanceof TaskifyError) {
+      logger.error(`[taskify] ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  } finally {
+    litellmProcess?.kill();
+  }
 }
 async function taskifyCommand(opts) {
   const { ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId } = opts;
@@ -1299,7 +1310,6 @@ async function taskifyCommand(opts) {
       mcpConfigJson = buildTaskifyMcpConfigJson(config);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      logger.error(`[taskify] MCP config error: ${msg}`);
       if (issueNumber && !local) {
         postComment(
           issueNumber,
@@ -1310,7 +1320,7 @@ async function taskifyCommand(opts) {
 Add the required MCP server config to \`kody.config.json\` and try again.`
         );
       }
-      process.exit(1);
+      throw new TaskifyError(`MCP config error: ${msg}`);
     }
   }
   const sc = resolveStageConfig(config, "taskify", "strong");
@@ -1358,40 +1368,37 @@ Kody is decomposing ${src} into tasks...`);
   });
   if (result.outcome !== "completed") {
     const errMsg = result.outcome === "timed_out" ? "Taskify timed out after 5 minutes." : `Taskify failed: ${result.error}`;
-    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed:
 
 > ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    process.exit(1);
+    throw new TaskifyError(errMsg);
   }
   const resultPath = path10.join(taskDir, RESULT_FILE);
   if (!fs11.existsSync(resultPath)) {
     const errMsg = `Claude did not write ${RESULT_FILE}. Output:
 
 ${result.output?.slice(0, 500) ?? "(none)"}`;
-    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: result file not found.
 
 ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    process.exit(1);
+    throw new TaskifyError(errMsg);
   }
   let parsed;
   try {
     parsed = JSON.parse(fs11.readFileSync(resultPath, "utf-8"));
   } catch {
     const errMsg = `Could not parse ${RESULT_FILE} as JSON.`;
-    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    process.exit(1);
+    throw new TaskifyError(errMsg);
   }
   const sourceLabel = ticketId ?? (prdFile ? path10.basename(prdFile) : "spec");
   if (parsed.status === "questions") {
@@ -1400,12 +1407,11 @@ ${errMsg}`);
     await handleTasks(parsed, sourceLabel, issueNumber, local ?? false);
   } else {
     const errMsg = `Unexpected status in ${RESULT_FILE}: ${JSON.stringify(parsed)}`;
-    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    process.exit(1);
+    throw new TaskifyError(errMsg);
   }
 }
 function handleQuestions(parsed, ticketId, issueNumber, local) {
@@ -1536,7 +1542,7 @@ function readTaskifyMarker(taskDir) {
     return null;
   }
 }
-var __dirname, AUTO_TRIGGER_THRESHOLD, MAX_TASKS_GUARD, TASKIFY_TIMEOUT_MS, MARKER_FILE, RESULT_FILE;
+var __dirname, TaskifyError, AUTO_TRIGGER_THRESHOLD, MAX_TASKS_GUARD, TASKIFY_TIMEOUT_MS, MARKER_FILE, RESULT_FILE;
 var init_taskify_command = __esm({
   "src/cli/taskify-command.ts"() {
     "use strict";
@@ -1548,6 +1554,12 @@ var init_taskify_command = __esm({
     init_task_resolution();
     init_litellm();
     __dirname = path10.dirname(fileURLToPath(import.meta.url));
+    TaskifyError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TaskifyError";
+      }
+    };
     AUTO_TRIGGER_THRESHOLD = 5;
     MAX_TASKS_GUARD = 20;
     TASKIFY_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -2686,10 +2698,12 @@ function escalateModelTier(currentTier) {
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
   const mapped = config.agent.modelMap[modelTier];
-  if (mapped) return mapped;
-  return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
+  if (!mapped) {
+    throw new Error(`No model configured for tier '${modelTier}'. Set agent.modelMap.${modelTier} in kody.config.json`);
+  }
+  return mapped;
 }
-var MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT, UI_EXTENSIONS, UI_PATH_SEGMENTS, TIER_ESCALATION, DEFAULT_MODEL_MAP;
+var 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";
@@ -2723,11 +2737,6 @@ var init_context = __esm({
       mid: "strong",
       strong: "strong"
     };
-    DEFAULT_MODEL_MAP = {
-      cheap: "haiku",
-      mid: "sonnet",
-      strong: "opus"
-    };
   }
 });
 
@@ -4912,7 +4921,7 @@ async function ensureLitellmProxy(config, projectDir) {
   return litellmProcess;
 }
 async function runModelHealthCheck(config) {
-  const usesProxy = needsLitellmProxy(config);
+  const usesProxy = anyStageNeedsProxy(config);
   const baseUrl = usesProxy ? getLitellmUrl() : "https://api.anthropic.com";
   const apiKey = usesProxy ? process.env.ANTHROPIC_COMPATIBLE_API_KEY : process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
@@ -5533,7 +5542,7 @@ function buildConfig(cwd, basic) {
     github: { owner: basic.owner, repo: basic.repo },
     agent: {
       provider: "anthropic",
-      modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+      modelMap: { cheap: "claude-haiku-4-5-20251001", mid: "claude-sonnet-4-6", strong: "claude-opus-4-6" }
     }
   };
   const mcp = detectMcpConfig(cwd, basic.pm, pkg);
@@ -5733,8 +5742,8 @@ function initCommand(opts, pkgRoot) {
 
 // src/bin/commands/bootstrap.ts
 init_architecture_detection();
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 
 // src/bin/qa-guide.ts
@@ -6008,22 +6017,23 @@ function installSkillsForProject(cwd) {
 }
 
 // src/bin/commands/bootstrap.ts
+init_config();
 var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path6.join(cwd, "src");
-  const baseDir = fs7.existsSync(srcDir) ? srcDir : cwd;
+  const srcDir = path7.join(cwd, "src");
+  const baseDir = fs8.existsSync(srcDir) ? srcDir : cwd;
   const results = [];
   function walk(dir) {
     const entries = [];
     try {
-      for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path6.join(dir, entry.name);
+        const full = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           entries.push(...walk(full));
         } else if (/\.(ts|js)$/.test(entry.name) && !/\.(test|spec|config|d)\.(ts|js)$/.test(entry.name)) {
           try {
-            const stat = fs7.statSync(full);
+            const stat = fs8.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -6037,8 +6047,8 @@ function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
   }
   const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
   for (const { filePath } of files) {
-    const rel = path6.relative(cwd, filePath);
-    const content = fs7.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    const rel = path7.relative(cwd, filePath);
+    const content = fs8.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
     results.push(`### File: ${rel}
 \`\`\`typescript
 ${content}
@@ -6050,9 +6060,9 @@ function ghComment(issueNumber, body, cwd) {
   try {
     let repoSlug = "";
     try {
-      const configPath = path6.join(cwd, "kody.config.json");
-      if (fs7.existsSync(configPath)) {
-        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const configPath = path7.join(cwd, "kody.config.json");
+      if (fs8.existsSync(configPath)) {
+        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -6079,7 +6089,9 @@ function ghComment(issueNumber, body, cwd) {
 }
 function bootstrapCommand(opts, pkgRoot) {
   const cwd = process.cwd();
+  setConfigDir(cwd);
   const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
+  const bootstrapModel = resolveStageConfig(getProjectConfig(), "bootstrap", "cheap").model;
   console.log(`
 \u{1F527} Kody Bootstrap \u2014 Generating project memory + step files
 `);
@@ -6087,8 +6099,8 @@ function bootstrapCommand(opts, pkgRoot) {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path6.join(cwd, rel);
-    if (fs7.existsSync(p)) return fs7.readFileSync(p, "utf-8").slice(0, maxChars);
+    const p = path7.join(cwd, rel);
+    if (fs8.existsSync(p)) return fs8.readFileSync(p, "utf-8").slice(0, maxChars);
     return null;
   };
   let repoContext = "";
@@ -6123,14 +6135,14 @@ ${sampleFiles}
 
 `;
   try {
-    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs8.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     repoContext += `## Top-level directories
 ${topDirs.join(", ")}
 
 `;
-    const srcDir = path6.join(cwd, "src");
-    if (fs7.existsSync(srcDir)) {
-      const srcDirs = fs7.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path7.join(cwd, "src");
+    if (fs8.existsSync(srcDir)) {
+      const srcDirs = fs8.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) repoContext += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -6140,19 +6152,19 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
+    if (fs8.existsSync(path7.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) repoContext += `## Config files present
 ${existingFiles.join(", ")}
 
 `;
   console.log("\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path6.join(cwd, ".kody", "memory");
-  fs7.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path6.join(memoryDir, "architecture.md");
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  const existingArch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
-  const existingConv = fs7.existsSync(conventionsPath) ? fs7.readFileSync(conventionsPath, "utf-8") : "";
+  const memoryDir = path7.join(cwd, ".kody", "memory");
+  fs8.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path7.join(memoryDir, "architecture.md");
+  const conventionsPath = path7.join(memoryDir, "conventions.md");
+  const existingArch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
+  const existingConv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
   const hasExisting = !!(existingArch || existingConv);
   const extendInstruction = hasExisting && !opts.force ? `
 ## Existing Documentation (EXTEND, do not replace)
@@ -6196,7 +6208,7 @@ ${repoContext}`;
     const output = execFileSync5("claude", [
       "--print",
       "--model",
-      "claude-haiku-4-5-20251001",
+      bootstrapModel,
       "--dangerously-skip-permissions",
       memoryPrompt
     ], {
@@ -6208,12 +6220,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs7.writeFileSync(archPath, parsed.architecture);
+      fs8.writeFileSync(archPath, parsed.architecture);
       const lineCount = parsed.architecture.split("\n").length;
       console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines)`);
     }
     if (parsed.conventions) {
-      fs7.writeFileSync(conventionsPath, parsed.conventions);
+      fs8.writeFileSync(conventionsPath, parsed.conventions);
       const lineCount = parsed.conventions.split("\n").length;
       console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines)`);
     }
@@ -6222,39 +6234,39 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs8.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `);
       console.log(`  \u2713 .kody/memory/architecture.md (${detected.length} items, basic detection)`);
     }
-    fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs8.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
   console.log("\n\u2500\u2500 Step Files \u2500\u2500");
-  const stepsDir = path6.join(cwd, ".kody", "steps");
-  fs7.mkdirSync(stepsDir, { recursive: true });
-  const arch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
-  const conv = fs7.existsSync(conventionsPath) ? fs7.readFileSync(conventionsPath, "utf-8") : "";
+  const stepsDir = path7.join(cwd, ".kody", "steps");
+  fs8.mkdirSync(stepsDir, { recursive: true });
+  const arch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
+  const conv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
   console.log("  \u23F3 Customizing step files...");
   let stepCount = 0;
   for (const stage of STEP_STAGES) {
-    const templatePath = path6.join(pkgRoot, "prompts", `${stage}.md`);
-    if (!fs7.existsSync(templatePath)) {
+    const templatePath = path7.join(pkgRoot, "prompts", `${stage}.md`);
+    if (!fs8.existsSync(templatePath)) {
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
-    const stepOutputPath = path6.join(stepsDir, `${stage}.md`);
-    if (fs7.existsSync(stepOutputPath) && !opts.force) {
+    const stepOutputPath = path7.join(stepsDir, `${stage}.md`);
+    if (fs8.existsSync(stepOutputPath) && !opts.force) {
       console.log(`  \u25CB ${stage}.md \u2014 already exists (use --force to regenerate)`);
       continue;
     }
-    const defaultPrompt = fs7.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs8.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs7.copyFileSync(templatePath, stepOutputPath);
+      fs8.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -6299,7 +6311,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       const output = execFileSync5("claude", [
         "--print",
         "--model",
-        "claude-haiku-4-5-20251001",
+        bootstrapModel,
         "--dangerously-skip-permissions",
         customizationPrompt
       ], {
@@ -6311,23 +6323,23 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       let cleaned = output.replace(/^```(?:markdown|md)?\s*\n?/, "").replace(/\n?```\s*$/, "");
       cleaned = cleaned.replace(/\n*\{\{TASK_CONTEXT\}\}\s*$/, "").trimEnd();
       const finalPrompt = cleaned + "\n\n" + afterPlaceholder;
-      fs7.writeFileSync(stepOutputPath, finalPrompt);
+      fs8.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs7.copyFileSync(templatePath, stepOutputPath);
+      fs8.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 qaGuidePath = path7.join(cwd, ".kody", "qa-guide.md");
+  if (!fs8.existsSync(qaGuidePath) || opts.force) {
     const discovery = discoverQaContext(cwd);
     if (discovery.routes.length > 0) {
       const qaGuide = generateQaGuide(discovery);
-      fs7.writeFileSync(qaGuidePath, qaGuide);
+      fs8.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}`);
@@ -6342,9 +6354,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   try {
     let repoSlug = "";
     try {
-      const configPath = path6.join(cwd, "kody.config.json");
-      if (fs7.existsSync(configPath)) {
-        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const configPath = path7.join(cwd, "kody.config.json");
+      if (fs8.existsSync(configPath)) {
+        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -6417,19 +6429,19 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     ".kody/memory/conventions.md",
     ".kody/qa-guide.md",
     ...installedSkillPaths
-  ].filter((f) => fs7.existsSync(path6.join(cwd, f)));
-  if (fs7.existsSync(path6.join(cwd, "skills-lock.json"))) {
+  ].filter((f) => fs8.existsSync(path7.join(cwd, f)));
+  if (fs8.existsSync(path7.join(cwd, "skills-lock.json"))) {
     filesToCommit.push("skills-lock.json");
   }
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs7.existsSync(path6.join(cwd, stepFile))) {
+    if (fs8.existsSync(path7.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path6.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path7.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
         execFileSync5("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
@@ -6456,9 +6468,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path6.join(cwd, "kody.config.json");
-            if (fs7.existsSync(configPath)) {
-              const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+            const configPath = path7.join(cwd, "kody.config.json");
+            if (fs8.existsSync(configPath)) {
+              const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
               baseBranch = config.git?.defaultBranch ?? "main";
             }
           } catch {

package/dist/ci/parse-inputs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parses @kody / /kody comment body into structured inputs.
+ * Run by the parse job in GitHub Actions.
+ * Reads from env, writes to $GITHUB_OUTPUT.
+ */
+export {};