@kody-ade/kody-engine 0.3.58 → 0.3.61

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.58",
+  version: "0.3.61",
   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",
@@ -525,12 +540,35 @@ var CHAT_SYSTEM_PROMPT = [
   "      pytest, go test, cargo, etc., whatever the project uses).",
   "    - standard Unix utilities (curl, jq, sed, awk, find, etc.).",
   "",
-  "# How to answer",
-  "If the user asks about repo content, code, history, issues, PRs, CI status, or",
-  "anything else knowable from the checkout or GitHub API, INVESTIGATE FIRST with",
-  "the tools above and answer from what you find. Do not say 'I don't have access'",
-  "\u2014 if you have not yet tried, try. Only fall back to a limitation statement after",
-  "a tool actually fails, and in that case quote the failing command and its error.",
+  "# Investigate before you answer (HARD RULE)",
+  "Do not answer from assumptions, training memory, or what the code 'probably'",
+  "does. Before replying to any question about this repo \u2014 its code, behavior,",
+  "config, history, issues, PRs, CI, or dependencies \u2014 you MUST first ground the",
+  "answer in concrete evidence collected in THIS session.",
+  "",
+  "Required pre-reply protocol for every non-trivial question:",
+  "1. Locate the relevant code with Glob/Grep. Don't guess paths.",
+  "2. Read the actual files end-to-end (or the relevant ranges). Read more than",
+  "   you think you need \u2014 adjacent files, callers, tests, types.",
+  "3. If behavior depends on runtime state (CI, PRs, issues, git history), run",
+  "   the matching `gh` / `git` / shell command and look at the real output.",
+  "4. Only after steps 1\u20133 do you compose the reply.",
+  "",
+  "Every factual claim about this repo in your reply must be backed by something",
+  "you actually read or executed in this session. Cite the source inline:",
+  "`path/to/file.ts:42`, `git show <sha>`, `gh pr view 123`, etc. If you cannot",
+  "produce a citation, you have not investigated enough \u2014 go back to step 1.",
+  "",
+  "Forbidden phrasings unless preceded by an actual tool failure quoted in your",
+  "reply: 'I don't have access', 'I can't see', 'it likely', 'it probably',",
+  "'typically this would', 'based on common patterns'. These are tells that you",
+  "skipped investigation \u2014 replace them with the result of the investigation.",
+  "",
+  "Speed is not the goal \u2014 correctness grounded in this specific codebase is.",
+  "Spend the tool calls. A short answer with three citations beats a long answer",
+  "with zero. If a question is genuinely trivial (greeting, clarification,",
+  "definition of a generic term unrelated to this repo), you may answer without",
+  "tools \u2014 but err on the side of investigating.",
   "",
   "Do not invent file paths, commit SHAs, line numbers, or command output. If you",
   "cite something concrete, you must have just read or run it in this session."
@@ -606,8 +644,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";
@@ -960,8 +998,8 @@ function coerceBare(spec, value) {
 
 // src/executor.ts
 import { spawn as spawn3 } from "child_process";
-import * as fs24 from "fs";
-import * as path21 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 
 // src/litellm.ts
 import { execFileSync, spawn } from "child_process";
@@ -1981,7 +2019,7 @@ function parseAgentResult(finalText) {
     };
   }
   const hasDoneMarker = DONE_RE.test(text);
-  const hasCommitMsg = /^[\s>*_#`~\-]*COMMIT_MSG\s*:/im.test(text);
+  const hasCommitMsg = /^[\s>*_#`~-]*COMMIT_MSG\s*:/im.test(text);
   if (!hasDoneMarker && !hasCommitMsg) {
     return {
       done: false,
@@ -1993,7 +2031,7 @@ function parseAgentResult(finalText) {
       failureReason: "no DONE or FAILED marker in agent output"
     };
   }
-  const commitMatch = text.match(/^[\s>*_#`~\-]*COMMIT_MSG[\s>*_#`~\-]*\s*:\s*(.+)$/im);
+  const commitMatch = text.match(/^[\s>*_#`~-]*COMMIT_MSG[\s>*_#`~-]*\s*:\s*(.+)$/im);
   const commitMessage = commitMatch ? stripMarkdownEmphasis(commitMatch[1]) : "";
   const feedbackActions = extractBlock(
     text,
@@ -2851,62 +2889,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 +3033,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 +4070,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 +4081,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 +4324,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 +4349,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 +4473,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 +4511,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 +4627,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 +4654,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 +4663,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 +4801,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 +4835,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 +4917,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 +4949,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 +4967,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 +5000,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 +5088,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 +5103,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 +5447,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 +5467,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(", ")}`;
@@ -5638,6 +5888,25 @@ function tryPostPr3(prNumber, body, cwd) {
   }
 }
 
+// src/scripts/resolvePreviewUrl.ts
+var DEFAULT_PREVIEW_URL = "http://localhost:3000";
+var resolvePreviewUrl = async (ctx) => {
+  const fromFlag = typeof ctx.args.previewUrl === "string" ? ctx.args.previewUrl.trim() : "";
+  if (fromFlag.length > 0) {
+    ctx.data.previewUrl = fromFlag;
+    ctx.data.previewUrlSource = "flag";
+    return;
+  }
+  const fromEnv = (process.env.PREVIEW_URL ?? "").trim();
+  if (fromEnv.length > 0) {
+    ctx.data.previewUrl = fromEnv;
+    ctx.data.previewUrlSource = "env";
+    return;
+  }
+  ctx.data.previewUrl = DEFAULT_PREVIEW_URL;
+  ctx.data.previewUrlSource = "default";
+};
+
 // src/scripts/revertFlow.ts
 import { execFileSync as execFileSync19 } from "child_process";
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
@@ -5707,11 +5976,7 @@ var revertFlow = async (ctx) => {
   const runUrl = getRunUrl();
   const runSuffix = runUrl ? `, run ${runUrl}` : "";
   const shaList = resolved.map((r) => `\`${r.full.slice(0, 7)}\``).join(", ");
-  tryPostPr4(
-    prNumber,
-    `\u2699\uFE0F kody revert started on \`${ctx.data.branch}\`${runSuffix} \u2014 reverting ${shaList}`,
-    ctx.cwd
-  );
+  tryPostPr4(prNumber, `\u2699\uFE0F kody revert started on \`${ctx.data.branch}\`${runSuffix} \u2014 reverting ${shaList}`, ctx.cwd);
 };
 function buildCommitMessage(resolved) {
   if (resolved.length === 1) {
@@ -5755,25 +6020,6 @@ function tryPostPr4(prNumber, body, cwd) {
   }
 }
 
-// src/scripts/resolvePreviewUrl.ts
-var DEFAULT_PREVIEW_URL = "http://localhost:3000";
-var resolvePreviewUrl = async (ctx) => {
-  const fromFlag = typeof ctx.args.previewUrl === "string" ? ctx.args.previewUrl.trim() : "";
-  if (fromFlag.length > 0) {
-    ctx.data.previewUrl = fromFlag;
-    ctx.data.previewUrlSource = "flag";
-    return;
-  }
-  const fromEnv = (process.env.PREVIEW_URL ?? "").trim();
-  if (fromEnv.length > 0) {
-    ctx.data.previewUrl = fromEnv;
-    ctx.data.previewUrlSource = "env";
-    return;
-  }
-  ctx.data.previewUrl = DEFAULT_PREVIEW_URL;
-  ctx.data.previewUrlSource = "default";
-};
-
 // src/scripts/reviewFlow.ts
 var reviewFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -6389,7 +6635,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 +6652,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 +6680,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 +6863,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({
@@ -6701,17 +6944,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];
 }
@@ -6815,8 +7058,8 @@ function resolveShellTimeoutMs(entry) {
 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})`;
@@ -6962,7 +7205,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
@@ -7024,9 +7267,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) {
@@ -7106,11 +7349,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 {
@@ -7135,7 +7378,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);
@@ -7145,9 +7388,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);
@@ -7362,9 +7605,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 {
@@ -7402,7 +7645,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) {
@@ -7489,7 +7732,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