@kody-ade/kody-engine 0.4.101 → 0.4.103

package/dist/bin/kody.js

@@ -469,16 +469,16 @@ var init_issue = __esm({
 });
 
 // src/prompt.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path17.join(projectDir, rel);
-    if (!fs18.existsSync(abs)) continue;
+    const abs = path18.join(projectDir, rel);
+    if (!fs19.existsSync(abs)) continue;
     let content;
     try {
-      content = fs18.readFileSync(abs, "utf-8");
+      content = fs19.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -626,28 +626,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs33 from "fs";
-import * as path32 from "path";
+import * as fs34 from "fs";
+import * as path33 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs33.statSync(file);
+      stat = fs34.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs33.readFileSync(file, "utf-8");
+      raw = fs34.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() ?? path32.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path33.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path32.relative(memoryAbs, file),
+      relPath: path33.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -715,16 +715,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs33.readdirSync(dir);
+      names = fs34.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path32.join(dir, name);
+      const full = path33.join(dir, name);
       let stat;
       try {
-        stat = fs33.statSync(full);
+        stat = fs34.statSync(full);
       } catch {
         continue;
       }
@@ -747,8 +747,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path32.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs33.existsSync(memoryAbs)) {
+      const memoryAbs = path33.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs34.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -880,7 +880,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.101",
+  version: "0.4.103",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -935,8 +935,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync32 } from "child_process";
-import * as fs39 from "fs";
-import * as path37 from "path";
+import * as fs40 from "fs";
+import * as path38 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1515,6 +1515,9 @@ async function runAgent(opts) {
     if (opts.pluginPaths && opts.pluginPaths.length > 0) {
       queryOptions.plugins = opts.pluginPaths.map((p) => ({ type: "local", path: p }));
     }
+    if (opts.agents && Object.keys(opts.agents).length > 0) {
+      queryOptions.agents = opts.agents;
+    }
     if (typeof opts.maxTurns === "number" && opts.maxTurns > 0) {
       queryOptions.maxTurns = opts.maxTurns;
     }
@@ -2383,8 +2386,8 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs38 from "fs";
-import * as path36 from "path";
+import * as fs39 from "fs";
+import * as path37 from "path";
 
 // src/dispatch.ts
 import * as fs11 from "fs";
@@ -2706,8 +2709,8 @@ init_issue();
 
 // src/executor.ts
 import { execFileSync as execFileSync30, spawn as spawn6 } from "child_process";
-import * as fs37 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 init_events();
 
 // src/lifecycleLabels.ts
@@ -3448,6 +3451,138 @@ function stripBlockingEnv(env) {
   return out;
 }
 
+// src/subagents.ts
+import * as fs15 from "fs";
+import * as path14 from "path";
+
+// src/scripts/buildSyntheticPlugin.ts
+import * as fs14 from "fs";
+import * as os3 from "os";
+import * as path13 from "path";
+function getPluginsCatalogRoot() {
+  const here = path13.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path13.join(here, "..", "plugins"),
+    // dev: src/scripts → src/plugins
+    path13.join(here, "..", "..", "plugins"),
+    // built: dist/scripts → dist/plugins
+    path13.join(here, "..", "..", "src", "plugins")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs14.existsSync(c) && fs14.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+var buildSyntheticPlugin = async (ctx, profile) => {
+  const cc = profile.claudeCode;
+  const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0;
+  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 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;
+    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 });
+    for (const name of cc.skills) {
+      copyDir(resolvePart("skills", name), path13.join(dst, name));
+    }
+  }
+  if (cc.commands.length > 0) {
+    const dst = path13.join(root, "commands");
+    fs14.mkdirSync(dst, { recursive: true });
+    for (const name of cc.commands) {
+      fs14.copyFileSync(resolvePart("commands", `${name}.md`), path13.join(dst, `${name}.md`));
+    }
+  }
+  if (cc.hooks.length > 0) {
+    const dst = path13.join(root, "hooks");
+    fs14.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"));
+      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)}
+`);
+  }
+  const manifest = {
+    name: `kody-synth-${profile.name}`,
+    version: "1.0.0",
+    description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
+  };
+  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)}
+`);
+  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);
+    if (ent.isDirectory()) copyDir(s, d);
+    else if (ent.isFile()) fs14.copyFileSync(s, d);
+  }
+}
+
+// src/subagents.ts
+function splitFrontmatter(raw) {
+  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
+  if (!match) return { fm: {}, body: raw.trim() };
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    fm[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  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;
+  throw new Error(
+    `loadSubagents: agent '${name}' not found in ${profileDir}/agents/ or shared catalog`
+  );
+}
+function loadSubagents(profile) {
+  const names = profile.claudeCode.subagents;
+  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"));
+    if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
+    const def = {
+      description: fm.description ?? `Subagent ${name}`,
+      prompt: body
+    };
+    if (fm.tools) {
+      const tools = fm.tools.split(",").map((t) => t.trim()).filter(Boolean);
+      if (tools.length > 0) def.tools = tools;
+    }
+    agents[fm.name || name] = def;
+  }
+  return agents;
+}
+
 // src/commit.ts
 import { execFileSync as execFileSync6 } from "child_process";
 
@@ -3528,8 +3663,8 @@ function pushWithRetry(opts = {}) {
 }
 
 // src/commit.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -3585,18 +3720,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path13.join(cwd ?? process.cwd(), ".git");
-  if (!fs14.existsSync(gitDir)) return aborted;
-  if (fs14.existsSync(path13.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path15.join(cwd ?? process.cwd(), ".git");
+  if (!fs16.existsSync(gitDir)) return aborted;
+  if (fs16.existsSync(path15.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs14.existsSync(path13.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs16.existsSync(path15.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs14.existsSync(path13.join(gitDir, "REVERT_HEAD"))) {
+  if (fs16.existsSync(path15.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs14.existsSync(path13.join(gitDir, "rebase-merge")) || fs14.existsSync(path13.join(gitDir, "rebase-apply"))) {
+  if (fs16.existsSync(path15.join(gitDir, "rebase-merge")) || fs16.existsSync(path15.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -3652,7 +3787,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs14.existsSync(path13.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs16.existsSync(path15.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -3951,20 +4086,20 @@ var advanceFlow = async (ctx, profile) => {
 
 // src/scripts/brainServe.ts
 import { createServer } from "http";
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 
 // src/scripts/brainTurnLog.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath(dir, chatId) {
-  return path14.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+  return path16.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath(dir, chatId);
-  if (!fs15.existsSync(p)) return 0;
-  const lines = fs15.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs17.existsSync(p)) return 0;
+  const lines = fs17.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -3974,9 +4109,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = eventsPath(dir, chatId);
-  if (!fs15.existsSync(p)) return [];
+  if (!fs17.existsSync(p)) return [];
   const out = [];
-  for (const line of fs15.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs17.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -4002,12 +4137,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath(dir, chatId);
-  fs15.mkdirSync(path14.dirname(p), { recursive: true });
+  fs17.mkdirSync(path16.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs15.appendFileSync(p, JSON.stringify(rec) + "\n");
+      fs17.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)}
@@ -4045,7 +4180,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs15.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
+    fs17.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
   } catch {
   }
   state.status = "ended";
@@ -4262,7 +4397,7 @@ async function handleChatTurn(req, res, chatId, opts) {
     return;
   }
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs16.mkdirSync(path15.dirname(sessionFile), { recursive: true });
+  fs18.mkdirSync(path17.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -4401,101 +4536,6 @@ var brainServe = async (ctx) => {
   });
 };
 
-// src/scripts/buildSyntheticPlugin.ts
-import * as fs17 from "fs";
-import * as os3 from "os";
-import * as path16 from "path";
-function getPluginsCatalogRoot() {
-  const here = path16.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path16.join(here, "..", "plugins"),
-    // dev: src/scripts → src/plugins
-    path16.join(here, "..", "..", "plugins"),
-    // built: dist/scripts → dist/plugins
-    path16.join(here, "..", "..", "src", "plugins")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs17.existsSync(c) && fs17.statSync(c).isDirectory()) return c;
-  }
-  return candidates[0];
-}
-var buildSyntheticPlugin = async (ctx, profile) => {
-  const cc = profile.claudeCode;
-  const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0 || cc.subagents.length > 0;
-  if (!needsSynthetic) return;
-  const catalog = getPluginsCatalogRoot();
-  const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path16.join(os3.tmpdir(), `kody-synth-${runId}`);
-  fs17.mkdirSync(path16.join(root, ".claude-plugin"), { recursive: true });
-  const resolvePart = (bucket, entry) => {
-    const local = path16.join(profile.dir, bucket, entry);
-    if (fs17.existsSync(local)) return local;
-    const central = path16.join(catalog, bucket, entry);
-    if (fs17.existsSync(central)) return central;
-    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 = path16.join(root, "skills");
-    fs17.mkdirSync(dst, { recursive: true });
-    for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path16.join(dst, name));
-    }
-  }
-  if (cc.commands.length > 0) {
-    const dst = path16.join(root, "commands");
-    fs17.mkdirSync(dst, { recursive: true });
-    for (const name of cc.commands) {
-      fs17.copyFileSync(resolvePart("commands", `${name}.md`), path16.join(dst, `${name}.md`));
-    }
-  }
-  if (cc.subagents.length > 0) {
-    const dst = path16.join(root, "agents");
-    fs17.mkdirSync(dst, { recursive: true });
-    for (const name of cc.subagents) {
-      fs17.copyFileSync(resolvePart("agents", `${name}.md`), path16.join(dst, `${name}.md`));
-    }
-  }
-  if (cc.hooks.length > 0) {
-    const dst = path16.join(root, "hooks");
-    fs17.mkdirSync(dst, { recursive: true });
-    const merged = { hooks: {} };
-    for (const name of cc.hooks) {
-      const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs17.readFileSync(src, "utf-8"));
-      for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
-        if (!Array.isArray(entries)) continue;
-        if (!merged.hooks[event]) merged.hooks[event] = [];
-        merged.hooks[event].push(...entries);
-      }
-    }
-    fs17.writeFileSync(path16.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
-`);
-  }
-  const manifest = {
-    name: `kody-synth-${profile.name}`,
-    version: "1.0.0",
-    description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
-  };
-  if (cc.skills.length > 0) manifest.skills = ["./skills/"];
-  if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-  if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs17.writeFileSync(path16.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
-`);
-  ctx.data.syntheticPluginPath = root;
-};
-function copyDir(src, dst) {
-  fs17.mkdirSync(dst, { recursive: true });
-  for (const ent of fs17.readdirSync(src, { withFileTypes: true })) {
-    const s = path16.join(src, ent.name);
-    const d = path16.join(dst, ent.name);
-    if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs17.copyFileSync(s, d);
-  }
-}
-
 // src/coverage.ts
 import { execFileSync as execFileSync9 } from "child_process";
 function patternToRegex(pattern) {
@@ -4633,13 +4673,13 @@ function defaultLabelMap() {
 }
 
 // src/scripts/commitAndPush.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 init_events();
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path18.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+  return path19.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
 var commitAndPush2 = async (ctx, profile) => {
   const branch = ctx.data.branch;
@@ -4649,9 +4689,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 && fs19.existsSync(sentinel)) {
+  if (sentinel && fs20.existsSync(sentinel)) {
     try {
-      const replay = JSON.parse(fs19.readFileSync(sentinel, "utf-8"));
+      const replay = JSON.parse(fs20.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;
@@ -4704,8 +4744,8 @@ var commitAndPush2 = async (ctx, profile) => {
   const result = ctx.data.commitResult;
   if (sentinel && result?.committed) {
     try {
-      fs19.mkdirSync(path18.dirname(sentinel), { recursive: true });
-      fs19.writeFileSync(
+      fs20.mkdirSync(path19.dirname(sentinel), { recursive: true });
+      fs20.writeFileSync(
         sentinel,
         JSON.stringify(
           {
@@ -4726,11 +4766,11 @@ var commitAndPush2 = async (ctx, profile) => {
 
 // src/scripts/commitGoalState.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as path19 from "path";
+import * as path20 from "path";
 var commitGoalState = async (ctx) => {
   const goal = ctx.data.goal;
   if (!goal) return;
-  const stateRel = path19.posix.join(".kody", "goals", goal.id, "state.json");
+  const stateRel = path20.posix.join(".kody", "goals", goal.id, "state.json");
   try {
     execFileSync10("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
   } catch (err) {
@@ -4775,20 +4815,20 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
+import * as fs21 from "fs";
+import * as path21 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 ? path20.join(profile.dir, explicit) : null,
-    mode ? path20.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path20.join(profile.dir, "prompt.md")
+    explicit ? path21.join(profile.dir, explicit) : null,
+    mode ? path21.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path21.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs20.existsSync(c)) {
+    if (fs21.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -4796,7 +4836,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs20.readFileSync(templatePath, "utf-8");
+  const template = fs21.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -4875,8 +4915,8 @@ function formatToolsUsage(profile) {
 // src/scripts/createQaGoal.ts
 init_issue();
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs21 from "fs";
-import * as path21 from "path";
+import * as fs22 from "fs";
+import * as path22 from "path";
 
 // src/scripts/postReviewResult.ts
 init_issue();
@@ -5129,8 +5169,8 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path21.join(cwd, ".kody", "goals", goalId);
-  fs21.mkdirSync(dir, { recursive: true });
+  const dir = path22.join(cwd, ".kody", "goals", goalId);
+  fs22.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -5138,8 +5178,8 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path21.join(dir, "state.json");
-  fs21.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  const filePath = path22.join(dir, "state.json");
+  fs22.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
@@ -5648,15 +5688,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync12 } from "child_process";
-import * as fs22 from "fs";
+import * as fs23 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 = fs22.readdirSync(cacheDir);
+    entries = fs23.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -5682,17 +5722,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs25 from "fs";
+import * as path25 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs23 from "fs";
-import * as path23 from "path";
+import * as fs24 from "fs";
+import * as path24 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs23.readFileSync(path23.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs24.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -5729,7 +5769,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs23.existsSync(path23.join(cwd, c))) return c;
+    if (fs24.existsSync(path24.join(cwd, c))) return c;
   }
   return null;
 }
@@ -5742,18 +5782,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path23.join(cwd, dir);
-    if (!fs23.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs24.existsSync(full)) continue;
     let files;
     try {
-      files = fs23.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs24.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 = fs23.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path24.join(full, file);
+        const content = fs24.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -5767,7 +5807,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path23.relative(cwd, filePath),
+          filePath: path24.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -5781,28 +5821,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 (!fs23.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs24.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs23.readdirSync(full, { withFileTypes: true });
+      entries = fs24.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) => fs23.existsSync(path23.join(entryPath, f))
+          (f) => fs24.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;
       }
@@ -5810,7 +5850,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs23.readFileSync(path23.join(cwd, col.filePath), "utf-8");
+            const colContent = fs24.readFileSync(path24.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -5829,8 +5869,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path23.join(cwd, appDir, "api");
-    if (!fs23.existsSync(apiDir)) continue;
+    const apiDir = path24.join(cwd, appDir, "api");
+    if (!fs24.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -5839,14 +5879,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs23.readdirSync(dir, { withFileTypes: true });
+    entries = fs24.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 = fs23.readFileSync(path23.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs24.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)
       );
@@ -5854,7 +5894,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 {
@@ -5865,7 +5905,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("]]")) {
@@ -5873,7 +5913,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([
@@ -5893,10 +5933,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 (!fs23.existsSync(envPath)) continue;
+    const envPath = path24.join(cwd, envFile);
+    if (!fs24.existsSync(envPath)) continue;
     try {
-      const content = fs23.readFileSync(envPath, "utf-8");
+      const content = fs24.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -5944,9 +5984,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs24.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs25.readFileSync(path25.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs24.existsSync(path24.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs24.existsSync(path24.join(cwd, "yarn.lock")) ? "yarn" : fs24.existsSync(path24.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs25.existsSync(path25.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs25.existsSync(path25.join(cwd, "yarn.lock")) ? "yarn" : fs25.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;
@@ -5956,8 +5996,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 (!fs24.existsSync(full)) continue;
+    const full = path25.join(cwd, appDir);
+    if (!fs25.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -5965,7 +6005,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs24.readdirSync(dir, { withFileTypes: true });
+    entries = fs25.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -5982,7 +6022,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("]]")) {
@@ -5990,7 +6030,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) {
@@ -6007,23 +6047,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs24.existsSync(path24.join(cwd, c))) out.authFiles.push(c);
+    if (fs25.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 (!fs24.existsSync(dir)) continue;
+    const dir = path25.join(cwd, rp);
+    if (!fs25.existsSync(dir)) continue;
     let files;
     try {
-      files = fs24.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs25.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs24.readFileSync(path24.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs25.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) {
@@ -6269,8 +6309,8 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs26 from "fs";
-import * as path26 from "path";
+import * as fs27 from "fs";
+import * as path27 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -6286,7 +6326,7 @@ var SCHEDULE_EVERY_VALUES = [
   "manual"
 ];
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-function splitFrontmatter(raw) {
+function splitFrontmatter2(raw) {
   const match = FRONTMATTER_RE.exec(raw);
   if (!match) return { frontmatter: {}, body: raw };
   const inner = match[1] ?? "";
@@ -6531,8 +6571,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs25 from "fs";
-import * as path25 from "path";
+import * as fs26 from "fs";
+import * as path26 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -6547,7 +6587,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();
@@ -6562,7 +6602,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs25.mkdirSync(this.absDir, { recursive: true });
+    fs26.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -6591,7 +6631,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs25.existsSync(this.absDir)) {
+    if (!fs26.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -6607,11 +6647,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path25.join(this.cwd, relPath);
-    if (!fs25.existsSync(absPath)) {
+    const absPath = path26.join(this.cwd, relPath);
+    if (!fs26.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs25.readFileSync(absPath, "utf-8");
+    const raw = fs26.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -6628,10 +6668,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path25.join(this.cwd, loaded.path);
-    fs25.mkdirSync(path25.dirname(absPath), { recursive: true });
+    const absPath = path26.join(this.cwd, loaded.path);
+    fs26.mkdirSync(path26.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs25.writeFileSync(absPath, body, "utf-8");
+    fs26.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -6709,7 +6749,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}
@@ -6822,17 +6862,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs26.readFileSync(path26.join(cwd, jobsDir, `${slug}.md`), "utf-8");
-    return splitFrontmatter(raw).frontmatter;
+    const raw = fs27.readFileSync(path27.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    return splitFrontmatter2(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs26.existsSync(absDir)) return [];
+  if (!fs27.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs26.readdirSync(absDir, { withFileTypes: true });
+    entries = fs27.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -7585,7 +7625,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 
 // src/gha.ts
 import { execFileSync as execFileSync17 } from "child_process";
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -7596,10 +7636,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs27.existsSync(eventPath)) return;
+  if (!eventPath || !fs28.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs27.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs28.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -7892,22 +7932,22 @@ var handleAbandonedGoal = async (ctx) => {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync19 } from "child_process";
-import * as fs29 from "fs";
-import * as path28 from "path";
+import * as fs30 from "fs";
+import * as path29 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs28 from "fs";
-import * as path27 from "path";
+import * as fs29 from "fs";
+import * as path28 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path27.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs28.existsSync(full)) {
+  const full = path28.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs29.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs28.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs29.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -7917,9 +7957,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs29.existsSync(path28.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs29.existsSync(path28.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs29.existsSync(path28.join(cwd, "bun.lockb"))) return "bun";
+  if (fs30.existsSync(path29.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs30.existsSync(path29.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs30.existsSync(path29.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -8041,48 +8081,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path28.join(cwd, "kody.config.json");
-  if (fs29.existsSync(configPath) && !force) {
+  const configPath = path29.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 = path28.join(cwd, ".github", "workflows");
-  const workflowPath = path28.join(workflowDir, "kody.yml");
-  if (fs29.existsSync(workflowPath) && !force) {
+  const workflowDir = path29.join(cwd, ".github", "workflows");
+  const workflowPath = path29.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 hasUi = fs29.existsSync(path28.join(cwd, "src/app")) || fs29.existsSync(path28.join(cwd, "app")) || fs29.existsSync(path28.join(cwd, "pages"));
+  const hasUi = fs30.existsSync(path29.join(cwd, "src/app")) || fs30.existsSync(path29.join(cwd, "app")) || fs30.existsSync(path29.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path28.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs29.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path29.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs30.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs29.mkdirSync(path28.dirname(qaGuidePath), { recursive: true });
+      fs30.mkdirSync(path29.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs29.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs30.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path28.join(cwd, ".kody", "jobs");
-    fs29.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path29.join(cwd, ".kody", "jobs");
+    fs30.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path28.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path28.join(cwd, rel);
-      if (fs29.existsSync(target) && !force) {
+      const rel = path29.join(".kody", "jobs", `${job.slug}.md`);
+      const target = path29.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);
     }
   }
@@ -8094,12 +8134,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path28.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs29.existsSync(target) && !force) {
+    const target = path29.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;
@@ -8177,14 +8217,14 @@ init_loadConventions();
 init_loadCoverageRules();
 
 // src/goal/state.ts
-import * as fs30 from "fs";
-import * as path29 from "path";
+import * as fs31 from "fs";
+import * as path30 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;
@@ -8232,16 +8272,16 @@ function serializeGoalState(s) {
 `;
 }
 function goalStatePath(cwd, goalId) {
-  return path29.join(cwd, ".kody", "goals", goalId, "state.json");
+  return path30.join(cwd, ".kody", "goals", goalId, "state.json");
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs30.existsSync(file)) {
+  if (!fs31.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs30.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs31.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -8249,8 +8289,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs30.mkdirSync(path29.dirname(file), { recursive: true });
-  fs30.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs31.mkdirSync(path30.dirname(file), { recursive: true });
+  fs31.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -8347,8 +8387,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs31 from "fs";
-import * as path30 from "path";
+import * as fs32 from "fs";
+import * as path31 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const workersDir = String(args?.workersDir ?? ".kody/workers");
@@ -8357,23 +8397,23 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path30.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs31.existsSync(absPath)) {
+  const absPath = path31.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs32.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs31.readFileSync(absPath, "utf-8");
+  const raw = fs32.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
-  const workerSlug = (splitFrontmatter(raw).frontmatter.worker ?? "").trim();
+  const workerSlug = (splitFrontmatter2(raw).frontmatter.worker ?? "").trim();
   let workerTitle = "";
   let workerPersona = "";
   if (workerSlug) {
-    const workerPath = path30.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-    if (!fs31.existsSync(workerPath)) {
+    const workerPath = path31.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+    if (!fs32.existsSync(workerPath)) {
       throw new Error(
         `loadJobFromFile: job '${slug}' declares worker '${workerSlug}' but ${workerPath} does not exist`
       );
     }
-    const workerRaw = fs31.readFileSync(workerPath, "utf-8");
+    const workerRaw = fs32.readFileSync(workerPath, "utf-8");
     const parsed = parseJobFile(workerRaw, workerSlug);
     workerTitle = parsed.title;
     workerPersona = parsed.body;
@@ -8411,19 +8451,19 @@ function humanizeSlug(slug) {
 }
 
 // src/scripts/loadWorkerAdhoc.ts
-import * as fs32 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path32 from "path";
 var loadWorkerAdhoc = async (ctx, _profile, args) => {
   const workersDir = String(args?.workersDir ?? ".kody/workers");
   const workerSlug = String(ctx.args.worker ?? "").trim();
   if (!workerSlug) {
     throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
   }
-  const workerPath = path31.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-  if (!fs32.existsSync(workerPath)) {
+  const workerPath = path32.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+  if (!fs33.existsSync(workerPath)) {
     throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
   }
-  const { title, body } = parsePersona(fs32.readFileSync(workerPath, "utf-8"), workerSlug);
+  const { title, body } = parsePersona(fs33.readFileSync(workerPath, "utf-8"), workerSlug);
   const message = resolveMessage(ctx.args.message);
   if (!message) {
     throw new Error(
@@ -8443,9 +8483,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs32.existsSync(eventPath)) return "";
+  if (!eventPath || !fs33.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs32.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs33.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -8469,7 +8509,7 @@ function stripDirective(body) {
   return lines.slice(start).join("\n").trim();
 }
 function parsePersona(raw, slug) {
-  const stripped = splitFrontmatter(raw).body;
+  const stripped = splitFrontmatter2(raw).body;
   const trimmed = stripped.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
   const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
@@ -8491,8 +8531,8 @@ init_loadPriorArt();
 init_events();
 
 // src/taskContext.ts
-import * as fs34 from "fs";
-import * as path33 from "path";
+import * as fs35 from "fs";
+import * as path34 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -8508,10 +8548,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path33.join(cwd, ".kody", "runs", ctx.runId);
-    fs34.mkdirSync(dir, { recursive: true });
-    const file = path33.join(dir, "task-context.json");
-    fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path34.join(cwd, ".kody", "runs", ctx.runId);
+    fs35.mkdirSync(dir, { recursive: true });
+    const file = path34.join(dir, "task-context.json");
+    fs35.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -9874,8 +9914,8 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs35 from "fs";
-import * as path34 from "path";
+import * as fs36 from "fs";
+import * as path35 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -9887,22 +9927,22 @@ 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 (!fs35.existsSync(jobPath)) {
+  const jobPath = path35.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs36.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs35.readFileSync(jobPath, "utf-8");
-  const { frontmatter } = splitFrontmatter(raw);
+  const raw = fs36.readFileSync(jobPath, "utf-8");
+  const { frontmatter } = splitFrontmatter2(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
     ctx.output.exitCode = 99;
     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 (!fs35.existsSync(scriptPath)) {
+  const scriptPath = path35.isAbsolute(tickScript) ? tickScript : path35.join(ctx.cwd, tickScript);
+  if (!fs36.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -10918,7 +10958,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -10940,7 +10980,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs36.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs37.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -11180,11 +11220,12 @@ 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);
     return runAgent({
       prompt,
       model,
@@ -11197,6 +11238,7 @@ async function runExecutable(profileName, input) {
       permissionModeOverride: profile.claudeCode.permissionMode,
       mcpServers: profile.claudeCode.mcpServers.length > 0 ? profile.claudeCode.mcpServers : void 0,
       pluginPaths: pluginPaths.length > 0 ? pluginPaths : void 0,
+      agents,
       maxTurns: profile.claudeCode.maxTurns,
       maxThinkingTokens: profile.claudeCode.maxThinkingTokens,
       maxTurnTimeoutMs: typeof profile.claudeCode.maxTurnTimeoutSec === "number" ? Math.floor(profile.claudeCode.maxTurnTimeoutSec * 1e3) : void 0,
@@ -11389,7 +11431,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs37.existsSync(profilePath)) return null;
+    if (!fs38.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -11398,17 +11440,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 (fs37.existsSync(c)) return c;
+    if (fs38.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -11508,8 +11550,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 (!fs37.existsSync(shellPath)) {
+  const shellPath = path36.join(profile.dir, shellName);
+  if (!fs38.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -11988,9 +12030,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs38.existsSync(path36.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs38.existsSync(path36.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs38.existsSync(path36.join(cwd, "bun.lockb"))) return "bun";
+  if (fs39.existsSync(path37.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs39.existsSync(path37.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs39.existsSync(path37.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -12077,11 +12119,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 (fs38.existsSync(logPath)) {
-      const content = fs38.readFileSync(logPath, "utf-8");
+    if (fs39.existsSync(logPath)) {
+      const content = fs39.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -12106,7 +12148,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);
@@ -12116,9 +12158,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 && fs38.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs39.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs38.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs39.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);
@@ -12377,12 +12419,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) => fs39.existsSync(path37.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs40.existsSync(path38.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -12426,7 +12468,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) {
@@ -12478,7 +12520,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs39.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs40.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {