@kody-ade/kody-engine 0.4.139 → 0.4.141

package/dist/bin/kody.js

@@ -93,7 +93,7 @@ var init_events = __esm({
 // src/verify.ts
 import { spawn } from "child_process";
 function runCommand(command, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const start = Date.now();
     const child = spawn(command, {
       cwd,
@@ -122,11 +122,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve4({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve5({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve4({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve5({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -672,28 +672,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs32 from "fs";
-import * as path31 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs32.statSync(file);
+      stat = fs31.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs32.readFileSync(file, "utf-8");
+      raw = fs31.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() ?? path31.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path29.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path31.relative(memoryAbs, file),
+      relPath: path29.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -761,16 +761,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs32.readdirSync(dir);
+      names = fs31.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path31.join(dir, name);
+      const full = path29.join(dir, name);
       let stat;
       try {
-        stat = fs32.statSync(full);
+        stat = fs31.statSync(full);
       } catch {
         continue;
       }
@@ -793,8 +793,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path31.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs32.existsSync(memoryAbs)) {
+      const memoryAbs = path29.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs31.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -926,7 +926,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.139",
+  version: "0.4.141",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -982,9 +982,9 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync32 } from "child_process";
-import * as fs42 from "fs";
-import * as path39 from "path";
+import { execFileSync as execFileSync30 } from "child_process";
+import * as fs41 from "fs";
+import * as path37 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1641,10 +1641,10 @@ async function runAgent(opts) {
       let timer;
       let next;
       if (turnTimeoutMs > 0) {
-        const timeoutPromise = new Promise((resolve4) => {
+        const timeoutPromise = new Promise((resolve5) => {
           timer = setTimeout(() => {
             timedOut = true;
-            resolve4({ done: true, value: void 0 });
+            resolve5({ done: true, value: void 0 });
           }, turnTimeoutMs);
         });
         next = await Promise.race([nextPromise, timeoutPromise]);
@@ -2318,7 +2318,7 @@ async function waitForNextUserMessage(opts) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function currentBranch(cwd) {
   try {
@@ -2533,9 +2533,9 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 }
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync31 } from "child_process";
-import * as fs41 from "fs";
-import * as path38 from "path";
+import { execFileSync as execFileSync29 } from "child_process";
+import * as fs40 from "fs";
+import * as path36 from "path";
 
 // src/dispatch.ts
 import * as fs11 from "fs";
@@ -2867,9 +2867,9 @@ function coerceBare(spec, value) {
 init_issue();
 
 // src/executor.ts
-import { execFileSync as execFileSync30, spawn as spawn8 } from "child_process";
-import * as fs40 from "fs";
-import * as path37 from "path";
+import { execFileSync as execFileSync28, spawn as spawn9 } from "child_process";
+import * as fs39 from "fs";
+import * as path35 from "path";
 
 // src/discipline.ts
 var DISCIPLINE = `# Working discipline (applies to this entire task)
@@ -4291,6 +4291,7 @@ var advanceFlow = async (ctx, profile) => {
 
 // src/scripts/brainServe.ts
 import { createServer } from "http";
+import { spawn as spawn3, spawnSync } from "child_process";
 import * as fs18 from "fs";
 import * as path17 from "path";
 
@@ -4473,17 +4474,17 @@ function authOk(req, expected) {
   return false;
 }
 function readJsonBody(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve4({});
+        resolve5({});
         return;
       }
       try {
-        resolve4(JSON.parse(raw));
+        resolve5(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -4491,6 +4492,13 @@ function readJsonBody(req) {
     req.on("error", reject);
   });
 }
+function strField(body, key) {
+  if (typeof body === "object" && body !== null && key in body) {
+    const v = body[key];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return void 0;
+}
 function sendJson(res, status, body) {
   res.writeHead(status, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
@@ -4588,6 +4596,51 @@ function streamToRes(res, dir, chatId, since) {
   );
   res.on("close", unsubscribe);
 }
+var REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+var repoClones = /* @__PURE__ */ new Map();
+async function ensureRepoCwd(opts) {
+  const repo = opts.repo?.trim();
+  if (!repo || !REPO_RE.test(repo)) return opts.baseCwd;
+  const root = path17.resolve(opts.reposRoot);
+  const dir = path17.resolve(root, repo);
+  if (dir !== root && !dir.startsWith(root + path17.sep)) return opts.baseCwd;
+  if (fs18.existsSync(path17.join(dir, ".git"))) return dir;
+  const inflight = repoClones.get(dir);
+  if (inflight) {
+    await inflight;
+    return dir;
+  }
+  const p = opts.cloneRepo(repo, opts.repoToken, dir).finally(() => {
+    if (repoClones.get(dir) === p) repoClones.delete(dir);
+  });
+  repoClones.set(dir, p);
+  await p;
+  return dir;
+}
+var defaultCloneRepo = (repo, token, dir) => {
+  fs18.mkdirSync(path17.dirname(dir), { recursive: true });
+  const authUrl = token ? `https://x-access-token:${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
+  return new Promise((resolve5, reject) => {
+    const child = spawn3("git", ["clone", "--depth=1", authUrl, dir], {
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        reject(new Error(`git clone ${repo} failed (exit ${code})`));
+        return;
+      }
+      try {
+        const name = process.env.GIT_AUTHOR_NAME ?? "Kody Bot";
+        const email = process.env.GIT_AUTHOR_EMAIL ?? "kody-bot@users.noreply.github.com";
+        spawnSync("git", ["-C", dir, "config", "user.name", name]);
+        spawnSync("git", ["-C", dir, "config", "user.email", email]);
+      } catch {
+      }
+      resolve5();
+    });
+    child.on("error", reject);
+  });
+};
 async function handleChatTurn(req, res, chatId, opts) {
   let body;
   try {
@@ -4601,6 +4654,8 @@ async function handleChatTurn(req, res, chatId, opts) {
     sendJson(res, 400, { error: "message required" });
     return;
   }
+  const repo = strField(body, "repo");
+  const repoToken = strField(body, "repoToken");
   const sessionFile = sessionFilePath(opts.cwd, chatId);
   fs18.mkdirSync(path17.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
@@ -4611,32 +4666,42 @@ async function handleChatTurn(req, res, chatId, opts) {
   const sinceFloor = getLastSeq(opts.cwd, chatId);
   const emitToLog = beginTurn(opts.cwd, chatId);
   const sink = new BrokerSink(emitToLog, chatId);
-  void enqueue(
-    chatId,
-    () => opts.runTurn({
-      sessionId: chatId,
-      sessionFile,
-      cwd: opts.cwd,
-      model: opts.model,
-      litellmUrl: opts.litellmUrl,
-      sink
-    }).catch((err) => {
+  void enqueue(chatId, async () => {
+    try {
+      const agentCwd = await ensureRepoCwd({
+        baseCwd: opts.cwd,
+        reposRoot: opts.reposRoot,
+        repo,
+        repoToken,
+        cloneRepo: opts.cloneRepo
+      });
+      await opts.runTurn({
+        sessionId: chatId,
+        sessionFile,
+        cwd: agentCwd,
+        model: opts.model,
+        litellmUrl: opts.litellmUrl,
+        sink
+      });
+    } catch (err) {
       const errMsg3 = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[brain-serve] chat turn failed: ${errMsg3}
 `);
       endTurnIfUnterminated(opts.cwd, chatId, errMsg3);
-    }).finally(() => {
+    } finally {
       endTurnIfUnterminated(
         opts.cwd,
         chatId,
         "Brain turn ended without a reply (the machine may have restarted mid-turn) \u2014 please resend your message"
       );
-    })
-  );
+    }
+  });
   streamToRes(res, opts.cwd, chatId, sinceFloor);
 }
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
+  const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
+  const reposRoot = opts.reposRoot ?? path17.join(path17.dirname(path17.resolve(opts.cwd)), "repos");
   return createServer(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -4660,6 +4725,8 @@ function buildServer(opts) {
       }
       await handleChatTurn(req, res, chatId, {
         cwd: opts.cwd,
+        reposRoot,
+        cloneRepo,
         model: opts.model,
         litellmUrl: opts.litellmUrl,
         runTurn
@@ -4710,16 +4777,18 @@ var brainServe = async (ctx) => {
   const server = buildServer({
     apiKey,
     cwd: ctx.cwd,
+    // Per-repo clones live here; defaults to a `repos` sibling of cwd.
+    reposRoot: process.env.BRAIN_REPOS_ROOT?.trim() || void 0,
     model,
     litellmUrl
   });
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     server.listen(port, "0.0.0.0", () => {
       process.stdout.write(
         `[brain-serve] listening on 0.0.0.0:${port} (cwd=${ctx.cwd})
 `
       );
-      resolve4();
+      resolve5();
     });
   });
   const shutdown = (signal) => {
@@ -4978,43 +5047,181 @@ var commitAndPush2 = async (ctx, profile) => {
   }
 };
 
-// src/scripts/commitGoalState.ts
-import { execFileSync as execFileSync10 } from "child_process";
-import * as path20 from "path";
-var commitGoalState = async (ctx) => {
-  const goal = ctx.data.goal;
-  if (!goal) return;
-  const stateRel = path20.posix.join(".kody", "goals", goal.id, "state.json");
+// src/goal/stateStore.ts
+init_issue();
+
+// src/stateBranch.ts
+init_issue();
+var STATE_BRANCH = "kody-state";
+function is404(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
+}
+function ensureStateBranch(owner, repo, cwd) {
   try {
-    execFileSync10("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
+    gh(["api", `/repos/${owner}/${repo}/git/ref/heads/${STATE_BRANCH}`], { cwd });
+    return;
   } catch (err) {
-    process.stderr.write(
-      `[goal-tick] commitGoalState: git add failed: ${err instanceof Error ? err.message : String(err)}
-`
+    if (!is404(err)) throw err;
+  }
+  const repoInfo = JSON.parse(gh(["api", `/repos/${owner}/${repo}`], { cwd }));
+  const defaultBranch2 = repoInfo.default_branch;
+  if (!defaultBranch2) {
+    throw new Error(`ensureStateBranch: could not resolve default branch for ${owner}/${repo}`);
+  }
+  const headRef = JSON.parse(
+    gh(["api", `/repos/${owner}/${repo}/git/ref/heads/${defaultBranch2}`], { cwd })
+  );
+  const sha = headRef.object?.sha;
+  if (!sha) {
+    throw new Error(`ensureStateBranch: could not resolve head sha for ${owner}/${repo}@${defaultBranch2}`);
+  }
+  try {
+    gh(["api", "--method", "POST", `/repos/${owner}/${repo}/git/refs`, "--input", "-"], {
+      cwd,
+      input: JSON.stringify({ ref: `refs/heads/${STATE_BRANCH}`, sha })
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/already exists/i.test(msg) || /HTTP 422/i.test(msg)) return;
+    throw err;
+  }
+}
+
+// src/goal/state.ts
+import * as fs21 from "fs";
+import * as path20 from "path";
+var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
+var GoalStateError = class extends Error {
+  constructor(path38, message) {
+    super(`Invalid goal state at ${path38}:
+  ${message}`);
+    this.path = path38;
+    this.name = "GoalStateError";
+  }
+  path;
+};
+function parseGoalState(filePath, raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GoalStateError(filePath, "must be a JSON object");
+  }
+  const r = raw;
+  const stateValue = r.state;
+  if (typeof stateValue !== "string" || !VALID_STATES.has(stateValue)) {
+    throw new GoalStateError(
+      filePath,
+      `"state" is required and must be one of: ${[...VALID_STATES].join(" | ")} (got ${JSON.stringify(stateValue)})`
     );
-    return;
   }
+  const parsed = {
+    state: stateValue,
+    extra: {}
+  };
+  if (typeof r.mergeApproved === "boolean") {
+    parsed.mergeApproved = r.mergeApproved;
+  }
+  if (typeof r.lastDispatchedIssue === "number" && Number.isFinite(r.lastDispatchedIssue)) {
+    parsed.lastDispatchedIssue = r.lastDispatchedIssue;
+  }
+  for (const ts of ["updatedAt", "createdAt", "startedAt"]) {
+    const v = r[ts];
+    if (typeof v === "string" && v.length > 0) parsed[ts] = v;
+  }
+  const known = /* @__PURE__ */ new Set(["state", "mergeApproved", "lastDispatchedIssue", "updatedAt", "createdAt", "startedAt"]);
+  for (const [k, v] of Object.entries(r)) {
+    if (!known.has(k)) parsed.extra[k] = v;
+  }
+  return parsed;
+}
+function serializeGoalState(s) {
+  const obj = { ...s.extra, state: s.state };
+  if (s.mergeApproved !== void 0) obj.mergeApproved = s.mergeApproved;
+  if (s.lastDispatchedIssue !== void 0) obj.lastDispatchedIssue = s.lastDispatchedIssue;
+  if (s.createdAt !== void 0) obj.createdAt = s.createdAt;
+  if (s.startedAt !== void 0) obj.startedAt = s.startedAt;
+  if (s.updatedAt !== void 0) obj.updatedAt = s.updatedAt;
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+// src/goal/stateStore.ts
+function statePath(goalId) {
+  return `.kody/goals/${goalId}/state.json`;
+}
+function is4042(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
+}
+function fetchGoalState(owner, repo, goalId, cwd) {
+  const filePath = statePath(goalId);
+  let raw;
   try {
-    execFileSync10("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    raw = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
+  } catch (err) {
+    if (is4042(err)) return null;
+    throw err;
+  }
+  const o = JSON.parse(raw);
+  if (!o.content) return null;
+  const decoded = Buffer.from(o.content, "base64").toString("utf-8");
+  return parseGoalState(filePath, JSON.parse(decoded));
+}
+function putGoalState(owner, repo, goalId, state, message, cwd) {
+  ensureStateBranch(owner, repo, cwd);
+  const filePath = statePath(goalId);
+  const content = Buffer.from(serializeGoalState(state), "utf-8").toString("base64");
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    let sha;
+    try {
+      const cur = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
+      const o = JSON.parse(cur);
+      if (o.sha) sha = o.sha;
+    } catch (err) {
+      if (!is4042(err)) throw err;
+    }
+    const payload = { message, content, branch: STATE_BRANCH };
+    if (sha) payload.sha = sha;
+    try {
+      gh(["api", "--method", "PUT", `/repos/${owner}/${repo}/contents/${filePath}`, "--input", "-"], {
+        cwd,
+        input: JSON.stringify(payload)
+      });
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const conflict = /HTTP 409/i.test(msg) || /HTTP 422/i.test(msg) || /does not match|but expected/i.test(msg);
+      if (!conflict || attempt === 3) throw err;
+    }
+  }
+}
+
+// src/scripts/commitGoalState.ts
+var commitGoalState = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  if (ctx.data.goalPersistChanged !== true) return;
+  const updated = ctx.data.goalPersistState;
+  if (!updated) return;
+  const owner = ctx.config.github?.owner;
+  const repo = ctx.config.github?.repo;
+  if (!owner || !repo) {
+    process.stderr.write(`[goal-tick] commitGoalState: missing github owner/repo; cannot persist ${goal.id}
+`);
     return;
-  } catch {
   }
-  const msg = describeCommitMessage(goal);
   try {
-    execFileSync10("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    putGoalState(owner, repo, goal.id, updated, describeCommitMessage(goal), ctx.cwd);
   } catch (err) {
     process.stderr.write(
-      `[goal-tick] commitGoalState: git commit failed: ${err instanceof Error ? err.message : String(err)}
+      `[goal-tick] commitGoalState: persist to ${STATE_BRANCH_LABEL} failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
 `
     );
-    return;
-  }
-  const result = pushWithRetry({ cwd: ctx.cwd });
-  if (!result.ok) {
-    process.stderr.write(`[goal-tick] commitGoalState: push failed (${result.reason}); will retry next tick
-`);
   }
 };
+var STATE_BRANCH_LABEL = "kody-state";
 function describeCommitMessage(goal) {
   if (goal.state === "closed") return `chore(goals): abandon ${goal.id} (cleanup complete)`;
   if (goal.state === "awaiting-merge") return `chore(goals): park ${goal.id} awaiting merge`;
@@ -5029,7 +5236,7 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path21 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
@@ -5042,7 +5249,7 @@ var composePrompt = async (ctx, profile) => {
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs21.existsSync(c)) {
+    if (fs22.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -5050,7 +5257,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs21.readFileSync(templatePath, "utf-8");
+  const template = fs22.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -5128,9 +5335,6 @@ function formatToolsUsage(profile) {
 
 // src/scripts/createQaGoal.ts
 init_issue();
-import { execFileSync as execFileSync11 } from "child_process";
-import * as fs22 from "fs";
-import * as path22 from "path";
 
 // src/scripts/postReviewResult.ts
 init_issue();
@@ -5382,104 +5586,6 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   if (!m) throw new Error(`gh issue create returned unexpected output: ${out}`);
   return { number: Number(m[1]), created: true };
 }
-function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path22.join(cwd, ".kody", "goals", goalId);
-  fs22.mkdirSync(dir, { recursive: true });
-  const state = {
-    version: 1,
-    state: "active",
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
-  };
-  const filePath = path22.join(dir, "state.json");
-  fs22.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
-`);
-  return filePath;
-}
-function gitTry(args, cwd) {
-  const env = { ...process.env, SKIP_HOOKS: "1", HUSKY: "0" };
-  try {
-    execFileSync11("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
-    return { ok: true, stderr: "" };
-  } catch (err) {
-    const e = err;
-    const stderr = typeof e?.stderr === "string" ? e.stderr : Buffer.isBuffer(e?.stderr) ? e.stderr.toString("utf8") : e?.message ?? "";
-    return { ok: false, stderr: stderr.trim() };
-  }
-}
-function commitAndPushState(filePath, goalId, cwd) {
-  const add = gitTry(["add", filePath], cwd);
-  if (!add.ok) {
-    process.stderr.write(`[createQaGoal] git add failed: ${add.stderr.slice(-400) || "(no stderr)"}
-`);
-    return;
-  }
-  const diff = gitTry(["diff", "--cached", "--quiet"], cwd);
-  if (diff.ok) {
-    process.stderr.write(`[createQaGoal] state.json unchanged \u2014 nothing to commit
-`);
-    return;
-  }
-  const commit = gitTry(["commit", "-m", `chore(goals): activate ${goalId}`, "--quiet"], cwd);
-  if (!commit.ok) {
-    process.stderr.write(`[createQaGoal] git commit failed: ${commit.stderr.slice(-400) || "(no stderr)"}
-`);
-    return;
-  }
-  const push = gitTry(["push", "--quiet"], cwd);
-  if (push.ok) return;
-  const stderr = push.stderr;
-  const tail = stderr.slice(-400) || "(no stderr captured)";
-  if (/non-fast-forward|rejected|fetch first|behind/i.test(stderr)) {
-    process.stderr.write(`[createQaGoal] push rejected (non-fast-forward) \u2014 pulling --rebase and retrying
-`);
-    const rebase = gitTry(["pull", "--rebase", "--autostash", "--quiet"], cwd);
-    if (!rebase.ok) {
-      process.stderr.write(
-        `[createQaGoal] rebase failed (manual recovery required): ${rebase.stderr.slice(-400) || "(no stderr)"}
-`
-      );
-      return;
-    }
-    const retryPush = gitTry(["push", "--quiet"], cwd);
-    if (retryPush.ok) {
-      process.stderr.write(`[createQaGoal] push succeeded after rebase
-`);
-      return;
-    }
-    process.stderr.write(
-      `[createQaGoal] push still failed after rebase: ${retryPush.stderr.slice(-400) || "(no stderr)"}
-`
-    );
-    return;
-  }
-  if (/pre-push|hook|husky/i.test(stderr)) {
-    process.stderr.write(`[createQaGoal] push rejected by pre-push hook \u2014 retrying with --no-verify
-`);
-    process.stderr.write(`[createQaGoal] hook output:
-${tail}
-`);
-    const noVerify = gitTry(["push", "--no-verify", "--quiet"], cwd);
-    if (noVerify.ok) {
-      process.stderr.write(`[createQaGoal] push succeeded with --no-verify (consider adding kody artifacts to ignore configs)
-`);
-      return;
-    }
-    process.stderr.write(
-      `[createQaGoal] --no-verify push also failed: ${noVerify.stderr.slice(-400) || "(no stderr)"}
-`
-    );
-    return;
-  }
-  process.stderr.write(
-    `[createQaGoal] state.json commit landed but push failed.
-[createQaGoal]   The goal will not be visible to goal-scheduler in CI until you run 'git push' manually.
-[createQaGoal]   git stderr:
-${tail}
-`
-  );
-}
 function createTaskIssue(finding, goalId, manifestNumber, cwd) {
   const labels = [`goal:${goalId}`, severityLabel(finding.severity), FINDING_LABEL];
   ensureLabel(`goal:${goalId}`, "1d76db", `goal: ${goalId}`, cwd);
@@ -5514,36 +5620,46 @@ var createQaGoal = async (ctx, _profile, agentResult) => {
     ctx.data.action = failedAction2("empty report body");
     return;
   }
+  const { markdown } = splitReport(finalText);
+  const verdict = detectVerdict(markdown);
+  const existingIssue = ctx.args.issue;
+  if (typeof existingIssue === "number" && existingIssue > 0) {
+    try {
+      postIssueComment(existingIssue, finalText, ctx.cwd);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.output.exitCode = 4;
+      ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
+      ctx.data.action = failedAction2(ctx.output.reason);
+      return;
+    }
+    process.stdout.write(
+      `
+QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
+`
+    );
+    ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
+    ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+    return;
+  }
+  await promoteReportToGoal(
+    ctx,
+    finalText,
+    ctx.args.scope,
+    ctx.args.goal
+  );
+};
+async function promoteReportToGoal(ctx, finalText, scopeArg, explicitGoalArg) {
   const { markdown, data, jsonError } = splitReport(finalText);
   const verdict = detectVerdict(markdown);
   const findings = data?.findings ?? [];
-  const existingIssue = ctx.args.issue;
   if (findings.length === 0 || jsonError) {
     if (jsonError) {
-      process.stderr.write(`[createQaGoal] JSON parse: ${jsonError} \u2014 falling back to single-issue mode
+      process.stderr.write(`[promoteReportToGoal] JSON parse: ${jsonError} \u2014 falling back to single-issue mode
 `);
     }
-    if (typeof existingIssue === "number" && existingIssue > 0) {
-      try {
-        postIssueComment(existingIssue, finalText, ctx.cwd);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        ctx.output.exitCode = 4;
-        ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
-        ctx.data.action = failedAction2(ctx.output.reason);
-        return;
-      }
-      process.stdout.write(
-        `
-QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
-`
-      );
-      ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
-      ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-      return;
-    }
     ensureLabel(FINDING_LABEL, "ededed", "kody: QA finding", ctx.cwd);
-    const scope2 = ctx.args.scope;
+    const scope2 = scopeArg;
     const title = `QA [${verdict}]: ${scope2?.trim() || "smoke"} \u2014 ${todayIso()}`.slice(0, 240);
     let url = "";
     try {
@@ -5571,8 +5687,8 @@ QA_REPORT_POSTED=${url} (verdict: ${verdict})
     ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
     return;
   }
-  const explicitGoal = ctx.args.goal?.trim();
-  const scope = ctx.args.scope;
+  const explicitGoal = explicitGoalArg?.trim();
+  const scope = scopeArg;
   let goalId;
   let manifestIssueNumber = null;
   let manifestCreated = false;
@@ -5639,8 +5755,17 @@ ${markdown}`,
 `);
     }
   }
-  const stateFile = writeStateFile(ctx.cwd, goalId);
-  commitAndPushState(stateFile, goalId, ctx.cwd);
+  const now = nowIso();
+  const goalState = { state: "active", startedAt: now, updatedAt: now, extra: { version: 1 } };
+  try {
+    putGoalState(ctx.config.github.owner, ctx.config.github.repo, goalId, goalState, `chore(goals): activate ${goalId}`, ctx.cwd);
+  } catch (err) {
+    process.stderr.write(
+      `[createQaGoal] failed to persist goal state to kody-state: ${err instanceof Error ? err.message : String(err)}
+[createQaGoal]   goal-scheduler will not see ${goalId} until this succeeds.
+`
+    );
+  }
   const repoUrl = `https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}`;
   if (manifestIssueNumber !== null) {
     const verb = manifestUpdated ? manifestCreated ? "OPENED" : "UPDATED" : "TARGETED";
@@ -5670,7 +5795,7 @@ QA_GOAL_TARGETED=(no manifest issue) (id: ${goalId}, verdict: ${verdict})
     mode: explicitGoal ? "goal-attach" : manifestCreated ? "goal-create" : "goal-append"
   });
   ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-};
+}
 
 // src/goal/operations.ts
 init_issue();
@@ -5909,13 +6034,13 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 }
 
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import * as fs23 from "fs";
 import * as os4 from "os";
-import * as path23 from "path";
+import * as path22 from "path";
 var diagMcp = async (_ctx) => {
   const home = os4.homedir();
-  const cacheDir = path23.join(home, ".cache", "ms-playwright");
+  const cacheDir = path22.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
     entries = fs23.readdirSync(cacheDir);
@@ -5929,7 +6054,7 @@ var diagMcp = async (_ctx) => {
   process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
   try {
-    const v = execFileSync12("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+    const v = execFileSync10("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
       stdio: "pipe",
       timeout: 6e4,
       encoding: "utf8"
@@ -5945,16 +6070,16 @@ var diagMcp = async (_ctx) => {
 
 // src/scripts/discoverQaContext.ts
 import * as fs25 from "fs";
-import * as path25 from "path";
+import * as path24 from "path";
 
 // src/scripts/frameworkDetectors.ts
 import * as fs24 from "fs";
-import * as path24 from "path";
+import * as path23 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs24.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs24.readFileSync(path23.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -5991,7 +6116,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs24.existsSync(path24.join(cwd, c))) return c;
+    if (fs24.existsSync(path23.join(cwd, c))) return c;
   }
   return null;
 }
@@ -6004,7 +6129,7 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path24.join(cwd, dir);
+    const full = path23.join(cwd, dir);
     if (!fs24.existsSync(full)) continue;
     let files;
     try {
@@ -6014,7 +6139,7 @@ function discoverPayloadCollections(cwd) {
     }
     for (const file of files) {
       try {
-        const filePath = path24.join(full, file);
+        const filePath = path23.join(full, file);
         const content = fs24.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
@@ -6029,7 +6154,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path24.relative(cwd, filePath),
+          filePath: path23.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -6043,7 +6168,7 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path24.join(cwd, dir);
+    const full = path23.join(cwd, dir);
     if (!fs24.existsSync(full)) continue;
     let entries;
     try {
@@ -6052,19 +6177,19 @@ function discoverAdminComponents(cwd, collections) {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path24.join(full, entry.name);
+      const entryPath = path23.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs24.existsSync(path24.join(entryPath, f))
+          (f) => fs24.existsSync(path23.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path24.relative(cwd, path24.join(entryPath, indexFile));
+        filePath = path23.relative(cwd, path23.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path24.relative(cwd, entryPath);
+        filePath = path23.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -6072,7 +6197,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs24.readFileSync(path24.join(cwd, col.filePath), "utf-8");
+            const colContent = fs24.readFileSync(path23.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -6091,7 +6216,7 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path24.join(cwd, appDir, "api");
+    const apiDir = path23.join(cwd, appDir, "api");
     if (!fs24.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
@@ -6108,7 +6233,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs24.readFileSync(path24.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs24.readFileSync(path23.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
       const methods = HTTP_METHODS.filter(
         (m) => new RegExp(`export\\s+(?:async\\s+)?function\\s+${m}\\b`).test(content)
       );
@@ -6116,7 +6241,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path24.relative(cwd, path24.join(dir, routeFile.name))
+          filePath: path23.relative(cwd, path23.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -6127,7 +6252,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkApiRoutes(path24.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path23.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6135,7 +6260,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path23.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -6155,7 +6280,7 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path24.join(cwd, envFile);
+    const envPath = path23.join(cwd, envFile);
     if (!fs24.existsSync(envPath)) continue;
     try {
       const content = fs24.readFileSync(envPath, "utf-8");
@@ -6206,9 +6331,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs25.readFileSync(path25.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs25.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs25.existsSync(path25.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs25.existsSync(path25.join(cwd, "yarn.lock")) ? "yarn" : fs25.existsSync(path25.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs25.existsSync(path24.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs25.existsSync(path24.join(cwd, "yarn.lock")) ? "yarn" : fs25.existsSync(path24.join(cwd, "bun.lockb")) ? "bun" : "npm";
     if (pkg.scripts?.dev) out.devCommand = `${pm} dev`;
     if (allDeps.next || allDeps.nuxt) out.devPort = 3e3;
     else if (allDeps.vite) out.devPort = 5173;
@@ -6218,7 +6343,7 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path25.join(cwd, appDir);
+    const full = path24.join(cwd, appDir);
     if (!fs25.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
@@ -6244,7 +6369,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkFrontendRoutes(path25.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path24.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6252,7 +6377,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path25.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -6269,13 +6394,13 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs25.existsSync(path25.join(cwd, c))) out.authFiles.push(c);
+    if (fs25.existsSync(path24.join(cwd, c))) out.authFiles.push(c);
   }
 }
 function detectRoles(cwd, out) {
   const rolePaths = ["src/types", "src/lib", "src/utils", "src/constants", "src/access", "src/collections"];
   for (const rp of rolePaths) {
-    const dir = path25.join(cwd, rp);
+    const dir = path24.join(cwd, rp);
     if (!fs25.existsSync(dir)) continue;
     let files;
     try {
@@ -6285,7 +6410,7 @@ function detectRoles(cwd, out) {
     }
     for (const f of files) {
       try {
-        const content = fs25.readFileSync(path25.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs25.readFileSync(path24.join(dir, f), "utf-8").slice(0, 5e3);
         const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
         if (roleMatches) {
           for (const m of roleMatches) {
@@ -6369,7 +6494,7 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 var API_TIMEOUT_MS4 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
@@ -6405,7 +6530,7 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync13("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync11("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS4,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6425,7 +6550,7 @@ function parsePr(url) {
 }
 
 // src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 var API_TIMEOUT_MS5 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var dispatchClassified = async (ctx) => {
@@ -6449,7 +6574,7 @@ ${auditLine}
 
 ${stateBody}`;
   try {
-    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS5,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6470,7 +6595,7 @@ function failedAction3(reason) {
 
 // src/scripts/dispatchJobFileTicks.ts
 import * as fs27 from "fs";
-import * as path27 from "path";
+import * as path26 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -6563,44 +6688,6 @@ function stripQuotes(value) {
 // src/scripts/jobState/contentsApiBackend.ts
 init_issue();
 
-// src/stateBranch.ts
-init_issue();
-var STATE_BRANCH = "kody-state";
-function is404(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
-}
-function ensureStateBranch(owner, repo, cwd) {
-  try {
-    gh(["api", `/repos/${owner}/${repo}/git/ref/heads/${STATE_BRANCH}`], { cwd });
-    return;
-  } catch (err) {
-    if (!is404(err)) throw err;
-  }
-  const repoInfo = JSON.parse(gh(["api", `/repos/${owner}/${repo}`], { cwd }));
-  const defaultBranch2 = repoInfo.default_branch;
-  if (!defaultBranch2) {
-    throw new Error(`ensureStateBranch: could not resolve default branch for ${owner}/${repo}`);
-  }
-  const headRef = JSON.parse(
-    gh(["api", `/repos/${owner}/${repo}/git/ref/heads/${defaultBranch2}`], { cwd })
-  );
-  const sha = headRef.object?.sha;
-  if (!sha) {
-    throw new Error(`ensureStateBranch: could not resolve head sha for ${owner}/${repo}@${defaultBranch2}`);
-  }
-  try {
-    gh(["api", "--method", "POST", `/repos/${owner}/${repo}/git/refs`, "--input", "-"], {
-      cwd,
-      input: JSON.stringify({ ref: `refs/heads/${STATE_BRANCH}`, sha })
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/already exists/i.test(msg) || /HTTP 422/i.test(msg)) return;
-    throw err;
-  }
-}
-
 // src/scripts/issueStateComment.ts
 init_issue();
 function isStateEnvelope(x) {
@@ -6778,7 +6865,7 @@ var ContentsApiBackend = class {
 
 // src/scripts/jobState/localFileBackend.ts
 import * as fs26 from "fs";
-import * as path26 from "path";
+import * as path25 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -6793,7 +6880,7 @@ var LocalFileBackend = class {
     if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
     this.cwd = opts.cwd;
     this.jobsDir = opts.jobsDir;
-    this.absDir = path26.join(opts.cwd, opts.jobsDir);
+    this.absDir = path25.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -6853,7 +6940,7 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path26.join(this.cwd, relPath);
+    const absPath = path25.join(this.cwd, relPath);
     if (!fs26.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
@@ -6874,8 +6961,8 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path26.join(this.cwd, loaded.path);
-    fs26.mkdirSync(path26.dirname(absPath), { recursive: true });
+    const absPath = path25.join(this.cwd, loaded.path);
+    fs26.mkdirSync(path25.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
     fs26.writeFileSync(absPath, body, "utf-8");
     return true;
@@ -6955,7 +7042,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path27.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path26.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -7068,7 +7155,7 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs27.readFileSync(path27.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs27.readFileSync(path26.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter2(raw).frontmatter;
   } catch {
     return {};
@@ -7605,7 +7692,7 @@ var finalizeTerminal = async (ctx) => {
 
 // src/scripts/finishFlow.ts
 init_issue();
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 var TERMINAL_PHASE = {
   "review-passed": { phase: "shipped", status: "succeeded" },
   "fix-applied": { phase: "shipped", status: "succeeded" },
@@ -7645,7 +7732,7 @@ var finishFlow = async (ctx, profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync13("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7675,9 +7762,9 @@ var finishFlow = async (ctx, profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 function git2(args, cwd) {
-  return execFileSync16("git", args, {
+  return execFileSync14("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -7694,11 +7781,11 @@ function getCurrentBranch(cwd) {
 }
 function resetWorkingTree(cwd) {
   try {
-    execFileSync16("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync14("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync16("git", ["clean", "-fd"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync14("git", ["clean", "-fd"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
 }
@@ -7710,14 +7797,14 @@ function checkoutPrBranch(prNumber, cwd) {
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
   try {
-    execFileSync16("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync14("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync16("git", ["clean", "-fd"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync14("git", ["clean", "-fd"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
-  execFileSync16("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync14("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -7843,7 +7930,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 import * as fs28 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
@@ -7886,7 +7973,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync17("gh", args, opts);
+      execFileSync15("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -7899,7 +7986,7 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync17("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync15("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
@@ -7908,7 +7995,7 @@ function sleepMs(ms) {
 init_issue();
 
 // src/workflow.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -7916,7 +8003,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync18("gh", args, {
+  return execFileSync16("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -8151,13 +8238,13 @@ var handleAbandonedGoal = async (ctx) => {
 };
 
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync17 } from "child_process";
 import * as fs29 from "fs";
-import * as path28 from "path";
+import * as path27 from "path";
 function detectPackageManager(cwd) {
-  if (fs29.existsSync(path28.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs29.existsSync(path28.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs29.existsSync(path28.join(cwd, "bun.lockb"))) return "bun";
+  if (fs29.existsSync(path27.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs29.existsSync(path27.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs29.existsSync(path27.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -8177,7 +8264,7 @@ function schemaUrlFromPkg() {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync19("git", ["remote", "get-url", "origin"], {
+    url = execFileSync17("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -8262,7 +8349,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync19("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync17("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -8270,7 +8357,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync19("git", ["branch", "--show-current"], {
+      return execFileSync17("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -8286,7 +8373,7 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path28.join(cwd, "kody.config.json");
+  const configPath = path27.join(cwd, "kody.config.json");
   if (fs29.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
@@ -8295,8 +8382,8 @@ function performInit(cwd, force) {
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path28.join(cwd, ".github", "workflows");
-  const workflowPath = path28.join(workflowDir, "kody.yml");
+  const workflowDir = path27.join(cwd, ".github", "workflows");
+  const workflowPath = path27.join(workflowDir, "kody.yml");
   if (fs29.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
@@ -8306,11 +8393,11 @@ function performInit(cwd, force) {
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path28.join(cwd, ".kody", "duties");
+    const jobsDir = path27.join(cwd, ".kody", "duties");
     fs29.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path28.join(".kody", "duties", `${job.slug}.md`);
-      const target = path28.join(cwd, rel);
+      const rel = path27.join(".kody", "duties", `${job.slug}.md`);
+      const target = path27.join(cwd, rel);
       if (fs29.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
@@ -8327,7 +8414,7 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path28.join(workflowDir, `kody-${exe.name}.yml`);
+    const target = path27.join(workflowDir, `kody-${exe.name}.yml`);
     if (fs29.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
@@ -8409,86 +8496,6 @@ Nothing to do. All files already present. (Use --force to overwrite.)
 init_loadConventions();
 init_loadCoverageRules();
 
-// src/goal/state.ts
-import * as fs30 from "fs";
-import * as path29 from "path";
-var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
-var GoalStateError = class extends Error {
-  constructor(path40, message) {
-    super(`Invalid goal state at ${path40}:
-  ${message}`);
-    this.path = path40;
-    this.name = "GoalStateError";
-  }
-  path;
-};
-function parseGoalState(filePath, raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new GoalStateError(filePath, "must be a JSON object");
-  }
-  const r = raw;
-  const stateValue = r.state;
-  if (typeof stateValue !== "string" || !VALID_STATES.has(stateValue)) {
-    throw new GoalStateError(
-      filePath,
-      `"state" is required and must be one of: ${[...VALID_STATES].join(" | ")} (got ${JSON.stringify(stateValue)})`
-    );
-  }
-  const parsed = {
-    state: stateValue,
-    extra: {}
-  };
-  if (typeof r.mergeApproved === "boolean") {
-    parsed.mergeApproved = r.mergeApproved;
-  }
-  if (typeof r.lastDispatchedIssue === "number" && Number.isFinite(r.lastDispatchedIssue)) {
-    parsed.lastDispatchedIssue = r.lastDispatchedIssue;
-  }
-  for (const ts of ["updatedAt", "createdAt", "startedAt"]) {
-    const v = r[ts];
-    if (typeof v === "string" && v.length > 0) parsed[ts] = v;
-  }
-  const known = /* @__PURE__ */ new Set(["state", "mergeApproved", "lastDispatchedIssue", "updatedAt", "createdAt", "startedAt"]);
-  for (const [k, v] of Object.entries(r)) {
-    if (!known.has(k)) parsed.extra[k] = v;
-  }
-  return parsed;
-}
-function serializeGoalState(s) {
-  const obj = { ...s.extra, state: s.state };
-  if (s.mergeApproved !== void 0) obj.mergeApproved = s.mergeApproved;
-  if (s.lastDispatchedIssue !== void 0) obj.lastDispatchedIssue = s.lastDispatchedIssue;
-  if (s.createdAt !== void 0) obj.createdAt = s.createdAt;
-  if (s.startedAt !== void 0) obj.startedAt = s.startedAt;
-  if (s.updatedAt !== void 0) obj.updatedAt = s.updatedAt;
-  return `${JSON.stringify(obj, null, 2)}
-`;
-}
-function goalStatePath(cwd, goalId) {
-  return path29.join(cwd, ".kody", "goals", goalId, "state.json");
-}
-function readGoalState(cwd, goalId) {
-  const file = goalStatePath(cwd, goalId);
-  if (!fs30.existsSync(file)) {
-    throw new GoalStateError(file, "file not found");
-  }
-  let raw;
-  try {
-    raw = JSON.parse(fs30.readFileSync(file, "utf-8"));
-  } catch (err) {
-    throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  return parseGoalState(file, raw);
-}
-function writeGoalState(cwd, goalId, state) {
-  const file = goalStatePath(cwd, goalId);
-  fs30.mkdirSync(path29.dirname(file), { recursive: true });
-  fs30.writeFileSync(file, serializeGoalState(state), "utf-8");
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-
 // src/scripts/loadGoalState.ts
 var loadGoalState = async (ctx) => {
   const goalId = ctx.args.goal;
@@ -8504,8 +8511,24 @@ var loadGoalState = async (ctx) => {
     ctx.output.reason = "invalid goal id (no slashes or '..' allowed)";
     return;
   }
+  const owner = ctx.config.github?.owner;
+  const repo = ctx.config.github?.repo;
+  if (!owner || !repo) {
+    ctx.skipAgent = true;
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "missing github owner/repo in config";
+    return;
+  }
   try {
-    const state = readGoalState(ctx.cwd, goalId);
+    const state = fetchGoalState(owner, repo, goalId, ctx.cwd);
+    if (!state) {
+      process.stdout.write(`[goal-tick] no goal state for ${goalId} on ${owner}/${repo} \u2014 nothing to tick
+`);
+      ctx.skipAgent = true;
+      ctx.output.exitCode = 0;
+      ctx.output.reason = "no goal state to tick";
+      return;
+    }
     ctx.data.goal = {
       id: goalId,
       state: state.state,
@@ -8580,8 +8603,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs31 from "fs";
-import * as path30 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/duties");
   const workersDir = String(args?.workersDir ?? ".kody/staff");
@@ -8590,11 +8613,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path30.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs31.existsSync(absPath)) {
+  const absPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs30.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs31.readFileSync(absPath, "utf-8");
+  const raw = fs30.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
   const frontmatter = splitFrontmatter2(raw).frontmatter;
   const mentions = (frontmatter.mentions ?? []).map((login) => `@${login}`).join(" ");
@@ -8602,13 +8625,13 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   let workerTitle = "";
   let workerPersona = "";
   if (workerSlug) {
-    const workerPath = path30.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-    if (!fs31.existsSync(workerPath)) {
+    const workerPath = path28.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+    if (!fs30.existsSync(workerPath)) {
       throw new Error(
         `loadJobFromFile: duty '${slug}' declares staff '${workerSlug}' but ${workerPath} does not exist`
       );
     }
-    const workerRaw = fs31.readFileSync(workerPath, "utf-8");
+    const workerRaw = fs30.readFileSync(workerPath, "utf-8");
     const parsed = parseJobFile(workerRaw, workerSlug);
     workerTitle = parsed.title;
     workerPersona = parsed.body;
@@ -8651,18 +8674,18 @@ init_loadMemoryContext();
 init_loadPriorArt();
 
 // src/scripts/loadQaContext.ts
-import * as fs34 from "fs";
-import * as path33 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 
 // src/scripts/kodyVariables.ts
-import * as fs33 from "fs";
-import * as path32 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 var KODY_VARIABLES_REL_PATH = ".kody/variables.json";
 function readKodyVariables(cwd) {
-  const full = path32.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path30.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs33.readFileSync(full, "utf-8");
+    raw = fs32.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -8711,18 +8734,18 @@ function readProfileStaff(raw) {
   return { staff: staff ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path33.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs34.existsSync(dir)) return "";
+  const dir = path31.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs33.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs34.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs33.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs34.readFileSync(path33.join(dir, file), "utf-8");
+      const raw = fs33.readFileSync(path31.join(dir, file), "utf-8");
       const { staff, body } = readProfileStaff(raw);
       if (!staff.includes(QA_STAFF) && !staff.includes(ALL_STAFF)) continue;
       blocks.push(`## ${file}
@@ -8759,8 +8782,8 @@ var loadQaContext = async (ctx) => {
 init_events();
 
 // src/taskContext.ts
-import * as fs35 from "fs";
-import * as path34 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -8776,10 +8799,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path34.join(cwd, ".kody", "runs", ctx.runId);
-    fs35.mkdirSync(dir, { recursive: true });
-    const file = path34.join(dir, "task-context.json");
-    fs35.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path32.join(cwd, ".kody", "runs", ctx.runId);
+    fs34.mkdirSync(dir, { recursive: true });
+    const file = path32.join(dir, "task-context.json");
+    fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -8827,19 +8850,19 @@ var loadTaskState = async (ctx) => {
 };
 
 // src/scripts/loadWorkerAdhoc.ts
-import * as fs36 from "fs";
-import * as path35 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 var loadWorkerAdhoc = async (ctx, _profile, args) => {
   const workersDir = String(args?.workersDir ?? ".kody/staff");
   const workerSlug = String(ctx.args.worker ?? "").trim();
   if (!workerSlug) {
     throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
   }
-  const workerPath = path35.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-  if (!fs36.existsSync(workerPath)) {
+  const workerPath = path33.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+  if (!fs35.existsSync(workerPath)) {
     throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
   }
-  const { title, body } = parsePersona(fs36.readFileSync(workerPath, "utf-8"), workerSlug);
+  const { title, body } = parsePersona(fs35.readFileSync(workerPath, "utf-8"), workerSlug);
   const message = resolveMessage(ctx.args.message);
   if (!message) {
     throw new Error(
@@ -8859,9 +8882,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs36.existsSync(eventPath)) return "";
+  if (!eventPath || !fs35.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs36.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs35.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -9024,7 +9047,7 @@ var mergeFlow = async (ctx) => {
 };
 
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 var API_TIMEOUT_MS7 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -9043,7 +9066,7 @@ var mergeReleasePr = async (ctx) => {
   process.stderr.write(`[kody mergeReleasePr] merging PR #${prNumber} (${prUrl})
 `);
   try {
-    const out = execFileSync20("gh", ["pr", "merge", String(prNumber), "--merge"], {
+    const out = execFileSync18("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS7,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -9382,6 +9405,17 @@ var parseJobStateFromAgentResult = async (ctx, _profile, agentResult, args) => {
   }
   const result = extractNextStateFromText(agentResult.finalText, fenceLabel, prevRev);
   if (result.error) {
+    const cleanFinishNoBlock = result.error.startsWith("missing `") && agentResult.outcome === "completed" && loaded != null;
+    if (cleanFinishNoBlock) {
+      ctx.data.nextJobState = {
+        version: 1,
+        rev: prevRev + 1,
+        cursor: loaded.state.cursor,
+        data: loaded.state.data,
+        done: loaded.state.done
+      };
+      return;
+    }
     ctx.data.nextStateParseError = result.error.startsWith("missing `") ? `agent did not emit a \`${fenceLabel}\` fenced block` : result.error;
     return;
   }
@@ -9502,7 +9536,7 @@ var persistFlowState = async (ctx) => {
 };
 
 // src/scripts/poolServe.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { createServer as createServer2 } from "http";
 
 // src/pool/fly.ts
@@ -9520,8 +9554,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path40, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path40}`, {
+  async call(path38, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path38}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -9532,7 +9566,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path40}: ${text.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path38}: ${text.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -10072,14 +10106,14 @@ function sendJson2(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readJsonBody2(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw.trim()) return resolve4({});
+      if (!raw.trim()) return resolve5({});
       try {
-        resolve4(JSON.parse(raw));
+        resolve5(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -10121,7 +10155,7 @@ function superviseLitellm() {
   let restarts = 0;
   const start = () => {
     log(`starting litellm child (port ${port}, host ${host})`);
-    const child = spawn3("litellm", ["--config", config, "--port", port, "--host", host], {
+    const child = spawn4("litellm", ["--config", config, "--port", port, "--host", host], {
       stdio: "inherit"
     });
     child.on("exit", (code) => {
@@ -10226,10 +10260,10 @@ var poolServe = async (ctx) => {
     }
   });
   const apiHost = process.env.POOL_API_HOST ?? "::";
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     server.listen(apiPort, apiHost, () => {
       log(`listening on ${apiHost}:${apiPort} (min=${min}, app=${app}, region=${region})`);
-      resolve4();
+      resolve5();
     });
   });
   const shutdown = (signal) => {
@@ -10431,7 +10465,7 @@ ${body}`;
 }
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var VALID_CLASSES3 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var recordClassification = async (ctx) => {
@@ -10479,7 +10513,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync21("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync19("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS8,
       stdio: ["ignore", "pipe", "pipe"]
@@ -10593,7 +10627,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 init_issue();
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
@@ -10687,7 +10721,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync22("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync20("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -10702,7 +10736,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync22("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync20("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -10726,12 +10760,12 @@ function tryPostPr3(prNumber, body, cwd) {
 function pushEmptyCommit(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync22(
+    execFileSync20(
       "git",
       ["commit", "--allow-empty", "-m", "chore: kody resolve refresh \u2014 empty commit to recompute mergeable status"],
       { cwd, env, stdio: ["ignore", "pipe", "pipe"] }
     );
-    execFileSync22("git", ["push", "-u", "origin", branch], {
+    execFileSync20("git", ["push", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -10742,6 +10776,46 @@ function pushEmptyCommit(branch, cwd) {
   }
 }
 
+// src/scripts/promoteQaGoal.ts
+init_issue();
+var REPORT_JSON_OPEN2 = "<!-- KODY_QA_REPORT_JSON";
+var promoteQaGoal = async (ctx) => {
+  ctx.skipAgent = true;
+  const issueNum = ctx.args.issue;
+  if (typeof issueNum !== "number" || issueNum <= 0) {
+    ctx.output.exitCode = 2;
+    ctx.output.reason = "qa-goal requires --issue <n>";
+    process.stderr.write("[qa-goal] missing --issue\n");
+    return;
+  }
+  let report;
+  try {
+    const issue = getIssue(issueNum, ctx.cwd);
+    const reportComment = [...issue.comments].reverse().find((c) => c.body.includes(REPORT_JSON_OPEN2));
+    if (!reportComment) {
+      ctx.output.exitCode = 3;
+      ctx.output.reason = `no QA report (${REPORT_JSON_OPEN2} \u2026) found on issue #${issueNum}`;
+      process.stderr.write(`[qa-goal] ${ctx.output.reason}
+`);
+      return;
+    }
+    report = reportComment.body;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.output.exitCode = 3;
+    ctx.output.reason = `failed to read issue #${issueNum}: ${msg}`;
+    process.stderr.write(`[qa-goal] ${ctx.output.reason}
+`);
+    return;
+  }
+  await promoteReportToGoal(
+    ctx,
+    report,
+    ctx.args.scope,
+    ctx.args.goal
+  );
+};
+
 // src/deployments.ts
 init_issue();
 function findPreviewDeploymentUrl(prNumber, cwd) {
@@ -10822,10 +10896,10 @@ var resolvePreviewUrl = async (ctx) => {
 };
 
 // src/scripts/resolveQaUrl.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 function ghQuery(args, cwd) {
   try {
-    const out = execFileSync23("gh", args, {
+    const out = execFileSync21("gh", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
@@ -10895,7 +10969,7 @@ var resolveQaUrl = async (ctx) => {
 };
 
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 init_issue();
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
 var revertFlow = async (ctx) => {
@@ -10978,7 +11052,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git3(args, cwd) {
-  return execFileSync24("git", args, {
+  return execFileSync22("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -10988,7 +11062,7 @@ function git3(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync24("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync22("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -11083,9 +11157,9 @@ function resolveBaseOverride(value) {
 }
 
 // src/scripts/runnerServe.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { createServer as createServer3 } from "http";
-import * as fs37 from "fs";
+import * as fs36 from "fs";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
 function getApiKey2() {
@@ -11107,17 +11181,17 @@ function authOk2(req, expected) {
   return false;
 }
 function readJsonBody3(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve4({});
+        resolve5({});
         return;
       }
       try {
-        resolve4(JSON.parse(raw));
+        resolve5(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -11166,8 +11240,8 @@ async function defaultRunJob(job) {
   const workdir = process.env.RUNNER_WORKDIR ?? DEFAULT_WORKDIR;
   const branch = job.ref ?? "main";
   const authUrl = `https://x-access-token:${job.githubToken}@github.com/${job.repo}.git`;
-  fs37.rmSync(workdir, { recursive: true, force: true });
-  fs37.mkdirSync(workdir, { recursive: true });
+  fs36.rmSync(workdir, { recursive: true, force: true });
+  fs36.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const interactive = job.mode === "interactive";
   const childEnv = {
@@ -11192,13 +11266,13 @@ async function defaultRunJob(job) {
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
-  const run = (cmd, args, cwd) => new Promise((resolve4) => {
-    const child = spawn4(cmd, args, { stdio: "inherit", env: childEnv, cwd });
-    child.on("exit", (code) => resolve4(code ?? 0));
+  const run = (cmd, args, cwd) => new Promise((resolve5) => {
+    const child = spawn5(cmd, args, { stdio: "inherit", env: childEnv, cwd });
+    child.on("exit", (code) => resolve5(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
 `);
-      resolve4(1);
+      resolve5(1);
     });
   });
   process.stdout.write(`[runner-serve] job ${job.jobId}: cloning ${job.repo}@${branch}
@@ -11285,11 +11359,11 @@ var runnerServe = async (ctx) => {
   const port = Number(process.env.PORT ?? DEFAULT_PORT2);
   const server = buildServer2({ apiKey });
   const host = process.env.RUNNER_HOST ?? "::";
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     server.listen(port, host, () => {
       process.stdout.write(`[runner-serve] listening on ${host}:${port} (idle, awaiting job)
 `);
-      resolve4();
+      resolve5();
     });
   });
   const shutdown = (signal) => {
@@ -11304,9 +11378,9 @@ var runnerServe = async (ctx) => {
 };
 
 // src/scripts/runTickScript.ts
-import { spawnSync } from "child_process";
-import * as fs38 from "fs";
-import * as path36 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs37 from "fs";
+import * as path34 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/duties");
@@ -11318,13 +11392,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path36.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs38.existsSync(jobPath)) {
+  const jobPath = path34.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs37.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs38.readFileSync(jobPath, "utf-8");
+  const raw = fs37.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter2(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -11332,8 +11406,8 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
     return;
   }
-  const scriptPath = path36.isAbsolute(tickScript) ? tickScript : path36.join(ctx.cwd, tickScript);
-  if (!fs38.existsSync(scriptPath)) {
+  const scriptPath = path34.isAbsolute(tickScript) ? tickScript : path34.join(ctx.cwd, tickScript);
+  if (!fs37.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -11350,7 +11424,7 @@ var runTickScript = async (ctx, _profile, args) => {
   ctx.data.jobSlug = slug;
   ctx.data.jobState = loaded;
   const childEnv = buildChildEnv(process.env, Boolean(ctx.args.force));
-  const result = spawnSync("bash", [scriptPath], {
+  const result = spawnSync2("bash", [scriptPath], {
     cwd: ctx.cwd,
     env: childEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -11449,7 +11523,8 @@ var saveGoalState = async (ctx) => {
     lastDispatchedIssue: goal.lastDispatchedIssue,
     updatedAt: changed ? nowIso() : prev?.updatedAt
   };
-  writeGoalState(ctx.cwd, goal.id, updated);
+  ctx.data.goalPersistState = updated;
+  ctx.data.goalPersistChanged = changed;
   ctx.skipAgent = true;
 };
 
@@ -11483,7 +11558,7 @@ function synthesizeAction(ctx) {
 }
 
 // src/scripts/serveFlow.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 function parseTarget(positional) {
   if (!Array.isArray(positional) || positional.length === 0) return "none";
   const first = String(positional[0]).toLowerCase();
@@ -11532,15 +11607,15 @@ var serveFlow = async (ctx) => {
     if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
-    const child = spawn5("claude", args, { stdio: "inherit", env: editorEnv, cwd: ctx.cwd });
-    const exitCode = await new Promise((resolve4) => {
-      child.on("exit", (code) => resolve4(code ?? 0));
+    const child = spawn6("claude", args, { stdio: "inherit", env: editorEnv, cwd: ctx.cwd });
+    const exitCode = await new Promise((resolve5) => {
+      child.on("exit", (code) => resolve5(code ?? 0));
       child.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
 `);
         process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
 `);
-        resolve4(1);
+        resolve5(1);
       });
     });
     killProxy();
@@ -11553,7 +11628,7 @@ var serveFlow = async (ctx) => {
     if (usesProxy) process.stdout.write(`  ANTHROPIC_BASE_URL=${url}
 `);
     try {
-      const code = spawn5("code", [ctx.cwd], { stdio: "inherit", env: editorEnv, detached: true });
+      const code = spawn6("code", [ctx.cwd], { stdio: "inherit", env: editorEnv, detached: true });
       code.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch VS Code: ${err.message}
 `);
@@ -11630,11 +11705,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync25("git", ["add", "-A"], {
+    execFileSync23("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -11645,7 +11720,7 @@ var stageMergeConflicts = async (ctx) => {
 
 // src/scripts/startFlow.ts
 init_issue();
-import { execFileSync as execFileSync26 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -11679,7 +11754,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync26("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync24("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS9,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -11693,7 +11768,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync27 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 init_issue();
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
@@ -11758,7 +11833,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync27("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync25("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -11808,7 +11883,7 @@ var verify = async (ctx) => {
 };
 
 // src/scripts/verifyReproFails.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 var TEST_TIMEOUT_MS = 10 * 60 * 1e3;
 var TAIL_CHARS2 = 8e3;
 var ANSI_RE2 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
@@ -11876,8 +11951,8 @@ function stripAnsi2(s) {
   return s.replace(ANSI_RE2, "");
 }
 function runCommand2(command, cwd) {
-  return new Promise((resolve4) => {
-    const child = spawn6(command, {
+  return new Promise((resolve5) => {
+    const child = spawn7(command, {
       cwd,
       shell: true,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
@@ -11903,11 +11978,11 @@ function runCommand2(command, cwd) {
     }, TEST_TIMEOUT_MS);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve4({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+      resolve5({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve4({ exitCode: -1, output: err.message });
+      resolve5({ exitCode: -1, output: err.message });
     });
   });
 }
@@ -12015,7 +12090,7 @@ var verifyWithRetry = async (ctx) => {
 
 // src/scripts/waitForCi.ts
 init_issue();
-import { execFileSync as execFileSync28 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -12093,7 +12168,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync28("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync26("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS10,
       cwd,
@@ -12206,7 +12281,7 @@ var appendCompanyActivity = async (ctx, _profile, agentResult) => {
 };
 
 // src/scripts/warmupMcp.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 var PER_SERVER_TIMEOUT_MS = 6e4;
 var PER_REQUEST_TIMEOUT_MS = 2e4;
 var warmupMcp = async (_ctx, profile) => {
@@ -12228,7 +12303,7 @@ var warmupMcp = async (_ctx, profile) => {
   }
 };
 async function warmupOne(command, args, env) {
-  const child = spawn7(command, args, {
+  const child = spawn8(command, args, {
     stdio: ["pipe", "pipe", "pipe"],
     env: env ? { ...process.env, ...env } : process.env
   });
@@ -12329,20 +12404,20 @@ function lineStream(stream) {
     tryDeliver();
   });
   return {
-    next: (timeoutMs) => new Promise((resolve4) => {
+    next: (timeoutMs) => new Promise((resolve5) => {
       if (queue.length > 0) {
-        resolve4(queue.shift());
+        resolve5(queue.shift());
         return;
       }
       if (ended) {
-        resolve4(null);
+        resolve5(null);
         return;
       }
-      waiter = resolve4;
+      waiter = resolve5;
       const t = setTimeout(() => {
-        if (waiter === resolve4) {
+        if (waiter === resolve5) {
           waiter = null;
-          resolve4(null);
+          resolve5(null);
         }
       }, Math.max(0, timeoutMs));
       t.unref?.();
@@ -12440,7 +12515,7 @@ var writeJobStateFile = async (ctx, _profile, agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs39 from "fs";
+import * as fs38 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -12462,7 +12537,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs39.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs38.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -12495,6 +12570,7 @@ var preflightScripts = {
   discoverQaContext,
   resolvePreviewUrl,
   resolveQaUrl,
+  promoteQaGoal,
   composePrompt,
   setCommentTarget,
   setLifecycleLabel,
@@ -12565,7 +12641,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync29 } from "child_process";
+import { execFileSync as execFileSync27 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -12598,7 +12674,7 @@ function verifyOne(tool3, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync29("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync27("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -12706,9 +12782,9 @@ async function runExecutable(profileName, input) {
       })
     };
   })() : null;
-  const ndjsonDir = path37.join(input.cwd, ".kody");
+  const ndjsonDir = path35.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path37.isAbsolute(p) ? p : path37.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path35.isAbsolute(p) ? p : path35.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -12920,7 +12996,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs40.existsSync(profilePath)) return null;
+    if (!fs39.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -12929,17 +13005,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path37.dirname(new URL(import.meta.url).pathname);
+  const here = path35.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path37.join(here, "executables", profileName, "profile.json"),
+    path35.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path37.join(here, "..", "executables", profileName, "profile.json"),
+    path35.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path37.join(here, "..", "src", "executables", profileName, "profile.json")
+    path35.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs40.existsSync(c)) return c;
+    if (fs39.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -13039,8 +13115,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path37.join(profile.dir, shellName);
-  if (!fs40.existsSync(shellPath)) {
+  const shellPath = path35.join(profile.dir, shellName);
+  if (!fs39.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -13056,7 +13132,7 @@ async function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const child = spawn8("bash", [shellPath, ...positional], {
+  const child = spawn9("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -13078,14 +13154,14 @@ async function runShellEntry(entry, ctx, profile) {
   let killTimer;
   let escalateTimer;
   const result = await new Promise(
-    (resolve4) => {
+    (resolve5) => {
       let settled = false;
       const settle = (code, signal, spawnErr) => {
         if (settled) return;
         settled = true;
         if (killTimer) clearTimeout(killTimer);
         if (escalateTimer) clearTimeout(escalateTimer);
-        resolve4({ code, signal, spawnErr });
+        resolve5({ code, signal, spawnErr });
       };
       child.on("error", (err) => settle(null, null, err));
       child.on("close", (code, signal) => settle(code, signal));
@@ -13367,7 +13443,7 @@ async function runContainerLoop(profile, ctx, input) {
 }
 function resetWorkingTree2(cwd) {
   try {
-    execFileSync30("git", ["reset", "--hard", "HEAD"], {
+    execFileSync28("git", ["reset", "--hard", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -13519,14 +13595,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs41.existsSync(path38.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs41.existsSync(path38.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs41.existsSync(path38.join(cwd, "bun.lockb"))) return "bun";
+  if (fs40.existsSync(path36.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs40.existsSync(path36.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs40.existsSync(path36.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync31(cmd, args, {
+    execFileSync29(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -13539,7 +13615,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync31("which", [bin], { stdio: "pipe" });
+    execFileSync29("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -13580,7 +13656,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync31("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync29("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -13590,16 +13666,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync31("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync29("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync31("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync29("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync31("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync29("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -13608,11 +13684,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path38.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path36.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs41.existsSync(logPath)) {
-      const content = fs41.readFileSync(logPath, "utf-8");
+    if (fs40.existsSync(logPath)) {
+      const content = fs40.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -13637,7 +13713,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path38.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path36.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -13647,9 +13723,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 && fs41.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs40.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs41.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs40.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);
@@ -13908,17 +13984,17 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path39.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path39.relative(cwd, eventsFilePath(cwd, sessionId));
+  const sessionFile = path37.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path37.relative(cwd, eventsFilePath(cwd, sessionId));
   const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tasksDir = path39.join(".kody", "tasks", safeSession);
+  const tasksDir = path37.join(".kody", "tasks", safeSession);
   const candidatePaths = [sessionFile, eventsFile, tasksDir];
-  const paths = candidatePaths.filter((p) => fs42.existsSync(path39.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs41.existsSync(path37.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync32("git", ["add", "-f", ...paths], opts);
-    execFileSync32("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync30("git", ["add", "-f", ...paths], opts);
+    execFileSync30("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[kody:chat] commit skipped: ${msg}
@@ -13957,7 +14033,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path39.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path37.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -14009,7 +14085,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs42.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs41.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {