@kody-ade/kody-engine 0.3.12 → 0.3.14

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.12",
+  version: "0.3.14",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -1163,11 +1163,187 @@ function parseScriptList(p, key, raw) {
   return out;
 }
 
+// src/commit.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs9 from "fs";
+import * as path8 from "path";
+var FORBIDDEN_PATH_PREFIXES = [
+  ".kody/",
+  ".kody-engine/",
+  ".kody/",
+  ".kody-lean/",
+  // back-compat: stale runtime dir from kody-lean v0.5.x
+  "node_modules/",
+  "dist/",
+  "build/"
+];
+var FORBIDDEN_PATH_EXACT = /* @__PURE__ */ new Set([".env", ".kody-pip-requirements.txt"]);
+var FORBIDDEN_PATH_SUFFIXES = [".log"];
+var CONVENTIONAL_PREFIXES = [
+  "feat:",
+  "fix:",
+  "chore:",
+  "docs:",
+  "refactor:",
+  "test:",
+  "perf:",
+  "ci:",
+  "style:",
+  "build:",
+  "revert:"
+];
+function git(args, cwd) {
+  try {
+    return execFileSync2("git", args, {
+      encoding: "utf-8",
+      timeout: 12e4,
+      cwd,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (err) {
+    const e = err;
+    const stderr = e.stderr?.toString().trim() ?? "";
+    const stdout = e.stdout?.toString().trim() ?? "";
+    const status = e.status ?? "?";
+    const detail = stderr || stdout || e.message || "(no output)";
+    throw new Error(`git ${args.join(" ")} (exit ${status}):
+${detail}`);
+  }
+}
+function tryGit(args, cwd) {
+  try {
+    git(args, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function abortUnfinishedGitOps(cwd) {
+  const aborted = [];
+  const gitDir = path8.join(cwd ?? process.cwd(), ".git");
+  if (!fs9.existsSync(gitDir)) return aborted;
+  if (fs9.existsSync(path8.join(gitDir, "MERGE_HEAD"))) {
+    if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
+  }
+  if (fs9.existsSync(path8.join(gitDir, "CHERRY_PICK_HEAD"))) {
+    if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
+  }
+  if (fs9.existsSync(path8.join(gitDir, "REVERT_HEAD"))) {
+    if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
+  }
+  if (fs9.existsSync(path8.join(gitDir, "rebase-merge")) || fs9.existsSync(path8.join(gitDir, "rebase-apply"))) {
+    if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
+  }
+  try {
+    const unmerged = git(["diff", "--name-only", "--diff-filter=U"], cwd);
+    if (unmerged) {
+      tryGit(["reset", "--mixed", "HEAD"], cwd);
+      aborted.push("unmerged-paths-reset");
+    }
+  } catch {
+  }
+  return aborted;
+}
+function isForbiddenPath(p) {
+  if (FORBIDDEN_PATH_EXACT.has(p)) return true;
+  for (const pre of FORBIDDEN_PATH_PREFIXES) if (p.startsWith(pre)) return true;
+  for (const suf of FORBIDDEN_PATH_SUFFIXES) if (p.endsWith(suf)) return true;
+  return false;
+}
+function listChangedFiles(cwd) {
+  const raw = execFileSync2("git", ["status", "--porcelain=v1", "-z"], {
+    encoding: "utf-8",
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (!raw) return [];
+  const entries = raw.split("\0").filter((e) => e.length > 0);
+  return entries.map((e) => e.slice(3)).filter(Boolean);
+}
+function listFilesInCommit(ref = "HEAD", cwd) {
+  try {
+    const raw = execFileSync2("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
+      encoding: "utf-8",
+      cwd,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return raw.split("\0").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function normalizeCommitMessage(raw) {
+  const trimmed = raw.trim().replace(/^['"]|['"]$/g, "").trim();
+  if (!trimmed) return "chore: kody update";
+  const firstLine2 = trimmed.split("\n")[0];
+  for (const prefix of CONVENTIONAL_PREFIXES) {
+    if (firstLine2.toLowerCase().startsWith(prefix)) return trimmed;
+  }
+  return `chore: ${trimmed}`;
+}
+function commitAndPush(branch, agentMessage, cwd) {
+  const allChanged = listChangedFiles(cwd);
+  const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
+  const mergeHeadExists = fs9.existsSync(path8.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  if (allowedFiles.length === 0 && !mergeHeadExists) {
+    return { committed: false, pushed: false, sha: "", message: "" };
+  }
+  for (const f of allowedFiles) {
+    try {
+      git(["add", "--", f], cwd);
+    } catch {
+    }
+  }
+  const message = normalizeCommitMessage(agentMessage);
+  try {
+    git(["commit", "--no-gpg-sign", "-m", message], cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/nothing to commit/i.test(msg)) {
+      return { committed: false, pushed: false, sha: "", message };
+    }
+    throw err;
+  }
+  const sha = git(["rev-parse", "HEAD"], cwd).slice(0, 7);
+  try {
+    git(["push", "-u", "origin", branch], cwd);
+  } catch {
+    git(["push", "--force-with-lease", "-u", "origin", branch], cwd);
+  }
+  return { committed: true, pushed: true, sha, message };
+}
+function hasCommitsAhead(branch, defaultBranch, cwd) {
+  try {
+    const out = git(["rev-list", "--count", `origin/${defaultBranch}..${branch}`], cwd);
+    return parseInt(out, 10) > 0;
+  } catch {
+    try {
+      const out = git(["rev-list", "--count", `${defaultBranch}..${branch}`], cwd);
+      return parseInt(out, 10) > 0;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/scripts/abortUnfinishedGitOps.ts
+var abortUnfinishedGitOps2 = async (ctx) => {
+  if (ctx.data.agentDone === false) return;
+  const aborted = abortUnfinishedGitOps(ctx.cwd);
+  if (aborted.length > 0) {
+    process.stderr.write(`[kody] cleaned up unfinished git ops: ${aborted.join(", ")}
+`);
+  }
+};
+
 // src/scripts/advanceFlow.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 
 // src/state.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 var STATE_BEGIN = "<!-- kody:state:v1:begin -->";
 var STATE_END = "<!-- kody:state:v1:end -->";
 var HISTORY_MAX_ENTRIES = 20;
@@ -1193,7 +1369,7 @@ function ghToken() {
 function gh(args, input, cwd) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync2("gh", args, {
+  return execFileSync3("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd,
@@ -1396,7 +1572,7 @@ var advanceFlow = async (ctx, profile) => {
   }
   const body = `@kody ${flow.name}`;
   try {
-    execFileSync3("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
+    execFileSync4("gh", ["issue", "comment", String(flow.issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS2,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1410,21 +1586,21 @@ var advanceFlow = async (ctx, profile) => {
 };
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as os2 from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 function getPluginsCatalogRoot() {
-  const here = path8.dirname(new URL(import.meta.url).pathname);
+  const here = path9.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path8.join(here, "..", "plugins"),
+    path9.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path8.join(here, "..", "..", "plugins"),
+    path9.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path8.join(here, "..", "..", "src", "plugins")
+    path9.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs9.existsSync(c) && fs9.statSync(c).isDirectory()) return c;
+    if (fs10.existsSync(c) && fs10.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -1434,50 +1610,50 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path8.join(os2.tmpdir(), `kody-synth-${runId}`);
-  fs9.mkdirSync(path8.join(root, ".claude-plugin"), { recursive: true });
+  const root = path9.join(os2.tmpdir(), `kody-synth-${runId}`);
+  fs10.mkdirSync(path9.join(root, ".claude-plugin"), { recursive: true });
   if (cc.skills.length > 0) {
-    const dst = path8.join(root, "skills");
-    fs9.mkdirSync(dst, { recursive: true });
+    const dst = path9.join(root, "skills");
+    fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      const src = path8.join(catalog, "skills", name);
-      if (!fs9.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
-      copyDir(src, path8.join(dst, name));
+      const src = path9.join(catalog, "skills", name);
+      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
+      copyDir(src, path9.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path8.join(root, "commands");
-    fs9.mkdirSync(dst, { recursive: true });
+    const dst = path9.join(root, "commands");
+    fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      const src = path8.join(catalog, "commands", `${name}.md`);
-      if (!fs9.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
-      fs9.copyFileSync(src, path8.join(dst, `${name}.md`));
+      const src = path9.join(catalog, "commands", `${name}.md`);
+      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
+      fs10.copyFileSync(src, path9.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path8.join(root, "agents");
-    fs9.mkdirSync(dst, { recursive: true });
+    const dst = path9.join(root, "agents");
+    fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      const src = path8.join(catalog, "agents", `${name}.md`);
-      if (!fs9.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
-      fs9.copyFileSync(src, path8.join(dst, `${name}.md`));
+      const src = path9.join(catalog, "agents", `${name}.md`);
+      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
+      fs10.copyFileSync(src, path9.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path8.join(root, "hooks");
-    fs9.mkdirSync(dst, { recursive: true });
+    const dst = path9.join(root, "hooks");
+    fs10.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
-      const src = path8.join(catalog, "hooks", `${name}.json`);
-      if (!fs9.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
-      const parsed = JSON.parse(fs9.readFileSync(src, "utf-8"));
+      const src = path9.join(catalog, "hooks", `${name}.json`);
+      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
+      const parsed = JSON.parse(fs10.readFileSync(src, "utf-8"));
       for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
         if (!Array.isArray(entries)) continue;
         if (!merged.hooks[event]) merged.hooks[event] = [];
         merged.hooks[event].push(...entries);
       }
     }
-    fs9.writeFileSync(path8.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs10.writeFileSync(path9.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -1488,22 +1664,22 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
   if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs9.writeFileSync(path8.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs10.writeFileSync(path9.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs9.mkdirSync(dst, { recursive: true });
-  for (const ent of fs9.readdirSync(src, { withFileTypes: true })) {
-    const s = path8.join(src, ent.name);
-    const d = path8.join(dst, ent.name);
+  fs10.mkdirSync(dst, { recursive: true });
+  for (const ent of fs10.readdirSync(src, { withFileTypes: true })) {
+    const s = path9.join(src, ent.name);
+    const d = path9.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs9.copyFileSync(s, d);
+    else if (ent.isFile()) fs10.copyFileSync(s, d);
   }
 }
 
 // src/coverage.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 function patternToRegex(pattern) {
   let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
@@ -1521,7 +1697,7 @@ function renderSiblingPath(file, requireSibling) {
 }
 function safeGit(args, cwd) {
   try {
-    return execFileSync4("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+    return execFileSync5("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
   } catch {
     return "";
   }
@@ -1564,18 +1740,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
 var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path9.join(projectDir, rel);
-    if (!fs10.existsSync(abs)) continue;
+    const abs = path10.join(projectDir, rel);
+    if (!fs11.existsSync(abs)) continue;
     let content;
     try {
-      content = fs10.readFileSync(abs, "utf-8");
+      content = fs11.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -1735,176 +1911,8 @@ function defaultLabelMap() {
 }
 
 // src/scripts/commitAndPush.ts
-import { execFileSync as execFileSync6 } from "child_process";
-
-// src/commit.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import * as fs11 from "fs";
-import * as path10 from "path";
-var FORBIDDEN_PATH_PREFIXES = [
-  ".kody/",
-  ".kody-engine/",
-  ".kody/",
-  ".kody-lean/",
-  // back-compat: stale runtime dir from kody-lean v0.5.x
-  "node_modules/",
-  "dist/",
-  "build/"
-];
-var FORBIDDEN_PATH_EXACT = /* @__PURE__ */ new Set([".env", ".kody-pip-requirements.txt"]);
-var FORBIDDEN_PATH_SUFFIXES = [".log"];
-var CONVENTIONAL_PREFIXES = [
-  "feat:",
-  "fix:",
-  "chore:",
-  "docs:",
-  "refactor:",
-  "test:",
-  "perf:",
-  "ci:",
-  "style:",
-  "build:",
-  "revert:"
-];
-function git(args, cwd) {
-  try {
-    return execFileSync5("git", args, {
-      encoding: "utf-8",
-      timeout: 12e4,
-      cwd,
-      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch (err) {
-    const e = err;
-    const stderr = e.stderr?.toString().trim() ?? "";
-    const stdout = e.stdout?.toString().trim() ?? "";
-    const status = e.status ?? "?";
-    const detail = stderr || stdout || e.message || "(no output)";
-    throw new Error(`git ${args.join(" ")} (exit ${status}):
-${detail}`);
-  }
-}
-function tryGit(args, cwd) {
-  try {
-    git(args, cwd);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function abortUnfinishedGitOps(cwd) {
-  const aborted = [];
-  const gitDir = path10.join(cwd ?? process.cwd(), ".git");
-  if (!fs11.existsSync(gitDir)) return aborted;
-  if (fs11.existsSync(path10.join(gitDir, "MERGE_HEAD"))) {
-    if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
-  }
-  if (fs11.existsSync(path10.join(gitDir, "CHERRY_PICK_HEAD"))) {
-    if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
-  }
-  if (fs11.existsSync(path10.join(gitDir, "REVERT_HEAD"))) {
-    if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
-  }
-  if (fs11.existsSync(path10.join(gitDir, "rebase-merge")) || fs11.existsSync(path10.join(gitDir, "rebase-apply"))) {
-    if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
-  }
-  try {
-    const unmerged = git(["diff", "--name-only", "--diff-filter=U"], cwd);
-    if (unmerged) {
-      tryGit(["reset", "--mixed", "HEAD"], cwd);
-      aborted.push("unmerged-paths-reset");
-    }
-  } catch {
-  }
-  return aborted;
-}
-function isForbiddenPath(p) {
-  if (FORBIDDEN_PATH_EXACT.has(p)) return true;
-  for (const pre of FORBIDDEN_PATH_PREFIXES) if (p.startsWith(pre)) return true;
-  for (const suf of FORBIDDEN_PATH_SUFFIXES) if (p.endsWith(suf)) return true;
-  return false;
-}
-function listChangedFiles(cwd) {
-  const raw = execFileSync5("git", ["status", "--porcelain=v1", "-z"], {
-    encoding: "utf-8",
-    cwd,
-    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (!raw) return [];
-  const entries = raw.split("\0").filter((e) => e.length > 0);
-  return entries.map((e) => e.slice(3)).filter(Boolean);
-}
-function listFilesInCommit(ref = "HEAD", cwd) {
-  try {
-    const raw = execFileSync5("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
-      encoding: "utf-8",
-      cwd,
-      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return raw.split("\0").map((s) => s.trim()).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-function normalizeCommitMessage(raw) {
-  const trimmed = raw.trim().replace(/^['"]|['"]$/g, "").trim();
-  if (!trimmed) return "chore: kody update";
-  const firstLine2 = trimmed.split("\n")[0];
-  for (const prefix of CONVENTIONAL_PREFIXES) {
-    if (firstLine2.toLowerCase().startsWith(prefix)) return trimmed;
-  }
-  return `chore: ${trimmed}`;
-}
-function commitAndPush(branch, agentMessage, cwd) {
-  const allChanged = listChangedFiles(cwd);
-  const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs11.existsSync(path10.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
-  if (allowedFiles.length === 0 && !mergeHeadExists) {
-    return { committed: false, pushed: false, sha: "", message: "" };
-  }
-  for (const f of allowedFiles) {
-    try {
-      git(["add", "--", f], cwd);
-    } catch {
-    }
-  }
-  const message = normalizeCommitMessage(agentMessage);
-  try {
-    git(["commit", "--no-gpg-sign", "-m", message], cwd);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/nothing to commit/i.test(msg)) {
-      return { committed: false, pushed: false, sha: "", message };
-    }
-    throw err;
-  }
-  const sha = git(["rev-parse", "HEAD"], cwd).slice(0, 7);
-  try {
-    git(["push", "-u", "origin", branch], cwd);
-  } catch {
-    git(["push", "--force-with-lease", "-u", "origin", branch], cwd);
-  }
-  return { committed: true, pushed: true, sha, message };
-}
-function hasCommitsAhead(branch, defaultBranch, cwd) {
-  try {
-    const out = git(["rev-list", "--count", `origin/${defaultBranch}..${branch}`], cwd);
-    return parseInt(out, 10) > 0;
-  } catch {
-    try {
-      const out = git(["rev-list", "--count", `${defaultBranch}..${branch}`], cwd);
-      return parseInt(out, 10) > 0;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// src/scripts/commitAndPush.ts
-var commitAndPush2 = async (ctx, profile) => {
+var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
+var commitAndPush2 = async (ctx) => {
   const branch = ctx.data.branch;
   if (!branch) {
     ctx.data.commitResult = { committed: false, pushed: false };
@@ -1915,21 +1923,7 @@ var commitAndPush2 = async (ctx, profile) => {
     ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
     return;
   }
-  const kind = profile.name;
-  if (kind === "resolve") {
-    try {
-      execFileSync6("git", ["add", "-A"], { cwd: ctx.cwd, env: { ...process.env, HUSKY: "0" }, stdio: "pipe" });
-    } catch {
-    }
-  } else {
-    const aborted = abortUnfinishedGitOps(ctx.cwd);
-    if (aborted.length > 0) {
-      process.stderr.write(`[kody] cleaned up unfinished git ops: ${aborted.join(", ")}
-`);
-    }
-  }
-  const fallbackMsg = defaultCommitMessage(kind, ctx.data);
-  const message = ctx.data.commitMessage || fallbackMsg;
+  const message = ctx.data.commitMessage || DEFAULT_COMMIT_MESSAGE;
   try {
     const result = commitAndPush(branch, message, ctx.cwd);
     ctx.data.commitResult = result;
@@ -1941,20 +1935,6 @@ var commitAndPush2 = async (ctx, profile) => {
   }
   ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
 };
-function defaultCommitMessage(mode, data) {
-  switch (mode) {
-    case "run":
-      return `chore: kody changes for #${data.commentTargetNumber}`;
-    case "fix":
-      return `chore(fix): kody fix for PR #${data.commentTargetNumber}`;
-    case "fix-ci":
-      return `fix(ci): kody fix-ci for PR #${data.commentTargetNumber}`;
-    case "resolve":
-      return `fix: resolve merge conflicts with ${data.baseBranch}`;
-    default:
-      return `chore: kody changes`;
-  }
-}
 
 // src/scripts/composePrompt.ts
 import * as fs12 from "fs";
@@ -2055,7 +2035,7 @@ function formatToolsUsage(profile) {
 }
 
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import * as fs13 from "fs";
 import * as os3 from "os";
 import * as path12 from "path";
@@ -2075,7 +2055,7 @@ var diagMcp = async (_ctx) => {
   process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
   try {
-    const v = execFileSync7(
+    const v = execFileSync6(
       "npx",
       ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"],
       { stdio: "pipe", timeout: 6e4, encoding: "utf8" }
@@ -2575,7 +2555,7 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 var API_TIMEOUT_MS3 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
@@ -2598,7 +2578,7 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync8("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync7("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS3,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -2618,7 +2598,7 @@ function parsePr(url) {
 }
 
 // src/issue.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 var API_TIMEOUT_MS4 = 3e4;
 function ghToken2() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -2626,7 +2606,7 @@ function ghToken2() {
 function gh2(args, options) {
   const token = ghToken2();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync9("gh", args, {
+  return execFileSync8("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS4,
     cwd: options?.cwd,
@@ -2752,6 +2732,70 @@ function postPrReviewComment(prNumber, body, cwd) {
   }
 }
 
+// src/scripts/dispatchManagerTicks.ts
+var dispatchManagerTicks = async (ctx, _profile, args) => {
+  ctx.skipAgent = true;
+  const label = String(args?.label ?? "");
+  const targetExecutable = String(args?.targetExecutable ?? "");
+  if (!label) throw new Error("dispatchManagerTicks: `with.label` is required");
+  if (!targetExecutable) throw new Error("dispatchManagerTicks: `with.targetExecutable` is required");
+  const issueArg = String(args?.issueArg ?? "issue");
+  const issues = listIssuesByLabel(label, ctx.cwd);
+  ctx.data.managerIssueCount = issues.length;
+  if (issues.length === 0) {
+    process.stdout.write(`[manager] no open issues with label "${label}"
+`);
+    return;
+  }
+  process.stdout.write(`[manager] ticking ${issues.length} issue(s) via ${targetExecutable}
+`);
+  const results = [];
+  for (const issue of issues) {
+    process.stdout.write(`[manager] \u2192 tick #${issue.number}: ${issue.title}
+`);
+    try {
+      const out = await runExecutable(targetExecutable, {
+        cliArgs: { [issueArg]: issue.number },
+        cwd: ctx.cwd,
+        config: ctx.config,
+        verbose: ctx.verbose,
+        quiet: ctx.quiet
+      });
+      results.push({ issue: issue.number, exitCode: out.exitCode, reason: out.reason });
+      if (out.exitCode !== 0) {
+        process.stderr.write(`[manager] tick #${issue.number} failed (exit ${out.exitCode}): ${out.reason ?? ""}
+`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[manager] tick #${issue.number} crashed: ${msg}
+`);
+      results.push({ issue: issue.number, exitCode: 99, reason: msg });
+    }
+  }
+  ctx.data.managerTickResults = results;
+  ctx.output.exitCode = 0;
+};
+function listIssuesByLabel(label, cwd) {
+  let raw = "";
+  try {
+    raw = gh2(
+      ["issue", "list", "--state", "open", "--label", label, "--limit", "100", "--json", "number,title"],
+      { cwd }
+    );
+  } catch {
+    return [];
+  }
+  let list;
+  try {
+    list = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(list)) return [];
+  return list.filter((x) => typeof x.number === "number" && typeof x.title === "string").map((x) => ({ number: x.number, title: x.title }));
+}
+
 // src/pr.ts
 var TITLE_MAX = 72;
 function stripTitlePrefixes(raw) {
@@ -2930,7 +2974,7 @@ function computeFailureReason(ctx) {
 }
 
 // src/scripts/finishFlow.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 
 // src/lifecycleLabels.ts
 var KODY_NAMESPACE = "kody";
@@ -3089,7 +3133,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync10("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync9("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS5,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -3103,7 +3147,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 var UncommittedChangesError = class extends Error {
   constructor(branch) {
     super(`Uncommitted changes on branch '${branch}' \u2014 refusing to run to protect work in progress`);
@@ -3113,7 +3157,7 @@ var UncommittedChangesError = class extends Error {
   branch;
 };
 function git2(args, cwd) {
-  return execFileSync11("git", args, {
+  return execFileSync10("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -3138,7 +3182,7 @@ function checkoutPrBranch(prNumber, cwd) {
     SKIP_HOOKS: "1",
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
-  execFileSync11("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync10("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -3205,7 +3249,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd) {
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import * as fs16 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
@@ -3248,7 +3292,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync12("gh", args, opts);
+      execFileSync11("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -3261,13 +3305,13 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync12("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync11("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
 
 // src/workflow.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -3275,7 +3319,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync13("gh", args, {
+  return execFileSync12("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -3459,7 +3503,7 @@ function tryPostPr2(prNumber, body, cwd) {
 }
 
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 import * as fs18 from "fs";
 import * as path16 from "path";
 
@@ -3500,7 +3544,7 @@ function qualityCommandsFor(pm) {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync14("git", ["remote", "get-url", "origin"], {
+    url = execFileSync13("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -3584,7 +3628,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync14("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync13("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -3592,7 +3636,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync14("git", ["branch", "--show-current"], {
+      return execFileSync13("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -3764,6 +3808,112 @@ 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 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 ?? "");
+  if (!marker) {
+    throw new Error("loadIssueStateComment: `with.marker` is required");
+  }
+  const issueArg = String(args?.issueArg ?? "issue");
+  const issueNumber = Number(ctx.args[issueArg]);
+  if (!Number.isFinite(issueNumber) || issueNumber <= 0) {
+    throw new Error(`loadIssueStateComment: ctx.args.${issueArg} must be a positive integer`);
+  }
+  const owner = ctx.config.github.owner;
+  const repo = ctx.config.github.repo;
+  if (!owner || !repo) {
+    throw new Error("loadIssueStateComment: ctx.config.github.owner/repo must be set");
+  }
+  const issue = getIssue(issueNumber, ctx.cwd);
+  const loaded = findStateComment2(owner, repo, issueNumber, marker, ctx.cwd);
+  ctx.data.stateMarker = marker;
+  ctx.data.issueIntent = issue.body;
+  ctx.data.issueTitle = issue.title;
+  ctx.data.issueNumber = String(issueNumber);
+  ctx.data.issueStateComment = loaded;
+  ctx.data.issueStateJson = loaded ? JSON.stringify(loaded.state, null, 2) : "null";
+};
+
 // src/scripts/loadPriorArt.ts
 var PER_PR_DIFF_MAX_BYTES = 8e3;
 var TOTAL_MAX_BYTES = 3e4;
@@ -3931,6 +4081,53 @@ function makeAction(type, payload) {
   return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
+// src/scripts/parseIssueStateFromAgentResult.ts
+function isPartialEnvelope(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return typeof o.cursor === "string" && o.cursor.length > 0 && typeof o.done === "boolean" && o.data !== null && typeof o.data === "object" && !Array.isArray(o.data);
+}
+var parseIssueStateFromAgentResult = async (ctx, _profile, agentResult, args) => {
+  const fenceLabel = String(args?.fenceLabel ?? "");
+  if (!fenceLabel) {
+    throw new Error("parseIssueStateFromAgentResult: `with.fenceLabel` is required");
+  }
+  if (!agentResult) {
+    ctx.data.nextStateParseError = "agent did not run";
+    return;
+  }
+  const fenceRegex = new RegExp("```" + escapeRegex(fenceLabel) + "\\s*\\n([\\s\\S]*?)\\n```", "m");
+  const match = fenceRegex.exec(agentResult.finalText);
+  if (!match) {
+    ctx.data.nextStateParseError = `agent did not emit a \`${fenceLabel}\` fenced block`;
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1].trim());
+  } catch (err) {
+    ctx.data.nextStateParseError = `state JSON parse error: ${err instanceof Error ? err.message : String(err)}`;
+    return;
+  }
+  if (!isPartialEnvelope(parsed)) {
+    ctx.data.nextStateParseError = "state must be an object with string `cursor`, object `data`, and boolean `done`";
+    return;
+  }
+  const loaded = ctx.data.issueStateComment;
+  const prevRev = loaded?.state.rev ?? 0;
+  const next = {
+    version: 1,
+    rev: prevRev + 1,
+    cursor: parsed.cursor,
+    data: parsed.data,
+    done: parsed.done
+  };
+  ctx.data.nextIssueState = next;
+};
+function escapeRegex(s) {
+  return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
 // src/scripts/persistArtifacts.ts
 var persistArtifacts = async (ctx, profile) => {
   if (profile.outputArtifacts.length === 0) return;
@@ -3977,7 +4174,7 @@ var persistFlowState = async (ctx) => {
 };
 
 // src/scripts/postClassification.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var API_TIMEOUT_MS6 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var postClassification = async (ctx) => {
@@ -4007,7 +4204,7 @@ var postClassification = async (ctx) => {
     ctx.cwd
   );
   try {
-    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
+    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS6,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4041,7 +4238,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS6,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4225,7 +4422,7 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 };
 
 // src/scripts/releaseFlow.ts
-import { execFileSync as execFileSync16, spawnSync } from "child_process";
+import { execFileSync as execFileSync15, spawnSync } from "child_process";
 import * as fs19 from "fs";
 import * as path17 from "path";
 function notifyIssue(issueNumber, body, cwd) {
@@ -4265,7 +4462,7 @@ function generateChangelog(cwd, newVersion, lastTag) {
   else logArgs.splice(1, 0, `-n${FIRST_RELEASE_COMMIT_CAP}`, "HEAD");
   let log = "";
   try {
-    log = execFileSync16("git", logArgs, {
+    log = execFileSync15("git", logArgs, {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -4322,7 +4519,7 @@ ${entry}${prior.slice(idx + 1)}`);
   }
 }
 function git3(args, cwd, timeout = 6e4) {
-  return execFileSync16("git", args, {
+  return execFileSync15("git", args, {
     encoding: "utf-8",
     timeout,
     cwd,
@@ -4699,7 +4896,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -4769,7 +4966,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync17("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync16("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -4784,7 +4981,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync17("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync16("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -4947,6 +5144,20 @@ var skipAgent = async (ctx) => {
   ctx.skipAgent = true;
 };
 
+// src/scripts/stageMergeConflicts.ts
+import { execFileSync as execFileSync17 } from "child_process";
+var stageMergeConflicts = async (ctx) => {
+  if (ctx.data.agentDone === false) return;
+  try {
+    execFileSync17("git", ["add", "-A"], {
+      cwd: ctx.cwd,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: "pipe"
+    });
+  } catch {
+  }
+};
+
 // src/scripts/startFlow.ts
 import { execFileSync as execFileSync18 } from "child_process";
 var API_TIMEOUT_MS7 = 3e4;
@@ -5238,6 +5449,42 @@ var watchStalePrsFlow = async (ctx) => {
   ctx.data.staleCount = stale.length;
 };
 
+// src/scripts/writeIssueStateComment.ts
+var writeIssueStateComment = async (ctx, _profile, _agentResult, args) => {
+  const marker = String(args?.marker ?? "");
+  if (!marker) {
+    throw new Error("writeIssueStateComment: `with.marker` is required");
+  }
+  const issueArg = String(args?.issueArg ?? "issue");
+  const issueNumber = Number(ctx.args[issueArg]);
+  if (!Number.isFinite(issueNumber) || issueNumber <= 0) {
+    throw new Error(`writeIssueStateComment: ctx.args.${issueArg} must be a positive integer`);
+  }
+  const parseError = ctx.data.nextStateParseError;
+  if (parseError) {
+    process.stderr.write(`[kody] state write skipped: ${parseError}
+`);
+    if (ctx.output.exitCode === 0) ctx.output.exitCode = 1;
+    if (!ctx.output.reason) ctx.output.reason = `next-state parse failed: ${parseError}`;
+    return;
+  }
+  const next = ctx.data.nextIssueState;
+  if (!next) {
+    return;
+  }
+  const owner = ctx.config.github.owner;
+  const repo = ctx.config.github.repo;
+  if (!owner || !repo) {
+    throw new Error("writeIssueStateComment: ctx.config.github.owner/repo must be set");
+  }
+  const loaded = ctx.data.issueStateComment;
+  if (loaded) {
+    updateStateComment(owner, repo, loaded.commentId, loaded.commentNodeId, marker, next, ctx.cwd);
+  } else {
+    createStateComment(owner, repo, issueNumber, marker, next, ctx.cwd);
+  }
+};
+
 // src/scripts/writeRunSummary.ts
 import * as fs20 from "fs";
 var writeRunSummary = async (ctx, profile) => {
@@ -5280,6 +5527,7 @@ var preflightScripts = {
   watchStalePrsFlow,
   loadTaskState,
   loadIssueContext,
+  loadIssueStateComment,
   loadConventions,
   loadCoverageRules,
   loadPriorArt,
@@ -5292,14 +5540,19 @@ var preflightScripts = {
   setLifecycleLabel,
   skipAgent,
   classifyByLabel,
-  diagMcp
+  diagMcp,
+  dispatchManagerTicks
 };
 var postflightScripts = {
   parseAgentResult: parseAgentResult2,
+  parseIssueStateFromAgentResult,
+  writeIssueStateComment,
   requireFeedbackActions,
   requirePlanDeviations,
   verify,
   checkCoverageWithRetry,
+  abortUnfinishedGitOps: abortUnfinishedGitOps2,
+  stageMergeConflicts,
   commitAndPush: commitAndPush2,
   ensurePr: ensurePr2,
   postIssueComment: postIssueComment2,