@kody-ade/kody-engine 0.4.12 → 0.4.14

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.12",
+  version: "0.4.14",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -51,9 +51,9 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync29 } from "child_process";
-import * as fs28 from "fs";
-import * as path25 from "path";
+import { execFileSync as execFileSync31 } from "child_process";
+import * as fs29 from "fs";
+import * as path26 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -188,9 +188,21 @@ function loadConfig(projectDir = process.cwd()) {
     aliases: mergeAliases(raw.aliases),
     classify: parseClassifyConfig(raw.classify),
     release: parseReleaseConfig(raw.release),
-    jobs: parseJobsConfig(raw.jobs)
+    jobs: parseJobsConfig(raw.jobs),
+    qa: parseQaConfig(raw.qa)
   };
 }
+function parseQaConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  if (typeof r.fallbackUrl === "string" && r.fallbackUrl.trim().length > 0) {
+    out.fallbackUrl = r.fallbackUrl.trim();
+  } else if (r.fallbackUrl !== void 0) {
+    throw new Error(`kody.config.json: qa.fallbackUrl must be a non-empty string`);
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function parseJobsConfig(raw) {
   if (!raw || typeof raw !== "object") return void 0;
   const r = raw;
@@ -388,7 +400,15 @@ async function runAgent(opts) {
     ...process.env,
     SKIP_HOOKS: "1",
     HUSKY: "0",
-    CI: process.env.CI ?? "1"
+    CI: process.env.CI ?? "1",
+    // MCP servers are spawned asynchronously by the SDK. With the default
+    // non-blocking behavior, the SDK announces its tool list at session
+    // init while servers are still in `pending`, so their tools never
+    // reach the model. Block until each MCP completes its handshake (or
+    // the timeout below elapses) so the tool list is complete on first
+    // turn.
+    MCP_CONNECTION_NONBLOCKING: process.env.MCP_CONNECTION_NONBLOCKING ?? "false",
+    MCP_TIMEOUT: process.env.MCP_TIMEOUT ?? "60000"
   };
   if (opts.litellmUrl) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
@@ -892,9 +912,9 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 }
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync28 } from "child_process";
-import * as fs27 from "fs";
-import * as path24 from "path";
+import { execFileSync as execFileSync30 } from "child_process";
+import * as fs28 from "fs";
+import * as path25 from "path";
 
 // src/dispatch.ts
 import * as fs7 from "fs";
@@ -1253,9 +1273,9 @@ function coerceBare(spec, value) {
 }
 
 // src/executor.ts
-import { execFileSync as execFileSync27, spawn as spawn4 } from "child_process";
-import * as fs26 from "fs";
-import * as path23 from "path";
+import { execFileSync as execFileSync29, spawn as spawn5 } from "child_process";
+import * as fs27 from "fs";
+import * as path24 from "path";
 
 // src/litellm.ts
 import { execFileSync as execFileSync3, spawn } from "child_process";
@@ -2581,118 +2601,803 @@ function formatToolsUsage(profile) {
   return lines.join("\n");
 }
 
-// src/scripts/diagMcp.ts
-import { execFileSync as execFileSync8 } from "child_process";
+// src/scripts/createQaGoal.ts
+import { execFileSync as execFileSync9 } from "child_process";
 import * as fs14 from "fs";
-import * as os3 from "os";
 import * as path13 from "path";
-var diagMcp = async (_ctx) => {
-  const home = os3.homedir();
-  const cacheDir = path13.join(home, ".cache", "ms-playwright");
-  let entries = [];
-  try {
-    entries = fs14.readdirSync(cacheDir);
-  } catch {
+
+// src/issue.ts
+import { execFileSync as execFileSync8 } from "child_process";
+var API_TIMEOUT_MS3 = 3e4;
+function ghToken2() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh2(args, options) {
+  const token = ghToken2();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync8("gh", args, {
+    encoding: "utf-8",
+    timeout: API_TIMEOUT_MS3,
+    cwd: options?.cwd,
+    env,
+    input: options?.input,
+    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
+  }).trim();
+}
+function getIssue(issueNumber, cwd) {
+  const output = gh2(["issue", "view", String(issueNumber), "--json", "number,title,body,comments,labels"], { cwd });
+  const parsed = JSON.parse(output);
+  if (typeof parsed?.title !== "string") {
+    throw new Error(`Issue #${issueNumber}: unexpected response shape`);
   }
-  const hasChromium = entries.some((e) => e.startsWith("chromium"));
-  process.stderr.write(
-    `[kody diag] ms-playwright cache: ${entries.length === 0 ? "EMPTY (or missing)" : entries.join(", ")}
+  return {
+    number: parsed.number ?? issueNumber,
+    title: parsed.title,
+    body: parsed.body ?? "",
+    comments: (parsed.comments ?? []).map((c) => ({
+      body: c.body ?? "",
+      author: c.author?.login ?? "unknown",
+      createdAt: c.createdAt ?? ""
+    })),
+    labels: Array.isArray(parsed.labels) ? parsed.labels.map((l) => l.name ?? "").filter((n) => n.length > 0) : []
+  };
+}
+function stripKodyMentions(body) {
+  return body.replace(/(@)(kody)/gi, "$1\u200B$2");
+}
+function postIssueComment(issueNumber, body, cwd) {
+  try {
+    gh2(["issue", "comment", String(issueNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
+  } catch (err) {
+    process.stderr.write(
+      `[kody] failed to post comment on #${issueNumber}: ${err instanceof Error ? err.message : String(err)}
 `
-  );
-  process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
-`);
+    );
+  }
+}
+function truncate2(s, maxBytes) {
+  if (s.length <= maxBytes) return s;
+  return `${s.slice(0, maxBytes)}\u2026 (+${s.length - maxBytes} chars)`;
+}
+function parsePrNumber(url) {
+  const m = url.match(/\/pull\/(\d+)(?:[/?#]|$)/);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  return Number.isFinite(n) ? n : null;
+}
+function getPr(prNumber, cwd) {
+  const output = gh2(["pr", "view", String(prNumber), "--json", "number,title,body,headRefName,baseRefName,state"], {
+    cwd
+  });
+  const parsed = JSON.parse(output);
+  if (typeof parsed?.title !== "string") {
+    throw new Error(`PR #${prNumber}: unexpected response shape`);
+  }
+  return {
+    number: parsed.number ?? prNumber,
+    title: parsed.title,
+    body: parsed.body ?? "",
+    headRefName: String(parsed.headRefName ?? ""),
+    baseRefName: String(parsed.baseRefName ?? ""),
+    state: String(parsed.state ?? "")
+  };
+}
+function getPrDiff(prNumber, cwd) {
   try {
-    const v = execFileSync8("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
-      stdio: "pipe",
-      timeout: 6e4,
-      encoding: "utf8"
-    }).trim();
-    process.stderr.write(`[kody diag] @playwright/mcp version: ${v}
-`);
-  } catch (e) {
-    const err = e instanceof Error ? e.message : String(e);
-    process.stderr.write(`[kody diag] @playwright/mcp spawn FAILED: ${err}
-`);
+    return gh2(["pr", "diff", String(prNumber)], { cwd });
+  } catch (err) {
+    process.stderr.write(
+      `[kody] failed to fetch diff for PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return "";
   }
-};
-
-// src/scripts/discoverQaContext.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-
-// src/scripts/frameworkDetectors.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
-function detectFrameworks(cwd) {
-  const out = [];
-  let deps = {};
+}
+function getPrReviews(prNumber, cwd) {
   try {
-    const pkg = JSON.parse(fs15.readFileSync(path14.join(cwd, "package.json"), "utf-8"));
-    deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const output = gh2(["pr", "view", String(prNumber), "--json", "reviews"], { cwd });
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed?.reviews)) return [];
+    return parsed.reviews.map(
+      (r) => ({
+        body: r.body ?? "",
+        state: r.state ?? "",
+        author: r.author?.login ?? "unknown",
+        submittedAt: r.submittedAt ?? ""
+      })
+    );
   } catch {
-    return out;
-  }
-  if (deps.payload || deps["@payloadcms/next"]) {
-    out.push({
-      name: "payload-cms",
-      version: deps.payload ?? deps["@payloadcms/next"] ?? null,
-      configFile: findFile(cwd, ["payload.config.ts", "payload-config.ts", "src/payload.config.ts"])
-    });
-  }
-  if (deps["next-auth"]) {
-    out.push({
-      name: "nextauth",
-      version: deps["next-auth"] ?? null,
-      configFile: findFile(cwd, ["auth.ts", "auth.config.ts", "src/auth.ts", "src/auth.config.ts"])
-    });
-  }
-  if (deps.prisma || deps["@prisma/client"]) {
-    out.push({
-      name: "prisma",
-      version: deps.prisma ?? deps["@prisma/client"] ?? null,
-      configFile: findFile(cwd, ["prisma/schema.prisma"])
-    });
+    return [];
   }
-  if (deps.next) {
-    out.push({
-      name: "nextjs",
-      version: deps.next ?? null,
-      configFile: findFile(cwd, ["next.config.ts", "next.config.mjs", "next.config.js"])
-    });
+}
+function getPrComments(prNumber, cwd) {
+  try {
+    const output = gh2(["pr", "view", String(prNumber), "--json", "comments"], { cwd });
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed?.comments)) return [];
+    return parsed.comments.map((c) => ({
+      body: c.body ?? "",
+      author: c.author?.login ?? "unknown",
+      createdAt: c.createdAt ?? ""
+    })).filter((c) => c.body.trim().length > 0);
+  } catch {
+    return [];
   }
-  return out;
 }
-function findFile(cwd, candidates) {
-  for (const c of candidates) {
-    if (fs15.existsSync(path14.join(cwd, c))) return c;
+var VERDICT_HEADING = /(^|\n)\s*#{1,6}\s*Verdict\s*:/i;
+function isReviewShaped(body) {
+  return VERDICT_HEADING.test(body);
+}
+function getPrLatestReviewBody(prNumber, cwd) {
+  const reviews = getPrReviews(prNumber, cwd).filter((r) => r.body.trim().length > 0).map((r) => ({ body: r.body, at: r.submittedAt }));
+  const comments = getPrComments(prNumber, cwd).filter((c) => isReviewShaped(c.body)).map((c) => ({ body: c.body, at: c.createdAt }));
+  const all = [...reviews, ...comments].sort((a, b) => (b.at || "").localeCompare(a.at || ""));
+  if (all.length > 0) return all[0].body;
+  const pr = getPr(prNumber, cwd);
+  return pr.body;
+}
+function postPrReviewComment(prNumber, body, cwd) {
+  try {
+    gh2(["pr", "comment", String(prNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
+  } catch (err) {
+    process.stderr.write(
+      `[kody] failed to post review comment on PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  return null;
 }
-var COLLECTION_DIRS = [
-  "src/server/payload/collections",
-  "src/payload/collections",
-  "src/collections",
-  "payload/collections"
-];
-function discoverPayloadCollections(cwd) {
-  const out = [];
-  for (const dir of COLLECTION_DIRS) {
-    const full = path14.join(cwd, dir);
-    if (!fs15.existsSync(full)) continue;
-    let files;
+
+// src/scripts/postReviewResult.ts
+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 {
-      files = fs15.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      postPrReviewComment(prNumber, `\u26A0\uFE0F kody review FAILED: ${truncate2(reason, 1e3)}`, ctx.cwd);
     } catch {
-      continue;
     }
-    for (const file of files) {
-      try {
-        const filePath = path14.join(full, file);
-        const content = fs15.readFileSync(filePath, "utf-8").slice(0, 1e4);
-        const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
-        if (!slugMatch) continue;
-        const slug = slugMatch[1];
-        const name = file.replace(/\.(ts|tsx)$/, "");
+    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}`;
+    ctx.data.action = failedAction(ctx.output.reason);
+    return;
+  }
+  const verdict = detectVerdict(reviewBody);
+  ctx.data.reviewVerdict = verdict;
+  ctx.data.reviewBody = reviewBody;
+  ctx.data.action = reviewAction(verdict, { bodyPreview: truncate2(reviewBody, 500) });
+  ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+  process.stdout.write(
+    `
+REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/pull/${prNumber} (verdict: ${verdict})
+`
+  );
+};
+
+// src/scripts/createQaGoal.ts
+var MANIFEST_LABEL = "kody:goals-manifest";
+var MANIFEST_TITLE = "Kody Goals Manifest";
+var MANIFEST_START = "<!-- kody-goals-start -->";
+var MANIFEST_END = "<!-- kody-goals-end -->";
+var FINDING_LABEL = "kody:qa-finding";
+var REPORT_JSON_OPEN = "<!-- KODY_QA_REPORT_JSON";
+var REPORT_JSON_CLOSE = "-->";
+function qaAction(verdict, payload) {
+  const type = verdict === "PASS" ? "QA_PASS" : verdict === "CONCERNS" ? "QA_CONCERNS" : verdict === "FAIL" ? "QA_FAIL" : "QA_COMPLETED";
+  return { type, payload: { verdict, ...payload }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function failedAction2(reason) {
+  return { type: "QA_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function buildGoalId(scope, existing) {
+  const focus = slugify(scope?.trim() ? scope.trim() : "smoke") || "smoke";
+  const base = `qa-${focus}-${todayIso()}`;
+  if (!existing.has(base)) return base;
+  let i = 2;
+  while (existing.has(`${base}-${i}`)) i++;
+  return `${base}-${i}`;
+}
+function buildGoalName(scope, verdict) {
+  const focus = scope?.trim() ? scope.trim() : "smoke";
+  const verdictTag = verdict === "UNKNOWN" ? "REPORT" : verdict;
+  return `QA: ${focus} \u2014 ${verdictTag} \u2014 ${todayIso()}`.slice(0, 240);
+}
+function splitReport(text) {
+  const open = text.indexOf(REPORT_JSON_OPEN);
+  if (open < 0) {
+    return { markdown: text.trim(), data: null, jsonError: "no JSON block marker" };
+  }
+  const closeRel = text.slice(open + REPORT_JSON_OPEN.length).indexOf(REPORT_JSON_CLOSE);
+  if (closeRel < 0) {
+    return { markdown: text.slice(0, open).trim(), data: null, jsonError: "JSON block not terminated" };
+  }
+  const closeAbs = open + REPORT_JSON_OPEN.length + closeRel;
+  const rawJson = text.slice(open + REPORT_JSON_OPEN.length, closeAbs).trim();
+  const fenced = rawJson.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
+  const cleanJson = fenced ? fenced[1].trim() : rawJson;
+  let parsed = null;
+  let parseError;
+  try {
+    const obj = JSON.parse(cleanJson);
+    if (!obj || !Array.isArray(obj.findings)) {
+      parseError = "JSON missing 'findings' array";
+    } else {
+      parsed = obj;
+    }
+  } catch (err) {
+    parseError = err instanceof Error ? err.message : String(err);
+  }
+  const markdown = text.slice(0, open).trim();
+  return { markdown, data: parsed, jsonError: parseError };
+}
+function loadManifest(cwd) {
+  let issuesJson;
+  try {
+    issuesJson = gh2(
+      ["issue", "list", "--label", MANIFEST_LABEL, "--state", "all", "--limit", "1", "--json", "number,body"],
+      { cwd }
+    );
+  } catch {
+    return { number: null, manifest: { version: 1, goals: [] } };
+  }
+  let arr = [];
+  try {
+    arr = JSON.parse(issuesJson);
+  } catch {
+    return { number: null, manifest: { version: 1, goals: [] } };
+  }
+  if (arr.length === 0) return { number: null, manifest: { version: 1, goals: [] } };
+  const issue = arr[0];
+  const manifest = parseManifestBody(issue.body);
+  return { number: issue.number, manifest };
+}
+function parseManifestBody(body) {
+  if (!body) return { version: 1, goals: [] };
+  const start = body.indexOf(MANIFEST_START);
+  const end = body.indexOf(MANIFEST_END);
+  if (start < 0 || end < 0 || end < start) return { version: 1, goals: [] };
+  const inner = body.slice(start + MANIFEST_START.length, end);
+  const fenceOpen = inner.indexOf("```");
+  const fenceClose = inner.lastIndexOf("```");
+  if (fenceOpen < 0 || fenceClose <= fenceOpen) return { version: 1, goals: [] };
+  const afterOpen = inner.indexOf("\n", fenceOpen);
+  if (afterOpen < 0) return { version: 1, goals: [] };
+  const json = inner.slice(afterOpen + 1, fenceClose).trim();
+  if (!json) return { version: 1, goals: [] };
+  try {
+    const parsed = JSON.parse(json);
+    if (!parsed || !Array.isArray(parsed.goals)) return { version: 1, goals: [] };
+    return { version: 1, goals: parsed.goals };
+  } catch {
+    return { version: 1, goals: [] };
+  }
+}
+function serializeManifestBody(manifest) {
+  const preamble = "> Kody goals manifest \u2014 the dashboard reads and writes the JSON block below.\n> Prefer editing via the UI to avoid merge conflicts.\n\n";
+  const json = JSON.stringify(manifest, null, 2);
+  return `${preamble}${MANIFEST_START}
+
+\`\`\`json
+${json}
+\`\`\`
+
+${MANIFEST_END}
+`;
+}
+function ensureLabel(name, color, description, cwd) {
+  try {
+    gh2(["label", "create", name, "--color", color, "--description", description, "--force"], { cwd });
+  } catch {
+  }
+}
+function severityLabel(sev) {
+  return `severity:${sev}`;
+}
+var SEVERITY_COLORS = {
+  P0: "b60205",
+  P1: "d93f0b",
+  P2: "fbca04",
+  P3: "0e8a16"
+};
+function ensureSeverityLabels(findings, cwd) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of findings) {
+    if (seen.has(f.severity)) continue;
+    seen.add(f.severity);
+    ensureLabel(severityLabel(f.severity), SEVERITY_COLORS[f.severity], `kody QA finding severity ${f.severity}`, cwd);
+  }
+}
+function buildIssueBody(f, goalId, parentManifestNumber) {
+  const lines = [];
+  if (f.route) lines.push(`**Route:** \`${f.route}\``);
+  lines.push("");
+  lines.push("**Steps**");
+  lines.push("");
+  lines.push(f.steps.trim());
+  lines.push("");
+  lines.push("**Expected**");
+  lines.push("");
+  lines.push(f.expected.trim());
+  lines.push("");
+  lines.push("**Actual**");
+  lines.push("");
+  lines.push(f.actual.trim());
+  lines.push("");
+  if (f.evidence?.trim()) {
+    lines.push("**Evidence**");
+    lines.push("");
+    lines.push(f.evidence.trim());
+    lines.push("");
+  }
+  lines.push("---");
+  if (parentManifestNumber !== null) {
+    lines.push(`Goal: \`${goalId}\` \u2014 manifest issue #${parentManifestNumber}`);
+  } else {
+    lines.push(`Goal: \`${goalId}\``);
+  }
+  return lines.join("\n");
+}
+function createOrUpdateManifestIssue(number, manifest, cwd) {
+  ensureLabel(MANIFEST_LABEL, "8b5cf6", "kody: goals manifest", cwd);
+  const body = serializeManifestBody(manifest);
+  if (number !== null) {
+    gh2(["issue", "edit", String(number), "--body-file", "-"], { input: body, cwd });
+    return { number, created: false };
+  }
+  const out = gh2(["issue", "create", "--title", MANIFEST_TITLE, "--label", MANIFEST_LABEL, "--body-file", "-"], {
+    input: body,
+    cwd
+  });
+  const url = out.split("\n").map((l) => l.trim()).filter(Boolean).pop() ?? "";
+  const m = url.match(/\/issues\/(\d+)\b/);
+  if (!m) throw new Error(`gh issue create returned unexpected output: ${out}`);
+  return { number: Number(m[1]), created: true };
+}
+function writeStateFile(cwd, goalId, lastDispatchedIssue) {
+  const dir = path13.join(cwd, ".kody", "goals", goalId);
+  fs14.mkdirSync(dir, { recursive: true });
+  const state = {
+    version: 1,
+    state: "active",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
+  };
+  const filePath = path13.join(dir, "state.json");
+  fs14.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+`);
+  return filePath;
+}
+function gitTry(args, cwd) {
+  const env = { ...process.env, SKIP_HOOKS: "1", HUSKY: "0" };
+  try {
+    execFileSync9("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
+    return { ok: true, stderr: "" };
+  } catch (err) {
+    const e = err;
+    const stderr = typeof e?.stderr === "string" ? e.stderr : Buffer.isBuffer(e?.stderr) ? e.stderr.toString("utf8") : e?.message ?? "";
+    return { ok: false, stderr: stderr.trim() };
+  }
+}
+function commitAndPushState(filePath, goalId, cwd) {
+  const add = gitTry(["add", filePath], cwd);
+  if (!add.ok) {
+    process.stderr.write(`[createQaGoal] git add failed: ${add.stderr.slice(-400) || "(no stderr)"}
+`);
+    return;
+  }
+  const diff = gitTry(["diff", "--cached", "--quiet"], cwd);
+  if (diff.ok) {
+    process.stderr.write(`[createQaGoal] state.json unchanged \u2014 nothing to commit
+`);
+    return;
+  }
+  const commit = gitTry(["commit", "-m", `chore(goals): activate ${goalId}`, "--quiet"], cwd);
+  if (!commit.ok) {
+    process.stderr.write(`[createQaGoal] git commit failed: ${commit.stderr.slice(-400) || "(no stderr)"}
+`);
+    return;
+  }
+  const push = gitTry(["push", "--quiet"], cwd);
+  if (push.ok) return;
+  const stderr = push.stderr;
+  const tail = stderr.slice(-400) || "(no stderr captured)";
+  if (/non-fast-forward|rejected|fetch first|behind/i.test(stderr)) {
+    process.stderr.write(`[createQaGoal] push rejected (non-fast-forward) \u2014 pulling --rebase and retrying
+`);
+    const rebase = gitTry(["pull", "--rebase", "--autostash", "--quiet"], cwd);
+    if (!rebase.ok) {
+      process.stderr.write(
+        `[createQaGoal] rebase failed (manual recovery required): ${rebase.stderr.slice(-400) || "(no stderr)"}
+`
+      );
+      return;
+    }
+    const retryPush = gitTry(["push", "--quiet"], cwd);
+    if (retryPush.ok) {
+      process.stderr.write(`[createQaGoal] push succeeded after rebase
+`);
+      return;
+    }
+    process.stderr.write(
+      `[createQaGoal] push still failed after rebase: ${retryPush.stderr.slice(-400) || "(no stderr)"}
+`
+    );
+    return;
+  }
+  if (/pre-push|hook|husky/i.test(stderr)) {
+    process.stderr.write(`[createQaGoal] push rejected by pre-push hook \u2014 retrying with --no-verify
+`);
+    process.stderr.write(`[createQaGoal] hook output:
+${tail}
+`);
+    const noVerify = gitTry(["push", "--no-verify", "--quiet"], cwd);
+    if (noVerify.ok) {
+      process.stderr.write(`[createQaGoal] push succeeded with --no-verify (consider adding kody artifacts to ignore configs)
+`);
+      return;
+    }
+    process.stderr.write(
+      `[createQaGoal] --no-verify push also failed: ${noVerify.stderr.slice(-400) || "(no stderr)"}
+`
+    );
+    return;
+  }
+  process.stderr.write(
+    `[createQaGoal] state.json commit landed but push failed.
+[createQaGoal]   The goal will not be visible to goal-scheduler in CI until you run 'git push' manually.
+[createQaGoal]   git stderr:
+${tail}
+`
+  );
+}
+function createTaskIssue(finding, goalId, manifestNumber, cwd) {
+  const labels = [`goal:${goalId}`, severityLabel(finding.severity), FINDING_LABEL];
+  ensureLabel(`goal:${goalId}`, "1d76db", `goal: ${goalId}`, cwd);
+  ensureLabel(FINDING_LABEL, "ededed", "kody: QA finding", cwd);
+  const title = `[${finding.severity}] ${finding.title}`.slice(0, 240);
+  const body = buildIssueBody(finding, goalId, manifestNumber);
+  const args = ["issue", "create", "--title", title, "--body-file", "-"];
+  for (const l of labels) {
+    args.push("--label", l);
+  }
+  const out = gh2(args, { input: body, cwd });
+  const url = out.split("\n").map((l) => l.trim()).filter(Boolean).pop() ?? "";
+  const m = url.match(/\/issues\/(\d+)\b/);
+  if (!m) throw new Error(`gh issue create returned unexpected output: ${out}`);
+  return { number: Number(m[1]), url };
+}
+var createQaGoal = async (ctx, _profile, agentResult) => {
+  if (!agentResult || agentResult.outcome !== "completed") {
+    const reason = agentResult?.error ?? "agent did not complete";
+    process.stderr.write(`[createQaGoal] ${reason}
+`);
+    ctx.output.exitCode = 1;
+    ctx.output.reason = reason;
+    ctx.data.action = failedAction2(reason);
+    return;
+  }
+  const finalText = agentResult.finalText.trim();
+  if (!finalText) {
+    process.stderr.write("[createQaGoal] agent produced no report body\n");
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "empty report body";
+    ctx.data.action = failedAction2("empty report body");
+    return;
+  }
+  const { markdown, data, jsonError } = splitReport(finalText);
+  const verdict = detectVerdict(markdown);
+  const findings = data?.findings ?? [];
+  const existingIssue = ctx.args.issue;
+  if (findings.length === 0 || jsonError) {
+    if (jsonError) {
+      process.stderr.write(`[createQaGoal] JSON parse: ${jsonError} \u2014 falling back to single-issue mode
+`);
+    }
+    if (typeof existingIssue === "number" && existingIssue > 0) {
+      try {
+        postIssueComment(existingIssue, finalText, ctx.cwd);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.output.exitCode = 4;
+        ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
+        ctx.data.action = failedAction2(ctx.output.reason);
+        return;
+      }
+      process.stdout.write(
+        `
+QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
+`
+      );
+      ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
+      ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+      return;
+    }
+    ensureLabel(FINDING_LABEL, "ededed", "kody: QA finding", ctx.cwd);
+    const scope2 = ctx.args.scope;
+    const title = `QA [${verdict}]: ${scope2?.trim() || "smoke"} \u2014 ${todayIso()}`.slice(0, 240);
+    let url = "";
+    try {
+      const out = gh2(
+        ["issue", "create", "--title", title, "--label", FINDING_LABEL, "--body-file", "-"],
+        { input: finalText, cwd: ctx.cwd }
+      );
+      url = out.split("\n").map((l) => l.trim()).filter(Boolean).pop() ?? "";
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.output.exitCode = 4;
+      ctx.output.reason = `failed to open record issue: ${truncate2(msg, 1e3)}`;
+      ctx.data.action = failedAction2(ctx.output.reason);
+      return;
+    }
+    process.stdout.write(`
+QA_REPORT_POSTED=${url} (verdict: ${verdict})
+`);
+    const m = url.match(/\/issues\/(\d+)\b/);
+    ctx.data.action = qaAction(verdict, {
+      issueNumber: m ? Number(m[1]) : 0,
+      issueUrl: url,
+      mode: "create-record"
+    });
+    ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+    return;
+  }
+  const explicitGoal = ctx.args.goal?.trim();
+  const scope = ctx.args.scope;
+  let goalId;
+  let manifestIssueNumber = null;
+  let manifestCreated = false;
+  let manifestUpdated = false;
+  if (explicitGoal && explicitGoal.length > 0) {
+    goalId = explicitGoal;
+    const manifestRead = loadManifest(ctx.cwd);
+    if (manifestRead.number !== null) {
+      manifestIssueNumber = manifestRead.number;
+      try {
+        postIssueComment(
+          manifestRead.number,
+          `## QA \u2014 ${verdict} \xB7 goal \`${goalId}\`
+
+${markdown}`,
+          ctx.cwd
+        );
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[createQaGoal] could not comment on manifest issue: ${reason.slice(0, 300)}
+`);
+      }
+    }
+  } else {
+    const manifestRead = loadManifest(ctx.cwd);
+    const existingIds = new Set(manifestRead.manifest.goals.map((g) => g.id));
+    goalId = buildGoalId(scope, existingIds);
+    const goalName = buildGoalName(scope, verdict);
+    const newGoal = {
+      id: goalId,
+      name: goalName,
+      description: markdown,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const nextManifest = {
+      version: 1,
+      goals: [...manifestRead.manifest.goals, newGoal]
+    };
+    let manifestIssue;
+    try {
+      manifestIssue = createOrUpdateManifestIssue(manifestRead.number, nextManifest, ctx.cwd);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.output.exitCode = 4;
+      ctx.output.reason = `failed to update goals manifest: ${truncate2(msg, 1e3)}`;
+      ctx.data.action = failedAction2(ctx.output.reason);
+      return;
+    }
+    manifestIssueNumber = manifestIssue.number;
+    manifestCreated = manifestIssue.created;
+    manifestUpdated = true;
+  }
+  ensureSeverityLabels(findings, ctx.cwd);
+  const opened = [];
+  const failed = [];
+  for (const f of findings) {
+    try {
+      const issue = createTaskIssue(f, goalId, manifestIssueNumber, ctx.cwd);
+      opened.push({ ...issue, severity: f.severity });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      failed.push({ title: f.title, reason });
+      process.stderr.write(`[createQaGoal] could not open issue for "${f.title}": ${reason.slice(0, 300)}
+`);
+    }
+  }
+  const stateFile = writeStateFile(ctx.cwd, goalId);
+  commitAndPushState(stateFile, goalId, ctx.cwd);
+  const repoUrl = `https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}`;
+  if (manifestIssueNumber !== null) {
+    const verb = manifestUpdated ? manifestCreated ? "OPENED" : "UPDATED" : "TARGETED";
+    process.stdout.write(
+      `
+QA_GOAL_${verb}=${repoUrl}/issues/${manifestIssueNumber} (id: ${goalId}, verdict: ${verdict})
+`
+    );
+  } else {
+    process.stdout.write(`
+QA_GOAL_TARGETED=(no manifest issue) (id: ${goalId}, verdict: ${verdict})
+`);
+  }
+  for (const o of opened) {
+    process.stdout.write(`QA_FINDING_OPENED=${o.url} (severity: ${o.severity})
+`);
+  }
+  if (failed.length > 0) {
+    process.stdout.write(`QA_FINDINGS_FAILED=${failed.length} (see stderr above)
+`);
+  }
+  ctx.data.action = qaAction(verdict, {
+    goalId,
+    manifestIssue: manifestIssueNumber ?? void 0,
+    findingsOpened: opened.length,
+    findingsFailed: failed.length,
+    mode: explicitGoal ? "goal-attach" : manifestCreated ? "goal-create" : "goal-append"
+  });
+  ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+};
+
+// src/scripts/diagMcp.ts
+import { execFileSync as execFileSync10 } from "child_process";
+import * as fs15 from "fs";
+import * as os3 from "os";
+import * as path14 from "path";
+var diagMcp = async (_ctx) => {
+  const home = os3.homedir();
+  const cacheDir = path14.join(home, ".cache", "ms-playwright");
+  let entries = [];
+  try {
+    entries = fs15.readdirSync(cacheDir);
+  } catch {
+  }
+  const hasChromium = entries.some((e) => e.startsWith("chromium"));
+  process.stderr.write(
+    `[kody diag] ms-playwright cache: ${entries.length === 0 ? "EMPTY (or missing)" : entries.join(", ")}
+`
+  );
+  process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
+`);
+  try {
+    const v = execFileSync10("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+      stdio: "pipe",
+      timeout: 6e4,
+      encoding: "utf8"
+    }).trim();
+    process.stderr.write(`[kody diag] @playwright/mcp version: ${v}
+`);
+  } catch (e) {
+    const err = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[kody diag] @playwright/mcp spawn FAILED: ${err}
+`);
+  }
+};
+
+// src/scripts/discoverQaContext.ts
+import * as fs17 from "fs";
+import * as path16 from "path";
+
+// src/scripts/frameworkDetectors.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+function detectFrameworks(cwd) {
+  const out = [];
+  let deps = {};
+  try {
+    const pkg = JSON.parse(fs16.readFileSync(path15.join(cwd, "package.json"), "utf-8"));
+    deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  } catch {
+    return out;
+  }
+  if (deps.payload || deps["@payloadcms/next"]) {
+    out.push({
+      name: "payload-cms",
+      version: deps.payload ?? deps["@payloadcms/next"] ?? null,
+      configFile: findFile(cwd, ["payload.config.ts", "payload-config.ts", "src/payload.config.ts"])
+    });
+  }
+  if (deps["next-auth"]) {
+    out.push({
+      name: "nextauth",
+      version: deps["next-auth"] ?? null,
+      configFile: findFile(cwd, ["auth.ts", "auth.config.ts", "src/auth.ts", "src/auth.config.ts"])
+    });
+  }
+  if (deps.prisma || deps["@prisma/client"]) {
+    out.push({
+      name: "prisma",
+      version: deps.prisma ?? deps["@prisma/client"] ?? null,
+      configFile: findFile(cwd, ["prisma/schema.prisma"])
+    });
+  }
+  if (deps.next) {
+    out.push({
+      name: "nextjs",
+      version: deps.next ?? null,
+      configFile: findFile(cwd, ["next.config.ts", "next.config.mjs", "next.config.js"])
+    });
+  }
+  return out;
+}
+function findFile(cwd, candidates) {
+  for (const c of candidates) {
+    if (fs16.existsSync(path15.join(cwd, c))) return c;
+  }
+  return null;
+}
+var COLLECTION_DIRS = [
+  "src/server/payload/collections",
+  "src/payload/collections",
+  "src/collections",
+  "payload/collections"
+];
+function discoverPayloadCollections(cwd) {
+  const out = [];
+  for (const dir of COLLECTION_DIRS) {
+    const full = path15.join(cwd, dir);
+    if (!fs16.existsSync(full)) continue;
+    let files;
+    try {
+      files = fs16.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      try {
+        const filePath = path15.join(full, file);
+        const content = fs16.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
+        if (!slugMatch) continue;
+        const slug = slugMatch[1];
+        const name = file.replace(/\.(ts|tsx)$/, "");
         const fields = [];
         const fieldMatches = content.matchAll(/name:\s*['"]([a-zA-Z_][a-zA-Z0-9_]*)['"]/g);
         for (const m of fieldMatches) {
@@ -2702,7 +3407,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path14.relative(cwd, filePath),
+          filePath: path15.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -2716,28 +3421,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 = path14.join(cwd, dir);
-    if (!fs15.existsSync(full)) continue;
+    const full = path15.join(cwd, dir);
+    if (!fs16.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs15.readdirSync(full, { withFileTypes: true });
+      entries = fs16.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path14.join(full, entry.name);
+      const entryPath = path15.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs15.existsSync(path14.join(entryPath, f))
+          (f) => fs16.existsSync(path15.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path14.relative(cwd, path14.join(entryPath, indexFile));
+        filePath = path15.relative(cwd, path15.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path14.relative(cwd, entryPath);
+        filePath = path15.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -2745,7 +3450,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs15.readFileSync(path14.join(cwd, col.filePath), "utf-8");
+            const colContent = fs16.readFileSync(path15.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -2764,8 +3469,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path14.join(cwd, appDir, "api");
-    if (!fs15.existsSync(apiDir)) continue;
+    const apiDir = path15.join(cwd, appDir, "api");
+    if (!fs16.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -2774,14 +3479,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs15.readdirSync(dir, { withFileTypes: true });
+    entries = fs16.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 = fs15.readFileSync(path14.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs16.readFileSync(path15.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)
       );
@@ -2789,7 +3494,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path14.relative(cwd, path14.join(dir, routeFile.name))
+          filePath: path15.relative(cwd, path15.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -2800,7 +3505,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(path14.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path15.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -2808,7 +3513,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path14.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path15.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -2828,10 +3533,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 = path14.join(cwd, envFile);
-    if (!fs15.existsSync(envPath)) continue;
+    const envPath = path15.join(cwd, envFile);
+    if (!fs16.existsSync(envPath)) continue;
     try {
-      const content = fs15.readFileSync(envPath, "utf-8");
+      const content = fs16.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -2879,9 +3584,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs16.readFileSync(path15.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs17.readFileSync(path16.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs16.existsSync(path15.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs16.existsSync(path15.join(cwd, "yarn.lock")) ? "yarn" : fs16.existsSync(path15.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs17.existsSync(path16.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs17.existsSync(path16.join(cwd, "yarn.lock")) ? "yarn" : fs17.existsSync(path16.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;
@@ -2891,8 +3596,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path15.join(cwd, appDir);
-    if (!fs16.existsSync(full)) continue;
+    const full = path16.join(cwd, appDir);
+    if (!fs17.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -2900,7 +3605,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs16.readdirSync(dir, { withFileTypes: true });
+    entries = fs17.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -2917,7 +3622,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(path15.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path16.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -2925,7 +3630,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path15.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path16.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -2942,23 +3647,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs16.existsSync(path15.join(cwd, c))) out.authFiles.push(c);
+    if (fs17.existsSync(path16.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 = path15.join(cwd, rp);
-    if (!fs16.existsSync(dir)) continue;
+    const dir = path16.join(cwd, rp);
+    if (!fs17.existsSync(dir)) continue;
     let files;
     try {
-      files = fs16.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs17.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs16.readFileSync(path15.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs17.readFileSync(path16.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) {
@@ -3104,8 +3809,8 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync9 } from "child_process";
-var API_TIMEOUT_MS3 = 3e4;
+import { execFileSync as execFileSync11 } from "child_process";
+var API_TIMEOUT_MS4 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
   if (!next) {
@@ -3140,199 +3845,58 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync9("gh", [sub, "comment", String(targetNumber), "--body", body], {
-      timeout: API_TIMEOUT_MS3,
-      cwd: ctx.cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (err) {
-    process.stderr.write(
-      `[kody dispatch] failed to post @kody ${next} on ${sub} #${targetNumber}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-};
-function parsePr(url) {
-  const m = url.match(/\/pull\/(\d+)(?:[/?#]|$)/);
-  if (!m) return null;
-  const n = parseInt(m[1], 10);
-  return Number.isFinite(n) ? n : null;
-}
-
-// src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync10 } from "child_process";
-var API_TIMEOUT_MS4 = 3e4;
-var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
-var dispatchClassified = async (ctx) => {
-  const issueNumber = ctx.args.issue;
-  if (!issueNumber) return;
-  const classification = ctx.data.classification;
-  if (!classification || !VALID_CLASSES2.has(classification)) return;
-  try {
-    execFileSync10("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
-      cwd: ctx.cwd,
-      timeout: API_TIMEOUT_MS4,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (err) {
-    process.stderr.write(
-      `[kody dispatchClassified] failed to dispatch @kody ${classification}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    ctx.data.action = failedAction("dispatch post failed");
-    ctx.output.exitCode = 1;
-    ctx.output.reason = "classify: dispatch failed";
-  }
-};
-function failedAction(reason) {
-  return { type: "CLASSIFY_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
-}
-
-// src/scripts/dispatchJobFileTicks.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
-
-// src/issue.ts
-import { execFileSync as execFileSync11 } from "child_process";
-var API_TIMEOUT_MS5 = 3e4;
-function ghToken2() {
-  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
-}
-function gh2(args, options) {
-  const token = ghToken2();
-  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync11("gh", args, {
-    encoding: "utf-8",
-    timeout: API_TIMEOUT_MS5,
-    cwd: options?.cwd,
-    env,
-    input: options?.input,
-    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
-  }).trim();
-}
-function getIssue(issueNumber, cwd) {
-  const output = gh2(["issue", "view", String(issueNumber), "--json", "number,title,body,comments,labels"], { cwd });
-  const parsed = JSON.parse(output);
-  if (typeof parsed?.title !== "string") {
-    throw new Error(`Issue #${issueNumber}: unexpected response shape`);
-  }
-  return {
-    number: parsed.number ?? issueNumber,
-    title: parsed.title,
-    body: parsed.body ?? "",
-    comments: (parsed.comments ?? []).map((c) => ({
-      body: c.body ?? "",
-      author: c.author?.login ?? "unknown",
-      createdAt: c.createdAt ?? ""
-    })),
-    labels: Array.isArray(parsed.labels) ? parsed.labels.map((l) => l.name ?? "").filter((n) => n.length > 0) : []
-  };
-}
-function stripKodyMentions(body) {
-  return body.replace(/(@)(kody)/gi, "$1\u200B$2");
-}
-function postIssueComment(issueNumber, body, cwd) {
-  try {
-    gh2(["issue", "comment", String(issueNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
-  } catch (err) {
-    process.stderr.write(
-      `[kody] failed to post comment on #${issueNumber}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-}
-function truncate2(s, maxBytes) {
-  if (s.length <= maxBytes) return s;
-  return `${s.slice(0, maxBytes)}\u2026 (+${s.length - maxBytes} chars)`;
-}
-function parsePrNumber(url) {
-  const m = url.match(/\/pull\/(\d+)(?:[/?#]|$)/);
-  if (!m) return null;
-  const n = parseInt(m[1], 10);
-  return Number.isFinite(n) ? n : null;
-}
-function getPr(prNumber, cwd) {
-  const output = gh2(["pr", "view", String(prNumber), "--json", "number,title,body,headRefName,baseRefName,state"], {
-    cwd
-  });
-  const parsed = JSON.parse(output);
-  if (typeof parsed?.title !== "string") {
-    throw new Error(`PR #${prNumber}: unexpected response shape`);
-  }
-  return {
-    number: parsed.number ?? prNumber,
-    title: parsed.title,
-    body: parsed.body ?? "",
-    headRefName: String(parsed.headRefName ?? ""),
-    baseRefName: String(parsed.baseRefName ?? ""),
-    state: String(parsed.state ?? "")
-  };
-}
-function getPrDiff(prNumber, cwd) {
-  try {
-    return gh2(["pr", "diff", String(prNumber)], { cwd });
-  } catch (err) {
-    process.stderr.write(
-      `[kody] failed to fetch diff for PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return "";
-  }
-}
-function getPrReviews(prNumber, cwd) {
-  try {
-    const output = gh2(["pr", "view", String(prNumber), "--json", "reviews"], { cwd });
-    const parsed = JSON.parse(output);
-    if (!Array.isArray(parsed?.reviews)) return [];
-    return parsed.reviews.map(
-      (r) => ({
-        body: r.body ?? "",
-        state: r.state ?? "",
-        author: r.author?.login ?? "unknown",
-        submittedAt: r.submittedAt ?? ""
-      })
-    );
-  } catch {
-    return [];
-  }
-}
-function getPrComments(prNumber, cwd) {
-  try {
-    const output = gh2(["pr", "view", String(prNumber), "--json", "comments"], { cwd });
-    const parsed = JSON.parse(output);
-    if (!Array.isArray(parsed?.comments)) return [];
-    return parsed.comments.map((c) => ({
-      body: c.body ?? "",
-      author: c.author?.login ?? "unknown",
-      createdAt: c.createdAt ?? ""
-    })).filter((c) => c.body.trim().length > 0);
-  } catch {
-    return [];
-  }
-}
-var VERDICT_HEADING = /(^|\n)\s*#{1,6}\s*Verdict\s*:/i;
-function isReviewShaped(body) {
-  return VERDICT_HEADING.test(body);
-}
-function getPrLatestReviewBody(prNumber, cwd) {
-  const reviews = getPrReviews(prNumber, cwd).filter((r) => r.body.trim().length > 0).map((r) => ({ body: r.body, at: r.submittedAt }));
-  const comments = getPrComments(prNumber, cwd).filter((c) => isReviewShaped(c.body)).map((c) => ({ body: c.body, at: c.createdAt }));
-  const all = [...reviews, ...comments].sort((a, b) => (b.at || "").localeCompare(a.at || ""));
-  if (all.length > 0) return all[0].body;
-  const pr = getPr(prNumber, cwd);
-  return pr.body;
+    execFileSync11("gh", [sub, "comment", String(targetNumber), "--body", body], {
+      timeout: API_TIMEOUT_MS4,
+      cwd: ctx.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[kody dispatch] failed to post @kody ${next} on ${sub} #${targetNumber}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+};
+function parsePr(url) {
+  const m = url.match(/\/pull\/(\d+)(?:[/?#]|$)/);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  return Number.isFinite(n) ? n : null;
 }
-function postPrReviewComment(prNumber, body, cwd) {
+
+// src/scripts/dispatchClassified.ts
+import { execFileSync as execFileSync12 } from "child_process";
+var API_TIMEOUT_MS5 = 3e4;
+var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
+var dispatchClassified = async (ctx) => {
+  const issueNumber = ctx.args.issue;
+  if (!issueNumber) return;
+  const classification = ctx.data.classification;
+  if (!classification || !VALID_CLASSES2.has(classification)) return;
   try {
-    gh2(["pr", "comment", String(prNumber), "--body-file", "-"], { input: stripKodyMentions(body), cwd });
+    execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
+      cwd: ctx.cwd,
+      timeout: API_TIMEOUT_MS5,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
   } catch (err) {
     process.stderr.write(
-      `[kody] failed to post review comment on PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}
+      `[kody dispatchClassified] failed to dispatch @kody ${classification}: ${err instanceof Error ? err.message : String(err)}
 `
     );
+    ctx.data.action = failedAction3("dispatch post failed");
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "classify: dispatch failed";
   }
+};
+function failedAction3(reason) {
+  return { type: "CLASSIFY_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
+// src/scripts/dispatchJobFileTicks.ts
+import * as fs19 from "fs";
+import * as path18 from "path";
+
 // src/scripts/issueStateComment.ts
 function isStateEnvelope(x) {
   if (x === null || typeof x !== "object") return false;
@@ -3503,8 +4067,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -3519,7 +4083,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 = path16.join(opts.cwd, opts.jobsDir);
+    this.absDir = path17.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -3534,7 +4098,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs17.mkdirSync(this.absDir, { recursive: true });
+    fs18.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -3563,7 +4127,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs17.existsSync(this.absDir)) {
+    if (!fs18.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -3579,11 +4143,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path16.join(this.cwd, relPath);
-    if (!fs17.existsSync(absPath)) {
+    const absPath = path17.join(this.cwd, relPath);
+    if (!fs18.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs17.readFileSync(absPath, "utf-8");
+    const raw = fs18.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -3600,10 +4164,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path16.join(this.cwd, loaded.path);
-    fs17.mkdirSync(path16.dirname(absPath), { recursive: true });
+    const absPath = path17.join(this.cwd, loaded.path);
+    fs18.mkdirSync(path17.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs17.writeFileSync(absPath, body, "utf-8");
+    fs18.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -3680,7 +4244,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path17.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path18.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -3728,10 +4292,10 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
   }
 };
 function listJobSlugs(absDir) {
-  if (!fs18.existsSync(absDir)) return [];
+  if (!fs19.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs18.readdirSync(absDir, { withFileTypes: true });
+    entries = fs19.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -3904,10 +4468,14 @@ function ensurePr(opts) {
   const title = buildPrTitle(effectiveOpts.issueNumber, effectiveOpts.issueTitle, effectiveOpts.draft);
   const body = buildPrBody(effectiveOpts);
   if (existing) {
+    const stripped = existing.url.replace(/^https:\/\/github\.com\//, "");
+    const [owner, repo] = stripped.split("/");
     try {
-      gh2(["pr", "edit", String(existing.number), "--body-file", "-"], { input: body, cwd: opts.cwd });
+      gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/pulls/${existing.number}`, "-f", `body=${body}`], {
+        cwd: opts.cwd
+      });
     } catch (err) {
-      throw new Error(`gh pr edit #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(`gh api PATCH #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return { url: existing.url, number: existing.number, draft: opts.draft, action: "updated" };
   }
@@ -3966,15 +4534,19 @@ var ensureMemorizePr = async (ctx) => {
   const body = buildBody(ctx, branch, datestamp);
   const existing = findExistingPr(branch, ctx.cwd);
   if (existing) {
+    const stripped = existing.url.replace(/^https:\/\/github\.com\//, "");
+    const [owner, repo] = stripped.split("/");
     try {
-      gh2(["pr", "edit", String(existing.number), "--body-file", "-"], { input: body, cwd: ctx.cwd });
+      gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/pulls/${existing.number}`, "-f", `body=${body}`], {
+        cwd: ctx.cwd
+      });
       ctx.output.prUrl = existing.url;
       ctx.data.prResult = { url: existing.url, number: existing.number, action: "updated" };
       process.stdout.write(`[kody memorize] updated PR ${existing.url}
 `);
     } catch (err) {
       ctx.output.exitCode = 4;
-      ctx.output.reason = `gh pr edit #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`;
+      ctx.output.reason = `gh api PATCH #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`;
     }
     return;
   }
@@ -4103,7 +4675,7 @@ function collectExpectedTests(raw) {
 }
 
 // src/scripts/finishFlow.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 
 // src/lifecycleLabels.ts
 var KODY_NAMESPACE = "kody";
@@ -4256,7 +4828,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync13("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4270,7 +4842,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var UncommittedChangesError = class extends Error {
   constructor(branch) {
     super(`Uncommitted changes on branch '${branch}' \u2014 refusing to run to protect work in progress`);
@@ -4280,7 +4852,7 @@ var UncommittedChangesError = class extends Error {
   branch;
 };
 function git2(args, cwd) {
-  return execFileSync13("git", args, {
+  return execFileSync14("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -4305,7 +4877,7 @@ function checkoutPrBranch(prNumber, cwd) {
     SKIP_HOOKS: "1",
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
-  execFileSync13("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync14("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -4419,8 +4991,8 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync14 } from "child_process";
-import * as fs19 from "fs";
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs20 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -4431,10 +5003,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs19.existsSync(eventPath)) return;
+  if (!eventPath || !fs20.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs19.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs20.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -4462,7 +5034,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync14("gh", args, opts);
+      execFileSync15("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -4475,13 +5047,13 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync14("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync15("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
 
 // src/workflow.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -4489,7 +5061,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync15("gh", args, {
+  return execFileSync16("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -4673,23 +5245,23 @@ function tryPostPr2(prNumber, body, cwd) {
 }
 
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs21 from "fs";
-import * as path19 from "path";
+import { execFileSync as execFileSync17 } from "child_process";
+import * as fs22 from "fs";
+import * as path20 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path18.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs20.existsSync(full)) {
+  const full = path19.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs21.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs20.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs21.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -4699,9 +5271,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs21.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs21.existsSync(path19.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs21.existsSync(path19.join(cwd, "bun.lockb"))) return "bun";
+  if (fs22.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs22.existsSync(path20.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs22.existsSync(path20.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -4714,7 +5286,7 @@ function qualityCommandsFor(pm) {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync16("git", ["remote", "get-url", "origin"], {
+    url = execFileSync17("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -4799,7 +5371,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync16("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync17("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -4807,7 +5379,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync16("git", ["branch", "--show-current"], {
+      return execFileSync17("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -4823,33 +5395,33 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path19.join(cwd, "kody.config.json");
-  if (fs21.existsSync(configPath) && !force) {
+  const configPath = path20.join(cwd, "kody.config.json");
+  if (fs22.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs21.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs22.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path19.join(cwd, ".github", "workflows");
-  const workflowPath = path19.join(workflowDir, "kody.yml");
-  if (fs21.existsSync(workflowPath) && !force) {
+  const workflowDir = path20.join(cwd, ".github", "workflows");
+  const workflowPath = path20.join(workflowDir, "kody.yml");
+  if (fs22.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs21.mkdirSync(workflowDir, { recursive: true });
-    fs21.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs22.mkdirSync(workflowDir, { recursive: true });
+    fs22.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs21.existsSync(path19.join(cwd, "src/app")) || fs21.existsSync(path19.join(cwd, "app")) || fs21.existsSync(path19.join(cwd, "pages"));
+  const hasUi = fs22.existsSync(path20.join(cwd, "src/app")) || fs22.existsSync(path20.join(cwd, "app")) || fs22.existsSync(path20.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path19.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs21.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path20.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs22.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs21.mkdirSync(path19.dirname(qaGuidePath), { recursive: true });
+      fs22.mkdirSync(path20.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs21.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs22.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
@@ -4861,12 +5433,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path19.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs21.existsSync(target) && !force) {
+    const target = path20.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs22.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs21.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs22.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -5004,8 +5576,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const slugArg = String(args?.slugArg ?? "job");
@@ -5013,11 +5585,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path20.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs22.existsSync(absPath)) {
+  const absPath = path21.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs23.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs22.readFileSync(absPath, "utf-8");
+  const raw = fs23.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);
@@ -5151,16 +5723,16 @@ var loadTaskState = async (ctx) => {
 };
 
 // src/scripts/loadVaultContext.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 var VAULT_DIR_RELATIVE = ".kody/vault";
 var MAX_PAGES = 8;
 var PER_PAGE_MAX_BYTES = 4e3;
 var TOTAL_MAX_BYTES2 = 24e3;
 var TRUNCATED_SUFFIX2 = "\n\n\u2026 (truncated)";
 var loadVaultContext = async (ctx) => {
-  const vaultAbs = path21.join(ctx.cwd, VAULT_DIR_RELATIVE);
-  if (!fs23.existsSync(vaultAbs)) {
+  const vaultAbs = path22.join(ctx.cwd, VAULT_DIR_RELATIVE);
+  if (!fs24.existsSync(vaultAbs)) {
     ctx.data.vaultContext = "";
     return;
   }
@@ -5185,21 +5757,21 @@ function collectPages(vaultAbs) {
   walkMd(vaultAbs, (file) => {
     let stat;
     try {
-      stat = fs23.statSync(file);
+      stat = fs24.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs23.readFileSync(file, "utf-8");
+      raw = fs24.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() ?? path21.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path22.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path21.relative(vaultAbs, file),
+      relPath: path22.relative(vaultAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -5267,16 +5839,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs23.readdirSync(dir);
+      names = fs24.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path21.join(dir, name);
+      const full = path22.join(dir, name);
       let stat;
       try {
-        stat = fs23.statSync(full);
+        stat = fs24.statSync(full);
       } catch {
         continue;
       }
@@ -5298,16 +5870,16 @@ var markFlowSuccess = async (ctx) => {
 };
 
 // src/scripts/memorizeFlow.ts
-import { execFileSync as execFileSync17 } from "child_process";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import { execFileSync as execFileSync18 } from "child_process";
+import * as fs25 from "fs";
+import * as path23 from "path";
 var VAULT_DIR_RELATIVE2 = ".kody/vault";
 var DEFAULT_LOOKBACK_HOURS = 36;
 var MAX_RECENT_PRS = 25;
 var MAX_VAULT_INDEX_ENTRIES = 200;
 var PR_BODY_TRUNC = 2e3;
 var memorizeFlow = async (ctx) => {
-  const vaultAbs = path22.join(ctx.cwd, VAULT_DIR_RELATIVE2);
+  const vaultAbs = path23.join(ctx.cwd, VAULT_DIR_RELATIVE2);
   ensureBranch(ctx, vaultAbs);
   if (ctx.skipAgent) return;
   const sinceIso = computeSinceIso(vaultAbs);
@@ -5317,8 +5889,8 @@ var memorizeFlow = async (ctx) => {
   const recent = fetchRecentPrs(ctx.cwd, sinceIso);
   ctx.data.recentPrs = formatRecentPrs(recent);
   ctx.data.recentPrCount = recent.length;
-  if (!fs24.existsSync(vaultAbs)) {
-    fs24.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs25.existsSync(vaultAbs)) {
+    fs25.mkdirSync(vaultAbs, { recursive: true });
   }
   ctx.data.vaultIndex = formatVaultIndex(vaultAbs);
   if (recent.length === 0) {
@@ -5350,18 +5922,18 @@ function ensureBranch(ctx, vaultAbs) {
     }
   }
   ctx.data.branch = branch;
-  if (!fs24.existsSync(vaultAbs)) {
-    fs24.mkdirSync(vaultAbs, { recursive: true });
+  if (!fs25.existsSync(vaultAbs)) {
+    fs25.mkdirSync(vaultAbs, { recursive: true });
   }
 }
 function computeSinceIso(vaultAbs) {
   const fallback = new Date(Date.now() - DEFAULT_LOOKBACK_HOURS * 60 * 60 * 1e3).toISOString();
-  if (!fs24.existsSync(vaultAbs)) return fallback;
+  if (!fs25.existsSync(vaultAbs)) return fallback;
   let latest = "";
   walkMd2(vaultAbs, (file) => {
     let raw;
     try {
-      raw = fs24.readFileSync(file, "utf-8");
+      raw = fs25.readFileSync(file, "utf-8");
     } catch {
       return;
     }
@@ -5438,10 +6010,10 @@ function formatVaultIndex(vaultAbs) {
   const entries = [];
   walkMd2(vaultAbs, (file) => {
     if (entries.length >= MAX_VAULT_INDEX_ENTRIES) return;
-    const rel = path22.relative(vaultAbs, file);
+    const rel = path23.relative(vaultAbs, file);
     let title = rel;
     try {
-      const raw = fs24.readFileSync(file, "utf-8");
+      const raw = fs25.readFileSync(file, "utf-8");
       const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
       const titleMatch = m?.[1]?.match(/^title:\s*(.+)$/m);
       if (titleMatch) title = `${titleMatch[1].trim()} (${rel})`;
@@ -5453,22 +6025,22 @@ function formatVaultIndex(vaultAbs) {
   return entries.join("\n");
 }
 function walkMd2(root, visit) {
-  if (!fs24.existsSync(root)) return;
+  if (!fs25.existsSync(root)) return;
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs24.readdirSync(dir);
+      names = fs25.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path22.join(dir, name);
+      const full = path23.join(dir, name);
       let stat;
       try {
-        stat = fs24.statSync(full);
+        stat = fs25.statSync(full);
       } catch {
         continue;
       }
@@ -5481,7 +6053,7 @@ function walkMd2(root, visit) {
   }
 }
 function git3(args, cwd) {
-  return execFileSync17("git", args, {
+  return execFileSync18("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -5491,7 +6063,7 @@ function git3(args, cwd) {
 }
 
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 var API_TIMEOUT_MS7 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -5510,7 +6082,7 @@ var mergeReleasePr = async (ctx) => {
   process.stderr.write(`[kody mergeReleasePr] merging PR #${prNumber} (${prUrl})
 `);
   try {
-    const out = execFileSync18("gh", ["pr", "merge", String(prNumber), "--merge"], {
+    const out = execFileSync19("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS7,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5610,77 +6182,13 @@ function composeBody({ label, exit, prUrl, reason, dryRun }) {
   return `\u2705 kody ${label} complete`;
 }
 
-// src/scripts/postReviewResult.ts
-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 failedAction2(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 = failedAction2(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 = failedAction2(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 = failedAction2("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}`;
-    ctx.data.action = failedAction2(ctx.output.reason);
-    return;
-  }
-  const verdict = detectVerdict(reviewBody);
-  ctx.data.reviewVerdict = verdict;
-  ctx.data.reviewBody = reviewBody;
-  ctx.data.action = reviewAction(verdict, { bodyPreview: truncate2(reviewBody, 500) });
-  ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-  process.stdout.write(
-    `
-REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/pull/${prNumber} (verdict: ${verdict})
-`
-  );
-};
-
 // src/scripts/openQaIssue.ts
 var QA_LABEL = "kody:qa-report";
-function qaAction(verdict, payload) {
+function qaAction2(verdict, payload) {
   const type = verdict === "PASS" ? "QA_PASS" : verdict === "CONCERNS" ? "QA_CONCERNS" : verdict === "FAIL" ? "QA_FAIL" : "QA_COMPLETED";
   return { type, payload: { verdict, ...payload }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
-function failedAction3(reason) {
+function failedAction4(reason) {
   return { type: "QA_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 function slugifyScope(scope) {
@@ -5692,7 +6200,7 @@ function buildIssueTitle(scope, verdict) {
   const verdictTag = verdict === "UNKNOWN" ? "REPORT" : verdict;
   return `QA [${verdictTag}]: ${focus} \u2014 ${date}`.slice(0, 240);
 }
-function ensureLabel(cwd) {
+function ensureLabel2(cwd) {
   try {
     gh2(["label", "create", QA_LABEL, "--color", "8b5cf6", "--description", "kody: QA report", "--force"], { cwd });
     return true;
@@ -5716,7 +6224,7 @@ var openQaIssue = async (ctx, _profile, agentResult) => {
 `);
     ctx.output.exitCode = 1;
     ctx.output.reason = reason;
-    ctx.data.action = failedAction3(reason);
+    ctx.data.action = failedAction4(reason);
     return;
   }
   const reportBody = agentResult.finalText.trim();
@@ -5724,7 +6232,7 @@ var openQaIssue = async (ctx, _profile, agentResult) => {
     process.stderr.write("qa-engineer: agent produced no report body\n");
     ctx.output.exitCode = 1;
     ctx.output.reason = "empty report body";
-    ctx.data.action = failedAction3("empty report body");
+    ctx.data.action = failedAction4("empty report body");
     return;
   }
   const verdict = detectVerdict(reportBody);
@@ -5738,7 +6246,7 @@ var openQaIssue = async (ctx, _profile, agentResult) => {
       const msg = err instanceof Error ? err.message : String(err);
       ctx.output.exitCode = 4;
       ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
-      ctx.data.action = failedAction3(ctx.output.reason);
+      ctx.data.action = failedAction4(ctx.output.reason);
       return;
     }
     process.stdout.write(
@@ -5746,13 +6254,13 @@ var openQaIssue = async (ctx, _profile, agentResult) => {
 QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
 `
     );
-    ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
+    ctx.data.action = qaAction2(verdict, { issueNumber: existingIssue, mode: "comment" });
     ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
     return;
   }
   const scope = ctx.args.scope;
   const title = buildIssueTitle(scope, verdict);
-  const hasLabel = ensureLabel(ctx.cwd);
+  const hasLabel = ensureLabel2(ctx.cwd);
   let created;
   try {
     created = createQaIssue(title, reportBody, hasLabel, ctx.cwd);
@@ -5760,13 +6268,13 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
     const msg = err instanceof Error ? err.message : String(err);
     ctx.output.exitCode = 4;
     ctx.output.reason = `failed to open QA issue: ${truncate2(msg, 1e3)}`;
-    ctx.data.action = failedAction3(ctx.output.reason);
+    ctx.data.action = failedAction4(ctx.output.reason);
     return;
   }
   process.stdout.write(`
 QA_REPORT_POSTED=${created.url} (verdict: ${verdict})
 `);
-  ctx.data.action = qaAction(verdict, {
+  ctx.data.action = qaAction2(verdict, {
     issueNumber: created.number,
     issueUrl: created.url,
     titleSlug: scope ? slugifyScope(scope) : "smoke",
@@ -6150,7 +6658,7 @@ ${body}`;
 }
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var VALID_CLASSES3 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var recordClassification = async (ctx) => {
@@ -6168,7 +6676,7 @@ var recordClassification = async (ctx) => {
     reason = parsed?.reason ?? null;
   }
   if (!classification) {
-    ctx.data.action = failedAction4("classification missing or invalid");
+    ctx.data.action = failedAction5("classification missing or invalid");
     tryAuditComment(
       issueNumber,
       "\u26A0\uFE0F kody classifier could not decide \u2014 please re-run with an explicit `@kody <type>`.",
@@ -6198,7 +6706,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync19("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync20("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS8,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6209,7 +6717,7 @@ function tryAuditComment(issueNumber, body, cwd) {
 function makeAction3(type, payload) {
   return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
-function failedAction4(reason) {
+function failedAction5(reason) {
   return { type: "CLASSIFY_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
@@ -6248,12 +6756,12 @@ function fail(ctx, profile, reason) {
   ctx.data.agentDone = false;
   ctx.data.agentFailureReason = reason;
   const modeSeg = profile.name.replace(/-/g, "_").toUpperCase();
-  const failedAction5 = {
+  const failedAction6 = {
     type: `${modeSeg}_FAILED`,
     payload: { reason },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  ctx.data.action = failedAction5;
+  ctx.data.action = failedAction6;
 }
 function countActionItems(block) {
   if (!block.trim()) return 0;
@@ -6294,12 +6802,12 @@ function fail2(ctx, profile, reason) {
   ctx.data.agentDone = false;
   ctx.data.agentFailureReason = reason;
   const modeSeg = profile.name.replace(/-/g, "_").toUpperCase();
-  const failedAction5 = {
+  const failedAction6 = {
     type: `${modeSeg}_FAILED`,
     payload: { reason },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  ctx.data.action = failedAction5;
+  ctx.data.action = failedAction6;
 }
 
 // src/scripts/resolveArtifacts.ts
@@ -6326,7 +6834,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -6396,7 +6904,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync20("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync21("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -6411,7 +6919,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync20("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync21("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -6511,8 +7019,81 @@ var resolvePreviewUrl = async (ctx) => {
   ctx.data.previewUrlSource = "default";
 };
 
+// src/scripts/resolveQaUrl.ts
+import { execFileSync as execFileSync22 } from "child_process";
+function ghQuery(args, cwd) {
+  try {
+    const out = execFileSync22("gh", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout: 15e3
+    }).trim();
+    if (!out) return null;
+    return JSON.parse(out);
+  } catch {
+    return null;
+  }
+}
+function lookupGoalDeploymentUrl(goalId, owner, repo, cwd) {
+  const ref = `goal-${goalId}`;
+  const deployments = ghQuery(
+    ["api", `repos/${owner}/${repo}/deployments?ref=${encodeURIComponent(ref)}&per_page=5`],
+    cwd
+  );
+  if (!deployments || deployments.length === 0) return null;
+  for (const d of deployments) {
+    const statuses = ghQuery(
+      ["api", `repos/${owner}/${repo}/deployments/${d.id}/statuses?per_page=10`],
+      cwd
+    );
+    if (!statuses || statuses.length === 0) continue;
+    const success = statuses.find((s) => s.state === "success");
+    if (!success) continue;
+    const url = success.environment_url || success.target_url;
+    if (typeof url === "string" && /^https?:\/\//.test(url)) return url;
+  }
+  return null;
+}
+var resolveQaUrl = async (ctx) => {
+  const explicit = ctx.args.url?.trim();
+  if (explicit && explicit.length > 0) {
+    ctx.data.previewUrl = explicit;
+    ctx.data.previewUrlSource = "--url flag";
+    return;
+  }
+  const goal = ctx.args.goal?.trim();
+  if (goal && goal.length > 0) {
+    const url = lookupGoalDeploymentUrl(goal, ctx.config.github.owner, ctx.config.github.repo, ctx.cwd);
+    if (url) {
+      ctx.data.previewUrl = url;
+      ctx.data.previewUrlSource = `goal-${goal} latest Vercel deployment`;
+      return;
+    }
+    process.stderr.write(
+      `[resolveQaUrl] no successful deployment found for ref goal-${goal}; falling back to env/config
+`
+    );
+  }
+  const envUrl = process.env.PREVIEW_URL?.trim();
+  if (envUrl && envUrl.length > 0) {
+    ctx.data.previewUrl = envUrl;
+    ctx.data.previewUrlSource = "$PREVIEW_URL env var";
+    return;
+  }
+  const fallback = ctx.config.qa?.fallbackUrl?.trim();
+  if (fallback && fallback.length > 0) {
+    ctx.data.previewUrl = fallback;
+    ctx.data.previewUrlSource = "kody.config.json qa.fallbackUrl";
+    return;
+  }
+  throw new Error(
+    "qa-engineer: no URL resolved. Pass --url, set --goal <id> on a goal that has a Vercel preview, set $PREVIEW_URL, or configure qa.fallbackUrl in kody.config.json."
+  );
+};
+
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
 var revertFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -6594,7 +7175,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git4(args, cwd) {
-  return execFileSync21("git", args, {
+  return execFileSync23("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -6604,7 +7185,7 @@ function git4(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync21("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync23("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -6782,11 +7363,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync22("git", ["add", "-A"], {
+    execFileSync24("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -6796,7 +7377,7 @@ var stageMergeConflicts = async (ctx) => {
 };
 
 // src/scripts/startFlow.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -6830,7 +7411,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync23("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync25("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS9,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6844,7 +7425,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
   const prNumber = ctx.args.pr;
@@ -6916,7 +7497,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync24("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync26("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -6924,9 +7505,9 @@ function revParseHead(cwd) {
 function pushBranch(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync24("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync26("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
   } catch {
-    execFileSync24("git", ["push", "--force-with-lease", "-u", "origin", branch], {
+    execFileSync26("git", ["push", "--force-with-lease", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7153,7 +7734,7 @@ function downgrade2(ctx, reason) {
 }
 
 // src/scripts/waitForCi.ts
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync27 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -7231,7 +7812,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync25("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync27("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS10,
       cwd,
@@ -7277,6 +7858,151 @@ function sleep2(ms) {
   return new Promise((res) => setTimeout(res, ms));
 }
 
+// src/scripts/warmupMcp.ts
+import { spawn as spawn4 } from "child_process";
+var PER_SERVER_TIMEOUT_MS = 6e4;
+var PER_REQUEST_TIMEOUT_MS = 2e4;
+var warmupMcp = async (_ctx, profile) => {
+  const servers = profile.claudeCode.mcpServers ?? [];
+  if (servers.length === 0) return;
+  for (const s of servers) {
+    const start = Date.now();
+    try {
+      const result = await warmupOne(s.command, s.args ?? [], s.env);
+      const ms = Date.now() - start;
+      process.stderr.write(`[kody warmup] ${s.name}: ${result.toolCount} tools (${ms}ms)
+`);
+    } catch (err) {
+      const ms = Date.now() - start;
+      const reason = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody warmup] ${s.name} FAILED after ${ms}ms: ${reason}
+`);
+    }
+  }
+};
+async function warmupOne(command, args, env) {
+  const child = spawn4(command, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: env ? { ...process.env, ...env } : process.env
+  });
+  let stderrBuf = "";
+  child.stderr.on("data", (b) => {
+    stderrBuf += b.toString("utf8");
+    if (stderrBuf.length > 4096) stderrBuf = stderrBuf.slice(-4096);
+  });
+  const overallDeadline = Date.now() + PER_SERVER_TIMEOUT_MS;
+  const lines = lineStream(child.stdout);
+  let nextId = 1;
+  const send = (method, params) => {
+    const id = nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    child.stdin.write(payload);
+    return id;
+  };
+  const notify = (method, params) => {
+    const payload = JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n";
+    child.stdin.write(payload);
+  };
+  const awaitResponse = async (id) => {
+    const reqDeadline = Math.min(Date.now() + PER_REQUEST_TIMEOUT_MS, overallDeadline);
+    while (Date.now() < reqDeadline) {
+      const line = await lines.next(reqDeadline - Date.now());
+      if (line === null) break;
+      let msg = null;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg && msg.id === id) return msg;
+    }
+    throw new Error(`request id=${id} timed out (stderr tail: ${stderrBuf.trim().slice(-300) || "(empty)"})`);
+  };
+  try {
+    const initId = send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "kody-warmup", version: "0.1.0" }
+    });
+    const initResp = await awaitResponse(initId);
+    if (initResp.error) throw new Error(`initialize error: ${initResp.error.message}`);
+    notify("notifications/initialized");
+    const listId = send("tools/list");
+    const listResp = await awaitResponse(listId);
+    if (listResp.error) throw new Error(`tools/list error: ${listResp.error.message}`);
+    const tools = listResp.result?.tools;
+    const toolCount = Array.isArray(tools) ? tools.length : 0;
+    if (toolCount === 0) throw new Error("tools/list returned 0 tools");
+    return { toolCount };
+  } finally {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, 2e3).unref();
+  }
+}
+function lineStream(stream) {
+  let buf = "";
+  const queue = [];
+  let waiter = null;
+  let ended = false;
+  const tryDeliver = () => {
+    if (waiter && queue.length > 0) {
+      const w = waiter;
+      waiter = null;
+      w(queue.shift());
+    } else if (waiter && ended) {
+      const w = waiter;
+      waiter = null;
+      w(null);
+    }
+  };
+  stream.on("data", (chunk) => {
+    buf += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, idx).replace(/\r$/, "");
+      buf = buf.slice(idx + 1);
+      if (line.length > 0) queue.push(line);
+    }
+    tryDeliver();
+  });
+  stream.on("end", () => {
+    if (buf.length > 0) {
+      queue.push(buf);
+      buf = "";
+    }
+    ended = true;
+    tryDeliver();
+  });
+  return {
+    next: (timeoutMs) => new Promise((resolve4) => {
+      if (queue.length > 0) {
+        resolve4(queue.shift());
+        return;
+      }
+      if (ended) {
+        resolve4(null);
+        return;
+      }
+      waiter = resolve4;
+      const t = setTimeout(() => {
+        if (waiter === resolve4) {
+          waiter = null;
+          resolve4(null);
+        }
+      }, Math.max(0, timeoutMs));
+      t.unref?.();
+    })
+  };
+}
+
 // src/scripts/watchStalePrsFlow.ts
 function readWatchConfig(ctx) {
   const cfg = ctx.config.watch;
@@ -7403,7 +8129,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -7425,7 +8151,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs25.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs26.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -7456,12 +8182,14 @@ var preflightScripts = {
   resolveArtifacts,
   discoverQaContext,
   resolvePreviewUrl,
+  resolveQaUrl,
   composePrompt,
   setCommentTarget,
   setLifecycleLabel,
   skipAgent,
   classifyByLabel,
   diagMcp,
+  warmupMcp,
   dispatchJobTicks,
   dispatchJobFileTicks
 };
@@ -7499,6 +8227,7 @@ var postflightScripts = {
   dispatchClassified,
   notifyTerminal,
   openQaIssue,
+  createQaGoal,
   recordOutcome,
   mergeReleasePr,
   waitForCi,
@@ -7510,7 +8239,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync26 } from "child_process";
+import { execFileSync as execFileSync28 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -7543,7 +8272,7 @@ function verifyOne(tool, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync26("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync28("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -7612,9 +8341,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path23.join(input.cwd, ".kody");
+  const ndjsonDir = path24.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path23.isAbsolute(p) ? p : path23.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path24.isAbsolute(p) ? p : path24.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -7709,17 +8438,17 @@ async function runExecutable(profileName, input) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path23.dirname(new URL(import.meta.url).pathname);
+  const here = path24.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path23.join(here, "executables", profileName, "profile.json"),
+    path24.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path23.join(here, "..", "executables", profileName, "profile.json"),
+    path24.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path23.join(here, "..", "src", "executables", profileName, "profile.json")
+    path24.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs26.existsSync(c)) return c;
+    if (fs27.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -7823,8 +8552,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path23.join(profile.dir, shellName);
-  if (!fs26.existsSync(shellPath)) {
+  const shellPath = path24.join(profile.dir, shellName);
+  if (!fs27.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -7840,7 +8569,7 @@ async function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const child = spawn4("bash", [shellPath, ...positional], {
+  const child = spawn5("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -8085,7 +8814,7 @@ async function runContainerLoop(profile, ctx, input) {
 }
 function resetWorkingTree(cwd) {
   try {
-    execFileSync27("git", ["reset", "--hard", "HEAD"], {
+    execFileSync29("git", ["reset", "--hard", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -8237,14 +8966,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs27.existsSync(path24.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs27.existsSync(path24.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs27.existsSync(path24.join(cwd, "bun.lockb"))) return "bun";
+  if (fs28.existsSync(path25.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs28.existsSync(path25.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs28.existsSync(path25.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync28(cmd, args, {
+    execFileSync30(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -8257,7 +8986,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync28("which", [bin], { stdio: "pipe" });
+    execFileSync30("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -8298,7 +9027,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync28("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync30("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -8308,16 +9037,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync28("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync30("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync28("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync30("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync28("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync30("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -8326,11 +9055,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path24.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path25.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs27.existsSync(logPath)) {
-      const content = fs27.readFileSync(logPath, "utf-8");
+    if (fs28.existsSync(logPath)) {
+      const content = fs28.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -8355,7 +9084,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path24.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path25.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -8365,9 +9094,9 @@ async function runCi(argv) {
   const eventName = process.env.GITHUB_EVENT_NAME;
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs27.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs28.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs27.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs28.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       manualWorkflowDispatch = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
@@ -8582,15 +9311,15 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path25.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path25.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs28.existsSync(path25.join(cwd, p)));
+  const sessionFile = path26.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path26.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs29.existsSync(path26.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync29("git", ["add", "-f", ...paths], opts);
-    execFileSync29("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
-    execFileSync29("git", ["push", "--quiet", "origin", "HEAD"], opts);
+    execFileSync31("git", ["add", "-f", ...paths], opts);
+    execFileSync31("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync31("git", ["push", "--quiet", "origin", "HEAD"], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[kody:chat] commit/push skipped: ${msg}
@@ -8622,7 +9351,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path25.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path26.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -8674,7 +9403,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs28.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs29.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {