@kody-ade/kody-engine-lite 0.1.6 → 0.1.8

package/README.md

@@ -152,21 +152,47 @@ kody-engine-lite init --force  # overwrite existing workflow
 Comment on any issue:
 
 ```
-@kody full <task-id>                      # Run full pipeline
-@kody rerun <task-id> --from <stage>      # Resume from stage
+@kody                                     # Run full pipeline (auto-generates task-id)
+@kody full <task-id>                      # Run with specific task-id
+@kody rerun --from <stage>                # Resume latest task from stage
+@kody rerun <task-id> --from <stage>      # Resume specific task
+@kody approve                             # Approve + provide answers to Kody's questions
 @kody status <task-id>                    # Check status
 ```
 
+### Approve Flow (Question Gate)
+
+When Kody encounters unclear requirements or architecture decisions, it pauses and posts questions:
+
+```
+Kody: 🤔 Kody has questions before proceeding:
+      1. Should the search be case-sensitive?
+      2. Which users should have access?
+
+      Reply with @kody approve and your answers in the comment body.
+```
+
+You reply:
+
+```
+@kody approve
+
+1. Yes, case-sensitive
+2. Only admin users
+```
+
+Kody resumes automatically from where it paused, with your answers injected as context.
+
 ## Pipeline Stages
 
 | Stage | Model | What it does |
 |-------|-------|-------------|
 | taskify | haiku | Classifies task from issue body → `task.json` |
-| plan | sonnet | Creates TDD implementation plan → `plan.md` |
-| build | opus | Implements code changes (uses Claude Code tools) |
+| plan | opus | Deep reasoning: creates TDD implementation plan → `plan.md` |
+| build | sonnet | Implements code changes (Claude Code tools handle execution) |
 | verify | — | Runs typecheck + tests + lint (from `kody.config.json`) |
-| review | sonnet | Code review → `review.md` (PASS/FAIL + findings) |
-| review-fix | opus | Fixes Critical/Major review findings |
+| review | opus | Thorough code review → `review.md` (PASS/FAIL + findings) |
+| review-fix | sonnet | Applies known fixes from review findings |
 | ship | — | Pushes branch + creates PR + comments on issue |
 
 ### Automatic Loops
@@ -200,8 +226,8 @@ Memory is prepended to every agent prompt, giving Claude Code project context.
 | `github.repo` | GitHub repo name | `""` |
 | `paths.taskDir` | Task artifacts directory | `.tasks` |
 | `agent.modelMap.cheap` | Model for taskify | `haiku` |
-| `agent.modelMap.mid` | Model for plan/review | `sonnet` |
-| `agent.modelMap.strong` | Model for build/review-fix | `opus` |
+| `agent.modelMap.mid` | Model for build/review-fix/autofix | `sonnet` |
+| `agent.modelMap.strong` | Model for plan/review (deep reasoning) | `opus` |
 
 ### Environment Variables
 
@@ -213,6 +239,59 @@ Memory is prepended to every agent prompt, giving Claude Code project context.
 | `LOG_LEVEL` | No | `debug`, `info`, `warn`, `error` (default: `info`) |
 | `LITELLM_BASE_URL` | No | LiteLLM proxy URL for model routing |
 
+## Multi-Runner Support
+
+Use different agent runners per stage. For example, use OpenCode (MiniMax) for reasoning and Claude Code for code execution:
+
+```json
+{
+  "agent": {
+    "defaultRunner": "claude",
+    "runners": {
+      "claude": { "type": "claude-code" },
+      "opencode": { "type": "opencode" }
+    },
+    "stageRunners": {
+      "taskify": "opencode",
+      "plan": "opencode",
+      "build": "claude",
+      "review": "opencode",
+      "review-fix": "claude",
+      "autofix": "claude"
+    }
+  }
+}
+```
+
+Available runner types:
+- `claude-code` — Claude Code CLI (`claude --print`). Supports tool use (Read, Write, Edit, Bash).
+- `opencode` — OpenCode CLI (`opencode github run`). Supports MiniMax, OpenAI, Anthropic, Gemini.
+
+If no `runners`/`stageRunners` config, defaults to Claude Code for all stages.
+
+## Complexity-Based Stage Skipping
+
+Skip stages based on task complexity to save time and cost:
+
+```bash
+# Simple fix — skip plan and review
+kody-engine-lite run --task-id fix-typo --task "Fix typo in README" --complexity low
+
+# Standard feature — skip review-fix
+kody-engine-lite run --task-id add-feature --task "Add search" --complexity medium
+
+# Complex task — run all stages (default)
+kody-engine-lite run --task-id refactor --task "Refactor auth" --complexity high
+```
+
+| Complexity | Stages | Skipped |
+|-----------|--------|---------|
+| low | taskify → build → verify → ship | plan, review, review-fix |
+| medium | taskify → plan → build → verify → review → ship | review-fix |
+| high | taskify → plan → build → verify → review → review-fix → ship | none |
+
+If `--complexity` is not provided, it's auto-detected from the taskify stage's `risk_level` output. A complexity label (`kody:low`, `kody:medium`, `kody:high`) is set on the issue.
+
 ## LiteLLM (Optional)
 
 For multi-provider model routing with fallback:

package/dist/bin/cli.js

@@ -47,10 +47,47 @@ function waitForProcess(child, timeout) {
     });
   });
 }
+async function runSubprocess(command2, args2, prompt, timeout, options) {
+  const child = spawn(command2, args2, {
+    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}
+${stderr.slice(-STDERR_TAIL_CHARS)}`
+  };
+}
+function checkCommand(command2, args2) {
+  try {
+    execFileSync(command2, args2, { timeout: 1e4, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function createClaudeCodeRunner() {
   return {
-    async run(stageName, prompt, model, timeout, _taskDir, options) {
-      const child = spawn(
+    async run(_stageName, prompt, model, timeout, _taskDir, options) {
+      return runSubprocess(
         "claude",
         [
           "--print",
@@ -60,51 +97,64 @@ function createClaudeCodeRunner() {
           "--allowedTools",
           "Bash,Edit,Read,Write,Glob,Grep"
         ],
-        {
-          cwd: options?.cwd ?? process.cwd(),
-          env: {
-            ...process.env,
-            SKIP_BUILD: "1",
-            SKIP_HOOKS: "1",
-            ...options?.env
-          },
-          stdio: ["pipe", "pipe", "pipe"]
-        }
+        prompt,
+        timeout,
+        options
       );
-      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}
-${stderr.slice(-STDERR_TAIL_CHARS)}`
-      };
     },
     async healthCheck() {
-      try {
-        execFileSync("claude", ["--version"], { timeout: 1e4, stdio: "pipe" });
-        return true;
-      } catch {
-        return false;
+      return checkCommand("claude", ["--version"]);
+    }
+  };
+}
+function createOpenCodeRunner() {
+  return {
+    async run(stageName, prompt, model, timeout, _taskDir, options) {
+      const args2 = ["run"];
+      if (model) {
+        args2.push("--model", model);
       }
+      args2.push(prompt);
+      return runSubprocess(
+        "opencode",
+        args2,
+        "",
+        // opencode takes message as positional, not stdin
+        timeout,
+        options
+      );
+    },
+    async healthCheck() {
+      return checkCommand("opencode", ["--version"]);
     }
   };
 }
-var SIGKILL_GRACE_MS, STDERR_TAIL_CHARS;
+function createRunners(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 factory2 = RUNNER_FACTORIES[runnerConfig.type];
+      if (factory2) {
+        runners[name] = factory2();
+      }
+    }
+    return runners;
+  }
+  const runnerType = config.agent.runner ?? "claude-code";
+  const factory = RUNNER_FACTORIES[runnerType];
+  const defaultName = config.agent.defaultRunner ?? "claude";
+  return { [defaultName]: factory ? factory() : createClaudeCodeRunner() };
+}
+var SIGKILL_GRACE_MS, STDERR_TAIL_CHARS, RUNNER_FACTORIES;
 var init_agent_runner = __esm({
   "src/agent-runner.ts"() {
     "use strict";
     SIGKILL_GRACE_MS = 5e3;
     STDERR_TAIL_CHARS = 500;
+    RUNNER_FACTORIES = {
+      "claude-code": createClaudeCodeRunner,
+      "opencode": createOpenCodeRunner
+    };
   }
 });
 
@@ -125,7 +175,7 @@ var init_definitions = __esm({
       {
         name: "plan",
         type: "agent",
-        modelTier: "mid",
+        modelTier: "strong",
         timeout: 3e5,
         maxRetries: 1,
         outputFile: "plan.md"
@@ -133,7 +183,7 @@ var init_definitions = __esm({
       {
         name: "build",
         type: "agent",
-        modelTier: "strong",
+        modelTier: "mid",
         timeout: 12e5,
         maxRetries: 1
       },
@@ -148,7 +198,7 @@ var init_definitions = __esm({
       {
         name: "review",
         type: "agent",
-        modelTier: "mid",
+        modelTier: "strong",
         timeout: 3e5,
         maxRetries: 1,
         outputFile: "review.md"
@@ -156,7 +206,7 @@ var init_definitions = __esm({
       {
         name: "review-fix",
         type: "agent",
-        modelTier: "strong",
+        modelTier: "mid",
         timeout: 6e5,
         maxRetries: 1
       },
@@ -253,6 +303,7 @@ var init_config = __esm({
       },
       agent: {
         runner: "claude-code",
+        defaultRunner: "claude",
         modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
       }
     };
@@ -663,7 +714,7 @@ var init_github_api = __esm({
     "use strict";
     init_logger();
     API_TIMEOUT_MS = 3e4;
-    LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed"];
+    LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed", "waiting", "low", "medium", "high"];
   }
 });
 
@@ -743,6 +794,65 @@ var init_verify_runner = __esm({
 import * as fs4 from "fs";
 import * as path4 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
+function filterByComplexity(stages, complexity) {
+  const skip = COMPLEXITY_SKIP[complexity] ?? [];
+  return stages.filter((s) => !skip.includes(s.name));
+}
+function checkForQuestions(ctx, stageName) {
+  if (ctx.input.local || !ctx.input.issueNumber) return false;
+  try {
+    if (stageName === "taskify") {
+      const taskJsonPath = path4.join(ctx.taskDir, "task.json");
+      if (!fs4.existsSync(taskJsonPath)) return false;
+      const raw = fs4.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) {
+        const body = `\u{1F914} **Kody has questions before proceeding:**
+
+${taskJson.questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+
+Reply with \`@kody approve\` and your answers in the comment body.`;
+        postComment(ctx.input.issueNumber, body);
+        setLifecycleLabel(ctx.input.issueNumber, "waiting");
+        return true;
+      }
+    }
+    if (stageName === "plan") {
+      const planPath = path4.join(ctx.taskDir, "plan.md");
+      if (!fs4.existsSync(planPath)) return false;
+      const plan = fs4.readFileSync(planPath, "utf-8");
+      const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
+      if (questionsMatch) {
+        const questionsText = questionsMatch[1].trim();
+        const questions = questionsText.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2));
+        if (questions.length > 0) {
+          const body = `\u{1F3D7}\uFE0F **Kody has architecture questions:**
+
+${questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+
+Reply with \`@kody approve\` and your answers in the comment body.`;
+          postComment(ctx.input.issueNumber, body);
+          setLifecycleLabel(ctx.input.issueNumber, "waiting");
+          return true;
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+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;
+}
 function loadState(taskId, taskDir) {
   const p = path4.join(taskDir, "status.json");
   if (!fs4.existsSync(p)) return null;
@@ -788,13 +898,15 @@ async function executeAgentStage(ctx, def) {
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
   const model = resolveModel(def.modelTier, def.name);
-  logger.info(`  model=${model} timeout=${def.timeout / 1e3}s`);
   const config = getProjectConfig();
+  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`);
   const extraEnv = {};
   if (config.agent.litellmUrl) {
     extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
   }
-  const result = await ctx.runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+  const runner = getRunnerForStage(ctx, def.name);
+  const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
     cwd: ctx.projectDir,
     env: extraEnv
   });
@@ -911,6 +1023,9 @@ async function executeVerifyWithAutofix(ctx, def) {
   };
 }
 async function executeReviewWithFix(ctx, def) {
+  if (ctx.input.dryRun) {
+    return { outcome: "completed", retries: 0 };
+  }
   const reviewDef = STAGES.find((s) => s.name === "review");
   const reviewFixDef = STAGES.find((s) => s.name === "review-fix");
   const reviewResult = await executeAgentStage(ctx, reviewDef);
@@ -934,8 +1049,65 @@ async function executeReviewWithFix(ctx, def) {
   logger.info(`  re-running review after fix...`);
   return executeAgentStage(ctx, reviewDef);
 }
+function buildPrBody(ctx) {
+  const sections = [];
+  const taskJsonPath = path4.join(ctx.taskDir, "task.json");
+  if (fs4.existsSync(taskJsonPath)) {
+    try {
+      const raw = fs4.readFileSync(taskJsonPath, "utf-8");
+      const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+      const task = JSON.parse(cleaned);
+      sections.push(`## Summary`);
+      sections.push(`**Type:** ${task.task_type ?? "unknown"} | **Risk:** ${task.risk_level ?? "unknown"}`);
+      if (task.description) sections.push(`
+${task.description}`);
+      if (task.scope?.length) sections.push(`
+**Scope:** ${task.scope.join(", ")}`);
+    } catch {
+    }
+  }
+  const planPath = path4.join(ctx.taskDir, "plan.md");
+  if (fs4.existsSync(planPath)) {
+    const plan = fs4.readFileSync(planPath, "utf-8").trim();
+    if (plan) {
+      const truncated = plan.length > 500 ? plan.slice(0, 500) + "\n..." : plan;
+      sections.push(`
+## Plan
+<details><summary>Implementation plan</summary>
+
+${truncated}
+</details>`);
+    }
+  }
+  const reviewPath = path4.join(ctx.taskDir, "review.md");
+  if (fs4.existsSync(reviewPath)) {
+    const review = fs4.readFileSync(reviewPath, "utf-8");
+    const verdictMatch = review.match(/## Verdict:\s*(PASS|FAIL)/i);
+    if (verdictMatch) {
+      sections.push(`
+**Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
+    }
+  }
+  const verifyPath = path4.join(ctx.taskDir, "verify.md");
+  if (fs4.existsSync(verifyPath)) {
+    const verify = fs4.readFileSync(verifyPath, "utf-8");
+    if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
+  }
+  if (ctx.input.issueNumber) {
+    sections.push(`
+Closes #${ctx.input.issueNumber}`);
+  }
+  sections.push(`
+---
+\u{1F916} Generated by Kody`);
+  return sections.join("\n");
+}
 function executeShipStage(ctx, _def) {
   const shipPath = path4.join(ctx.taskDir, "ship.md");
+  if (ctx.input.dryRun) {
+    fs4.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) {
     fs4.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
@@ -968,13 +1140,7 @@ function executeShipStage(ctx, _def) {
       const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
       title = (lines[0] ?? "Update").slice(0, 72);
     }
-    const closesLine = ctx.input.issueNumber ? `
-
-Closes #${ctx.input.issueNumber}` : "";
-    const body = `Generated by Kody pipeline${closesLine}
-
----
-\u{1F916} Generated by Kody`;
+    const body = buildPrBody(ctx);
     const pr = createPR(head, base, title, body);
     if (pr) {
       if (ctx.input.issueNumber && !ctx.input.local) {
@@ -1035,6 +1201,9 @@ async function runPipeline(ctx) {
       logger.warn(`  Failed to create feature branch: ${err}`);
     }
   }
+  let complexity = ctx.input.complexity ?? "high";
+  let activeStages = filterByComplexity(STAGES, complexity);
+  let skippedStagesCommentPosted = false;
   for (const def of STAGES) {
     if (!startExecution) {
       if (def.name === fromStage) {
@@ -1047,6 +1216,23 @@ async function runPipeline(ctx) {
       logger.info(`[${def.name}] already completed, skipping`);
       continue;
     }
+    if (!activeStages.find((s) => s.name === def.name)) {
+      logger.info(`[${def.name}] skipped (complexity: ${complexity})`);
+      state.stages[def.name] = { state: "completed", retries: 0, outputFile: void 0 };
+      writeState(state, ctx.taskDir);
+      if (!skippedStagesCommentPosted && ctx.input.issueNumber && !ctx.input.local && !ctx.input.dryRun) {
+        const skipped = STAGES.filter((s) => !activeStages.find((a) => a.name === s.name)).map((s) => s.name);
+        try {
+          postComment(
+            ctx.input.issueNumber,
+            `\u26A1 **Complexity: ${complexity}** \u2014 skipping ${skipped.join(", ")} (not needed for ${complexity}-risk tasks)`
+          );
+        } catch {
+        }
+        skippedStagesCommentPosted = true;
+      }
+      continue;
+    }
     ciGroup(`Stage: ${def.name}`);
     state.stages[def.name] = {
       state: "running",
@@ -1094,6 +1280,48 @@ async function runPipeline(ctx) {
         outputFile: result.outputFile
       };
       logger.info(`[${def.name}] \u2713 completed`);
+      if ((def.name === "taskify" || def.name === "plan") && !ctx.input.dryRun) {
+        const paused = checkForQuestions(ctx, def.name);
+        if (paused) {
+          state.state = "failed";
+          state.stages[def.name] = {
+            ...state.stages[def.name],
+            state: "completed",
+            error: "paused: waiting for answers"
+          };
+          writeState(state, ctx.taskDir);
+          logger.info(`  Pipeline paused \u2014 questions posted on issue`);
+          return state;
+        }
+      }
+      if (def.name === "taskify" && !ctx.input.complexity) {
+        try {
+          const taskJsonPath = path4.join(ctx.taskDir, "task.json");
+          if (fs4.existsSync(taskJsonPath)) {
+            const raw = fs4.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 && COMPLEXITY_SKIP[taskJson.risk_level]) {
+              complexity = taskJson.risk_level;
+              activeStages = filterByComplexity(STAGES, complexity);
+              logger.info(`  Complexity auto-detected: ${complexity} (${activeStages.map((s) => s.name).join(" \u2192 ")})`);
+              if (ctx.input.issueNumber && !ctx.input.local) {
+                try {
+                  setLifecycleLabel(ctx.input.issueNumber, complexity);
+                } catch {
+                }
+                if (taskJson.task_type) {
+                  try {
+                    setLabel(ctx.input.issueNumber, `kody:${taskJson.task_type}`);
+                  } catch {
+                  }
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
       if (!ctx.input.dryRun && ctx.input.issueNumber) {
         if (def.name === "build") {
           try {
@@ -1285,6 +1513,7 @@ Task: ${state.taskId}`);
     console.log(`  ${icon} ${stage.name}: ${s.state}${extra}`);
   }
 }
+var COMPLEXITY_SKIP;
 var init_state_machine = __esm({
   "src/state-machine.ts"() {
     "use strict";
@@ -1296,6 +1525,11 @@ var init_state_machine = __esm({
     init_verify_runner();
     init_config();
     init_logger();
+    COMPLEXITY_SKIP = {
+      low: ["plan", "review", "review-fix"],
+      medium: ["review-fix"],
+      high: []
+    };
   }
 });
 
@@ -1392,7 +1626,7 @@ function parseArgs() {
   const args2 = process.argv.slice(2);
   if (hasFlag(args2, "--help") || hasFlag(args2, "-h") || args2.length === 0) {
     console.log(`Usage:
-  kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--feedback "<text>"] [--local] [--dry-run]
+  kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--complexity low|medium|high] [--feedback "<text>"] [--local] [--dry-run]
   kody rerun  --task-id <id> --from <stage> [--cwd <path>] [--issue-number <n>]
   kody status --task-id <id> [--cwd <path>]
   kody --help`);
@@ -1414,9 +1648,17 @@ function parseArgs() {
     cwd: getArg(args2, "--cwd"),
     issueNumber: issueStr ? parseInt(issueStr, 10) : void 0,
     feedback: getArg(args2, "--feedback") ?? process.env.FEEDBACK,
-    local: localFlag || !isCI2 && !hasFlag(args2, "--no-local")
+    local: localFlag || !isCI2 && !hasFlag(args2, "--no-local"),
+    complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY
   };
 }
+function findLatestTaskForIssue(issueNumber, projectDir) {
+  const tasksDir = path5.join(projectDir, ".tasks");
+  if (!fs6.existsSync(tasksDir)) return null;
+  const prefix = `${issueNumber}-`;
+  const dirs = fs6.readdirSync(tasksDir).filter((d) => d.startsWith(prefix)).sort().reverse();
+  return dirs[0] ?? null;
+}
 function generateTaskId() {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
@@ -1424,15 +1666,6 @@ function generateTaskId() {
 }
 async function main() {
   const input = parseArgs();
-  let taskId = input.taskId;
-  if (!taskId) {
-    if (input.command === "run" && input.task) {
-      taskId = generateTaskId();
-    } else {
-      console.error("--task-id is required");
-      process.exit(1);
-    }
-  }
   const projectDir = input.cwd ? path5.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
     if (!fs6.existsSync(projectDir)) {
@@ -1443,6 +1676,25 @@ async function main() {
     setGhCwd(projectDir);
     logger.info(`Working directory: ${projectDir}`);
   }
+  let taskId = input.taskId;
+  if (!taskId) {
+    if (input.command === "rerun" && input.issueNumber) {
+      const found = findLatestTaskForIssue(input.issueNumber, projectDir);
+      if (!found) {
+        console.error(`No previous task found for issue #${input.issueNumber}`);
+        process.exit(1);
+      }
+      taskId = found;
+      logger.info(`Found latest task for issue #${input.issueNumber}: ${taskId}`);
+    } else if (input.issueNumber) {
+      taskId = `${input.issueNumber}-${generateTaskId()}`;
+    } else if (input.command === "run" && input.task) {
+      taskId = generateTaskId();
+    } else {
+      console.error("--task-id is required (or provide --issue-number to auto-generate)");
+      process.exit(1);
+    }
+  }
   const taskDir = path5.join(projectDir, ".tasks", taskId);
   fs6.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
@@ -1473,31 +1725,87 @@ ${issue.body ?? ""}`;
     }
   }
   if (input.command === "rerun" && !input.fromStage) {
-    console.error("--from <stage> is required for rerun");
+    const statusPath = path5.join(taskDir, "status.json");
+    if (fs6.existsSync(statusPath)) {
+      try {
+        const status = JSON.parse(fs6.readFileSync(statusPath, "utf-8"));
+        const stageNames = ["taskify", "plan", "build", "verify", "review", "review-fix", "ship"];
+        let foundPaused = false;
+        for (const name of stageNames) {
+          const s = status.stages[name];
+          if (s?.error?.includes("paused")) {
+            const idx = stageNames.indexOf(name);
+            if (idx < stageNames.length - 1) {
+              input.fromStage = stageNames[idx + 1];
+              foundPaused = true;
+              logger.info(`Auto-detected resume from: ${input.fromStage} (after paused ${name})`);
+              break;
+            }
+          }
+          if (s?.state === "failed" || s?.state === "pending") {
+            input.fromStage = name;
+            foundPaused = true;
+            logger.info(`Auto-detected resume from: ${input.fromStage}`);
+            break;
+          }
+        }
+        if (!foundPaused) {
+          input.fromStage = "taskify";
+          logger.info("No paused/failed stage found, resuming from taskify");
+        }
+      } catch {
+        console.error("--from <stage> is required (could not read status.json)");
+        process.exit(1);
+      }
+    } else {
+      console.error("--from <stage> is required for rerun (no status.json found)");
+      process.exit(1);
+    }
+  }
+  const config = getProjectConfig();
+  const runners = createRunners(config);
+  const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
+  const defaultRunner = runners[defaultRunnerName];
+  if (!defaultRunner) {
+    console.error(`Default runner "${defaultRunnerName}" not configured`);
     process.exit(1);
   }
-  const runner = createClaudeCodeRunner();
-  const healthy = await runner.healthCheck();
+  const healthy = await defaultRunner.healthCheck();
   if (!healthy) {
-    console.error("Claude Code CLI not available. Install: npm i -g @anthropic-ai/claude-code");
+    console.error(`Runner "${defaultRunnerName}" health check failed`);
     process.exit(1);
   }
   const ctx = {
     taskId,
     taskDir,
     projectDir,
-    runner,
+    runners,
     input: {
       mode: input.command === "rerun" ? "rerun" : "full",
       fromStage: input.fromStage,
       dryRun: input.dryRun,
       issueNumber: input.issueNumber,
       feedback: input.feedback,
-      local: input.local
+      local: input.local,
+      complexity: input.complexity
     }
   };
+  logger.info(`Task: ${taskId}`);
   logger.info(`Mode: ${ctx.input.mode}${ctx.input.local ? " (local)" : " (CI)"}`);
   if (ctx.input.issueNumber) logger.info(`Issue: #${ctx.input.issueNumber}`);
+  if (ctx.input.issueNumber && !ctx.input.local && ctx.input.mode === "full") {
+    const runUrl = process.env.RUN_URL ?? "";
+    const runLink = runUrl ? ` ([logs](${runUrl}))` : "";
+    try {
+      postComment(
+        ctx.input.issueNumber,
+        `\u{1F680} Kody pipeline started: \`${taskId}\`${runLink}
+
+To rerun: \`@kody rerun ${taskId} --from <stage>\``
+      );
+    } catch {
+    }
+  }
   const state = await runPipeline(ctx);
   const files = fs6.readdirSync(taskDir);
   console.log(`
@@ -1562,7 +1870,7 @@ function getVersion() {
   const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
-function checkCommand(name, args2, fix) {
+function checkCommand2(name, args2, fix) {
   try {
     const output = execFileSync7(name, args2, {
       encoding: "utf-8",
@@ -1703,6 +2011,235 @@ function detectArchitecture(cwd) {
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
+function detectBasicConfig(cwd) {
+  let pm = "pnpm";
+  if (fs7.existsSync(path6.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs7.existsSync(path6.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml")) && fs7.existsSync(path6.join(cwd, "package-lock.json"))) pm = "npm";
+  let defaultBranch = "main";
+  try {
+    const ref = execFileSync7("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    defaultBranch = ref.replace("refs/remotes/origin/", "");
+  } catch {
+    try {
+      execFileSync7("git", ["rev-parse", "--verify", "origin/dev"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      defaultBranch = "dev";
+    } catch {
+    }
+  }
+  let owner = "";
+  let repo = "";
+  try {
+    const remote = execFileSync7("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (match) {
+      owner = match[1];
+      repo = match[2];
+    }
+  } catch {
+  }
+  const hasOpenCode = fs7.existsSync(path6.join(cwd, "opencode.json"));
+  return { defaultBranch, owner, repo, pm, hasOpenCode };
+}
+function smartInit(cwd) {
+  const basic = detectBasicConfig(cwd);
+  let context = "";
+  const readIfExists = (rel, maxChars = 3e3) => {
+    const p = path6.join(cwd, rel);
+    if (fs7.existsSync(p)) {
+      const content = fs7.readFileSync(p, "utf-8");
+      return content.slice(0, maxChars);
+    }
+    return null;
+  };
+  const pkgJson = readIfExists("package.json");
+  if (pkgJson) context += `## package.json
+${pkgJson}
+
+`;
+  const tsconfig = readIfExists("tsconfig.json", 1e3);
+  if (tsconfig) context += `## tsconfig.json
+${tsconfig}
+
+`;
+  const readme = readIfExists("README.md", 2e3);
+  if (readme) context += `## README.md (first 2000 chars)
+${readme}
+
+`;
+  const claudeMd = readIfExists("CLAUDE.md", 3e3);
+  if (claudeMd) context += `## CLAUDE.md
+${claudeMd}
+
+`;
+  try {
+    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    context += `## 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);
+      context += `## src/ subdirectories
+${srcDirs.join(", ")}
+
+`;
+    }
+  } catch {
+  }
+  const existingFiles = [];
+  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "opencode.json", "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 (existingFiles.length) context += `## Config files present
+${existingFiles.join(", ")}
+
+`;
+  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}, opencode=${basic.hasOpenCode}
+`;
+  const prompt = `You are analyzing a project to configure Kody (an autonomous SDLC pipeline).
+
+Given this project context, output ONLY a JSON object with EXACTLY this structure:
+
+{
+  "config": {
+    "quality": {
+      "typecheck": "${basic.pm} <script or command>",
+      "lint": "${basic.pm} <script or command>",
+      "lintFix": "${basic.pm} <script or command>",
+      "format": "${basic.pm} <script or command>",
+      "formatFix": "${basic.pm} <script or command>",
+      "testUnit": "${basic.pm} <script or command>"
+    },
+    "git": { "defaultBranch": "${basic.defaultBranch}" },
+    "github": { "owner": "${basic.owner}", "repo": "${basic.repo}" },
+    "paths": { "taskDir": ".tasks" },
+    "agent": {
+      "runner": "${basic.hasOpenCode ? "opencode" : "claude-code"}",
+      "defaultRunner": "${basic.hasOpenCode ? "opencode" : "claude"}",
+      "modelMap": { "cheap": "haiku", "mid": "sonnet", "strong": "opus" }
+    }
+  },
+  "architecture": "# Architecture\\n\\n<markdown content>",
+  "conventions": "# Conventions\\n\\n<markdown content>"
+}
+
+CRITICAL rules for config.quality:
+- Every command MUST start with "${basic.pm}" (e.g., "${basic.pm} typecheck", "${basic.pm} lint")
+- Look at the package.json "scripts" section to find the correct script names
+- testUnit must run ONLY unit tests \u2014 exclude integration and e2e tests. If there's a "test:unit" script use it. Otherwise use "test" but add exclude flags for int/e2e.
+- If a script doesn't exist and can't be inferred, set the value to ""
+- Do NOT invent commands that don't exist in package.json scripts
+
+Rules for architecture (markdown string):
+- Be specific about THIS project
+- Include: framework, language, database, testing, key directories, data flow
+- Reference CLAUDE.md and .ai-docs/ if they exist
+- Keep under 50 lines
+
+Rules for conventions (markdown string):
+- Extract actual patterns from the project
+- If CLAUDE.md exists, reference it
+- If .ai-docs/ exists, reference it
+- Keep under 30 lines
+
+Output ONLY valid JSON. No markdown fences. No explanation before or after.
+
+${context}`;
+  console.log("  \u23F3 Analyzing project with Claude Code...");
+  try {
+    const output = execFileSync7("claude", [
+      "--print",
+      "--model",
+      "haiku",
+      "--dangerously-skip-permissions",
+      prompt
+    ], {
+      encoding: "utf-8",
+      timeout: 12e4,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+    const parsed = JSON.parse(cleaned);
+    const config = parsed.config ?? {};
+    if (!config.git) config.git = {};
+    if (!config.github) config.github = {};
+    if (!config.paths) config.paths = {};
+    if (!config.agent) config.agent = {};
+    config.git.defaultBranch = config.git.defaultBranch || basic.defaultBranch;
+    config.github.owner = config.github.owner || basic.owner;
+    config.github.repo = config.github.repo || basic.repo;
+    config.paths.taskDir = config.paths.taskDir || ".tasks";
+    config.agent.runner = config.agent.runner || (basic.hasOpenCode ? "opencode" : "claude-code");
+    config.agent.defaultRunner = config.agent.defaultRunner || (basic.hasOpenCode ? "opencode" : "claude");
+    if (!config.agent.modelMap) {
+      config.agent.modelMap = { cheap: "haiku", mid: "sonnet", strong: "opus" };
+    }
+    return {
+      config,
+      architecture: parsed.architecture ?? "",
+      conventions: parsed.conventions ?? ""
+    };
+  } catch (err) {
+    console.log("  \u26A0 Smart detection failed, falling back to basic detection");
+    return {
+      config: buildFallbackConfig(cwd, basic),
+      architecture: "",
+      conventions: ""
+    };
+  }
+}
+function buildFallbackConfig(cwd, basic) {
+  const pkg = (() => {
+    try {
+      return JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+    } catch {
+      return {};
+    }
+  })();
+  const scripts = pkg.scripts ?? {};
+  const find = (...c) => {
+    for (const s of c) {
+      if (scripts[s]) return `${basic.pm} ${s}`;
+    }
+    return "";
+  };
+  return {
+    quality: {
+      typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
+      lint: find("lint"),
+      lintFix: find("lint:fix", "lint-fix"),
+      format: find("format:check"),
+      formatFix: find("format", "format:fix"),
+      testUnit: find("test:unit", "test", "test:ci")
+    },
+    git: { defaultBranch: basic.defaultBranch },
+    github: { owner: basic.owner, repo: basic.repo },
+    paths: { taskDir: ".tasks" },
+    agent: {
+      runner: basic.hasOpenCode ? "opencode" : "claude-code",
+      defaultRunner: basic.hasOpenCode ? "opencode" : "claude",
+      modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+    }
+  };
+}
 function initCommand(opts) {
   const cwd = process.cwd();
   console.log(`
@@ -1726,26 +2263,11 @@ function initCommand(opts) {
     console.log("  \u2713 .github/workflows/kody.yml");
   }
   const configDest = path6.join(cwd, "kody.config.json");
-  if (!fs7.existsSync(configDest)) {
-    const defaultConfig = {
-      quality: {
-        typecheck: "pnpm tsc --noEmit",
-        lint: "",
-        lintFix: "",
-        format: "",
-        formatFix: "",
-        testUnit: "pnpm test"
-      },
-      git: { defaultBranch: "main" },
-      github: { owner: "", repo: "" },
-      paths: { taskDir: ".tasks" },
-      agent: {
-        runner: "claude-code",
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
-      }
-    };
-    fs7.writeFileSync(configDest, JSON.stringify(defaultConfig, null, 2) + "\n");
-    console.log("  \u2713 kody.config.json (created \u2014 edit github.owner and github.repo)");
+  let smartResult = null;
+  if (!fs7.existsSync(configDest) || opts.force) {
+    smartResult = smartInit(cwd);
+    fs7.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
@@ -1761,11 +2283,11 @@ function initCommand(opts) {
   }
   console.log("\n\u2500\u2500 Prerequisites \u2500\u2500");
   const checks = [
-    checkCommand("claude", ["--version"], "Install: npm i -g @anthropic-ai/claude-code"),
-    checkCommand("gh", ["--version"], "Install: https://cli.github.com"),
-    checkCommand("git", ["--version"], "Install git"),
-    checkCommand("node", ["--version"], "Install Node.js >= 22"),
-    checkCommand("pnpm", ["--version"], "Install: npm i -g pnpm"),
+    checkCommand2("claude", ["--version"], "Install: npm i -g @anthropic-ai/claude-code"),
+    checkCommand2("gh", ["--version"], "Install: https://cli.github.com"),
+    checkCommand2("git", ["--version"], "Install git"),
+    checkCommand2("node", ["--version"], "Install Node.js >= 22"),
+    checkCommand2("pnpm", ["--version"], "Install: npm i -g pnpm"),
     checkFile(path6.join(cwd, "package.json"), "package.json", "Run: pnpm init")
   ];
   for (const c of checks) {
@@ -1797,7 +2319,16 @@ function initCommand(opts) {
       { name: "kody:building", color: "0e8a16", description: "Kody is building code" },
       { name: "kody:review", color: "fbca04", description: "Kody is reviewing code" },
       { name: "kody:done", color: "0e8a16", description: "Kody completed successfully" },
-      { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" }
+      { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" },
+      { name: "kody:waiting", color: "fef2c0", description: "Kody is waiting for answers" },
+      { name: "kody:low", color: "bfdadc", description: "Low complexity \u2014 skip plan/review" },
+      { name: "kody:medium", color: "c5def5", description: "Medium complexity \u2014 skip review-fix" },
+      { name: "kody:high", color: "d4c5f9", description: "High complexity \u2014 full pipeline" },
+      { name: "kody:feature", color: "0e8a16", description: "New feature" },
+      { name: "kody:bugfix", color: "d93f0b", description: "Bug fix" },
+      { name: "kody:refactor", color: "fbca04", description: "Code refactoring" },
+      { name: "kody:docs", color: "0075ca", description: "Documentation" },
+      { name: "kody:chore", color: "e4e669", description: "Maintenance task" }
     ];
     console.log("\n\u2500\u2500 Labels \u2500\u2500");
     for (const label of labels) {
@@ -1862,33 +2393,38 @@ function initCommand(opts) {
       console.log("  \u2717 kody.config.json \u2014 invalid JSON");
     }
   }
-  console.log("\n\u2500\u2500 Architecture Detection \u2500\u2500");
+  console.log("\n\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");
-  if (fs7.existsSync(archPath)) {
-    console.log("  \u25CB .kody/memory/architecture.md (exists, not overwriting)");
+  const conventionsPath = path6.join(memoryDir, "conventions.md");
+  if (fs7.existsSync(archPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
+  } else if (smartResult?.architecture) {
+    fs7.writeFileSync(archPath, smartResult.architecture);
+    const lineCount = smartResult.architecture.split("\n").length;
+    console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines, LLM-generated)`);
   } else {
     const archItems = detectArchitecture(cwd);
     if (archItems.length > 0) {
-      fs7.mkdirSync(memoryDir, { recursive: true });
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const content = `# Architecture (auto-detected ${timestamp2})
+      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
-`;
-      fs7.writeFileSync(archPath, content);
-      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items detected)`);
-      for (const item of archItems) {
-        console.log(`    ${item}`);
-      }
+`);
+      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items, basic detection)`);
     } else {
       console.log("  \u25CB No architecture detected");
     }
   }
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  if (!fs7.existsSync(conventionsPath)) {
-    fs7.mkdirSync(memoryDir, { recursive: true });
+  if (fs7.existsSync(conventionsPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
+  } else if (smartResult?.conventions) {
+    fs7.writeFileSync(conventionsPath, smartResult.conventions);
+    const lineCount = smartResult.conventions.split("\n").length;
+    console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
+  } else {
     fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",

package/prompts/plan.md

@@ -9,7 +9,7 @@ You are a planning agent following the Superpowers Writing Plans methodology.
 
 Before planning, examine the codebase to understand existing code structure, patterns, and conventions. Use Read, Glob, and Grep.
 
-Output a markdown plan with numbered steps:
+Output a markdown plan. Start with the steps, then optionally add a Questions section at the end.
 
 ## Step N: <short description>
 **File:** <exact file path>
@@ -27,4 +27,22 @@ Superpowers Writing Plans rules:
 7. If modifying existing code, show the exact function/line to change
 8. Keep it simple — avoid unnecessary abstractions (YAGNI)
 
+If there are architecture decisions or technical tradeoffs that need input, add a Questions section at the END of your plan:
+
+## Questions
+
+- <question about architecture decision or tradeoff>
+
+Questions rules:
+- ONLY ask about significant architecture/technical decisions that affect the implementation
+- Ask about: design pattern choice, database schema decisions, API contract changes, performance tradeoffs
+- Recommend an approach with rationale — don't just ask open-ended questions
+- Do NOT ask about requirements — those should be clear from task.json
+- Do NOT ask about things you can determine from the codebase
+- If no questions, omit the Questions section entirely
+- Maximum 3 questions — only decisions with real impact
+
+Good questions: "Recommend middleware pattern vs wrapper — middleware is simpler but wrapper allows caching. Approve middleware?"
+Bad questions: "What should I name the function?", "Should I add tests?"
+
 {{TASK_CONTEXT}}

package/prompts/taskify.md

@@ -17,7 +17,8 @@ Required JSON format:
   "title": "Brief title, max 72 characters",
   "description": "Clear description of what the task requires",
   "scope": ["list", "of", "exact/file/paths", "affected"],
-  "risk_level": "low | medium | high"
+  "risk_level": "low | medium | high",
+  "questions": []
 }
 
 Risk level heuristics:
@@ -25,6 +26,17 @@ Risk level heuristics:
 - medium: multiple files, possible side effects, API changes, new dependencies, refactoring existing logic
 - high: core business logic, data migrations, security, authentication, payment processing, database schema changes
 
+Questions rules:
+- ONLY ask product/requirements questions — things you CANNOT determine by reading code
+- Ask about: unclear scope, missing acceptance criteria, ambiguous user behavior, missing edge case decisions
+- Do NOT ask about technical implementation — that is the planner's job
+- Do NOT ask about things you can find by reading the codebase (file structure, frameworks, patterns)
+- If the task is clear and complete, leave questions as an empty array []
+- Maximum 3 questions — only the most important ones
+
+Good questions: "Should the search be case-sensitive?", "Which users should have access?", "Should this work offline?"
+Bad questions: "What framework should I use?", "Where should I put the file?", "What's the project structure?"
+
 Guidelines:
 - scope must contain exact file paths (use Glob to discover them)
 - title must be actionable ("Add X", "Fix Y", "Refactor Z")

package/templates/kody.yml

@@ -103,16 +103,41 @@ jobs:
 
           # Validate mode
           case "$MODE" in
-            full|rerun|status) ;;
-            *) MODE="full"; TASK_ID="$MODE" ;;
+            full|rerun|status|approve) ;;
+            *)
+              # If first arg isn't a mode, it might be a task-id or nothing
+              if [ -n "$MODE" ] && [ "$MODE" != "" ]; then
+                TASK_ID="$MODE"
+              fi
+              MODE="full"
+              ;;
           esac
 
+          # Auto-generate task-id if not provided
+          ISSUE_NUM="${{ github.event.issue.number }}"
+          if [ -z "$TASK_ID" ]; then
+            TASK_ID="${ISSUE_NUM}-$(date +%y%m%d-%H%M%S)"
+          fi
+
+          # For approve mode: extract answer body and convert to rerun
+          if [ "$MODE" = "approve" ]; then
+            # Everything after @kody approve [task-id] is the feedback
+            APPROVE_BODY=$(echo "$BODY" | sed -n '/\(@kody\|\/kody\)\s*approve/,$p' | tail -n +2)
+            FEEDBACK="$APPROVE_BODY"
+            MODE="rerun"
+            # FROM_STAGE will be determined by entry.ts from paused state
+          fi
+
           echo "task_id=$TASK_ID" >> $GITHUB_OUTPUT
           echo "mode=$MODE" >> $GITHUB_OUTPUT
           echo "from_stage=$FROM_STAGE" >> $GITHUB_OUTPUT
-          echo "issue_number=${{ github.event.issue.number }}" >> $GITHUB_OUTPUT
-          echo "feedback=$FEEDBACK" >> $GITHUB_OUTPUT
-          echo "valid=$([ -n "$TASK_ID" ] && echo true || echo false)" >> $GITHUB_OUTPUT
+          echo "issue_number=$ISSUE_NUM" >> $GITHUB_OUTPUT
+          {
+            echo "feedback<<KODY_EOF"
+            echo "$FEEDBACK"
+            echo "KODY_EOF"
+          } >> $GITHUB_OUTPUT
+          echo "valid=true" >> $GITHUB_OUTPUT
 
   # ─── Orchestrate ─────────────────────────────────────────────────────────────
   orchestrate: