npm - @kody-ade/kody-engine - Versions diffs - 0.4.141 → 0.4.142 - Mend

@kody-ade/kody-engine 0.4.141 → 0.4.142

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/bin/kody.js +585 -442
package/package.json +1 -1

package/dist/bin/kody.js CHANGED Viewed

@@ -93,7 +93,7 @@ var init_events = __esm({
 // src/verify.ts
 import { spawn } from "child_process";
 function runCommand(command, cwd) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const start = Date.now();
     const child = spawn(command, {
       cwd,
@@ -122,11 +122,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve5({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve6({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve5({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve6({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -358,6 +358,141 @@ var init_submitMcp = __esm({
   }
 });
+// src/repoWorkspace.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+import * as fs6 from "fs";
+import * as path6 from "path";
+async function resolveAndClone(reposRoot, repo, repoToken, cloneRepo) {
+  const name = repo?.trim();
+  if (!name || !REPO_RE.test(name)) return null;
+  const root = path6.resolve(reposRoot);
+  const dir = path6.resolve(root, name);
+  if (dir !== root && !dir.startsWith(root + path6.sep)) return null;
+  if (fs6.existsSync(path6.join(dir, ".git"))) return dir;
+  const inflight = repoClones.get(dir);
+  if (inflight) {
+    await inflight;
+    return dir;
+  }
+  const p = cloneRepo(name, repoToken, dir).finally(() => {
+    if (repoClones.get(dir) === p) repoClones.delete(dir);
+  });
+  repoClones.set(dir, p);
+  await p;
+  return dir;
+}
+async function ensureRepoCwd(opts) {
+  const dir = await resolveAndClone(
+    opts.reposRoot,
+    opts.repo,
+    opts.repoToken,
+    opts.cloneRepo
+  );
+  return dir ?? opts.baseCwd;
+}
+async function fetchRepo(opts) {
+  const dir = await resolveAndClone(
+    opts.reposRoot,
+    opts.repo,
+    opts.repoToken,
+    opts.cloneRepo ?? defaultCloneRepo
+  );
+  if (!dir) {
+    throw new Error(
+      `invalid repo "${opts.repo}" \u2014 expected "owner/name" with no path escapes`
+    );
+  }
+  return dir;
+}
+var REPO_RE, repoClones, defaultCloneRepo;
+var init_repoWorkspace = __esm({
+  "src/repoWorkspace.ts"() {
+    "use strict";
+    REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+    repoClones = /* @__PURE__ */ new Map();
+    defaultCloneRepo = (repo, token, dir) => {
+      fs6.mkdirSync(path6.dirname(dir), { recursive: true });
+      const authUrl = token ? `https://x-access-token:${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
+      return new Promise((resolve6, reject) => {
+        const child = spawn2("git", ["clone", "--depth=1", authUrl, dir], {
+          stdio: "inherit"
+        });
+        child.on("exit", (code) => {
+          if (code !== 0) {
+            reject(new Error(`git clone ${repo} failed (exit ${code})`));
+            return;
+          }
+          try {
+            const name = process.env.GIT_AUTHOR_NAME ?? "Kody Bot";
+            const email = process.env.GIT_AUTHOR_EMAIL ?? "kody-bot@users.noreply.github.com";
+            spawnSync("git", ["-C", dir, "config", "user.name", name]);
+            spawnSync("git", ["-C", dir, "config", "user.email", email]);
+          } catch {
+          }
+          resolve6();
+        });
+        child.on("error", reject);
+      });
+    };
+  }
+});
+// src/fetchRepoMcp.ts
+var fetchRepoMcp_exports = {};
+__export(fetchRepoMcp_exports, {
+  buildFetchRepoMcpServer: () => buildFetchRepoMcpServer
+});
+import {
+  createSdkMcpServer as createSdkMcpServer3,
+  tool as tool3
+} from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
+function buildFetchRepoMcpServer(opts) {
+  const fetchTool = tool3(
+    "fetch_repo",
+    'Clone another GitHub repository into your workspace so you can read and work on it. Pass `repo` as "owner/name" (e.g. "A-Guy-educ/A-Guy"). Returns the absolute path of the clone \u2014 then use your Read/Grep/Glob/Bash tools at that path to inspect it. Already-fetched repos are reused instantly. Use this whenever the user asks about a repository other than your current one \u2014 you are NOT limited to a single repo.',
+    {
+      repo: z3.string().describe('GitHub repository as "owner/name", e.g. "A-Guy-educ/A-Guy".')
+    },
+    async (args) => {
+      const repo = String(args.repo ?? "").trim();
+      try {
+        const dir = await fetchRepo({
+          reposRoot: opts.reposRoot,
+          repo,
+          repoToken: opts.repoToken
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Cloned ${repo} \u2192 ${dir}
+Use Read/Grep/Glob/Bash at that absolute path to explore it. It now lives in your workspace alongside any other repos you've fetched.`
+            }
+          ]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Could not fetch ${repo}: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  return createSdkMcpServer3({
+    name: "kody-fetch-repo",
+    version: "0.1.0",
+    tools: [fetchTool]
+  });
+}
+var init_fetchRepoMcp = __esm({
+  "src/fetchRepoMcp.ts"() {
+    "use strict";
+    init_repoWorkspace();
+  }
+});
 // src/issue.ts
 import { execFileSync } from "child_process";
 function ghToken() {
@@ -515,16 +650,16 @@ var init_issue = __esm({
 });
 // src/prompt.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path18.join(projectDir, rel);
-    if (!fs19.existsSync(abs)) continue;
+    const abs = path19.join(projectDir, rel);
+    if (!fs20.existsSync(abs)) continue;
     let content;
     try {
-      content = fs19.readFileSync(abs, "utf-8");
+      content = fs20.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -672,28 +807,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs31.statSync(file);
+      stat = fs32.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs31.readFileSync(file, "utf-8");
+      raw = fs32.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() ?? path29.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path30.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path29.relative(memoryAbs, file),
+      relPath: path30.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -761,16 +896,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs31.readdirSync(dir);
+      names = fs32.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path29.join(dir, name);
+      const full = path30.join(dir, name);
       let stat;
       try {
-        stat = fs31.statSync(full);
+        stat = fs32.statSync(full);
       } catch {
         continue;
       }
@@ -793,8 +928,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path29.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs31.existsSync(memoryAbs)) {
+      const memoryAbs = path30.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs32.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -926,7 +1061,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.141",
+  version: "0.4.142",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -983,8 +1118,8 @@ var package_default = {
 // src/chat-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs41 from "fs";
-import * as path37 from "path";
+import * as fs42 from "fs";
+import * as path38 from "path";
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1050,8 +1185,8 @@ function makeRunId(sessionId, suffix) {
 }
 // src/chat/loop.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 // src/task-artifacts.ts
 import fs2 from "fs";
@@ -1142,8 +1277,8 @@ function taskArtifactsPromptAddendum(opts) {
 }
 // src/agent.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 // src/claudeBinary.ts
@@ -1528,10 +1663,10 @@ function resolveTurnTimeoutMs(opts) {
   return DEFAULT_TURN_TIMEOUT_MS;
 }
 async function runAgent(opts) {
-  const ndjsonDir = opts.ndjsonDir ?? path6.join(opts.cwd, ".kody");
-  fs6.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path6.join(ndjsonDir, "last-run.jsonl");
-  const fullLog = fs6.createWriteStream(ndjsonPath, { flags: "w" });
+  const ndjsonDir = opts.ndjsonDir ?? path7.join(opts.cwd, ".kody");
+  fs7.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path7.join(ndjsonDir, "last-run.jsonl");
+  const fullLog = fs7.createWriteStream(ndjsonPath, { flags: "w" });
   const env = {
     ...process.env,
     SKIP_HOOKS: "1",
@@ -1565,7 +1700,9 @@ async function runAgent(opts) {
     const queryOptions = {
       model: opts.model.model,
       cwd: opts.cwd,
-      allowedTools: opts.allowedToolsOverride ?? DEFAULT_ALLOWED_TOOLS,
+      // Fresh array (never mutate the shared DEFAULT_ALLOWED_TOOLS const) so
+      // opt-in tools like fetch_repo can be appended below.
+      allowedTools: [...opts.allowedToolsOverride ?? DEFAULT_ALLOWED_TOOLS],
       permissionMode: opts.permissionModeOverride ?? "acceptEdits",
       env
     };
@@ -1594,6 +1731,16 @@ async function runAgent(opts) {
       getSubmitted = submitHandle.getSubmitted;
       mcpEntries.push(["kody-submit", submitHandle.server]);
     }
+    if (opts.enableFetchRepoTool && opts.reposRoot) {
+      const { buildFetchRepoMcpServer: buildFetchRepoMcpServer2 } = await Promise.resolve().then(() => (init_fetchRepoMcp(), fetchRepoMcp_exports));
+      const fetchServer = buildFetchRepoMcpServer2({
+        reposRoot: opts.reposRoot,
+        repoToken: opts.repoToken
+      });
+      mcpEntries.push(["kody-fetch-repo", fetchServer]);
+      queryOptions.allowedTools.push("mcp__kody-fetch-repo__fetch_repo");
+      queryOptions.additionalDirectories = [opts.reposRoot];
+    }
     if (mcpEntries.length > 0) {
       queryOptions.mcpServers = Object.fromEntries(mcpEntries);
     }
@@ -1641,10 +1788,10 @@ async function runAgent(opts) {
       let timer;
       let next;
       if (turnTimeoutMs > 0) {
-        const timeoutPromise = new Promise((resolve5) => {
+        const timeoutPromise = new Promise((resolve6) => {
           timer = setTimeout(() => {
             timedOut = true;
-            resolve5({ done: true, value: void 0 });
+            resolve6({ done: true, value: void 0 });
           }, turnTimeoutMs);
         });
         next = await Promise.race([nextPromise, timeoutPromise]);
@@ -1774,48 +1921,48 @@ async function runAgent(opts) {
 }
 // src/registry.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 function getExecutablesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path8.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "executables"),
+    path8.join(here, "executables"),
     // dev: src/
-    path7.join(here, "..", "executables"),
+    path8.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path7.join(here, "..", "src", "executables")
+    path8.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path7.join(process.cwd(), ".kody", "executables");
+  return path8.join(process.cwd(), ".kody", "executables");
 }
 function getBuiltinJobsRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path8.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "jobs"),
+    path8.join(here, "jobs"),
     // dev: src/
-    path7.join(here, "..", "jobs"),
+    path8.join(here, "..", "jobs"),
     // built: dist/bin → dist/jobs
-    path7.join(here, "..", "src", "jobs")
+    path8.join(here, "..", "src", "jobs")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
+  for (const ent of fs8.readdirSync(root, { withFileTypes: true })) {
     if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
     const slug = ent.name.slice(0, -3);
-    out.push({ slug, filePath: path7.join(root, ent.name) });
+    out.push({ slug, filePath: path8.join(root, ent.name) });
   }
   out.sort((a, b) => a.slug.localeCompare(b.slug));
   return out;
@@ -1828,13 +1975,13 @@ function listExecutables(roots = getExecutableRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs7.existsSync(root)) continue;
-    const entries = fs7.readdirSync(root, { withFileTypes: true });
+    if (!fs8.existsSync(root)) continue;
+    const entries = fs8.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
-      const profilePath = path7.join(root, ent.name, "profile.json");
-      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
+      const profilePath = path8.join(root, ent.name, "profile.json");
+      if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -1846,8 +1993,8 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
   if (!isSafeName(name)) return null;
   const rootList = typeof roots === "string" ? [roots] : roots;
   for (const root of rootList) {
-    const profilePath = path7.join(root, name, "profile.json");
-    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
+    const profilePath = path8.join(root, name, "profile.json");
+    if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -1863,7 +2010,7 @@ function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -1893,14 +2040,14 @@ function parseGenericFlags(argv) {
 }
 // src/chat/session.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path8.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path9.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs8.existsSync(file)) return null;
-  const raw = fs8.readFileSync(file, "utf-8");
+  if (!fs9.existsSync(file)) return null;
+  const raw = fs9.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -1913,8 +2060,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs8.existsSync(file)) return [];
-  const raw = fs8.readFileSync(file, "utf-8").trim();
+  if (!fs9.existsSync(file)) return [];
+  const raw = fs9.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -1930,14 +2077,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs9.mkdirSync(path9.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs8.appendFileSync(file, `${line}
+  fs9.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -2037,6 +2184,15 @@ var CHAT_SYSTEM_PROMPT = [
   "Do not invent file paths, commit SHAs, line numbers, or command output. If you",
   "cite something concrete, you must have just read or run it in this session."
 ].join("\n");
+var CROSS_REPO_PROMPT = [
+  "# Working across repositories",
+  "You are NOT limited to the repository at your current working directory. You",
+  'have a `fetch_repo` tool: call fetch_repo("owner/name") to clone another repo',
+  "into your workspace; it returns an absolute path. Then use Read/Grep/Glob/Bash",
+  "at that path to inspect or work on it. Already-fetched repos are reused",
+  "instantly. When the user asks about a different repo \u2014 or to compare repos \u2014",
+  "fetch it instead of saying you are scoped to a single repo."
+].join("\n");
 function buildExecutableCatalog() {
   let discovered;
   try {
@@ -2047,7 +2203,7 @@ function buildExecutableCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs10.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() });
@@ -2093,11 +2249,13 @@ async function runChatTurn(opts) {
   const contextBlock = readContextBlock(opts.cwd);
   const memoryBlock = readMemoryIndexBlock(opts.cwd);
   const instructionsBlock = readInstructionsBlock(opts.cwd);
+  const crossRepoBlock = opts.reposRoot ? CROSS_REPO_PROMPT : null;
   const systemPrompt = [
     basePrompt,
     contextBlock,
     memoryBlock,
     instructionsBlock,
+    crossRepoBlock,
     catalog,
     artifactAddendum
   ].filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
@@ -2111,6 +2269,14 @@ async function runChatTurn(opts) {
     verbose: opts.verbose,
     quiet: opts.quiet,
     systemPromptAppend: systemPrompt,
+    // Let the agent clone + work on OTHER repos mid-conversation (a
+    // repo-less Brain serves many). Enabled whenever we know where repos
+    // live; grants read access to that root via additionalDirectories.
+    ...opts.reposRoot ? {
+      enableFetchRepoTool: true,
+      reposRoot: opts.reposRoot,
+      repoToken: opts.repoToken
+    } : {},
     onProgress: async (ev) => {
       progressSeq += 1;
       if (ev.kind === "thinking") {
@@ -2195,10 +2361,10 @@ async function emit(sink, type, sessionId, suffix, payload) {
 var MEMORY_INDEX_REL = ".kody/memory/INDEX.md";
 var MAX_INDEX_BYTES = 8e3;
 function readMemoryIndexBlock(cwd) {
-  const indexPath = path9.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path10.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs9.readFileSync(indexPath, "utf-8");
+    raw = fs10.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -2216,17 +2382,17 @@ function readMemoryIndexBlock(cwd) {
 var CONTEXT_DIR_REL = ".kody/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path9.join(cwd, CONTEXT_DIR_REL);
+  const dir = path10.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs9.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs10.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs9.readFileSync(path9.join(dir, file), "utf-8").trim();
+      const content = fs10.readFileSync(path10.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 ${content}`);
@@ -2247,10 +2413,10 @@ ${content}`);
 var INSTRUCTIONS_REL = ".kody/instructions.md";
 var MAX_INSTRUCTIONS_BYTES = 8e3;
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path9.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path10.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs9.readFileSync(instructionsPath, "utf-8");
+    raw = fs10.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -2269,8 +2435,8 @@ function readInstructionsBlock(cwd) {
 // src/chat/modes/interactive.ts
 init_issue();
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 // src/chat/inbox.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -2318,7 +2484,7 @@ async function waitForNextUserMessage(opts) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function currentBranch(cwd) {
   try {
@@ -2429,9 +2595,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, _verbose) {
-  const sessionRel = path10.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path10.relative(cwd, eventsFilePath(cwd, sessionId));
-  const rels = [sessionRel, eventsRel].filter((p) => fs10.existsSync(path10.join(cwd, p)));
+  const sessionRel = path11.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path11.relative(cwd, eventsFilePath(cwd, sessionId));
+  const rels = [sessionRel, eventsRel].filter((p) => fs11.existsSync(path11.join(cwd, p)));
   if (rels.length === 0) return;
   const repository = process.env.GITHUB_REPOSITORY;
   if (!repository) {
@@ -2443,8 +2609,8 @@ function commitTurn(cwd, sessionId, _verbose) {
   }
   const branch = defaultBranch(cwd) ?? "main";
   for (const rel of rels) {
-    const repoPath = rel.split(path10.sep).join("/");
-    const localText = fs10.readFileSync(path10.join(cwd, rel), "utf-8");
+    const repoPath = rel.split(path11.sep).join("/");
+    const localText = fs11.readFileSync(path11.join(cwd, rel), "utf-8");
     putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
@@ -2534,11 +2700,11 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 // src/kody-cli.ts
 import { execFileSync as execFileSync29 } from "child_process";
-import * as fs40 from "fs";
-import * as path36 from "path";
+import * as fs41 from "fs";
+import * as path37 from "path";
 // src/dispatch.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -2622,10 +2788,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs11.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs12.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs11.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2699,7 +2865,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 || !fs11.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs12.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -2707,7 +2873,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs11.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -2745,7 +2911,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs11.readFileSync(exe.profilePath, "utf-8");
+      raw = fs12.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -2868,8 +3034,8 @@ init_issue();
 // src/executor.ts
 import { execFileSync as execFileSync28, spawn as spawn9 } from "child_process";
-import * as fs39 from "fs";
-import * as path35 from "path";
+import * as fs40 from "fs";
+import * as path36 from "path";
 // src/discipline.ts
 var DISCIPLINE = `# Working discipline (applies to this entire task)
@@ -2920,8 +3086,8 @@ init_events();
 init_issue();
 // src/profile.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path12 from "path";
 // src/profile-error.ts
 var ProfileError = class extends Error {
@@ -3089,12 +3255,12 @@ var KNOWN_PROFILE_KEYS = /* @__PURE__ */ new Set([
   "preloadContext"
 ]);
 function loadProfile(profilePath) {
-  if (!fs12.existsSync(profilePath)) {
+  if (!fs13.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs12.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs13.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -3105,7 +3271,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] ${path11.basename(path11.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path12.basename(path12.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -3166,7 +3332,7 @@ 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: path11.dirname(profilePath)
+    dir: path12.dirname(profilePath)
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -3536,10 +3702,10 @@ function errMsg(err) {
 }
 // src/litellm.ts
-import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
-import * as fs13 from "fs";
+import { execFileSync as execFileSync4, spawn as spawn3 } from "child_process";
+import * as fs14 from "fs";
 import * as os2 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -3586,20 +3752,20 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path12.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
-  fs13.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path13.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  fs14.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
-  const logPath = path12.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
-  const outFd = fs13.openSync(logPath, "w");
-  const child = spawn2(cmd, args, {
+  const logPath = path13.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const outFd = fs14.openSync(logPath, "w");
+  const child = spawn3(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs13.closeSync(outFd);
+  fs14.closeSync(outFd);
   const timeoutMs = resolveLitellmTimeoutMs();
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -3618,7 +3784,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs13.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs14.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -3630,10 +3796,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path12.join(projectDir, ".env");
-  if (!fs13.existsSync(dotenvPath)) return {};
+  const dotenvPath = path13.join(projectDir, ".env");
+  if (!fs14.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs13.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs14.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)=(.*)$/);
@@ -3656,25 +3822,25 @@ function stripBlockingEnv(env) {
 }
 // src/subagents.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as os3 from "os";
-import * as path13 from "path";
+import * as path14 from "path";
 function getPluginsCatalogRoot() {
-  const here = path13.dirname(new URL(import.meta.url).pathname);
+  const here = path14.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path13.join(here, "..", "plugins"),
+    path14.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path13.join(here, "..", "..", "plugins"),
+    path14.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path13.join(here, "..", "..", "src", "plugins")
+    path14.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs14.existsSync(c) && fs14.statSync(c).isDirectory()) return c;
+    if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -3684,45 +3850,45 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path13.join(os3.tmpdir(), `kody-synth-${runId}`);
-  fs14.mkdirSync(path13.join(root, ".claude-plugin"), { recursive: true });
+  const root = path14.join(os3.tmpdir(), `kody-synth-${runId}`);
+  fs15.mkdirSync(path14.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
-    const local = path13.join(profile.dir, bucket, entry);
-    if (fs14.existsSync(local)) return local;
-    const central = path13.join(catalog, bucket, entry);
-    if (fs14.existsSync(central)) return central;
+    const local = path14.join(profile.dir, bucket, entry);
+    if (fs15.existsSync(local)) return local;
+    const central = path14.join(catalog, bucket, entry);
+    if (fs15.existsSync(central)) return central;
     throw new Error(
       `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
     );
   };
   if (cc.skills.length > 0) {
-    const dst = path13.join(root, "skills");
-    fs14.mkdirSync(dst, { recursive: true });
+    const dst = path14.join(root, "skills");
+    fs15.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path13.join(dst, name));
+      copyDir(resolvePart("skills", name), path14.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path13.join(root, "commands");
-    fs14.mkdirSync(dst, { recursive: true });
+    const dst = path14.join(root, "commands");
+    fs15.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      fs14.copyFileSync(resolvePart("commands", `${name}.md`), path13.join(dst, `${name}.md`));
+      fs15.copyFileSync(resolvePart("commands", `${name}.md`), path14.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path13.join(root, "hooks");
-    fs14.mkdirSync(dst, { recursive: true });
+    const dst = path14.join(root, "hooks");
+    fs15.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
       const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs14.readFileSync(src, "utf-8"));
+      const parsed = JSON.parse(fs15.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);
       }
     }
-    fs14.writeFileSync(path13.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs15.writeFileSync(path14.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -3732,17 +3898,17 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   };
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-  fs14.writeFileSync(path13.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs15.writeFileSync(path14.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs14.mkdirSync(dst, { recursive: true });
-  for (const ent of fs14.readdirSync(src, { withFileTypes: true })) {
-    const s = path13.join(src, ent.name);
-    const d = path13.join(dst, ent.name);
+  fs15.mkdirSync(dst, { recursive: true });
+  for (const ent of fs15.readdirSync(src, { withFileTypes: true })) {
+    const s = path14.join(src, ent.name);
+    const d = path14.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs14.copyFileSync(s, d);
+    else if (ent.isFile()) fs15.copyFileSync(s, d);
   }
 }
@@ -3759,10 +3925,10 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile(profileDir, name) {
-  const local = path14.join(profileDir, "agents", `${name}.md`);
-  if (fs15.existsSync(local)) return local;
-  const central = path14.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs15.existsSync(central)) return central;
+  const local = path15.join(profileDir, "agents", `${name}.md`);
+  if (fs16.existsSync(local)) return local;
+  const central = path15.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs16.existsSync(central)) return central;
   throw new Error(
     `loadSubagents: agent '${name}' not found in ${profileDir}/agents/ or shared catalog`
   );
@@ -3772,7 +3938,7 @@ function loadSubagents(profile) {
   if (!names || names.length === 0) return void 0;
   const agents = {};
   for (const name of names) {
-    const { fm, body } = splitFrontmatter(fs15.readFileSync(resolveAgentFile(profile.dir, name), "utf-8"));
+    const { fm, body } = splitFrontmatter(fs16.readFileSync(resolveAgentFile(profile.dir, name), "utf-8"));
     if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
     const def = {
       description: fm.description ?? `Subagent ${name}`,
@@ -3868,8 +4034,8 @@ function pushWithRetry(opts = {}) {
 }
 // src/commit.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -3925,18 +4091,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path15.join(cwd ?? process.cwd(), ".git");
-  if (!fs16.existsSync(gitDir)) return aborted;
-  if (fs16.existsSync(path15.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path16.join(cwd ?? process.cwd(), ".git");
+  if (!fs17.existsSync(gitDir)) return aborted;
+  if (fs17.existsSync(path16.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs16.existsSync(path15.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs17.existsSync(path16.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs16.existsSync(path15.join(gitDir, "REVERT_HEAD"))) {
+  if (fs17.existsSync(path16.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs16.existsSync(path15.join(gitDir, "rebase-merge")) || fs16.existsSync(path15.join(gitDir, "rebase-apply"))) {
+  if (fs17.existsSync(path16.join(gitDir, "rebase-merge")) || fs17.existsSync(path16.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -3992,7 +4158,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs16.existsSync(path15.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs17.existsSync(path16.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -4290,22 +4456,22 @@ var advanceFlow = async (ctx, profile) => {
 };
 // src/scripts/brainServe.ts
+init_repoWorkspace();
 import { createServer } from "http";
-import { spawn as spawn3, spawnSync } from "child_process";
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 // src/scripts/brainTurnLog.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath(dir, chatId) {
-  return path16.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+  return path17.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath(dir, chatId);
-  if (!fs17.existsSync(p)) return 0;
-  const lines = fs17.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs18.existsSync(p)) return 0;
+  const lines = fs18.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -4315,9 +4481,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = eventsPath(dir, chatId);
-  if (!fs17.existsSync(p)) return [];
+  if (!fs18.existsSync(p)) return [];
   const out = [];
-  for (const line of fs17.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs18.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -4343,12 +4509,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath(dir, chatId);
-  fs17.mkdirSync(path16.dirname(p), { recursive: true });
+  fs18.mkdirSync(path17.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs17.appendFileSync(p, JSON.stringify(rec) + "\n");
+      fs18.appendFileSync(p, JSON.stringify(rec) + "\n");
     } catch (err) {
       process.stderr.write(
         `[brain-turn-log] append failed for ${chatId}: ${err instanceof Error ? err.message : String(err)}
@@ -4386,7 +4552,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs17.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
+    fs18.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
   } catch {
   }
   state.status = "ended";
@@ -4474,17 +4640,17 @@ function authOk(req, expected) {
   return false;
 }
 function readJsonBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve5({});
+        resolve6({});
         return;
       }
       try {
-        resolve5(JSON.parse(raw));
+        resolve6(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -4596,51 +4762,6 @@ function streamToRes(res, dir, chatId, since) {
   );
   res.on("close", unsubscribe);
 }
-var REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
-var repoClones = /* @__PURE__ */ new Map();
-async function ensureRepoCwd(opts) {
-  const repo = opts.repo?.trim();
-  if (!repo || !REPO_RE.test(repo)) return opts.baseCwd;
-  const root = path17.resolve(opts.reposRoot);
-  const dir = path17.resolve(root, repo);
-  if (dir !== root && !dir.startsWith(root + path17.sep)) return opts.baseCwd;
-  if (fs18.existsSync(path17.join(dir, ".git"))) return dir;
-  const inflight = repoClones.get(dir);
-  if (inflight) {
-    await inflight;
-    return dir;
-  }
-  const p = opts.cloneRepo(repo, opts.repoToken, dir).finally(() => {
-    if (repoClones.get(dir) === p) repoClones.delete(dir);
-  });
-  repoClones.set(dir, p);
-  await p;
-  return dir;
-}
-var defaultCloneRepo = (repo, token, dir) => {
-  fs18.mkdirSync(path17.dirname(dir), { recursive: true });
-  const authUrl = token ? `https://x-access-token:${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
-  return new Promise((resolve5, reject) => {
-    const child = spawn3("git", ["clone", "--depth=1", authUrl, dir], {
-      stdio: "inherit"
-    });
-    child.on("exit", (code) => {
-      if (code !== 0) {
-        reject(new Error(`git clone ${repo} failed (exit ${code})`));
-        return;
-      }
-      try {
-        const name = process.env.GIT_AUTHOR_NAME ?? "Kody Bot";
-        const email = process.env.GIT_AUTHOR_EMAIL ?? "kody-bot@users.noreply.github.com";
-        spawnSync("git", ["-C", dir, "config", "user.name", name]);
-        spawnSync("git", ["-C", dir, "config", "user.email", email]);
-      } catch {
-      }
-      resolve5();
-    });
-    child.on("error", reject);
-  });
-};
 async function handleChatTurn(req, res, chatId, opts) {
   let body;
   try {
@@ -4657,7 +4778,7 @@ async function handleChatTurn(req, res, chatId, opts) {
   const repo = strField(body, "repo");
   const repoToken = strField(body, "repoToken");
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs18.mkdirSync(path17.dirname(sessionFile), { recursive: true });
+  fs19.mkdirSync(path18.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -4681,7 +4802,10 @@ async function handleChatTurn(req, res, chatId, opts) {
         cwd: agentCwd,
         model: opts.model,
         litellmUrl: opts.litellmUrl,
-        sink
+        sink,
+        // Let the agent clone + work on OTHER repos via the fetch_repo tool.
+        reposRoot: opts.reposRoot,
+        repoToken
       });
     } catch (err) {
       const errMsg3 = err instanceof Error ? err.message : String(err);
@@ -4701,7 +4825,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 ?? path17.join(path17.dirname(path17.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path18.join(path18.dirname(path18.resolve(opts.cwd)), "repos");
   return createServer(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -4782,13 +4906,13 @@ var brainServe = async (ctx) => {
     model,
     litellmUrl
   });
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     server.listen(port, "0.0.0.0", () => {
       process.stdout.write(
         `[brain-serve] listening on 0.0.0.0:${port} (cwd=${ctx.cwd})
 `
       );
-      resolve5();
+      resolve6();
     });
   });
   const shutdown = (signal) => {
@@ -4956,13 +5080,13 @@ function defaultLabelMap() {
 }
 // src/scripts/commitAndPush.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 init_events();
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path19.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+  return path20.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
 var commitAndPush2 = async (ctx, profile) => {
   const branch = ctx.data.branch;
@@ -4972,9 +5096,9 @@ var commitAndPush2 = async (ctx, profile) => {
   }
   const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
   const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-  if (sentinel && fs20.existsSync(sentinel)) {
+  if (sentinel && fs21.existsSync(sentinel)) {
     try {
-      const replay = JSON.parse(fs20.readFileSync(sentinel, "utf-8"));
+      const replay = JSON.parse(fs21.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;
@@ -5027,8 +5151,8 @@ var commitAndPush2 = async (ctx, profile) => {
   const result = ctx.data.commitResult;
   if (sentinel && result?.committed) {
     try {
-      fs20.mkdirSync(path19.dirname(sentinel), { recursive: true });
-      fs20.writeFileSync(
+      fs21.mkdirSync(path20.dirname(sentinel), { recursive: true });
+      fs21.writeFileSync(
         sentinel,
         JSON.stringify(
           {
@@ -5089,14 +5213,14 @@ function ensureStateBranch(owner, repo, cwd) {
 }
 // src/goal/state.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
 var GoalStateError = class extends Error {
-  constructor(path38, message) {
-    super(`Invalid goal state at ${path38}:
+  constructor(path39, message) {
+    super(`Invalid goal state at ${path39}:
   ${message}`);
-    this.path = path38;
+    this.path = path39;
     this.name = "GoalStateError";
   }
   path;
@@ -5236,20 +5360,20 @@ function describeCommitMessage(goal) {
 }
 // src/scripts/composePrompt.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
   const explicit = ctx.data.promptTemplate;
   const mode = ctx.args.mode;
   const candidates = [
-    explicit ? path21.join(profile.dir, explicit) : null,
-    mode ? path21.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path21.join(profile.dir, "prompt.md")
+    explicit ? path22.join(profile.dir, explicit) : null,
+    mode ? path22.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path22.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs22.existsSync(c)) {
+    if (fs23.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -5257,7 +5381,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs22.readFileSync(templatePath, "utf-8");
+  const template = fs23.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -6035,15 +6159,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as os4 from "os";
-import * as path22 from "path";
+import * as path23 from "path";
 var diagMcp = async (_ctx) => {
   const home = os4.homedir();
-  const cacheDir = path22.join(home, ".cache", "ms-playwright");
+  const cacheDir = path23.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs23.readdirSync(cacheDir);
+    entries = fs24.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -6069,17 +6193,17 @@ var diagMcp = async (_ctx) => {
 };
 // src/scripts/discoverQaContext.ts
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 // src/scripts/frameworkDetectors.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs24.readFileSync(path23.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs25.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -6116,7 +6240,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs24.existsSync(path23.join(cwd, c))) return c;
+    if (fs25.existsSync(path24.join(cwd, c))) return c;
   }
   return null;
 }
@@ -6129,18 +6253,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path23.join(cwd, dir);
-    if (!fs24.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs25.existsSync(full)) continue;
     let files;
     try {
-      files = fs24.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs25.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path23.join(full, file);
-        const content = fs24.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path24.join(full, file);
+        const content = fs25.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -6154,7 +6278,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path23.relative(cwd, filePath),
+          filePath: path24.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -6168,28 +6292,28 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path23.join(cwd, dir);
-    if (!fs24.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs25.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs24.readdirSync(full, { withFileTypes: true });
+      entries = fs25.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path23.join(full, entry.name);
+      const entryPath = path24.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs24.existsSync(path23.join(entryPath, f))
+          (f) => fs25.existsSync(path24.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path23.relative(cwd, path23.join(entryPath, indexFile));
+        filePath = path24.relative(cwd, path24.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path23.relative(cwd, entryPath);
+        filePath = path24.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -6197,7 +6321,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs24.readFileSync(path23.join(cwd, col.filePath), "utf-8");
+            const colContent = fs25.readFileSync(path24.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -6216,8 +6340,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path23.join(cwd, appDir, "api");
-    if (!fs24.existsSync(apiDir)) continue;
+    const apiDir = path24.join(cwd, appDir, "api");
+    if (!fs25.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -6226,14 +6350,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs24.readdirSync(dir, { withFileTypes: true });
+    entries = fs25.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 = fs24.readFileSync(path23.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs25.readFileSync(path24.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)
       );
@@ -6241,7 +6365,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path23.relative(cwd, path23.join(dir, routeFile.name))
+          filePath: path24.relative(cwd, path24.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -6252,7 +6376,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(path23.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path24.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6260,7 +6384,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path23.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -6280,10 +6404,10 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path23.join(cwd, envFile);
-    if (!fs24.existsSync(envPath)) continue;
+    const envPath = path24.join(cwd, envFile);
+    if (!fs25.existsSync(envPath)) continue;
     try {
-      const content = fs24.readFileSync(envPath, "utf-8");
+      const content = fs25.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -6331,9 +6455,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs25.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs26.readFileSync(path25.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs25.existsSync(path24.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs25.existsSync(path24.join(cwd, "yarn.lock")) ? "yarn" : fs25.existsSync(path24.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs26.existsSync(path25.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs26.existsSync(path25.join(cwd, "yarn.lock")) ? "yarn" : fs26.existsSync(path25.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;
@@ -6343,8 +6467,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path24.join(cwd, appDir);
-    if (!fs25.existsSync(full)) continue;
+    const full = path25.join(cwd, appDir);
+    if (!fs26.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -6352,7 +6476,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs25.readdirSync(dir, { withFileTypes: true });
+    entries = fs26.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -6369,7 +6493,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(path24.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path25.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6377,7 +6501,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path25.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -6394,23 +6518,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs25.existsSync(path24.join(cwd, c))) out.authFiles.push(c);
+    if (fs26.existsSync(path25.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 = path24.join(cwd, rp);
-    if (!fs25.existsSync(dir)) continue;
+    const dir = path25.join(cwd, rp);
+    if (!fs26.existsSync(dir)) continue;
     let files;
     try {
-      files = fs25.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs26.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs25.readFileSync(path24.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs26.readFileSync(path25.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) {
@@ -6594,8 +6718,8 @@ function failedAction3(reason) {
 }
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs27 from "fs";
-import * as path26 from "path";
+import * as fs28 from "fs";
+import * as path27 from "path";
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -6864,8 +6988,8 @@ var ContentsApiBackend = class {
 };
 // src/scripts/jobState/localFileBackend.ts
-import * as fs26 from "fs";
-import * as path25 from "path";
+import * as fs27 from "fs";
+import * as path26 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -6880,7 +7004,7 @@ var LocalFileBackend = class {
     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.join(opts.cwd, opts.jobsDir);
+    this.absDir = path26.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -6895,7 +7019,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs26.mkdirSync(this.absDir, { recursive: true });
+    fs27.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -6924,7 +7048,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs26.existsSync(this.absDir)) {
+    if (!fs27.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -6940,11 +7064,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path25.join(this.cwd, relPath);
-    if (!fs26.existsSync(absPath)) {
+    const absPath = path26.join(this.cwd, relPath);
+    if (!fs27.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs26.readFileSync(absPath, "utf-8");
+    const raw = fs27.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -6961,10 +7085,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path25.join(this.cwd, loaded.path);
-    fs26.mkdirSync(path25.dirname(absPath), { recursive: true });
+    const absPath = path26.join(this.cwd, loaded.path);
+    fs27.mkdirSync(path26.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs26.writeFileSync(absPath, body, "utf-8");
+    fs27.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -7042,7 +7166,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path26.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path27.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -7155,17 +7279,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs27.readFileSync(path26.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs28.readFileSync(path27.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter2(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs27.existsSync(absDir)) return [];
+  if (!fs28.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs27.readdirSync(absDir, { withFileTypes: true });
+    entries = fs28.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7931,7 +8055,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 // src/gha.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -7942,10 +8066,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs28.existsSync(eventPath)) return;
+  if (!eventPath || !fs29.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs28.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs29.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -8239,12 +8363,12 @@ var handleAbandonedGoal = async (ctx) => {
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync17 } from "child_process";
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 function detectPackageManager(cwd) {
-  if (fs29.existsSync(path27.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs29.existsSync(path27.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs29.existsSync(path27.join(cwd, "bun.lockb"))) return "bun";
+  if (fs30.existsSync(path28.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs30.existsSync(path28.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs30.existsSync(path28.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -8373,36 +8497,36 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path27.join(cwd, "kody.config.json");
-  if (fs29.existsSync(configPath) && !force) {
+  const configPath = path28.join(cwd, "kody.config.json");
+  if (fs30.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
-    fs29.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs30.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path27.join(cwd, ".github", "workflows");
-  const workflowPath = path27.join(workflowDir, "kody.yml");
-  if (fs29.existsSync(workflowPath) && !force) {
+  const workflowDir = path28.join(cwd, ".github", "workflows");
+  const workflowPath = path28.join(workflowDir, "kody.yml");
+  if (fs30.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs29.mkdirSync(workflowDir, { recursive: true });
-    fs29.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs30.mkdirSync(workflowDir, { recursive: true });
+    fs30.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path27.join(cwd, ".kody", "duties");
-    fs29.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path28.join(cwd, ".kody", "duties");
+    fs30.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path27.join(".kody", "duties", `${job.slug}.md`);
-      const target = path27.join(cwd, rel);
-      if (fs29.existsSync(target) && !force) {
+      const rel = path28.join(".kody", "duties", `${job.slug}.md`);
+      const target = path28.join(cwd, rel);
+      if (fs30.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs29.writeFileSync(target, fs29.readFileSync(job.filePath, "utf-8"));
+      fs30.writeFileSync(target, fs30.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -8414,12 +8538,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path27.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs29.existsSync(target) && !force) {
+    const target = path28.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs30.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs29.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs30.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -8603,8 +8727,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 // src/scripts/loadJobFromFile.ts
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/duties");
   const workersDir = String(args?.workersDir ?? ".kody/staff");
@@ -8613,11 +8737,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs30.existsSync(absPath)) {
+  const absPath = path29.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs31.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs30.readFileSync(absPath, "utf-8");
+  const raw = fs31.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
   const frontmatter = splitFrontmatter2(raw).frontmatter;
   const mentions = (frontmatter.mentions ?? []).map((login) => `@${login}`).join(" ");
@@ -8625,13 +8749,13 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   let workerTitle = "";
   let workerPersona = "";
   if (workerSlug) {
-    const workerPath = path28.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-    if (!fs30.existsSync(workerPath)) {
+    const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+    if (!fs31.existsSync(workerPath)) {
       throw new Error(
         `loadJobFromFile: duty '${slug}' declares staff '${workerSlug}' but ${workerPath} does not exist`
       );
     }
-    const workerRaw = fs30.readFileSync(workerPath, "utf-8");
+    const workerRaw = fs31.readFileSync(workerPath, "utf-8");
     const parsed = parseJobFile(workerRaw, workerSlug);
     workerTitle = parsed.title;
     workerPersona = parsed.body;
@@ -8674,18 +8798,18 @@ init_loadMemoryContext();
 init_loadPriorArt();
 // src/scripts/loadQaContext.ts
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 // src/scripts/kodyVariables.ts
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 var KODY_VARIABLES_REL_PATH = ".kody/variables.json";
 function readKodyVariables(cwd) {
-  const full = path30.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path31.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs32.readFileSync(full, "utf-8");
+    raw = fs33.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -8734,18 +8858,18 @@ function readProfileStaff(raw) {
   return { staff: staff ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path31.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs33.existsSync(dir)) return "";
+  const dir = path32.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs34.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs33.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs34.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs33.readFileSync(path31.join(dir, file), "utf-8");
+      const raw = fs34.readFileSync(path32.join(dir, file), "utf-8");
       const { staff, body } = readProfileStaff(raw);
       if (!staff.includes(QA_STAFF) && !staff.includes(ALL_STAFF)) continue;
       blocks.push(`## ${file}
@@ -8782,8 +8906,8 @@ var loadQaContext = async (ctx) => {
 init_events();
 // src/taskContext.ts
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -8799,10 +8923,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path32.join(cwd, ".kody", "runs", ctx.runId);
-    fs34.mkdirSync(dir, { recursive: true });
-    const file = path32.join(dir, "task-context.json");
-    fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path33.join(cwd, ".kody", "runs", ctx.runId);
+    fs35.mkdirSync(dir, { recursive: true });
+    const file = path33.join(dir, "task-context.json");
+    fs35.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -8850,19 +8974,19 @@ var loadTaskState = async (ctx) => {
 };
 // src/scripts/loadWorkerAdhoc.ts
-import * as fs35 from "fs";
-import * as path33 from "path";
+import * as fs36 from "fs";
+import * as path34 from "path";
 var loadWorkerAdhoc = async (ctx, _profile, args) => {
   const workersDir = String(args?.workersDir ?? ".kody/staff");
   const workerSlug = String(ctx.args.worker ?? "").trim();
   if (!workerSlug) {
     throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
   }
-  const workerPath = path33.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-  if (!fs35.existsSync(workerPath)) {
+  const workerPath = path34.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+  if (!fs36.existsSync(workerPath)) {
     throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
   }
-  const { title, body } = parsePersona(fs35.readFileSync(workerPath, "utf-8"), workerSlug);
+  const { title, body } = parsePersona(fs36.readFileSync(workerPath, "utf-8"), workerSlug);
   const message = resolveMessage(ctx.args.message);
   if (!message) {
     throw new Error(
@@ -8882,9 +9006,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 "";
@@ -9554,8 +9678,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path38, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path38}`, {
+  async call(path39, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path39}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -9566,7 +9690,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path38}: ${text.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path39}: ${text.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -10106,14 +10230,14 @@ function sendJson2(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readJsonBody2(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw.trim()) return resolve5({});
+      if (!raw.trim()) return resolve6({});
       try {
-        resolve5(JSON.parse(raw));
+        resolve6(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -10260,10 +10384,10 @@ var poolServe = async (ctx) => {
     }
   });
   const apiHost = process.env.POOL_API_HOST ?? "::";
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     server.listen(apiPort, apiHost, () => {
       log(`listening on ${apiHost}:${apiPort} (min=${min}, app=${app}, region=${region})`);
-      resolve5();
+      resolve6();
     });
   });
   const shutdown = (signal) => {
@@ -11159,7 +11283,7 @@ function resolveBaseOverride(value) {
 // src/scripts/runnerServe.ts
 import { spawn as spawn5 } from "child_process";
 import { createServer as createServer3 } from "http";
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
 function getApiKey2() {
@@ -11181,17 +11305,17 @@ function authOk2(req, expected) {
   return false;
 }
 function readJsonBody3(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve5({});
+        resolve6({});
         return;
       }
       try {
-        resolve5(JSON.parse(raw));
+        resolve6(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -11240,8 +11364,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`;
-  fs36.rmSync(workdir, { recursive: true, force: true });
-  fs36.mkdirSync(workdir, { recursive: true });
+  fs37.rmSync(workdir, { recursive: true, force: true });
+  fs37.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const interactive = job.mode === "interactive";
   const childEnv = {
@@ -11266,13 +11390,13 @@ async function defaultRunJob(job) {
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
-  const run = (cmd, args, cwd) => new Promise((resolve5) => {
+  const run = (cmd, args, cwd) => new Promise((resolve6) => {
     const child = spawn5(cmd, args, { stdio: "inherit", env: childEnv, cwd });
-    child.on("exit", (code) => resolve5(code ?? 0));
+    child.on("exit", (code) => resolve6(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
 `);
-      resolve5(1);
+      resolve6(1);
     });
   });
   process.stdout.write(`[runner-serve] job ${job.jobId}: cloning ${job.repo}@${branch}
@@ -11359,11 +11483,11 @@ var runnerServe = async (ctx) => {
   const port = Number(process.env.PORT ?? DEFAULT_PORT2);
   const server = buildServer2({ apiKey });
   const host = process.env.RUNNER_HOST ?? "::";
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     server.listen(port, host, () => {
       process.stdout.write(`[runner-serve] listening on ${host}:${port} (idle, awaiting job)
 `);
-      resolve5();
+      resolve6();
     });
   });
   const shutdown = (signal) => {
@@ -11379,8 +11503,8 @@ var runnerServe = async (ctx) => {
 // src/scripts/runTickScript.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import * as fs37 from "fs";
-import * as path34 from "path";
+import * as fs38 from "fs";
+import * as path35 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/duties");
@@ -11392,13 +11516,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path34.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs37.existsSync(jobPath)) {
+  const jobPath = path35.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs38.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs37.readFileSync(jobPath, "utf-8");
+  const raw = fs38.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter2(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -11406,8 +11530,8 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
     return;
   }
-  const scriptPath = path34.isAbsolute(tickScript) ? tickScript : path34.join(ctx.cwd, tickScript);
-  if (!fs37.existsSync(scriptPath)) {
+  const scriptPath = path35.isAbsolute(tickScript) ? tickScript : path35.join(ctx.cwd, tickScript);
+  if (!fs38.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -11608,14 +11732,14 @@ var serveFlow = async (ctx) => {
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
     const child = spawn6("claude", args, { stdio: "inherit", env: editorEnv, cwd: ctx.cwd });
-    const exitCode = await new Promise((resolve5) => {
-      child.on("exit", (code) => resolve5(code ?? 0));
+    const exitCode = await new Promise((resolve6) => {
+      child.on("exit", (code) => resolve6(code ?? 0));
       child.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
 `);
         process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
 `);
-        resolve5(1);
+        resolve6(1);
       });
     });
     killProxy();
@@ -11951,7 +12075,7 @@ function stripAnsi2(s) {
   return s.replace(ANSI_RE2, "");
 }
 function runCommand2(command, cwd) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const child = spawn7(command, {
       cwd,
       shell: true,
@@ -11978,11 +12102,11 @@ function runCommand2(command, cwd) {
     }, TEST_TIMEOUT_MS);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve5({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+      resolve6({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve5({ exitCode: -1, output: err.message });
+      resolve6({ exitCode: -1, output: err.message });
     });
   });
 }
@@ -12404,20 +12528,20 @@ function lineStream(stream) {
     tryDeliver();
   });
   return {
-    next: (timeoutMs) => new Promise((resolve5) => {
+    next: (timeoutMs) => new Promise((resolve6) => {
       if (queue.length > 0) {
-        resolve5(queue.shift());
+        resolve6(queue.shift());
         return;
       }
       if (ended) {
-        resolve5(null);
+        resolve6(null);
         return;
       }
-      waiter = resolve5;
+      waiter = resolve6;
       const t = setTimeout(() => {
-        if (waiter === resolve5) {
+        if (waiter === resolve6) {
           waiter = null;
-          resolve5(null);
+          resolve6(null);
         }
       }, Math.max(0, timeoutMs));
       t.unref?.();
@@ -12515,7 +12639,7 @@ var writeJobStateFile = async (ctx, _profile, agentResult, args) => {
 };
 // src/scripts/writeRunSummary.ts
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -12537,7 +12661,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs38.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs39.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -12655,31 +12779,49 @@ function firstRequiredFailure(results, tools) {
   }
   return null;
 }
-function verifyOne(tool3, cwd) {
-  const result = { name: tool3.name, present: false, verified: false };
-  let present = runShell(tool3.install.checkCommand, cwd);
-  if (!present && tool3.install.installCommand) {
-    runShell(tool3.install.installCommand, cwd, 12e4);
-    present = runShell(tool3.install.checkCommand, cwd);
+function verifyOne(tool4, cwd) {
+  const result = { name: tool4.name, present: false, verified: false };
+  const checkRes = runShell(tool4.install.checkCommand, cwd);
+  let present = checkRes.ok;
+  if (!present && tool4.install.installCommand) {
+    runShell(tool4.install.installCommand, cwd, 12e4);
+    present = runShell(tool4.install.checkCommand, cwd).ok;
   }
   result.present = present;
   if (!present) {
-    result.error = `tool "${tool3.name}" not on PATH (check: ${tool3.install.checkCommand})`;
+    result.error = `tool "${tool4.name}" not on PATH (check: ${tool4.install.checkCommand})`;
     return result;
   }
-  const verified = runShell(tool3.verify, cwd);
-  result.verified = verified;
-  if (!verified) result.error = `tool "${tool3.name}" failed verify: ${tool3.verify}`;
+  const verifyRes = runShell(tool4.verify, cwd);
+  result.verified = verifyRes.ok;
+  if (!verifyRes.ok) {
+    const tail = formatStderrTail(verifyRes.stderr, verifyRes.stdout);
+    result.error = `tool "${tool4.name}" failed verify: ${tool4.verify}${tail ? ` \u2014 ${tail}` : ""}`;
+  }
   return result;
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync27("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
-    return true;
-  } catch {
-    return false;
+    const stdout = execFileSync27("sh", ["-c", cmd], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs,
+      encoding: "utf-8"
+    });
+    return { ok: true, stdout: stdout ?? "", stderr: "" };
+  } catch (err) {
+    const e = err;
+    const stdout = e.stdout ? e.stdout.toString() : "";
+    const stderr = e.stderr ? e.stderr.toString() : "";
+    return { ok: false, stdout, stderr };
   }
 }
+function formatStderrTail(stderr, stdout) {
+  const source = stderr.trim() || stdout.trim();
+  if (!source) return "";
+  const flat = source.replace(/\s+/g, " ").trim();
+  return flat.length > 400 ? `\u2026${flat.slice(-400)}` : flat;
+}
 // src/executor.ts
 var CONTAINER_MAX_ITERATIONS = 50;
@@ -12725,11 +12867,12 @@ async function runExecutable(profileName, input) {
   if (input.config) {
     config = input.config;
   } else if (input.skipConfig) {
+    const envModel = process.env.MODEL?.trim();
     config = {
       quality: { typecheck: "", lint: "", testUnit: "", format: "" },
       git: { defaultBranch: "main" },
       github: { owner: "", repo: "" },
-      agent: { model: "claude/claude-haiku-4-5-20251001" }
+      agent: { model: envModel || "claude/claude-haiku-4-5-20251001" }
     };
   } else {
     try {
@@ -12782,9 +12925,9 @@ async function runExecutable(profileName, input) {
       })
     };
   })() : null;
-  const ndjsonDir = path35.join(input.cwd, ".kody");
+  const ndjsonDir = path36.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path35.isAbsolute(p) ? p : path35.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path36.isAbsolute(p) ? p : path36.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -12996,7 +13139,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs39.existsSync(profilePath)) return null;
+    if (!fs40.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -13005,17 +13148,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path35.dirname(new URL(import.meta.url).pathname);
+  const here = path36.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path35.join(here, "executables", profileName, "profile.json"),
+    path36.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path35.join(here, "..", "executables", profileName, "profile.json"),
+    path36.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path35.join(here, "..", "src", "executables", profileName, "profile.json")
+    path36.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs39.existsSync(c)) return c;
+    if (fs40.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -13115,8 +13258,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path35.join(profile.dir, shellName);
-  if (!fs39.existsSync(shellPath)) {
+  const shellPath = path36.join(profile.dir, shellName);
+  if (!fs40.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -13154,14 +13297,14 @@ async function runShellEntry(entry, ctx, profile) {
   let killTimer;
   let escalateTimer;
   const result = await new Promise(
-    (resolve5) => {
+    (resolve6) => {
       let settled = false;
       const settle = (code, signal, spawnErr) => {
         if (settled) return;
         settled = true;
         if (killTimer) clearTimeout(killTimer);
         if (escalateTimer) clearTimeout(escalateTimer);
-        resolve5({ code, signal, spawnErr });
+        resolve6({ code, signal, spawnErr });
       };
       child.on("error", (err) => settle(null, null, err));
       child.on("close", (code, signal) => settle(code, signal));
@@ -13595,9 +13738,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs40.existsSync(path36.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs40.existsSync(path36.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs40.existsSync(path36.join(cwd, "bun.lockb"))) return "bun";
+  if (fs41.existsSync(path37.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs41.existsSync(path37.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs41.existsSync(path37.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -13684,11 +13827,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path36.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path37.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs40.existsSync(logPath)) {
-      const content = fs40.readFileSync(logPath, "utf-8");
+    if (fs41.existsSync(logPath)) {
+      const content = fs41.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -13713,7 +13856,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path36.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path37.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -13723,9 +13866,9 @@ async function runCi(argv) {
   const eventName = process.env.GITHUB_EVENT_NAME;
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs40.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs41.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs40.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs41.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       manualWorkflowDispatch = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
@@ -13984,12 +14127,12 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path37.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path37.relative(cwd, eventsFilePath(cwd, sessionId));
+  const sessionFile = path38.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path38.relative(cwd, eventsFilePath(cwd, sessionId));
   const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tasksDir = path37.join(".kody", "tasks", safeSession);
+  const tasksDir = path38.join(".kody", "tasks", safeSession);
   const candidatePaths = [sessionFile, eventsFile, tasksDir];
-  const paths = candidatePaths.filter((p) => fs41.existsSync(path37.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs42.existsSync(path38.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -14033,7 +14176,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path37.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path38.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -14085,7 +14228,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs41.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs42.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -14441,7 +14584,7 @@ ${HELP_TEXT}`);
     }
   }
   const cwd = args.cwd ?? process.cwd();
-  const configlessCommands = /* @__PURE__ */ new Set(["init", "goal-scheduler"]);
+  const configlessCommands = /* @__PURE__ */ new Set(["init", "goal-scheduler", "brain-serve"]);
   const skipConfig = configlessCommands.has(args.executableName ?? "");
   try {
     const result = await runExecutable(args.executableName, {