@kody-ade/kody-engine-lite 0.1.81 → 0.1.82

package/dist/bin/cli.js

@@ -137,7 +137,7 @@ var init_agent_runner = __esm({
   "src/agent-runner.ts"() {
     "use strict";
     SIGKILL_GRACE_MS = 5e3;
-    STDERR_TAIL_CHARS = 500;
+    STDERR_TAIL_CHARS = 2e3;
     RUNNER_FACTORIES = {
       "claude-code": createClaudeCodeRunner
     };
@@ -282,7 +282,11 @@ function getProjectConfig() {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
         github: { ...DEFAULT_CONFIG.github, ...raw.github },
-        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
+        agent: {
+          ...DEFAULT_CONFIG.agent,
+          ...raw.agent,
+          modelMap: { ...DEFAULT_CONFIG.agent.modelMap, ...raw.agent?.modelMap }
+        },
         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
       };
@@ -1868,8 +1872,8 @@ async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, mo
     `Stage: ${stageName}`,
     ``,
     `Error output:`,
-    errorOutput.slice(-2e3),
-    // Last 2000 chars of error
+    errorOutput.slice(-5e3),
+    // Last 5000 chars of error for accurate diagnosis
     ``,
     modifiedFiles.length > 0 ? `Files modified by build stage:
 ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (build may not have run yet)."
@@ -1916,13 +1920,21 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const output = execFileSync5("git", ["diff", "--name-only", "HEAD~1"], {
+    const staged = execFileSync5("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return output ? output.split("\n").filter(Boolean) : [];
+    const unstaged = execFileSync5("git", ["diff", "--name-only"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const all = `${staged}
+${unstaged}`.split("\n").filter(Boolean);
+    return [...new Set(all)];
   } catch {
     return [];
   }
@@ -2122,55 +2134,198 @@ var init_verify = __esm({
   }
 });
 
-// src/stages/review.ts
+// src/cli/task-resolution.ts
 import * as fs9 from "fs";
 import * as path9 from "path";
+import { execFileSync as execFileSync7 } 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 prefix = `${issueNumber}-`;
+  const direct = allDirs.find((d) => d.startsWith(prefix));
+  if (direct) return direct;
+  try {
+    const branch = execFileSync7("git", ["branch", "--show-current"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branchIssueMatch = branch.match(/^(\d+)-/);
+    if (branchIssueMatch) {
+      const branchIssueNum = branchIssueMatch[1];
+      const branchPrefix = `${branchIssueNum}-`;
+      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
+      if (fromBranch) return fromBranch;
+    }
+  } catch {
+  }
+  return null;
+}
+function generateTaskId() {
+  const now = /* @__PURE__ */ new Date();
+  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())}`;
+}
+var init_task_resolution = __esm({
+  "src/cli/task-resolution.ts"() {
+    "use strict";
+  }
+});
+
+// src/review-standalone.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+function resolveReviewTarget(input) {
+  if (input.prs.length === 0) {
+    return {
+      action: "none",
+      message: `Issue #${input.issueNumber} has no open PRs. Nothing to review.`
+    };
+  }
+  if (input.prs.length === 1) {
+    return { action: "review", prNumber: input.prs[0].number };
+  }
+  const prList = input.prs.map((pr) => `  - #${pr.number}: ${pr.title}`).join("\n");
+  return {
+    action: "pick",
+    prs: input.prs,
+    message: `\u26A0\uFE0F Issue #${input.issueNumber} has ${input.prs.length} open PRs:
+${prList}
+
+Run: \`pnpm kody review --pr-number <n>\`
+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 taskContent = `# ${input.prTitle}
+
+${input.prBody ?? ""}`;
+  fs10.writeFileSync(path10.join(taskDir, "task.md"), taskContent);
+  const reviewDef = STAGES.find((s) => s.name === "review");
+  const ctx = {
+    taskId,
+    taskDir,
+    projectDir: input.projectDir,
+    runners: input.runners,
+    sessions: {},
+    input: {
+      mode: "full",
+      local: input.local
+    }
+  };
+  logger.info(`[review] standalone review for: ${input.prTitle}`);
+  const result = await executeAgentStage(ctx, reviewDef);
+  if (result.outcome !== "completed") {
+    return {
+      outcome: "failed",
+      taskDir,
+      error: result.error ?? "Review stage failed"
+    };
+  }
+  const reviewPath = path10.join(taskDir, "review.md");
+  let reviewContent;
+  if (fs10.existsSync(reviewPath)) {
+    reviewContent = fs10.readFileSync(reviewPath, "utf-8");
+  }
+  return {
+    outcome: "completed",
+    reviewContent,
+    taskDir
+  };
+}
+function detectReviewVerdict(reviewContent) {
+  const verdictMatch = reviewContent.match(/##\s*Verdict:\s*(PASS|FAIL)/i);
+  if (verdictMatch) {
+    return verdictMatch[1].toLowerCase();
+  }
+  const hasCritical = /###\s*Critical\s*\n(?!None\.)/i.test(reviewContent);
+  const hasMajor = /###\s*Major\s*\n(?!None\.)/i.test(reviewContent);
+  if (hasCritical || hasMajor) return "fail";
+  return "pass";
+}
+function formatReviewComment(reviewContent, taskId) {
+  const verdict = detectReviewVerdict(reviewContent);
+  const cta = verdict === "fail" ? "\n\n> To fix these issues, comment: `@kody fix`\n> The review findings will be used automatically as context." : "";
+  return `## \u{1F50D} Kody Review (\`${taskId}\`)
+
+${reviewContent}${cta}
+
+---
+\u{1F916} Generated by Kody`;
+}
+var init_review_standalone = __esm({
+  "src/review-standalone.ts"() {
+    "use strict";
+    init_definitions();
+    init_agent();
+    init_task_resolution();
+    init_logger();
+  }
+});
+
+// src/stages/review.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
 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);
-  if (reviewResult.outcome !== "completed") {
-    return reviewResult;
-  }
-  const reviewFile = path9.join(ctx.taskDir, "review.md");
-  if (!fs9.existsSync(reviewFile)) {
-    return { outcome: "failed", retries: 0, error: "review.md not found" };
-  }
-  const content = fs9.readFileSync(reviewFile, "utf-8");
-  const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
-  if (!hasIssues) {
-    return reviewResult;
-  }
-  logger.info(`  review found issues, running review-fix...`);
-  const fixResult = await executeAgentStage(ctx, reviewFixDef);
-  if (fixResult.outcome !== "completed") {
-    return fixResult;
+  for (let iteration = 0; iteration <= MAX_REVIEW_FIX_ITERATIONS; iteration++) {
+    const label = iteration === 0 ? "initial review" : `review after fix #${iteration}`;
+    logger.info(`  running ${label}...`);
+    const reviewResult = await executeAgentStage(ctx, reviewDef);
+    if (reviewResult.outcome !== "completed") {
+      return reviewResult;
+    }
+    const reviewFile = path11.join(ctx.taskDir, "review.md");
+    if (!fs11.existsSync(reviewFile)) {
+      return { outcome: "failed", retries: iteration, error: "review.md not found" };
+    }
+    const content = fs11.readFileSync(reviewFile, "utf-8");
+    if (detectReviewVerdict(content) !== "fail") {
+      return { ...reviewResult, retries: iteration };
+    }
+    if (iteration === MAX_REVIEW_FIX_ITERATIONS) {
+      logger.warn(`  review still failing after ${MAX_REVIEW_FIX_ITERATIONS} fix attempts`);
+      return { ...reviewResult, retries: iteration };
+    }
+    logger.info(`  review found issues (iteration ${iteration + 1}/${MAX_REVIEW_FIX_ITERATIONS}), running review-fix...`);
+    const fixResult = await executeAgentStage(ctx, reviewFixDef);
+    if (fixResult.outcome !== "completed") {
+      return fixResult;
+    }
   }
-  logger.info(`  re-running review after fix...`);
-  return executeAgentStage(ctx, reviewDef);
+  return { outcome: "failed", retries: MAX_REVIEW_FIX_ITERATIONS, error: "Unexpected review-fix loop exit" };
 }
+var MAX_REVIEW_FIX_ITERATIONS;
 var init_review = __esm({
   "src/stages/review.ts"() {
     "use strict";
     init_definitions();
     init_logger();
     init_agent();
+    init_review_standalone();
+    MAX_REVIEW_FIX_ITERATIONS = 2;
   }
 });
 
 // src/stages/ship.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
-import { execFileSync as execFileSync7 } from "child_process";
+import * as fs12 from "fs";
+import * as path12 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path10.join(ctx.taskDir, "task.json");
-  if (fs10.existsSync(taskJsonPath)) {
+  const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+  if (fs12.existsSync(taskJsonPath)) {
     try {
-      const raw = fs10.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs12.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2189,9 +2344,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path10.join(ctx.taskDir, "review.md");
-  if (fs10.existsSync(reviewPath)) {
-    const review = fs10.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path12.join(ctx.taskDir, "review.md");
+  if (fs12.existsSync(reviewPath)) {
+    const review = fs12.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2208,14 +2363,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path10.join(ctx.taskDir, "verify.md");
-  if (fs10.existsSync(verifyPath)) {
-    const verify = fs10.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path12.join(ctx.taskDir, "verify.md");
+  if (fs12.existsSync(verifyPath)) {
+    const verify = fs12.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path10.join(ctx.taskDir, "plan.md");
-  if (fs10.existsSync(planPath)) {
-    const plan = fs10.readFileSync(planPath, "utf-8").trim();
+  const planPath = path12.join(ctx.taskDir, "plan.md");
+  if (fs12.existsSync(planPath)) {
+    const plan = fs12.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2235,25 +2390,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path10.join(ctx.taskDir, "ship.md");
+  const shipPath = path12.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs10.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs12.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   if (ctx.input.local && !ctx.input.issueNumber) {
-    fs10.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs12.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
     const head = getCurrentBranch(ctx.projectDir);
     const base = getDefaultBranch(ctx.projectDir);
     try {
-      execFileSync7("git", ["add", ctx.taskDir], {
+      execFileSync8("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync7("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync8("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
@@ -2267,7 +2422,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync7("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync8("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -2287,10 +2442,10 @@ function executeShipStage(ctx, _def) {
       docs: "docs",
       chore: "chore"
     };
-    const taskJsonPath = path10.join(ctx.taskDir, "task.json");
-    if (fs10.existsSync(taskJsonPath)) {
+    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+    if (fs12.existsSync(taskJsonPath)) {
       try {
-        const raw = fs10.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs12.readFileSync(taskJsonPath, "utf-8");
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         const prefix = TYPE_PREFIX[task.task_type] ?? "chore";
@@ -2300,9 +2455,9 @@ function executeShipStage(ctx, _def) {
       }
     }
     if (title === "Update") {
-      const taskMdPath = path10.join(ctx.taskDir, "task.md");
-      if (fs10.existsSync(taskMdPath)) {
-        const content = fs10.readFileSync(taskMdPath, "utf-8");
+      const taskMdPath = path12.join(ctx.taskDir, "task.md");
+      if (fs12.existsSync(taskMdPath)) {
+        const content = fs12.readFileSync(taskMdPath, "utf-8");
         const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("*"));
         if (firstLine) title = `chore: ${firstLine.trim()}`.slice(0, 72);
       }
@@ -2322,7 +2477,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs10.writeFileSync(shipPath, `# Ship
+      fs12.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2343,19 +2498,19 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs10.writeFileSync(shipPath, `# Ship
+        fs12.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs10.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs12.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
       }
     }
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    fs10.writeFileSync(shipPath, `# Ship
+    fs12.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -2401,15 +2556,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path11.join(ctx.taskDir, "task.json");
-      if (!fs11.existsSync(taskJsonPath)) return false;
-      const raw = fs11.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path13.join(ctx.taskDir, "task.json");
+      if (!fs13.existsSync(taskJsonPath)) return false;
+      const raw = fs13.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const taskJson = JSON.parse(cleaned);
       if (taskJson.questions && Array.isArray(taskJson.questions) && taskJson.questions.length > 0) {
@@ -2424,9 +2579,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path11.join(ctx.taskDir, "plan.md");
-      if (!fs11.existsSync(planPath)) return false;
-      const plan = fs11.readFileSync(planPath, "utf-8");
+      const planPath = path13.join(ctx.taskDir, "plan.md");
+      if (!fs13.existsSync(planPath)) return false;
+      const plan = fs13.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2455,8 +2610,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
@@ -2482,9 +2637,9 @@ function autoDetectComplexity(ctx, def) {
   if (def.name !== "taskify") return null;
   if (ctx.input.complexity) return null;
   try {
-    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
-    if (!fs12.existsSync(taskJsonPath)) return null;
-    const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path14.join(ctx.taskDir, "task.json");
+    if (!fs14.existsSync(taskJsonPath)) return null;
+    const raw = fs14.readFileSync(taskJsonPath, "utf-8");
     const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const taskJson = JSON.parse(cleaned);
     if (!taskJson.risk_level || !isValidComplexity(taskJson.risk_level)) return null;
@@ -2514,8 +2669,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 = path12.join(ctx.taskDir, "plan.md");
-  const plan = fs12.existsSync(planPath) ? fs12.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path14.join(ctx.taskDir, "plan.md");
+  const plan = fs14.existsSync(planPath) ? fs14.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2582,22 +2737,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path13.join(ctx.projectDir, ".kody", "memory");
-    if (!fs13.existsSync(memoryDir)) {
-      fs13.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path15.join(ctx.projectDir, ".kody", "memory");
+    if (!fs15.existsSync(memoryDir)) {
+      fs15.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path13.join(ctx.taskDir, "verify.md");
-    if (fs13.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs13.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path15.join(ctx.taskDir, "verify.md");
+    if (fs15.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs15.readFileSync(verifyPath, "utf-8"));
       if (/vitest/i.test(verify)) learnings.push("- Uses vitest for testing");
       if (/jest/i.test(verify)) learnings.push("- Uses jest for testing");
       if (/eslint/i.test(verify)) learnings.push("- Uses eslint for linting");
@@ -2606,18 +2761,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 = path13.join(ctx.taskDir, "review.md");
-    if (fs13.existsSync(reviewPath)) {
-      const review = fs13.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path15.join(ctx.taskDir, "review.md");
+    if (fs15.existsSync(reviewPath)) {
+      const review = fs15.readFileSync(reviewPath, "utf-8");
       if (/\.js extension/i.test(review)) learnings.push("- Imports use .js extensions (ESM)");
       if (/barrel export/i.test(review)) learnings.push("- Uses barrel exports (index.ts)");
       if (/timezone/i.test(review)) learnings.push("- Timezone handling is a concern in this codebase");
       if (/UTC/i.test(review)) learnings.push("- Date operations should consider UTC vs local time");
     }
-    const taskJsonPath = path13.join(ctx.taskDir, "task.json");
-    if (fs13.existsSync(taskJsonPath)) {
+    const taskJsonPath = path15.join(ctx.taskDir, "task.json");
+    if (fs15.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs13.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs15.readFileSync(taskJsonPath, "utf-8"));
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         if (task.scope && Array.isArray(task.scope)) {
@@ -2628,13 +2783,13 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path13.join(memoryDir, "conventions.md");
+      const conventionsPath = path15.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs13.appendFileSync(conventionsPath, entry);
-      invalidateCache(conventionsPath, path13.join(memoryDir, ".tiers"));
+      fs15.appendFileSync(conventionsPath, entry);
+      invalidateCache(conventionsPath, path15.join(memoryDir, ".tiers"));
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnDecisions(ctx.taskDir, memoryDir, ctx.taskId, timestamp2);
@@ -2643,13 +2798,13 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path13.join(memoryDir, "architecture.md");
-  if (fs13.existsSync(archPath)) return;
+  const archPath = path15.join(memoryDir, "architecture.md");
+  if (fs15.existsSync(archPath)) return;
   const detected = [];
-  const pkgPath = path13.join(projectDir, "package.json");
-  if (fs13.existsSync(pkgPath)) {
+  const pkgPath = path15.join(projectDir, "package.json");
+  if (fs15.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+      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}`);
@@ -2665,15 +2820,15 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
       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 (fs13.existsSync(path13.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs13.existsSync(path13.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs13.existsSync(path13.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
+      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 = fs13.readdirSync(projectDir, { withFileTypes: true });
+    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);
@@ -2682,10 +2837,10 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
     if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path13.join(projectDir, "src");
-  if (fs13.existsSync(srcDir)) {
+  const srcDir = path15.join(projectDir, "src");
+  if (fs15.existsSync(srcDir)) {
     try {
-      const srcEntries = fs13.readdirSync(srcDir, { withFileTypes: true });
+      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 {
@@ -2697,15 +2852,15 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs13.writeFileSync(archPath, content);
-    invalidateCache(archPath, path13.join(memoryDir, ".tiers"));
+    fs15.writeFileSync(archPath, content);
+    invalidateCache(archPath, path15.join(memoryDir, ".tiers"));
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
 function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
-  const reviewPath = path13.join(taskDir, "review.md");
-  if (!fs13.existsSync(reviewPath)) return;
-  const review = fs13.readFileSync(reviewPath, "utf-8");
+  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)) {
@@ -2724,10 +2879,10 @@ function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
     decisions.push(`- Avoid ${match[1].trim()} for ${match[2].trim()}`);
   }
   if (decisions.length === 0) return;
-  const decisionsPath = path13.join(memoryDir, "decisions.md");
+  const decisionsPath = path15.join(memoryDir, "decisions.md");
   let existing = "";
-  if (fs13.existsSync(decisionsPath)) {
-    existing = fs13.readFileSync(decisionsPath, "utf-8");
+  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";
   }
@@ -2737,8 +2892,8 @@ function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
 ## From task ${taskId} (${timestamp2})
 ${newDecisions.join("\n")}
 `;
-  fs13.appendFileSync(decisionsPath, existing ? entry : existing + entry);
-  invalidateCache(decisionsPath, path13.join(memoryDir, ".tiers"));
+  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({
@@ -2750,13 +2905,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path14.join(taskDir, filename);
-  if (!fs14.existsSync(p)) return null;
+  const p = path16.join(taskDir, filename);
+  if (!fs16.existsSync(p)) return null;
   try {
-    const content = fs14.readFileSync(p, "utf-8");
+    const content = fs16.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -2809,13 +2964,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path14.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path16.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs14.existsSync(logPath)) return [];
+  if (!fs16.existsSync(logPath)) return [];
   try {
-    const content = fs14.readFileSync(logPath, "utf-8");
+    const content = fs16.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -2842,11 +2997,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path14.dirname(logPath);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(logPath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs14.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs16.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -2957,8 +3112,8 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
 });
 
 // src/pipeline.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -2971,8 +3126,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path15.join(ctx.taskDir, "task.md");
-    const title = fs15.existsSync(taskMdPath) ? fs15.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path17.join(ctx.taskDir, "task.md");
+    const title = fs17.existsSync(taskMdPath) ? fs17.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -2980,10 +3135,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path15.join(taskDir, ".lock");
-  if (fs15.existsSync(lockPath)) {
+  const lockPath = path17.join(taskDir, ".lock");
+  if (fs17.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs15.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs17.readFileSync(lockPath, "utf-8").trim(), 10);
       try {
         process.kill(pid, 0);
         throw new Error(`Pipeline already running (PID ${pid})`);
@@ -2994,11 +3149,11 @@ function acquireLock(taskDir) {
       if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
     }
   }
-  fs15.writeFileSync(lockPath, String(process.pid));
+  fs17.writeFileSync(lockPath, String(process.pid));
 }
 function releaseLock(taskDir) {
   try {
-    fs15.unlinkSync(path15.join(taskDir, ".lock"));
+    fs17.unlinkSync(path17.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3166,8 +3321,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync8 } from "child_process";
-import * as fs16 from "fs";
+import { execFileSync as execFileSync9 } from "child_process";
+import * as fs18 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3179,7 +3334,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync8("claude", ["--version"], {
+      const v = execFileSync9("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3187,14 +3342,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync8("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync9("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync8("pnpm", ["--version"], {
+      const v = execFileSync9("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3202,7 +3357,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync8("node", ["--version"], {
+      const v = execFileSync9("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3212,7 +3367,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync8("gh", ["--version"], {
+      const v = execFileSync9("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3220,7 +3375,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs16.existsSync("package.json")) throw new Error("not found");
+      if (!fs18.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3240,140 +3395,6 @@ var init_preflight = __esm({
   }
 });
 
-// src/cli/task-resolution.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
-import { execFileSync as execFileSync9 } from "child_process";
-function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path16.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 = execFileSync9("git", ["branch", "--show-current"], {
-      encoding: "utf-8",
-      cwd: projectDir,
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const branchIssueMatch = branch.match(/^(\d+)-/);
-    if (branchIssueMatch) {
-      const branchIssueNum = branchIssueMatch[1];
-      const branchPrefix = `${branchIssueNum}-`;
-      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
-      if (fromBranch) return fromBranch;
-    }
-  } catch {
-  }
-  return null;
-}
-function generateTaskId() {
-  const now = /* @__PURE__ */ new Date();
-  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())}`;
-}
-var init_task_resolution = __esm({
-  "src/cli/task-resolution.ts"() {
-    "use strict";
-  }
-});
-
-// src/review-standalone.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
-function resolveReviewTarget(input) {
-  if (input.prs.length === 0) {
-    return {
-      action: "none",
-      message: `Issue #${input.issueNumber} has no open PRs. Nothing to review.`
-    };
-  }
-  if (input.prs.length === 1) {
-    return { action: "review", prNumber: input.prs[0].number };
-  }
-  const prList = input.prs.map((pr) => `  - #${pr.number}: ${pr.title}`).join("\n");
-  return {
-    action: "pick",
-    prs: input.prs,
-    message: `\u26A0\uFE0F Issue #${input.issueNumber} has ${input.prs.length} open PRs:
-${prList}
-
-Run: \`pnpm kody review --pr-number <n>\`
-Or comment on the specific PR: \`@kody review\``
-  };
-}
-async function runStandaloneReview(input) {
-  const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path17.join(input.projectDir, ".kody", "tasks", taskId);
-  fs18.mkdirSync(taskDir, { recursive: true });
-  const taskContent = `# ${input.prTitle}
-
-${input.prBody ?? ""}`;
-  fs18.writeFileSync(path17.join(taskDir, "task.md"), taskContent);
-  const reviewDef = STAGES.find((s) => s.name === "review");
-  const ctx = {
-    taskId,
-    taskDir,
-    projectDir: input.projectDir,
-    runners: input.runners,
-    sessions: {},
-    input: {
-      mode: "full",
-      local: input.local
-    }
-  };
-  logger.info(`[review] standalone review for: ${input.prTitle}`);
-  const result = await executeAgentStage(ctx, reviewDef);
-  if (result.outcome !== "completed") {
-    return {
-      outcome: "failed",
-      taskDir,
-      error: result.error ?? "Review stage failed"
-    };
-  }
-  const reviewPath = path17.join(taskDir, "review.md");
-  let reviewContent;
-  if (fs18.existsSync(reviewPath)) {
-    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
-  }
-  return {
-    outcome: "completed",
-    reviewContent,
-    taskDir
-  };
-}
-function detectReviewVerdict(reviewContent) {
-  const verdictMatch = reviewContent.match(/##\s*Verdict:\s*(PASS|FAIL)/i);
-  if (verdictMatch) {
-    return verdictMatch[1].toLowerCase();
-  }
-  const hasCritical = /###\s*Critical\s*\n(?!None\.)/i.test(reviewContent);
-  const hasMajor = /###\s*Major\s*\n(?!None\.)/i.test(reviewContent);
-  if (hasCritical || hasMajor) return "fail";
-  return "pass";
-}
-function formatReviewComment(reviewContent, taskId) {
-  const verdict = detectReviewVerdict(reviewContent);
-  const cta = verdict === "fail" ? "\n\n> To fix these issues, comment: `@kody fix`\n> The review findings will be used automatically as context." : "";
-  return `## \u{1F50D} Kody Review (\`${taskId}\`)
-
-${reviewContent}${cta}
-
----
-\u{1F916} Generated by Kody`;
-}
-var init_review_standalone = __esm({
-  "src/review-standalone.ts"() {
-    "use strict";
-    init_definitions();
-    init_agent();
-    init_task_resolution();
-    init_logger();
-  }
-});
-
 // src/cli/args.ts
 function getArg(args2, flag) {
   const idx = args2.indexOf(flag);
@@ -3938,7 +3959,6 @@ async function main() {
       console.log(result.reviewContent);
       if (!input.local && prNumber) {
         const comment = formatReviewComment(result.reviewContent, taskId);
-        postPRComment(prNumber, comment);
         const verdict = detectReviewVerdict(result.reviewContent);
         if (verdict === "fail") {
           submitPRReview(prNumber, comment, "request-changes");

package/package.json

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