@kody-ade/kody-engine 0.4.401 → 0.4.402

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.401",
+      version: "0.4.402",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -1088,7 +1088,7 @@ function cmsHeaders(opts) {
     }
   };
 }
-async function callDashboardCms(opts, path50, init = {}) {
+async function callDashboardCms(opts, path51, init = {}) {
   const baseUrl = dashboardBaseUrl(opts);
   if (!baseUrl) {
     return {
@@ -1100,7 +1100,7 @@ async function callDashboardCms(opts, path50, init = {}) {
   const headerResult = cmsHeaders(opts);
   if (!headerResult.ok) return headerResult;
   try {
-    const res = await fetch(`${baseUrl}${path50}`, {
+    const res = await fetch(`${baseUrl}${path51}`, {
       ...init,
       headers: {
         ...headerResult.headers,
@@ -1172,8 +1172,8 @@ function documentArg(value) {
 function normalizeCmsDocumentIdInput(input) {
   const trimmed = stripWrappingQuotes(input.trim());
   const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? trimmed;
-  const path50 = parseDocumentPath(withoutQuery);
-  return path50 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
+  const path51 = parseDocumentPath(withoutQuery);
+  return path51 ?? parseDocumentIdSegment(withoutQuery) ?? withoutQuery;
 }
 function stripWrappingQuotes(value) {
   let current = value;
@@ -1184,9 +1184,9 @@ function stripWrappingQuotes(value) {
   }
 }
 function parseDocumentPath(value) {
-  const path50 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
-  if (!path50?.includes("/content/entries/")) return null;
-  const parts = path50.split("/").filter(Boolean).map(decodePathPart);
+  const path51 = value.startsWith("http://") || value.startsWith("https://") ? urlPathname(value) : value;
+  if (!path51?.includes("/content/entries/")) return null;
+  const parts = path51.split("/").filter(Boolean).map(decodePathPart);
   const entriesIndex = parts.findIndex((part, index) => part === "content" && parts[index + 1] === "entries");
   const idPart = parts[entriesIndex + 3];
   if (!idPart || idPart === "new") return null;
@@ -3770,7 +3770,7 @@ var init_task_artifacts = __esm({
 
 // src/gha.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -3781,10 +3781,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs16.existsSync(eventPath)) return;
+  if (!eventPath || !fs17.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs16.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs17.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -4313,31 +4313,31 @@ var init_lifecycles = __esm({
 });
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as os3 from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 function getPluginsCatalogRoot() {
-  const here = path16.dirname(new URL(import.meta.url).pathname);
+  const here = path17.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path16.join(here, "..", "plugins"),
+    path17.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path16.join(here, "..", "..", "plugins"),
+    path17.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path16.join(here, "..", "..", "src", "plugins")
+    path17.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs17.existsSync(c) && fs17.statSync(c).isDirectory()) return c;
+    if (fs18.existsSync(c) && fs18.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function copyDir(src, dst) {
-  fs17.mkdirSync(dst, { recursive: true });
-  for (const ent of fs17.readdirSync(src, { withFileTypes: true })) {
-    const s = path16.join(src, ent.name);
-    const d = path16.join(dst, ent.name);
+  fs18.mkdirSync(dst, { recursive: true });
+  for (const ent of fs18.readdirSync(src, { withFileTypes: true })) {
+    const s = path17.join(src, ent.name);
+    const d = path17.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs17.copyFileSync(s, d);
+    else if (ent.isFile()) fs18.copyFileSync(s, d);
   }
 }
 var buildSyntheticPlugin;
@@ -4350,45 +4350,45 @@ var init_buildSyntheticPlugin = __esm({
       if (!needsSynthetic) return;
       const catalog = getPluginsCatalogRoot();
       const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const root = path16.join(os3.tmpdir(), `kody-synth-${runId}`);
-      fs17.mkdirSync(path16.join(root, ".claude-plugin"), { recursive: true });
+      const root = path17.join(os3.tmpdir(), `kody-synth-${runId}`);
+      fs18.mkdirSync(path17.join(root, ".claude-plugin"), { recursive: true });
       const resolvePart = (bucket, entry) => {
-        const local = path16.join(profile.dir, bucket, entry);
-        if (fs17.existsSync(local)) return local;
-        const central = path16.join(catalog, bucket, entry);
-        if (fs17.existsSync(central)) return central;
+        const local = path17.join(profile.dir, bucket, entry);
+        if (fs18.existsSync(local)) return local;
+        const central = path17.join(catalog, bucket, entry);
+        if (fs18.existsSync(central)) return central;
         throw new Error(
           `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in implementation dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
         );
       };
       if (cc.skills.length > 0) {
-        const dst = path16.join(root, "skills");
-        fs17.mkdirSync(dst, { recursive: true });
+        const dst = path17.join(root, "skills");
+        fs18.mkdirSync(dst, { recursive: true });
         for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path16.join(dst, name));
+          copyDir(resolvePart("skills", name), path17.join(dst, name));
         }
       }
       if (cc.commands.length > 0) {
-        const dst = path16.join(root, "commands");
-        fs17.mkdirSync(dst, { recursive: true });
+        const dst = path17.join(root, "commands");
+        fs18.mkdirSync(dst, { recursive: true });
         for (const name of cc.commands) {
-          fs17.copyFileSync(resolvePart("commands", `${name}.md`), path16.join(dst, `${name}.md`));
+          fs18.copyFileSync(resolvePart("commands", `${name}.md`), path17.join(dst, `${name}.md`));
         }
       }
       if (cc.hooks.length > 0) {
-        const dst = path16.join(root, "hooks");
-        fs17.mkdirSync(dst, { recursive: true });
+        const dst = path17.join(root, "hooks");
+        fs18.mkdirSync(dst, { recursive: true });
         const merged = { hooks: {} };
         for (const name of cc.hooks) {
           const src = resolvePart("hooks", `${name}.json`);
-          const parsed = JSON.parse(fs17.readFileSync(src, "utf-8"));
+          const parsed = JSON.parse(fs18.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);
           }
         }
-        fs17.writeFileSync(path16.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+        fs18.writeFileSync(path17.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
       }
       const manifest = {
@@ -4398,7 +4398,7 @@ var init_buildSyntheticPlugin = __esm({
       };
       if (cc.skills.length > 0) manifest.skills = ["./skills/"];
       if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs17.writeFileSync(path16.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+      fs18.writeFileSync(path17.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       ctx.data.syntheticPluginPath = root;
     };
@@ -4406,8 +4406,8 @@ var init_buildSyntheticPlugin = __esm({
 });
 
 // src/subagents.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 function splitFrontmatter(raw) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
   if (!match) return { fm: {}, body: raw.trim() };
@@ -4420,10 +4420,10 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile2(profileDir, name) {
-  const local = path17.join(profileDir, "agents", `${name}.md`);
-  if (fs18.existsSync(local)) return local;
-  const central = path17.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs18.existsSync(central)) return central;
+  const local = path18.join(profileDir, "agents", `${name}.md`);
+  if (fs19.existsSync(local)) return local;
+  const central = path18.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs19.existsSync(central)) return central;
   throw new Error(`loadSubagents: agent '${name}' not found in ${profileDir}/agents/ or shared catalog`);
 }
 function captureSubagentTemplates(profile) {
@@ -4432,7 +4432,7 @@ function captureSubagentTemplates(profile) {
   const out = {};
   for (const name of names) {
     try {
-      out[name] = fs18.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
+      out[name] = fs19.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
     } catch {
     }
   }
@@ -4443,7 +4443,7 @@ function loadSubagents(profile) {
   if (!names || names.length === 0) return void 0;
   const agents = {};
   for (const name of names) {
-    const raw = profile.subagentTemplates?.[name] ?? fs18.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
+    const raw = profile.subagentTemplates?.[name] ?? fs19.readFileSync(resolveAgentFile2(profile.dir, name), "utf-8");
     const { fm, body } = splitFrontmatter(raw);
     if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
     const def = {
@@ -4467,15 +4467,15 @@ var init_subagents = __esm({
 });
 
 // src/profile.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function loadProfile(profilePath) {
-  if (!fs19.existsSync(profilePath)) {
+  if (!fs20.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs19.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs20.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -4486,7 +4486,7 @@ function loadProfile(profilePath) {
   const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
   if (unknownKeys.length > 0) {
     process.stderr.write(
-      `[kody profile] ${path18.basename(path18.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path19.basename(path19.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -4496,7 +4496,7 @@ function loadProfile(profilePath) {
     if (!refPath) {
       throw new ProfileError(profilePath, `capability references unknown implementation '${execRef}'`);
     }
-    if (path18.resolve(refPath) === path18.resolve(profilePath)) {
+    if (path19.resolve(refPath) === path19.resolve(profilePath)) {
     } else {
       const base = loadProfile(refPath);
       return {
@@ -4594,8 +4594,8 @@ function loadProfile(profilePath) {
     // Phase 5 in-process handoff opt-in. Default false; containers
     // flip to true after end-to-end verification.
     preloadContext: r.preloadContext === true,
-    dir: path18.dirname(profilePath),
-    promptTemplates: readPromptTemplates(path18.dirname(profilePath))
+    dir: path19.dirname(profilePath),
+    promptTemplates: readPromptTemplates(path19.dirname(profilePath))
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -4638,17 +4638,17 @@ function readPromptTemplates(dir) {
   const out = {};
   const read = (p) => {
     try {
-      out[p] = fs19.readFileSync(p, "utf-8");
+      out[p] = fs20.readFileSync(p, "utf-8");
     } catch {
     }
   };
-  read(path18.join(dir, "prompt.md"));
-  read(path18.join(dir, "capability.md"));
-  read(path18.join(dir, "capability.md"));
+  read(path19.join(dir, "prompt.md"));
+  read(path19.join(dir, "capability.md"));
+  read(path19.join(dir, "capability.md"));
   try {
-    const promptsDir = path18.join(dir, "prompts");
-    for (const ent of fs19.readdirSync(promptsDir)) {
-      if (ent.endsWith(".md")) read(path18.join(promptsDir, ent));
+    const promptsDir = path19.join(dir, "prompts");
+    for (const ent of fs20.readdirSync(promptsDir)) {
+      if (ent.endsWith(".md")) read(path19.join(promptsDir, ent));
     }
   } catch {
   }
@@ -5422,16 +5422,16 @@ var init_state = __esm({
 });
 
 // src/prompt.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path19.join(projectDir, rel);
-    if (!fs20.existsSync(abs)) continue;
+    const abs = path20.join(projectDir, rel);
+    if (!fs21.existsSync(abs)) continue;
     let content;
     try {
-      content = fs20.readFileSync(abs, "utf-8");
+      content = fs21.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -5666,8 +5666,8 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 function formatBlockFromBackend(docs) {
   const pages = docs.flatMap((record2) => {
     if (!record2.doc || typeof record2.doc !== "object") return [];
@@ -5690,21 +5690,21 @@ function collectPages(memoryAbs) {
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs21.statSync(file);
+      stat = fs22.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs21.readFileSync(file, "utf-8");
+      raw = fs22.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path20.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path21.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path20.relative(memoryAbs, file),
+      relPath: path21.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -5772,16 +5772,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs21.readdirSync(dir);
+      names = fs22.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path20.join(dir, name);
+      const full = path21.join(dir, name);
       let stat;
       try {
-        stat = fs21.statSync(full);
+        stat = fs22.statSync(full);
       } catch {
         continue;
       }
@@ -5816,8 +5816,8 @@ var init_loadMemoryContext = __esm({
         }
         return;
       }
-      const memoryAbs = path20.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs21.existsSync(memoryAbs)) {
+      const memoryAbs = path21.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs22.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -5861,11 +5861,11 @@ var init_loadCoverageRules = __esm({
 
 // src/container.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs22.existsSync(profilePath)) return null;
+    if (!fs23.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -6328,11 +6328,11 @@ var init_lifecycleLabels = __esm({
 });
 
 // src/litellm.ts
-import { execFileSync as execFileSync4, spawn as spawn3 } from "child_process";
-import * as fs23 from "fs";
+import { execFileSync as execFileSync4, spawn as spawn4 } from "child_process";
+import * as fs24 from "fs";
 import * as net from "net";
 import * as os4 from "os";
-import * as path21 from "path";
+import * as path22 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -6401,6 +6401,8 @@ function locateLitellmScript() {
   }
 }
 function resolveLitellmCommand() {
+  const imageScript = "/opt/venv/bin/litellm";
+  if (fs24.existsSync(imageScript)) return imageScript;
   try {
     execFileSync4("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     return "litellm";
@@ -6436,13 +6438,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const spawnProxy = () => {
     const portMatch = activeUrl.match(/:(\d+)/);
     const port = portMatch ? portMatch[1] : "4000";
-    const configPath = path21.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
-    fs23.writeFileSync(configPath, generateLitellmConfigYaml(model));
+    const configPath = path22.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
+    fs24.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
-    const nextLogPath = path21.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
-    const outFd = fs23.openSync(nextLogPath, "w");
-    child = spawn3(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
-    fs23.closeSync(outFd);
+    const nextLogPath = path22.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
+    const outFd = fs24.openSync(nextLogPath, "w");
+    child = spawn4(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
+    fs24.closeSync(outFd);
     logPath = nextLogPath;
   };
   const waitForHealth = async () => {
@@ -6456,7 +6458,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const readLogTail = () => {
     if (!logPath) return "";
     try {
-      return fs23.readFileSync(logPath, "utf-8").slice(-2e3);
+      return fs24.readFileSync(logPath, "utf-8").slice(-2e3);
     } catch {
       return "";
     }
@@ -6539,10 +6541,10 @@ function canListen(port, host) {
   });
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path21.join(projectDir, ".env");
-  if (!fs23.existsSync(dotenvPath)) return {};
+  const dotenvPath = path22.join(projectDir, ".env");
+  if (!fs24.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs23.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs24.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)=(.*)$/);
@@ -6939,8 +6941,8 @@ var init_pushWithRetry = __esm({
 
 // src/commit.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function isGitHubYamlPath(filePath) {
   const normalized = filePath.replace(/^\.\/+/, "");
   return normalized.startsWith(".github/") && /\.ya?ml$/i.test(normalized);
@@ -6982,18 +6984,18 @@ function ensureGitIdentity(cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path22.join(cwd ?? process.cwd(), ".git");
-  if (!fs24.existsSync(gitDir)) return aborted;
-  if (fs24.existsSync(path22.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path23.join(cwd ?? process.cwd(), ".git");
+  if (!fs25.existsSync(gitDir)) return aborted;
+  if (fs25.existsSync(path23.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs24.existsSync(path22.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs25.existsSync(path23.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs24.existsSync(path22.join(gitDir, "REVERT_HEAD"))) {
+  if (fs25.existsSync(path23.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs24.existsSync(path22.join(gitDir, "rebase-merge")) || fs24.existsSync(path22.join(gitDir, "rebase-apply"))) {
+  if (fs25.existsSync(path23.join(gitDir, "rebase-merge")) || fs25.existsSync(path23.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -7050,7 +7052,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs24.existsSync(path22.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs25.existsSync(path23.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -7690,13 +7692,13 @@ var init_state2 = __esm({
 });
 
 // src/goal/runLog.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
   const logs = goalRunLogs(data);
   const existing = logs[goalId];
-  const path50 = existing?.path ?? goalRunLogPath(goalId, data);
+  const path51 = existing?.path ?? goalRunLogPath(goalId, data);
   logs[goalId] = {
-    path: path50,
+    path: path51,
     events: [...existing?.events ?? [], buildGoalRunLogEvent(data, goalId, event, at)]
   };
 }
@@ -8032,8 +8034,8 @@ function readGithubEvent() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
   if (!eventPath) return null;
   try {
-    if (!fs25.existsSync(eventPath)) return null;
-    const parsed = JSON.parse(fs25.readFileSync(eventPath, "utf-8"));
+    if (!fs26.existsSync(eventPath)) return null;
+    const parsed = JSON.parse(fs26.readFileSync(eventPath, "utf-8"));
     return recordValue3(parsed);
   } catch {
     return null;
@@ -8143,8 +8145,8 @@ var init_stateStore = __esm({
 });
 
 // src/goal/targetLoopResolution.ts
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 async function resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal) {
   const targetId = loopGoal.loopTarget?.id.trim() ?? "";
   assertSafeGoalId(targetId, "loop target");
@@ -8222,11 +8224,11 @@ function goalInstanceTime(state) {
   return Number.isNaN(parsed) ? 0 : parsed;
 }
 function loadGoalTemplate(cwd, targetId) {
-  return readJsonObject(path23.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
+  return readJsonObject(path24.join(cwd, ".kody-engine", "definitions", "goals", targetId, "state.json"));
 }
 function readJsonObject(filePath) {
-  if (!fs26.existsSync(filePath)) return null;
-  const parsed = JSON.parse(fs26.readFileSync(filePath, "utf8"));
+  if (!fs27.existsSync(filePath)) return null;
+  const parsed = JSON.parse(fs27.readFileSync(filePath, "utf8"));
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(`goal template ${filePath} must be a JSON object`);
   }
@@ -8669,11 +8671,11 @@ function validateWorkflow(value, options = {}) {
 function formatWorkflowValidationIssues(issues) {
   return issues.map((entry) => `${entry.path}: ${entry.message}`);
 }
-function validateDataMatch(value, path50, issues, capabilityOutputs) {
+function validateDataMatch(value, path51, issues, capabilityOutputs) {
   if (value === void 0) return;
   const match = asRecord2(value);
   if (!match || Object.keys(match).length === 0) {
-    issue(issues, "invalid_condition", path50, "workflow condition must contain at least one match");
+    issue(issues, "invalid_condition", path51, "workflow condition must contain at least one match");
     return;
   }
   for (const [field, expected] of Object.entries(match)) {
@@ -8681,7 +8683,7 @@ function validateDataMatch(value, path50, issues, capabilityOutputs) {
       issue(
         issues,
         "invalid_data_path",
-        `${path50}.${field}`,
+        `${path51}.${field}`,
         `workflow condition must read from facts, evidence, artifacts, result, workflow, or lastOutcome`
       );
     }
@@ -8689,12 +8691,12 @@ function validateDataMatch(value, path50, issues, capabilityOutputs) {
       issue(
         issues,
         "undeclared_result_path",
-        `${path50}.${field}`,
+        `${path51}.${field}`,
         `workflow condition reads ${field}, but the source capability does not declare it`
       );
     }
     if (!isComparable(expected)) {
-      issue(issues, "invalid_condition_value", `${path50}.${field}`, "workflow condition value must be a JSON scalar");
+      issue(issues, "invalid_condition_value", `${path51}.${field}`, "workflow condition value must be a JSON scalar");
     }
   }
 }
@@ -8712,8 +8714,8 @@ function isComparable(value) {
   if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true;
   return Array.isArray(value) && value.length > 0 && value.every((item) => isComparable(item) && !Array.isArray(item));
 }
-function issue(issues, code, path50, message) {
-  issues.push({ code, path: path50, message });
+function issue(issues, code, path51, message) {
+  issues.push({ code, path: path51, message });
 }
 var SAFE_NAME, SAFE_STEP_ID, SAFE_DATA_PATH, SUPPORTED_STEP_FIELDS, SUPPORTED_TRANSITION_FIELDS;
 var init_workflowValidation = __esm({
@@ -8745,8 +8747,8 @@ var init_workflowValidation = __esm({
 });
 
 // src/workflowDefinitions.ts
-import * as fs27 from "fs";
-import * as path24 from "path";
+import * as fs28 from "fs";
+import * as path25 from "path";
 function isWorkflowDefinitionId(value) {
   return WORKFLOW_ID_PATTERN.test(value);
 }
@@ -8787,14 +8789,14 @@ function normalizeWorkflowDefinition(value) {
   };
 }
 function readWorkflowDefinition(_config, cwd, id) {
-  const filePath = path24.join(cwd ?? process.cwd(), ".kody-engine", "runtime", workflowDefinitionPath(id));
-  if (!fs27.existsSync(filePath)) return null;
-  return parseWorkflowDefinition(fs27.readFileSync(filePath, "utf8"));
+  const filePath = path25.join(cwd ?? process.cwd(), ".kody-engine", "runtime", workflowDefinitionPath(id));
+  if (!fs28.existsSync(filePath)) return null;
+  return parseWorkflowDefinition(fs28.readFileSync(filePath, "utf8"));
 }
 function workflowDefinitionToCapabilityFolder(id, workflow, source = workflowDefinitionPath(id)) {
   return {
     slug: id,
-    dir: path24.dirname(source),
+    dir: path25.dirname(source),
     profilePath: source,
     bodyPath: source,
     title: workflow.name,
@@ -8971,15 +8973,15 @@ var init_backendStateBackend = __esm({
         this.jobsDir = opts.jobsDir.replace(/\/+$/, "");
       }
       async load(slug) {
-        const path50 = stateFilePath(this.jobsDir, slug);
+        const path51 = stateFilePath(this.jobsDir, slug);
         const loaded = await createStateBackendFromEnv().get(this.tenantId, `capabilities/${slug}`, "job-state");
         if (!loaded) {
-          return { path: path50, handle: null, state: initialStateEnvelope("seed"), created: true };
+          return { path: path51, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
         if (!isStateEnvelope(loaded.doc)) {
           throw new Error(`BackendStateBackend: capabilities/${slug} is not a StateEnvelope`);
         }
-        return { path: path50, handle: loaded.updatedAt, state: loaded.doc, created: false };
+        return { path: path51, handle: loaded.updatedAt, state: loaded.doc, created: false };
       }
       async save(loaded, next) {
         if (!loaded.created && isStateUnchanged(loaded.state, next)) return false;
@@ -8999,8 +9001,8 @@ var init_backendStateBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs28 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -9056,7 +9058,7 @@ var init_localFileBackend = __esm({
         if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
         this.cwd = opts.cwd;
         this.jobsDir = opts.jobsDir;
-        this.absDir = path25.resolve(opts.cwd, opts.jobsDir);
+        this.absDir = path26.resolve(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -9071,7 +9073,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs28.mkdirSync(this.absDir, { recursive: true });
+        fs29.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -9100,7 +9102,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs28.existsSync(this.absDir)) {
+        if (!fs29.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -9116,11 +9118,11 @@ var init_localFileBackend = __esm({
       }
       load(slug) {
         const relPath = stateFilePath(this.jobsDir, slug);
-        const absPath = path25.resolve(this.cwd, relPath);
-        if (!fs28.existsSync(absPath)) {
+        const absPath = path26.resolve(this.cwd, relPath);
+        if (!fs29.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs28.readFileSync(absPath, "utf-8");
+        const raw = fs29.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -9137,13 +9139,13 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path25.resolve(this.cwd, loaded.path);
-        fs28.mkdirSync(path25.dirname(absPath), { recursive: true });
+        const absPath = path26.resolve(this.cwd, loaded.path);
+        fs29.mkdirSync(path26.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs28.writeFileSync(tmpPath, body, "utf-8");
-        fs28.renameSync(tmpPath, absPath);
+        fs29.writeFileSync(tmpPath, body, "utf-8");
+        fs29.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -9175,7 +9177,7 @@ var init_jobState = __esm({
 });
 
 // src/scripts/goalCapabilityScheduling.ts
-import * as path26 from "path";
+import * as path27 from "path";
 function isCapabilityCadenceGoal(goal, extra) {
   return extra.scheduleMode === "agentLoop" || extra.scheduler === "agentLoop" || goal.type === "standing" && goal.capabilities.length > 0;
 }
@@ -9231,7 +9233,7 @@ function planTargetLoopSchedule(opts) {
 }
 async function planGoalCapabilitySchedule(opts) {
   const jobsDir = opts.jobsDir ?? capabilitiesRoot(opts.cwd);
-  const jobsRoot = path26.resolve(opts.cwd, jobsDir);
+  const jobsRoot = path27.resolve(opts.cwd, jobsDir);
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const at = now.toISOString();
   const backend = resolveBackend({ config: opts.config, cwd: opts.cwd, jobsDir });
@@ -11046,8 +11048,8 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
   return runtimeStatePath(cwd, "agent-runs", runId, `commit-${profileName}.lock`);
@@ -11068,9 +11070,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs29.existsSync(sentinel)) {
+      if (sentinel && fs30.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs29.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs30.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;
@@ -11130,8 +11132,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs29.mkdirSync(path27.dirname(sentinel), { recursive: true });
-          fs29.writeFileSync(
+          fs30.mkdirSync(path28.dirname(sentinel), { recursive: true });
+          fs30.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -11225,8 +11227,8 @@ var init_commitGoalState = __esm({
 });
 
 // src/scripts/composePrompt.ts
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 function fenceUntrusted(value) {
   if (value.trim().length === 0) return value;
   const safe = value.replace(/-{3,}\s*END UNTRUSTED INPUT\s*-{3,}/gi, "[END UNTRUSTED INPUT]");
@@ -11350,10 +11352,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        explicit ? path28.join(profile.dir, explicit) : null,
-        mode ? path28.join(profile.dir, "prompts", `${mode}.md`) : null,
-        path28.join(profile.dir, "prompt.md"),
-        path28.join(profile.dir, "capability.md")
+        explicit ? path29.join(profile.dir, explicit) : null,
+        mode ? path29.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path29.join(profile.dir, "prompt.md"),
+        path29.join(profile.dir, "capability.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -11366,7 +11368,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs30.readFileSync(c, "utf-8");
+          template = fs31.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -11377,7 +11379,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs30.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs31.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -12066,19 +12068,19 @@ var init_deriveQaScopeFromIssue = __esm({
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as os5 from "os";
-import * as path29 from "path";
+import * as path30 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
       const home = os5.homedir();
-      const cacheDir = path29.join(home, ".cache", "ms-playwright");
+      const cacheDir = path30.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs31.readdirSync(cacheDir);
+        entries = fs32.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -12106,13 +12108,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs32.readFileSync(path30.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs33.readFileSync(path31.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -12149,25 +12151,25 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs32.existsSync(path30.join(cwd, c))) return c;
+    if (fs33.existsSync(path31.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path30.join(cwd, dir);
-    if (!fs32.existsSync(full)) continue;
+    const full = path31.join(cwd, dir);
+    if (!fs33.existsSync(full)) continue;
     let files;
     try {
-      files = fs32.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs33.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path30.join(full, file);
-        const content = fs32.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path31.join(full, file);
+        const content = fs33.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -12181,7 +12183,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path30.relative(cwd, filePath),
+          filePath: path31.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -12194,28 +12196,28 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path30.join(cwd, dir);
-    if (!fs32.existsSync(full)) continue;
+    const full = path31.join(cwd, dir);
+    if (!fs33.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs32.readdirSync(full, { withFileTypes: true });
+      entries = fs33.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path30.join(full, entry.name);
+      const entryPath = path31.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs32.existsSync(path30.join(entryPath, f))
+          (f) => fs33.existsSync(path31.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path30.relative(cwd, path30.join(entryPath, indexFile));
+        filePath = path31.relative(cwd, path31.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path30.relative(cwd, entryPath);
+        filePath = path31.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -12223,7 +12225,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs32.readFileSync(path30.join(cwd, col.filePath), "utf-8");
+            const colContent = fs33.readFileSync(path31.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -12241,8 +12243,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path30.join(cwd, appDir, "api");
-    if (!fs32.existsSync(apiDir)) continue;
+    const apiDir = path31.join(cwd, appDir, "api");
+    if (!fs33.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -12251,14 +12253,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir, { withFileTypes: true });
+    entries = fs33.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 = fs32.readFileSync(path30.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs33.readFileSync(path31.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)
       );
@@ -12266,7 +12268,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path30.relative(cwd, path30.join(dir, routeFile.name))
+          filePath: path31.relative(cwd, path31.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -12277,7 +12279,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkApiRoutes(path30.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path31.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -12285,16 +12287,16 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path30.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path31.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path30.join(cwd, envFile);
-    if (!fs32.existsSync(envPath)) continue;
+    const envPath = path31.join(cwd, envFile);
+    if (!fs33.existsSync(envPath)) continue;
     try {
-      const content = fs32.readFileSync(envPath, "utf-8");
+      const content = fs33.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -12339,8 +12341,8 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -12371,9 +12373,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs33.readFileSync(path31.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs34.readFileSync(path32.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs33.existsSync(path31.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs33.existsSync(path31.join(cwd, "yarn.lock")) ? "yarn" : fs33.existsSync(path31.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs34.existsSync(path32.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs34.existsSync(path32.join(cwd, "yarn.lock")) ? "yarn" : fs34.existsSync(path32.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;
@@ -12383,8 +12385,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path31.join(cwd, appDir);
-    if (!fs33.existsSync(full)) continue;
+    const full = path32.join(cwd, appDir);
+    if (!fs34.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -12392,7 +12394,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs33.readdirSync(dir, { withFileTypes: true });
+    entries = fs34.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -12409,7 +12411,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkFrontendRoutes(path31.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path32.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -12417,7 +12419,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path31.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path32.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -12434,23 +12436,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs33.existsSync(path31.join(cwd, c))) out.authFiles.push(c);
+    if (fs34.existsSync(path32.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 = path31.join(cwd, rp);
-    if (!fs33.existsSync(dir)) continue;
+    const dir = path32.join(cwd, rp);
+    if (!fs34.existsSync(dir)) continue;
     let files;
     try {
-      files = fs33.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs34.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs33.readFileSync(path31.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs34.readFileSync(path32.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) {
@@ -13731,12 +13733,12 @@ var init_fixFlow = __esm({
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 function detectPackageManager(cwd) {
-  if (fs34.existsSync(path32.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs34.existsSync(path32.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs34.existsSync(path32.join(cwd, "bun.lockb"))) return "bun";
+  if (fs35.existsSync(path33.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs35.existsSync(path33.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs35.existsSync(path33.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -13808,22 +13810,22 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path32.join(cwd, "kody.config.json");
-  if (fs34.existsSync(configPath) && !force) {
+  const configPath = path33.join(cwd, "kody.config.json");
+  if (fs35.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs34.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs35.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path32.join(cwd, ".github", "workflows");
-  const workflowPath = path32.join(workflowDir, "kody.yml");
-  if (fs34.existsSync(workflowPath) && !force) {
+  const workflowDir = path33.join(cwd, ".github", "workflows");
+  const workflowPath = path33.join(workflowDir, "kody.yml");
+  if (fs35.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs34.mkdirSync(workflowDir, { recursive: true });
-    fs34.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs35.mkdirSync(workflowDir, { recursive: true });
+    fs35.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   for (const exe of listImplementations()) {
@@ -13834,12 +13836,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path32.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs34.existsSync(target) && !force) {
+    const target = path33.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs35.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs34.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs35.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -13987,7 +13989,7 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 });
 
 // src/scripts/loadAgentAdhoc.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -13995,9 +13997,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs35.existsSync(eventPath)) return "";
+  if (!eventPath || !fs36.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs35.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs36.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -14051,10 +14053,10 @@ var init_loadAgentAdhoc = __esm({
         throw new Error("loadAgentAdhoc: ctx.args.agent must be a non-empty slug");
       }
       const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-      if (!fs35.existsSync(agentPath)) {
+      if (!fs36.existsSync(agentPath)) {
         throw new Error(`loadAgentAdhoc: agent identity not found: ${agentPath}`);
       }
-      const { title, body } = parseAgentFile(fs35.readFileSync(agentPath, "utf-8"), agentSlug);
+      const { title, body } = parseAgentFile(fs36.readFileSync(agentPath, "utf-8"), agentSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -14126,13 +14128,13 @@ var init_loadCapabilityState = __esm({
 function isCompanyIntentId(value) {
   return SLUG_RE.test(value);
 }
-function normalizeCompanyIntent(path50, raw) {
+function normalizeCompanyIntent(path51, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${path50}: intent must be JSON object`);
+    throw new Error(`${path51}: intent must be JSON object`);
   }
   const input = raw;
   const id = stringField4(input.id);
-  if (!id || !isCompanyIntentId(id)) throw new Error(`${path50}: invalid intent id`);
+  if (!id || !isCompanyIntentId(id)) throw new Error(`${path51}: invalid intent id`);
   const createdAt = stringField4(input.createdAt) || nowIso();
   const updatedAt = stringField4(input.updatedAt) || createdAt;
   const description = stringField4(input.description);
@@ -14423,8 +14425,8 @@ var init_loadIssueStateComment = __esm({
 });
 
 // src/scripts/loadJobFromFile.ts
-import * as fs36 from "fs";
-import * as path33 from "path";
+import * as fs37 from "fs";
+import * as path34 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -14463,10 +14465,10 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const capability = resolveCapabilityFolder(slug, path33.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path34.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         throw new Error(
-          `loadJobFromFile: capability folder not found or incomplete: ${path33.resolve(ctx.cwd, jobsDir, slug)}`
+          `loadJobFromFile: capability folder not found or incomplete: ${path34.resolve(ctx.cwd, jobsDir, slug)}`
         );
       }
       const { title, body, config } = capability;
@@ -14476,12 +14478,12 @@ var init_loadJobFromFile = __esm({
       let agentIdentity = "";
       if (agentSlug) {
         const agentPath = resolveAgentFile(ctx.cwd, agentSlug, agentsDir);
-        if (!fs36.existsSync(agentPath)) {
+        if (!fs37.existsSync(agentPath)) {
           throw new Error(
             `loadJobFromFile: capability '${slug}' declares agent '${agentSlug}' but ${agentPath} does not exist`
           );
         }
-        const agentRaw = fs36.readFileSync(agentPath, "utf-8");
+        const agentRaw = fs37.readFileSync(agentPath, "utf-8");
         const parsed = parseJobFile(agentRaw, agentSlug);
         agentTitle = parsed.title;
         agentIdentity = parsed.body;
@@ -14561,13 +14563,13 @@ ${truncate2(issue2.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs37 from "fs";
-import * as path34 from "path";
+import * as fs38 from "fs";
+import * as path35 from "path";
 function readKodyVariables(cwd) {
-  const full = path34.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path35.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs37.readFileSync(full, "utf-8");
+    raw = fs38.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -14730,8 +14732,8 @@ var init_runtimeSecrets = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs38 from "fs";
-import * as path35 from "path";
+import * as fs39 from "fs";
+import * as path36 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -14760,18 +14762,18 @@ function readProfileAgents(raw) {
   return { agent: agent ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path35.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs38.existsSync(dir)) return "";
+  const dir = path36.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs39.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs38.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs39.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs38.readFileSync(path35.join(dir, file), "utf-8");
+      const raw = fs39.readFileSync(path36.join(dir, file), "utf-8");
       const { agent, body } = readProfileAgents(raw);
       if (!agent.includes(QA_AGENT) && !agent.includes(ALL_AGENTS)) continue;
       blocks.push(`## ${file}
@@ -14820,8 +14822,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs39 from "fs";
-import * as path36 from "path";
+import * as fs40 from "fs";
+import * as path37 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -14837,9 +14839,9 @@ function buildTaskContext(args) {
 function persistTaskContext(cwd, ctx) {
   try {
     const dir = runtimeStatePath(cwd, "agent-runs", ctx.runId);
-    fs39.mkdirSync(dir, { recursive: true });
-    const file = path36.join(dir, "task-context.json");
-    fs39.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    fs40.mkdirSync(dir, { recursive: true });
+    const file = path37.join(dir, "task-context.json");
+    fs40.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -15266,19 +15268,19 @@ function parseAgencyModelProposal(raw) {
 function normalizeBundleFiles(bundle) {
   const seen = /* @__PURE__ */ new Set();
   return bundle.files.map((file, index) => {
-    const path50 = file.path.replace(/^\/+/, "");
-    const parts = path50.split("/");
-    if (!path50 || file.path.startsWith("/") || file.path.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
+    const path51 = file.path.replace(/^\/+/, "");
+    const parts = path51.split("/");
+    if (!path51 || file.path.startsWith("/") || file.path.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
       throw new Error(`openAgencyModelReviewPr: files[${index}].path is unsafe`);
     }
     if (!/^(agents\/[^/]+\.md|capabilities\/[^/]+\/.+|goals\/(?:templates\/)?[^/]+\/.+|workflows\/[^/]+\.json)$/.test(
-      path50
+      path51
     )) {
       throw new Error(`openAgencyModelReviewPr: files[${index}].path is not a supported definition path`);
     }
-    if (seen.has(path50)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path50}`);
-    seen.add(path50);
-    return { path: path50, content: file.content.replace(/\r\n?/g, "\n") };
+    if (seen.has(path51)) throw new Error(`openAgencyModelReviewPr: duplicate generated file path: ${path51}`);
+    seen.add(path51);
+    return { path: path51, content: file.content.replace(/\r\n?/g, "\n") };
   });
 }
 function buildProposalId(issueNumber, bundle, sourceLabel) {
@@ -16222,9 +16224,9 @@ var init_postResearchComment = __esm({
 });
 
 // src/scripts/prepareBrowserAuth.ts
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as os6 from "os";
-import * as path37 from "path";
+import * as path38 from "path";
 function appendAuthMessage(ctx, message) {
   const current = typeof ctx.data.qaAuthBlock === "string" ? ctx.data.qaAuthBlock.trim() : "";
   ctx.data.qaAuthBlock = current ? `${current}
@@ -16263,9 +16265,9 @@ async function githubJson(url, token) {
   return await response.json();
 }
 function writeKodyStorageState(input) {
-  const directory = fs40.mkdtempSync(path37.join(os6.tmpdir(), "kody-browser-auth-"));
-  fs40.chmodSync(directory, 448);
-  const file = path37.join(directory, "storage-state.json");
+  const directory = fs41.mkdtempSync(path38.join(os6.tmpdir(), "kody-browser-auth-"));
+  fs41.chmodSync(directory, 448);
+  const file = path38.join(directory, "storage-state.json");
   const now = Date.now();
   const repoEntry = {
     repoUrl: input.repoUrl,
@@ -16295,7 +16297,7 @@ function writeKodyStorageState(input) {
       }
     ]
   };
-  fs40.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
+  fs41.writeFileSync(file, JSON.stringify(storageState), { mode: 384 });
   return { directory, file };
 }
 function configurePlaywright(profile, storageStatePath) {
@@ -16377,7 +16379,7 @@ async function prepareMethod(ctx, profile, method) {
     configurePlaywright(profile, state.file);
     const authDirectory = state.directory;
     registerRuntimeCleanup(ctx, () => {
-      fs40.rmSync(authDirectory, { recursive: true, force: true });
+      fs41.rmSync(authDirectory, { recursive: true, force: true });
     });
     appendAuthMessage(
       ctx,
@@ -16385,7 +16387,7 @@ async function prepareMethod(ctx, profile, method) {
     );
     return true;
   } catch (error) {
-    if (state) fs40.rmSync(state.directory, { recursive: true, force: true });
+    if (state) fs41.rmSync(state.directory, { recursive: true, force: true });
     const reason = error instanceof Error ? error.message : String(error);
     appendAuthMessage(
       ctx,
@@ -16498,9 +16500,9 @@ function latestResult(raw, agentResult) {
 function recordField4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function resolveDotted(root, path50) {
-  if (!path50) return void 0;
-  return path50.split(".").reduce((value, key) => recordField4(value)?.[key], root);
+function resolveDotted(root, path51) {
+  if (!path51) return void 0;
+  return path51.split(".").reduce((value, key) => recordField4(value)?.[key], root);
 }
 function stringValue4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -17451,10 +17453,10 @@ var init_previewBuildHelpers = __esm({
 });
 
 // src/scripts/previewBuildRun.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 async function runCmd(cmd, args, opts = {}) {
   await new Promise((resolve16, reject) => {
-    const child = spawn4(cmd, args, {
+    const child = spawn5(cmd, args, {
       cwd: opts.cwd,
       env: { ...process.env, ...opts.env ?? {} },
       stdio: opts.input ? ["pipe", "inherit", "inherit"] : "inherit"
@@ -17537,12 +17539,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path38 from "path";
+import * as path39 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path38.dirname(fileURLToPath(import.meta.url));
+  const here = path39.dirname(fileURLToPath(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path38.join(here, "preview-build-templates", file);
+  return path39.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -17789,10 +17791,10 @@ var init_runPreviewBuild = __esm({
         console.log(`[preview-build] vault: ${Object.keys(buildEnv).length} secrets, mode=${buildMode}`);
         if (Object.keys(buildEnv).length > 0) {
           const lines = Object.entries(buildEnv).map(([k, v]) => `${k}=${JSON.stringify(v)}`);
-          await writeFile(path38.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path39.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path38.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path39.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -17976,8 +17978,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledImplementationTick.ts
-import * as fs41 from "fs";
-import * as path39 from "path";
+import * as fs42 from "fs";
+import * as path40 from "path";
 var runScheduledImplementationTick;
 var init_runScheduledImplementationTick = __esm({
   "src/scripts/runScheduledImplementationTick.ts"() {
@@ -17998,14 +18000,14 @@ var init_runScheduledImplementationTick = __esm({
         ctx.output.reason = `runScheduledImplementationTick: args.slug or ctx.args.${slugArg} must be non-empty capability slug`;
         return;
       }
-      const capability = resolveCapabilityFolder(slug, path39.resolve(ctx.cwd, jobsDir));
+      const capability = resolveCapabilityFolder(slug, path40.resolve(ctx.cwd, jobsDir));
       if (!capability) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: capability folder not found or incomplete: ${slug} (searched ${jobsDir} and company store)`;
         return;
       }
-      const shellPath = path39.join(profile.dir, shell);
-      if (!fs41.existsSync(shellPath)) {
+      const shellPath = path40.join(profile.dir, shell);
+      if (!fs42.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledImplementationTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -18036,8 +18038,8 @@ var init_runScheduledImplementationTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs42 from "fs";
-import * as path40 from "path";
+import * as fs43 from "fs";
+import * as path41 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -18057,10 +18059,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const capability = readCapabilityFolder(path40.resolve(ctx.cwd, jobsDir), slug);
+      const capability = readCapabilityFolder(path41.resolve(ctx.cwd, jobsDir), slug);
       if (!capability) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path40.resolve(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: capability folder not found or incomplete: ${path41.resolve(ctx.cwd, jobsDir, slug)}`;
         return;
       }
       const tickScript = capability.config.tickScript;
@@ -18069,8 +18071,8 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: capability ${slug} has no \`tickScript\` in profile.json \u2014 route via capability-tick instead`;
         return;
       }
-      const scriptPath = path40.isAbsolute(tickScript) ? tickScript : path40.join(ctx.cwd, tickScript);
-      if (!fs42.existsSync(scriptPath)) {
+      const scriptPath = path41.isAbsolute(tickScript) ? tickScript : path41.join(ctx.cwd, tickScript);
+      if (!fs43.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -18352,7 +18354,7 @@ var init_syncFlow = __esm({
 });
 
 // src/scripts/validateAgencyModelProposal.ts
-import * as path41 from "path";
+import * as path42 from "path";
 function validateModelBundle(bundle, expectedKind, options = {}) {
   const failures = [];
   validateOneModel(bundle.model, bundle.files, "model", true, failures, expectedKind, options);
@@ -18678,7 +18680,7 @@ var init_validateAgencyModelProposal = __esm({
       const bundle = parseAgencyModelProposal(raw);
       const expectedKind = readExpectedModelKind(args);
       const failures = validateModelBundle(bundle, expectedKind, {
-        capabilityRoot: path41.join(ctx.cwd, ".kody", "capabilities")
+        capabilityRoot: path42.join(ctx.cwd, ".kody", "capabilities")
       });
       if (failures.length > 0) {
         throw new Error(`validateAgencyModelProposal: ${failures.join("; ")}`);
@@ -18723,7 +18725,7 @@ var init_verify2 = __esm({
 });
 
 // src/scripts/verifyReproFails.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 function composeTestCommand(baseCmd, testPath) {
   const trimmed = baseCmd.trim();
   const lower = trimmed.toLowerCase();
@@ -18742,7 +18744,7 @@ function stripAnsi2(s) {
 }
 function runCommand2(command, cwd) {
   return new Promise((resolve16) => {
-    const child = spawn5(command, {
+    const child = spawn6(command, {
       cwd,
       shell: true,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
@@ -19072,9 +19074,9 @@ var init_waitForCi = __esm({
 });
 
 // src/scripts/warmupMcp.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 async function warmupOne(command, args, env) {
-  const child = spawn6(command, args, {
+  const child = spawn7(command, args, {
     stdio: ["pipe", "pipe", "pipe"],
     env: env ? { ...process.env, ...env } : process.env
   });
@@ -19229,7 +19231,7 @@ var init_warmupMcp = __esm({
 });
 
 // src/scripts/writeAgentRunSummary.ts
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 var writeAgentRunSummary;
 var init_writeAgentRunSummary = __esm({
   "src/scripts/writeAgentRunSummary.ts"() {
@@ -19255,7 +19257,7 @@ var init_writeAgentRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs43.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs44.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -19581,17 +19583,17 @@ var init_scripts = __esm({
 });
 
 // src/stateWorkspace.ts
-import * as fs44 from "fs";
-import * as path42 from "path";
+import * as fs45 from "fs";
+import * as path43 from "path";
 function tenantId(config) {
   const owner = config.github?.owner?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[0]?.trim();
   const repo = config.github?.repo?.trim() || process.env.GITHUB_REPOSITORY?.split("/")[1]?.trim();
   return owner && repo ? `${owner}/${repo}` : null;
 }
 function writeRuntimeFile(cwd, relativePath, content) {
-  const target = path42.join(cwd, RUNTIME_ROOT, relativePath);
-  fs44.mkdirSync(path42.dirname(target), { recursive: true });
-  fs44.writeFileSync(target, content, "utf8");
+  const target = path43.join(cwd, RUNTIME_ROOT, relativePath);
+  fs45.mkdirSync(path43.dirname(target), { recursive: true });
+  fs45.writeFileSync(target, content, "utf8");
 }
 function record(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -19656,11 +19658,11 @@ async function hydrateStateWorkspace(config, cwd, backendOverride) {
       throw new Error("Convex backend is required for runtime workspace documents");
     return;
   }
-  const key = `${path42.resolve(cwd)}|${tenant}`;
+  const key = `${path43.resolve(cwd)}|${tenant}`;
   if (hydratedWorkspaces.has(key)) return;
   const backend = backendOverride ?? createStateBackendFromEnv();
-  const root = path42.join(cwd, RUNTIME_ROOT);
-  fs44.rmSync(root, { recursive: true, force: true });
+  const root = path43.join(cwd, RUNTIME_ROOT);
+  fs45.rmSync(root, { recursive: true, force: true });
   await Promise.all([
     hydratePrefix(backend, tenant, cwd, "context:"),
     hydratePrefix(backend, tenant, cwd, "memory:"),
@@ -19676,7 +19678,7 @@ var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
     init_state_backend();
-    RUNTIME_ROOT = path42.join(".kody-engine", "runtime");
+    RUNTIME_ROOT = path43.join(".kody-engine", "runtime");
     hydratedWorkspaces = /* @__PURE__ */ new Set();
   }
 });
@@ -19746,10 +19748,10 @@ var init_tools = __esm({
 });
 
 // src/executor.ts
-import { spawn as spawn7 } from "child_process";
-import * as fs45 from "fs";
+import { spawn as spawn8 } from "child_process";
+import * as fs46 from "fs";
 import * as os7 from "os";
-import * as path43 from "path";
+import * as path44 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -19977,7 +19979,7 @@ async function runImplementation(profileName, input) {
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path43.isAbsolute(p) ? p : path43.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path44.isAbsolute(p) ? p : path44.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -20415,17 +20417,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveImplementation(profileName);
   if (found) return found;
-  const here = path43.dirname(new URL(import.meta.url).pathname);
+  const here = path44.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path43.join(here, "implementations", profileName, "profile.json"),
+    path44.join(here, "implementations", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path43.join(here, "..", "implementations", profileName, "profile.json"),
+    path44.join(here, "..", "implementations", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/implementations)
-    path43.join(here, "..", "src", "implementations", profileName, "profile.json")
+    path44.join(here, "..", "src", "implementations", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs45.existsSync(c)) return c;
+    if (fs46.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -20540,15 +20542,15 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path43.join(profile.dir, shellName);
-  if (!fs45.existsSync(shellPath)) {
+  const shellPath = path44.join(profile.dir, shellName);
+  if (!fs46.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
     return;
   }
   const positional = entry.with ? Object.values(entry.with).map((v) => String(v)) : [];
-  const outputFile = path43.join(
+  const outputFile = path44.join(
     os7.tmpdir(),
     `kody-shell-output-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
   );
@@ -20561,7 +20563,7 @@ async function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const child = spawn7("bash", [shellPath, ...positional], {
+  const child = spawn8("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -20620,9 +20622,9 @@ async function runShellEntry(entry, ctx, profile) {
   }
   let sideChannelText = "";
   try {
-    if (fs45.existsSync(outputFile)) {
-      sideChannelText = fs45.readFileSync(outputFile, "utf-8");
-      fs45.rmSync(outputFile, { force: true });
+    if (fs46.existsSync(outputFile)) {
+      sideChannelText = fs46.readFileSync(outputFile, "utf-8");
+      fs46.rmSync(outputFile, { force: true });
     }
   } catch {
   }
@@ -20792,7 +20794,7 @@ __export(job_exports, {
   stableJobKey: () => stableJobKey,
   validateJob: () => validateJob
 });
-import * as path44 from "path";
+import * as path45 from "path";
 function newJobId(flavor) {
   localJobSeq += 1;
   const runId = process.env.GITHUB_RUN_ID;
@@ -21255,11 +21257,11 @@ function selectWorkflowTransition(step, data, counts) {
 }
 function workflowResultConditionPaths(transitions) {
   return transitions.flatMap(
-    (transition) => Object.keys(transition.when ?? {}).filter((path50) => path50.startsWith("result."))
+    (transition) => Object.keys(transition.when ?? {}).filter((path51) => path51.startsWith("result."))
   );
 }
 function conditionMatches(condition, context) {
-  return Object.entries(condition).every(([path50, expected]) => valueMatches(resolveDottedPath2(context, path50), expected));
+  return Object.entries(condition).every(([path51, expected]) => valueMatches(resolveDottedPath2(context, path51), expected));
 }
 function withWorkflowBoundaryEval(capability, result) {
   const capabilityKind = capability.config.capabilityKind;
@@ -21417,7 +21419,7 @@ function loadCapabilityContext(slug, cwd) {
   return resolveCapabilityFolder(slug, hydratedCapabilitiesRoot(cwd));
 }
 function hydratedCapabilitiesRoot(cwd) {
-  return path44.join(cwd, ".kody-engine", "definitions", "capabilities");
+  return path45.join(cwd, ".kody-engine", "definitions", "capabilities");
 }
 function loadWorkflowContext(slug, base) {
   if (!slug || !base.config || !isWorkflowDefinitionId(slug)) return null;
@@ -21580,7 +21582,7 @@ function translateOpenAISseToBrain(opts) {
 
 // src/servers/brain-serve.ts
 import { createServer as createServer2 } from "http";
-import * as path47 from "path";
+import * as path48 from "path";
 
 // src/chat/loop.ts
 init_agent();
@@ -21588,8 +21590,8 @@ init_agents();
 init_config();
 init_registry();
 init_task_artifacts();
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 
 // src/chat/attachments.ts
 init_runtimePaths();
@@ -21646,12 +21648,293 @@ function prepareAttachments(turns, cwd, sessionId) {
   return { turns: rewritten, imagePaths };
 }
 
-// src/chat/events.ts
+// src/chat/codex-app-server.ts
+import { spawn as spawn3 } from "child_process";
 import * as fs12 from "fs";
 import * as path13 from "path";
+import { createInterface } from "readline";
+function codexThreadStartParams(args) {
+  return {
+    cwd: args.cwd,
+    developerInstructions: args.developerInstructions
+  };
+}
+function codexTurnStartParams(args) {
+  return {
+    threadId: args.threadId,
+    input: [{ type: "text", text: args.message }]
+  };
+}
+function translateCodexNotification(notification, chatId) {
+  const params = notification.params ?? {};
+  if (notification.method === "item/agentMessage/delta") {
+    const delta = params.delta;
+    return typeof delta === "string" && delta.length > 0 ? [{ type: "text", text: delta, chatId }] : [];
+  }
+  if (notification.method === "turn/completed") {
+    return [{ type: "done", chatId }];
+  }
+  if (notification.method === "error") {
+    const message = params.message;
+    return [
+      {
+        type: "error",
+        error: typeof message === "string" ? message : "Codex app-server error",
+        chatId
+      }
+    ];
+  }
+  if (notification.method === "item/started") {
+    const item = params.item;
+    if (!item || typeof item !== "object") return [];
+    const record2 = item;
+    return [
+      {
+        type: "tool_use",
+        name: typeof record2.type === "string" ? record2.type : "tool",
+        input: record2,
+        chatId
+      }
+    ];
+  }
+  return [];
+}
+var CodexAppServerClient = class {
+  process;
+  initialized = false;
+  constructor(options) {
+    const child = (options.spawnImpl ?? spawn3)("codex", ["app-server", "--stdio"], {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.process = {
+      child,
+      nextId: 1,
+      pending: /* @__PURE__ */ new Map(),
+      turnWaiters: /* @__PURE__ */ new Map()
+    };
+    const lines = createInterface({ input: child.stdout });
+    lines.on("line", (line) => this.handleLine(line));
+    child.on("error", (error) => this.fail(error));
+    child.on("exit", (code, signal) => {
+      this.fail(new Error(`codex app-server exited (${code ?? `signal ${signal}`})`));
+    });
+  }
+  async startThread(args) {
+    await this.ensureInitialized();
+    const result = await this.request("thread/start", codexThreadStartParams(args));
+    const thread = result.thread;
+    if (!thread || typeof thread !== "object") {
+      throw new Error("Codex app-server returned no thread");
+    }
+    const id = thread.id;
+    if (typeof id !== "string" || !id) throw new Error("Codex app-server returned an invalid thread id");
+    return id;
+  }
+  async resumeThread(threadId) {
+    await this.ensureInitialized();
+    await this.request("thread/resume", { threadId });
+  }
+  async runTurn(args) {
+    await new Promise((resolve16, reject) => {
+      this.process.turnWaiters.set(args.threadId, {
+        resolve: resolve16,
+        reject,
+        onNotification: args.onNotification,
+        queue: Promise.resolve()
+      });
+      void this.request("turn/start", codexTurnStartParams(args)).catch((error) => {
+        this.process.turnWaiters.delete(args.threadId);
+        reject(error);
+      });
+    });
+  }
+  close() {
+    this.process.child.kill();
+    this.fail(new Error("Codex app-server client closed"));
+  }
+  request(method, params) {
+    const id = this.process.nextId++;
+    return new Promise((resolve16, reject) => {
+      this.process.pending.set(id, { resolve: resolve16, reject });
+      this.process.child.stdin.write(`${JSON.stringify({ method, id, params })}
+`);
+    });
+  }
+  notify(method, params) {
+    this.process.child.stdin.write(`${JSON.stringify({ method, params })}
+`);
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    await this.request("initialize", {
+      clientInfo: { name: "kody-brain", version: "0.1.0" }
+    });
+    this.notify("initialized", {});
+    this.initialized = true;
+  }
+  handleLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof message.id === "number") {
+      const pending = this.process.pending.get(message.id);
+      if (!pending) return;
+      this.process.pending.delete(message.id);
+      if (message.error && typeof message.error === "object") {
+        const error = message.error;
+        pending.reject(new Error(typeof error.message === "string" ? error.message : "Codex request failed"));
+      } else {
+        pending.resolve(message.result ?? {});
+      }
+      return;
+    }
+    if (typeof message.method !== "string") return;
+    const notification = {
+      method: message.method,
+      params: typeof message.params === "object" && message.params !== null ? message.params : {}
+    };
+    const threadId = notification.params?.threadId;
+    if (typeof threadId !== "string") return;
+    const waiter = this.process.turnWaiters.get(threadId);
+    if (!waiter) return;
+    waiter.queue = waiter.queue.then(() => waiter.onNotification(notification));
+    if (notification.method === "turn/completed" || notification.method === "error") {
+      this.process.turnWaiters.delete(threadId);
+      void waiter.queue.then(() => {
+        if (notification.method === "error") {
+          waiter.reject(new Error(String(notification.params?.message ?? "Codex turn failed")));
+        } else {
+          waiter.resolve();
+        }
+      }, waiter.reject);
+    }
+  }
+  fail(error) {
+    for (const pending of this.process.pending.values()) pending.reject(error);
+    this.process.pending.clear();
+    for (const waiter of this.process.turnWaiters.values()) waiter.reject(error);
+    this.process.turnWaiters.clear();
+  }
+};
+var clients = /* @__PURE__ */ new Map();
+function threadMapPath(cwd) {
+  return path13.join(cwd, ".kody-engine", "runtime", "codex-threads.json");
+}
+function readThreadMap(cwd) {
+  try {
+    const value = JSON.parse(fs12.readFileSync(threadMapPath(cwd), "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    return Object.fromEntries(
+      Object.entries(value).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+function writeThreadMap(cwd, map) {
+  const file = threadMapPath(cwd);
+  fs12.mkdirSync(path13.dirname(file), { recursive: true });
+  fs12.writeFileSync(file, `${JSON.stringify(map, null, 2)}
+`);
+}
+async function runCodexChatTurn(args) {
+  const { opts, turns, systemPrompt, store } = args;
+  const last = turns.at(-1);
+  if (!last || last.role !== "user") {
+    const error = "last turn is not a user message";
+    await opts.sink.emit({
+      event: "chat.error",
+      payload: { error },
+      runId: opts.sessionId,
+      emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { exitCode: 64, error };
+  }
+  const client = clients.get(opts.cwd) ?? new CodexAppServerClient({ cwd: opts.cwd });
+  clients.set(opts.cwd, client);
+  const map = readThreadMap(opts.cwd);
+  let threadId = map[opts.sessionId];
+  if (threadId) {
+    try {
+      await client.resumeThread(threadId);
+    } catch {
+      threadId = void 0;
+    }
+  }
+  threadId ??= await client.startThread({ cwd: opts.cwd, developerInstructions: systemPrompt });
+  if (!map[opts.sessionId]) {
+    map[opts.sessionId] = threadId;
+    writeThreadMap(opts.cwd, map);
+  }
+  const replyParts = [];
+  try {
+    await client.runTurn({
+      threadId,
+      message: last.content,
+      onNotification: async (notification) => {
+        for (const event of translateCodexNotification(notification, opts.sessionId)) {
+          if (event.type === "text" && event.text) {
+            replyParts.push(event.text);
+            await opts.sink.emit({
+              event: "chat.message",
+              payload: { sessionId: opts.sessionId, role: "assistant", content: event.text },
+              runId: opts.sessionId,
+              emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } else if (event.type === "tool_use") {
+            await opts.sink.emit({
+              event: "chat.tool",
+              payload: { phase: "use", name: event.name, input: event.input },
+              runId: opts.sessionId,
+              emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await opts.sink.emit({
+      event: "chat.error",
+      payload: { error: message },
+      runId: opts.sessionId,
+      emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { exitCode: 99, error: message };
+  }
+  const reply = replyParts.join("").trim();
+  if (!reply) {
+    const error = "Codex completed without producing a reply";
+    await opts.sink.emit({
+      event: "chat.error",
+      payload: { error },
+      runId: opts.sessionId,
+      emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { exitCode: 99, error };
+  }
+  await store.appendTurn({ role: "assistant", content: reply, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  await opts.sink.emit({
+    event: "chat.done",
+    payload: { sessionId: opts.sessionId },
+    runId: opts.sessionId,
+    emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { exitCode: 0, reply };
+}
+
+// src/chat/events.ts
+import * as fs13 from "fs";
+import * as path14 from "path";
 import posixPath2 from "path/posix";
 function eventsFilePath(cwd, sessionId) {
-  return path13.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
+  return path14.join(cwd, ".kody-engine", "runtime", "events", `${sessionId}.jsonl`);
 }
 var FileSink = class {
   constructor(file) {
@@ -21659,8 +21942,8 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs12.mkdirSync(path13.dirname(this.file), { recursive: true });
-    fs12.appendFileSync(this.file, `${JSON.stringify(event)}
+    fs13.mkdirSync(path14.dirname(this.file), { recursive: true });
+    fs13.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
 };
@@ -21718,15 +22001,15 @@ init_convex_client();
 import { anyApi as anyApi2 } from "convex/server";
 
 // src/chat/session.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import posixPath3 from "path/posix";
 function sessionFilePath(cwd, sessionId) {
-  return path14.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
+  return path15.join(cwd, ".kody-engine", "runtime", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs13.existsSync(file)) return null;
-  const raw = fs13.readFileSync(file, "utf-8");
+  if (!fs14.existsSync(file)) return null;
+  const raw = fs14.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -21739,8 +22022,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs13.existsSync(file)) return [];
-  const raw = fs13.readFileSync(file, "utf-8").trim();
+  if (!fs14.existsSync(file)) return [];
+  const raw = fs14.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -21756,14 +22039,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs13.mkdirSync(path14.dirname(file), { recursive: true });
+  fs14.mkdirSync(path15.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs13.appendFileSync(file, `${line}
+  fs14.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -21996,7 +22279,7 @@ function buildImplementationCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs14.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs15.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() });
@@ -22018,6 +22301,9 @@ function buildImplementationCatalog() {
   }
   return lines.join("\n");
 }
+function shouldWriteTaskArtifacts(driver) {
+  return driver !== "codex-app-server";
+}
 async function runChatTurn(opts) {
   const store = opts.store ?? createSessionStore({ sessionId: opts.sessionId, sessionFile: opts.sessionFile });
   const turns = await store.readTurns();
@@ -22041,11 +22327,11 @@ async function runChatTurn(opts) {
     taskKey: `sessions/${opts.sessionId}`
   };
   initializeTaskArtifacts(taskArtifactsPaths, { taskType: "chat", target: opts.sessionId });
-  const artifactAddendum = taskArtifactsPromptAddendum({
+  const artifactAddendum = shouldWriteTaskArtifacts(opts.driver) ? taskArtifactsPromptAddendum({
     taskId: taskArtifactsPaths.taskId,
     taskType: "chat",
     relDir: taskArtifactsPaths.relDir
-  });
+  }) : null;
   const contextBlock = readContextBlock(opts.cwd);
   const memoryBlock = readMemoryIndexBlock(opts.cwd);
   const instructionsBlock = readInstructionsBlock(opts.cwd);
@@ -22074,6 +22360,14 @@ async function runChatTurn(opts) {
     artifactAddendum
   ].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
   const prompt = buildPrompt(promptTurns);
+  if (opts.driver === "codex-app-server") {
+    return runCodexChatTurn({
+      opts,
+      turns: promptTurns,
+      systemPrompt,
+      store
+    });
+  }
   if (opts.model.protocol === "openai" && opts.litellmUrl) {
     return runOpenAIChatTurn({
       opts,
@@ -22092,7 +22386,7 @@ async function runChatTurn(opts) {
     quiet: opts.quiet,
     additionalDirectories: [
       taskArtifactsPaths.absDir,
-      ...Array.from(new Set(imagePaths.map((p2) => path15.dirname(p2))))
+      ...Array.from(new Set(imagePaths.map((p2) => path16.dirname(p2))))
     ],
     systemPromptAppend: systemPrompt,
     ...opts.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {},
@@ -22275,10 +22569,10 @@ async function emit(sink, type, sessionId, suffix, payload) {
 var MEMORY_INDEX_REL = ".kody-engine/runtime/memory/INDEX.md";
 var MAX_INDEX_BYTES = 8e3;
 function readMemoryIndexBlock(cwd) {
-  const indexPath = path15.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path16.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs14.readFileSync(indexPath, "utf-8");
+    raw = fs15.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -22298,17 +22592,17 @@ _\u2026 (memory index truncated; use recall_search to read more)_` : trimmed;
 var CONTEXT_DIR_REL = ".kody-engine/runtime/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path15.join(cwd, CONTEXT_DIR_REL);
+  const dir = path16.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs14.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs15.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs14.readFileSync(path15.join(dir, file), "utf-8").trim();
+      const content = fs15.readFileSync(path16.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -22334,7 +22628,7 @@ var SYSTEM_PROMPT_OVERRIDE_REL = ".kody-engine/runtime/system-prompt.md";
 function readSystemPromptOverride(cwd) {
   let raw;
   try {
-    raw = fs14.readFileSync(path15.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
+    raw = fs15.readFileSync(path16.join(cwd, SYSTEM_PROMPT_OVERRIDE_REL), "utf-8");
   } catch {
     return null;
   }
@@ -22342,10 +22636,10 @@ function readSystemPromptOverride(cwd) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path15.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path16.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs14.readFileSync(instructionsPath, "utf-8");
+    raw = fs15.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -22363,13 +22657,28 @@ _\u2026 (instructions truncated)_` : trimmed;
   ].join("\n");
 }
 
+// src/chat/runtime-drivers.ts
+var RUNTIME_DRIVERS = {
+  native: "native",
+  "codex app-server": "codex-app-server",
+  "codex-app-server": "codex-app-server"
+};
+function resolveBrainDriver(runtime) {
+  const normalized = runtime.trim().toLowerCase();
+  const driver = RUNTIME_DRIVERS[normalized];
+  if (!driver) {
+    throw new Error(`Unsupported Brain runtime: ${runtime}`);
+  }
+  return driver;
+}
+
 // src/servers/brain-serve.ts
 init_config();
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync24 } from "child_process";
-import * as fs46 from "fs";
-import * as path45 from "path";
+import * as fs47 from "fs";
+import * as path46 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -22496,7 +22805,7 @@ init_config();
 
 // src/dispatch.ts
 init_config();
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -22598,10 +22907,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs15.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs16.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs16.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -22725,7 +23034,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 || !fs15.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs16.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -22733,7 +23042,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs16.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -22787,7 +23096,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listImplementations()) {
     let raw;
     try {
-      raw = fs15.readFileSync(exe.profilePath, "utf-8");
+      raw = fs16.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -23171,9 +23480,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs46.existsSync(path45.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs46.existsSync(path45.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs46.existsSync(path45.join(cwd, "bun.lockb"))) return "bun";
+  if (fs47.existsSync(path46.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs47.existsSync(path46.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs47.existsSync(path46.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shouldChainScheduledWatch(match) {
@@ -23266,8 +23575,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = lastRunLogPath(cwd);
   let tail = "";
   try {
-    if (fs46.existsSync(logPath)) {
-      const content = fs46.readFileSync(logPath, "utf-8");
+    if (fs47.existsSync(logPath)) {
+      const content = fs47.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -23296,7 +23605,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path45.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path46.resolve(args.cwd) : process.cwd();
   try {
     const n = unpackAllSecrets();
     if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
@@ -23355,9 +23664,9 @@ async function runCi(argv) {
       forceRunCliArgs = { goal: envForceMessage };
     }
   }
-  if (!args.issueNumber && !autoFallback && !forceRunAction && !runRequestFanOut && eventName === "workflow_dispatch" && dispatchEventPath && fs46.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && !forceRunAction && !runRequestFanOut && eventName === "workflow_dispatch" && dispatchEventPath && fs47.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs46.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs47.readFileSync(dispatchEventPath, "utf-8"));
       const inputs = objectValue2(evt.inputs);
       const issueInput = parseInt(String(inputs?.issue_number ?? ""), 10);
       const sessionInput = String(inputs?.sessionId ?? "");
@@ -23730,8 +24039,8 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 init_runtimePaths();
-import * as fs47 from "fs";
-import * as path46 from "path";
+import * as fs48 from "fs";
+import * as path47 from "path";
 import posixPath4 from "path/posix";
 var live = /* @__PURE__ */ new Map();
 function brainEventsFilePath(dir, chatId) {
@@ -23739,8 +24048,8 @@ function brainEventsFilePath(dir, chatId) {
 }
 function lastPersistedSeq(dir, chatId) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs47.existsSync(p)) return 0;
-  const lines = fs47.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs48.existsSync(p)) return 0;
+  const lines = fs48.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -23750,9 +24059,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = brainEventsFilePath(dir, chatId);
-  if (!fs47.existsSync(p)) return [];
+  if (!fs48.existsSync(p)) return [];
   const out = [];
-  for (const line of fs47.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs48.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -23778,12 +24087,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = brainEventsFilePath(dir, chatId);
-  fs47.mkdirSync(path46.dirname(p), { recursive: true });
+  fs48.mkdirSync(path47.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs47.appendFileSync(p, `${JSON.stringify(rec)}
+      fs48.appendFileSync(p, `${JSON.stringify(rec)}
 `);
     } catch (err) {
       process.stderr.write(
@@ -23822,7 +24131,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs47.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
+    fs48.appendFileSync(brainEventsFilePath(dir, chatId), `${JSON.stringify(rec)}
 `);
   } catch {
   }
@@ -24019,9 +24328,14 @@ var BrokerSink = class {
     const be = translateChatEvent(event, this.chatId);
     if (!be) return;
     this.emitToLog(be);
-    if (this.tenantId) await createStateBackendFromEnv().appendChatEvent(this.tenantId, this.chatId, be);
+    if (this.tenantId && hasStateBackendConfig()) {
+      await createStateBackendFromEnv().appendChatEvent(this.tenantId, this.chatId, be);
+    }
   }
 };
+function hasStateBackendConfig(env = process.env) {
+  return Boolean(env.CONVEX_URL?.trim() && env.KODY_SERVICE_KEY?.trim());
+}
 var chatQueues = /* @__PURE__ */ new Map();
 function enqueue(chatId, fn) {
   const prev = chatQueues.get(chatId) ?? Promise.resolve();
@@ -24081,8 +24395,18 @@ async function handleChatTurn(req, res, chatId, opts) {
   const dashboardUrl = strField(body, "dashboardUrl");
   const storeRepoUrl = strField(body, "storeRepoUrl");
   const storeRef = strField(body, "storeRef");
+  const runtime = strField(body, "runtime");
   const allowCrossRepo = boolField(body, "allowCrossRepo");
   const agentIdentity = agentIdentityField(body);
+  let turnDriver = opts.driver;
+  if (runtime) {
+    try {
+      turnDriver = resolveBrainDriver(runtime);
+    } catch (err) {
+      sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+  }
   openSseStream(res, chatId);
   if (repo) {
     emitSse(res, {
@@ -24112,7 +24436,6 @@ async function handleChatTurn(req, res, chatId, opts) {
   }
   const stateToken = repoToken || envGithubToken();
   const sessionFile = sessionFilePath(agentCwd, chatId);
-  const brainEventsFile = brainEventsFilePath(agentCwd, chatId);
   const sessionStore = createSessionStore({
     sessionId: chatId,
     sessionFile,
@@ -24142,6 +24465,7 @@ async function handleChatTurn(req, res, chatId, opts) {
         ...allowCrossRepo ? { enableFetchRepoTool: true } : {},
         repoToken,
         ...agentIdentity ? { agentIdentity } : {},
+        ...turnDriver ? { driver: turnDriver } : {},
         ...dashboardUrl && repo && stateToken ? {
           cmsDashboardUrl: dashboardUrl,
           cmsRepoSlug: repo,
@@ -24168,7 +24492,7 @@ async function handleChatTurn(req, res, chatId, opts) {
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path47.join(path47.dirname(path47.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path48.join(path48.dirname(path48.resolve(opts.cwd)), "repos");
   return createServer2(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -24196,7 +24520,8 @@ function buildServer(opts) {
         cloneRepo,
         model: opts.model,
         litellmUrl: opts.litellmUrl,
-        runTurn
+        runTurn,
+        driver: opts.driver
       });
       return;
     }
@@ -24223,11 +24548,12 @@ async function brainServe(opts) {
   }
   const apiKey = getApiKey();
   const port = Number(process.env.PORT ?? DEFAULT_PORT);
+  const driver = process.env.BRAIN_DRIVER?.trim() === "codex-app-server" ? "codex-app-server" : "native";
   const model = parseModelRuntimeConfig(
     process.env.MODEL?.trim() || "claude/claude-haiku-4-5-20251001",
     process.env.KODY_MODEL_CONFIG
   );
-  const usesProxy = needsLitellmProxy(model);
+  const usesProxy = driver === "native" && needsLitellmProxy(model);
   let handle = null;
   if (usesProxy) {
     process.stdout.write(`[brain-serve] starting LiteLLM proxy for ${model.provider}/${model.model}...
@@ -24243,7 +24569,8 @@ async function brainServe(opts) {
     // Per-repo clones live here; defaults to a `repos` sibling of cwd.
     reposRoot: process.env.BRAIN_REPOS_ROOT?.trim() || void 0,
     model,
-    litellmUrl
+    litellmUrl,
+    driver
   });
   await new Promise((resolve16) => {
     server.listen(port, "0.0.0.0", () => {
@@ -24768,8 +25095,8 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import * as fs48 from "fs";
-import * as path48 from "path";
+import * as fs49 from "fs";
+import * as path49 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync25 } from "child_process";
@@ -25041,7 +25368,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path48.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path49.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const runRequest = readRunRequestFromEnv();
   if (runRequest && "request" in runRequest) {
@@ -25102,7 +25429,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs48.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs49.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -25148,8 +25475,8 @@ init_config();
 // src/definition-hydration.ts
 init_state_backend();
 import { createHash as createHash5 } from "crypto";
-import * as fs49 from "fs";
-import * as path49 from "path";
+import * as fs50 from "fs";
+import * as path50 from "path";
 var SLUG_RE2 = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 function assertSafeDefinitionPath(filePath) {
   const segments = filePath.split("/");
@@ -25183,32 +25510,32 @@ function writeDefinition(root, kind, definition) {
   if (kind === "agent") {
     const raw = bundle.files["agent.md"];
     if (typeof raw !== "string") throw new Error(`agent definition ${definition.slug} is missing agent.md`);
-    fs49.writeFileSync(path49.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
+    fs50.writeFileSync(path50.join(root, "agents", `${definition.slug}.md`), raw, "utf8");
     return;
   }
   if (kind === "goal") {
-    const goalRoot = path49.join(root, "goals", definition.slug);
+    const goalRoot = path50.join(root, "goals", definition.slug);
     for (const [filePath, contents] of Object.entries(bundle.files)) {
-      const target = path49.join(goalRoot, filePath);
-      fs49.mkdirSync(path49.dirname(target), { recursive: true });
-      fs49.writeFileSync(target, contents, "utf8");
+      const target = path50.join(goalRoot, filePath);
+      fs50.mkdirSync(path50.dirname(target), { recursive: true });
+      fs50.writeFileSync(target, contents, "utf8");
     }
     return;
   }
-  const capabilityRoot = path49.join(root, "capabilities", definition.slug);
+  const capabilityRoot = path50.join(root, "capabilities", definition.slug);
   for (const [filePath, contents] of Object.entries(bundle.files)) {
-    const target = path49.join(capabilityRoot, filePath);
-    fs49.mkdirSync(path49.dirname(target), { recursive: true });
-    fs49.writeFileSync(target, contents, "utf8");
+    const target = path50.join(capabilityRoot, filePath);
+    fs50.mkdirSync(path50.dirname(target), { recursive: true });
+    fs50.writeFileSync(target, contents, "utf8");
   }
 }
 async function hydrateDefinitions(options) {
-  const root = path49.join(options.cwd, ".kody-engine", "definitions");
+  const root = path50.join(options.cwd, ".kody-engine", "definitions");
   const staging = `${root}.tmp-${process.pid}-${Date.now()}`;
-  fs49.rmSync(staging, { recursive: true, force: true });
-  fs49.mkdirSync(path49.join(staging, "agents"), { recursive: true });
-  fs49.mkdirSync(path49.join(staging, "capabilities"), { recursive: true });
-  fs49.mkdirSync(path49.join(staging, "goals"), { recursive: true });
+  fs50.rmSync(staging, { recursive: true, force: true });
+  fs50.mkdirSync(path50.join(staging, "agents"), { recursive: true });
+  fs50.mkdirSync(path50.join(staging, "capabilities"), { recursive: true });
+  fs50.mkdirSync(path50.join(staging, "goals"), { recursive: true });
   try {
     const [capabilities, agents, goals] = await Promise.all([
       options.backend.listDefinitions(options.tenantId, "capability"),
@@ -25234,13 +25561,13 @@ async function hydrateDefinitions(options) {
       hydratedAt: (/* @__PURE__ */ new Date()).toISOString(),
       versions: Object.fromEntries(Object.entries(versions).sort(([left], [right]) => left.localeCompare(right)))
     };
-    fs49.writeFileSync(path49.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    fs50.writeFileSync(path50.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-    fs49.rmSync(root, { recursive: true, force: true });
-    fs49.renameSync(staging, root);
+    fs50.rmSync(root, { recursive: true, force: true });
+    fs50.renameSync(staging, root);
     return { root, tenantId: options.tenantId, versions: manifest.versions };
   } catch (error) {
-    fs49.rmSync(staging, { recursive: true, force: true });
+    fs50.rmSync(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -25334,8 +25661,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path50, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path50}`, {
+  async call(path51, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path51}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -25346,7 +25673,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text2 = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path50}: ${text2.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path51}: ${text2.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -26098,8 +26425,8 @@ async function poolServe() {
 }
 
 // src/servers/runner-serve.ts
-import { spawn as spawn8 } from "child_process";
-import * as fs50 from "fs";
+import { spawn as spawn9 } from "child_process";
+import * as fs51 from "fs";
 import { createServer as createServer6 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
@@ -26234,8 +26561,8 @@ async function defaultRunJob(job) {
   const workdir = process.env.RUNNER_WORKDIR ?? DEFAULT_WORKDIR;
   const branch = job.ref ?? "main";
   const authUrl = `https://x-access-token:${job.githubToken}@github.com/${job.repo}.git`;
-  fs50.rmSync(workdir, { recursive: true, force: true });
-  fs50.mkdirSync(workdir, { recursive: true });
+  fs51.rmSync(workdir, { recursive: true, force: true });
+  fs51.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const target = job.runRequest.target;
   const interactive = target.type === "chat";
@@ -26265,7 +26592,7 @@ async function defaultRunJob(job) {
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
   const run = (cmd, args, cwd) => new Promise((resolve16) => {
-    const child = spawn8(cmd, args, { stdio: "inherit", env: childEnv, cwd });
+    const child = spawn9(cmd, args, { stdio: "inherit", env: childEnv, cwd });
     child.on("exit", (code) => resolve16(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
@@ -26368,7 +26695,7 @@ async function runnerServe() {
 // src/servers/serve.ts
 init_config();
 init_litellm();
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 function parseTarget2(positional) {
   if (!Array.isArray(positional) || positional.length === 0) return "none";
   const first = String(positional[0]).toLowerCase();
@@ -26418,7 +26745,7 @@ async function serve(opts) {
     if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
-    const child = spawn9("claude", args, { stdio: "inherit", env: editorEnv, cwd: opts.cwd });
+    const child = spawn10("claude", args, { stdio: "inherit", env: editorEnv, cwd: opts.cwd });
     const exitCode = await new Promise((resolve16) => {
       child.on("exit", (code) => resolve16(code ?? 0));
       child.on("error", (err) => {
@@ -26438,7 +26765,7 @@ async function serve(opts) {
     if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
 `);
     try {
-      const code = spawn9("code", [opts.cwd], { stdio: "inherit", env: editorEnv, detached: true });
+      const code = spawn10("code", [opts.cwd], { stdio: "inherit", env: editorEnv, detached: true });
       code.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch VS Code: ${err.message}
 `);