@kody-ade/kody-engine 0.3.72 → 0.3.75

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.72",
+  version: "0.3.75",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -51,9 +51,9 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync26 } from "child_process";
-import * as fs27 from "fs";
-import * as path24 from "path";
+import { execFileSync as execFileSync28 } from "child_process";
+import * as fs28 from "fs";
+import * as path25 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -473,6 +473,20 @@ import * as path4 from "path";
 function sessionFilePath(cwd, sessionId) {
   return path4.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
+function readMeta(file) {
+  if (!fs4.existsSync(file)) return null;
+  const raw = fs4.readFileSync(file, "utf-8");
+  const firstLine2 = raw.split("\n", 1)[0]?.trim();
+  if (!firstLine2) return null;
+  try {
+    const parsed = JSON.parse(firstLine2);
+    if (parsed.type !== "meta") return null;
+    if (parsed.mode !== "one-shot" && parsed.mode !== "interactive") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
 function readSession(file) {
   if (!fs4.existsSync(file)) return [];
   const raw = fs4.readFileSync(file, "utf-8").trim();
@@ -641,13 +655,187 @@ async function emit(sink, type, sessionId, suffix, payload) {
   });
 }
 
+// src/chat/modes/interactive.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs5 from "fs";
+import * as path5 from "path";
+
+// src/chat/inbox.ts
+import { execFileSync } from "child_process";
+var DEFAULT_POLL_MS = 3e4;
+async function waitForNextUserMessage(opts) {
+  const pollMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const logger = opts.logger ?? {
+    warn: (m) => process.stderr.write(`[kody:chat:inbox] ${m}
+`)
+  };
+  const idleStart = Date.now();
+  while (true) {
+    const now = Date.now();
+    if (now >= opts.deadlineMs) return { kind: "deadline" };
+    if (now - idleStart >= opts.idleTimeoutMs) return { kind: "idle-timeout" };
+    if (!opts.skipPull) {
+      try {
+        const branch = currentBranch(opts.cwd);
+        if (branch) {
+          execFileSync("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
+            cwd: opts.cwd,
+            stdio: "pipe"
+          });
+        } else {
+          execFileSync("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`git pull failed (will retry): ${msg}`);
+      }
+    }
+    const turns = readSession(opts.sessionFile);
+    for (let i = opts.watermark; i < turns.length; i++) {
+      const t = turns[i];
+      if (t.role === "user") {
+        return { kind: "message", turn: t, turnIndex: i };
+      }
+    }
+    const remainingDeadline = opts.deadlineMs - Date.now();
+    const remainingIdle = opts.idleTimeoutMs - (Date.now() - idleStart);
+    const sleepMs2 = Math.max(0, Math.min(pollMs, remainingDeadline, remainingIdle));
+    if (sleepMs2 === 0) continue;
+    await sleep(sleepMs2);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function currentBranch(cwd) {
+  try {
+    const out = execFileSync("git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const branch = out.toString("utf-8").trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/chat/modes/interactive.ts
+var DEFAULT_IDLE_EXIT_MS = 5 * 6e4;
+var DEFAULT_HARD_CAP_MS = 30 * 6e4;
+var DEFAULT_POLL_MS2 = 3e4;
+async function runInteractiveMode(opts) {
+  const sessionFile = sessionFilePath(opts.cwd, opts.sessionId);
+  const idleExitMs = opts.meta.idleExitMs ?? DEFAULT_IDLE_EXIT_MS;
+  const hardCapMs = opts.meta.hardCapMs ?? DEFAULT_HARD_CAP_MS;
+  const startedAt = Date.now();
+  const deadlineMs = startedAt + hardCapMs;
+  await emit2(opts.sink, "chat.ready", opts.sessionId, "ready", {
+    sessionId: opts.sessionId,
+    startedAt: new Date(startedAt).toISOString(),
+    idleExitMs,
+    hardCapMs
+  });
+  let watermark = 0;
+  let turnsCompleted = 0;
+  while (true) {
+    const turns = readSession(sessionFile);
+    const pendingIdx = findNextUserTurn(turns, watermark);
+    if (pendingIdx === -1) {
+      const result = await waitForNextUserMessage({
+        sessionFile,
+        cwd: opts.cwd,
+        watermark,
+        idleTimeoutMs: idleExitMs,
+        deadlineMs,
+        pollIntervalMs: opts.pollIntervalMs ?? DEFAULT_POLL_MS2,
+        skipPull: opts.skipGit
+      });
+      if (result.kind === "idle-timeout") {
+        await emitExit(opts, "idle-timeout", turnsCompleted);
+        return { exitCode: 0, reason: "idle-timeout", turnsCompleted };
+      }
+      if (result.kind === "deadline") {
+        await emitExit(opts, "deadline", turnsCompleted);
+        return { exitCode: 0, reason: "deadline", turnsCompleted };
+      }
+    }
+    let turnResult;
+    try {
+      turnResult = await runChatTurn({
+        sessionId: opts.sessionId,
+        sessionFile,
+        cwd: opts.cwd,
+        model: opts.model,
+        litellmUrl: opts.litellmUrl,
+        sink: opts.sink,
+        verbose: opts.verbose,
+        quiet: opts.quiet,
+        invokeAgent: opts.invokeAgent
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await emit2(opts.sink, "chat.error", opts.sessionId, `loop-${turnsCompleted}`, { error: msg });
+      await emitExit(opts, "fatal", turnsCompleted);
+      return { exitCode: 99, reason: "fatal", turnsCompleted };
+    }
+    if (turnResult.exitCode === 64) {
+    } else if (turnResult.exitCode !== 0) {
+    } else {
+      turnsCompleted += 1;
+      if (!opts.skipGit) commitTurn(opts.cwd, opts.sessionId, opts.verbose ?? false);
+    }
+    watermark = readSession(sessionFile).length;
+  }
+}
+function findNextUserTurn(turns, fromIdx) {
+  for (let i = fromIdx; i < turns.length; i++) {
+    if (turns[i].role === "user") return i;
+  }
+  if (turns.length > 0 && turns[turns.length - 1].role === "user") return turns.length - 1;
+  return -1;
+}
+function commitTurn(cwd, sessionId, verbose) {
+  const sessionRel = path5.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path5.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionRel, eventsRel].filter((p) => fs5.existsSync(path5.join(cwd, p)));
+  if (paths.length === 0) return;
+  const stdio = verbose ? "inherit" : "pipe";
+  try {
+    execFileSync2("git", ["add", "-f", ...paths], { cwd, stdio });
+    execFileSync2("git", ["commit", "--quiet", "-m", `chat: interactive turn for ${sessionId}`], { cwd, stdio });
+    execFileSync2("git", ["push", "--quiet", "origin", "HEAD"], { cwd, stdio });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody:chat:interactive] commit/push skipped: ${msg}
+`);
+  }
+}
+async function emitExit(opts, reason, turnsCompleted) {
+  await emit2(opts.sink, "chat.exit", opts.sessionId, "exit", {
+    sessionId: opts.sessionId,
+    reason,
+    turnsCompleted,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function emit2(sink, type, sessionId, suffix, payload) {
+  await sink.emit({
+    event: type,
+    payload,
+    runId: makeRunId(sessionId, suffix),
+    emittedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
 // src/kody-cli.ts
-import { execFileSync as execFileSync25 } from "child_process";
-import * as fs26 from "fs";
-import * as path23 from "path";
+import { execFileSync as execFileSync27 } from "child_process";
+import * as fs27 from "fs";
+import * as path24 from "path";
 
 // src/dispatch.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -712,25 +900,25 @@ function cronMatchesInWindow(spec, end, windowSec) {
 }
 
 // src/registry.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function getExecutablesRoot() {
-  const here = path5.dirname(new URL(import.meta.url).pathname);
+  const here = path6.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path5.join(here, "executables"),
+    path6.join(here, "executables"),
     // dev: src/
-    path5.join(here, "..", "executables"),
+    path6.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path5.join(here, "..", "src", "executables")
+    path6.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs5.existsSync(c) && fs5.statSync(c).isDirectory()) return c;
+    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path5.join(process.cwd(), ".kody", "executables");
+  return path6.join(process.cwd(), ".kody", "executables");
 }
 function getExecutableRoots() {
   return [getProjectExecutablesRoot(), getExecutablesRoot()];
@@ -740,13 +928,13 @@ function listExecutables(roots = getExecutableRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs5.existsSync(root)) continue;
-    const entries = fs5.readdirSync(root, { withFileTypes: true });
+    if (!fs6.existsSync(root)) continue;
+    const entries = fs6.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
-      const profilePath = path5.join(root, ent.name, "profile.json");
-      if (fs5.existsSync(profilePath) && fs5.statSync(profilePath).isFile()) {
+      const profilePath = path6.join(root, ent.name, "profile.json");
+      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -758,8 +946,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 = path5.join(root, name, "profile.json");
-    if (fs5.existsSync(profilePath) && fs5.statSync(profilePath).isFile()) {
+    const profilePath = path6.join(root, name, "profile.json");
+    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -775,7 +963,7 @@ function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs5.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -812,10 +1000,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs6.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs7.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs6.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs7.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -890,7 +1078,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs6.readFileSync(exe.profilePath, "utf-8");
+      raw = fs7.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -1004,14 +1192,14 @@ function coerceBare(spec, value) {
 
 // src/executor.ts
 import { spawn as spawn3 } from "child_process";
-import * as fs25 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 
 // src/litellm.ts
-import { execFileSync, spawn } from "child_process";
-import * as fs7 from "fs";
+import { execFileSync as execFileSync3, spawn } from "child_process";
+import * as fs8 from "fs";
 import * as os from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -1042,29 +1230,29 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let cmd = "litellm";
   try {
-    execFileSync("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync3("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
   } catch {
     try {
-      execFileSync("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync3("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
       cmd = "python3";
     } catch {
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path6.join(os.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
-  fs7.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path7.join(os.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  fs8.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 = path6.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
-  const outFd = fs7.openSync(logPath, "w");
+  const logPath = path7.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const outFd = fs8.openSync(logPath, "w");
   const child = spawn(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs7.closeSync(outFd);
+  fs8.closeSync(outFd);
   for (let i = 0; i < 30; i++) {
     await new Promise((r) => setTimeout(r, 2e3));
     if (await checkLitellmHealth(url)) {
@@ -1081,7 +1269,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs7.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs8.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -1092,10 +1280,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path6.join(projectDir, ".env");
-  if (!fs7.existsSync(dotenvPath)) return {};
+  const dotenvPath = path7.join(projectDir, ".env");
+  if (!fs8.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs7.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs8.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)=(.*)$/);
@@ -1118,8 +1306,8 @@ function stripBlockingEnv(env) {
 }
 
 // src/profile.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 var VALID_INPUT_TYPES = /* @__PURE__ */ new Set(["int", "string", "bool", "enum"]);
 var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["primitive", "orchestrator", "container", "watch", "utility"]);
@@ -1135,12 +1323,12 @@ var ProfileError = class extends Error {
   profilePath;
 };
 function loadProfile(profilePath) {
-  if (!fs8.existsSync(profilePath)) {
+  if (!fs9.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1179,7 +1367,7 @@ function loadProfile(profilePath) {
     inputArtifacts: parseInputArtifacts(profilePath, r.input),
     outputArtifacts: parseOutputArtifacts(profilePath, r.output),
     children,
-    dir: path7.dirname(profilePath)
+    dir: path8.dirname(profilePath)
   };
   return profile;
 }
@@ -1423,9 +1611,9 @@ function parseScriptList(p, key, raw) {
 }
 
 // src/commit.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import * as fs9 from "fs";
-import * as path8 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+import * as fs10 from "fs";
+import * as path9 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -1454,7 +1642,7 @@ var CONVENTIONAL_PREFIXES = [
 ];
 function git(args, cwd) {
   try {
-    return execFileSync2("git", args, {
+    return execFileSync4("git", args, {
       encoding: "utf-8",
       timeout: 12e4,
       cwd,
@@ -1481,18 +1669,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path8.join(cwd ?? process.cwd(), ".git");
-  if (!fs9.existsSync(gitDir)) return aborted;
-  if (fs9.existsSync(path8.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path9.join(cwd ?? process.cwd(), ".git");
+  if (!fs10.existsSync(gitDir)) return aborted;
+  if (fs10.existsSync(path9.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs9.existsSync(path8.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs10.existsSync(path9.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs9.existsSync(path8.join(gitDir, "REVERT_HEAD"))) {
+  if (fs10.existsSync(path9.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs9.existsSync(path8.join(gitDir, "rebase-merge")) || fs9.existsSync(path8.join(gitDir, "rebase-apply"))) {
+  if (fs10.existsSync(path9.join(gitDir, "rebase-merge")) || fs10.existsSync(path9.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -1513,7 +1701,7 @@ function isForbiddenPath(p) {
   return false;
 }
 function listChangedFiles(cwd) {
-  const raw = execFileSync2("git", ["status", "--porcelain=v1", "-z"], {
+  const raw = execFileSync4("git", ["status", "--porcelain=v1", "-z"], {
     encoding: "utf-8",
     cwd,
     env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -1525,7 +1713,7 @@ function listChangedFiles(cwd) {
 }
 function listFilesInCommit(ref = "HEAD", cwd) {
   try {
-    const raw = execFileSync2("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
+    const raw = execFileSync4("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -1548,7 +1736,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs9.existsSync(path8.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs10.existsSync(path9.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -1614,10 +1802,10 @@ var abortUnfinishedGitOps2 = async (ctx) => {
 };
 
 // src/scripts/advanceFlow.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 
 // src/state.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 var STATE_BEGIN = "<!-- kody:state:v1:begin -->";
 var STATE_END = "<!-- kody:state:v1:end -->";
 var HISTORY_MAX_ENTRIES = 20;
@@ -1643,7 +1831,7 @@ function ghToken() {
 function gh(args, input, cwd) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync3("gh", args, {
+  return execFileSync5("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd,
@@ -1846,7 +2034,7 @@ var advanceFlow = async (ctx, profile) => {
   }
   const body = `@kody ${flow.name}`;
   try {
-    execFileSync4("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
+    execFileSync6("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS2,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1860,21 +2048,21 @@ var advanceFlow = async (ctx, profile) => {
 };
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as os2 from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 function getPluginsCatalogRoot() {
-  const here = path9.dirname(new URL(import.meta.url).pathname);
+  const here = path10.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path9.join(here, "..", "plugins"),
+    path10.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path9.join(here, "..", "..", "plugins"),
+    path10.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path9.join(here, "..", "..", "src", "plugins")
+    path10.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs10.existsSync(c) && fs10.statSync(c).isDirectory()) return c;
+    if (fs11.existsSync(c) && fs11.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -1884,52 +2072,52 @@ 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 = path9.join(os2.tmpdir(), `kody-synth-${runId}`);
-  fs10.mkdirSync(path9.join(root, ".claude-plugin"), { recursive: true });
+  const root = path10.join(os2.tmpdir(), `kody-synth-${runId}`);
+  fs11.mkdirSync(path10.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
-    const local = path9.join(profile.dir, bucket, entry);
-    if (fs10.existsSync(local)) return local;
-    const central = path9.join(catalog, bucket, entry);
-    if (fs10.existsSync(central)) return central;
+    const local = path10.join(profile.dir, bucket, entry);
+    if (fs11.existsSync(local)) return local;
+    const central = path10.join(catalog, bucket, entry);
+    if (fs11.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 = path9.join(root, "skills");
-    fs10.mkdirSync(dst, { recursive: true });
+    const dst = path10.join(root, "skills");
+    fs11.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path9.join(dst, name));
+      copyDir(resolvePart("skills", name), path10.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path9.join(root, "commands");
-    fs10.mkdirSync(dst, { recursive: true });
+    const dst = path10.join(root, "commands");
+    fs11.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      fs10.copyFileSync(resolvePart("commands", `${name}.md`), path9.join(dst, `${name}.md`));
+      fs11.copyFileSync(resolvePart("commands", `${name}.md`), path10.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path9.join(root, "agents");
-    fs10.mkdirSync(dst, { recursive: true });
+    const dst = path10.join(root, "agents");
+    fs11.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      fs10.copyFileSync(resolvePart("agents", `${name}.md`), path9.join(dst, `${name}.md`));
+      fs11.copyFileSync(resolvePart("agents", `${name}.md`), path10.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path9.join(root, "hooks");
-    fs10.mkdirSync(dst, { recursive: true });
+    const dst = path10.join(root, "hooks");
+    fs11.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
       const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs10.readFileSync(src, "utf-8"));
+      const parsed = JSON.parse(fs11.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);
       }
     }
-    fs10.writeFileSync(path9.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs11.writeFileSync(path10.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -1940,22 +2128,22 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
   if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs10.writeFileSync(path9.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs11.writeFileSync(path10.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs10.mkdirSync(dst, { recursive: true });
-  for (const ent of fs10.readdirSync(src, { withFileTypes: true })) {
-    const s = path9.join(src, ent.name);
-    const d = path9.join(dst, ent.name);
+  fs11.mkdirSync(dst, { recursive: true });
+  for (const ent of fs11.readdirSync(src, { withFileTypes: true })) {
+    const s = path10.join(src, ent.name);
+    const d = path10.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs10.copyFileSync(s, d);
+    else if (ent.isFile()) fs11.copyFileSync(s, d);
   }
 }
 
 // src/coverage.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 function patternToRegex(pattern) {
   let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
@@ -1973,7 +2161,7 @@ function renderSiblingPath(file, requireSibling) {
 }
 function safeGit(args, cwd) {
   try {
-    return execFileSync5("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+    return execFileSync7("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
   } catch {
     return "";
   }
@@ -2016,18 +2204,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
 var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path10.join(projectDir, rel);
-    if (!fs11.existsSync(abs)) continue;
+    const abs = path11.join(projectDir, rel);
+    if (!fs12.existsSync(abs)) continue;
     let content;
     try {
-      content = fs11.readFileSync(abs, "utf-8");
+      content = fs12.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -2232,20 +2420,20 @@ var commitAndPush2 = async (ctx) => {
 };
 
 // src/scripts/composePrompt.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path12 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 ? path11.join(profile.dir, explicit) : null,
-    mode ? path11.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path11.join(profile.dir, "prompt.md")
+    explicit ? path12.join(profile.dir, explicit) : null,
+    mode ? path12.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path12.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs12.existsSync(c)) {
+    if (fs13.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -2253,7 +2441,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs12.readFileSync(templatePath, "utf-8");
+  const template = fs13.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -2330,16 +2518,16 @@ function formatToolsUsage(profile) {
 }
 
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import * as fs13 from "fs";
+import { execFileSync as execFileSync8 } from "child_process";
+import * as fs14 from "fs";
 import * as os3 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 var diagMcp = async (_ctx) => {
   const home = os3.homedir();
-  const cacheDir = path12.join(home, ".cache", "ms-playwright");
+  const cacheDir = path13.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs13.readdirSync(cacheDir);
+    entries = fs14.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -2350,7 +2538,7 @@ var diagMcp = async (_ctx) => {
   process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
   try {
-    const v = execFileSync6("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+    const v = execFileSync8("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
       stdio: "pipe",
       timeout: 6e4,
       encoding: "utf8"
@@ -2365,17 +2553,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs14.readFileSync(path13.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs15.readFileSync(path14.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -2412,7 +2600,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs14.existsSync(path13.join(cwd, c))) return c;
+    if (fs15.existsSync(path14.join(cwd, c))) return c;
   }
   return null;
 }
@@ -2425,18 +2613,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path13.join(cwd, dir);
-    if (!fs14.existsSync(full)) continue;
+    const full = path14.join(cwd, dir);
+    if (!fs15.existsSync(full)) continue;
     let files;
     try {
-      files = fs14.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs15.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path13.join(full, file);
-        const content = fs14.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path14.join(full, file);
+        const content = fs15.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -2450,7 +2638,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path13.relative(cwd, filePath),
+          filePath: path14.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -2464,28 +2652,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 = path13.join(cwd, dir);
-    if (!fs14.existsSync(full)) continue;
+    const full = path14.join(cwd, dir);
+    if (!fs15.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs14.readdirSync(full, { withFileTypes: true });
+      entries = fs15.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path13.join(full, entry.name);
+      const entryPath = path14.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs14.existsSync(path13.join(entryPath, f))
+          (f) => fs15.existsSync(path14.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path13.relative(cwd, path13.join(entryPath, indexFile));
+        filePath = path14.relative(cwd, path14.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path13.relative(cwd, entryPath);
+        filePath = path14.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -2493,7 +2681,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs14.readFileSync(path13.join(cwd, col.filePath), "utf-8");
+            const colContent = fs15.readFileSync(path14.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -2512,8 +2700,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path13.join(cwd, appDir, "api");
-    if (!fs14.existsSync(apiDir)) continue;
+    const apiDir = path14.join(cwd, appDir, "api");
+    if (!fs15.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -2522,14 +2710,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs14.readdirSync(dir, { withFileTypes: true });
+    entries = fs15.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 = fs14.readFileSync(path13.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs15.readFileSync(path14.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)
       );
@@ -2537,7 +2725,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path13.relative(cwd, path13.join(dir, routeFile.name))
+          filePath: path14.relative(cwd, path14.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -2548,7 +2736,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(path13.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path14.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -2556,7 +2744,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path13.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path14.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -2576,10 +2764,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 = path13.join(cwd, envFile);
-    if (!fs14.existsSync(envPath)) continue;
+    const envPath = path14.join(cwd, envFile);
+    if (!fs15.existsSync(envPath)) continue;
     try {
-      const content = fs14.readFileSync(envPath, "utf-8");
+      const content = fs15.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -2627,9 +2815,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs15.readFileSync(path14.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(path15.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs15.existsSync(path14.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs15.existsSync(path14.join(cwd, "yarn.lock")) ? "yarn" : fs15.existsSync(path14.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs16.existsSync(path15.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs16.existsSync(path15.join(cwd, "yarn.lock")) ? "yarn" : fs16.existsSync(path15.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;
@@ -2639,8 +2827,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path14.join(cwd, appDir);
-    if (!fs15.existsSync(full)) continue;
+    const full = path15.join(cwd, appDir);
+    if (!fs16.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -2648,7 +2836,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs15.readdirSync(dir, { withFileTypes: true });
+    entries = fs16.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -2665,7 +2853,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(path14.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path15.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -2673,7 +2861,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path14.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path15.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -2690,23 +2878,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs15.existsSync(path14.join(cwd, c))) out.authFiles.push(c);
+    if (fs16.existsSync(path15.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 = path14.join(cwd, rp);
-    if (!fs15.existsSync(dir)) continue;
+    const dir = path15.join(cwd, rp);
+    if (!fs16.existsSync(dir)) continue;
     let files;
     try {
-      files = fs15.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs16.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs15.readFileSync(path14.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs16.readFileSync(path15.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) {
@@ -2852,7 +3040,7 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 var API_TIMEOUT_MS3 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
@@ -2888,7 +3076,7 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync7("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync9("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS3,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -2908,7 +3096,7 @@ function parsePr(url) {
 }
 
 // src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 var API_TIMEOUT_MS4 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var dispatchClassified = async (ctx) => {
@@ -2917,7 +3105,7 @@ var dispatchClassified = async (ctx) => {
   const classification = ctx.data.classification;
   if (!classification || !VALID_CLASSES2.has(classification)) return;
   try {
-    execFileSync8("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
+    execFileSync10("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS4,
       stdio: ["ignore", "pipe", "pipe"]
@@ -2937,11 +3125,11 @@ function failedAction(reason) {
 }
 
 // src/scripts/dispatchMissionFileTicks.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 
 // src/issue.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 var API_TIMEOUT_MS5 = 3e4;
 function ghToken2() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -2949,7 +3137,7 @@ function ghToken2() {
 function gh2(args, options) {
   const token = ghToken2();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync9("gh", args, {
+  return execFileSync11("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS5,
     cwd: options?.cwd,
@@ -3251,8 +3439,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/missionState/localFileBackend.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -3267,7 +3455,7 @@ var LocalFileBackend = class {
     if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
     this.cwd = opts.cwd;
     this.missionsDir = opts.missionsDir;
-    this.absDir = path15.join(opts.cwd, opts.missionsDir);
+    this.absDir = path16.join(opts.cwd, opts.missionsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -3282,7 +3470,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs16.mkdirSync(this.absDir, { recursive: true });
+    fs17.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -3311,7 +3499,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs16.existsSync(this.absDir)) {
+    if (!fs17.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -3327,11 +3515,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.missionsDir, slug);
-    const absPath = path15.join(this.cwd, relPath);
-    if (!fs16.existsSync(absPath)) {
+    const absPath = path16.join(this.cwd, relPath);
+    if (!fs17.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs16.readFileSync(absPath, "utf-8");
+    const raw = fs17.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -3348,10 +3536,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path15.join(this.cwd, loaded.path);
-    fs16.mkdirSync(path15.dirname(absPath), { recursive: true });
+    const absPath = path16.join(this.cwd, loaded.path);
+    fs17.mkdirSync(path16.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs16.writeFileSync(absPath, body, "utf-8");
+    fs17.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -3428,7 +3616,7 @@ var dispatchMissionFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listMissionSlugs(path16.join(ctx.cwd, missionsDir));
+    const slugs = listMissionSlugs(path17.join(ctx.cwd, missionsDir));
     ctx.data.missionSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[missions] no mission files in ${missionsDir}
@@ -3476,10 +3664,10 @@ var dispatchMissionFileTicks = async (ctx, _profile, args) => {
   }
 };
 function listMissionSlugs(absDir) {
-  if (!fs17.existsSync(absDir)) return [];
+  if (!fs18.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs17.readdirSync(absDir, { withFileTypes: true });
+    entries = fs18.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -3848,7 +4036,7 @@ function collectExpectedTests(raw) {
 }
 
 // src/scripts/finishFlow.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 
 // src/lifecycleLabels.ts
 var KODY_NAMESPACE = "kody";
@@ -4001,7 +4189,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync10("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4015,7 +4203,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 var UncommittedChangesError = class extends Error {
   constructor(branch) {
     super(`Uncommitted changes on branch '${branch}' \u2014 refusing to run to protect work in progress`);
@@ -4025,7 +4213,7 @@ var UncommittedChangesError = class extends Error {
   branch;
 };
 function git2(args, cwd) {
-  return execFileSync11("git", args, {
+  return execFileSync13("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -4050,7 +4238,7 @@ function checkoutPrBranch(prNumber, cwd) {
     SKIP_HOOKS: "1",
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
-  execFileSync11("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync13("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -4117,8 +4305,8 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync12 } from "child_process";
-import * as fs18 from "fs";
+import { execFileSync as execFileSync14 } from "child_process";
+import * as fs19 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -4129,10 +4317,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs18.existsSync(eventPath)) return;
+  if (!eventPath || !fs19.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs19.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -4160,7 +4348,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync12("gh", args, opts);
+      execFileSync14("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -4173,13 +4361,13 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync12("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync14("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
 
 // src/workflow.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -4187,7 +4375,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync13("gh", args, {
+  return execFileSync15("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -4371,23 +4559,23 @@ function tryPostPr2(prNumber, body, cwd) {
 }
 
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync14 } from "child_process";
-import * as fs20 from "fs";
-import * as path18 from "path";
+import { execFileSync as execFileSync16 } from "child_process";
+import * as fs21 from "fs";
+import * as path19 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path17.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs19.existsSync(full)) {
+  const full = path18.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs20.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs19.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs20.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -4397,9 +4585,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs20.existsSync(path18.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs20.existsSync(path18.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs20.existsSync(path18.join(cwd, "bun.lockb"))) return "bun";
+  if (fs21.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs21.existsSync(path19.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs21.existsSync(path19.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -4412,7 +4600,7 @@ function qualityCommandsFor(pm) {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync14("git", ["remote", "get-url", "origin"], {
+    url = execFileSync16("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -4497,7 +4685,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync14("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync16("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -4505,7 +4693,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync14("git", ["branch", "--show-current"], {
+      return execFileSync16("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -4521,33 +4709,33 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path18.join(cwd, "kody.config.json");
-  if (fs20.existsSync(configPath) && !force) {
+  const configPath = path19.join(cwd, "kody.config.json");
+  if (fs21.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs20.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs21.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path18.join(cwd, ".github", "workflows");
-  const workflowPath = path18.join(workflowDir, "kody.yml");
-  if (fs20.existsSync(workflowPath) && !force) {
+  const workflowDir = path19.join(cwd, ".github", "workflows");
+  const workflowPath = path19.join(workflowDir, "kody.yml");
+  if (fs21.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs20.mkdirSync(workflowDir, { recursive: true });
-    fs20.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs21.mkdirSync(workflowDir, { recursive: true });
+    fs21.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs20.existsSync(path18.join(cwd, "src/app")) || fs20.existsSync(path18.join(cwd, "app")) || fs20.existsSync(path18.join(cwd, "pages"));
+  const hasUi = fs21.existsSync(path19.join(cwd, "src/app")) || fs21.existsSync(path19.join(cwd, "app")) || fs21.existsSync(path19.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path18.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs20.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path19.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs21.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs20.mkdirSync(path18.dirname(qaGuidePath), { recursive: true });
+      fs21.mkdirSync(path19.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs20.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs21.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
@@ -4559,12 +4747,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path18.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs20.existsSync(target) && !force) {
+    const target = path19.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs21.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs20.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs21.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -4702,8 +4890,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadMissionFromFile.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 var loadMissionFromFile = async (ctx, _profile, args) => {
   const missionsDir = String(args?.missionsDir ?? ".kody/missions");
   const slugArg = String(args?.slugArg ?? "mission");
@@ -4711,11 +4899,11 @@ var loadMissionFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadMissionFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path19.join(ctx.cwd, missionsDir, `${slug}.md`);
-  if (!fs21.existsSync(absPath)) {
+  const absPath = path20.join(ctx.cwd, missionsDir, `${slug}.md`);
+  if (!fs22.existsSync(absPath)) {
     throw new Error(`loadMissionFromFile: mission file not found: ${absPath}`);
   }
-  const raw = fs21.readFileSync(absPath, "utf-8");
+  const raw = fs22.readFileSync(absPath, "utf-8");
   const { title, body } = parseMissionFile(raw, slug);
   const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
   const loaded = await backend.load(slug);
@@ -4849,16 +5037,16 @@ var loadTaskState = async (ctx) => {
 };
 
 // src/scripts/loadVaultContext.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 var VAULT_DIR_RELATIVE = ".kody/vault";
 var MAX_PAGES = 8;
 var PER_PAGE_MAX_BYTES = 4e3;
 var TOTAL_MAX_BYTES2 = 24e3;
 var TRUNCATED_SUFFIX2 = "\n\n\u2026 (truncated)";
 var loadVaultContext = async (ctx) => {
-  const vaultAbs = path20.join(ctx.cwd, VAULT_DIR_RELATIVE);
-  if (!fs22.existsSync(vaultAbs)) {
+  const vaultAbs = path21.join(ctx.cwd, VAULT_DIR_RELATIVE);
+  if (!fs23.existsSync(vaultAbs)) {
     ctx.data.vaultContext = "";
     return;
   }
@@ -4883,21 +5071,21 @@ function collectPages(vaultAbs) {
   walkMd(vaultAbs, (file) => {
     let stat;
     try {
-      stat = fs22.statSync(file);
+      stat = fs23.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs22.readFileSync(file, "utf-8");
+      raw = fs23.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path20.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path21.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path20.relative(vaultAbs, file),
+      relPath: path21.relative(vaultAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -4965,16 +5153,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs22.readdirSync(dir);
+      names = fs23.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path20.join(dir, name);
+      const full = path21.join(dir, name);
       let stat;
       try {
-        stat = fs22.statSync(full);
+        stat = fs23.statSync(full);
       } catch {
         continue;
       }
@@ -4996,16 +5184,16 @@ var markFlowSuccess = async (ctx) => {
 };
 
 // src/scripts/memorizeFlow.ts
-import { execFileSync as execFileSync15 } from "child_process";
-import * as fs23 from "fs";
-import * as path21 from "path";
+import { execFileSync as execFileSync17 } from "child_process";
+import * as fs24 from "fs";
+import * as path22 from "path";
 var VAULT_DIR_RELATIVE2 = ".kody/vault";
 var DEFAULT_LOOKBACK_HOURS = 36;
 var MAX_RECENT_PRS = 25;
 var MAX_VAULT_INDEX_ENTRIES = 200;
 var PR_BODY_TRUNC = 2e3;
 var memorizeFlow = async (ctx) => {
-  const vaultAbs = path21.join(ctx.cwd, VAULT_DIR_RELATIVE2);
+  const vaultAbs = path22.join(ctx.cwd, VAULT_DIR_RELATIVE2);
   ensureBranch(ctx, vaultAbs);
   if (ctx.skipAgent) return;
   const sinceIso = computeSinceIso(vaultAbs);
@@ -5015,8 +5203,8 @@ var memorizeFlow = async (ctx) => {
   const recent = fetchRecentPrs(ctx.cwd, sinceIso);
   ctx.data.recentPrs = formatRecentPrs(recent);
   ctx.data.recentPrCount = recent.length;
-  if (!fs23.existsSync(vaultAbs)) {
-    fs23.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs24.existsSync(vaultAbs)) {
+    fs24.mkdirSync(vaultAbs, { recursive: true });
   }
   ctx.data.vaultIndex = formatVaultIndex(vaultAbs);
   if (recent.length === 0) {
@@ -5048,18 +5236,18 @@ function ensureBranch(ctx, vaultAbs) {
     }
   }
   ctx.data.branch = branch;
-  if (!fs23.existsSync(vaultAbs)) {
-    fs23.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs24.existsSync(vaultAbs)) {
+    fs24.mkdirSync(vaultAbs, { recursive: true });
   }
 }
 function computeSinceIso(vaultAbs) {
   const fallback = new Date(Date.now() - DEFAULT_LOOKBACK_HOURS * 60 * 60 * 1e3).toISOString();
-  if (!fs23.existsSync(vaultAbs)) return fallback;
+  if (!fs24.existsSync(vaultAbs)) return fallback;
   let latest = "";
   walkMd2(vaultAbs, (file) => {
     let raw;
     try {
-      raw = fs23.readFileSync(file, "utf-8");
+      raw = fs24.readFileSync(file, "utf-8");
     } catch {
       return;
     }
@@ -5136,10 +5324,10 @@ function formatVaultIndex(vaultAbs) {
   const entries = [];
   walkMd2(vaultAbs, (file) => {
     if (entries.length >= MAX_VAULT_INDEX_ENTRIES) return;
-    const rel = path21.relative(vaultAbs, file);
+    const rel = path22.relative(vaultAbs, file);
     let title = rel;
     try {
-      const raw = fs23.readFileSync(file, "utf-8");
+      const raw = fs24.readFileSync(file, "utf-8");
       const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
       const titleMatch = m?.[1]?.match(/^title:\s*(.+)$/m);
       if (titleMatch) title = `${titleMatch[1].trim()} (${rel})`;
@@ -5151,22 +5339,22 @@ function formatVaultIndex(vaultAbs) {
   return entries.join("\n");
 }
 function walkMd2(root, visit) {
-  if (!fs23.existsSync(root)) return;
+  if (!fs24.existsSync(root)) return;
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs23.readdirSync(dir);
+      names = fs24.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path21.join(dir, name);
+      const full = path22.join(dir, name);
       let stat;
       try {
-        stat = fs23.statSync(full);
+        stat = fs24.statSync(full);
       } catch {
         continue;
       }
@@ -5179,7 +5367,7 @@ function walkMd2(root, visit) {
   }
 }
 function git3(args, cwd) {
-  return execFileSync15("git", args, {
+  return execFileSync17("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -5189,7 +5377,7 @@ function git3(args, cwd) {
 }
 
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 var API_TIMEOUT_MS7 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -5208,7 +5396,7 @@ var mergeReleasePr = async (ctx) => {
   process.stderr.write(`[kody mergeReleasePr] merging PR #${prNumber} (${prUrl})
 `);
   try {
-    const out = execFileSync16("gh", ["pr", "merge", String(prNumber), "--merge"], {
+    const out = execFileSync18("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS7,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5663,7 +5851,7 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 };
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var VALID_CLASSES3 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var recordClassification = async (ctx) => {
@@ -5711,7 +5899,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync17("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync19("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS8,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5839,7 +6027,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -5909,7 +6097,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync18("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync20("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -5924,7 +6112,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync18("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync20("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -6025,7 +6213,7 @@ var resolvePreviewUrl = async (ctx) => {
 };
 
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
 var revertFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -6107,7 +6295,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git4(args, cwd) {
-  return execFileSync19("git", args, {
+  return execFileSync21("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -6117,7 +6305,7 @@ function git4(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync19("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync21("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -6270,11 +6458,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync20("git", ["add", "-A"], {
+    execFileSync22("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -6284,7 +6472,7 @@ var stageMergeConflicts = async (ctx) => {
 };
 
 // src/scripts/startFlow.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -6318,7 +6506,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync21("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync23("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS9,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6332,7 +6520,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
   const prNumber = ctx.args.pr;
@@ -6404,7 +6592,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync22("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync24("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -6412,9 +6600,9 @@ function revParseHead(cwd) {
 function pushBranch(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync22("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync24("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
   } catch {
-    execFileSync22("git", ["push", "--force-with-lease", "-u", "origin", branch], {
+    execFileSync24("git", ["push", "--force-with-lease", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6525,7 +6713,7 @@ var verify = async (ctx) => {
 };
 
 // src/scripts/waitForCi.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -6540,17 +6728,17 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
     return;
   }
   const fixCiAttempts = state?.core.attempts?.["fix-ci"] ?? 0;
-  await sleep(initialWaitSeconds * 1e3);
+  await sleep2(initialWaitSeconds * 1e3);
   const deadline = Date.now() + timeoutMinutes * 6e4;
   let lastSummary = "";
   while (Date.now() < deadline) {
     const rows = fetchChecks(prNumber, ctx.cwd);
     if (rows === null) {
-      await sleep(pollSeconds * 1e3);
+      await sleep2(pollSeconds * 1e3);
       continue;
     }
     if (rows.length === 0) {
-      await sleep(pollSeconds * 1e3);
+      await sleep2(pollSeconds * 1e3);
       continue;
     }
     const summary = summarize(rows);
@@ -6593,7 +6781,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
       tryPostPr7(prNumber, `\u2705 kody waitForCi: all ${rows.length} checks green on PR #${prNumber}`, ctx.cwd);
       return;
     }
-    await sleep(pollSeconds * 1e3);
+    await sleep2(pollSeconds * 1e3);
   }
   ctx.data.action = mkAction("CI_TIMEOUT", {
     reason: `CI did not complete within ${timeoutMinutes} minutes`,
@@ -6603,7 +6791,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync23("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync25("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS10,
       cwd,
@@ -6645,7 +6833,7 @@ function tryPostPr7(prNumber, body, cwd) {
   } catch {
   }
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((res) => setTimeout(res, ms));
 }
 
@@ -6775,7 +6963,7 @@ var writeMissionStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -6797,7 +6985,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs24.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs25.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -6879,7 +7067,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -6912,7 +7100,7 @@ function verifyOne(tool, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync24("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync26("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -6981,9 +7169,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path22.join(input.cwd, ".kody");
+  const ndjsonDir = path23.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path22.isAbsolute(p) ? p : path22.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path23.isAbsolute(p) ? p : path23.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -7078,17 +7266,17 @@ async function runExecutable(profileName, input) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path22.dirname(new URL(import.meta.url).pathname);
+  const here = path23.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path22.join(here, "executables", profileName, "profile.json"),
+    path23.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path22.join(here, "..", "executables", profileName, "profile.json"),
+    path23.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path22.join(here, "..", "src", "executables", profileName, "profile.json")
+    path23.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs25.existsSync(c)) return c;
+    if (fs26.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -7192,8 +7380,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path22.join(profile.dir, shellName);
-  if (!fs25.existsSync(shellPath)) {
+  const shellPath = path23.join(profile.dir, shellName);
+  if (!fs26.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -7314,6 +7502,7 @@ async function runContainerLoop(profile, ctx, input) {
   const issueNumber = ctx.args.issue;
   let currentIdx = 0;
   let iteration = 0;
+  let knownPrUrl;
   while (currentIdx >= 0 && currentIdx < children.length) {
     iteration++;
     if (iteration > CONTAINER_MAX_ITERATIONS) {
@@ -7328,6 +7517,7 @@ async function runContainerLoop(profile, ctx, input) {
     process.stderr.write(`[kody container] step ${iteration}: invoking ${child.exec}
 `);
     const priorState = readContainerState(ctx, child, reader);
+    if (priorState.core?.prUrl) knownPrUrl = priorState.core.prUrl;
     const priorAction = priorState.executables?.[child.exec]?.lastAction;
     let actionType;
     if (priorAction && /_COMPLETED$/i.test(priorAction.type)) {
@@ -7337,8 +7527,7 @@ async function runContainerLoop(profile, ctx, input) {
     } else {
       let cliArgs;
       if (child.target === "pr") {
-        const prUrl = priorState.core?.prUrl;
-        const prNumber = prUrl ? parsePrNumber4(prUrl) : null;
+        const prNumber = knownPrUrl ? parsePrNumber4(knownPrUrl) : null;
         if (!prNumber) {
           const reason = `container child "${child.exec}" needs --pr but state.core.prUrl is unset`;
           process.stderr.write(`[kody container] aborting: ${reason}
@@ -7384,6 +7573,7 @@ async function runContainerLoop(profile, ctx, input) {
         return;
       }
       const next = readContainerState(ctx, child, reader);
+      if (next.core?.prUrl) knownPrUrl = next.core.prUrl;
       ctx.data.taskState = next;
       const actionFromState = next.core?.lastOutcome?.type;
       actionType = actionFromState ?? (childOut.exitCode === 0 ? "RUN_COMPLETED" : "RUN_FAILED");
@@ -7420,16 +7610,25 @@ async function runContainerLoop(profile, ctx, input) {
     currentIdx = nextIdx;
   }
 }
-function readContainerState(ctx, _child, reader) {
+function readContainerState(ctx, child, reader) {
   const issueNumber = ctx.args.issue;
+  const cached = ctx.data.taskState;
+  const prUrl = cached?.core?.prUrl;
+  const prNumber = prUrl ? parsePrNumber4(prUrl) : null;
+  if (child.target === "pr" && prNumber) {
+    try {
+      return reader("pr", prNumber, ctx.cwd);
+    } catch {
+    }
+  }
   if (issueNumber !== void 0) {
     try {
       return reader("issue", issueNumber, ctx.cwd);
     } catch {
     }
   }
-  if (ctx.data.taskState && typeof ctx.data.taskState === "object") {
-    return ctx.data.taskState;
+  if (cached && typeof cached === "object") {
+    return cached;
   }
   return {
     schemaVersion: 1,
@@ -7552,14 +7751,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs26.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs26.existsSync(path23.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs26.existsSync(path23.join(cwd, "bun.lockb"))) return "bun";
+  if (fs27.existsSync(path24.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs27.existsSync(path24.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs27.existsSync(path24.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync25(cmd, args, {
+    execFileSync27(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -7572,7 +7771,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync25("which", [bin], { stdio: "pipe" });
+    execFileSync27("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -7606,7 +7805,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync25("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync27("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -7616,16 +7815,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync25("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync27("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync25("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync27("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync25("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync27("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -7634,11 +7833,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path23.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path24.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs26.existsSync(logPath)) {
-      const content = fs26.readFileSync(logPath, "utf-8");
+    if (fs27.existsSync(logPath)) {
+      const content = fs27.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -7663,7 +7862,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path23.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path24.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -7673,9 +7872,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 && fs26.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs27.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs26.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs27.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);
@@ -7890,15 +8089,15 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path24.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path24.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs27.existsSync(path24.join(cwd, p)));
+  const sessionFile = path25.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path25.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs28.existsSync(path25.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync26("git", ["add", ...paths], opts);
-    execFileSync26("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
-    execFileSync26("git", ["push", "--quiet", "origin", "HEAD"], opts);
+    execFileSync28("git", ["add", "-f", ...paths], opts);
+    execFileSync28("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync28("git", ["push", "--quiet", "origin", "HEAD"], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[kody:chat] commit/push skipped: ${msg}
@@ -7930,7 +8129,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path24.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path25.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -7974,7 +8173,21 @@ ${CHAT_HELP}`);
   const sessionFile = sessionFilePath(cwd, sessionId);
   if (args.initMessage) seedInitialMessage(sessionFile, args.initMessage);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
+  const meta = readMeta(sessionFile);
   try {
+    if (meta?.mode === "interactive") {
+      const result2 = await runInteractiveMode({
+        sessionId,
+        cwd,
+        model,
+        litellmUrl: litellm?.url ?? null,
+        sink,
+        meta,
+        verbose: args.verbose,
+        quiet: args.quiet
+      });
+      return result2.exitCode;
+    }
     const result = await runChatTurn({
       sessionId,
       sessionFile,