@kody-ade/kody-engine 0.4.75 → 0.4.77

package/dist/bin/kody.js

@@ -460,16 +460,16 @@ var init_issue = __esm({
 });
 
 // src/prompt.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path12 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
     const abs = path12.join(projectDir, rel);
-    if (!fs13.existsSync(abs)) continue;
+    if (!fs14.existsSync(abs)) continue;
     let content;
     try {
-      content = fs13.readFileSync(abs, "utf-8");
+      content = fs14.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -617,20 +617,20 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path26 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs27.statSync(file);
+      stat = fs28.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs27.readFileSync(file, "utf-8");
+      raw = fs28.readFileSync(file, "utf-8");
     } catch {
       return;
     }
@@ -706,7 +706,7 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs27.readdirSync(dir);
+      names = fs28.readdirSync(dir);
     } catch {
       continue;
     }
@@ -715,7 +715,7 @@ function walkMd(root, visit) {
       const full = path26.join(dir, name);
       let stat;
       try {
-        stat = fs27.statSync(full);
+        stat = fs28.statSync(full);
       } catch {
         continue;
       }
@@ -739,7 +739,7 @@ var init_loadMemoryContext = __esm({
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
       const memoryAbs = path26.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs27.existsSync(memoryAbs)) {
+      if (!fs28.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -868,12 +868,12 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.75",
+  version: "0.4.77",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
   bin: {
-    kody: "dist/bin/kody.js"
+    "kody-engine": "dist/bin/kody.js"
   },
   files: [
     "dist",
@@ -881,7 +881,7 @@ var package_default = {
     "kody.config.schema.json"
   ],
   scripts: {
-    kody: "tsx bin/kody.ts",
+    "kody:run": "tsx bin/kody.ts",
     serve: "tsx bin/kody.ts serve",
     "serve:vscode": "tsx bin/kody.ts serve vscode",
     "serve:claude": "tsx bin/kody.ts serve claude",
@@ -923,7 +923,7 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 import * as path32 from "path";
 
 // src/chat/events.ts
@@ -989,6 +989,9 @@ function makeRunId(sessionId, suffix) {
   return `chat-${sessionId}-${suffix}`;
 }
 
+// src/chat/loop.ts
+import * as fs7 from "fs";
+
 // src/agent.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
@@ -1512,15 +1515,134 @@ async function runAgent(opts) {
   };
 }
 
-// src/chat/session.ts
+// src/registry.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
+function getExecutablesRoot() {
+  const here = path5.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path5.join(here, "executables"),
+    // dev: src/
+    path5.join(here, "..", "executables"),
+    // built: dist/bin → dist/executables
+    path5.join(here, "..", "src", "executables")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c) && fs5.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+function getProjectExecutablesRoot() {
+  return path5.join(process.cwd(), ".kody", "executables");
+}
+function getBuiltinJobsRoot() {
+  const here = path5.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path5.join(here, "jobs"),
+    // dev: src/
+    path5.join(here, "..", "jobs"),
+    // built: dist/bin → dist/jobs
+    path5.join(here, "..", "src", "jobs")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c) && fs5.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+function listBuiltinJobs(root = getBuiltinJobsRoot()) {
+  if (!fs5.existsSync(root) || !fs5.statSync(root).isDirectory()) return [];
+  const out = [];
+  for (const ent of fs5.readdirSync(root, { withFileTypes: true })) {
+    if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
+    const slug = ent.name.slice(0, -3);
+    out.push({ slug, filePath: path5.join(root, ent.name) });
+  }
+  out.sort((a, b) => a.slug.localeCompare(b.slug));
+  return out;
+}
+function getExecutableRoots() {
+  return [getProjectExecutablesRoot(), getExecutablesRoot()];
+}
+function listExecutables(roots = getExecutableRoots()) {
+  const rootList = typeof roots === "string" ? [roots] : roots;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const root of rootList) {
+    if (!fs5.existsSync(root)) continue;
+    const entries = fs5.readdirSync(root, { withFileTypes: true });
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      if (seen.has(ent.name)) continue;
+      const profilePath = path5.join(root, ent.name, "profile.json");
+      if (fs5.existsSync(profilePath) && fs5.statSync(profilePath).isFile()) {
+        out.push({ name: ent.name, profilePath });
+        seen.add(ent.name);
+      }
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveExecutable(name, roots = getExecutableRoots()) {
+  if (!isSafeName(name)) return null;
+  const rootList = typeof roots === "string" ? [roots] : roots;
+  for (const root of rootList) {
+    const profilePath = path5.join(root, name, "profile.json");
+    if (fs5.existsSync(profilePath) && fs5.statSync(profilePath).isFile()) {
+      return profilePath;
+    }
+  }
+  return null;
+}
+function hasExecutable(name, roots = getExecutableRoots()) {
+  return resolveExecutable(name, roots) !== null;
+}
+function isSafeName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
+}
+function getProfileInputs(name, roots = getExecutableRoots()) {
+  const profilePath = resolveExecutable(name, roots);
+  if (!profilePath) return null;
+  try {
+    const raw = JSON.parse(fs5.readFileSync(profilePath, "utf-8"));
+    if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
+    return raw.inputs;
+  } catch {
+    return null;
+  }
+}
+function parseGenericFlags(argv) {
+  const args = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    const value = next !== void 0 && !next.startsWith("--") ? (i++, next) : true;
+    args[key] = value;
+    if (key.includes("-")) {
+      const camel = key.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+      if (camel !== key && args[camel] === void 0) args[camel] = value;
+    }
+  }
+  if (positional.length > 0) args._ = positional;
+  return args;
+}
+
+// src/chat/session.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path5.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path6.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs5.existsSync(file)) return null;
-  const raw = fs5.readFileSync(file, "utf-8");
+  if (!fs6.existsSync(file)) return null;
+  const raw = fs6.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -1533,8 +1655,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs5.existsSync(file)) return [];
-  const raw = fs5.readFileSync(file, "utf-8").trim();
+  if (!fs6.existsSync(file)) return [];
+  const raw = fs6.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -1550,14 +1672,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs5.mkdirSync(path5.dirname(file), { recursive: true });
+  fs6.mkdirSync(path6.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs5.appendFileSync(file, `${line}
+  fs6.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -1635,6 +1757,38 @@ var CHAT_SYSTEM_PROMPT = [
   "Do not invent file paths, commit SHAs, line numbers, or command output. If you",
   "cite something concrete, you must have just read or run it in this session."
 ].join("\n");
+function buildExecutableCatalog() {
+  let discovered;
+  try {
+    discovered = listExecutables();
+  } catch {
+    return "";
+  }
+  const entries = [];
+  for (const { name, profilePath } of discovered) {
+    try {
+      const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+      const describe = typeof raw.describe === "string" ? raw.describe : "";
+      const firstSentence = describe.split(/(?<=[.!?])\s+/, 1)[0] ?? "";
+      entries.push({ name, describe: firstSentence.trim() });
+    } catch {
+    }
+  }
+  if (entries.length === 0) return "";
+  const lines = [
+    "",
+    "# Available executables",
+    "These run inside the engine, NOT inside this chat. You cannot invoke them",
+    "directly \u2014 to run one, tell the user to post `@kody <name>` (with any flags)",
+    "as a comment on the relevant issue or PR. The dispatcher binds the issue/PR",
+    "number to the executable's inputs automatically.",
+    ""
+  ];
+  for (const e of entries) {
+    lines.push(`- \`${e.name}\` \u2014 ${e.describe || "(no description)"}`);
+  }
+  return lines.join("\n");
+}
 async function runChatTurn(opts) {
   const turns = readSession(opts.sessionFile);
   if (turns.length === 0) {
@@ -1648,7 +1802,11 @@ async function runChatTurn(opts) {
     await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
     return { exitCode: 64, error };
   }
-  const systemPrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
+  const basePrompt = opts.systemPrompt ?? CHAT_SYSTEM_PROMPT;
+  const catalog = buildExecutableCatalog();
+  const systemPrompt = catalog ? `${basePrompt}
+
+${catalog}` : basePrompt;
   const prompt = buildPrompt(turns);
   let progressSeq = 0;
   const invoke = opts.invokeAgent ?? ((p) => runAgent({
@@ -1728,9 +1886,9 @@ async function emit(sink, type, sessionId, suffix, payload) {
 
 // src/chat/modes/interactive.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs6 from "fs";
+import * as fs8 from "fs";
 import * as os from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync } from "child_process";
@@ -1887,9 +2045,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, verbose) {
-  const sessionRel = path6.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path6.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionRel, eventsRel].filter((p) => fs6.existsSync(path6.join(cwd, p)));
+  const sessionRel = path7.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path7.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionRel, eventsRel].filter((p) => fs8.existsSync(path7.join(cwd, p)));
   if (paths.length === 0) return;
   const startBranch = currentBranch2(cwd);
   const eventsBranch = defaultBranch(cwd) ?? "main";
@@ -1899,17 +2057,17 @@ function commitTurn(cwd, sessionId, verbose) {
   }
   const stdio = verbose ? "inherit" : "pipe";
   const exec = (args) => execFileSync2("git", args, { cwd, stdio });
-  const worktreeDir = fs6.mkdtempSync(path6.join(os.tmpdir(), "kody-events-"));
+  const worktreeDir = fs8.mkdtempSync(path7.join(os.tmpdir(), "kody-events-"));
   let worktreeAdded = false;
   try {
     exec(["fetch", "--quiet", "origin", eventsBranch]);
     exec(["worktree", "add", "--detach", "--quiet", worktreeDir, `origin/${eventsBranch}`]);
     worktreeAdded = true;
     for (const rel of paths) {
-      const src = path6.join(cwd, rel);
-      const dst = path6.join(worktreeDir, rel);
-      fs6.mkdirSync(path6.dirname(dst), { recursive: true });
-      fs6.copyFileSync(src, dst);
+      const src = path7.join(cwd, rel);
+      const dst = path7.join(worktreeDir, rel);
+      fs8.mkdirSync(path7.dirname(dst), { recursive: true });
+      fs8.copyFileSync(src, dst);
     }
     commitPathsAndPush(worktreeDir, paths, sessionId, verbose, `HEAD:${eventsBranch}`);
   } catch (err) {
@@ -1924,7 +2082,7 @@ function commitTurn(cwd, sessionId, verbose) {
       }
     }
     try {
-      fs6.rmSync(worktreeDir, { recursive: true, force: true });
+      fs8.rmSync(worktreeDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -2020,11 +2178,11 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as path31 from "path";
 
 // src/dispatch.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -2088,125 +2246,6 @@ function cronMatchesInWindow(spec, end, windowSec) {
   return false;
 }
 
-// src/registry.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
-function getExecutablesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path7.join(here, "executables"),
-    // dev: src/
-    path7.join(here, "..", "executables"),
-    // built: dist/bin → dist/executables
-    path7.join(here, "..", "src", "executables")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
-  }
-  return candidates[0];
-}
-function getProjectExecutablesRoot() {
-  return path7.join(process.cwd(), ".kody", "executables");
-}
-function getBuiltinJobsRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path7.join(here, "jobs"),
-    // dev: src/
-    path7.join(here, "..", "jobs"),
-    // built: dist/bin → dist/jobs
-    path7.join(here, "..", "src", "jobs")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
-  }
-  return candidates[0];
-}
-function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
-  const out = [];
-  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
-    if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
-    const slug = ent.name.slice(0, -3);
-    out.push({ slug, filePath: path7.join(root, ent.name) });
-  }
-  out.sort((a, b) => a.slug.localeCompare(b.slug));
-  return out;
-}
-function getExecutableRoots() {
-  return [getProjectExecutablesRoot(), getExecutablesRoot()];
-}
-function listExecutables(roots = getExecutableRoots()) {
-  const rootList = typeof roots === "string" ? [roots] : roots;
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const root of rootList) {
-    if (!fs7.existsSync(root)) continue;
-    const entries = fs7.readdirSync(root, { withFileTypes: true });
-    for (const ent of entries) {
-      if (!ent.isDirectory()) continue;
-      if (seen.has(ent.name)) continue;
-      const profilePath = path7.join(root, ent.name, "profile.json");
-      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
-        out.push({ name: ent.name, profilePath });
-        seen.add(ent.name);
-      }
-    }
-  }
-  return out.sort((a, b) => a.name.localeCompare(b.name));
-}
-function resolveExecutable(name, roots = getExecutableRoots()) {
-  if (!isSafeName(name)) return null;
-  const rootList = typeof roots === "string" ? [roots] : roots;
-  for (const root of rootList) {
-    const profilePath = path7.join(root, name, "profile.json");
-    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
-      return profilePath;
-    }
-  }
-  return null;
-}
-function hasExecutable(name, roots = getExecutableRoots()) {
-  return resolveExecutable(name, roots) !== null;
-}
-function isSafeName(name) {
-  return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
-}
-function getProfileInputs(name, roots = getExecutableRoots()) {
-  const profilePath = resolveExecutable(name, roots);
-  if (!profilePath) return null;
-  try {
-    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
-    if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
-    return raw.inputs;
-  } catch {
-    return null;
-  }
-}
-function parseGenericFlags(argv) {
-  const args = {};
-  const positional = [];
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith("--")) {
-      positional.push(arg);
-      continue;
-    }
-    const key = arg.slice(2);
-    const next = argv[i + 1];
-    const value = next !== void 0 && !next.startsWith("--") ? (i++, next) : true;
-    args[key] = value;
-    if (key.includes("-")) {
-      const camel = key.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
-      if (camel !== key && args[camel] === void 0) args[camel] = value;
-    }
-  }
-  if (positional.length > 0) args._ = positional;
-  return args;
-}
-
 // src/dispatch.ts
 var POLITE_WORDS = /* @__PURE__ */ new Set([
   "please",
@@ -2227,10 +2266,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs8.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs9.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs8.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs9.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2303,7 +2342,7 @@ function autoDispatchTyped(opts) {
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs8.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs9.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -2311,7 +2350,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs8.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs9.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -2345,7 +2384,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs8.readFileSync(exe.profilePath, "utf-8");
+      raw = fs9.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -2462,7 +2501,7 @@ init_issue();
 
 // src/executor.ts
 import { execFileSync as execFileSync29, spawn as spawn6 } from "child_process";
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as path30 from "path";
 init_events();
 
@@ -2470,7 +2509,7 @@ init_events();
 init_issue();
 
 // src/profile.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path8 from "path";
 
 // src/profile-error.ts
@@ -2637,12 +2676,12 @@ var KNOWN_PROFILE_KEYS = /* @__PURE__ */ new Set([
   "preloadContext"
 ]);
 function loadProfile(profilePath) {
-  if (!fs9.existsSync(profilePath)) {
+  if (!fs10.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs10.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -3084,7 +3123,7 @@ function errMsg(err) {
 
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as os2 from "os";
 import * as path9 from "path";
 async function checkLitellmHealth(url) {
@@ -3134,19 +3173,19 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
     }
   }
   const configPath = path9.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
-  fs10.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  fs11.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
   const logPath = path9.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
-  const outFd = fs10.openSync(logPath, "w");
+  const outFd = fs11.openSync(logPath, "w");
   const child = spawn2(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs10.closeSync(outFd);
+  fs11.closeSync(outFd);
   const timeoutMs = resolveLitellmTimeoutMs();
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -3165,7 +3204,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs10.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs11.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -3178,9 +3217,9 @@ ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
   const dotenvPath = path9.join(projectDir, ".env");
-  if (!fs10.existsSync(dotenvPath)) return {};
+  if (!fs11.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs10.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs11.readFileSync(dotenvPath, "utf-8").split("\n")) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
     const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -3204,7 +3243,7 @@ function stripBlockingEnv(env) {
 
 // src/commit.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path10 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
@@ -3262,17 +3301,17 @@ function tryGit(args, cwd) {
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
   const gitDir = path10.join(cwd ?? process.cwd(), ".git");
-  if (!fs11.existsSync(gitDir)) return aborted;
-  if (fs11.existsSync(path10.join(gitDir, "MERGE_HEAD"))) {
+  if (!fs12.existsSync(gitDir)) return aborted;
+  if (fs12.existsSync(path10.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs11.existsSync(path10.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs12.existsSync(path10.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs11.existsSync(path10.join(gitDir, "REVERT_HEAD"))) {
+  if (fs12.existsSync(path10.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs11.existsSync(path10.join(gitDir, "rebase-merge")) || fs11.existsSync(path10.join(gitDir, "rebase-apply"))) {
+  if (fs12.existsSync(path10.join(gitDir, "rebase-merge")) || fs12.existsSync(path10.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -3328,7 +3367,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs11.existsSync(path10.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs12.existsSync(path10.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -3640,7 +3679,7 @@ var advanceFlow = async (ctx, profile) => {
 };
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os3 from "os";
 import * as path11 from "path";
 function getPluginsCatalogRoot() {
@@ -3654,7 +3693,7 @@ function getPluginsCatalogRoot() {
     // fallback
   ];
   for (const c of candidates) {
-    if (fs12.existsSync(c) && fs12.statSync(c).isDirectory()) return c;
+    if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -3665,51 +3704,51 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const root = path11.join(os3.tmpdir(), `kody-synth-${runId}`);
-  fs12.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
+  fs13.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
     const local = path11.join(profile.dir, bucket, entry);
-    if (fs12.existsSync(local)) return local;
+    if (fs13.existsSync(local)) return local;
     const central = path11.join(catalog, bucket, entry);
-    if (fs12.existsSync(central)) return central;
+    if (fs13.existsSync(central)) return central;
     throw new Error(
       `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
     );
   };
   if (cc.skills.length > 0) {
     const dst = path11.join(root, "skills");
-    fs12.mkdirSync(dst, { recursive: true });
+    fs13.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
       copyDir(resolvePart("skills", name), path11.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
     const dst = path11.join(root, "commands");
-    fs12.mkdirSync(dst, { recursive: true });
+    fs13.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      fs12.copyFileSync(resolvePart("commands", `${name}.md`), path11.join(dst, `${name}.md`));
+      fs13.copyFileSync(resolvePart("commands", `${name}.md`), path11.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
     const dst = path11.join(root, "agents");
-    fs12.mkdirSync(dst, { recursive: true });
+    fs13.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      fs12.copyFileSync(resolvePart("agents", `${name}.md`), path11.join(dst, `${name}.md`));
+      fs13.copyFileSync(resolvePart("agents", `${name}.md`), path11.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
     const dst = path11.join(root, "hooks");
-    fs12.mkdirSync(dst, { recursive: true });
+    fs13.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
       const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs12.readFileSync(src, "utf-8"));
+      const parsed = JSON.parse(fs13.readFileSync(src, "utf-8"));
       for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
         if (!Array.isArray(entries)) continue;
         if (!merged.hooks[event]) merged.hooks[event] = [];
         merged.hooks[event].push(...entries);
       }
     }
-    fs12.writeFileSync(path11.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs13.writeFileSync(path11.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -3720,17 +3759,17 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
   if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs12.writeFileSync(path11.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs13.writeFileSync(path11.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs12.mkdirSync(dst, { recursive: true });
-  for (const ent of fs12.readdirSync(src, { withFileTypes: true })) {
+  fs13.mkdirSync(dst, { recursive: true });
+  for (const ent of fs13.readdirSync(src, { withFileTypes: true })) {
     const s = path11.join(src, ent.name);
     const d = path11.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs12.copyFileSync(s, d);
+    else if (ent.isFile()) fs13.copyFileSync(s, d);
   }
 }
 
@@ -3871,7 +3910,7 @@ function defaultLabelMap() {
 }
 
 // src/scripts/commitAndPush.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path13 from "path";
 init_events();
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
@@ -3887,9 +3926,9 @@ var commitAndPush2 = async (ctx, profile) => {
   }
   const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
   const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-  if (sentinel && fs14.existsSync(sentinel)) {
+  if (sentinel && fs15.existsSync(sentinel)) {
     try {
-      const replay = JSON.parse(fs14.readFileSync(sentinel, "utf-8"));
+      const replay = JSON.parse(fs15.readFileSync(sentinel, "utf-8"));
       ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
       if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
       if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
@@ -3942,8 +3981,8 @@ var commitAndPush2 = async (ctx, profile) => {
   const result = ctx.data.commitResult;
   if (sentinel && result?.committed) {
     try {
-      fs14.mkdirSync(path13.dirname(sentinel), { recursive: true });
-      fs14.writeFileSync(
+      fs15.mkdirSync(path13.dirname(sentinel), { recursive: true });
+      fs15.writeFileSync(
         sentinel,
         JSON.stringify(
           {
@@ -4012,7 +4051,7 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path15 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
@@ -4025,7 +4064,7 @@ var composePrompt = async (ctx, profile) => {
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs15.existsSync(c)) {
+    if (fs16.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -4033,7 +4072,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs15.readFileSync(templatePath, "utf-8");
+  const template = fs16.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -4112,7 +4151,7 @@ function formatToolsUsage(profile) {
 // src/scripts/createQaGoal.ts
 init_issue();
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path16 from "path";
 
 // src/scripts/postReviewResult.ts
@@ -4367,7 +4406,7 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
   const dir = path16.join(cwd, ".kody", "goals", goalId);
-  fs16.mkdirSync(dir, { recursive: true });
+  fs17.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -4376,7 +4415,7 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
   const filePath = path16.join(dir, "state.json");
-  fs16.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  fs17.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
@@ -4872,7 +4911,7 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as os4 from "os";
 import * as path17 from "path";
 var diagMcp = async (_ctx) => {
@@ -4880,7 +4919,7 @@ var diagMcp = async (_ctx) => {
   const cacheDir = path17.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs17.readdirSync(cacheDir);
+    entries = fs18.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -4906,17 +4945,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as path19 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as path18 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs18.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -4953,7 +4992,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs18.existsSync(path18.join(cwd, c))) return c;
+    if (fs19.existsSync(path18.join(cwd, c))) return c;
   }
   return null;
 }
@@ -4967,17 +5006,17 @@ function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
     const full = path18.join(cwd, dir);
-    if (!fs18.existsSync(full)) continue;
+    if (!fs19.existsSync(full)) continue;
     let files;
     try {
-      files = fs18.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs19.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
         const filePath = path18.join(full, file);
-        const content = fs18.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const content = fs19.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -5006,10 +5045,10 @@ function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
     const full = path18.join(cwd, dir);
-    if (!fs18.existsSync(full)) continue;
+    if (!fs19.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs18.readdirSync(full, { withFileTypes: true });
+      entries = fs19.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -5019,7 +5058,7 @@ function discoverAdminComponents(cwd, collections) {
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs18.existsSync(path18.join(entryPath, f))
+          (f) => fs19.existsSync(path18.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
@@ -5034,7 +5073,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs18.readFileSync(path18.join(cwd, col.filePath), "utf-8");
+            const colContent = fs19.readFileSync(path18.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -5054,7 +5093,7 @@ function scanApiRoutes(cwd) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
     const apiDir = path18.join(cwd, appDir, "api");
-    if (!fs18.existsSync(apiDir)) continue;
+    if (!fs19.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -5063,14 +5102,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs19.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs18.readFileSync(path18.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs19.readFileSync(path18.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
       const methods = HTTP_METHODS.filter(
         (m) => new RegExp(`export\\s+(?:async\\s+)?function\\s+${m}\\b`).test(content)
       );
@@ -5118,9 +5157,9 @@ function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
     const envPath = path18.join(cwd, envFile);
-    if (!fs18.existsSync(envPath)) continue;
+    if (!fs19.existsSync(envPath)) continue;
     try {
-      const content = fs18.readFileSync(envPath, "utf-8");
+      const content = fs19.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -5168,9 +5207,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs19.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs19.existsSync(path19.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs19.existsSync(path19.join(cwd, "yarn.lock")) ? "yarn" : fs19.existsSync(path19.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs20.existsSync(path19.join(cwd, "yarn.lock")) ? "yarn" : fs20.existsSync(path19.join(cwd, "bun.lockb")) ? "bun" : "npm";
     if (pkg.scripts?.dev) out.devCommand = `${pm} dev`;
     if (allDeps.next || allDeps.nuxt) out.devPort = 3e3;
     else if (allDeps.vite) out.devPort = 5173;
@@ -5181,7 +5220,7 @@ function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
     const full = path19.join(cwd, appDir);
-    if (!fs19.existsSync(full)) continue;
+    if (!fs20.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -5189,7 +5228,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs19.readdirSync(dir, { withFileTypes: true });
+    entries = fs20.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -5231,23 +5270,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs19.existsSync(path19.join(cwd, c))) out.authFiles.push(c);
+    if (fs20.existsSync(path19.join(cwd, c))) out.authFiles.push(c);
   }
 }
 function detectRoles(cwd, out) {
   const rolePaths = ["src/types", "src/lib", "src/utils", "src/constants", "src/access", "src/collections"];
   for (const rp of rolePaths) {
     const dir = path19.join(cwd, rp);
-    if (!fs19.existsSync(dir)) continue;
+    if (!fs20.existsSync(dir)) continue;
     let files;
     try {
-      files = fs19.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs20.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs19.readFileSync(path19.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs20.readFileSync(path19.join(dir, f), "utf-8").slice(0, 5e3);
         const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
         if (roleMatches) {
           for (const m of roleMatches) {
@@ -5480,7 +5519,7 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path21 from "path";
 
 // src/scripts/jobFrontmatter.ts
@@ -5736,7 +5775,7 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path20 from "path";
 var LocalFileBackend = class {
   name = "local-file";
@@ -5767,7 +5806,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs20.mkdirSync(this.absDir, { recursive: true });
+    fs21.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -5796,7 +5835,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs20.existsSync(this.absDir)) {
+    if (!fs21.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -5813,10 +5852,10 @@ var LocalFileBackend = class {
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
     const absPath = path20.join(this.cwd, relPath);
-    if (!fs20.existsSync(absPath)) {
+    if (!fs21.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs20.readFileSync(absPath, "utf-8");
+    const raw = fs21.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -5834,9 +5873,9 @@ var LocalFileBackend = class {
       return false;
     }
     const absPath = path20.join(this.cwd, loaded.path);
-    fs20.mkdirSync(path20.dirname(absPath), { recursive: true });
+    fs21.mkdirSync(path20.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs20.writeFileSync(absPath, body, "utf-8");
+    fs21.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -6012,17 +6051,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs21.readFileSync(path21.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs22.readFileSync(path21.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs21.existsSync(absDir)) return [];
+  if (!fs22.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs21.readdirSync(absDir, { withFileTypes: true });
+    entries = fs22.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6705,7 +6744,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 
 // src/gha.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -6716,10 +6755,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs22.existsSync(eventPath)) return;
+  if (!eventPath || !fs23.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs22.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs23.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -7008,22 +7047,22 @@ var handleAbandonedGoal = async (ctx) => {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as path23 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path22 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
   const full = path22.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs23.existsSync(full)) {
+  if (!fs24.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs23.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs24.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -7033,9 +7072,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs24.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs24.existsSync(path23.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs24.existsSync(path23.join(cwd, "bun.lockb"))) return "bun";
+  if (fs25.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs25.existsSync(path23.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs25.existsSync(path23.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -7129,7 +7168,7 @@ jobs:
 
       - env:
           ALL_SECRETS: \${{ toJSON(secrets) }}
-        run: npx -y -p @kody-ade/kody-engine@latest kody ci --issue \${{ github.event.inputs.issue_number || github.event.issue.number }}
+        run: npx -y -p @kody-ade/kody-engine@latest kody-engine ci --issue \${{ github.event.inputs.issue_number || github.event.issue.number }}
 `;
 function defaultBranchFromGit(cwd) {
   try {
@@ -7158,47 +7197,47 @@ function performInit(cwd, force) {
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
   const configPath = path23.join(cwd, "kody.config.json");
-  if (fs24.existsSync(configPath) && !force) {
+  if (fs25.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
-    fs24.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs25.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
   const workflowDir = path23.join(cwd, ".github", "workflows");
   const workflowPath = path23.join(workflowDir, "kody.yml");
-  if (fs24.existsSync(workflowPath) && !force) {
+  if (fs25.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs24.mkdirSync(workflowDir, { recursive: true });
-    fs24.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs25.mkdirSync(workflowDir, { recursive: true });
+    fs25.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs24.existsSync(path23.join(cwd, "src/app")) || fs24.existsSync(path23.join(cwd, "app")) || fs24.existsSync(path23.join(cwd, "pages"));
+  const hasUi = fs25.existsSync(path23.join(cwd, "src/app")) || fs25.existsSync(path23.join(cwd, "app")) || fs25.existsSync(path23.join(cwd, "pages"));
   if (hasUi) {
     const qaGuidePath = path23.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs24.existsSync(qaGuidePath) && !force) {
+    if (fs25.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs24.mkdirSync(path23.dirname(qaGuidePath), { recursive: true });
+      fs25.mkdirSync(path23.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs24.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs25.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
     const jobsDir = path23.join(cwd, ".kody", "jobs");
-    fs24.mkdirSync(jobsDir, { recursive: true });
+    fs25.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
       const rel = path23.join(".kody", "jobs", `${job.slug}.md`);
       const target = path23.join(cwd, rel);
-      if (fs24.existsSync(target) && !force) {
+      if (fs25.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs24.writeFileSync(target, fs24.readFileSync(job.filePath, "utf-8"));
+      fs25.writeFileSync(target, fs25.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -7211,11 +7250,11 @@ function performInit(cwd, force) {
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
     const target = path23.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs24.existsSync(target) && !force) {
+    if (fs25.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs24.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs25.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -7255,7 +7294,7 @@ jobs:
           node-version: 22
       - env:
           GH_TOKEN: \${{ secrets.KODY_TOKEN || github.token }}
-        run: npx -y -p @kody-ade/kody-engine@latest kody ${name}
+        run: npx -y -p @kody-ade/kody-engine@latest kody-engine ${name}
 `;
 }
 var initFlow = async (ctx) => {
@@ -7293,7 +7332,7 @@ init_loadConventions();
 init_loadCoverageRules();
 
 // src/goal/state.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as path24 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
 var GoalStateError = class extends Error {
@@ -7348,12 +7387,12 @@ function goalStatePath(cwd, goalId) {
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs25.existsSync(file)) {
+  if (!fs26.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs25.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs26.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -7361,8 +7400,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs25.mkdirSync(path24.dirname(file), { recursive: true });
-  fs25.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs26.mkdirSync(path24.dirname(file), { recursive: true });
+  fs26.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -7464,7 +7503,7 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as path25 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -7474,10 +7513,10 @@ var loadJobFromFile = async (ctx, _profile, args) => {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
   const absPath = path25.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs26.existsSync(absPath)) {
+  if (!fs27.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs26.readFileSync(absPath, "utf-8");
+  const raw = fs27.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
   const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   const loaded = await backend.load(slug);
@@ -7516,7 +7555,7 @@ init_loadPriorArt();
 init_events();
 
 // src/taskContext.ts
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path27 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
@@ -7534,9 +7573,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = path27.join(cwd, ".kody", "runs", ctx.runId);
-    fs28.mkdirSync(dir, { recursive: true });
+    fs29.mkdirSync(dir, { recursive: true });
     const file = path27.join(dir, "task-context.json");
-    fs28.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs29.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -8893,7 +8932,7 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path28 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
@@ -8907,12 +8946,12 @@ var runTickScript = async (ctx, _profile, args) => {
     return;
   }
   const jobPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs29.existsSync(jobPath)) {
+  if (!fs30.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs29.readFileSync(jobPath, "utf-8");
+  const raw = fs30.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -8921,7 +8960,7 @@ var runTickScript = async (ctx, _profile, args) => {
     return;
   }
   const scriptPath = path28.isAbsolute(tickScript) ? tickScript : path28.join(ctx.cwd, tickScript);
-  if (!fs29.existsSync(scriptPath)) {
+  if (!fs30.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -9024,7 +9063,7 @@ function buildChildEnv(parent, force) {
 
 // src/scripts/brainServe.ts
 import { createServer } from "http";
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as path29 from "path";
 var DEFAULT_PORT = 8080;
 function getApiKey() {
@@ -9136,7 +9175,7 @@ async function handleChatTurn(req, res, chatId, opts) {
     return;
   }
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs30.mkdirSync(path29.dirname(sessionFile), { recursive: true });
+  fs31.mkdirSync(path29.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -10095,7 +10134,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -10117,7 +10156,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs31.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs32.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -10537,7 +10576,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs32.existsSync(profilePath)) return null;
+    if (!fs33.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -10556,7 +10595,7 @@ function resolveProfilePath(profileName) {
     // fallback
   ];
   for (const c of candidates) {
-    if (fs32.existsSync(c)) return c;
+    if (fs33.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -10657,7 +10696,7 @@ var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
   const shellPath = path30.join(profile.dir, shellName);
-  if (!fs32.existsSync(shellPath)) {
+  if (!fs33.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -11136,9 +11175,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs33.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs33.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs33.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
+  if (fs34.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs34.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs34.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -11228,8 +11267,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = path31.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs33.existsSync(logPath)) {
-      const content = fs33.readFileSync(logPath, "utf-8");
+    if (fs34.existsSync(logPath)) {
+      const content = fs34.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -11264,9 +11303,9 @@ async function runCi(argv) {
   const eventName = process.env.GITHUB_EVENT_NAME;
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs33.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs34.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs33.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs34.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       manualWorkflowDispatch = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
@@ -11527,7 +11566,7 @@ function parseChatArgs(argv, env = process.env) {
 function commitChatFiles(cwd, sessionId, verbose) {
   const sessionFile = path32.relative(cwd, sessionFilePath(cwd, sessionId));
   const eventsFile = path32.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs34.existsSync(path32.join(cwd, p)));
+  const paths = [sessionFile, eventsFile].filter((p) => fs35.existsSync(path32.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -11617,7 +11656,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs34.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs35.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -11856,20 +11895,20 @@ function formatMs(ms) {
 }
 
 // src/entry.ts
-var HELP_TEXT = `kody \u2014 single-session autonomous engineer
+var HELP_TEXT = `kody-engine \u2014 single-session autonomous engineer
 
 Usage:
-  kody run     --issue <N> [--cwd <path>] [--verbose|--quiet]
-  kody fix     --pr    <N> [--feedback "..."] [--cwd <path>] [--verbose|--quiet]
-  kody fix-ci  --pr    <N> [--run-id <ID>]    [--cwd <path>] [--verbose|--quiet]
-  kody resolve --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
-  kody review  --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
-  kody <other>                                [--cwd <path>] [--verbose|--quiet]
-  kody ci      --issue <N> [preflight flags \u2014 see: kody ci --help]
-  kody chat    [chat flags \u2014 see: kody chat --help]
-  kody stats   [--since 7d|--run <id>|--json|--cwd <path>]
-  kody help
-  kody version
+  kody-engine run     --issue <N> [--cwd <path>] [--verbose|--quiet]
+  kody-engine fix     --pr    <N> [--feedback "..."] [--cwd <path>] [--verbose|--quiet]
+  kody-engine fix-ci  --pr    <N> [--run-id <ID>]    [--cwd <path>] [--verbose|--quiet]
+  kody-engine resolve --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
+  kody-engine review  --pr    <N>                    [--cwd <path>] [--verbose|--quiet]
+  kody-engine <other>                                [--cwd <path>] [--verbose|--quiet]
+  kody-engine ci      --issue <N> [preflight flags \u2014 see: kody-engine ci --help]
+  kody-engine chat    [chat flags \u2014 see: kody-engine chat --help]
+  kody-engine stats   [--since 7d|--run <id>|--json|--cwd <path>]
+  kody-engine help
+  kody-engine version
 
 Each top-level command (run, fix, fix-ci, resolve, review, \u2026) is a discovered
 executable under \`src/executables/<name>/profile.json\`. Drop in a new