@kody-ade/kody-engine 0.4.141 → 0.4.143

package/dist/bin/kody.js

@@ -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.143",
   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));
@@ -13590,14 +13733,31 @@ function unpackAllSecrets(env = process.env) {
   return count;
 }
 function resolveAuthToken(env = process.env) {
-  const token = env.KODY_TOKEN || env.GH_TOKEN || env.GITHUB_TOKEN || env.GH_PAT;
+  const sources = [
+    ["KODY_TOKEN", env.KODY_TOKEN],
+    ["GH_TOKEN", env.GH_TOKEN],
+    ["GITHUB_TOKEN", env.GITHUB_TOKEN],
+    ["GH_PAT", env.GH_PAT]
+  ];
+  const picked = sources.find(([, v]) => !!v);
+  const token = picked?.[1];
   if (token && !env.GH_TOKEN) env.GH_TOKEN = token;
+  if (token) {
+    const trimmed = token.trim();
+    const lenDiff = token.length - trimmed.length;
+    process.stdout.write(
+      `\u2192 kody: GH_TOKEN sourced from env.${picked[0]} (length=${token.length}, prefix=${token.slice(0, 4)}, trailingWhitespace=${lenDiff > 0 ? "YES " + lenDiff + " chars" : "no"})
+`
+    );
+  } else {
+    process.stdout.write("\u2192 kody: WARNING no auth token found (KODY_TOKEN/GH_TOKEN/GITHUB_TOKEN/GH_PAT all empty)\n");
+  }
   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 +13844,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 +13873,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 +13883,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 +14144,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 +14193,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 +14245,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 +14601,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, {