@kody-ade/kody-engine-lite 0.1.33 → 0.1.35

package/dist/bin/cli.js

@@ -2516,15 +2516,70 @@ var init_task_resolution = __esm({
   }
 });
 
-// src/entry.ts
-var entry_exports = {};
+// src/cli/task-state.ts
 import * as fs18 from "fs";
 import * as path17 from "path";
+function resolveTaskAction(issueNumber, existingTaskId, existingState) {
+  if (!existingTaskId || !existingState) {
+    return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
+  }
+  if (existingState.state === "completed") {
+    return { action: "already-completed", taskId: existingTaskId };
+  }
+  if (existingState.state === "running") {
+    return { action: "already-running", taskId: existingTaskId };
+  }
+  if (existingState.state === "failed") {
+    for (const stageName of STAGE_ORDER) {
+      const stage = existingState.stages[stageName];
+      if (!stage) continue;
+      if (stage.error?.includes("paused")) {
+        const idx = STAGE_ORDER.indexOf(stageName);
+        if (idx < STAGE_ORDER.length - 1) {
+          return { action: "resume", taskId: existingTaskId, fromStage: STAGE_ORDER[idx + 1] };
+        }
+      }
+      if (stage.state === "failed" || stage.state === "pending") {
+        return { action: "resume", taskId: existingTaskId, fromStage: stageName };
+      }
+    }
+    return { action: "resume", taskId: existingTaskId, fromStage: "taskify" };
+  }
+  return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
+}
+function resolveForIssue(issueNumber, projectDir) {
+  const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
+  if (!existingTaskId) {
+    return resolveTaskAction(issueNumber, null, null);
+  }
+  const statusPath = path17.join(projectDir, ".tasks", existingTaskId, "status.json");
+  let existingState = null;
+  if (fs18.existsSync(statusPath)) {
+    try {
+      existingState = JSON.parse(fs18.readFileSync(statusPath, "utf-8"));
+    } catch {
+    }
+  }
+  return resolveTaskAction(issueNumber, existingTaskId, existingState);
+}
+var STAGE_ORDER;
+var init_task_state = __esm({
+  "src/cli/task-state.ts"() {
+    "use strict";
+    init_task_resolution();
+    STAGE_ORDER = ["taskify", "plan", "build", "verify", "review", "review-fix", "ship"];
+  }
+});
+
+// src/entry.ts
+var entry_exports = {};
+import * as fs19 from "fs";
+import * as path18 from "path";
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path17.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path18.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs18.existsSync(projectDir)) {
+    if (!fs19.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -2534,16 +2589,35 @@ async function main() {
   }
   let taskId = input.taskId;
   if (!taskId) {
-    if ((input.command === "rerun" || input.command === "fix") && input.issueNumber) {
-      const found = findLatestTaskForIssue(input.issueNumber, projectDir);
-      if (!found) {
-        console.error(`No previous task found for issue #${input.issueNumber}`);
-        process.exit(1);
+    if (input.issueNumber) {
+      const taskAction = resolveForIssue(input.issueNumber, projectDir);
+      logger.info(`Task action: ${taskAction.action}`);
+      if (taskAction.action === "already-completed") {
+        logger.info(`Issue #${input.issueNumber} already completed (task ${taskAction.taskId})`);
+        if (!input.local) {
+          try {
+            postComment(input.issueNumber, `\u2705 Issue #${input.issueNumber} already completed (task \`${taskAction.taskId}\`)`);
+          } catch {
+          }
+        }
+        process.exit(0);
+      }
+      if (taskAction.action === "already-running") {
+        logger.info(`Issue #${input.issueNumber} already running (task ${taskAction.taskId})`);
+        if (!input.local) {
+          try {
+            postComment(input.issueNumber, `\u23F3 Pipeline already running for issue #${input.issueNumber} (task \`${taskAction.taskId}\`)`);
+          } catch {
+          }
+        }
+        process.exit(0);
+      }
+      taskId = taskAction.taskId;
+      if (taskAction.action === "resume") {
+        input.fromStage = taskAction.fromStage;
+        input.command = "rerun";
+        logger.info(`Resuming task ${taskId} from ${taskAction.fromStage}`);
       }
-      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 {
@@ -2551,8 +2625,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path17.join(projectDir, ".tasks", taskId);
-  fs18.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path18.join(projectDir, ".tasks", taskId);
+  fs19.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -2560,67 +2634,27 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs18.writeFileSync(path17.join(taskDir, "task.md"), input.task);
+    fs19.writeFileSync(path18.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path17.join(taskDir, "task.md");
-  if (!fs18.existsSync(taskMdPath) && input.issueNumber) {
+  const taskMdPath = path18.join(taskDir, "task.md");
+  if (!fs19.existsSync(taskMdPath) && input.issueNumber) {
     logger.info(`Fetching issue #${input.issueNumber} body as task...`);
     const issue = getIssue(input.issueNumber);
     if (issue) {
       const taskContent = `# ${issue.title}
 
 ${issue.body ?? ""}`;
-      fs18.writeFileSync(taskMdPath, taskContent);
+      fs19.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (input.command === "run") {
-    if (!fs18.existsSync(taskMdPath)) {
-      console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
-      process.exit(1);
-    }
+  if (!fs19.existsSync(taskMdPath)) {
+    console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
+    process.exit(1);
   }
   if (input.command === "fix" && !input.fromStage) {
     input.fromStage = "build";
   }
-  if (input.command === "rerun" && !input.fromStage) {
-    const statusPath = path17.join(taskDir, "status.json");
-    if (fs18.existsSync(statusPath)) {
-      try {
-        const status = JSON.parse(fs18.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 {
-      logger.info("No status.json found \u2014 running full pipeline with feedback");
-      input.command = "run";
-    }
-  }
   const config = getProjectConfig();
   let litellmProcess = null;
   const cleanupLitellm = () => {
@@ -2694,7 +2728,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs18.readdirSync(taskDir);
+  const files = fs19.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -2738,6 +2772,7 @@ var init_entry = __esm({
     init_args();
     init_litellm();
     init_task_resolution();
+    init_task_state();
     main().catch(async (err) => {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(msg);
@@ -2755,15 +2790,15 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 import { fileURLToPath } from "url";
-var __dirname = path18.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path18.resolve(__dirname, "..", "..");
+var __dirname = path19.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path19.resolve(__dirname, "..", "..");
 function getVersion() {
-  const pkgPath = path18.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path19.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 function checkCommand2(name, args2, fix) {
@@ -2779,7 +2814,7 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs19.existsSync(filePath)) {
+  if (fs20.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
@@ -2851,10 +2886,10 @@ function checkGhSecret(repoSlug, secretName) {
 }
 function detectArchitecture(cwd) {
   const detected = [];
-  const pkgPath = path18.join(cwd, "package.json");
-  if (fs19.existsSync(pkgPath)) {
+  const pkgPath = path19.join(cwd, "package.json");
+  if (fs20.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs20.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}`);
@@ -2877,41 +2912,41 @@ function detectArchitecture(cwd) {
       if (allDeps.tailwindcss) detected.push(`- CSS: Tailwind CSS ${allDeps.tailwindcss}`);
       if (pkg.type === "module") detected.push("- Module system: ESM");
       else detected.push("- Module system: CommonJS");
-      if (fs19.existsSync(path18.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs19.existsSync(path18.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs19.existsSync(path18.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs19.existsSync(path18.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs20.existsSync(path19.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs20.existsSync(path19.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
+      else if (fs20.existsSync(path19.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }
   try {
-    const entries = fs19.readdirSync(cwd, { withFileTypes: true });
+    const entries = fs20.readdirSync(cwd, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     if (dirs.length > 0) detected.push(`- Top-level directories: ${dirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path18.join(cwd, "src");
-  if (fs19.existsSync(srcDir)) {
+  const srcDir = path19.join(cwd, "src");
+  if (fs20.existsSync(srcDir)) {
     try {
-      const srcEntries = fs19.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs20.readdirSync(srcDir, { withFileTypes: true });
       const srcDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
     } catch {
     }
   }
   const configs = [];
-  if (fs19.existsSync(path18.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
-  if (fs19.existsSync(path18.join(cwd, "docker-compose.yml")) || fs19.existsSync(path18.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
-  if (fs19.existsSync(path18.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
-  if (fs19.existsSync(path18.join(cwd, ".env")) || fs19.existsSync(path18.join(cwd, ".env.local"))) configs.push(".env");
+  if (fs20.existsSync(path19.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
+  if (fs20.existsSync(path19.join(cwd, "docker-compose.yml")) || fs20.existsSync(path19.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
+  if (fs20.existsSync(path19.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
+  if (fs20.existsSync(path19.join(cwd, ".env")) || fs20.existsSync(path19.join(cwd, ".env.local"))) configs.push(".env");
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs19.existsSync(path18.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs19.existsSync(path18.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs19.existsSync(path18.join(cwd, "pnpm-lock.yaml")) && fs19.existsSync(path18.join(cwd, "package-lock.json"))) pm = "npm";
+  if (fs20.existsSync(path19.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs20.existsSync(path19.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml")) && fs20.existsSync(path19.join(cwd, "package-lock.json"))) pm = "npm";
   let defaultBranch = "main";
   try {
     const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
@@ -2955,9 +2990,9 @@ function smartInit(cwd) {
   const basic = detectBasicConfig(cwd);
   let context = "";
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path18.join(cwd, rel);
-    if (fs19.existsSync(p)) {
-      const content = fs19.readFileSync(p, "utf-8");
+    const p = path19.join(cwd, rel);
+    if (fs20.existsSync(p)) {
+      const content = fs20.readFileSync(p, "utf-8");
       return content.slice(0, maxChars);
     }
     return null;
@@ -2983,14 +3018,14 @@ ${claudeMd}
 
 `;
   try {
-    const topDirs = fs19.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs20.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 = path18.join(cwd, "src");
-    if (fs19.existsSync(srcDir)) {
-      const srcDirs = fs19.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path19.join(cwd, "src");
+    if (fs20.existsSync(srcDir)) {
+      const srcDirs = fs20.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       context += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -3000,7 +3035,7 @@ ${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 (fs19.existsSync(path18.join(cwd, f))) existingFiles.push(f);
+    if (fs20.existsSync(path19.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
@@ -3106,7 +3141,7 @@ ${context}`;
 function validateQualityCommands(cwd, config, pm) {
   let scripts = {};
   try {
-    const pkg = JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return;
@@ -3140,7 +3175,7 @@ function validateQualityCommands(cwd, config, pm) {
 function buildFallbackConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -3180,34 +3215,34 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path18.join(PKG_ROOT, "templates");
-  const workflowSrc = path18.join(templatesDir, "kody.yml");
-  const workflowDest = path18.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs19.existsSync(workflowSrc)) {
+  const templatesDir = path19.join(PKG_ROOT, "templates");
+  const workflowSrc = path19.join(templatesDir, "kody.yml");
+  const workflowDest = path19.join(cwd, ".github", "workflows", "kody.yml");
+  if (!fs20.existsSync(workflowSrc)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs19.existsSync(workflowDest) && !opts.force) {
+  if (fs20.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs19.mkdirSync(path18.dirname(workflowDest), { recursive: true });
-    fs19.copyFileSync(workflowSrc, workflowDest);
+    fs20.mkdirSync(path19.dirname(workflowDest), { recursive: true });
+    fs20.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path18.join(cwd, "kody.config.json");
+  const configDest = path19.join(cwd, "kody.config.json");
   let smartResult = null;
-  if (!fs19.existsSync(configDest) || opts.force) {
+  if (!fs20.existsSync(configDest) || opts.force) {
     smartResult = smartInit(cwd);
-    fs19.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    fs20.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)");
   }
-  const gitignorePath = path18.join(cwd, ".gitignore");
-  if (fs19.existsSync(gitignorePath)) {
-    const content = fs19.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path19.join(cwd, ".gitignore");
+  if (fs20.existsSync(gitignorePath)) {
+    const content = fs20.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".tasks/")) {
-      fs19.appendFileSync(gitignorePath, "\n.tasks/\n");
+      fs20.appendFileSync(gitignorePath, "\n.tasks/\n");
       console.log("  \u2713 .gitignore (added .tasks/)");
     } else {
       console.log("  \u25CB .gitignore (.tasks/ already present)");
@@ -3220,7 +3255,7 @@ function initCommand(opts) {
     checkCommand2("git", ["--version"], "Install git"),
     checkCommand2("node", ["--version"], "Install Node.js >= 22"),
     checkCommand2("pnpm", ["--version"], "Install: npm i -g pnpm"),
-    checkFile(path18.join(cwd, "package.json"), "package.json", "Run: pnpm init")
+    checkFile(path19.join(cwd, "package.json"), "package.json", "Run: pnpm init")
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -3297,9 +3332,9 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs19.existsSync(configDest)) {
+  if (fs20.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs19.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs20.readFileSync(configDest, "utf-8"));
       const configChecks = [];
       if (config.github?.owner && config.github?.repo) {
         configChecks.push({ name: "github.owner/repo", ok: true, detail: `${config.github.owner}/${config.github.repo}` });
@@ -3326,21 +3361,21 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path18.join(cwd, ".kody", "memory");
-  fs19.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path18.join(memoryDir, "architecture.md");
-  const conventionsPath = path18.join(memoryDir, "conventions.md");
-  if (fs19.existsSync(archPath) && !opts.force) {
+  const memoryDir = path19.join(cwd, ".kody", "memory");
+  fs20.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path19.join(memoryDir, "architecture.md");
+  const conventionsPath = path19.join(memoryDir, "conventions.md");
+  if (fs20.existsSync(archPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
   } else if (smartResult?.architecture) {
-    fs19.writeFileSync(archPath, smartResult.architecture);
+    fs20.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) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs19.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs20.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
@@ -3350,14 +3385,14 @@ ${archItems.join("\n")}
       console.log("  \u25CB No architecture detected");
     }
   }
-  if (fs19.existsSync(conventionsPath) && !opts.force) {
+  if (fs20.existsSync(conventionsPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
   } else if (smartResult?.conventions) {
-    fs19.writeFileSync(conventionsPath, smartResult.conventions);
+    fs20.writeFileSync(conventionsPath, smartResult.conventions);
     const lineCount = smartResult.conventions.split("\n").length;
     console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
   } else {
-    fs19.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs20.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 Git \u2500\u2500");
@@ -3366,7 +3401,7 @@ ${archItems.join("\n")}
     "kody.config.json",
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md"
-  ].filter((f) => fs19.existsSync(path18.join(cwd, f)));
+  ].filter((f) => fs20.existsSync(path19.join(cwd, f)));
   if (filesToCommit.length > 0) {
     try {
       execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });

package/package.json

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