@kody-ade/kody-engine 0.4.30 → 0.4.32

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.30",
+  version: "0.4.32",
   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 execFileSync30 } from "child_process";
-import * as fs29 from "fs";
-import * as path26 from "path";
+import { execFileSync as execFileSync32 } from "child_process";
+import * as fs30 from "fs";
+import * as path28 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -912,9 +912,9 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 }
 
 // src/kody-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 path27 from "path";
 
 // src/dispatch.ts
 import * as fs7 from "fs";
@@ -1299,9 +1299,9 @@ function coerceBare(spec, value) {
 }
 
 // src/executor.ts
-import { execFileSync as execFileSync28, spawn as spawn5 } from "child_process";
-import * as fs27 from "fs";
-import * as path24 from "path";
+import { execFileSync as execFileSync30, spawn as spawn5 } from "child_process";
+import * as fs28 from "fs";
+import * as path26 from "path";
 
 // src/issue.ts
 import { execFileSync as execFileSync3 } from "child_process";
@@ -2749,6 +2749,301 @@ function defaultLabelMap() {
   };
 }
 
+// src/goal/operations.ts
+import { execFileSync as execFileSync9 } from "child_process";
+
+// src/goal/labels.ts
+function goalLabel(goalId) {
+  return `goal:${goalId}`;
+}
+var DISPATCHED_LABEL = "goal-runner:dispatched";
+var FAILED_LABEL = "goal-runner:failed";
+var UMBRELLA_BUILDING_LABEL = "kody:building";
+var TICK_LABELS = [
+  {
+    name: DISPATCHED_LABEL,
+    color: "ededed",
+    description: "kody goal-runner: already dispatched this tick"
+  },
+  {
+    name: FAILED_LABEL,
+    color: "b60205",
+    description: "kody goal-runner: task failed; needs human attention"
+  }
+];
+
+// src/goal/operations.ts
+function fail(err) {
+  if (err instanceof Error) {
+    const lines = err.message.split("\n").filter(Boolean);
+    return { ok: false, error: lines[0] ?? err.message };
+  }
+  return { ok: false, error: String(err) };
+}
+function listGoalIssues(goalId, excludeIssueNumber, cwd) {
+  try {
+    const out = gh(
+      [
+        "api",
+        `repos/{owner}/{repo}/issues?labels=${goalLabel(goalId)}&state=all&per_page=100`,
+        "--jq",
+        "[.[] | select(.pull_request == null) | {number, state: (.state | ascii_upcase), labels: [.labels[].name]}]"
+      ],
+      { cwd }
+    );
+    const arr = JSON.parse(out);
+    const filtered = excludeIssueNumber !== void 0 ? arr.filter((i) => i.number !== excludeIssueNumber) : arr;
+    return { ok: true, value: filtered };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function ensureLabel(name, color, description, cwd) {
+  try {
+    gh(["label", "create", name, "--color", color, "--description", description, "--force"], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function addLabel2(issueNumber, label, cwd) {
+  try {
+    gh(["issue", "edit", String(issueNumber), "--add-label", label], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function commentOnIssue(issueNumber, body, cwd) {
+  try {
+    gh(["issue", "comment", String(issueNumber), "--body", body], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function closeIssue(issueNumber, options, cwd) {
+  try {
+    if (options.comment) {
+      gh(["issue", "comment", String(issueNumber), "--body", options.comment], { cwd });
+    }
+    const args = ["issue", "close", String(issueNumber)];
+    if (options.reason) args.push("--reason", options.reason);
+    gh(args, { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function getIssueState(issueNumber, cwd) {
+  try {
+    const out = gh(["issue", "view", String(issueNumber), "--json", "state", "--jq", ".state"], {
+      cwd
+    });
+    const norm = out.trim().toUpperCase();
+    if (norm !== "OPEN" && norm !== "CLOSED") {
+      return { ok: false, error: `unexpected state: ${out}` };
+    }
+    return { ok: true, value: norm };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function findUmbrellaByTitle(goalId, title, cwd) {
+  try {
+    const out = gh(
+      [
+        "api",
+        `repos/{owner}/{repo}/issues?labels=${goalLabel(goalId)}&state=all&per_page=100`,
+        "--jq",
+        `[.[] | select(.pull_request == null) | select(.title == "${title.replace(/"/g, '\\"')}")] | (map(select(.state == "open")) + map(select(.state != "open")))[0].number // empty`
+      ],
+      { cwd }
+    );
+    const trimmed = out.trim();
+    if (!trimmed) return { ok: true, value: null };
+    const n = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(n)) return { ok: true, value: null };
+    return { ok: true, value: n };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function createIssue(args, cwd) {
+  try {
+    const cliArgs = ["issue", "create", "--title", args.title, "--body", args.body];
+    for (const l of args.labels) cliArgs.push("--label", l);
+    const url = gh(cliArgs, { cwd });
+    const match = url.match(/\/issues\/(\d+)/);
+    if (!match?.[1]) return { ok: false, error: `couldn't parse issue number from URL: ${url}` };
+    return { ok: true, value: Number.parseInt(match[1], 10) };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function listPrsByBase(base, state, cwd) {
+  try {
+    const out = gh(
+      [
+        "pr",
+        "list",
+        "--base",
+        base,
+        "--state",
+        state,
+        "--limit",
+        "50",
+        "--json",
+        "number,isDraft,mergeable,mergeStateStatus,url,headRefName,body"
+      ],
+      { cwd }
+    );
+    return { ok: true, value: JSON.parse(out) };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function listPrsByHead(head, state, cwd) {
+  try {
+    const out = gh(
+      [
+        "pr",
+        "list",
+        "--head",
+        head,
+        "--state",
+        state,
+        "--json",
+        "number,isDraft,mergeable,mergeStateStatus,url,headRefName,body"
+      ],
+      { cwd }
+    );
+    return { ok: true, value: JSON.parse(out) };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function mergePrSquash(prNumber, cwd) {
+  try {
+    gh(["pr", "merge", String(prNumber), "--squash", "--delete-branch"], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function closePr(prNumber, comment, cwd) {
+  try {
+    gh(["pr", "close", String(prNumber), "--comment", comment], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function createPr(args, cwd) {
+  try {
+    const cli = ["pr", "create", "--head", args.head, "--base", args.base, "--title", args.title, "--body", args.body];
+    if (args.draft) cli.push("--draft");
+    const url = gh(cli, { cwd });
+    if (!url.includes("/pull/")) return { ok: false, error: `gh pr create returned unexpected output: ${url}` };
+    return { ok: true, value: url.trim() };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function editPrBody(prNumber, body, cwd) {
+  try {
+    gh(["pr", "edit", String(prNumber), "--body", body], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function markPrReady(prNumber, cwd) {
+  try {
+    gh(["pr", "ready", String(prNumber)], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function ghTokenEnv() {
+  const token = process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+  return token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+}
+function remoteBranchExists(ref, cwd) {
+  try {
+    execFileSync9("git", ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${ref}`], {
+      cwd,
+      stdio: "pipe",
+      env: ghTokenEnv()
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fetchOrigin(cwd) {
+  try {
+    execFileSync9("git", ["fetch", "origin", "--quiet"], { cwd, stdio: "pipe", env: ghTokenEnv() });
+  } catch {
+  }
+}
+function createBranchFrom(branch, base, cwd) {
+  try {
+    execFileSync9("git", ["push", "origin", `refs/remotes/origin/${base}:refs/heads/${branch}`, "--quiet"], {
+      cwd,
+      stdio: "pipe",
+      env: ghTokenEnv()
+    });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function inferLinkedIssue(pr) {
+  const body = pr.body ?? "";
+  const m = body.match(/\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+#(\d+)\b/i);
+  if (m?.[1]) return Number.parseInt(m[1], 10);
+  const ref = pr.headRefName ?? "";
+  const bm = ref.match(/^(\d+)-/);
+  if (bm?.[1]) return Number.parseInt(bm[1], 10);
+  return void 0;
+}
+
+// src/scripts/closeMergedTaskIssues.ts
+var closeMergedTaskIssues = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const merged = listPrsByBase(goal.goalBranch, "merged", ctx.cwd);
+  if (!merged.ok) {
+    process.stderr.write(`[goal-tick] closeMergedTaskIssues: list failed: ${merged.error}
+`);
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const pr of merged.value ?? []) {
+    const linked = inferLinkedIssue(pr);
+    if (linked === void 0 || seen.has(linked)) continue;
+    seen.add(linked);
+    const stateRes = getIssueState(linked, ctx.cwd);
+    if (!stateRes.ok || stateRes.value !== "OPEN") continue;
+    process.stdout.write(`[goal-tick] closing #${linked} (PR merged into ${goal.goalBranch})
+`);
+    const r = closeIssue(
+      linked,
+      {
+        comment: `_Closed by goal-tick: PR for this task merged into \`${goal.goalBranch}\`._`,
+        reason: "completed"
+      },
+      ctx.cwd
+    );
+    if (!r.ok) {
+      process.stderr.write(`[goal-tick] failed to close #${linked}: ${r.error} (continuing)
+`);
+    }
+  }
+};
+
 // src/scripts/commitAndPush.ts
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
 var commitAndPush2 = async (ctx) => {
@@ -2792,17 +3087,69 @@ var commitAndPush2 = async (ctx) => {
   ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
 };
 
+// src/scripts/commitGoalState.ts
+import { execFileSync as execFileSync10 } from "child_process";
+import * as path12 from "path";
+var commitGoalState = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const stateRel = path12.posix.join(".kody", "goals", goal.id, "state.json");
+  try {
+    execFileSync10("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch (err) {
+    process.stderr.write(
+      `[goal-tick] commitGoalState: git add failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return;
+  }
+  try {
+    execFileSync10("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+    return;
+  } catch {
+  }
+  const msg = describeCommitMessage(goal);
+  try {
+    execFileSync10("git", ["commit", "-m", msg, "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch (err) {
+    process.stderr.write(
+      `[goal-tick] commitGoalState: git commit failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return;
+  }
+  try {
+    execFileSync10("git", ["push", "--quiet"], { cwd: ctx.cwd, stdio: "pipe" });
+  } catch {
+    process.stderr.write("[goal-tick] commitGoalState: push failed (will retry next tick)\n");
+  }
+};
+function describeCommitMessage(goal) {
+  if (goal.state === "closed") return `chore(goals): abandon ${goal.id} (cleanup complete)`;
+  if (goal.state === "done") return `chore(goals): mark ${goal.id} done`;
+  if (goal.lastDispatchedIssue !== void 0) {
+    return `chore(goals): dispatched #${goal.lastDispatchedIssue} for ${goal.id}`;
+  }
+  if (goal.phase === "in-flight") {
+    return `chore(goals): tick ${goal.id} (waiting for in-flight task)`;
+  }
+  if (goal.phase === "blocked-by-failure") {
+    return `chore(goals): tick ${goal.id} (blocked by failed task)`;
+  }
+  return `chore(goals): tick ${goal.id} (idle)`;
+}
+
 // src/scripts/composePrompt.ts
 import * as fs13 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
   const explicit = ctx.data.promptTemplate;
   const mode = ctx.args.mode;
   const candidates = [
-    explicit ? path12.join(profile.dir, explicit) : null,
-    mode ? path12.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path12.join(profile.dir, "prompt.md")
+    explicit ? path13.join(profile.dir, explicit) : null,
+    mode ? path13.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path13.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
@@ -2891,9 +3238,9 @@ function formatToolsUsage(profile) {
 }
 
 // src/scripts/createQaGoal.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import * as fs14 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 
 // src/scripts/postReviewResult.ts
 function detectVerdict(body) {
@@ -3075,7 +3422,7 @@ ${json}
 ${MANIFEST_END}
 `;
 }
-function ensureLabel(name, color, description, cwd) {
+function ensureLabel2(name, color, description, cwd) {
   try {
     gh(["label", "create", name, "--color", color, "--description", description, "--force"], { cwd });
   } catch {
@@ -3095,7 +3442,7 @@ function ensureSeverityLabels(findings, cwd) {
   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);
+    ensureLabel2(severityLabel(f.severity), SEVERITY_COLORS[f.severity], `kody QA finding severity ${f.severity}`, cwd);
   }
 }
 function buildIssueBody(f, goalId, parentManifestNumber) {
@@ -3129,7 +3476,7 @@ function buildIssueBody(f, goalId, parentManifestNumber) {
   return lines.join("\n");
 }
 function createOrUpdateManifestIssue(number, manifest, cwd) {
-  ensureLabel(MANIFEST_LABEL, "8b5cf6", "kody: goals manifest", cwd);
+  ensureLabel2(MANIFEST_LABEL, "8b5cf6", "kody: goals manifest", cwd);
   const body = serializeManifestBody(manifest);
   if (number !== null) {
     gh(["issue", "edit", String(number), "--body-file", "-"], { input: body, cwd });
@@ -3145,7 +3492,7 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path13.join(cwd, ".kody", "goals", goalId);
+  const dir = path14.join(cwd, ".kody", "goals", goalId);
   fs14.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
@@ -3154,7 +3501,7 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path13.join(dir, "state.json");
+  const filePath = path14.join(dir, "state.json");
   fs14.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
@@ -3162,7 +3509,7 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
 function gitTry(args, cwd) {
   const env = { ...process.env, SKIP_HOOKS: "1", HUSKY: "0" };
   try {
-    execFileSync9("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
+    execFileSync11("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env });
     return { ok: true, stderr: "" };
   } catch (err) {
     const e = err;
@@ -3244,8 +3591,8 @@ ${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);
+  ensureLabel2(`goal:${goalId}`, "1d76db", `goal: ${goalId}`, cwd);
+  ensureLabel2(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", "-"];
@@ -3304,7 +3651,7 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
       ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
       return;
     }
-    ensureLabel(FINDING_LABEL, "ededed", "kody: QA finding", ctx.cwd);
+    ensureLabel2(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 = "";
@@ -3434,14 +3781,57 @@ QA_GOAL_TARGETED=(no manifest issue) (id: ${goalId}, verdict: ${verdict})
   ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
 };
 
+// src/goal/phase.ts
+function derivePhase(snap) {
+  if (snap.lifecycleState === void 0) return "missing";
+  if (snap.lifecycleState === "abandoned") return "abandoned";
+  if (snap.lifecycleState === "closed" || snap.lifecycleState === "done") return "terminal";
+  if (snap.childTasks.length === 0) return "no-tasks";
+  const allClosed = snap.childTasks.every((t) => t.state === "CLOSED");
+  if (allClosed) return "all-done";
+  const anyFailed = snap.childTasks.some((t) => t.labels.includes(FAILED_LABEL));
+  if (anyFailed) return "blocked-by-failure";
+  const inFlight = snap.childTasks.some((t) => t.state === "OPEN" && t.labels.includes(DISPATCHED_LABEL));
+  if (inFlight) return "in-flight";
+  const dispatchable = snap.childTasks.some((t) => t.state === "OPEN" && !t.labels.includes(DISPATCHED_LABEL));
+  if (dispatchable) return "ready-to-dispatch";
+  return "idle";
+}
+function pickNextDispatchable(snap) {
+  const candidates = snap.childTasks.filter((t) => t.state === "OPEN" && !t.labels.includes(DISPATCHED_LABEL)).sort((a, b) => a.number - b.number);
+  return candidates[0];
+}
+
+// src/scripts/deriveGoalPhase.ts
+var deriveGoalPhase = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const issues = listGoalIssues(goal.id, goal.goalIssueNumber, ctx.cwd);
+  if (!issues.ok) {
+    process.stderr.write(`[goal-tick] deriveGoalPhase: list failed: ${issues.error}
+`);
+    goal.childTasks = [];
+    goal.phase = "idle";
+    return;
+  }
+  const childTasks = issues.value ?? [];
+  goal.childTasks = childTasks;
+  goal.phase = derivePhase({
+    lifecycleState: goal.state,
+    childTasks
+  });
+  process.stdout.write(`[goal-tick] phase=${goal.phase} goal=${goal.id} tasks=${childTasks.length}
+`);
+};
+
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 import * as fs15 from "fs";
 import * as os3 from "os";
-import * as path14 from "path";
+import * as path15 from "path";
 var diagMcp = async (_ctx) => {
   const home = os3.homedir();
-  const cacheDir = path14.join(home, ".cache", "ms-playwright");
+  const cacheDir = path15.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
     entries = fs15.readdirSync(cacheDir);
@@ -3455,7 +3845,7 @@ var diagMcp = async (_ctx) => {
   process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
   try {
-    const v = execFileSync10("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+    const v = execFileSync12("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
       stdio: "pipe",
       timeout: 6e4,
       encoding: "utf8"
@@ -3471,16 +3861,16 @@ var diagMcp = async (_ctx) => {
 
 // src/scripts/discoverQaContext.ts
 import * as fs17 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 
 // src/scripts/frameworkDetectors.ts
 import * as fs16 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs16.readFileSync(path15.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(path16.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -3517,7 +3907,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs16.existsSync(path15.join(cwd, c))) return c;
+    if (fs16.existsSync(path16.join(cwd, c))) return c;
   }
   return null;
 }
@@ -3530,7 +3920,7 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path15.join(cwd, dir);
+    const full = path16.join(cwd, dir);
     if (!fs16.existsSync(full)) continue;
     let files;
     try {
@@ -3540,7 +3930,7 @@ function discoverPayloadCollections(cwd) {
     }
     for (const file of files) {
       try {
-        const filePath = path15.join(full, file);
+        const filePath = path16.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;
@@ -3555,7 +3945,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path15.relative(cwd, filePath),
+          filePath: path16.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -3569,7 +3959,7 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path15.join(cwd, dir);
+    const full = path16.join(cwd, dir);
     if (!fs16.existsSync(full)) continue;
     let entries;
     try {
@@ -3578,19 +3968,19 @@ function discoverAdminComponents(cwd, collections) {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path15.join(full, entry.name);
+      const entryPath = path16.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs16.existsSync(path15.join(entryPath, f))
+          (f) => fs16.existsSync(path16.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path15.relative(cwd, path15.join(entryPath, indexFile));
+        filePath = path16.relative(cwd, path16.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path15.relative(cwd, entryPath);
+        filePath = path16.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -3598,7 +3988,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs16.readFileSync(path15.join(cwd, col.filePath), "utf-8");
+            const colContent = fs16.readFileSync(path16.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -3617,7 +4007,7 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path15.join(cwd, appDir, "api");
+    const apiDir = path16.join(cwd, appDir, "api");
     if (!fs16.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
@@ -3634,7 +4024,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs16.readFileSync(path15.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs16.readFileSync(path16.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)
       );
@@ -3642,7 +4032,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path15.relative(cwd, path15.join(dir, routeFile.name))
+          filePath: path16.relative(cwd, path16.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -3653,7 +4043,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(path15.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path16.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -3661,7 +4051,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path15.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path16.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -3681,7 +4071,7 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path15.join(cwd, envFile);
+    const envPath = path16.join(cwd, envFile);
     if (!fs16.existsSync(envPath)) continue;
     try {
       const content = fs16.readFileSync(envPath, "utf-8");
@@ -3732,9 +4122,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs17.readFileSync(path16.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs17.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    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";
+    const pm = fs17.existsSync(path17.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs17.existsSync(path17.join(cwd, "yarn.lock")) ? "yarn" : fs17.existsSync(path17.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;
@@ -3744,7 +4134,7 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path16.join(cwd, appDir);
+    const full = path17.join(cwd, appDir);
     if (!fs17.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
@@ -3770,7 +4160,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(path16.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path17.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -3778,7 +4168,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path16.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path17.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -3795,13 +4185,13 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs17.existsSync(path16.join(cwd, c))) out.authFiles.push(c);
+    if (fs17.existsSync(path17.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 = path16.join(cwd, rp);
+    const dir = path17.join(cwd, rp);
     if (!fs17.existsSync(dir)) continue;
     let files;
     try {
@@ -3811,7 +4201,7 @@ function detectRoles(cwd, out) {
     }
     for (const f of files) {
       try {
-        const content = fs17.readFileSync(path16.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs17.readFileSync(path17.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) {
@@ -3957,7 +4347,7 @@ var discoverQaContext = async (ctx) => {
 };
 
 // src/scripts/dispatch.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 var API_TIMEOUT_MS4 = 3e4;
 var dispatch = async (ctx, _profile, _agentResult, args) => {
   const next = args?.next;
@@ -3993,7 +4383,7 @@ var dispatch = async (ctx, _profile, _agentResult, args) => {
   const sub = usePr ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync11("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync13("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS4,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4013,7 +4403,7 @@ function parsePr(url) {
 }
 
 // src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var API_TIMEOUT_MS5 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var dispatchClassified = async (ctx) => {
@@ -4022,7 +4412,7 @@ var dispatchClassified = async (ctx) => {
   const classification = ctx.data.classification;
   if (!classification || !VALID_CLASSES2.has(classification)) return;
   try {
-    execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
+    execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS5,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4043,7 +4433,7 @@ function failedAction3(reason) {
 
 // src/scripts/dispatchJobFileTicks.ts
 import * as fs19 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -4295,7 +4685,7 @@ var ContentsApiBackend = class {
 
 // src/scripts/jobState/localFileBackend.ts
 import * as fs18 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -4310,7 +4700,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 = path17.join(opts.cwd, opts.jobsDir);
+    this.absDir = path18.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -4370,7 +4760,7 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path17.join(this.cwd, relPath);
+    const absPath = path18.join(this.cwd, relPath);
     if (!fs18.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
@@ -4391,8 +4781,8 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path17.join(this.cwd, loaded.path);
-    fs18.mkdirSync(path17.dirname(absPath), { recursive: true });
+    const absPath = path18.join(this.cwd, loaded.path);
+    fs18.mkdirSync(path18.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
     fs18.writeFileSync(absPath, body, "utf-8");
     return true;
@@ -4471,7 +4861,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path18.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path19.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -4570,7 +4960,7 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs19.readFileSync(path18.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs19.readFileSync(path19.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
@@ -4650,6 +5040,134 @@ function listIssuesByLabel(label, cwd) {
   return list.filter((x) => typeof x.number === "number" && typeof x.title === "string").map((x) => ({ number: x.number, title: x.title }));
 }
 
+// src/scripts/dispatchNextTask.ts
+var dispatchNextTask = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal?.childTasks) return;
+  const next = pickNextDispatchable({
+    lifecycleState: goal.state,
+    childTasks: goal.childTasks
+  });
+  if (!next) {
+    process.stdout.write("[goal-tick] no undispatched open task \u2014 idle\n");
+    return;
+  }
+  process.stdout.write(`[goal-tick] dispatching @kody on task #${next.number} (--base ${goal.goalBranch})
+`);
+  const comment = commentOnIssue(next.number, `@kody --base ${goal.goalBranch}`, ctx.cwd);
+  if (!comment.ok) {
+    process.stderr.write(`[goal-tick] dispatchNextTask: comment failed on #${next.number}: ${comment.error}
+`);
+    return;
+  }
+  const label = addLabel2(next.number, DISPATCHED_LABEL, ctx.cwd);
+  if (!label.ok) {
+    process.stderr.write(
+      `[goal-tick] dispatchNextTask: add-label failed on #${next.number}: ${label.error} (continuing \u2014 comment already posted)
+`
+    );
+  }
+  goal.lastDispatchedIssue = next.number;
+};
+
+// src/scripts/ensureGoalBranch.ts
+var ensureGoalBranch = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  fetchOrigin(ctx.cwd);
+  if (remoteBranchExists(goal.goalBranch, ctx.cwd)) {
+    process.stdout.write(`[goal-tick] origin/${goal.goalBranch} already exists \u2014 leaving as-is
+`);
+    return;
+  }
+  if (!remoteBranchExists(goal.defaultBranch, ctx.cwd)) {
+    process.stderr.write(`[goal-tick] cannot create goal branch: origin/${goal.defaultBranch} missing
+`);
+    return;
+  }
+  process.stdout.write(`[goal-tick] creating origin/${goal.goalBranch} from origin/${goal.defaultBranch}
+`);
+  const r = createBranchFrom(goal.goalBranch, goal.defaultBranch, ctx.cwd);
+  if (!r.ok) {
+    process.stderr.write(
+      `[goal-tick] push of ${goal.goalBranch} failed: ${r.error} \u2014 task dispatch will fall back to defaultBranch
+`
+    );
+  }
+};
+
+// src/scripts/ensureGoalPr.ts
+var ensureGoalPr = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  if (goal.goalPrUrl) return;
+  if (!remoteBranchExists(goal.goalBranch, ctx.cwd)) return;
+  const existing = listPrsByHead(goal.goalBranch, "open", ctx.cwd);
+  if (existing.ok && existing.value && existing.value.length > 0) {
+    goal.goalPrUrl = existing.value[0].url;
+    return;
+  }
+  const title = `goal: ${goal.id}`;
+  const body = goal.goalIssueNumber ? `Tracking integration PR for goal **${goal.id}**.
+
+Child task PRs merge into \`${goal.goalBranch}\`. This PR is held in **draft** until every task is complete, then promoted to ready-for-review by goal-tick.
+
+Closes #${goal.goalIssueNumber}
+` : `Tracking integration PR for goal **${goal.id}**.
+
+Child task PRs merge into \`${goal.goalBranch}\`. Held in **draft** until every task is complete.
+`;
+  const created = createPr(
+    {
+      head: goal.goalBranch,
+      base: goal.defaultBranch,
+      title,
+      body,
+      draft: true
+    },
+    ctx.cwd
+  );
+  if (!created.ok) {
+    process.stderr.write(
+      `[goal-tick] ensureGoalPr: gh pr create failed: ${created.error} (continuing without goal PR)
+`
+    );
+    return;
+  }
+  process.stdout.write(`[goal-tick] opened draft goal PR ${created.value} for ${goal.id}
+`);
+  goal.goalPrUrl = created.value;
+};
+
+// src/scripts/ensureLifecycleLabels.ts
+var ensureLifecycleLabels = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  for (const spec of TICK_LABELS) {
+    const r2 = ensureLabel(spec.name, spec.color, spec.description, ctx.cwd);
+    if (!r2.ok) {
+      process.stderr.write(`[goal-tick] ensureLifecycleLabels: ${spec.name}: ${r2.error}
+`);
+    }
+  }
+  const goalLbl = goalLabel(goal.id);
+  const r = ensureLabel(goalLbl, "0e8a16", `kody goal task: belongs to goal ${goal.id}`, ctx.cwd);
+  if (!r.ok) {
+    process.stderr.write(`[goal-tick] ensureLifecycleLabels: ${goalLbl}: ${r.error}
+`);
+  }
+  const u = ensureLabel(
+    UMBRELLA_BUILDING_LABEL,
+    "1d76db",
+    "kody: in-flight (work being assembled on a branch)",
+    ctx.cwd
+  );
+  if (!u.ok) {
+    process.stderr.write(`[goal-tick] ensureLifecycleLabels: ${UMBRELLA_BUILDING_LABEL}: ${u.error}
+`);
+  }
+};
+
 // src/pr.ts
 var TITLE_MAX = 72;
 function stripTitlePrefixes(raw) {
@@ -4786,20 +5304,37 @@ function ensurePr(opts) {
 }
 
 // src/scripts/ensurePr.ts
+function setOutcome(ctx, outcome) {
+  ctx.data.prResult = outcome;
+  if (outcome.kind === "created" || outcome.kind === "updated") {
+    ctx.output.prUrl = outcome.url;
+  }
+}
 var ensurePr2 = async (ctx) => {
   if (ctx.skipAgent && ctx.output.exitCode !== void 0) {
+    setOutcome(ctx, { kind: "skipped", reason: "preflight short-circuited (skipAgent)" });
     return;
   }
   const commitResult = ctx.data.commitResult;
   const hasCommits = Boolean(ctx.data.hasCommitsAhead);
   if (!commitResult?.committed && !hasCommits) {
+    setOutcome(ctx, { kind: "skipped", reason: "no commits to ship" });
     return;
   }
   if (commitResult?.committed && commitResult.pushed === false) {
+    setOutcome(ctx, { kind: "skipped", reason: "local commit succeeded but push failed" });
+    return;
+  }
+  if (ctx.data.verifyOk === false) {
+    const reason = `verify failed: ${ctx.data.verifyReason ?? "unknown"}`;
+    setOutcome(ctx, { kind: "skipped", reason });
     return;
   }
   const branch = ctx.data.branch;
-  if (!branch) return;
+  if (!branch) {
+    setOutcome(ctx, { kind: "skipped", reason: "no branch context (ctx.data.branch missing)" });
+    return;
+  }
   const failureReason = computeFailureReason(ctx);
   const isFailure = failureReason.length > 0;
   const changedFiles = ctx.data.changedFiles ?? [];
@@ -4821,13 +5356,26 @@ var ensurePr2 = async (ctx) => {
       baseBranch,
       cwd: ctx.cwd
     });
-    ctx.output.prUrl = result.url;
-    ctx.data.prResult = result;
+    if (!result.url || result.url.trim().length === 0) {
+      const reason = `gh pr create returned empty URL (action=${result.action}); refusing to claim success`;
+      ctx.data.prCrashReason = reason;
+      ctx.output.exitCode = 4;
+      ctx.output.reason = reason;
+      setOutcome(ctx, { kind: "crashed", reason });
+      return;
+    }
+    setOutcome(ctx, {
+      kind: result.action === "created" ? "created" : "updated",
+      url: result.url,
+      number: result.number,
+      draft: result.draft
+    });
   } catch (err) {
     const reason = `PR creation failed: ${err instanceof Error ? err.message : String(err)}`;
     ctx.data.prCrashReason = reason;
     ctx.output.exitCode = 4;
     ctx.output.reason = reason;
+    setOutcome(ctx, { kind: "crashed", reason });
   }
 };
 function computeFailureReason(ctx) {
@@ -4863,8 +5411,203 @@ function collectExpectedTests(raw) {
   return out;
 }
 
+// src/scripts/ensureUmbrellaIssue.ts
+var ensureUmbrellaIssue = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  if (goal.goalIssueNumber !== void 0) return;
+  const title = `goal: ${goal.id}`;
+  const body = `Umbrella issue for goal **${goal.id}**.
+
+Closed automatically when the goal PR (\`${goal.goalBranch}\` \u2192 \`${goal.defaultBranch}\`) merges.
+`;
+  const existing = findUmbrellaByTitle(goal.id, title, ctx.cwd);
+  if (existing.ok && existing.value !== null && existing.value !== void 0) {
+    process.stdout.write(`[goal-tick] adopted existing umbrella issue #${existing.value} for ${goal.id}
+`);
+    goal.goalIssueNumber = existing.value;
+    return;
+  }
+  const created = createIssue(
+    {
+      title,
+      body,
+      labels: [goalLabel(goal.id), UMBRELLA_BUILDING_LABEL]
+    },
+    ctx.cwd
+  );
+  if (!created.ok) {
+    process.stderr.write(
+      `[goal-tick] ensureUmbrellaIssue: gh issue create failed: ${created.error} \u2014 continuing without umbrella issue
+`
+    );
+    return;
+  }
+  process.stdout.write(`[goal-tick] opened umbrella issue #${created.value} for ${goal.id}
+`);
+  goal.goalIssueNumber = created.value;
+};
+
+// src/goal/state.ts
+import * as fs20 from "fs";
+import * as path20 from "path";
+var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
+var GoalStateError = class extends Error {
+  constructor(path29, message) {
+    super(`Invalid goal state at ${path29}:
+  ${message}`);
+    this.path = path29;
+    this.name = "GoalStateError";
+  }
+  path;
+};
+function parseGoalState(filePath, raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GoalStateError(filePath, "must be a JSON object");
+  }
+  const r = raw;
+  const stateValue = r.state;
+  if (typeof stateValue !== "string" || !VALID_STATES.has(stateValue)) {
+    throw new GoalStateError(
+      filePath,
+      `"state" is required and must be one of: ${[...VALID_STATES].join(" | ")} (got ${JSON.stringify(stateValue)})`
+    );
+  }
+  const parsed = {
+    state: stateValue,
+    extra: {}
+  };
+  if (typeof r.goalIssueNumber === "number" && Number.isFinite(r.goalIssueNumber)) {
+    parsed.goalIssueNumber = r.goalIssueNumber;
+  }
+  if (typeof r.lastDispatchedIssue === "number" && Number.isFinite(r.lastDispatchedIssue)) {
+    parsed.lastDispatchedIssue = r.lastDispatchedIssue;
+  }
+  if (typeof r.goalPrUrl === "string" && r.goalPrUrl.length > 0) {
+    parsed.goalPrUrl = r.goalPrUrl;
+  }
+  for (const ts of ["updatedAt", "createdAt", "startedAt", "completedAt"]) {
+    const v = r[ts];
+    if (typeof v === "string" && v.length > 0) parsed[ts] = v;
+  }
+  const known = /* @__PURE__ */ new Set([
+    "state",
+    "goalIssueNumber",
+    "lastDispatchedIssue",
+    "goalPrUrl",
+    "updatedAt",
+    "createdAt",
+    "startedAt",
+    "completedAt"
+  ]);
+  for (const [k, v] of Object.entries(r)) {
+    if (!known.has(k)) parsed.extra[k] = v;
+  }
+  return parsed;
+}
+function serializeGoalState(s) {
+  const obj = { ...s.extra, state: s.state };
+  if (s.goalIssueNumber !== void 0) obj.goalIssueNumber = s.goalIssueNumber;
+  if (s.lastDispatchedIssue !== void 0) obj.lastDispatchedIssue = s.lastDispatchedIssue;
+  if (s.goalPrUrl !== void 0) obj.goalPrUrl = s.goalPrUrl;
+  if (s.createdAt !== void 0) obj.createdAt = s.createdAt;
+  if (s.startedAt !== void 0) obj.startedAt = s.startedAt;
+  if (s.completedAt !== void 0) obj.completedAt = s.completedAt;
+  if (s.updatedAt !== void 0) obj.updatedAt = s.updatedAt;
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function goalStatePath(cwd, goalId) {
+  return path20.join(cwd, ".kody", "goals", goalId, "state.json");
+}
+function readGoalState(cwd, goalId) {
+  const file = goalStatePath(cwd, goalId);
+  if (!fs20.existsSync(file)) {
+    throw new GoalStateError(file, "file not found");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs20.readFileSync(file, "utf-8"));
+  } catch (err) {
+    throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return parseGoalState(file, raw);
+}
+function writeGoalState(cwd, goalId, state) {
+  const file = goalStatePath(cwd, goalId);
+  fs20.mkdirSync(path20.dirname(file), { recursive: true });
+  fs20.writeFileSync(file, serializeGoalState(state), "utf-8");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+// src/scripts/finalizeGoal.ts
+var finalizeGoal = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  process.stdout.write(`[goal-tick] all task(s) closed \u2014 finalising goal ${goal.id}
+`);
+  if (!remoteBranchExists(goal.goalBranch, ctx.cwd)) {
+    process.stderr.write(`[goal-tick] goal branch ${goal.goalBranch} not found on origin \u2014 skipping final PR
+`);
+    finishState(goal);
+    return;
+  }
+  const title = `goal: ${goal.id}`;
+  const closesLine = goal.goalIssueNumber ? `
+
+Closes #${goal.goalIssueNumber}
+` : "\n";
+  const body = `Final integration PR for goal **${goal.id}**.
+
+All task issues are closed and merged into \`${goal.goalBranch}\`. Ready for review.${closesLine}`;
+  const existing = listPrsByHead(goal.goalBranch, "open", ctx.cwd);
+  if (existing.ok && existing.value && existing.value.length > 0) {
+    const pr = existing.value[0];
+    goal.goalPrUrl = pr.url;
+    const edit = editPrBody(pr.number, body, ctx.cwd);
+    if (!edit.ok) {
+      process.stderr.write(`[goal-tick] finalizeGoal: editPrBody failed: ${edit.error}
+`);
+    }
+    if (pr.isDraft) {
+      process.stdout.write(`[goal-tick] promoting draft goal PR #${pr.number} to ready-for-review
+`);
+      const ready = markPrReady(pr.number, ctx.cwd);
+      if (!ready.ok) {
+        process.stderr.write(`[goal-tick] finalizeGoal: markPrReady failed: ${ready.error}
+`);
+      }
+    }
+  } else {
+    const created = createPr(
+      {
+        head: goal.goalBranch,
+        base: goal.defaultBranch,
+        title,
+        body,
+        // ready-for-review (not draft) since we're finalizing.
+        draft: false
+      },
+      ctx.cwd
+    );
+    if (!created.ok) {
+      process.stderr.write(`[goal-tick] finalizeGoal: gh pr create failed: ${created.error}
+`);
+    } else {
+      goal.goalPrUrl = created.value;
+    }
+  }
+  finishState(goal);
+};
+function finishState(goal) {
+  goal.state = "done";
+  goal.completedAt = nowIso();
+}
+
 // src/scripts/finishFlow.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 var API_TIMEOUT_MS6 = 3e4;
 var STATUS_ICON = {
   "review-passed": "\u2705",
@@ -4898,7 +5641,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 **PR:** ${state.core.prUrl}` : "";
   const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
   try {
-    execFileSync13("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4912,7 +5655,7 @@ var finishFlow = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/branch.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync16 } 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`);
@@ -4922,7 +5665,7 @@ var UncommittedChangesError = class extends Error {
   branch;
 };
 function git2(args, cwd) {
-  return execFileSync14("git", args, {
+  return execFileSync16("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -4947,7 +5690,7 @@ function checkoutPrBranch(prNumber, cwd) {
     SKIP_HOOKS: "1",
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
-  execFileSync14("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync16("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -5061,8 +5804,8 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
 }
 
 // src/gha.ts
-import { execFileSync as execFileSync15 } from "child_process";
-import * as fs20 from "fs";
+import { execFileSync as execFileSync17 } from "child_process";
+import * as fs21 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -5073,10 +5816,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs20.existsSync(eventPath)) return;
+  if (!eventPath || !fs21.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs20.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs21.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -5104,7 +5847,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync15("gh", args, opts);
+      execFileSync17("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -5117,13 +5860,13 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync15("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync17("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
 
 // src/workflow.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
@@ -5131,7 +5874,7 @@ function ghToken3() {
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync16("gh", args, {
+  return execFileSync18("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -5314,24 +6057,63 @@ function tryPostPr2(prNumber, body, cwd) {
   }
 }
 
+// src/scripts/handleAbandonedGoal.ts
+var handleAbandonedGoal = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal || goal.state !== "abandoned") return;
+  process.stdout.write(`[goal-tick] ${goal.id} is abandoned \u2014 running cleanup
+`);
+  const issues = listGoalIssues(goal.id, goal.goalIssueNumber, ctx.cwd);
+  if (!issues.ok) {
+    process.stderr.write(`[goal-tick] handleAbandonedGoal: list failed: ${issues.error}
+`);
+  } else {
+    for (const i of issues.value ?? []) {
+      if (i.state !== "OPEN") continue;
+      const r = closeIssue(
+        i.number,
+        {
+          comment: "_Goal abandoned \u2014 closing this task without dispatch._",
+          reason: "not planned"
+        },
+        ctx.cwd
+      );
+      if (!r.ok) {
+        process.stderr.write(`[goal-tick] handleAbandonedGoal: failed to close #${i.number}: ${r.error}
+`);
+      }
+    }
+  }
+  const goalPrs = listPrsByHead(goal.goalBranch, "open", ctx.cwd);
+  if (goalPrs.ok && goalPrs.value && goalPrs.value.length > 0) {
+    const pr = goalPrs.value[0];
+    const r = closePr(pr.number, "_Goal abandoned by operator \u2014 closing without merge._", ctx.cwd);
+    if (!r.ok) {
+      process.stderr.write(`[goal-tick] handleAbandonedGoal: failed to close goal PR #${pr.number}: ${r.error}
+`);
+    }
+  }
+  goal.state = "closed";
+};
+
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync17 } from "child_process";
-import * as fs22 from "fs";
-import * as path20 from "path";
+import { execFileSync as execFileSync19 } from "child_process";
+import * as fs23 from "fs";
+import * as path22 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path19.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs21.existsSync(full)) {
+  const full = path21.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs22.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs21.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs22.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -5341,9 +6123,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  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";
+  if (fs23.existsSync(path22.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs23.existsSync(path22.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs23.existsSync(path22.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -5356,7 +6138,7 @@ function qualityCommandsFor(pm) {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync17("git", ["remote", "get-url", "origin"], {
+    url = execFileSync19("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -5441,7 +6223,7 @@ jobs:
 `;
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync17("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync19("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -5449,7 +6231,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync17("git", ["branch", "--show-current"], {
+      return execFileSync19("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -5465,48 +6247,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path20.join(cwd, "kody.config.json");
-  if (fs22.existsSync(configPath) && !force) {
+  const configPath = path22.join(cwd, "kody.config.json");
+  if (fs23.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs22.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs23.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path20.join(cwd, ".github", "workflows");
-  const workflowPath = path20.join(workflowDir, "kody.yml");
-  if (fs22.existsSync(workflowPath) && !force) {
+  const workflowDir = path22.join(cwd, ".github", "workflows");
+  const workflowPath = path22.join(workflowDir, "kody.yml");
+  if (fs23.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs22.mkdirSync(workflowDir, { recursive: true });
-    fs22.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs23.mkdirSync(workflowDir, { recursive: true });
+    fs23.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs22.existsSync(path20.join(cwd, "src/app")) || fs22.existsSync(path20.join(cwd, "app")) || fs22.existsSync(path20.join(cwd, "pages"));
+  const hasUi = fs23.existsSync(path22.join(cwd, "src/app")) || fs23.existsSync(path22.join(cwd, "app")) || fs23.existsSync(path22.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path20.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs22.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path22.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs23.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs22.mkdirSync(path20.dirname(qaGuidePath), { recursive: true });
+      fs23.mkdirSync(path22.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs22.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs23.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path20.join(cwd, ".kody", "jobs");
-    fs22.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path22.join(cwd, ".kody", "jobs");
+    fs23.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path20.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path20.join(cwd, rel);
-      if (fs22.existsSync(target) && !force) {
+      const rel = path22.join(".kody", "jobs", `${job.slug}.md`);
+      const target = path22.join(cwd, rel);
+      if (fs23.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs22.writeFileSync(target, fs22.readFileSync(job.filePath, "utf-8"));
+      fs23.writeFileSync(target, fs23.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -5518,12 +6300,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path20.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs22.existsSync(target) && !force) {
+    const target = path22.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs23.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs22.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs23.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -5611,6 +6393,48 @@ var loadCoverageRules = async (ctx) => {
   ctx.data.coverageRules = ctx.config.testRequirements ?? [];
 };
 
+// src/scripts/loadGoalState.ts
+var loadGoalState = async (ctx) => {
+  const goalId = ctx.args.goal;
+  if (typeof goalId !== "string" || goalId.length === 0) {
+    ctx.skipAgent = true;
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "missing --goal";
+    return;
+  }
+  if (goalId.includes("/") || goalId.includes("..")) {
+    ctx.skipAgent = true;
+    ctx.output.exitCode = 1;
+    ctx.output.reason = "invalid goal id (no slashes or '..' allowed)";
+    return;
+  }
+  try {
+    const state = readGoalState(ctx.cwd, goalId);
+    ctx.data.goal = {
+      id: goalId,
+      state: state.state,
+      goalIssueNumber: state.goalIssueNumber,
+      lastDispatchedIssue: state.lastDispatchedIssue,
+      goalPrUrl: state.goalPrUrl,
+      // Cache the full parsed object so saveGoalState can preserve `extra`.
+      raw: state,
+      // `phase` is populated by deriveGoalPhase later in the chain. Initialize
+      // to undefined so runWhen on `data.goal.phase` can match correctly.
+      phase: void 0,
+      // Populated by ensureGoalBranch / configured by config.git.defaultBranch.
+      defaultBranch: ctx.config.git.defaultBranch,
+      // Convenience derivations.
+      goalBranch: `goal-${goalId}`
+    };
+  } catch (err) {
+    process.stdout.write(`[goal-tick] ${err instanceof Error ? err.message : String(err)}
+`);
+    ctx.skipAgent = true;
+    ctx.output.exitCode = 0;
+    ctx.output.reason = "no goal state to tick";
+  }
+};
+
 // src/scripts/loadIssueContext.ts
 var DEFAULT_COMMENT_LIMIT = 12;
 var DEFAULT_COMMENT_MAX_BYTES = 16e3;
@@ -5661,8 +6485,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const slugArg = String(args?.slugArg ?? "job");
@@ -5670,11 +6494,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path21.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs23.existsSync(absPath)) {
+  const absPath = path23.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs24.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs23.readFileSync(absPath, "utf-8");
+  const raw = fs24.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);
@@ -5706,16 +6530,16 @@ function humanizeSlug(slug) {
 }
 
 // src/scripts/loadMemoryContext.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 var MEMORY_DIR_RELATIVE = ".kody/memory";
 var MAX_PAGES = 8;
 var PER_PAGE_MAX_BYTES = 4e3;
 var TOTAL_MAX_BYTES = 24e3;
 var TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
 var loadMemoryContext = async (ctx) => {
-  const memoryAbs = path22.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-  if (!fs24.existsSync(memoryAbs)) {
+  const memoryAbs = path24.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+  if (!fs25.existsSync(memoryAbs)) {
     ctx.data.memoryContext = "";
     return;
   }
@@ -5740,21 +6564,21 @@ function collectPages(memoryAbs) {
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs24.statSync(file);
+      stat = fs25.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs24.readFileSync(file, "utf-8");
+      raw = fs25.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() ?? path22.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path24.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path22.relative(memoryAbs, file),
+      relPath: path24.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -5822,16 +6646,16 @@ function walkMd(root, visit) {
     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 = path24.join(dir, name);
       let stat;
       try {
-        stat = fs24.statSync(full);
+        stat = fs25.statSync(full);
       } catch {
         continue;
       }
@@ -5954,8 +6778,32 @@ var markFlowSuccess = async (ctx) => {
   }
 };
 
+// src/scripts/mergeReadyTaskPRs.ts
+var mergeReadyTaskPRs = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) return;
+  const open = listPrsByBase(goal.goalBranch, "open", ctx.cwd);
+  if (!open.ok) {
+    process.stderr.write(`[goal-tick] mergeReadyTaskPRs: list failed: ${open.error}
+`);
+    return;
+  }
+  for (const pr of open.value ?? []) {
+    if (pr.isDraft) continue;
+    if (pr.mergeable !== "MERGEABLE") continue;
+    if (pr.mergeStateStatus !== "CLEAN") continue;
+    process.stdout.write(`[goal-tick] merging PR #${pr.number} into ${goal.goalBranch}
+`);
+    const r = mergePrSquash(pr.number, ctx.cwd);
+    if (!r.ok) {
+      process.stderr.write(`[goal-tick] failed to merge PR #${pr.number}: ${r.error} (continuing)
+`);
+    }
+  }
+};
+
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 var API_TIMEOUT_MS7 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -5974,7 +6822,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 = execFileSync20("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS7,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6092,7 +6940,7 @@ function buildIssueTitle(scope, verdict) {
   const verdictTag = verdict === "UNKNOWN" ? "REPORT" : verdict;
   return `QA [${verdictTag}]: ${focus} \u2014 ${date}`.slice(0, 240);
 }
-function ensureLabel2(cwd) {
+function ensureLabel3(cwd) {
   try {
     gh(["label", "create", QA_LABEL, "--color", "8b5cf6", "--description", "kody: QA report", "--force"], { cwd });
     return true;
@@ -6152,7 +7000,7 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
   }
   const scope = ctx.args.scope;
   const title = buildIssueTitle(scope, verdict);
-  const hasLabel = ensureLabel2(ctx.cwd);
+  const hasLabel = ensureLabel3(ctx.cwd);
   let created;
   try {
     created = createQaIssue(title, reportBody, hasLabel, ctx.cwd);
@@ -6417,6 +7265,22 @@ var persistFlowState = async (ctx) => {
   }
 };
 
+// src/scripts/prOutcome.ts
+function readPrOutcome(data) {
+  const raw = data.prResult;
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  switch (r.kind) {
+    case "created":
+    case "updated":
+    case "skipped":
+    case "crashed":
+      return raw;
+    default:
+      return null;
+  }
+}
+
 // src/scripts/postIssueComment.ts
 var FAILED_LABEL_SPEC = {
   label: "kody:failed",
@@ -6430,8 +7294,7 @@ var postIssueComment2 = async (ctx) => {
   if (!targetType || !targetNumber) return;
   const commitResult = ctx.data.commitResult;
   const hasCommits = Boolean(ctx.data.hasCommitsAhead);
-  const prUrl = ctx.output.prUrl;
-  const prAction = ctx.data.prResult?.action;
+  const prResult = readPrOutcome(ctx.data);
   if (!commitResult?.committed && !hasCommits) {
     const specific = computeFailureReason2(ctx);
     const reason = specific.length > 0 ? specific : "no changes to commit";
@@ -6449,18 +7312,17 @@ var postIssueComment2 = async (ctx) => {
   }
   const failureReason = computeFailureReason2(ctx);
   const isFailure = failureReason.length > 0;
-  const justPushedToExistingPr = prAction === "updated" && commitResult?.committed === true;
-  const successMsg = justPushedToExistingPr ? `\u2705 kody pushed to ${prUrl}` : prAction === "updated" ? `\u2139\uFE0F kody made no changes \u2014 PR: ${prUrl}` : `\u2705 kody PR opened: ${prUrl}`;
   const branch = ctx.data.branch;
-  const failurePrSuffix = computeFailureSuffix({
-    prUrl,
-    prAction,
+  const msg = renderMessage({
+    prResult,
+    isFailure,
+    failureReason,
+    justPushedToExistingPr: prResult?.kind === "updated" && commitResult?.committed === true,
     branch,
     branchPushed: commitResult?.committed === true,
     githubOwner: ctx.config.github?.owner,
     githubRepo: ctx.config.github?.repo
   });
-  const msg = isFailure ? `\u26A0\uFE0F kody FAILED: ${truncate2(failureReason, 1500)}${failurePrSuffix}` : successMsg;
   postWith(targetType, targetNumber, msg, ctx.cwd);
   let exitCode = 0;
   const agentDone = Boolean(ctx.data.agentDone);
@@ -6484,12 +7346,29 @@ function markRunFailed(ctx) {
   }
 }
 function computeFailureSuffix(input) {
-  if (input.prUrl) {
-    return input.prAction === "updated" ? ` \u2014 PR: ${input.prUrl}` : ` \u2014 draft PR: ${input.prUrl}`;
-  }
+  if (input.prResult?.kind === "created") return ` \u2014 draft PR: ${input.prResult.url}`;
+  if (input.prResult?.kind === "updated") return ` \u2014 PR: ${input.prResult.url}`;
   if (!input.branchPushed || !input.branch || !input.githubOwner || !input.githubRepo) return "";
   return ` \u2014 branch: https://github.com/${input.githubOwner}/${input.githubRepo}/tree/${input.branch}`;
 }
+function renderMessage(input) {
+  const suffix = computeFailureSuffix(input);
+  if (input.isFailure) {
+    return `\u26A0\uFE0F kody FAILED: ${truncate2(input.failureReason, 1500)}${suffix}`;
+  }
+  switch (input.prResult?.kind) {
+    case "created":
+      return `\u2705 kody PR opened: ${input.prResult.url}`;
+    case "updated":
+      return input.justPushedToExistingPr ? `\u2705 kody pushed to ${input.prResult.url}` : `\u2139\uFE0F kody made no changes \u2014 PR: ${input.prResult.url}`;
+    case "skipped":
+      return `\u26A0\uFE0F kody finished but did not open a PR \u2014 ${input.prResult.reason}${suffix}`;
+    case "crashed":
+      return `\u26A0\uFE0F kody PR step crashed: ${truncate2(input.prResult.reason, 1500)}${suffix}`;
+    case void 0:
+      return `\u26A0\uFE0F kody finished but PR step did not run${suffix}`;
+  }
+}
 function computeFailureReason2(ctx) {
   const misses = ctx.data.coverageMisses ?? [];
   if (misses.length > 0) return `missing tests: ${misses.map((m) => m.expectedTest).join(", ")}`;
@@ -6557,7 +7436,7 @@ ${body}`;
 }
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var VALID_CLASSES3 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var recordClassification = async (ctx) => {
@@ -6605,7 +7484,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync19("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync21("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS8,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6644,14 +7523,14 @@ var requireFeedbackActions = async (ctx, profile) => {
   const items = countActionItems(actions);
   ctx.data.feedbackAgentItemCount = items;
   if (items < MIN_ITEMS) {
-    fail(
+    fail2(
       ctx,
       profile,
       actions.length === 0 ? "agent omitted required FEEDBACK_ACTIONS block \u2014 cannot verify that review feedback was addressed" : "agent FEEDBACK_ACTIONS block listed no items \u2014 cannot verify that review feedback was addressed"
     );
   }
 };
-function fail(ctx, profile, reason) {
+function fail2(ctx, profile, reason) {
   ctx.data.agentDone = false;
   ctx.data.agentFailureReason = reason;
   const modeSeg = profile.name.replace(/-/g, "_").toUpperCase();
@@ -6728,7 +7607,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -6798,7 +7677,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync20("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync22("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -6813,7 +7692,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 = execFileSync22("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -6914,10 +7793,10 @@ var resolvePreviewUrl = async (ctx) => {
 };
 
 // src/scripts/resolveQaUrl.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 function ghQuery(args, cwd) {
   try {
-    const out = execFileSync21("gh", args, {
+    const out = execFileSync23("gh", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
@@ -6987,7 +7866,7 @@ var resolveQaUrl = async (ctx) => {
 };
 
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 var SHA_RE = /^[0-9a-f]{4,40}$/i;
 var revertFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -7069,7 +7948,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git3(args, cwd) {
-  return execFileSync22("git", args, {
+  return execFileSync24("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -7079,7 +7958,7 @@ function git3(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync22("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync24("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -7175,17 +8054,17 @@ function resolveBaseOverride(value) {
 }
 function resolveBaseFromLabels(labels) {
   if (!labels.includes("goal-runner:dispatched")) return null;
-  const goalLabel = labels.find((l) => l.startsWith("goal:"));
-  if (!goalLabel) return null;
-  const goalId = goalLabel.slice("goal:".length);
+  const goalLabel2 = labels.find((l) => l.startsWith("goal:"));
+  if (!goalLabel2) return null;
+  const goalId = goalLabel2.slice("goal:".length);
   if (!/^[a-z0-9-]+$/.test(goalId)) return null;
   return `goal-${goalId}`;
 }
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -7197,13 +8076,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path23.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs25.existsSync(jobPath)) {
+  const jobPath = path25.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs26.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs25.readFileSync(jobPath, "utf-8");
+  const raw = fs26.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -7211,8 +8090,8 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
     return;
   }
-  const scriptPath = path23.isAbsolute(tickScript) ? tickScript : path23.join(ctx.cwd, tickScript);
-  if (!fs25.existsSync(scriptPath)) {
+  const scriptPath = path25.isAbsolute(tickScript) ? tickScript : path25.join(ctx.cwd, tickScript);
+  if (!fs26.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -7313,6 +8192,26 @@ function buildChildEnv(parent, force) {
   return out;
 }
 
+// src/scripts/saveGoalState.ts
+var saveGoalState = async (ctx) => {
+  const goal = ctx.data.goal;
+  if (!goal) {
+    ctx.skipAgent = true;
+    return;
+  }
+  const updated = {
+    ...goal.raw ?? { state: goal.state, extra: {} },
+    state: goal.state,
+    goalIssueNumber: goal.goalIssueNumber,
+    lastDispatchedIssue: goal.lastDispatchedIssue,
+    goalPrUrl: goal.goalPrUrl,
+    completedAt: goal.completedAt ?? goal.raw?.completedAt,
+    updatedAt: nowIso()
+  };
+  writeGoalState(ctx.cwd, goal.id, updated);
+  ctx.skipAgent = true;
+};
+
 // src/scripts/saveTaskState.ts
 var saveTaskState = async (ctx, profile) => {
   const target = ctx.data.commentTargetType;
@@ -7388,11 +8287,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync23("git", ["add", "-A"], {
+    execFileSync25("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -7402,7 +8301,7 @@ var stageMergeConflicts = async (ctx) => {
 };
 
 // src/scripts/startFlow.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -7436,7 +8335,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync24("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync26("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS9,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7450,7 +8349,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync27 } from "child_process";
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
   const prNumber = ctx.args.pr;
@@ -7522,7 +8421,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync25("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync27("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -7530,9 +8429,9 @@ function revParseHead(cwd) {
 function pushBranch(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync25("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync27("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
   } catch {
-    execFileSync25("git", ["push", "--force-with-lease", "-u", "origin", branch], {
+    execFileSync27("git", ["push", "--force-with-lease", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -7759,7 +8658,7 @@ function downgrade2(ctx, reason) {
 }
 
 // src/scripts/waitForCi.ts
-import { execFileSync as execFileSync26 } from "child_process";
+import { execFileSync as execFileSync28 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -7837,7 +8736,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync26("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync28("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS10,
       cwd,
@@ -8095,7 +8994,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -8117,7 +9016,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs26.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs27.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -8156,7 +9055,19 @@ var preflightScripts = {
   warmupMcp,
   dispatchJobTicks,
   dispatchJobFileTicks,
-  runTickScript
+  runTickScript,
+  loadGoalState,
+  handleAbandonedGoal,
+  ensureLifecycleLabels,
+  ensureUmbrellaIssue,
+  ensureGoalPr,
+  mergeReadyTaskPRs,
+  closeMergedTaskIssues,
+  deriveGoalPhase,
+  ensureGoalBranch,
+  dispatchNextTask,
+  finalizeGoal,
+  saveGoalState
 };
 var postflightScripts = {
   parseAgentResult: parseAgentResult2,
@@ -8195,7 +9106,8 @@ var postflightScripts = {
   recordOutcome,
   mergeReleasePr,
   waitForCi,
-  markFlowSuccess
+  markFlowSuccess,
+  commitGoalState
 };
 var allScriptNames = /* @__PURE__ */ new Set([
   ...Object.keys(preflightScripts),
@@ -8203,7 +9115,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync27 } from "child_process";
+import { execFileSync as execFileSync29 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -8236,7 +9148,7 @@ function verifyOne(tool, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync27("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync29("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -8305,9 +9217,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path24.join(input.cwd, ".kody");
+  const ndjsonDir = path26.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path24.isAbsolute(p) ? p : path24.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path26.isAbsolute(p) ? p : path26.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -8416,17 +9328,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path24.dirname(new URL(import.meta.url).pathname);
+  const here = path26.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path24.join(here, "executables", profileName, "profile.json"),
+    path26.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path24.join(here, "..", "executables", profileName, "profile.json"),
+    path26.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path24.join(here, "..", "src", "executables", profileName, "profile.json")
+    path26.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs27.existsSync(c)) return c;
+    if (fs28.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -8530,8 +9442,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path24.join(profile.dir, shellName);
-  if (!fs27.existsSync(shellPath)) {
+  const shellPath = path26.join(profile.dir, shellName);
+  if (!fs28.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -8792,7 +9704,7 @@ async function runContainerLoop(profile, ctx, input) {
 }
 function resetWorkingTree(cwd) {
   try {
-    execFileSync28("git", ["reset", "--hard", "HEAD"], {
+    execFileSync30("git", ["reset", "--hard", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -8944,14 +9856,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  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";
+  if (fs29.existsSync(path27.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs29.existsSync(path27.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs29.existsSync(path27.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync29(cmd, args, {
+    execFileSync31(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -8964,7 +9876,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync29("which", [bin], { stdio: "pipe" });
+    execFileSync31("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -9005,7 +9917,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync29("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync31("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -9015,16 +9927,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync29("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync31("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync29("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync31("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync29("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync31("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -9033,11 +9945,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path25.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path27.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs28.existsSync(logPath)) {
-      const content = fs28.readFileSync(logPath, "utf-8");
+    if (fs29.existsSync(logPath)) {
+      const content = fs29.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -9062,7 +9974,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path25.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path27.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -9072,9 +9984,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 && fs28.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs29.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs28.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs29.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);
@@ -9289,15 +10201,15 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  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)));
+  const sessionFile = path28.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path28.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs30.existsSync(path28.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync30("git", ["add", "-f", ...paths], opts);
-    execFileSync30("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
-    execFileSync30("git", ["push", "--quiet", "origin", "HEAD"], opts);
+    execFileSync32("git", ["add", "-f", ...paths], opts);
+    execFileSync32("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync32("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}
@@ -9329,7 +10241,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path26.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path28.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -9381,7 +10293,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs29.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs30.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {