@kody-ade/kody-engine-lite 0.1.25 → 0.1.27

package/dist/bin/cli.js

@@ -698,6 +698,16 @@ ${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
     context += `
 ## Plan Summary
 ${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
+`;
+  }
+  const contextMdPath = path4.join(taskDir, "context.md");
+  if (fs4.existsSync(contextMdPath)) {
+    const accumulated = fs4.readFileSync(contextMdPath, "utf-8");
+    const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
+    const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
+    context += `
+## Previous Stage Context
+${prefix}${truncated}
 `;
   }
   if (feedback) {
@@ -726,7 +736,7 @@ function resolveModel(modelTier, stageName) {
   if (mapped) return mapped;
   return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
 }
-var DEFAULT_MODEL_MAP, MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC;
+var DEFAULT_MODEL_MAP, MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT;
 var init_context = __esm({
   "src/context.ts"() {
     "use strict";
@@ -739,6 +749,7 @@ var init_context = __esm({
     };
     MAX_TASK_CONTEXT_PLAN = 1500;
     MAX_TASK_CONTEXT_SPEC = 2e3;
+    MAX_ACCUMULATED_CONTEXT = 4e3;
   }
 });
 
@@ -894,8 +905,25 @@ async function executeAgentStage(ctx, def) {
       }
     }
   }
+  appendStageContext(ctx.taskDir, def.name, result.output);
   return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
 }
+function appendStageContext(taskDir, stageName, output) {
+  const contextPath = path5.join(taskDir, "context.md");
+  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
+  let summary;
+  if (output && output.trim()) {
+    summary = output.slice(0, 500);
+    if (output.length > 500) summary += "\n...(truncated)";
+  } else {
+    summary = "(stage completed via tool use \u2014 no text output)";
+  }
+  const entry = `
+### ${stageName} (${timestamp2})
+${summary}
+`;
+  fs5.appendFileSync(contextPath, entry);
+}
 var init_agent = __esm({
   "src/stages/agent.ts"() {
     "use strict";
@@ -1596,6 +1624,39 @@ function autoDetectComplexity(ctx, def) {
     return null;
   }
 }
+function checkRiskGate(ctx, def, state, complexity) {
+  if (def.name !== "plan") return null;
+  if (complexity !== "high") return null;
+  if (ctx.input.dryRun || ctx.input.local) return null;
+  if (ctx.input.mode === "rerun") return null;
+  if (!ctx.input.issueNumber) return null;
+  const planPath = path11.join(ctx.taskDir, "plan.md");
+  const plan = fs11.existsSync(planPath) ? fs11.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  try {
+    postComment(
+      ctx.input.issueNumber,
+      `\u{1F6D1} **Risk gate: HIGH complexity \u2014 awaiting approval**
+
+<details><summary>\u{1F4CB} Plan summary</summary>
+
+${plan}
+</details>
+
+To approve: \`@kody approve\``
+    );
+    setLifecycleLabel(ctx.input.issueNumber, "waiting");
+  } catch {
+  }
+  state.state = "failed";
+  state.stages[def.name] = {
+    ...state.stages[def.name],
+    state: "completed",
+    error: "paused: risk gate \u2014 awaiting approval"
+  };
+  writeState(state, ctx.taskDir);
+  logger.info(`  Pipeline paused \u2014 HIGH risk gate, awaiting approval on issue`);
+  return state;
+}
 function commitAfterStage(ctx, def) {
   if (ctx.input.dryRun || !ctx.input.issueNumber) return;
   if (def.name === "build") {
@@ -1761,14 +1822,212 @@ var init_auto_learn = __esm({
   }
 });
 
-// src/pipeline.ts
+// src/retrospective.ts
 import * as fs13 from "fs";
 import * as path13 from "path";
+function readArtifact(taskDir, filename, maxChars) {
+  const p = path13.join(taskDir, filename);
+  if (!fs13.existsSync(p)) return null;
+  try {
+    const content = fs13.readFileSync(p, "utf-8");
+    return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
+  } catch {
+    return null;
+  }
+}
+function computeStageDuration(stage) {
+  if (!stage.startedAt) return void 0;
+  const end = stage.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  return new Date(end).getTime() - new Date(stage.startedAt).getTime();
+}
+function collectRunContext(ctx, state, pipelineStartTime) {
+  const durationMs = Date.now() - pipelineStartTime;
+  const lines = [];
+  lines.push(`## This Run`);
+  lines.push(`Task: ${state.taskId}`);
+  lines.push(`Outcome: ${state.state}`);
+  lines.push(`Duration: ${durationMs}ms (${Math.round(durationMs / 1e3)}s)`);
+  lines.push(`Mode: ${ctx.input.mode}`);
+  lines.push(``);
+  lines.push(`### Stage Results`);
+  let failedStage;
+  for (const def of STAGES) {
+    const s = state.stages[def.name];
+    const duration = computeStageDuration(s);
+    const durationStr = duration != null ? `, ${duration}ms` : "";
+    const errorStr = s.error ? ` \u2014 ${s.error}` : "";
+    lines.push(`${def.name}: ${s.state} (${s.retries} retries${durationStr})${errorStr}`);
+    if (s.state === "failed" || s.state === "timeout") {
+      failedStage = def.name;
+    }
+  }
+  lines.push(``);
+  const artifacts = [
+    ["task.md", 300],
+    ["task.json", 500],
+    ["plan.md", 500],
+    ["verify.md", 800],
+    ["review.md", 500],
+    ["ship.md", 300]
+  ];
+  lines.push(`### Artifacts`);
+  for (const [filename, maxChars] of artifacts) {
+    const content = readArtifact(ctx.taskDir, filename, maxChars);
+    if (content) {
+      lines.push(`#### ${filename}`);
+      lines.push(content);
+      lines.push(``);
+    }
+  }
+  return lines.join("\n");
+}
+function getLogPath(projectDir) {
+  return path13.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+}
+function readPreviousRetrospectives(projectDir, limit = 10) {
+  const logPath = getLogPath(projectDir);
+  if (!fs13.existsSync(logPath)) return [];
+  try {
+    const content = fs13.readFileSync(logPath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const entries = [];
+    const start = Math.max(0, lines.length - limit);
+    for (let i = start; i < lines.length; i++) {
+      try {
+        entries.push(JSON.parse(lines[i]));
+      } catch {
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function formatPreviousEntries(entries) {
+  if (entries.length === 0) return "No previous runs recorded.";
+  return entries.map((e) => {
+    const failed = e.failedStage ? ` at ${e.failedStage}` : "";
+    const pattern = e.patternMatch ? `Pattern: ${e.patternMatch}` : "Pattern: none";
+    const flaw = e.pipelineFlaw ? ` | Flaw: ${e.pipelineFlaw.component} \u2014 ${e.pipelineFlaw.issue}` : "";
+    return `[${e.timestamp.slice(0, 10)}] ${e.taskId}: ${e.outcome}${failed} \u2014 "${e.observation.slice(0, 120)}"
+  ${pattern} | Suggestion: "${e.suggestion}"${flaw}`;
+  }).join("\n");
+}
+function appendRetrospectiveEntry(projectDir, entry) {
+  const logPath = getLogPath(projectDir);
+  const dir = path13.dirname(logPath);
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
+  }
+  fs13.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+}
+async function runRetrospective(ctx, state, pipelineStartTime) {
+  if (ctx.input.dryRun) return;
+  try {
+    const durationMs = Date.now() - pipelineStartTime;
+    const runContext = collectRunContext(ctx, state, pipelineStartTime);
+    const previous = readPreviousRetrospectives(ctx.projectDir);
+    const previousText = formatPreviousEntries(previous);
+    const prompt = RETROSPECTIVE_PROMPT + `## Run Context
+${runContext}
+
+## Previous Retrospectives (last ${previous.length} runs)
+${previousText}
+`;
+    const runner = getRunnerForStage(ctx, "taskify");
+    const model = resolveModel("cheap");
+    const result = await runner.run("retrospective", prompt, model, 3e4, "");
+    let observation = "Retrospective analysis unavailable";
+    let patternMatch = null;
+    let suggestion = "No suggestion";
+    let pipelineFlaw = null;
+    if (result.outcome === "completed" && result.output) {
+      const cleaned = result.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+      try {
+        const parsed = JSON.parse(cleaned);
+        observation = parsed.observation ?? observation;
+        patternMatch = parsed.patternMatch ?? null;
+        suggestion = parsed.suggestion ?? suggestion;
+        if (parsed.pipelineFlaw && parsed.pipelineFlaw.component) {
+          pipelineFlaw = {
+            component: parsed.pipelineFlaw.component,
+            issue: parsed.pipelineFlaw.issue ?? "Unknown",
+            evidence: parsed.pipelineFlaw.evidence ?? ""
+          };
+        }
+      } catch {
+        logger.warn("  Retrospective: failed to parse LLM output");
+      }
+    }
+    const stageResults = {};
+    let failedStage;
+    for (const def of STAGES) {
+      const s = state.stages[def.name];
+      stageResults[def.name] = {
+        state: s.state,
+        retries: s.retries,
+        durationMs: computeStageDuration(s),
+        error: s.error
+      };
+      if (s.state === "failed" || s.state === "timeout") {
+        failedStage = def.name;
+      }
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: state.taskId,
+      outcome: state.state === "completed" ? "completed" : "failed",
+      durationMs,
+      stageResults,
+      failedStage,
+      observation,
+      patternMatch,
+      suggestion,
+      pipelineFlaw
+    };
+    appendRetrospectiveEntry(ctx.projectDir, entry);
+    logger.info(`Retrospective: ${observation.slice(0, 120)}`);
+  } catch (err) {
+    logger.warn(`Retrospective failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+var RETROSPECTIVE_PROMPT;
+var init_retrospective = __esm({
+  "src/retrospective.ts"() {
+    "use strict";
+    init_definitions();
+    init_context();
+    init_runner_selection();
+    init_logger();
+    RETROSPECTIVE_PROMPT = `You are a pipeline retrospective analyst. You observe automated software development pipeline runs and identify flaws, patterns, and improvement opportunities.
+
+Output ONLY valid JSON. No markdown fences. No explanation.
+
+{
+  "observation": "One paragraph: what happened in this run, what went well, what went wrong",
+  "patternMatch": "If this matches a pattern seen in previous runs, describe the pattern. Otherwise null",
+  "suggestion": "One specific, actionable change to improve pipeline reliability or efficiency",
+  "pipelineFlaw": {
+    "component": "pipeline component name (e.g., verify, build, autofix, taskify prompt, review prompt, model selection, timeout config)",
+    "issue": "concise description of the flaw",
+    "evidence": "specific data from this run that supports this conclusion"
+  }
+}
+
+If no pipeline flaw is detected, set "pipelineFlaw" to null.
+
+`;
+  }
+});
+
+// src/pipeline.ts
+import * as fs14 from "fs";
+import * as path14 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (!ctx.input.issueNumber || ctx.input.dryRun) return;
   try {
-    const taskMdPath = path13.join(ctx.taskDir, "task.md");
-    const title = fs13.existsSync(taskMdPath) ? fs13.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path14.join(ctx.taskDir, "task.md");
+    const title = fs14.existsSync(taskMdPath) ? fs14.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -1776,10 +2035,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path13.join(taskDir, ".lock");
-  if (fs13.existsSync(lockPath)) {
+  const lockPath = path14.join(taskDir, ".lock");
+  if (fs14.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs13.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs14.readFileSync(lockPath, "utf-8").trim(), 10);
       try {
         process.kill(pid, 0);
         throw new Error(`Pipeline already running (PID ${pid})`);
@@ -1790,11 +2049,11 @@ function acquireLock(taskDir) {
       if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
     }
   }
-  fs13.writeFileSync(lockPath, String(process.pid));
+  fs14.writeFileSync(lockPath, String(process.pid));
 }
 function releaseLock(taskDir) {
   try {
-    fs13.unlinkSync(path13.join(taskDir, ".lock"));
+    fs14.unlinkSync(path14.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -1807,6 +2066,7 @@ async function runPipeline(ctx) {
   }
 }
 async function runPipelineInner(ctx) {
+  const pipelineStartTime = Date.now();
   let state = loadState(ctx.taskId, ctx.taskDir);
   if (!state) {
     state = initState(ctx.taskId);
@@ -1888,6 +2148,8 @@ async function runPipelineInner(ctx) {
         complexity = detected.complexity;
         activeStages = detected.activeStages;
       }
+      const gated = checkRiskGate(ctx, def, state, complexity);
+      if (gated) return gated;
       commitAfterStage(ctx, def);
     } else {
       const isTimeout = result.outcome === "timed_out";
@@ -1916,6 +2178,8 @@ async function runPipelineInner(ctx) {
     }
     autoLearn(ctx);
   }
+  await runRetrospective(ctx, state, pipelineStartTime).catch(() => {
+  });
   return state;
 }
 function printStatus(taskId, taskDir) {
@@ -1949,12 +2213,13 @@ var init_pipeline = __esm({
     init_executor_registry();
     init_hooks();
     init_auto_learn();
+    init_retrospective();
   }
 });
 
 // src/preflight.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -2007,7 +2272,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs14.existsSync("package.json")) throw new Error("not found");
+      if (!fs15.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -2078,8 +2343,8 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 import { execFileSync as execFileSync9 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
@@ -2090,8 +2355,8 @@ async function checkLitellmHealth(url) {
   }
 }
 async function tryStartLitellm(url, projectDir) {
-  const configPath = path14.join(projectDir, "litellm-config.yaml");
-  if (!fs15.existsSync(configPath)) {
+  const configPath = path15.join(projectDir, "litellm-config.yaml");
+  if (!fs16.existsSync(configPath)) {
     logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
     return null;
   }
@@ -2118,10 +2383,10 @@ async function tryStartLitellm(url, projectDir) {
     cmd = "python3";
     args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-  const dotenvPath = path14.join(projectDir, ".env");
+  const dotenvPath = path15.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs15.existsSync(dotenvPath)) {
-    for (const line of fs15.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  if (fs16.existsSync(dotenvPath)) {
+    for (const line of fs16.readFileSync(dotenvPath, "utf-8").split("\n")) {
       const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
       if (match) dotenvVars[match[1]] = match[2];
     }
@@ -2161,13 +2426,13 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-resolution.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 import { execFileSync as execFileSync10 } from "child_process";
 function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path15.join(projectDir, ".tasks");
-  if (!fs16.existsSync(tasksDir)) return null;
-  const allDirs = fs16.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const tasksDir = path16.join(projectDir, ".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;
@@ -2202,13 +2467,13 @@ var init_task_resolution = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path16.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path17.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs17.existsSync(projectDir)) {
+    if (!fs18.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -2235,8 +2500,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path16.join(projectDir, ".tasks", taskId);
-  fs17.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path17.join(projectDir, ".tasks", taskId);
+  fs18.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -2244,22 +2509,22 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs17.writeFileSync(path16.join(taskDir, "task.md"), input.task);
+    fs18.writeFileSync(path17.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path16.join(taskDir, "task.md");
-  if (!fs17.existsSync(taskMdPath) && input.issueNumber) {
+  const taskMdPath = path17.join(taskDir, "task.md");
+  if (!fs18.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 ?? ""}`;
-      fs17.writeFileSync(taskMdPath, taskContent);
+      fs18.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
   if (input.command === "run") {
-    if (!fs17.existsSync(taskMdPath)) {
+    if (!fs18.existsSync(taskMdPath)) {
       console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
       process.exit(1);
     }
@@ -2268,10 +2533,10 @@ ${issue.body ?? ""}`;
     input.fromStage = "build";
   }
   if (input.command === "rerun" && !input.fromStage) {
-    const statusPath = path16.join(taskDir, "status.json");
-    if (fs17.existsSync(statusPath)) {
+    const statusPath = path17.join(taskDir, "status.json");
+    if (fs18.existsSync(statusPath)) {
       try {
-        const status = JSON.parse(fs17.readFileSync(statusPath, "utf-8"));
+        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) {
@@ -2378,7 +2643,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs17.readdirSync(taskDir);
+  const files = fs18.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -2437,15 +2702,15 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 import { fileURLToPath } from "url";
-var __dirname = path17.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path17.resolve(__dirname, "..", "..");
+var __dirname = path18.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path18.resolve(__dirname, "..", "..");
 function getVersion() {
-  const pkgPath = path17.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path18.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 function checkCommand2(name, args2, fix) {
@@ -2461,7 +2726,7 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs18.existsSync(filePath)) {
+  if (fs19.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
@@ -2533,10 +2798,10 @@ function checkGhSecret(repoSlug, secretName) {
 }
 function detectArchitecture(cwd) {
   const detected = [];
-  const pkgPath = path17.join(cwd, "package.json");
-  if (fs18.existsSync(pkgPath)) {
+  const pkgPath = path18.join(cwd, "package.json");
+  if (fs19.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs19.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}`);
@@ -2559,41 +2824,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 (fs18.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs18.existsSync(path17.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs18.existsSync(path17.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs18.existsSync(path17.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
+      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");
     } catch {
     }
   }
   try {
-    const entries = fs18.readdirSync(cwd, { withFileTypes: true });
+    const entries = fs19.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 = path17.join(cwd, "src");
-  if (fs18.existsSync(srcDir)) {
+  const srcDir = path18.join(cwd, "src");
+  if (fs19.existsSync(srcDir)) {
     try {
-      const srcEntries = fs18.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs19.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 (fs18.existsSync(path17.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
-  if (fs18.existsSync(path17.join(cwd, "docker-compose.yml")) || fs18.existsSync(path17.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
-  if (fs18.existsSync(path17.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
-  if (fs18.existsSync(path17.join(cwd, ".env")) || fs18.existsSync(path17.join(cwd, ".env.local"))) configs.push(".env");
+  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 (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs18.existsSync(path17.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs18.existsSync(path17.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs18.existsSync(path17.join(cwd, "pnpm-lock.yaml")) && fs18.existsSync(path17.join(cwd, "package-lock.json"))) pm = "npm";
+  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";
   let defaultBranch = "main";
   try {
     const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
@@ -2637,9 +2902,9 @@ function smartInit(cwd) {
   const basic = detectBasicConfig(cwd);
   let context = "";
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path17.join(cwd, rel);
-    if (fs18.existsSync(p)) {
-      const content = fs18.readFileSync(p, "utf-8");
+    const p = path18.join(cwd, rel);
+    if (fs19.existsSync(p)) {
+      const content = fs19.readFileSync(p, "utf-8");
       return content.slice(0, maxChars);
     }
     return null;
@@ -2665,14 +2930,14 @@ ${claudeMd}
 
 `;
   try {
-    const topDirs = fs18.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs19.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 = path17.join(cwd, "src");
-    if (fs18.existsSync(srcDir)) {
-      const srcDirs = fs18.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    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);
       context += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -2682,7 +2947,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 (fs18.existsSync(path17.join(cwd, f))) existingFiles.push(f);
+    if (fs19.existsSync(path18.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
@@ -2788,7 +3053,7 @@ ${context}`;
 function validateQualityCommands(cwd, config, pm) {
   let scripts = {};
   try {
-    const pkg = JSON.parse(fs18.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return;
@@ -2822,7 +3087,7 @@ function validateQualityCommands(cwd, config, pm) {
 function buildFallbackConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs18.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -2862,34 +3127,34 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path17.join(PKG_ROOT, "templates");
-  const workflowSrc = path17.join(templatesDir, "kody.yml");
-  const workflowDest = path17.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs18.existsSync(workflowSrc)) {
+  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)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs18.existsSync(workflowDest) && !opts.force) {
+  if (fs19.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs18.mkdirSync(path17.dirname(workflowDest), { recursive: true });
-    fs18.copyFileSync(workflowSrc, workflowDest);
+    fs19.mkdirSync(path18.dirname(workflowDest), { recursive: true });
+    fs19.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path17.join(cwd, "kody.config.json");
+  const configDest = path18.join(cwd, "kody.config.json");
   let smartResult = null;
-  if (!fs18.existsSync(configDest) || opts.force) {
+  if (!fs19.existsSync(configDest) || opts.force) {
     smartResult = smartInit(cwd);
-    fs18.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    fs19.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 = path17.join(cwd, ".gitignore");
-  if (fs18.existsSync(gitignorePath)) {
-    const content = fs18.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path18.join(cwd, ".gitignore");
+  if (fs19.existsSync(gitignorePath)) {
+    const content = fs19.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".tasks/")) {
-      fs18.appendFileSync(gitignorePath, "\n.tasks/\n");
+      fs19.appendFileSync(gitignorePath, "\n.tasks/\n");
       console.log("  \u2713 .gitignore (added .tasks/)");
     } else {
       console.log("  \u25CB .gitignore (.tasks/ already present)");
@@ -2902,7 +3167,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(path17.join(cwd, "package.json"), "package.json", "Run: pnpm init")
+    checkFile(path18.join(cwd, "package.json"), "package.json", "Run: pnpm init")
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -2979,9 +3244,9 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs18.existsSync(configDest)) {
+  if (fs19.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs18.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs19.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}` });
@@ -3008,21 +3273,21 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path17.join(cwd, ".kody", "memory");
-  fs18.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path17.join(memoryDir, "architecture.md");
-  const conventionsPath = path17.join(memoryDir, "conventions.md");
-  if (fs18.existsSync(archPath) && !opts.force) {
+  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) {
     console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
   } else if (smartResult?.architecture) {
-    fs18.writeFileSync(archPath, smartResult.architecture);
+    fs19.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);
-      fs18.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs19.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
@@ -3032,14 +3297,14 @@ ${archItems.join("\n")}
       console.log("  \u25CB No architecture detected");
     }
   }
-  if (fs18.existsSync(conventionsPath) && !opts.force) {
+  if (fs19.existsSync(conventionsPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
   } else if (smartResult?.conventions) {
-    fs18.writeFileSync(conventionsPath, smartResult.conventions);
+    fs19.writeFileSync(conventionsPath, smartResult.conventions);
     const lineCount = smartResult.conventions.split("\n").length;
     console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
   } else {
-    fs18.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs19.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
   const allChecks = [...checks, ghAuth, ghRepo];