@kody-ade/kody-engine 0.3.57 → 0.3.60

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.57",
+  version: "0.3.60",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -28,6 +28,7 @@ var package_default = {
     prepublishOnly: "pnpm build"
   },
   dependencies: {
+    "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119"
   },
   devDependencies: {
@@ -51,8 +52,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync26 } from "child_process";
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -186,9 +187,23 @@ function loadConfig(projectDir = process.cwd()) {
     defaultPrExecutable: typeof raw.defaultPrExecutable === "string" && raw.defaultPrExecutable.length > 0 ? raw.defaultPrExecutable : "fix",
     aliases: mergeAliases(raw.aliases),
     classify: parseClassifyConfig(raw.classify),
-    release: parseReleaseConfig(raw.release)
+    release: parseReleaseConfig(raw.release),
+    missions: parseMissionsConfig(raw.missions)
   };
 }
+function parseMissionsConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  if (r.stateBackend === "contents-api" || r.stateBackend === "local-file") {
+    out.stateBackend = r.stateBackend;
+  } else if (typeof r.stateBackend === "string") {
+    throw new Error(
+      `kody.config.json: missions.stateBackend must be "contents-api" or "local-file", got "${r.stateBackend}"`
+    );
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 var BUILTIN_ALIASES = {
   build: "run",
   orchestrate: "bug",
@@ -606,8 +621,8 @@ async function emit(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync25 } from "child_process";
-import * as fs25 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 
 // src/dispatch.ts
 import * as fs6 from "fs";
@@ -959,9 +974,9 @@ function coerceBare(spec, value) {
 }
 
 // src/executor.ts
-import { spawnSync } from "child_process";
-import * as fs24 from "fs";
-import * as path21 from "path";
+import { spawn as spawn3 } from "child_process";
+import * as fs25 from "fs";
+import * as path22 from "path";
 
 // src/litellm.ts
 import { execFileSync, spawn } from "child_process";
@@ -2851,62 +2866,8 @@ function failedAction(reason) {
 }
 
 // src/scripts/dispatchMissionFileTicks.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-var dispatchMissionFileTicks = async (ctx, _profile, args) => {
-  ctx.skipAgent = true;
-  const targetExecutable = String(args?.targetExecutable ?? "");
-  if (!targetExecutable) {
-    throw new Error("dispatchMissionFileTicks: `with.targetExecutable` is required");
-  }
-  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
-  const slugArg = String(args?.slugArg ?? "mission");
-  const slugs = listMissionSlugs(path15.join(ctx.cwd, missionsDir));
-  ctx.data.missionSlugCount = slugs.length;
-  if (slugs.length === 0) {
-    process.stdout.write(`[missions] no mission files in ${missionsDir}
-`);
-    return;
-  }
-  process.stdout.write(`[missions] ticking ${slugs.length} mission(s) via ${targetExecutable}
-`);
-  const results = [];
-  for (const slug of slugs) {
-    process.stdout.write(`[missions] \u2192 tick ${slug}
-`);
-    try {
-      const out = await runExecutable(targetExecutable, {
-        cliArgs: { [slugArg]: slug },
-        cwd: ctx.cwd,
-        config: ctx.config,
-        verbose: ctx.verbose,
-        quiet: ctx.quiet
-      });
-      results.push({ slug, exitCode: out.exitCode, reason: out.reason });
-      if (out.exitCode !== 0) {
-        process.stderr.write(`[missions] tick ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
-`);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[missions] tick ${slug} crashed: ${msg}
-`);
-      results.push({ slug, exitCode: 99, reason: msg });
-    }
-  }
-  ctx.data.missionTickResults = results;
-  ctx.output.exitCode = 0;
-};
-function listMissionSlugs(absDir) {
-  if (!fs16.existsSync(absDir)) return [];
-  let entries;
-  try {
-    entries = fs16.readdirSync(absDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, "")).filter((slug) => slug.length > 0 && !slug.startsWith("_") && !slug.startsWith(".")).sort();
-}
+import * as fs17 from "fs";
+import * as path16 from "path";
 
 // src/issue.ts
 import { execFileSync as execFileSync9 } from "child_process";
@@ -3049,6 +3010,411 @@ function postPrReviewComment(prNumber, body, cwd) {
   }
 }
 
+// src/scripts/issueStateComment.ts
+function isStateEnvelope(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return o.version === 1 && typeof o.rev === "number" && Number.isInteger(o.rev) && o.rev >= 0 && typeof o.cursor === "string" && typeof o.done === "boolean" && o.data !== null && typeof o.data === "object" && !Array.isArray(o.data);
+}
+function initialStateEnvelope(cursor = "seed") {
+  return { version: 1, rev: 0, cursor, data: {}, done: false };
+}
+function formatStateCommentBody(marker, state) {
+  return `<!-- ${marker} -->
+
+\`\`\`json
+${JSON.stringify(state, null, 2)}
+\`\`\`
+`;
+}
+function parseStateCommentBody(marker, body) {
+  const markerLine = `<!-- ${marker} -->`;
+  if (!body.trimStart().startsWith(markerLine)) return null;
+  const fenceOpen = body.indexOf("```json");
+  if (fenceOpen === -1) return null;
+  const after = body.slice(fenceOpen + "```json".length);
+  const fenceClose = after.indexOf("```");
+  if (fenceClose === -1) return null;
+  const jsonText = after.slice(0, fenceClose).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return null;
+  }
+  return isStateEnvelope(parsed) ? parsed : null;
+}
+function listIssueComments(owner, repo, issueNumber, cwd) {
+  const raw = gh2(["api", "--paginate", `repos/${owner}/${repo}/issues/${issueNumber}/comments`], { cwd });
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((c) => typeof c.id === "number" && typeof c.node_id === "string" && typeof c.body === "string").map((c) => ({ id: c.id, node_id: c.node_id, body: c.body }));
+}
+function findStateComment2(owner, repo, issueNumber, marker, cwd) {
+  const comments = listIssueComments(owner, repo, issueNumber, cwd);
+  for (const c of comments) {
+    const state = parseStateCommentBody(marker, c.body);
+    if (!state) continue;
+    return { commentId: c.id, commentNodeId: c.node_id, state };
+  }
+  return null;
+}
+function createStateComment(owner, repo, issueNumber, marker, state, cwd) {
+  const body = formatStateCommentBody(marker, state);
+  const raw = gh2(["api", "--method", "POST", `repos/${owner}/${repo}/issues/${issueNumber}/comments`, "--input", "-"], {
+    cwd,
+    input: JSON.stringify({ body })
+  });
+  const parsed = JSON.parse(raw);
+  try {
+    minimizeComment(parsed.node_id, cwd);
+  } catch {
+  }
+  return { commentId: parsed.id, commentNodeId: parsed.node_id, state };
+}
+function updateStateComment(owner, repo, commentId, commentNodeId, marker, state, cwd) {
+  const body = formatStateCommentBody(marker, state);
+  gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/issues/comments/${commentId}`, "--input", "-"], {
+    cwd,
+    input: JSON.stringify({ body })
+  });
+  try {
+    minimizeComment(commentNodeId, cwd);
+  } catch {
+  }
+}
+function minimizeComment(nodeId, cwd) {
+  const mutation = "mutation($id: ID!) { minimizeComment(input: { classifier: OUTDATED, subjectId: $id }) { minimizedComment { isMinimized } } }";
+  gh2(["api", "graphql", "-f", `query=${mutation}`, "-f", `id=${nodeId}`], { cwd });
+}
+
+// src/scripts/missionState/backend.ts
+function isStateUnchanged(prev, next) {
+  if (prev.cursor !== next.cursor) return false;
+  if (prev.done !== next.done) return false;
+  return JSON.stringify(prev.data) === JSON.stringify(next.data);
+}
+function stateFilePath(missionsDir, slug) {
+  return `${missionsDir.replace(/\/+$/, "")}/${slug}.state.json`;
+}
+function slugFromStateFilePath(filePath) {
+  const last = filePath.split("/").pop() ?? filePath;
+  return last.replace(/\.state\.json$/i, "");
+}
+
+// src/scripts/missionState/contentsApiBackend.ts
+var ContentsApiBackend = class {
+  name = "contents-api";
+  owner;
+  repo;
+  missionsDir;
+  cwd;
+  constructor(opts) {
+    if (!opts.owner || !opts.repo) {
+      throw new Error("ContentsApiBackend: owner and repo are required");
+    }
+    this.owner = opts.owner;
+    this.repo = opts.repo;
+    this.missionsDir = opts.missionsDir;
+    this.cwd = opts.cwd;
+  }
+  load(slug) {
+    const filePath = stateFilePath(this.missionsDir, slug);
+    let raw = "";
+    try {
+      raw = gh2(["api", `/repos/${this.owner}/${this.repo}/contents/${filePath}`], { cwd: this.cwd });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/HTTP 404/i.test(msg) || /Not Found/i.test(msg)) {
+        return { path: filePath, handle: null, state: initialStateEnvelope("seed"), created: true };
+      }
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error(`ContentsApiBackend: contents API for ${filePath} did not return JSON`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error(`ContentsApiBackend: contents API for ${filePath} returned non-object`);
+    }
+    const o = parsed;
+    if (o.type !== "file" || o.encoding !== "base64" || typeof o.content !== "string") {
+      throw new Error(`ContentsApiBackend: ${filePath} is not a base64 file`);
+    }
+    const decoded = Buffer.from(o.content, "base64").toString("utf-8");
+    let envelope;
+    try {
+      envelope = JSON.parse(decoded);
+    } catch {
+      throw new Error(`ContentsApiBackend: ${filePath} is not valid JSON`);
+    }
+    if (!isStateEnvelope(envelope)) {
+      throw new Error(`ContentsApiBackend: ${filePath} is not a StateEnvelope`);
+    }
+    return { path: filePath, handle: o.sha, state: envelope, created: false };
+  }
+  save(loaded, next) {
+    if (!loaded.created && isStateUnchanged(loaded.state, next)) {
+      return false;
+    }
+    const slug = slugFromStateFilePath(loaded.path);
+    const body = JSON.stringify(next, null, 2) + "\n";
+    const payload = {
+      message: `chore(missions): update state for ${slug} (rev ${next.rev})`,
+      content: Buffer.from(body, "utf-8").toString("base64")
+    };
+    if (typeof loaded.handle === "string") payload.sha = loaded.handle;
+    gh2(["api", "--method", "PUT", `/repos/${this.owner}/${this.repo}/contents/${loaded.path}`, "--input", "-"], {
+      cwd: this.cwd,
+      input: JSON.stringify(payload)
+    });
+    return true;
+  }
+};
+
+// src/scripts/missionState/localFileBackend.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+var LocalFileBackend = class {
+  name = "local-file";
+  cwd;
+  missionsDir;
+  absDir;
+  owner;
+  repo;
+  cache;
+  constructor(opts) {
+    if (!opts.cwd) throw new Error("LocalFileBackend: cwd is required");
+    if (!opts.missionsDir) throw new Error("LocalFileBackend: missionsDir is required");
+    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.owner = opts.owner;
+    this.repo = opts.repo;
+    this.cache = opts.cache ?? defaultCacheAdapter();
+  }
+  /**
+   * Restore the mission directory from the most recent Actions cache entry
+   * for this repo. No-op when not running in Actions or when no cache exists.
+   */
+  async hydrate() {
+    if (!this.cache.isAvailable()) {
+      process.stdout.write(`[missions/state] hydrate skipped: actions cache unavailable
+`);
+      return;
+    }
+    fs16.mkdirSync(this.absDir, { recursive: true });
+    const prefix = this.cacheKeyPrefix();
+    const probeKey = `${prefix}probe-${Date.now()}`;
+    try {
+      const matched = await this.cache.restore([this.absDir], probeKey, [prefix]);
+      if (matched) {
+        process.stdout.write(`[missions/state] hydrate hit: ${matched}
+`);
+      } else {
+        process.stdout.write(`[missions/state] hydrate miss (cold start)
+`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[missions/state] hydrate failed (continuing): ${msg}
+`);
+    }
+  }
+  /**
+   * Save the mission directory to the Actions cache under a unique key.
+   * No-op when not running in Actions. Errors are logged, never thrown —
+   * callers run this in a finally block and must not swallow real errors.
+   */
+  async persist() {
+    if (!this.cache.isAvailable()) {
+      process.stdout.write(`[missions/state] persist skipped: actions cache unavailable
+`);
+      return;
+    }
+    if (!fs16.existsSync(this.absDir)) {
+      return;
+    }
+    const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
+    try {
+      await this.cache.save([this.absDir], key);
+      process.stdout.write(`[missions/state] persist saved: ${key}
+`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[missions/state] persist failed (continuing): ${msg}
+`);
+    }
+  }
+  load(slug) {
+    const relPath = stateFilePath(this.missionsDir, slug);
+    const absPath = path15.join(this.cwd, relPath);
+    if (!fs16.existsSync(absPath)) {
+      return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
+    }
+    const raw = fs16.readFileSync(absPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`LocalFileBackend: ${relPath} is not valid JSON: ${msg}`);
+    }
+    if (!isStateEnvelope(parsed)) {
+      throw new Error(`LocalFileBackend: ${relPath} is not a StateEnvelope`);
+    }
+    return { path: relPath, handle: null, state: parsed, created: false };
+  }
+  save(loaded, next) {
+    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 body = JSON.stringify(next, null, 2) + "\n";
+    fs16.writeFileSync(absPath, body, "utf-8");
+    return true;
+  }
+  cacheKeyPrefix() {
+    return `kody-mission-state-${sanitizeKey(this.owner)}-${sanitizeKey(this.repo)}-`;
+  }
+};
+function sanitizeKey(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function defaultCacheAdapter() {
+  let mod = null;
+  const load = async () => {
+    if (!mod) {
+      mod = await import("@actions/cache");
+    }
+    return mod;
+  };
+  const available = () => {
+    if (process.env.GITHUB_ACTIONS !== "true") return false;
+    return Boolean(process.env.ACTIONS_CACHE_URL || process.env.ACTIONS_RESULTS_URL);
+  };
+  return {
+    isAvailable: available,
+    async restore(paths, primaryKey, restoreKeys) {
+      if (!available()) return void 0;
+      const m = await load();
+      return m.restoreCache(paths, primaryKey, restoreKeys);
+    },
+    async save(paths, primaryKey) {
+      if (!available()) return;
+      const m = await load();
+      try {
+        await m.saveCache(paths, primaryKey);
+      } catch (err) {
+        const name = err?.name ?? "";
+        if (name === "ReserveCacheError") return;
+        throw err;
+      }
+    }
+  };
+}
+
+// src/scripts/missionState/index.ts
+function resolveBackend(opts) {
+  const owner = opts.config.github?.owner;
+  const repo = opts.config.github?.repo;
+  if (!owner || !repo) {
+    throw new Error("resolveBackend: config.github.owner and config.github.repo must be set");
+  }
+  const requested = opts.config.missions?.stateBackend ?? "contents-api";
+  switch (requested) {
+    case "contents-api":
+      return new ContentsApiBackend({ owner, repo, missionsDir: opts.missionsDir, cwd: opts.cwd });
+    case "local-file":
+      return new LocalFileBackend({ cwd: opts.cwd, missionsDir: opts.missionsDir, owner, repo });
+    default: {
+      const _exhaustive = requested;
+      throw new Error(`resolveBackend: unknown stateBackend "${String(_exhaustive)}"`);
+    }
+  }
+}
+
+// src/scripts/dispatchMissionFileTicks.ts
+var dispatchMissionFileTicks = async (ctx, _profile, args) => {
+  ctx.skipAgent = true;
+  const targetExecutable = String(args?.targetExecutable ?? "");
+  if (!targetExecutable) {
+    throw new Error("dispatchMissionFileTicks: `with.targetExecutable` is required");
+  }
+  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
+  const slugArg = String(args?.slugArg ?? "mission");
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  if (backend.hydrate) {
+    await backend.hydrate();
+  }
+  try {
+    const slugs = listMissionSlugs(path16.join(ctx.cwd, missionsDir));
+    ctx.data.missionSlugCount = slugs.length;
+    if (slugs.length === 0) {
+      process.stdout.write(`[missions] no mission files in ${missionsDir}
+`);
+      return;
+    }
+    process.stdout.write(`[missions] ticking ${slugs.length} mission(s) via ${targetExecutable}
+`);
+    const results = [];
+    for (const slug of slugs) {
+      process.stdout.write(`[missions] \u2192 tick ${slug}
+`);
+      try {
+        const out = await runExecutable(targetExecutable, {
+          cliArgs: { [slugArg]: slug },
+          cwd: ctx.cwd,
+          config: ctx.config,
+          verbose: ctx.verbose,
+          quiet: ctx.quiet
+        });
+        results.push({ slug, exitCode: out.exitCode, reason: out.reason });
+        if (out.exitCode !== 0) {
+          process.stderr.write(`[missions] tick ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
+`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[missions] tick ${slug} crashed: ${msg}
+`);
+        results.push({ slug, exitCode: 99, reason: msg });
+      }
+    }
+    ctx.data.missionTickResults = results;
+    ctx.output.exitCode = 0;
+  } finally {
+    if (backend.persist) {
+      try {
+        await backend.persist();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[missions] backend persist failed: ${msg}
+`);
+      }
+    }
+  }
+};
+function listMissionSlugs(absDir) {
+  if (!fs17.existsSync(absDir)) return [];
+  let entries;
+  try {
+    entries = fs17.readdirSync(absDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, "")).filter((slug) => slug.length > 0 && !slug.startsWith("_") && !slug.startsWith(".")).sort();
+}
+
 // src/scripts/dispatchMissionTicks.ts
 var dispatchMissionTicks = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
@@ -3681,7 +4047,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 
 // src/gha.ts
 import { execFileSync as execFileSync12 } from "child_process";
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -3692,10 +4058,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs17.existsSync(eventPath)) return;
+  if (!eventPath || !fs18.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs17.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs18.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -3935,22 +4301,22 @@ function tryPostPr2(prNumber, body, cwd) {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path16.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs18.existsSync(full)) {
+  const full = path17.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs19.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs18.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs19.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -3960,9 +4326,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs19.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs19.existsSync(path17.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs19.existsSync(path17.join(cwd, "bun.lockb"))) return "bun";
+  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";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -4084,33 +4450,33 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path17.join(cwd, "kody.config.json");
-  if (fs19.existsSync(configPath) && !force) {
+  const configPath = path18.join(cwd, "kody.config.json");
+  if (fs20.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs19.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs20.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path17.join(cwd, ".github", "workflows");
-  const workflowPath = path17.join(workflowDir, "kody.yml");
-  if (fs19.existsSync(workflowPath) && !force) {
+  const workflowDir = path18.join(cwd, ".github", "workflows");
+  const workflowPath = path18.join(workflowDir, "kody.yml");
+  if (fs20.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs19.mkdirSync(workflowDir, { recursive: true });
-    fs19.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs20.mkdirSync(workflowDir, { recursive: true });
+    fs20.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs19.existsSync(path17.join(cwd, "src/app")) || fs19.existsSync(path17.join(cwd, "app")) || fs19.existsSync(path17.join(cwd, "pages"));
+  const hasUi = fs20.existsSync(path18.join(cwd, "src/app")) || fs20.existsSync(path18.join(cwd, "app")) || fs20.existsSync(path18.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path17.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs19.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path18.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs20.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs19.mkdirSync(path17.dirname(qaGuidePath), { recursive: true });
+      fs20.mkdirSync(path18.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs19.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs20.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
@@ -4122,12 +4488,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path17.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs19.existsSync(target) && !force) {
+    const target = path18.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs20.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs19.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs20.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -4238,89 +4604,6 @@ var loadIssueContext = async (ctx) => {
   ctx.data.commentTargetNumber = issueNumber;
 };
 
-// src/scripts/issueStateComment.ts
-function isStateEnvelope(x) {
-  if (x === null || typeof x !== "object") return false;
-  const o = x;
-  return o.version === 1 && typeof o.rev === "number" && Number.isInteger(o.rev) && o.rev >= 0 && typeof o.cursor === "string" && typeof o.done === "boolean" && o.data !== null && typeof o.data === "object" && !Array.isArray(o.data);
-}
-function initialStateEnvelope(cursor = "seed") {
-  return { version: 1, rev: 0, cursor, data: {}, done: false };
-}
-function formatStateCommentBody(marker, state) {
-  return `<!-- ${marker} -->
-
-\`\`\`json
-${JSON.stringify(state, null, 2)}
-\`\`\`
-`;
-}
-function parseStateCommentBody(marker, body) {
-  const markerLine = `<!-- ${marker} -->`;
-  if (!body.trimStart().startsWith(markerLine)) return null;
-  const fenceOpen = body.indexOf("```json");
-  if (fenceOpen === -1) return null;
-  const after = body.slice(fenceOpen + "```json".length);
-  const fenceClose = after.indexOf("```");
-  if (fenceClose === -1) return null;
-  const jsonText = after.slice(0, fenceClose).trim();
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonText);
-  } catch {
-    return null;
-  }
-  return isStateEnvelope(parsed) ? parsed : null;
-}
-function listIssueComments(owner, repo, issueNumber, cwd) {
-  const raw = gh2(["api", "--paginate", `repos/${owner}/${repo}/issues/${issueNumber}/comments`], { cwd });
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return [];
-  }
-  if (!Array.isArray(parsed)) return [];
-  return parsed.filter((c) => typeof c.id === "number" && typeof c.node_id === "string" && typeof c.body === "string").map((c) => ({ id: c.id, node_id: c.node_id, body: c.body }));
-}
-function findStateComment2(owner, repo, issueNumber, marker, cwd) {
-  const comments = listIssueComments(owner, repo, issueNumber, cwd);
-  for (const c of comments) {
-    const state = parseStateCommentBody(marker, c.body);
-    if (!state) continue;
-    return { commentId: c.id, commentNodeId: c.node_id, state };
-  }
-  return null;
-}
-function createStateComment(owner, repo, issueNumber, marker, state, cwd) {
-  const body = formatStateCommentBody(marker, state);
-  const raw = gh2(["api", "--method", "POST", `repos/${owner}/${repo}/issues/${issueNumber}/comments`, "--input", "-"], {
-    cwd,
-    input: JSON.stringify({ body })
-  });
-  const parsed = JSON.parse(raw);
-  try {
-    minimizeComment(parsed.node_id, cwd);
-  } catch {
-  }
-  return { commentId: parsed.id, commentNodeId: parsed.node_id, state };
-}
-function updateStateComment(owner, repo, commentId, commentNodeId, marker, state, cwd) {
-  const body = formatStateCommentBody(marker, state);
-  gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/issues/comments/${commentId}`, "--input", "-"], {
-    cwd,
-    input: JSON.stringify({ body })
-  });
-  try {
-    minimizeComment(commentNodeId, cwd);
-  } catch {
-  }
-}
-function minimizeComment(nodeId, cwd) {
-  const mutation = "mutation($id: ID!) { minimizeComment(input: { classifier: OUTDATED, subjectId: $id }) { minimizedComment { isMinimized } } }";
-  gh2(["api", "graphql", "-f", `query=${mutation}`, "-f", `id=${nodeId}`], { cwd });
-}
-
 // src/scripts/loadIssueStateComment.ts
 var loadIssueStateComment = async (ctx, _profile, args) => {
   const marker = String(args?.marker ?? "");
@@ -4348,75 +4631,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadMissionFromFile.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
-
-// src/scripts/missionStateFile.ts
-function stateFilePath(missionsDir, slug) {
-  return `${missionsDir.replace(/\/+$/, "")}/${slug}.state.json`;
-}
-function loadMissionState(owner, repo, filePath, cwd) {
-  let raw = "";
-  try {
-    raw = gh2(["api", `/repos/${owner}/${repo}/contents/${filePath}`], { cwd });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/HTTP 404/i.test(msg) || /Not Found/i.test(msg)) {
-      return { path: filePath, sha: null, state: initialStateEnvelope("seed"), created: true };
-    }
-    throw err;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`loadMissionState: contents API for ${filePath} did not return JSON`);
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`loadMissionState: contents API for ${filePath} returned non-object`);
-  }
-  const o = parsed;
-  if (o.type !== "file" || o.encoding !== "base64" || typeof o.content !== "string") {
-    throw new Error(`loadMissionState: ${filePath} is not a base64 file`);
-  }
-  const decoded = Buffer.from(o.content, "base64").toString("utf-8");
-  let envelope;
-  try {
-    envelope = JSON.parse(decoded);
-  } catch {
-    throw new Error(`loadMissionState: ${filePath} is not valid JSON`);
-  }
-  if (!isStateEnvelope(envelope)) {
-    throw new Error(`loadMissionState: ${filePath} is not a StateEnvelope`);
-  }
-  return { path: filePath, sha: o.sha, state: envelope, created: false };
-}
-function writeMissionState(owner, repo, loaded, next, cwd) {
-  if (!loaded.created && deepEqualsState(loaded.state, next)) {
-    return false;
-  }
-  const body = JSON.stringify(next, null, 2) + "\n";
-  const payload = {
-    message: `chore(missions): update state for ${stateFileSlug(loaded.path)} (rev ${next.rev})`,
-    content: Buffer.from(body, "utf-8").toString("base64")
-  };
-  if (loaded.sha) payload.sha = loaded.sha;
-  gh2(["api", "--method", "PUT", `/repos/${owner}/${repo}/contents/${loaded.path}`, "--input", "-"], {
-    cwd,
-    input: JSON.stringify(payload)
-  });
-  return true;
-}
-function deepEqualsState(a, b) {
-  if (a.cursor !== b.cursor || a.done !== b.done) return false;
-  return JSON.stringify(a.data) === JSON.stringify(b.data);
-}
-function stateFileSlug(filePath) {
-  const last = filePath.split("/").pop() ?? filePath;
-  return last.replace(/\.state\.json$/i, "");
-}
-
-// src/scripts/loadMissionFromFile.ts
+import * as fs21 from "fs";
+import * as path19 from "path";
 var loadMissionFromFile = async (ctx, _profile, args) => {
   const missionsDir = String(args?.missionsDir ?? ".kody/missions");
   const slugArg = String(args?.slugArg ?? "mission");
@@ -4424,18 +4640,14 @@ var loadMissionFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadMissionFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const owner = ctx.config.github.owner;
-  const repo = ctx.config.github.repo;
-  if (!owner || !repo) {
-    throw new Error("loadMissionFromFile: ctx.config.github.owner/repo must be set");
-  }
-  const absPath = path18.join(ctx.cwd, missionsDir, `${slug}.md`);
-  if (!fs20.existsSync(absPath)) {
+  const absPath = path19.join(ctx.cwd, missionsDir, `${slug}.md`);
+  if (!fs21.existsSync(absPath)) {
     throw new Error(`loadMissionFromFile: mission file not found: ${absPath}`);
   }
-  const raw = fs20.readFileSync(absPath, "utf-8");
+  const raw = fs21.readFileSync(absPath, "utf-8");
   const { title, body } = parseMissionFile(raw, slug);
-  const loaded = loadMissionState(owner, repo, stateFilePath(missionsDir, slug), ctx.cwd);
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  const loaded = await backend.load(slug);
   ctx.data.missionSlug = slug;
   ctx.data.missionTitle = title;
   ctx.data.missionIntent = body;
@@ -4566,16 +4778,16 @@ var loadTaskState = async (ctx) => {
 };
 
 // src/scripts/loadVaultContext.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 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 = path19.join(ctx.cwd, VAULT_DIR_RELATIVE);
-  if (!fs21.existsSync(vaultAbs)) {
+  const vaultAbs = path20.join(ctx.cwd, VAULT_DIR_RELATIVE);
+  if (!fs22.existsSync(vaultAbs)) {
     ctx.data.vaultContext = "";
     return;
   }
@@ -4600,21 +4812,21 @@ function collectPages(vaultAbs) {
   walkMd(vaultAbs, (file) => {
     let stat;
     try {
-      stat = fs21.statSync(file);
+      stat = fs22.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs21.readFileSync(file, "utf-8");
+      raw = fs22.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path19.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path20.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path19.relative(vaultAbs, file),
+      relPath: path20.relative(vaultAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -4682,16 +4894,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs21.readdirSync(dir);
+      names = fs22.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path19.join(dir, name);
+      const full = path20.join(dir, name);
       let stat;
       try {
-        stat = fs21.statSync(full);
+        stat = fs22.statSync(full);
       } catch {
         continue;
       }
@@ -4714,15 +4926,15 @@ var markFlowSuccess = async (ctx) => {
 
 // src/scripts/memorizeFlow.ts
 import { execFileSync as execFileSync15 } from "child_process";
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 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 = path20.join(ctx.cwd, VAULT_DIR_RELATIVE2);
+  const vaultAbs = path21.join(ctx.cwd, VAULT_DIR_RELATIVE2);
   ensureBranch(ctx, vaultAbs);
   if (ctx.skipAgent) return;
   const sinceIso = computeSinceIso(vaultAbs);
@@ -4732,8 +4944,8 @@ var memorizeFlow = async (ctx) => {
   const recent = fetchRecentPrs(ctx.cwd, sinceIso);
   ctx.data.recentPrs = formatRecentPrs(recent);
   ctx.data.recentPrCount = recent.length;
-  if (!fs22.existsSync(vaultAbs)) {
-    fs22.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs23.existsSync(vaultAbs)) {
+    fs23.mkdirSync(vaultAbs, { recursive: true });
   }
   ctx.data.vaultIndex = formatVaultIndex(vaultAbs);
   if (recent.length === 0) {
@@ -4765,18 +4977,18 @@ function ensureBranch(ctx, vaultAbs) {
     }
   }
   ctx.data.branch = branch;
-  if (!fs22.existsSync(vaultAbs)) {
-    fs22.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs23.existsSync(vaultAbs)) {
+    fs23.mkdirSync(vaultAbs, { recursive: true });
   }
 }
 function computeSinceIso(vaultAbs) {
   const fallback = new Date(Date.now() - DEFAULT_LOOKBACK_HOURS * 60 * 60 * 1e3).toISOString();
-  if (!fs22.existsSync(vaultAbs)) return fallback;
+  if (!fs23.existsSync(vaultAbs)) return fallback;
   let latest = "";
   walkMd2(vaultAbs, (file) => {
     let raw;
     try {
-      raw = fs22.readFileSync(file, "utf-8");
+      raw = fs23.readFileSync(file, "utf-8");
     } catch {
       return;
     }
@@ -4853,10 +5065,10 @@ function formatVaultIndex(vaultAbs) {
   const entries = [];
   walkMd2(vaultAbs, (file) => {
     if (entries.length >= MAX_VAULT_INDEX_ENTRIES) return;
-    const rel = path20.relative(vaultAbs, file);
+    const rel = path21.relative(vaultAbs, file);
     let title = rel;
     try {
-      const raw = fs22.readFileSync(file, "utf-8");
+      const raw = fs23.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})`;
@@ -4868,22 +5080,22 @@ function formatVaultIndex(vaultAbs) {
   return entries.join("\n");
 }
 function walkMd2(root, visit) {
-  if (!fs22.existsSync(root)) return;
+  if (!fs23.existsSync(root)) return;
   const stack = [root];
   while (stack.length > 0) {
     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;
       }
@@ -5212,7 +5424,15 @@ var postIssueComment2 = async (ctx) => {
   const isFailure = failureReason.length > 0;
   const justPushedToExistingPr = prAction === "updated" && commitResult?.committed === true;
   const successMsg = justPushedToExistingPr ? `\u2705 kody pushed to ${prUrl}` : prAction === "updated" ? `\u2139\uFE0F kody made no changes \u2014 PR: ${prUrl}` : `\u2705 kody PR opened: ${prUrl}`;
-  const failurePrSuffix = prUrl ? prAction === "updated" ? ` \u2014 PR: ${prUrl}` : ` \u2014 draft PR: ${prUrl}` : "";
+  const branch = ctx.data.branch;
+  const failurePrSuffix = computeFailureSuffix({
+    prUrl,
+    prAction,
+    branch,
+    branchPushed: commitResult?.committed === true,
+    githubOwner: ctx.config.github?.owner,
+    githubRepo: ctx.config.github?.repo
+  });
   const msg = isFailure ? `\u26A0\uFE0F kody FAILED: ${truncate2(failureReason, 1500)}${failurePrSuffix}` : successMsg;
   postWith(targetType, targetNumber, msg, ctx.cwd);
   let exitCode = 0;
@@ -5224,6 +5444,13 @@ var postIssueComment2 = async (ctx) => {
   ctx.output.exitCode = exitCode;
   ctx.output.reason = failureReason || void 0;
 };
+function computeFailureSuffix(input) {
+  if (input.prUrl) {
+    return input.prAction === "updated" ? ` \u2014 PR: ${input.prUrl}` : ` \u2014 draft PR: ${input.prUrl}`;
+  }
+  if (!input.branchPushed || !input.branch || !input.githubOwner || !input.githubRepo) return "";
+  return ` \u2014 branch: https://github.com/${input.githubOwner}/${input.githubRepo}/tree/${input.branch}`;
+}
 function computeFailureReason2(ctx) {
   const misses = ctx.data.coverageMisses ?? [];
   if (misses.length > 0) return `missing tests: ${misses.map((m) => m.expectedTest).join(", ")}`;
@@ -6389,7 +6616,7 @@ var writeIssueStateComment = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeMissionStateFile.ts
-var writeMissionStateFile = async (ctx, _profile, _agentResult) => {
+var writeMissionStateFile = async (ctx, _profile, _agentResult, args) => {
   const parseError = ctx.data.nextStateParseError;
   if (parseError) {
     process.stderr.write(`[kody] mission state write skipped: ${parseError}
@@ -6406,16 +6633,13 @@ var writeMissionStateFile = async (ctx, _profile, _agentResult) => {
   if (!loaded) {
     throw new Error("writeMissionStateFile: ctx.data.missionState missing \u2014 preflight must run first");
   }
-  const owner = ctx.config.github.owner;
-  const repo = ctx.config.github.repo;
-  if (!owner || !repo) {
-    throw new Error("writeMissionStateFile: ctx.config.github.owner/repo must be set");
-  }
-  writeMissionState(owner, repo, loaded, next, ctx.cwd);
+  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  await backend.save(loaded, next);
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -6437,7 +6661,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs23.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs24.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -6620,9 +6844,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path21.join(input.cwd, ".kody");
+  const ndjsonDir = path22.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path21.isAbsolute(p) ? p : path21.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path22.isAbsolute(p) ? p : path22.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -6648,7 +6872,7 @@ async function runExecutable(profileName, input) {
     for (const entry of profile.scripts.preflight) {
       if (!shouldRun(entry, ctx)) continue;
       if (entry.shell) {
-        runShellEntry(entry, ctx, profile);
+        await runShellEntry(entry, ctx, profile);
       } else {
         const fn = preflightScripts[entry.script];
         if (!fn) return finish({ exitCode: 99, reason: `preflight script not registered: ${entry.script}` });
@@ -6671,7 +6895,7 @@ async function runExecutable(profileName, input) {
       const label = entry.script ?? entry.shell ?? "<unknown>";
       try {
         if (entry.shell) {
-          runShellEntry(entry, ctx, profile);
+          await runShellEntry(entry, ctx, profile);
         } else {
           const fn = postflightScripts[entry.script];
           if (!fn) return finish({ exitCode: 99, reason: `postflight script not registered: ${entry.script}` });
@@ -6701,17 +6925,17 @@ async function runExecutable(profileName, input) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path21.dirname(new URL(import.meta.url).pathname);
+  const here = path22.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path21.join(here, "executables", profileName, "profile.json"),
+    path22.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path21.join(here, "..", "executables", profileName, "profile.json"),
+    path22.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path21.join(here, "..", "src", "executables", profileName, "profile.json")
+    path22.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs24.existsSync(c)) return c;
+    if (fs25.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -6812,10 +7036,11 @@ function resolveShellTimeoutMs(entry) {
   }
   return DEFAULT_SHELL_TIMEOUT_MS;
 }
-function runShellEntry(entry, ctx, profile) {
+var SIGKILL_GRACE_MS = 5e3;
+async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path21.join(profile.dir, shellName);
-  if (!fs24.existsSync(shellPath)) {
+  const shellPath = path22.join(profile.dir, shellName);
+  if (!fs25.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -6831,17 +7056,63 @@ function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const r = spawnSync("bash", [shellPath, ...positional], {
+  const child = spawn3("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
-    encoding: "utf-8",
     env,
     stdio: ["pipe", "pipe", "pipe"],
-    timeout: timeoutMs
+    detached: true
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout?.on("data", (chunk) => {
+    const s = chunk.toString("utf-8");
+    stdout += s;
+    process.stdout.write(s);
+  });
+  child.stderr?.on("data", (chunk) => {
+    const s = chunk.toString("utf-8");
+    stderr += s;
+    process.stderr.write(s);
   });
-  const stdout = r.stdout ?? "";
-  const stderr = r.stderr ?? "";
-  if (stdout) process.stdout.write(stdout);
-  if (stderr) process.stderr.write(stderr);
+  let timedOut = false;
+  let killTimer;
+  let escalateTimer;
+  const result = await new Promise(
+    (resolve4) => {
+      let settled = false;
+      const settle = (code, signal, spawnErr) => {
+        if (settled) return;
+        settled = true;
+        if (killTimer) clearTimeout(killTimer);
+        if (escalateTimer) clearTimeout(escalateTimer);
+        resolve4({ code, signal, spawnErr });
+      };
+      child.on("error", (err) => settle(null, null, err));
+      child.on("close", (code, signal) => settle(code, signal));
+      if (typeof child.pid === "number") {
+        const pgid = child.pid;
+        killTimer = setTimeout(() => {
+          timedOut = true;
+          try {
+            process.kill(-pgid, "SIGTERM");
+          } catch {
+          }
+          escalateTimer = setTimeout(() => {
+            try {
+              process.kill(-pgid, "SIGKILL");
+            } catch {
+            }
+          }, SIGKILL_GRACE_MS);
+        }, timeoutMs);
+      }
+    }
+  );
+  if (result.spawnErr) {
+    ctx.skipAgent = true;
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `shell '${shellName}' failed to spawn: ${result.spawnErr.message}`;
+    return;
+  }
   if (/^KODY_SKIP_AGENT=true\s*$/m.test(stdout)) {
     ctx.skipAgent = true;
     if (ctx.output.exitCode === void 0) ctx.output.exitCode = 0;
@@ -6850,7 +7121,6 @@ function runShellEntry(entry, ctx, profile) {
   if (prUrlMatch?.[1]) ctx.output.prUrl = prUrlMatch[1].trim();
   const reasonMatch = stdout.match(/^KODY_REASON=(.+)$/m);
   if (reasonMatch?.[1]) ctx.output.reason = reasonMatch[1].trim();
-  const timedOut = r.status === null && r.signal !== null;
   if (timedOut) {
     ctx.skipAgent = true;
     const seconds = Math.round(timeoutMs / 1e3);
@@ -6858,11 +7128,11 @@ function runShellEntry(entry, ctx, profile) {
       ctx.output.exitCode = 124;
     }
     if (!ctx.output.reason) {
-      ctx.output.reason = `shell '${shellName}' timed out after ${seconds}s (signal=${r.signal})`;
+      ctx.output.reason = `shell '${shellName}' timed out after ${seconds}s (process group signalled SIGTERM/SIGKILL)`;
     }
     return;
   }
-  const exit = r.status ?? -1;
+  const exit = result.code ?? -1;
   if (exit !== 0) {
     ctx.skipAgent = true;
     if (ctx.output.exitCode === void 0 || ctx.output.exitCode === 0) {
@@ -6916,7 +7186,7 @@ Environment:
 Exit codes (inherited from kody run):
   0   success (PR opened, verify passed)
   1   agent reported FAILED (draft PR opened)
-  2   verify failed (draft PR opened)
+  2   verify failed (no PR opened \u2014 branch pushed for inspection)
   3   no commits to ship
   4   PR creation failed
   5   uncommitted changes on target branch
@@ -6978,9 +7248,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs25.existsSync(path22.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs25.existsSync(path22.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs25.existsSync(path22.join(cwd, "bun.lockb"))) return "bun";
+  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";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -7060,11 +7330,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path22.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path23.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs25.existsSync(logPath)) {
-      const content = fs25.readFileSync(logPath, "utf-8");
+    if (fs26.existsSync(logPath)) {
+      const content = fs26.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -7089,7 +7359,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path22.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path23.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -7099,9 +7369,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 && fs25.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs26.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs25.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs26.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);
@@ -7316,9 +7586,9 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path23.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path23.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs26.existsSync(path23.join(cwd, p)));
+  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)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -7356,7 +7626,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path23.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path24.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -7443,7 +7713,7 @@ directory to add a new command.
 Exit codes:
   0   success (PR opened, verify passed \u2014 or resolve produced a merge commit)
   1   agent reported FAILED (draft PR opened)
-  2   verify failed (draft PR opened) \u2014 skipped in resolve mode
+  2   verify failed (no PR opened \u2014 branch pushed for inspection) \u2014 skipped in resolve mode
   3   no commits to ship (also the resolve clean-merge short-circuit)
   4   PR creation failed
   5   uncommitted changes on target branch