@kody-ade/kody-engine 0.4.81 → 0.4.83

package/dist/bin/kody.js

@@ -460,16 +460,16 @@ var init_issue = __esm({
 });
 
 // src/prompt.ts
-import * as fs14 from "fs";
-import * as path12 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path12.join(projectDir, rel);
-    if (!fs14.existsSync(abs)) continue;
+    const abs = path14.join(projectDir, rel);
+    if (!fs16.existsSync(abs)) continue;
     let content;
     try {
-      content = fs14.readFileSync(abs, "utf-8");
+      content = fs16.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -617,28 +617,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs28.statSync(file);
+      stat = fs30.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs28.readFileSync(file, "utf-8");
+      raw = fs30.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() ?? path26.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path28.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path26.relative(memoryAbs, file),
+      relPath: path28.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -706,16 +706,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs28.readdirSync(dir);
+      names = fs30.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path26.join(dir, name);
+      const full = path28.join(dir, name);
       let stat;
       try {
-        stat = fs28.statSync(full);
+        stat = fs30.statSync(full);
       } catch {
         continue;
       }
@@ -738,8 +738,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path26.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs28.existsSync(memoryAbs)) {
+      const memoryAbs = path28.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs30.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -868,7 +868,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.81",
+  version: "0.4.83",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -3702,529 +3702,982 @@ var advanceFlow = async (ctx, profile) => {
   }
 };
 
-// src/scripts/buildSyntheticPlugin.ts
+// src/scripts/brainServe.ts
+import { createServer } from "http";
+import * as fs14 from "fs";
+import * as path12 from "path";
+
+// src/scripts/brainTurnLog.ts
 import * as fs13 from "fs";
-import * as os3 from "os";
 import * as path11 from "path";
-function getPluginsCatalogRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path11.join(here, "..", "plugins"),
-    // dev: src/scripts → src/plugins
-    path11.join(here, "..", "..", "plugins"),
-    // built: dist/scripts → dist/plugins
-    path11.join(here, "..", "..", "src", "plugins")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) return c;
+var live = /* @__PURE__ */ new Map();
+function eventsPath(dir, chatId) {
+  return path11.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+}
+function lastPersistedSeq(dir, chatId) {
+  const p = eventsPath(dir, chatId);
+  if (!fs13.existsSync(p)) return 0;
+  const lines = fs13.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (lines.length === 0) return 0;
+  try {
+    return JSON.parse(lines[lines.length - 1]).seq || 0;
+  } catch {
+    return 0;
   }
-  return candidates[0];
 }
-var buildSyntheticPlugin = async (ctx, profile) => {
-  const cc = profile.claudeCode;
-  const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0 || cc.subagents.length > 0;
-  if (!needsSynthetic) return;
-  const catalog = getPluginsCatalogRoot();
-  const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path11.join(os3.tmpdir(), `kody-synth-${runId}`);
-  fs13.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
-  const resolvePart = (bucket, entry) => {
-    const local = path11.join(profile.dir, bucket, entry);
-    if (fs13.existsSync(local)) return local;
-    const central = path11.join(catalog, bucket, entry);
-    if (fs13.existsSync(central)) return central;
-    throw new Error(
-      `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
-    );
-  };
-  if (cc.skills.length > 0) {
-    const dst = path11.join(root, "skills");
-    fs13.mkdirSync(dst, { recursive: true });
-    for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path11.join(dst, name));
+function readSince(dir, chatId, since) {
+  const p = eventsPath(dir, chatId);
+  if (!fs13.existsSync(p)) return [];
+  const out = [];
+  for (const line of fs13.readFileSync(p, "utf-8").split("\n")) {
+    if (!line) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (rec.seq > since) out.push(rec);
+    } catch {
     }
   }
-  if (cc.commands.length > 0) {
-    const dst = path11.join(root, "commands");
-    fs13.mkdirSync(dst, { recursive: true });
-    for (const name of cc.commands) {
-      fs13.copyFileSync(resolvePart("commands", `${name}.md`), path11.join(dst, `${name}.md`));
+  return out;
+}
+function isTerminal(event) {
+  return event.type === "done" || event.type === "error";
+}
+function beginTurn(dir, chatId) {
+  const existing = live.get(chatId);
+  const seqFloor = existing ? existing.seq : lastPersistedSeq(dir, chatId);
+  const turn = (existing?.turn ?? 0) + 1;
+  const state = {
+    seq: seqFloor,
+    turn,
+    status: "running",
+    terminal: null,
+    subscribers: /* @__PURE__ */ new Set()
+  };
+  live.set(chatId, state);
+  const p = eventsPath(dir, chatId);
+  fs13.mkdirSync(path11.dirname(p), { recursive: true });
+  return (event) => {
+    state.seq += 1;
+    const rec = { seq: state.seq, turn, ts: Date.now(), event };
+    try {
+      fs13.appendFileSync(p, JSON.stringify(rec) + "\n");
+    } catch (err) {
+      process.stderr.write(
+        `[brain-turn-log] append failed for ${chatId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
-  }
-  if (cc.subagents.length > 0) {
-    const dst = path11.join(root, "agents");
-    fs13.mkdirSync(dst, { recursive: true });
-    for (const name of cc.subagents) {
-      fs13.copyFileSync(resolvePart("agents", `${name}.md`), path11.join(dst, `${name}.md`));
+    for (const fn of state.subscribers) {
+      try {
+        fn(rec);
+      } catch {
+      }
     }
-  }
-  if (cc.hooks.length > 0) {
-    const dst = path11.join(root, "hooks");
-    fs13.mkdirSync(dst, { recursive: true });
-    const merged = { hooks: {} };
-    for (const name of cc.hooks) {
-      const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs13.readFileSync(src, "utf-8"));
-      for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
-        if (!Array.isArray(entries)) continue;
-        if (!merged.hooks[event]) merged.hooks[event] = [];
-        merged.hooks[event].push(...entries);
+    if (isTerminal(event)) {
+      state.status = "ended";
+      state.terminal = rec;
+      const subs = [...state.subscribers];
+      state.subscribers.clear();
+      for (const fn of subs) {
+        try {
+          fn(null);
+        } catch {
+        }
       }
     }
-    fs13.writeFileSync(path11.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
-`);
-  }
-  const manifest = {
-    name: `kody-synth-${profile.name}`,
-    version: "1.0.0",
-    description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
   };
-  if (cc.skills.length > 0) manifest.skills = ["./skills/"];
-  if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-  if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs13.writeFileSync(path11.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
-`);
-  ctx.data.syntheticPluginPath = root;
-};
-function copyDir(src, dst) {
-  fs13.mkdirSync(dst, { recursive: true });
-  for (const ent of fs13.readdirSync(src, { withFileTypes: true })) {
-    const s = path11.join(src, ent.name);
-    const d = path11.join(dst, ent.name);
-    if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs13.copyFileSync(s, d);
-  }
-}
-
-// src/coverage.ts
-import { execFileSync as execFileSync8 } from "child_process";
-function patternToRegex(pattern) {
-  let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
-  s = s.replace(/§S/g, "(?:.*/)?").replace(/§A/g, ".*");
-  return new RegExp(`^${s}$`);
-}
-function renderSiblingPath(file, requireSibling) {
-  const lastSlash = file.lastIndexOf("/");
-  const dir = lastSlash === -1 ? "" : file.slice(0, lastSlash + 1);
-  const base = lastSlash === -1 ? file : file.slice(lastSlash + 1);
-  const name = base.replace(/\.[^.]+$/, "");
-  const ext = base.match(/\.[^.]+$/)?.[0] ?? "";
-  const sibling = requireSibling.replace(/\{name\}/g, name).replace(/\{ext\}/g, ext);
-  return dir + sibling;
 }
-function safeGit(args, cwd) {
+function endTurnIfUnterminated(dir, chatId, errMessage) {
+  const state = live.get(chatId);
+  if (!state || state.status === "ended") return;
+  state.seq += 1;
+  const rec = {
+    seq: state.seq,
+    turn: state.turn,
+    ts: Date.now(),
+    event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
+  };
   try {
-    return execFileSync8("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+    fs13.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
   } catch {
-    return "";
   }
-}
-function getAddedFiles(baseBranch, cwd) {
-  const committed = safeGit(["diff", "--name-only", "--diff-filter=A", `origin/${baseBranch}...HEAD`], cwd);
-  const untracked = safeGit(["ls-files", "--others", "--exclude-standard"], cwd);
-  const set = /* @__PURE__ */ new Set();
-  for (const f of committed.split("\n")) if (f) set.add(f);
-  for (const f of untracked.split("\n")) if (f) set.add(f);
-  return [...set];
-}
-function checkCoverage(addedFiles, requirements) {
-  if (requirements.length === 0) return [];
-  const addedSet = new Set(addedFiles);
-  const misses = [];
-  for (const file of addedFiles) {
-    if (/\.(test|spec)\./.test(file)) continue;
-    for (const req of requirements) {
-      const re = patternToRegex(req.pattern);
-      if (!re.test(file)) continue;
-      const expected = renderSiblingPath(file, req.requireSibling);
-      if (!addedSet.has(expected)) {
-        misses.push({ file, expectedTest: expected });
-      }
-      break;
+  state.status = "ended";
+  state.terminal = rec;
+  const subs = [...state.subscribers];
+  state.subscribers.clear();
+  for (const fn of subs) {
+    try {
+      fn(rec);
+      fn(null);
+    } catch {
     }
   }
-  return misses;
-}
-function formatMissesForFeedback(misses) {
-  if (misses.length === 0) return "";
-  const lines = ["The following files were added without a sibling test file:"];
-  for (const m of misses) lines.push(`- \`${m.file}\` \u2192 expected \`${m.expectedTest}\``);
-  lines.push("");
-  lines.push(
-    "Add the missing test files. Each should cover the new file's public API with at least a happy path and one failure path. Then re-emit DONE / COMMIT_MSG / PR_SUMMARY."
-  );
-  return lines.join("\n");
 }
-
-// src/scripts/checkCoverageWithRetry.ts
-init_prompt();
-var checkCoverageWithRetry = async (ctx) => {
-  const reqs = ctx.data.coverageRules ?? [];
-  if (reqs.length === 0) {
-    ctx.data.coverageMisses = [];
-    return;
-  }
-  if (!ctx.data.agentDone) {
-    ctx.data.coverageMisses = [];
-    return;
+function subscribe(dir, chatId, since, onRecord, onClose) {
+  const backlog = readSince(dir, chatId, since);
+  for (const rec of backlog) onRecord(rec);
+  const lastReplayed = backlog.length ? backlog[backlog.length - 1] : null;
+  if (lastReplayed && isTerminal(lastReplayed.event)) {
+    onClose();
+    return () => {
+    };
   }
-  const misses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
-  if (misses.length === 0) {
-    ctx.data.coverageMisses = [];
-    return;
+  const state = live.get(chatId);
+  if (state && state.status === "running") {
+    const fn = (rec) => {
+      if (rec === null) {
+        state.subscribers.delete(fn);
+        onClose();
+        return;
+      }
+      if (rec.seq > since) onRecord(rec);
+    };
+    state.subscribers.add(fn);
+    return () => {
+      state.subscribers.delete(fn);
+    };
   }
-  const invoker = ctx.data.__invokeAgent;
-  const basePrompt = ctx.data.prompt;
-  if (!invoker || !basePrompt) {
-    ctx.data.coverageMisses = misses;
-    return;
+  if (state && state.status === "ended" && state.terminal) {
+    if (state.terminal.seq > since && !lastReplayed) onRecord(state.terminal);
+    onClose();
+    return () => {
+    };
   }
-  process.stderr.write(`[kody] coverage check found ${misses.length} missing test(s); retrying agent once
-`);
-  const retryPrompt = `${basePrompt}
-
-# Coverage failure (retry)
-${formatMissesForFeedback(misses)}`;
-  const retry = await invoker(retryPrompt);
-  const retryParsed = parseAgentResult(retry.finalText);
-  if (retry.outcome === "completed" && retryParsed.done) {
-    ctx.data.agentDone = true;
-    ctx.data.commitMessage = retryParsed.commitMessage || ctx.data.commitMessage;
-    ctx.data.prSummary = retryParsed.prSummary || ctx.data.prSummary;
-  }
-  const finalMisses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
-  ctx.data.coverageMisses = finalMisses;
-};
-
-// src/scripts/classifyByLabel.ts
-var VALID_CLASSES = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
-var classifyByLabel = async (ctx) => {
-  const issue = ctx.data.issue;
-  const labels = issue?.labels;
-  if (!labels || labels.length === 0) return;
-  const cfgMap = ctx.config.classify?.labelMap;
-  const map = cfgMap ?? defaultLabelMap();
-  for (const label of labels) {
-    const candidate = map[label.toLowerCase()];
-    if (candidate && VALID_CLASSES.has(candidate)) {
-      ctx.data.classification = candidate;
-      ctx.data.classificationSource = "label";
-      ctx.data.classificationReason = `label \`${label}\` \u2192 ${candidate}`;
-      ctx.skipAgent = true;
-      return;
-    }
+  if (lastReplayed) {
+    onRecord({
+      seq: lastReplayed.seq + 1,
+      turn: lastReplayed.turn,
+      ts: Date.now(),
+      event: {
+        type: "error",
+        error: "stream interrupted (server restarted mid-reply) \u2014 resend your message",
+        chatId
+      }
+    });
   }
-};
-function defaultLabelMap() {
-  return {
-    bug: "bug",
-    enhancement: "bug",
-    refactor: "feature",
-    feature: "feature",
-    performance: "feature",
-    rfc: "spec",
-    design: "spec",
-    spec: "spec",
-    docs: "chore",
-    chore: "chore",
-    dependencies: "chore"
+  onClose();
+  return () => {
   };
 }
+function getLastSeq(dir, chatId) {
+  const state = live.get(chatId);
+  if (state) return state.seq;
+  return lastPersistedSeq(dir, chatId);
+}
 
-// src/scripts/commitAndPush.ts
-import * as fs15 from "fs";
-import * as path13 from "path";
-init_events();
-var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
-function sentinelPathForStage(cwd, profileName) {
-  const runId = resolveRunId();
-  return path13.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+// src/scripts/brainServe.ts
+var DEFAULT_PORT = 8080;
+function getApiKey() {
+  const key = (process.env.BRAIN_API_KEY ?? "").trim();
+  if (!key) {
+    throw new Error(
+      "BRAIN_API_KEY env var is required \u2014 set it on the Fly machine before boot."
+    );
+  }
+  return key;
 }
-var commitAndPush2 = async (ctx, profile) => {
-  const branch = ctx.data.branch;
-  if (!branch) {
-    ctx.data.commitResult = { committed: false, pushed: false };
-    return;
+function authOk(req, expected) {
+  const xApiKey = req.headers["x-api-key"]?.trim();
+  if (xApiKey && xApiKey === expected) return true;
+  const auth = req.headers["authorization"]?.trim();
+  if (auth && auth.toLowerCase().startsWith("bearer ")) {
+    return auth.slice(7).trim() === expected;
   }
-  const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
-  const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-  if (sentinel && fs15.existsSync(sentinel)) {
-    try {
-      const replay = JSON.parse(fs15.readFileSync(sentinel, "utf-8"));
-      ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
-      if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
-      if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
-      if (replay.salvagedFromMissingMarker) ctx.data.salvagedFromMissingMarker = true;
-      ctx.data.commitIdempotencyReplay = true;
-      process.stderr.write(`[kody commitAndPush] idempotency replay (sentinel ${sentinel})
+  return false;
+}
+function readJsonBody(req) {
+  return new Promise((resolve4, 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({});
+        return;
+      }
+      try {
+        resolve4(JSON.parse(raw));
+      } catch (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function writeSseHeaders(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive",
+    "x-accel-buffering": "no"
+  });
+}
+function emitSse(res, event) {
+  res.write(`data: ${JSON.stringify(event)}
+
 `);
-      return;
-    } catch {
+}
+function translateChatEvent(event, chatId) {
+  switch (event.event) {
+    case "chat.message": {
+      const content = String(event.payload.content ?? "");
+      if (content.length === 0) return null;
+      return { type: "text", text: content, chatId };
     }
+    case "chat.tool": {
+      if (event.payload.phase !== "use") return null;
+      return {
+        type: "tool_use",
+        name: typeof event.payload.name === "string" ? event.payload.name : "tool",
+        input: event.payload.input ?? {},
+        chatId
+      };
+    }
+    case "chat.done":
+      return { type: "done", chatId };
+    case "chat.error":
+      return {
+        type: "error",
+        error: typeof event.payload.error === "string" ? event.payload.error : "agent error",
+        chatId
+      };
+    default:
+      return null;
   }
-  if (ctx.data.verifyOk === false) {
-    ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "verifyFailed" };
-    ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
-    return;
-  }
-  const markerMissing = ctx.data.agentMarkerMissing === true;
-  if (ctx.data.agentDone === false && !markerMissing) {
-    ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "agentDone=false" };
-    ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
-    return;
+}
+var BrokerSink = class {
+  constructor(emitToLog, chatId) {
+    this.emitToLog = emitToLog;
+    this.chatId = chatId;
   }
-  if (ctx.data.agentDone === false && markerMissing) {
-    ctx.data.salvagedFromMissingMarker = true;
+  emitToLog;
+  chatId;
+  async emit(event) {
+    const be = translateChatEvent(event, this.chatId);
+    if (be) this.emitToLog(be);
   }
-  const message = ctx.data.commitMessage || DEFAULT_COMMIT_MESSAGE;
-  try {
-    const result2 = commitAndPush(branch, message, ctx.cwd);
-    ctx.data.commitResult = result2;
-    const postCommitFiles = result2.committed ? listFilesInCommit("HEAD", ctx.cwd) : listChangedFiles(ctx.cwd);
-    ctx.data.changedFiles = postCommitFiles.filter((f) => !isForbiddenPath(f));
-    if (result2.committed && !result2.pushed) {
-      const reason = result2.pushError ?? "push failed (no error detail)";
-      ctx.data.commitCrash = reason;
-      if (ctx.output.exitCode === void 0 || ctx.output.exitCode === 0) {
-        ctx.output.exitCode = 4;
-      }
-      if (!ctx.output.reason) ctx.output.reason = reason;
-      process.stderr.write(`[kody commitAndPush] ${reason}
+};
+var chatQueues = /* @__PURE__ */ new Map();
+function enqueue(chatId, fn) {
+  const prev = chatQueues.get(chatId) ?? Promise.resolve();
+  const next = prev.catch(() => {
+  }).then(fn);
+  chatQueues.set(
+    chatId,
+    next.finally(() => {
+      if (chatQueues.get(chatId) === next) chatQueues.delete(chatId);
+    })
+  );
+  return next;
+}
+function streamToRes(res, dir, chatId, since) {
+  writeSseHeaders(res);
+  emitSse(res, { type: "chat", chatId });
+  let maxSent = since;
+  const unsubscribe = subscribe(
+    dir,
+    chatId,
+    since,
+    (rec) => {
+      if (rec.seq <= maxSent) return;
+      maxSent = rec.seq;
+      if (res.writableEnded) return;
+      res.write(`data: ${JSON.stringify({ ...rec.event, seq: rec.seq })}
+
 `);
+    },
+    () => {
+      if (!res.writableEnded) {
+        try {
+          res.end();
+        } catch {
+        }
+      }
     }
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    ctx.data.commitCrash = reason;
-    ctx.data.commitResult = { committed: false, pushed: false };
-    process.stderr.write(`[kody commitAndPush] failed: ${reason}
-`);
+  );
+  res.on("close", unsubscribe);
+}
+async function handleChatTurn(req, res, chatId, opts) {
+  let body;
+  try {
+    body = await readJsonBody(req);
+  } catch {
+    sendJson(res, 400, { error: "invalid JSON body" });
+    return;
   }
-  ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
-  const result = ctx.data.commitResult;
-  if (sentinel && result?.committed) {
-    try {
-      fs15.mkdirSync(path13.dirname(sentinel), { recursive: true });
-      fs15.writeFileSync(
-        sentinel,
-        JSON.stringify(
-          {
-            commitResult: ctx.data.commitResult,
-            changedFiles: ctx.data.changedFiles,
-            hasCommitsAhead: ctx.data.hasCommitsAhead,
-            salvagedFromMissingMarker: ctx.data.salvagedFromMissingMarker === true,
-            writtenAt: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          null,
-          2
-        )
+  const message = typeof body === "object" && body !== null && "message" in body ? body.message : void 0;
+  if (typeof message !== "string" || !message.trim()) {
+    sendJson(res, 400, { error: "message required" });
+    return;
+  }
+  const sessionFile = sessionFilePath(opts.cwd, chatId);
+  fs14.mkdirSync(path12.dirname(sessionFile), { recursive: true });
+  appendTurn(sessionFile, {
+    role: "user",
+    content: message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  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) => {
+      const errMsg2 = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[brain-serve] chat turn failed: ${errMsg2}
+`);
+      endTurnIfUnterminated(opts.cwd, chatId, errMsg2);
+    }).finally(() => {
+      endTurnIfUnterminated(
+        opts.cwd,
+        chatId,
+        "Brain turn ended without a reply (the machine may have restarted mid-turn) \u2014 please resend your message"
       );
-    } catch {
+    })
+  );
+  streamToRes(res, opts.cwd, chatId, sinceFloor);
+}
+function buildServer(opts) {
+  const runTurn = opts.runTurn ?? runChatTurn;
+  return createServer(async (req, res) => {
+    if (!req.method || !req.url) {
+      sendJson(res, 400, { error: "bad request" });
+      return;
     }
-  }
-};
-
-// src/scripts/commitGoalState.ts
-import { execFileSync as execFileSync9 } from "child_process";
-import * as path14 from "path";
-var commitGoalState = async (ctx) => {
-  const goal = ctx.data.goal;
-  if (!goal) return;
-  const stateRel = path14.posix.join(".kody", "goals", goal.id, "state.json");
-  try {
-    execFileSync9("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
-  } catch (err) {
-    process.stderr.write(
-      `[goal-tick] commitGoalState: git add failed: ${err instanceof Error ? err.message : String(err)}
+    const url = new URL(req.url, `http://localhost`);
+    if (req.method === "GET" && url.pathname === "/healthz") {
+      sendJson(res, 200, { ok: true });
+      return;
+    }
+    if (!authOk(req, opts.apiKey)) {
+      sendJson(res, 401, { error: "unauthorized" });
+      return;
+    }
+    const m = url.pathname.match(/^\/chats\/([^/]+)\/messages\/?$/);
+    if (req.method === "POST" && m) {
+      const chatId = decodeURIComponent(m[1] ?? "");
+      if (!chatId) {
+        sendJson(res, 400, { error: "chatId required" });
+        return;
+      }
+      await handleChatTurn(req, res, chatId, {
+        cwd: opts.cwd,
+        model: opts.model,
+        litellmUrl: opts.litellmUrl,
+        runTurn
+      });
+      return;
+    }
+    const sm = url.pathname.match(/^\/chats\/([^/]+)\/stream\/?$/);
+    if (req.method === "GET" && sm) {
+      const chatId = decodeURIComponent(sm[1] ?? "");
+      if (!chatId) {
+        sendJson(res, 400, { error: "chatId required" });
+        return;
+      }
+      const sinceRaw = url.searchParams.get("since");
+      const since = Number.isFinite(Number(sinceRaw)) ? Number(sinceRaw) : 0;
+      streamToRes(res, opts.cwd, chatId, since);
+      return;
+    }
+    sendJson(res, 404, { error: "not found" });
+  });
+}
+var brainServe = async (ctx) => {
+  ctx.skipAgent = true;
+  const unpacked = unpackAllSecrets();
+  if (unpacked > 0) {
+    process.stdout.write(
+      `[brain-serve] unpacked ${unpacked} secret(s) from ALL_SECRETS
 `
     );
-    return;
-  }
-  try {
-    execFileSync9("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
-    return;
-  } catch {
   }
-  const msg = describeCommitMessage(goal);
-  try {
-    execFileSync9("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
-  } catch (err) {
-    process.stderr.write(
-      `[goal-tick] commitGoalState: git commit failed: ${err instanceof Error ? err.message : String(err)}
+  const apiKey = getApiKey();
+  const port = Number(process.env.PORT ?? DEFAULT_PORT);
+  const model = parseProviderModel(ctx.config.agent.model);
+  const usesProxy = needsLitellmProxy(model);
+  let handle = null;
+  if (usesProxy) {
+    process.stdout.write(
+      `[brain-serve] starting LiteLLM proxy for ${model.provider}/${model.model}...
+`
+    );
+    handle = await startLitellmIfNeeded(model, ctx.cwd);
+    process.stdout.write(
+      `[brain-serve] LiteLLM ready at ${handle?.url ?? LITELLM_DEFAULT_URL}
 `
     );
-    return;
-  }
-  try {
-    execFileSync9("git", ["push", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
-  } catch {
-    process.stderr.write("[goal-tick] commitGoalState: push failed (will retry next tick)\n");
   }
+  const litellmUrl = usesProxy ? handle?.url ?? LITELLM_DEFAULT_URL : null;
+  const server = buildServer({
+    apiKey,
+    cwd: ctx.cwd,
+    model,
+    litellmUrl
+  });
+  await new Promise((resolve4) => {
+    server.listen(port, "0.0.0.0", () => {
+      process.stdout.write(
+        `[brain-serve] listening on 0.0.0.0:${port} (cwd=${ctx.cwd})
+`
+      );
+      resolve4();
+    });
+  });
+  const shutdown = (signal) => {
+    process.stdout.write(`[brain-serve] ${signal} \u2014 shutting down
+`);
+    server.close(() => {
+      if (handle) {
+        try {
+          handle.kill();
+        } catch {
+        }
+      }
+      process.exit(0);
+    });
+  };
+  process.once("SIGINT", () => shutdown("SIGINT"));
+  process.once("SIGTERM", () => shutdown("SIGTERM"));
+  await new Promise(() => {
+  });
 };
-function describeCommitMessage(goal) {
-  if (goal.state === "closed") return `chore(goals): abandon ${goal.id} (cleanup complete)`;
-  if (goal.state === "done") return `chore(goals): mark ${goal.id} done`;
-  if (goal.lastDispatchedIssue !== void 0) {
-    return `chore(goals): dispatched #${goal.lastDispatchedIssue} for ${goal.id}`;
-  }
-  if (goal.phase === "in-flight") {
-    return `chore(goals): tick ${goal.id} (waiting for in-flight task)`;
-  }
-  return `chore(goals): tick ${goal.id} (idle)`;
-}
 
-// src/scripts/composePrompt.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
-var composePrompt = async (ctx, profile) => {
-  const explicit = ctx.data.promptTemplate;
-  const mode = ctx.args.mode;
+// src/scripts/buildSyntheticPlugin.ts
+import * as fs15 from "fs";
+import * as os3 from "os";
+import * as path13 from "path";
+function getPluginsCatalogRoot() {
+  const here = path13.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    explicit ? path15.join(profile.dir, explicit) : null,
-    mode ? path15.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path15.join(profile.dir, "prompt.md")
-  ].filter(Boolean);
-  let templatePath = "";
+    path13.join(here, "..", "plugins"),
+    // dev: src/scripts → src/plugins
+    path13.join(here, "..", "..", "plugins"),
+    // built: dist/scripts → dist/plugins
+    path13.join(here, "..", "..", "src", "plugins")
+    // fallback
+  ];
   for (const c of candidates) {
-    if (fs16.existsSync(c)) {
-      templatePath = c;
-      break;
+    if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+var buildSyntheticPlugin = async (ctx, profile) => {
+  const cc = profile.claudeCode;
+  const needsSynthetic = cc.skills.length > 0 || cc.commands.length > 0 || cc.hooks.length > 0 || cc.subagents.length > 0;
+  if (!needsSynthetic) return;
+  const catalog = getPluginsCatalogRoot();
+  const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const root = path13.join(os3.tmpdir(), `kody-synth-${runId}`);
+  fs15.mkdirSync(path13.join(root, ".claude-plugin"), { recursive: true });
+  const resolvePart = (bucket, entry) => {
+    const local = path13.join(profile.dir, bucket, entry);
+    if (fs15.existsSync(local)) return local;
+    const central = path13.join(catalog, bucket, entry);
+    if (fs15.existsSync(central)) return central;
+    throw new Error(
+      `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
+    );
+  };
+  if (cc.skills.length > 0) {
+    const dst = path13.join(root, "skills");
+    fs15.mkdirSync(dst, { recursive: true });
+    for (const name of cc.skills) {
+      copyDir(resolvePart("skills", name), path13.join(dst, name));
     }
   }
-  if (!templatePath) {
-    throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
+  if (cc.commands.length > 0) {
+    const dst = path13.join(root, "commands");
+    fs15.mkdirSync(dst, { recursive: true });
+    for (const name of cc.commands) {
+      fs15.copyFileSync(resolvePart("commands", `${name}.md`), path13.join(dst, `${name}.md`));
+    }
   }
-  const template = fs16.readFileSync(templatePath, "utf-8");
-  const tokens = {
-    ...stringifyAll(ctx.args, "args."),
-    ...stringifyAll(ctx.data, ""),
-    conventionsBlock: formatConventions(ctx.data.conventions),
-    coverageBlock: formatCoverageBlock(
-      ctx.data.coverageRules
-    ),
-    toolsUsage: formatToolsUsage(profile),
-    systemPromptAppend: profile.claudeCode.systemPromptAppend ?? "",
-    repoOwner: ctx.config.github.owner,
-    repoName: ctx.config.github.repo,
-    defaultBranch: ctx.config.git.defaultBranch,
-    branch: ctx.data.branch ?? ""
-  };
-  ctx.data.prompt = template.replace(MUSTACHE, (_, key) => tokens[key] ?? "");
-};
-function stringifyAll(source, prefix) {
-  const out = {};
-  for (const [k, v] of Object.entries(source)) {
-    const key = prefix + k;
-    if (v === null || v === void 0) continue;
-    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-      out[key] = String(v);
-    } else if (Array.isArray(v)) {
-      out[key] = v.map((x) => typeof x === "string" ? x : JSON.stringify(x)).join("\n");
-    } else if (typeof v === "object") {
-      for (const [k2, v2] of Object.entries(v)) {
-        if (typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean") {
-          out[`${key}.${k2}`] = String(v2);
-        }
-      }
+  if (cc.subagents.length > 0) {
+    const dst = path13.join(root, "agents");
+    fs15.mkdirSync(dst, { recursive: true });
+    for (const name of cc.subagents) {
+      fs15.copyFileSync(resolvePart("agents", `${name}.md`), path13.join(dst, `${name}.md`));
     }
   }
-  return out;
+  if (cc.hooks.length > 0) {
+    const dst = path13.join(root, "hooks");
+    fs15.mkdirSync(dst, { recursive: true });
+    const merged = { hooks: {} };
+    for (const name of cc.hooks) {
+      const src = resolvePart("hooks", `${name}.json`);
+      const parsed = JSON.parse(fs15.readFileSync(src, "utf-8"));
+      for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
+        if (!Array.isArray(entries)) continue;
+        if (!merged.hooks[event]) merged.hooks[event] = [];
+        merged.hooks[event].push(...entries);
+      }
+    }
+    fs15.writeFileSync(path13.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+`);
+  }
+  const manifest = {
+    name: `kody-synth-${profile.name}`,
+    version: "1.0.0",
+    description: `Synthetic plugin assembled by Kody for profile '${profile.name}' at runtime.`
+  };
+  if (cc.skills.length > 0) manifest.skills = ["./skills/"];
+  if (cc.commands.length > 0) manifest.commands = ["./commands/"];
+  if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
+  fs15.writeFileSync(path13.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+  ctx.data.syntheticPluginPath = root;
+};
+function copyDir(src, dst) {
+  fs15.mkdirSync(dst, { recursive: true });
+  for (const ent of fs15.readdirSync(src, { withFileTypes: true })) {
+    const s = path13.join(src, ent.name);
+    const d = path13.join(dst, ent.name);
+    if (ent.isDirectory()) copyDir(s, d);
+    else if (ent.isFile()) fs15.copyFileSync(s, d);
+  }
 }
-function formatConventions(conventions) {
-  if (!conventions || conventions.length === 0) return "";
-  const lines = ["# Project conventions (AUTHORITATIVE \u2014 follow these over patterns you infer from code)", ""];
-  for (const c of conventions) {
-    lines.push(`## ${c.path}${c.truncated ? " (truncated)" : ""}`);
-    lines.push("");
-    lines.push("```");
-    lines.push(c.content);
-    lines.push("```");
-    lines.push("");
+
+// src/coverage.ts
+import { execFileSync as execFileSync8 } from "child_process";
+function patternToRegex(pattern) {
+  let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
+  s = s.replace(/§S/g, "(?:.*/)?").replace(/§A/g, ".*");
+  return new RegExp(`^${s}$`);
+}
+function renderSiblingPath(file, requireSibling) {
+  const lastSlash = file.lastIndexOf("/");
+  const dir = lastSlash === -1 ? "" : file.slice(0, lastSlash + 1);
+  const base = lastSlash === -1 ? file : file.slice(lastSlash + 1);
+  const name = base.replace(/\.[^.]+$/, "");
+  const ext = base.match(/\.[^.]+$/)?.[0] ?? "";
+  const sibling = requireSibling.replace(/\{name\}/g, name).replace(/\{ext\}/g, ext);
+  return dir + sibling;
+}
+function safeGit(args, cwd) {
+  try {
+    return execFileSync8("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+  } catch {
+    return "";
   }
-  return lines.join("\n");
 }
-function formatCoverageBlock(reqs) {
-  if (!reqs || reqs.length === 0) return "";
-  const lines = [
-    "# Test coverage requirements (ENFORCED)",
-    "",
-    "Every newly added file matching one of these patterns MUST be accompanied by a sibling test file in the same commit. The wrapper checks this after you finish; if any sibling test is missing, the run will fail and the issue will be re-invoked with the gap as feedback.",
-    ""
-  ];
-  for (const r of reqs) lines.push(`- new \`${r.pattern}\` \u2192 must include sibling \`${r.requireSibling}\``);
-  lines.push("");
-  return lines.join("\n");
+function getAddedFiles(baseBranch, cwd) {
+  const committed = safeGit(["diff", "--name-only", "--diff-filter=A", `origin/${baseBranch}...HEAD`], cwd);
+  const untracked = safeGit(["ls-files", "--others", "--exclude-standard"], cwd);
+  const set = /* @__PURE__ */ new Set();
+  for (const f of committed.split("\n")) if (f) set.add(f);
+  for (const f of untracked.split("\n")) if (f) set.add(f);
+  return [...set];
 }
-function formatToolsUsage(profile) {
-  const entries = (profile.cliTools ?? []).filter((t) => t.usage.trim().length > 0);
-  if (entries.length === 0) return "";
-  const lines = ["# Available CLI tools", ""];
-  for (const t of entries) {
-    lines.push(`## \`${t.name}\``);
-    lines.push(t.usage);
-    if (t.allowedUses.length > 0) {
-      lines.push(`Allowed sub-commands: ${t.allowedUses.map((u) => `\`${u}\``).join(", ")}`);
+function checkCoverage(addedFiles, requirements) {
+  if (requirements.length === 0) return [];
+  const addedSet = new Set(addedFiles);
+  const misses = [];
+  for (const file of addedFiles) {
+    if (/\.(test|spec)\./.test(file)) continue;
+    for (const req of requirements) {
+      const re = patternToRegex(req.pattern);
+      if (!re.test(file)) continue;
+      const expected = renderSiblingPath(file, req.requireSibling);
+      if (!addedSet.has(expected)) {
+        misses.push({ file, expectedTest: expected });
+      }
+      break;
     }
-    lines.push("");
   }
+  return misses;
+}
+function formatMissesForFeedback(misses) {
+  if (misses.length === 0) return "";
+  const lines = ["The following files were added without a sibling test file:"];
+  for (const m of misses) lines.push(`- \`${m.file}\` \u2192 expected \`${m.expectedTest}\``);
+  lines.push("");
+  lines.push(
+    "Add the missing test files. Each should cover the new file's public API with at least a happy path and one failure path. Then re-emit DONE / COMMIT_MSG / PR_SUMMARY."
+  );
   return lines.join("\n");
 }
 
-// src/scripts/createQaGoal.ts
-init_issue();
-import { execFileSync as execFileSync10 } from "child_process";
-import * as fs17 from "fs";
-import * as path16 from "path";
+// src/scripts/checkCoverageWithRetry.ts
+init_prompt();
+var checkCoverageWithRetry = async (ctx) => {
+  const reqs = ctx.data.coverageRules ?? [];
+  if (reqs.length === 0) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  if (!ctx.data.agentDone) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  const misses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
+  if (misses.length === 0) {
+    ctx.data.coverageMisses = [];
+    return;
+  }
+  const invoker = ctx.data.__invokeAgent;
+  const basePrompt = ctx.data.prompt;
+  if (!invoker || !basePrompt) {
+    ctx.data.coverageMisses = misses;
+    return;
+  }
+  process.stderr.write(`[kody] coverage check found ${misses.length} missing test(s); retrying agent once
+`);
+  const retryPrompt = `${basePrompt}
 
-// src/scripts/postReviewResult.ts
-init_issue();
-function detectVerdict(body) {
-  const m = body.match(/##\s*Verdict\s*:\s*(PASS|CONCERNS|FAIL)\b/i);
-  if (!m) return "UNKNOWN";
-  return m[1].toUpperCase();
-}
-function reviewAction(verdict, payload) {
-  const type = verdict === "PASS" ? "REVIEW_PASS" : verdict === "CONCERNS" ? "REVIEW_CONCERNS" : verdict === "FAIL" ? "REVIEW_FAIL" : "REVIEW_COMPLETED";
-  return { type, payload: { verdict, ...payload }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+# Coverage failure (retry)
+${formatMissesForFeedback(misses)}`;
+  const retry = await invoker(retryPrompt);
+  const retryParsed = parseAgentResult(retry.finalText);
+  if (retry.outcome === "completed" && retryParsed.done) {
+    ctx.data.agentDone = true;
+    ctx.data.commitMessage = retryParsed.commitMessage || ctx.data.commitMessage;
+    ctx.data.prSummary = retryParsed.prSummary || ctx.data.prSummary;
+  }
+  const finalMisses = checkCoverage(getAddedFiles(ctx.config.git.defaultBranch, ctx.cwd), reqs);
+  ctx.data.coverageMisses = finalMisses;
+};
+
+// src/scripts/classifyByLabel.ts
+var VALID_CLASSES = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
+var classifyByLabel = async (ctx) => {
+  const issue = ctx.data.issue;
+  const labels = issue?.labels;
+  if (!labels || labels.length === 0) return;
+  const cfgMap = ctx.config.classify?.labelMap;
+  const map = cfgMap ?? defaultLabelMap();
+  for (const label of labels) {
+    const candidate = map[label.toLowerCase()];
+    if (candidate && VALID_CLASSES.has(candidate)) {
+      ctx.data.classification = candidate;
+      ctx.data.classificationSource = "label";
+      ctx.data.classificationReason = `label \`${label}\` \u2192 ${candidate}`;
+      ctx.skipAgent = true;
+      return;
+    }
+  }
+};
+function defaultLabelMap() {
+  return {
+    bug: "bug",
+    enhancement: "bug",
+    refactor: "feature",
+    feature: "feature",
+    performance: "feature",
+    rfc: "spec",
+    design: "spec",
+    spec: "spec",
+    docs: "chore",
+    chore: "chore",
+    dependencies: "chore"
+  };
 }
-function failedAction(reason) {
-  return { type: "REVIEW_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+
+// src/scripts/commitAndPush.ts
+import * as fs17 from "fs";
+import * as path15 from "path";
+init_events();
+var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
+function sentinelPathForStage(cwd, profileName) {
+  const runId = resolveRunId();
+  return path15.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
-var postReviewResult = async (ctx, _profile, agentResult) => {
-  const prNumber = ctx.data.commentTargetNumber;
-  if (!prNumber) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = "review postflight: no PR number in context";
-    ctx.data.action = failedAction(ctx.output.reason);
+var commitAndPush2 = async (ctx, profile) => {
+  const branch = ctx.data.branch;
+  if (!branch) {
+    ctx.data.commitResult = { committed: false, pushed: false };
     return;
   }
-  if (!agentResult || agentResult.outcome !== "completed") {
-    const reason = agentResult?.error ?? "agent did not complete";
+  const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
+  const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
+  if (sentinel && fs17.existsSync(sentinel)) {
     try {
-      postPrReviewComment(prNumber, `\u26A0\uFE0F kody review FAILED: ${truncate2(reason, 1e3)}`, ctx.cwd);
+      const replay = JSON.parse(fs17.readFileSync(sentinel, "utf-8"));
+      ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
+      if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
+      if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
+      if (replay.salvagedFromMissingMarker) ctx.data.salvagedFromMissingMarker = true;
+      ctx.data.commitIdempotencyReplay = true;
+      process.stderr.write(`[kody commitAndPush] idempotency replay (sentinel ${sentinel})
+`);
+      return;
     } catch {
     }
-    ctx.output.exitCode = 1;
-    ctx.output.reason = reason;
-    ctx.data.action = failedAction(reason);
+  }
+  if (ctx.data.verifyOk === false) {
+    ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "verifyFailed" };
+    ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
     return;
   }
-  const reviewBody = agentResult.finalText.trim();
-  if (!reviewBody) {
-    try {
-      postPrReviewComment(prNumber, `\u26A0\uFE0F kody review FAILED: agent produced no review body`, ctx.cwd);
-    } catch {
-    }
-    ctx.output.exitCode = 1;
-    ctx.output.reason = "empty review body";
-    ctx.data.action = failedAction("empty review body");
+  const markerMissing = ctx.data.agentMarkerMissing === true;
+  if (ctx.data.agentDone === false && !markerMissing) {
+    ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "agentDone=false" };
+    ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
     return;
   }
-  try {
-    postPrReviewComment(prNumber, reviewBody, ctx.cwd);
-  } catch (err) {
+  if (ctx.data.agentDone === false && markerMissing) {
+    ctx.data.salvagedFromMissingMarker = true;
+  }
+  const message = ctx.data.commitMessage || DEFAULT_COMMIT_MESSAGE;
+  try {
+    const result2 = commitAndPush(branch, message, ctx.cwd);
+    ctx.data.commitResult = result2;
+    const postCommitFiles = result2.committed ? listFilesInCommit("HEAD", ctx.cwd) : listChangedFiles(ctx.cwd);
+    ctx.data.changedFiles = postCommitFiles.filter((f) => !isForbiddenPath(f));
+    if (result2.committed && !result2.pushed) {
+      const reason = result2.pushError ?? "push failed (no error detail)";
+      ctx.data.commitCrash = reason;
+      if (ctx.output.exitCode === void 0 || ctx.output.exitCode === 0) {
+        ctx.output.exitCode = 4;
+      }
+      if (!ctx.output.reason) ctx.output.reason = reason;
+      process.stderr.write(`[kody commitAndPush] ${reason}
+`);
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    ctx.data.commitCrash = reason;
+    ctx.data.commitResult = { committed: false, pushed: false };
+    process.stderr.write(`[kody commitAndPush] failed: ${reason}
+`);
+  }
+  ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
+  const result = ctx.data.commitResult;
+  if (sentinel && result?.committed) {
+    try {
+      fs17.mkdirSync(path15.dirname(sentinel), { recursive: true });
+      fs17.writeFileSync(
+        sentinel,
+        JSON.stringify(
+          {
+            commitResult: ctx.data.commitResult,
+            changedFiles: ctx.data.changedFiles,
+            hasCommitsAhead: ctx.data.hasCommitsAhead,
+            salvagedFromMissingMarker: ctx.data.salvagedFromMissingMarker === true,
+            writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          null,
+          2
+        )
+      );
+    } catch {
+    }
+  }
+};
+
+// src/scripts/commitGoalState.ts
+import { execFileSync as execFileSync9 } from "child_process";
+import * as path16 from "path";
+var commitGoalState = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const stateRel = path16.posix.join(".kody", "goals", goal.id, "state.json");
+  try {
+    execFileSync9("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch (err) {
+    process.stderr.write(
+      `[goal-tick] commitGoalState: git add failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return;
+  }
+  try {
+    execFileSync9("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    return;
+  } catch {
+  }
+  const msg = describeCommitMessage(goal);
+  try {
+    execFileSync9("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch (err) {
+    process.stderr.write(
+      `[goal-tick] commitGoalState: git commit failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return;
+  }
+  try {
+    execFileSync9("git", ["push", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch {
+    process.stderr.write("[goal-tick] commitGoalState: push failed (will retry next tick)\n");
+  }
+};
+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`;
+  if (goal.state === "done") return `chore(goals): mark ${goal.id} done`;
+  if (goal.lastDispatchedIssue !== void 0) {
+    return `chore(goals): dispatched #${goal.lastDispatchedIssue} for ${goal.id}`;
+  }
+  if (goal.phase === "in-flight") {
+    return `chore(goals): tick ${goal.id} (waiting for in-flight task)`;
+  }
+  return `chore(goals): tick ${goal.id} (idle)`;
+}
+
+// src/scripts/composePrompt.ts
+import * as fs18 from "fs";
+import * as path17 from "path";
+var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+var composePrompt = async (ctx, profile) => {
+  const explicit = ctx.data.promptTemplate;
+  const mode = ctx.args.mode;
+  const candidates = [
+    explicit ? path17.join(profile.dir, explicit) : null,
+    mode ? path17.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path17.join(profile.dir, "prompt.md")
+  ].filter(Boolean);
+  let templatePath = "";
+  for (const c of candidates) {
+    if (fs18.existsSync(c)) {
+      templatePath = c;
+      break;
+    }
+  }
+  if (!templatePath) {
+    throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
+  }
+  const template = fs18.readFileSync(templatePath, "utf-8");
+  const tokens = {
+    ...stringifyAll(ctx.args, "args."),
+    ...stringifyAll(ctx.data, ""),
+    conventionsBlock: formatConventions(ctx.data.conventions),
+    coverageBlock: formatCoverageBlock(
+      ctx.data.coverageRules
+    ),
+    toolsUsage: formatToolsUsage(profile),
+    systemPromptAppend: profile.claudeCode.systemPromptAppend ?? "",
+    repoOwner: ctx.config.github.owner,
+    repoName: ctx.config.github.repo,
+    defaultBranch: ctx.config.git.defaultBranch,
+    branch: ctx.data.branch ?? ""
+  };
+  ctx.data.prompt = template.replace(MUSTACHE, (_, key) => tokens[key] ?? "");
+};
+function stringifyAll(source, prefix) {
+  const out = {};
+  for (const [k, v] of Object.entries(source)) {
+    const key = prefix + k;
+    if (v === null || v === void 0) continue;
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      out[key] = String(v);
+    } else if (Array.isArray(v)) {
+      out[key] = v.map((x) => typeof x === "string" ? x : JSON.stringify(x)).join("\n");
+    } else if (typeof v === "object") {
+      for (const [k2, v2] of Object.entries(v)) {
+        if (typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean") {
+          out[`${key}.${k2}`] = String(v2);
+        }
+      }
+    }
+  }
+  return out;
+}
+function formatConventions(conventions) {
+  if (!conventions || conventions.length === 0) return "";
+  const lines = ["# Project conventions (AUTHORITATIVE \u2014 follow these over patterns you infer from code)", ""];
+  for (const c of conventions) {
+    lines.push(`## ${c.path}${c.truncated ? " (truncated)" : ""}`);
+    lines.push("");
+    lines.push("```");
+    lines.push(c.content);
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatCoverageBlock(reqs) {
+  if (!reqs || reqs.length === 0) return "";
+  const lines = [
+    "# Test coverage requirements (ENFORCED)",
+    "",
+    "Every newly added file matching one of these patterns MUST be accompanied by a sibling test file in the same commit. The wrapper checks this after you finish; if any sibling test is missing, the run will fail and the issue will be re-invoked with the gap as feedback.",
+    ""
+  ];
+  for (const r of reqs) lines.push(`- new \`${r.pattern}\` \u2192 must include sibling \`${r.requireSibling}\``);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatToolsUsage(profile) {
+  const entries = (profile.cliTools ?? []).filter((t) => t.usage.trim().length > 0);
+  if (entries.length === 0) return "";
+  const lines = ["# Available CLI tools", ""];
+  for (const t of entries) {
+    lines.push(`## \`${t.name}\``);
+    lines.push(t.usage);
+    if (t.allowedUses.length > 0) {
+      lines.push(`Allowed sub-commands: ${t.allowedUses.map((u) => `\`${u}\``).join(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/scripts/createQaGoal.ts
+init_issue();
+import { execFileSync as execFileSync10 } from "child_process";
+import * as fs19 from "fs";
+import * as path18 from "path";
+
+// src/scripts/postReviewResult.ts
+init_issue();
+function detectVerdict(body) {
+  const m = body.match(/##\s*Verdict\s*:\s*(PASS|CONCERNS|FAIL)\b/i);
+  if (!m) return "UNKNOWN";
+  return m[1].toUpperCase();
+}
+function reviewAction(verdict, payload) {
+  const type = verdict === "PASS" ? "REVIEW_PASS" : verdict === "CONCERNS" ? "REVIEW_CONCERNS" : verdict === "FAIL" ? "REVIEW_FAIL" : "REVIEW_COMPLETED";
+  return { type, payload: { verdict, ...payload }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function failedAction(reason) {
+  return { type: "REVIEW_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
+var postReviewResult = async (ctx, _profile, agentResult) => {
+  const prNumber = ctx.data.commentTargetNumber;
+  if (!prNumber) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = "review postflight: no PR number in context";
+    ctx.data.action = failedAction(ctx.output.reason);
+    return;
+  }
+  if (!agentResult || agentResult.outcome !== "completed") {
+    const reason = agentResult?.error ?? "agent did not complete";
+    try {
+      postPrReviewComment(prNumber, `\u26A0\uFE0F kody review FAILED: ${truncate2(reason, 1e3)}`, ctx.cwd);
+    } catch {
+    }
+    ctx.output.exitCode = 1;
+    ctx.output.reason = reason;
+    ctx.data.action = failedAction(reason);
+    return;
+  }
+  const reviewBody = agentResult.finalText.trim();
+  if (!reviewBody) {
+    try {
+      postPrReviewComment(prNumber, `\u26A0\uFE0F kody review FAILED: agent produced no review body`, ctx.cwd);
+    } catch {
+    }
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "empty review body";
+    ctx.data.action = failedAction("empty review body");
+    return;
+  }
+  try {
+    postPrReviewComment(prNumber, reviewBody, ctx.cwd);
+  } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     ctx.output.exitCode = 4;
     ctx.output.reason = `failed to post review comment: ${msg}`;
@@ -4429,8 +4882,8 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path16.join(cwd, ".kody", "goals", goalId);
-  fs17.mkdirSync(dir, { recursive: true });
+  const dir = path18.join(cwd, ".kody", "goals", goalId);
+  fs19.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -4438,8 +4891,8 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path16.join(dir, "state.json");
-  fs17.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  const filePath = path18.join(dir, "state.json");
+  fs19.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
@@ -4870,6 +5323,7 @@ function derivePhase(snap) {
   if (!snap.lifecycleState) return "missing";
   if (snap.lifecycleState === "abandoned") return "abandoned";
   if (snap.lifecycleState === "closed" || snap.lifecycleState === "done") return "terminal";
+  if (snap.lifecycleState === "awaiting-merge") return "awaiting-merge";
   const hasInFlight = snap.childTasks.some((t) => t.state === "OPEN" && t.prState === "draft");
   if (hasInFlight) return "in-flight";
   if (snap.childTasks.length === 0) return "idle";
@@ -4935,15 +5389,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs18 from "fs";
+import * as fs20 from "fs";
 import * as os4 from "os";
-import * as path17 from "path";
+import * as path19 from "path";
 var diagMcp = async (_ctx) => {
   const home = os4.homedir();
-  const cacheDir = path17.join(home, ".cache", "ms-playwright");
+  const cacheDir = path19.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs18.readdirSync(cacheDir);
+    entries = fs20.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -4969,17 +5423,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs19.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs21.readFileSync(path20.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -5016,7 +5470,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs19.existsSync(path18.join(cwd, c))) return c;
+    if (fs21.existsSync(path20.join(cwd, c))) return c;
   }
   return null;
 }
@@ -5029,18 +5483,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path18.join(cwd, dir);
-    if (!fs19.existsSync(full)) continue;
+    const full = path20.join(cwd, dir);
+    if (!fs21.existsSync(full)) continue;
     let files;
     try {
-      files = fs19.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs21.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path18.join(full, file);
-        const content = fs19.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path20.join(full, file);
+        const content = fs21.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -5054,7 +5508,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path18.relative(cwd, filePath),
+          filePath: path20.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -5068,28 +5522,28 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path18.join(cwd, dir);
-    if (!fs19.existsSync(full)) continue;
+    const full = path20.join(cwd, dir);
+    if (!fs21.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs19.readdirSync(full, { withFileTypes: true });
+      entries = fs21.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path18.join(full, entry.name);
+      const entryPath = path20.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs19.existsSync(path18.join(entryPath, f))
+          (f) => fs21.existsSync(path20.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path18.relative(cwd, path18.join(entryPath, indexFile));
+        filePath = path20.relative(cwd, path20.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path18.relative(cwd, entryPath);
+        filePath = path20.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -5097,7 +5551,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs19.readFileSync(path18.join(cwd, col.filePath), "utf-8");
+            const colContent = fs21.readFileSync(path20.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -5116,8 +5570,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path18.join(cwd, appDir, "api");
-    if (!fs19.existsSync(apiDir)) continue;
+    const apiDir = path20.join(cwd, appDir, "api");
+    if (!fs21.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -5126,14 +5580,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs19.readdirSync(dir, { withFileTypes: true });
+    entries = fs21.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs19.readFileSync(path18.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs21.readFileSync(path20.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)
       );
@@ -5141,7 +5595,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path18.relative(cwd, path18.join(dir, routeFile.name))
+          filePath: path20.relative(cwd, path20.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -5152,7 +5606,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(path18.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path20.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -5160,7 +5614,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path18.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path20.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -5180,10 +5634,10 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path18.join(cwd, envFile);
-    if (!fs19.existsSync(envPath)) continue;
+    const envPath = path20.join(cwd, envFile);
+    if (!fs21.existsSync(envPath)) continue;
     try {
-      const content = fs19.readFileSync(envPath, "utf-8");
+      const content = fs21.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -5231,9 +5685,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs22.readFileSync(path21.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs20.existsSync(path19.join(cwd, "yarn.lock")) ? "yarn" : fs20.existsSync(path19.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs22.existsSync(path21.join(cwd, "yarn.lock")) ? "yarn" : fs22.existsSync(path21.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;
@@ -5243,8 +5697,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path19.join(cwd, appDir);
-    if (!fs20.existsSync(full)) continue;
+    const full = path21.join(cwd, appDir);
+    if (!fs22.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -5252,7 +5706,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs20.readdirSync(dir, { withFileTypes: true });
+    entries = fs22.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -5269,7 +5723,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(path19.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path21.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -5277,7 +5731,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path19.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path21.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -5294,23 +5748,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs20.existsSync(path19.join(cwd, c))) out.authFiles.push(c);
+    if (fs22.existsSync(path21.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 = path19.join(cwd, rp);
-    if (!fs20.existsSync(dir)) continue;
+    const dir = path21.join(cwd, rp);
+    if (!fs22.existsSync(dir)) continue;
     let files;
     try {
-      files = fs20.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs22.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs20.readFileSync(path19.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs22.readFileSync(path21.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) {
@@ -5543,8 +5997,8 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -5803,8 +6257,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -5819,7 +6273,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 = path20.join(opts.cwd, opts.jobsDir);
+    this.absDir = path22.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -5834,7 +6288,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs21.mkdirSync(this.absDir, { recursive: true });
+    fs23.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -5863,7 +6317,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs21.existsSync(this.absDir)) {
+    if (!fs23.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -5879,11 +6333,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path20.join(this.cwd, relPath);
-    if (!fs21.existsSync(absPath)) {
+    const absPath = path22.join(this.cwd, relPath);
+    if (!fs23.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs21.readFileSync(absPath, "utf-8");
+    const raw = fs23.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -5900,10 +6354,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path20.join(this.cwd, loaded.path);
-    fs21.mkdirSync(path20.dirname(absPath), { recursive: true });
+    const absPath = path22.join(this.cwd, loaded.path);
+    fs23.mkdirSync(path22.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs21.writeFileSync(absPath, body, "utf-8");
+    fs23.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -5981,7 +6435,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path21.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path23.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -6086,17 +6540,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs22.readFileSync(path21.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs24.readFileSync(path23.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs22.existsSync(absDir)) return [];
+  if (!fs24.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs22.readdirSync(absDir, { withFileTypes: true });
+    entries = fs24.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6779,7 +7233,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch2, cwd, baseBranch
 
 // src/gha.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import * as fs23 from "fs";
+import * as fs25 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -6790,10 +7244,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs23.existsSync(eventPath)) return;
+  if (!eventPath || !fs25.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs23.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs25.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -7082,22 +7536,22 @@ var handleAbandonedGoal = async (ctx) => {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path22.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs24.existsSync(full)) {
+  const full = path24.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs26.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs24.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs26.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -7107,9 +7561,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs25.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs25.existsSync(path23.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs25.existsSync(path23.join(cwd, "bun.lockb"))) return "bun";
+  if (fs27.existsSync(path25.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs27.existsSync(path25.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs27.existsSync(path25.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -7231,48 +7685,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path23.join(cwd, "kody.config.json");
-  if (fs25.existsSync(configPath) && !force) {
+  const configPath = path25.join(cwd, "kody.config.json");
+  if (fs27.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
-    fs25.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs27.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path23.join(cwd, ".github", "workflows");
-  const workflowPath = path23.join(workflowDir, "kody.yml");
-  if (fs25.existsSync(workflowPath) && !force) {
+  const workflowDir = path25.join(cwd, ".github", "workflows");
+  const workflowPath = path25.join(workflowDir, "kody.yml");
+  if (fs27.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs25.mkdirSync(workflowDir, { recursive: true });
-    fs25.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs27.mkdirSync(workflowDir, { recursive: true });
+    fs27.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs25.existsSync(path23.join(cwd, "src/app")) || fs25.existsSync(path23.join(cwd, "app")) || fs25.existsSync(path23.join(cwd, "pages"));
+  const hasUi = fs27.existsSync(path25.join(cwd, "src/app")) || fs27.existsSync(path25.join(cwd, "app")) || fs27.existsSync(path25.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path23.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs25.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path25.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs27.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs25.mkdirSync(path23.dirname(qaGuidePath), { recursive: true });
+      fs27.mkdirSync(path25.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs25.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs27.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path23.join(cwd, ".kody", "jobs");
-    fs25.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path25.join(cwd, ".kody", "jobs");
+    fs27.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path23.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path23.join(cwd, rel);
-      if (fs25.existsSync(target) && !force) {
+      const rel = path25.join(".kody", "jobs", `${job.slug}.md`);
+      const target = path25.join(cwd, rel);
+      if (fs27.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs25.writeFileSync(target, fs25.readFileSync(job.filePath, "utf-8"));
+      fs27.writeFileSync(target, fs27.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -7284,12 +7738,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path23.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs25.existsSync(target) && !force) {
+    const target = path25.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs27.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs25.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs27.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -7367,9 +7821,9 @@ init_loadConventions();
 init_loadCoverageRules();
 
 // src/goal/state.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
-var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
+import * as fs28 from "fs";
+import * as path26 from "path";
+var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
 var GoalStateError = class extends Error {
   constructor(path34, message) {
     super(`Invalid goal state at ${path34}:
@@ -7395,6 +7849,9 @@ function parseGoalState(filePath, raw) {
     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;
   }
@@ -7402,7 +7859,7 @@ function parseGoalState(filePath, raw) {
     const v = r[ts];
     if (typeof v === "string" && v.length > 0) parsed[ts] = v;
   }
-  const known = /* @__PURE__ */ new Set(["state", "lastDispatchedIssue", "updatedAt", "createdAt", "startedAt"]);
+  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;
   }
@@ -7410,6 +7867,7 @@ function parseGoalState(filePath, raw) {
 }
 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;
@@ -7418,16 +7876,16 @@ function serializeGoalState(s) {
 `;
 }
 function goalStatePath(cwd, goalId) {
-  return path24.join(cwd, ".kody", "goals", goalId, "state.json");
+  return path26.join(cwd, ".kody", "goals", goalId, "state.json");
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs26.existsSync(file)) {
+  if (!fs28.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs26.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs28.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -7435,8 +7893,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs26.mkdirSync(path24.dirname(file), { recursive: true });
-  fs26.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs28.mkdirSync(path26.dirname(file), { recursive: true });
+  fs28.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -7538,8 +7996,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const slugArg = String(args?.slugArg ?? "job");
@@ -7547,11 +8005,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path25.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs27.existsSync(absPath)) {
+  const absPath = path27.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs29.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs27.readFileSync(absPath, "utf-8");
+  const raw = fs29.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
   const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   const loaded = await backend.load(slug);
@@ -7590,8 +8048,8 @@ init_loadPriorArt();
 init_events();
 
 // src/taskContext.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -7607,10 +8065,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path27.join(cwd, ".kody", "runs", ctx.runId);
-    fs29.mkdirSync(dir, { recursive: true });
-    const file = path27.join(dir, "task-context.json");
-    fs29.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path29.join(cwd, ".kody", "runs", ctx.runId);
+    fs31.mkdirSync(dir, { recursive: true });
+    const file = path29.join(dir, "task-context.json");
+    fs31.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -7888,6 +8346,23 @@ QA_REPORT_POSTED=${created.url} (verdict: ${verdict})
   ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
 };
 
+// src/scripts/parkGoalForMerge.ts
+var parkGoalForMerge = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const approved = goal.raw?.mergeApproved === true;
+  if (approved) {
+    process.stdout.write(`[goal-tick] goal ${goal.id}: merge approved \u2014 running finalize (one-shot)
+`);
+    if (goal.raw) goal.raw.mergeApproved = false;
+    return;
+  }
+  process.stdout.write(`[goal-tick] all task(s) done \u2014 parking goal ${goal.id} for manual merge (no auto-merge)
+`);
+  goal.state = "awaiting-merge";
+  goal.phase = "awaiting-merge";
+};
+
 // src/scripts/parseAgentResult.ts
 init_prompt();
 var parseAgentResult2 = async (ctx, profile, agentResult) => {
@@ -8858,688 +9333,289 @@ var revertFlow = async (ctx) => {
 function buildCommitMessage(resolved) {
   if (resolved.length === 1) {
     const { full, subject } = resolved[0];
-    return subject ? `revert: "${subject}" (${full.slice(0, 7)})` : `revert: ${full.slice(0, 7)}`;
-  }
-  const shas = resolved.map((r) => r.full.slice(0, 7)).join(", ");
-  return `revert: ${resolved.length} commit(s) (${shas})`;
-}
-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 execFileSync23("git", args, {
-    encoding: "utf-8",
-    timeout: 3e4,
-    cwd,
-    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
-}
-function isAncestorOfHead(sha, cwd) {
-  try {
-    execFileSync23("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
-      cwd,
-      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
-      stdio: ["ignore", "ignore", "ignore"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function tryPostPr4(prNumber, body, cwd) {
-  try {
-    postPrReviewComment(prNumber, body, cwd);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody revertFlow] PR comment on #${prNumber} failed: ${msg}
-`);
-  }
-}
-
-// src/scripts/reviewFlow.ts
-init_issue();
-var reviewFlow = async (ctx) => {
-  const prNumber = ctx.args.pr;
-  const pr = getPr(prNumber, ctx.cwd);
-  if (pr.state !== "OPEN") {
-    ctx.output.exitCode = 1;
-    ctx.output.reason = `PR #${prNumber} is not OPEN (state: ${pr.state})`;
-    ctx.skipAgent = true;
-    return;
-  }
-  ctx.data.pr = pr;
-  ctx.data.commentTargetType = "pr";
-  ctx.data.commentTargetNumber = prNumber;
-  checkoutPrBranch(prNumber, ctx.cwd);
-  ctx.data.branch = getCurrentBranch(ctx.cwd);
-  ctx.data.prDiff = getPrDiff(prNumber, ctx.cwd);
-  const runUrl = getRunUrl();
-  const runSuffix = runUrl ? `, run ${runUrl}` : "";
-  tryPostPr5(prNumber, `\u{1F440} kody review started on PR #${prNumber}${runSuffix}`, ctx.cwd);
-};
-function tryPostPr5(prNumber, body, cwd) {
-  try {
-    postPrReviewComment(prNumber, body, cwd);
-  } catch {
-  }
-}
-
-// src/scripts/runFlow.ts
-init_issue();
-var runFlow = async (ctx) => {
-  const issueNumber = ctx.args.issue;
-  const issue = getIssue(issueNumber, ctx.cwd);
-  ctx.data.issue = issue;
-  ctx.data.commentTargetType = "issue";
-  ctx.data.commentTargetNumber = issueNumber;
-  const argBase = resolveBaseOverride(ctx.args.base);
-  const baseRaw = ctx.args.base;
-  if (baseRaw && !argBase) {
-    process.stderr.write(`[kody runFlow] ignoring --base "${baseRaw}" (must match kody-task or goal-branch pattern)
-`);
-  }
-  const base = argBase;
-  if (base) {
-    ctx.data.baseBranch = base;
-    process.stderr.write(`[kody runFlow] resolved base branch: ${base} (from --base)
-`);
-  }
-  const branchInfo = ensureFeatureBranch(issueNumber, issue.title, ctx.config.git.defaultBranch, ctx.cwd, base ?? void 0);
-  ctx.data.branch = branchInfo.branch;
-  const runUrl = getRunUrl();
-  const startMsg = runUrl ? `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\`, run ${runUrl}` : `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\``;
-  tryPost(issueNumber, startMsg, ctx.cwd);
-};
-function tryPost(issueNumber, body, cwd) {
-  try {
-    postIssueComment(issueNumber, body, cwd);
-  } catch {
-  }
-}
-function resolveBaseOverride(value) {
-  if (!value) return null;
-  if (value.length > 200) return null;
-  if (value.includes("..")) return null;
-  if (!/^[a-z0-9][a-z0-9/._-]*$/.test(value)) return null;
-  return value;
-}
-
-// src/scripts/runTickScript.ts
-import { spawnSync } from "child_process";
-import * as fs30 from "fs";
-import * as path28 from "path";
-var runTickScript = async (ctx, _profile, args) => {
-  ctx.skipAgent = true;
-  const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
-  const slugArg = String(args?.slugArg ?? "job");
-  const fenceLabel = String(args?.fenceLabel ?? "kody-job-next-state");
-  const slug = String(ctx.args[slugArg] ?? "").trim();
-  if (!slug) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
-    return;
-  }
-  const jobPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs30.existsSync(jobPath)) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
-    return;
-  }
-  const raw = fs30.readFileSync(jobPath, "utf-8");
-  const { frontmatter } = splitFrontmatter(raw);
-  const tickScript = frontmatter.tickScript;
-  if (!tickScript) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
-    return;
-  }
-  const scriptPath = path28.isAbsolute(tickScript) ? tickScript : path28.join(ctx.cwd, tickScript);
-  if (!fs30.existsSync(scriptPath)) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
-    return;
-  }
-  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
-  let loaded;
-  try {
-    loaded = await backend.load(slug);
-  } catch (err) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: state load failed: ${err instanceof Error ? err.message : String(err)}`;
-    return;
-  }
-  ctx.data.jobSlug = slug;
-  ctx.data.jobState = loaded;
-  const childEnv = buildChildEnv(process.env, Boolean(ctx.args.force));
-  const result = spawnSync("bash", [scriptPath], {
-    cwd: ctx.cwd,
-    env: childEnv,
-    stdio: ["ignore", "pipe", "pipe"],
-    encoding: "utf-8",
-    timeout: 5 * 60 * 1e3,
-    // Default maxBuffer is 1MB — a chatty `gh pr list --json …` over a
-    // busy repo (or an accidental `set -x`) can blow that and silently
-    // truncate stdout, which is the exact "silent state drop" failure
-    // mode this whole executable was written to prevent. 16MB is well
-    // above any realistic tick output.
-    maxBuffer: 16 * 1024 * 1024
-  });
-  if (result.stdout) process.stdout.write(result.stdout);
-  if (result.stderr) process.stderr.write(result.stderr);
-  if (result.error) {
-    ctx.output.exitCode = 99;
-    ctx.output.reason = `runTickScript: spawn error: ${result.error.message}`;
-    return;
-  }
-  if (result.signal) {
-    ctx.output.exitCode = 124;
-    ctx.output.reason = `runTickScript: ${tickScript} killed by ${result.signal} (likely 5min timeout)`;
-    return;
-  }
-  if (result.status !== 0) {
-    ctx.output.exitCode = result.status ?? 99;
-    ctx.output.reason = `runTickScript: ${tickScript} exited ${result.status}`;
-    return;
-  }
-  const prevRev = loaded.state.rev ?? 0;
-  const parsed = extractNextStateFromText(result.stdout ?? "", fenceLabel, prevRev);
-  if (parsed.error) {
-    ctx.data.nextStateParseError = parsed.error;
-    ctx.output.exitCode = 1;
-    ctx.output.reason = `runTickScript: ${parsed.error}`;
-    return;
-  }
-  ctx.data.nextJobState = parsed.envelope;
-};
-function buildChildEnv(parent, force) {
-  const allow = /* @__PURE__ */ new Set([
-    "PATH",
-    "HOME",
-    "USER",
-    "LOGNAME",
-    "SHELL",
-    "TMPDIR",
-    "LANG",
-    "LC_ALL",
-    "TERM",
-    // GitHub auth — `gh` reads these.
-    "GH_TOKEN",
-    "GH_PAT",
-    "GITHUB_TOKEN",
-    // CI metadata commonly read by tick scripts (`gh repo view`,
-    // workflow run links, etc.). All public values from GitHub Actions.
-    "GITHUB_ACTIONS",
-    "GITHUB_ACTOR",
-    "GITHUB_REPOSITORY",
-    "GITHUB_REPOSITORY_OWNER",
-    "GITHUB_REF",
-    "GITHUB_SHA",
-    "GITHUB_RUN_ID",
-    "GITHUB_RUN_NUMBER",
-    "GITHUB_WORKFLOW",
-    "GITHUB_JOB",
-    "GITHUB_SERVER_URL",
-    "GITHUB_API_URL",
-    "GITHUB_EVENT_NAME",
-    "RUNNER_OS",
-    "RUNNER_ARCH"
-  ]);
-  const out = {};
-  for (const [key, value] of Object.entries(parent)) {
-    if (value === void 0) continue;
-    if (allow.has(key) || key.startsWith("KODY_PUBLIC_")) {
-      out[key] = value;
-    }
-  }
-  if (force) out.KODY_FORCE = "1";
-  return out;
-}
-
-// src/scripts/brainServe.ts
-import { createServer } from "http";
-import * as fs32 from "fs";
-import * as path30 from "path";
-
-// src/scripts/brainTurnLog.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
-var live = /* @__PURE__ */ new Map();
-function eventsPath(dir, chatId) {
-  return path29.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
-}
-function lastPersistedSeq(dir, chatId) {
-  const p = eventsPath(dir, chatId);
-  if (!fs31.existsSync(p)) return 0;
-  const lines = fs31.readFileSync(p, "utf-8").split("\n").filter(Boolean);
-  if (lines.length === 0) return 0;
-  try {
-    return JSON.parse(lines[lines.length - 1]).seq || 0;
-  } catch {
-    return 0;
-  }
-}
-function readSince(dir, chatId, since) {
-  const p = eventsPath(dir, chatId);
-  if (!fs31.existsSync(p)) return [];
-  const out = [];
-  for (const line of fs31.readFileSync(p, "utf-8").split("\n")) {
-    if (!line) continue;
-    try {
-      const rec = JSON.parse(line);
-      if (rec.seq > since) out.push(rec);
-    } catch {
-    }
-  }
-  return out;
-}
-function isTerminal(event) {
-  return event.type === "done" || event.type === "error";
-}
-function beginTurn(dir, chatId) {
-  const existing = live.get(chatId);
-  const seqFloor = existing ? existing.seq : lastPersistedSeq(dir, chatId);
-  const turn = (existing?.turn ?? 0) + 1;
-  const state = {
-    seq: seqFloor,
-    turn,
-    status: "running",
-    terminal: null,
-    subscribers: /* @__PURE__ */ new Set()
-  };
-  live.set(chatId, state);
-  const p = eventsPath(dir, chatId);
-  fs31.mkdirSync(path29.dirname(p), { recursive: true });
-  return (event) => {
-    state.seq += 1;
-    const rec = { seq: state.seq, turn, ts: Date.now(), event };
-    try {
-      fs31.appendFileSync(p, JSON.stringify(rec) + "\n");
-    } catch (err) {
-      process.stderr.write(
-        `[brain-turn-log] append failed for ${chatId}: ${err instanceof Error ? err.message : String(err)}
-`
-      );
-    }
-    for (const fn of state.subscribers) {
-      try {
-        fn(rec);
-      } catch {
-      }
-    }
-    if (isTerminal(event)) {
-      state.status = "ended";
-      state.terminal = rec;
-      const subs = [...state.subscribers];
-      state.subscribers.clear();
-      for (const fn of subs) {
-        try {
-          fn(null);
-        } catch {
-        }
-      }
-    }
-  };
-}
-function endTurnIfUnterminated(dir, chatId, errMessage) {
-  const state = live.get(chatId);
-  if (!state || state.status === "ended") return;
-  state.seq += 1;
-  const rec = {
-    seq: state.seq,
-    turn: state.turn,
-    ts: Date.now(),
-    event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
-  };
-  try {
-    fs31.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
-  } catch {
-  }
-  state.status = "ended";
-  state.terminal = rec;
-  const subs = [...state.subscribers];
-  state.subscribers.clear();
-  for (const fn of subs) {
-    try {
-      fn(rec);
-      fn(null);
-    } catch {
-    }
-  }
-}
-function subscribe(dir, chatId, since, onRecord, onClose) {
-  const backlog = readSince(dir, chatId, since);
-  for (const rec of backlog) onRecord(rec);
-  const lastReplayed = backlog.length ? backlog[backlog.length - 1] : null;
-  if (lastReplayed && isTerminal(lastReplayed.event)) {
-    onClose();
-    return () => {
-    };
-  }
-  const state = live.get(chatId);
-  if (state && state.status === "running") {
-    const fn = (rec) => {
-      if (rec === null) {
-        state.subscribers.delete(fn);
-        onClose();
-        return;
-      }
-      if (rec.seq > since) onRecord(rec);
-    };
-    state.subscribers.add(fn);
-    return () => {
-      state.subscribers.delete(fn);
-    };
-  }
-  if (state && state.status === "ended" && state.terminal) {
-    if (state.terminal.seq > since && !lastReplayed) onRecord(state.terminal);
-    onClose();
-    return () => {
-    };
-  }
-  if (lastReplayed) {
-    onRecord({
-      seq: lastReplayed.seq + 1,
-      turn: lastReplayed.turn,
-      ts: Date.now(),
-      event: {
-        type: "error",
-        error: "stream interrupted (server restarted mid-reply) \u2014 resend your message",
-        chatId
-      }
-    });
-  }
-  onClose();
-  return () => {
-  };
-}
-function getLastSeq(dir, chatId) {
-  const state = live.get(chatId);
-  if (state) return state.seq;
-  return lastPersistedSeq(dir, chatId);
-}
-
-// src/scripts/brainServe.ts
-var DEFAULT_PORT = 8080;
-function getApiKey() {
-  const key = (process.env.BRAIN_API_KEY ?? "").trim();
-  if (!key) {
-    throw new Error(
-      "BRAIN_API_KEY env var is required \u2014 set it on the Fly machine before boot."
-    );
-  }
-  return key;
-}
-function authOk(req, expected) {
-  const xApiKey = req.headers["x-api-key"]?.trim();
-  if (xApiKey && xApiKey === expected) return true;
-  const auth = req.headers["authorization"]?.trim();
-  if (auth && auth.toLowerCase().startsWith("bearer ")) {
-    return auth.slice(7).trim() === expected;
-  }
-  return false;
-}
-function readJsonBody(req) {
-  return new Promise((resolve4, 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({});
-        return;
-      }
-      try {
-        resolve4(JSON.parse(raw));
-      } catch (err) {
-        reject(err instanceof Error ? err : new Error(String(err)));
-      }
-    });
-    req.on("error", reject);
-  });
-}
-function sendJson(res, status, body) {
-  res.writeHead(status, { "content-type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-function writeSseHeaders(res) {
-  res.writeHead(200, {
-    "content-type": "text/event-stream; charset=utf-8",
-    "cache-control": "no-cache, no-transform",
-    connection: "keep-alive",
-    "x-accel-buffering": "no"
-  });
+    return subject ? `revert: "${subject}" (${full.slice(0, 7)})` : `revert: ${full.slice(0, 7)}`;
+  }
+  const shas = resolved.map((r) => r.full.slice(0, 7)).join(", ");
+  return `revert: ${resolved.length} commit(s) (${shas})`;
 }
-function emitSse(res, event) {
-  res.write(`data: ${JSON.stringify(event)}
-
-`);
+function buildPrSummary(resolved) {
+  return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
-function translateChatEvent(event, chatId) {
-  switch (event.event) {
-    case "chat.message": {
-      const content = String(event.payload.content ?? "");
-      if (content.length === 0) return null;
-      return { type: "text", text: content, chatId };
-    }
-    case "chat.tool": {
-      if (event.payload.phase !== "use") return null;
-      return {
-        type: "tool_use",
-        name: typeof event.payload.name === "string" ? event.payload.name : "tool",
-        input: event.payload.input ?? {},
-        chatId
-      };
-    }
-    case "chat.done":
-      return { type: "done", chatId };
-    case "chat.error":
-      return {
-        type: "error",
-        error: typeof event.payload.error === "string" ? event.payload.error : "agent error",
-        chatId
-      };
-    default:
-      return null;
+function git3(args, cwd) {
+  return execFileSync23("git", args, {
+    encoding: "utf-8",
+    timeout: 3e4,
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function isAncestorOfHead(sha, cwd) {
+  try {
+    execFileSync23("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+      cwd,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
   }
 }
-var BrokerSink = class {
-  constructor(emitToLog, chatId) {
-    this.emitToLog = emitToLog;
-    this.chatId = chatId;
+function tryPostPr4(prNumber, body, cwd) {
+  try {
+    postPrReviewComment(prNumber, body, cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody revertFlow] PR comment on #${prNumber} failed: ${msg}
+`);
   }
-  emitToLog;
-  chatId;
-  async emit(event) {
-    const be = translateChatEvent(event, this.chatId);
-    if (be) this.emitToLog(be);
+}
+
+// src/scripts/reviewFlow.ts
+init_issue();
+var reviewFlow = async (ctx) => {
+  const prNumber = ctx.args.pr;
+  const pr = getPr(prNumber, ctx.cwd);
+  if (pr.state !== "OPEN") {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `PR #${prNumber} is not OPEN (state: ${pr.state})`;
+    ctx.skipAgent = true;
+    return;
   }
+  ctx.data.pr = pr;
+  ctx.data.commentTargetType = "pr";
+  ctx.data.commentTargetNumber = prNumber;
+  checkoutPrBranch(prNumber, ctx.cwd);
+  ctx.data.branch = getCurrentBranch(ctx.cwd);
+  ctx.data.prDiff = getPrDiff(prNumber, ctx.cwd);
+  const runUrl = getRunUrl();
+  const runSuffix = runUrl ? `, run ${runUrl}` : "";
+  tryPostPr5(prNumber, `\u{1F440} kody review started on PR #${prNumber}${runSuffix}`, ctx.cwd);
 };
-var chatQueues = /* @__PURE__ */ new Map();
-function enqueue(chatId, fn) {
-  const prev = chatQueues.get(chatId) ?? Promise.resolve();
-  const next = prev.catch(() => {
-  }).then(fn);
-  chatQueues.set(
-    chatId,
-    next.finally(() => {
-      if (chatQueues.get(chatId) === next) chatQueues.delete(chatId);
-    })
-  );
-  return next;
+function tryPostPr5(prNumber, body, cwd) {
+  try {
+    postPrReviewComment(prNumber, body, cwd);
+  } catch {
+  }
 }
-function streamToRes(res, dir, chatId, since) {
-  writeSseHeaders(res);
-  emitSse(res, { type: "chat", chatId });
-  let maxSent = since;
-  const unsubscribe = subscribe(
-    dir,
-    chatId,
-    since,
-    (rec) => {
-      if (rec.seq <= maxSent) return;
-      maxSent = rec.seq;
-      if (res.writableEnded) return;
-      res.write(`data: ${JSON.stringify({ ...rec.event, seq: rec.seq })}
 
+// src/scripts/runFlow.ts
+init_issue();
+var runFlow = async (ctx) => {
+  const issueNumber = ctx.args.issue;
+  const issue = getIssue(issueNumber, ctx.cwd);
+  ctx.data.issue = issue;
+  ctx.data.commentTargetType = "issue";
+  ctx.data.commentTargetNumber = issueNumber;
+  const argBase = resolveBaseOverride(ctx.args.base);
+  const baseRaw = ctx.args.base;
+  if (baseRaw && !argBase) {
+    process.stderr.write(`[kody runFlow] ignoring --base "${baseRaw}" (must match kody-task or goal-branch pattern)
 `);
-    },
-    () => {
-      if (!res.writableEnded) {
-        try {
-          res.end();
-        } catch {
-        }
-      }
-    }
-  );
-  res.on("close", unsubscribe);
-}
-async function handleChatTurn(req, res, chatId, opts) {
-  let body;
+  }
+  const base = argBase;
+  if (base) {
+    ctx.data.baseBranch = base;
+    process.stderr.write(`[kody runFlow] resolved base branch: ${base} (from --base)
+`);
+  }
+  const branchInfo = ensureFeatureBranch(issueNumber, issue.title, ctx.config.git.defaultBranch, ctx.cwd, base ?? void 0);
+  ctx.data.branch = branchInfo.branch;
+  const runUrl = getRunUrl();
+  const startMsg = runUrl ? `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\`, run ${runUrl}` : `\u2699\uFE0F kody started \u2014 branch \`${ctx.data.branch}\``;
+  tryPost(issueNumber, startMsg, ctx.cwd);
+};
+function tryPost(issueNumber, body, cwd) {
   try {
-    body = await readJsonBody(req);
+    postIssueComment(issueNumber, body, cwd);
   } catch {
-    sendJson(res, 400, { error: "invalid JSON body" });
-    return;
-  }
-  const message = typeof body === "object" && body !== null && "message" in body ? body.message : void 0;
-  if (typeof message !== "string" || !message.trim()) {
-    sendJson(res, 400, { error: "message required" });
-    return;
   }
-  const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs32.mkdirSync(path30.dirname(sessionFile), { recursive: true });
-  appendTurn(sessionFile, {
-    role: "user",
-    content: message,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  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) => {
-      const errMsg2 = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[brain-serve] chat turn failed: ${errMsg2}
-`);
-      endTurnIfUnterminated(opts.cwd, chatId, errMsg2);
-    }).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;
-  return createServer(async (req, res) => {
-    if (!req.method || !req.url) {
-      sendJson(res, 400, { error: "bad request" });
-      return;
-    }
-    const url = new URL(req.url, `http://localhost`);
-    if (req.method === "GET" && url.pathname === "/healthz") {
-      sendJson(res, 200, { ok: true });
-      return;
-    }
-    if (!authOk(req, opts.apiKey)) {
-      sendJson(res, 401, { error: "unauthorized" });
-      return;
-    }
-    const m = url.pathname.match(/^\/chats\/([^/]+)\/messages\/?$/);
-    if (req.method === "POST" && m) {
-      const chatId = decodeURIComponent(m[1] ?? "");
-      if (!chatId) {
-        sendJson(res, 400, { error: "chatId required" });
-        return;
-      }
-      await handleChatTurn(req, res, chatId, {
-        cwd: opts.cwd,
-        model: opts.model,
-        litellmUrl: opts.litellmUrl,
-        runTurn
-      });
-      return;
-    }
-    const sm = url.pathname.match(/^\/chats\/([^/]+)\/stream\/?$/);
-    if (req.method === "GET" && sm) {
-      const chatId = decodeURIComponent(sm[1] ?? "");
-      if (!chatId) {
-        sendJson(res, 400, { error: "chatId required" });
-        return;
-      }
-      const sinceRaw = url.searchParams.get("since");
-      const since = Number.isFinite(Number(sinceRaw)) ? Number(sinceRaw) : 0;
-      streamToRes(res, opts.cwd, chatId, since);
-      return;
-    }
-    sendJson(res, 404, { error: "not found" });
-  });
+function resolveBaseOverride(value) {
+  if (!value) return null;
+  if (value.length > 200) return null;
+  if (value.includes("..")) return null;
+  if (!/^[a-z0-9][a-z0-9/._-]*$/.test(value)) return null;
+  return value;
 }
-var brainServe = async (ctx) => {
+
+// src/scripts/runTickScript.ts
+import { spawnSync } from "child_process";
+import * as fs32 from "fs";
+import * as path30 from "path";
+var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
-  const apiKey = getApiKey();
-  const port = Number(process.env.PORT ?? DEFAULT_PORT);
-  const model = parseProviderModel(ctx.config.agent.model);
-  const usesProxy = needsLitellmProxy(model);
-  let handle = null;
-  if (usesProxy) {
-    process.stdout.write(
-      `[brain-serve] starting LiteLLM proxy for ${model.provider}/${model.model}...
-`
-    );
-    handle = await startLitellmIfNeeded(model, ctx.cwd);
-    process.stdout.write(
-      `[brain-serve] LiteLLM ready at ${handle?.url ?? LITELLM_DEFAULT_URL}
-`
-    );
+  const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const slugArg = String(args?.slugArg ?? "job");
+  const fenceLabel = String(args?.fenceLabel ?? "kody-job-next-state");
+  const slug = String(ctx.args[slugArg] ?? "").trim();
+  if (!slug) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
+    return;
   }
-  const litellmUrl = usesProxy ? handle?.url ?? LITELLM_DEFAULT_URL : null;
-  const server = buildServer({
-    apiKey,
+  const jobPath = path30.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs32.existsSync(jobPath)) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
+    return;
+  }
+  const raw = fs32.readFileSync(jobPath, "utf-8");
+  const { frontmatter } = splitFrontmatter(raw);
+  const tickScript = frontmatter.tickScript;
+  if (!tickScript) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
+    return;
+  }
+  const scriptPath = path30.isAbsolute(tickScript) ? tickScript : path30.join(ctx.cwd, tickScript);
+  if (!fs32.existsSync(scriptPath)) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
+    return;
+  }
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
+  let loaded;
+  try {
+    loaded = await backend.load(slug);
+  } catch (err) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: state load failed: ${err instanceof Error ? err.message : String(err)}`;
+    return;
+  }
+  ctx.data.jobSlug = slug;
+  ctx.data.jobState = loaded;
+  const childEnv = buildChildEnv(process.env, Boolean(ctx.args.force));
+  const result = spawnSync("bash", [scriptPath], {
     cwd: ctx.cwd,
-    model,
-    litellmUrl
-  });
-  await new Promise((resolve4) => {
-    server.listen(port, "0.0.0.0", () => {
-      process.stdout.write(
-        `[brain-serve] listening on 0.0.0.0:${port} (cwd=${ctx.cwd})
-`
-      );
-      resolve4();
-    });
+    env: childEnv,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    timeout: 5 * 60 * 1e3,
+    // Default maxBuffer is 1MB — a chatty `gh pr list --json …` over a
+    // busy repo (or an accidental `set -x`) can blow that and silently
+    // truncate stdout, which is the exact "silent state drop" failure
+    // mode this whole executable was written to prevent. 16MB is well
+    // above any realistic tick output.
+    maxBuffer: 16 * 1024 * 1024
   });
-  const shutdown = (signal) => {
-    process.stdout.write(`[brain-serve] ${signal} \u2014 shutting down
-`);
-    server.close(() => {
-      if (handle) {
-        try {
-          handle.kill();
-        } catch {
-        }
-      }
-      process.exit(0);
-    });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = `runTickScript: spawn error: ${result.error.message}`;
+    return;
+  }
+  if (result.signal) {
+    ctx.output.exitCode = 124;
+    ctx.output.reason = `runTickScript: ${tickScript} killed by ${result.signal} (likely 5min timeout)`;
+    return;
+  }
+  if (result.status !== 0) {
+    ctx.output.exitCode = result.status ?? 99;
+    ctx.output.reason = `runTickScript: ${tickScript} exited ${result.status}`;
+    return;
+  }
+  const prevRev = loaded.state.rev ?? 0;
+  const parsed = extractNextStateFromText(result.stdout ?? "", fenceLabel, prevRev);
+  if (parsed.error) {
+    ctx.data.nextStateParseError = parsed.error;
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `runTickScript: ${parsed.error}`;
+    return;
+  }
+  ctx.data.nextJobState = parsed.envelope;
+};
+function buildChildEnv(parent, force) {
+  const allow = /* @__PURE__ */ new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TMPDIR",
+    "LANG",
+    "LC_ALL",
+    "TERM",
+    // GitHub auth — `gh` reads these.
+    "GH_TOKEN",
+    "GH_PAT",
+    "GITHUB_TOKEN",
+    // CI metadata commonly read by tick scripts (`gh repo view`,
+    // workflow run links, etc.). All public values from GitHub Actions.
+    "GITHUB_ACTIONS",
+    "GITHUB_ACTOR",
+    "GITHUB_REPOSITORY",
+    "GITHUB_REPOSITORY_OWNER",
+    "GITHUB_REF",
+    "GITHUB_SHA",
+    "GITHUB_RUN_ID",
+    "GITHUB_RUN_NUMBER",
+    "GITHUB_WORKFLOW",
+    "GITHUB_JOB",
+    "GITHUB_SERVER_URL",
+    "GITHUB_API_URL",
+    "GITHUB_EVENT_NAME",
+    "RUNNER_OS",
+    "RUNNER_ARCH"
+  ]);
+  const out = {};
+  for (const [key, value] of Object.entries(parent)) {
+    if (value === void 0) continue;
+    if (allow.has(key) || key.startsWith("KODY_PUBLIC_")) {
+      out[key] = value;
+    }
+  }
+  if (force) out.KODY_FORCE = "1";
+  return out;
+}
+
+// src/scripts/saveGoalState.ts
+var saveGoalState = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) {
+    ctx.skipAgent = true;
+    return;
+  }
+  const updated = {
+    ...goal.raw ?? { state: goal.state, extra: {} },
+    state: goal.state,
+    lastDispatchedIssue: goal.lastDispatchedIssue,
+    updatedAt: nowIso()
   };
-  process.once("SIGINT", () => shutdown("SIGINT"));
-  process.once("SIGTERM", () => shutdown("SIGTERM"));
-  await new Promise(() => {
-  });
+  writeGoalState(ctx.cwd, goal.id, updated);
+  ctx.skipAgent = true;
+};
+
+// src/scripts/saveTaskState.ts
+var saveTaskState = async (ctx, profile) => {
+  const target = ctx.data.commentTargetType;
+  const number = ctx.data.commentTargetNumber;
+  const state = ctx.data.taskState;
+  if (!target || !number || !state) return;
+  const executable = profile.name;
+  const action = ctx.data.action ?? synthesizeAction(ctx);
+  if (ctx.output.prUrl && !state.core.prUrl) state.core.prUrl = ctx.output.prUrl;
+  if (typeof ctx.data.runUrl === "string") state.core.runUrl = ctx.data.runUrl;
+  const next = reduce(state, executable, action, profile.phase);
+  if (ctx.output.prUrl) next.core.prUrl = ctx.output.prUrl;
+  if (typeof ctx.data.runUrl === "string") next.core.runUrl = ctx.data.runUrl;
+  writeTaskState(target, number, next, ctx.cwd);
+  ctx.data.taskStateRendered = renderStateComment(next);
 };
+function synthesizeAction(ctx) {
+  const ok = ctx.output.exitCode === 0;
+  return {
+    type: ok ? "RUN_COMPLETED" : "RUN_FAILED",
+    payload: {
+      exitCode: ctx.output.exitCode,
+      reason: ctx.output.reason,
+      prUrl: ctx.output.prUrl
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 
 // src/scripts/serveFlow.ts
 import { spawn as spawn3 } from "child_process";
@@ -9643,52 +9719,6 @@ var serveFlow = async (ctx) => {
   });
 };
 
-// src/scripts/saveGoalState.ts
-var saveGoalState = async (ctx) => {
-  const goal = ctx.data.goal;
-  if (!goal) {
-    ctx.skipAgent = true;
-    return;
-  }
-  const updated = {
-    ...goal.raw ?? { state: goal.state, extra: {} },
-    state: goal.state,
-    lastDispatchedIssue: goal.lastDispatchedIssue,
-    updatedAt: nowIso()
-  };
-  writeGoalState(ctx.cwd, goal.id, updated);
-  ctx.skipAgent = true;
-};
-
-// src/scripts/saveTaskState.ts
-var saveTaskState = async (ctx, profile) => {
-  const target = ctx.data.commentTargetType;
-  const number = ctx.data.commentTargetNumber;
-  const state = ctx.data.taskState;
-  if (!target || !number || !state) return;
-  const executable = profile.name;
-  const action = ctx.data.action ?? synthesizeAction(ctx);
-  if (ctx.output.prUrl && !state.core.prUrl) state.core.prUrl = ctx.output.prUrl;
-  if (typeof ctx.data.runUrl === "string") state.core.runUrl = ctx.data.runUrl;
-  const next = reduce(state, executable, action, profile.phase);
-  if (ctx.output.prUrl) next.core.prUrl = ctx.output.prUrl;
-  if (typeof ctx.data.runUrl === "string") next.core.runUrl = ctx.data.runUrl;
-  writeTaskState(target, number, next, ctx.cwd);
-  ctx.data.taskStateRendered = renderStateComment(next);
-};
-function synthesizeAction(ctx) {
-  const ok = ctx.output.exitCode === 0;
-  return {
-    type: ok ? "RUN_COMPLETED" : "RUN_FAILED",
-    payload: {
-      exitCode: ctx.output.exitCode,
-      reason: ctx.output.reason,
-      prUrl: ctx.output.prUrl
-    },
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
 // src/scripts/setCommentTarget.ts
 var setCommentTarget = async (ctx, _profile, args) => {
   const type = args?.type ?? "issue";
@@ -10531,6 +10561,7 @@ var preflightScripts = {
   handleAbandonedGoal,
   deriveGoalPhase,
   dispatchNextTask,
+  parkGoalForMerge,
   finalizeGoal,
   saveGoalState
 };