@kody-ade/kody-engine 0.4.40 → 0.4.42

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.40",
+  version: "0.4.42",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -52,8 +52,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -417,6 +417,9 @@ async function runAgent(opts) {
   const resultTexts = [];
   let outcome = "failed";
   let errorMessage;
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+  let messageCount = 0;
+  const startedAt = Date.now();
   try {
     const queryOptions = {
       model: opts.model.model,
@@ -454,6 +457,7 @@ async function runAgent(opts) {
       options: queryOptions
     });
     for await (const msg of result) {
+      messageCount++;
       try {
         fullLog.write(`${JSON.stringify(msg)}
 `);
@@ -463,6 +467,17 @@ async function runAgent(opts) {
       if (line) process.stdout.write(`${line}
 `);
       const m = msg;
+      const usage = m.usage;
+      if (usage && typeof usage === "object") {
+        const i = Number(usage.input_tokens ?? 0);
+        const o = Number(usage.output_tokens ?? 0);
+        const cr = Number(usage.cache_read_input_tokens ?? 0);
+        const cc = Number(usage.cache_creation_input_tokens ?? 0);
+        if (Number.isFinite(i)) tokens.input += i;
+        if (Number.isFinite(o)) tokens.output += o;
+        if (Number.isFinite(cr)) tokens.cacheRead += cr;
+        if (Number.isFinite(cc)) tokens.cacheCreate += cc;
+      }
       if (m.type === "result") {
         if (m.subtype === "success") {
           outcome = "completed";
@@ -484,7 +499,15 @@ async function runAgent(opts) {
     }
   }
   const finalText = resultTexts.join("\n\n---\n\n");
-  return { outcome, finalText, error: errorMessage, ndjsonPath };
+  return {
+    outcome,
+    finalText,
+    error: errorMessage,
+    ndjsonPath,
+    durationMs: Date.now() - startedAt,
+    tokens,
+    messageCount
+  };
 }
 
 // src/chat/session.ts
@@ -913,8 +936,8 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 
 // src/dispatch.ts
 import * as fs7 from "fs";
@@ -1493,12 +1516,75 @@ function postPrReviewComment(prNumber, body, cwd) {
 
 // src/executor.ts
 import { execFileSync as execFileSync29, spawn as spawn5 } from "child_process";
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 
-// src/profile.ts
+// src/events.ts
+import * as crypto from "crypto";
 import * as fs8 from "fs";
 import * as path7 from "path";
+var cachedRunId = null;
+function resolveRunId() {
+  if (cachedRunId) return cachedRunId;
+  if (process.env.KODY_RUN_ID) {
+    cachedRunId = process.env.KODY_RUN_ID;
+    return cachedRunId;
+  }
+  if (process.env.GITHUB_RUN_ID) {
+    const attempt = process.env.GITHUB_RUN_ATTEMPT ?? "1";
+    cachedRunId = `gh-${process.env.GITHUB_RUN_ID}-${attempt}`;
+  } else {
+    cachedRunId = `${Date.now().toString(36)}-${crypto.randomBytes(4).toString("hex")}`;
+  }
+  process.env.KODY_RUN_ID = cachedRunId;
+  return cachedRunId;
+}
+function emitEvent(cwd, ev) {
+  if (process.env.KODY_EVENTS === "0") return;
+  try {
+    const runId = resolveRunId();
+    const fullEvent = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      runId,
+      ...ev
+    };
+    const eventsPath = path7.join(cwd, ".kody", "runs", runId, "events.jsonl");
+    fs8.mkdirSync(path7.dirname(eventsPath), { recursive: true });
+    fs8.appendFileSync(eventsPath, `${JSON.stringify(fullEvent)}
+`);
+  } catch {
+  }
+}
+function readEvents(cwd, runId) {
+  const eventsPath = path7.join(cwd, ".kody", "runs", runId, "events.jsonl");
+  if (!fs8.existsSync(eventsPath)) return [];
+  const lines = fs8.readFileSync(eventsPath, "utf-8").split("\n");
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function listRuns(cwd) {
+  const runsDir = path7.join(cwd, ".kody", "runs");
+  if (!fs8.existsSync(runsDir)) return [];
+  return fs8.readdirSync(runsDir).filter((name) => {
+    try {
+      return fs8.statSync(path7.join(runsDir, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+
+// src/profile.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
 var VALID_INPUT_TYPES = /* @__PURE__ */ new Set(["int", "string", "bool", "enum"]);
 var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["primitive", "orchestrator", "container", "watch", "utility"]);
@@ -1514,12 +1600,12 @@ var ProfileError = class extends Error {
   profilePath;
 };
 function loadProfile(profilePath) {
-  if (!fs8.existsSync(profilePath)) {
+  if (!fs9.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs9.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1558,7 +1644,7 @@ function loadProfile(profilePath) {
     inputArtifacts: parseInputArtifacts(profilePath, r.input),
     outputArtifacts: parseOutputArtifacts(profilePath, r.output),
     children,
-    dir: path7.dirname(profilePath)
+    dir: path8.dirname(profilePath)
   };
   return profile;
 }
@@ -1921,9 +2007,9 @@ function errMsg(err) {
 
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn } from "child_process";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as os from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -1963,20 +2049,20 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path8.join(os.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
-  fs9.writeFileSync(configPath, generateLitellmConfigYaml(model));
+  const configPath = path9.join(os.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  fs10.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
-  const logPath = path8.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
-  const outFd = fs9.openSync(logPath, "w");
+  const logPath = path9.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const outFd = fs10.openSync(logPath, "w");
   const child = spawn(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
   });
-  fs9.closeSync(outFd);
+  fs10.closeSync(outFd);
   for (let i = 0; i < 30; i++) {
     await new Promise((r) => setTimeout(r, 2e3));
     if (await checkLitellmHealth(url)) {
@@ -1993,7 +2079,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   }
   let logTail = "";
   try {
-    logTail = fs9.readFileSync(logPath, "utf-8").slice(-2e3);
+    logTail = fs10.readFileSync(logPath, "utf-8").slice(-2e3);
   } catch {
   }
   try {
@@ -2004,10 +2090,10 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
 ${logTail}`);
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path8.join(projectDir, ".env");
-  if (!fs9.existsSync(dotenvPath)) return {};
+  const dotenvPath = path9.join(projectDir, ".env");
+  if (!fs10.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs9.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs10.readFileSync(dotenvPath, "utf-8").split("\n")) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
     const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -2031,8 +2117,8 @@ function stripBlockingEnv(env) {
 
 // src/commit.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 var FORBIDDEN_PATH_PREFIXES = [
   ".kody/",
   ".kody-engine/",
@@ -2088,18 +2174,18 @@ function tryGit(args, cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path9.join(cwd ?? process.cwd(), ".git");
-  if (!fs10.existsSync(gitDir)) return aborted;
-  if (fs10.existsSync(path9.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path10.join(cwd ?? process.cwd(), ".git");
+  if (!fs11.existsSync(gitDir)) return aborted;
+  if (fs11.existsSync(path10.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs10.existsSync(path9.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs11.existsSync(path10.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs10.existsSync(path9.join(gitDir, "REVERT_HEAD"))) {
+  if (fs11.existsSync(path10.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs10.existsSync(path9.join(gitDir, "rebase-merge")) || fs10.existsSync(path9.join(gitDir, "rebase-apply"))) {
+  if (fs11.existsSync(path10.join(gitDir, "rebase-merge")) || fs11.existsSync(path10.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -2155,7 +2241,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs10.existsSync(path9.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs11.existsSync(path10.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -2467,21 +2553,21 @@ var advanceFlow = async (ctx, profile) => {
 };
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as os2 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 function getPluginsCatalogRoot() {
-  const here = path10.dirname(new URL(import.meta.url).pathname);
+  const here = path11.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path10.join(here, "..", "plugins"),
+    path11.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path10.join(here, "..", "..", "plugins"),
+    path11.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path10.join(here, "..", "..", "src", "plugins")
+    path11.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs11.existsSync(c) && fs11.statSync(c).isDirectory()) return c;
+    if (fs12.existsSync(c) && fs12.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
@@ -2491,52 +2577,52 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path10.join(os2.tmpdir(), `kody-synth-${runId}`);
-  fs11.mkdirSync(path10.join(root, ".claude-plugin"), { recursive: true });
+  const root = path11.join(os2.tmpdir(), `kody-synth-${runId}`);
+  fs12.mkdirSync(path11.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
-    const local = path10.join(profile.dir, bucket, entry);
-    if (fs11.existsSync(local)) return local;
-    const central = path10.join(catalog, bucket, entry);
-    if (fs11.existsSync(central)) return central;
+    const local = path11.join(profile.dir, bucket, entry);
+    if (fs12.existsSync(local)) return local;
+    const central = path11.join(catalog, bucket, entry);
+    if (fs12.existsSync(central)) return central;
     throw new Error(
       `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
     );
   };
   if (cc.skills.length > 0) {
-    const dst = path10.join(root, "skills");
-    fs11.mkdirSync(dst, { recursive: true });
+    const dst = path11.join(root, "skills");
+    fs12.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      copyDir(resolvePart("skills", name), path10.join(dst, name));
+      copyDir(resolvePart("skills", name), path11.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
-    const dst = path10.join(root, "commands");
-    fs11.mkdirSync(dst, { recursive: true });
+    const dst = path11.join(root, "commands");
+    fs12.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      fs11.copyFileSync(resolvePart("commands", `${name}.md`), path10.join(dst, `${name}.md`));
+      fs12.copyFileSync(resolvePart("commands", `${name}.md`), path11.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
-    const dst = path10.join(root, "agents");
-    fs11.mkdirSync(dst, { recursive: true });
+    const dst = path11.join(root, "agents");
+    fs12.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      fs11.copyFileSync(resolvePart("agents", `${name}.md`), path10.join(dst, `${name}.md`));
+      fs12.copyFileSync(resolvePart("agents", `${name}.md`), path11.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
-    const dst = path10.join(root, "hooks");
-    fs11.mkdirSync(dst, { recursive: true });
+    const dst = path11.join(root, "hooks");
+    fs12.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
       const src = resolvePart("hooks", `${name}.json`);
-      const parsed = JSON.parse(fs11.readFileSync(src, "utf-8"));
+      const parsed = JSON.parse(fs12.readFileSync(src, "utf-8"));
       for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
         if (!Array.isArray(entries)) continue;
         if (!merged.hooks[event]) merged.hooks[event] = [];
         merged.hooks[event].push(...entries);
       }
     }
-    fs11.writeFileSync(path10.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+    fs12.writeFileSync(path11.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
   }
   const manifest = {
@@ -2547,17 +2633,17 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (cc.skills.length > 0) manifest.skills = ["./skills/"];
   if (cc.commands.length > 0) manifest.commands = ["./commands/"];
   if (cc.subagents.length > 0) manifest.agents = cc.subagents.map((n) => `./agents/${n}.md`);
-  fs11.writeFileSync(path10.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+  fs12.writeFileSync(path11.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   ctx.data.syntheticPluginPath = root;
 };
 function copyDir(src, dst) {
-  fs11.mkdirSync(dst, { recursive: true });
-  for (const ent of fs11.readdirSync(src, { withFileTypes: true })) {
-    const s = path10.join(src, ent.name);
-    const d = path10.join(dst, ent.name);
+  fs12.mkdirSync(dst, { recursive: true });
+  for (const ent of fs12.readdirSync(src, { withFileTypes: true })) {
+    const s = path11.join(src, ent.name);
+    const d = path11.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs11.copyFileSync(s, d);
+    else if (ent.isFile()) fs12.copyFileSync(s, d);
   }
 }
 
@@ -2623,18 +2709,18 @@ function formatMissesForFeedback(misses) {
 }
 
 // src/prompt.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path12 from "path";
 var CONVENTIONS_PER_FILE_MAX_BYTES = 3e4;
 var CONVENTION_FILES = ["CLAUDE.md", "AGENTS.md"];
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path11.join(projectDir, rel);
-    if (!fs12.existsSync(abs)) continue;
+    const abs = path12.join(projectDir, rel);
+    if (!fs13.existsSync(abs)) continue;
     let content;
     try {
-      content = fs12.readFileSync(abs, "utf-8");
+      content = fs13.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -2846,11 +2932,11 @@ var commitAndPush2 = async (ctx) => {
 
 // src/scripts/commitGoalState.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as path12 from "path";
+import * as path13 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");
+  const stateRel = path13.posix.join(".kody", "goals", goal.id, "state.json");
   try {
     execFileSync9("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
   } catch (err) {
@@ -2894,20 +2980,20 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 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 ? path13.join(profile.dir, explicit) : null,
-    mode ? path13.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path13.join(profile.dir, "prompt.md")
+    explicit ? path14.join(profile.dir, explicit) : null,
+    mode ? path14.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path14.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs13.existsSync(c)) {
+    if (fs14.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -2915,7 +3001,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs13.readFileSync(templatePath, "utf-8");
+  const template = fs14.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -2993,8 +3079,8 @@ function formatToolsUsage(profile) {
 
 // src/scripts/createQaGoal.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 
 // src/scripts/postReviewResult.ts
 function detectVerdict(body) {
@@ -3246,8 +3332,8 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path14.join(cwd, ".kody", "goals", goalId);
-  fs14.mkdirSync(dir, { recursive: true });
+  const dir = path15.join(cwd, ".kody", "goals", goalId);
+  fs15.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -3255,8 +3341,8 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path14.join(dir, "state.json");
-  fs14.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  const filePath = path15.join(dir, "state.json");
+  fs15.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
@@ -3667,6 +3753,14 @@ function markPrReady(prNumber, cwd) {
     return fail(err);
   }
 }
+function fetchDefaultBranch(cwd) {
+  try {
+    const out = gh(["api", "repos/{owner}/{repo}", "--jq", ".default_branch"], { cwd });
+    return { ok: true, value: out.trim() };
+  } catch (err) {
+    return fail(err);
+  }
+}
 
 // src/goal/phase.ts
 function derivePhase(snap) {
@@ -3690,6 +3784,15 @@ function pickNextDispatchable(snap) {
 var deriveGoalPhase = async (ctx) => {
   const goal = ctx.data.goal;
   if (!goal) return;
+  const defaultBranchResult = fetchDefaultBranch(ctx.cwd);
+  if (defaultBranchResult.ok && defaultBranchResult.value) {
+    goal.defaultBranch = defaultBranchResult.value;
+  } else if (defaultBranchResult.error) {
+    process.stderr.write(
+      `[goal-tick] deriveGoalPhase: fetchDefaultBranch failed (${defaultBranchResult.error}); falling back to ${goal.defaultBranch}
+`
+    );
+  }
   const issues = listGoalIssues(goal.id, ctx.cwd);
   if (!issues.ok) {
     process.stderr.write(`[goal-tick] deriveGoalPhase: list issues failed: ${issues.error}
@@ -3738,15 +3841,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as os3 from "os";
-import * as path15 from "path";
+import * as path16 from "path";
 var diagMcp = async (_ctx) => {
   const home = os3.homedir();
-  const cacheDir = path15.join(home, ".cache", "ms-playwright");
+  const cacheDir = path16.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs15.readdirSync(cacheDir);
+    entries = fs16.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -3772,17 +3875,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path18 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs16.readFileSync(path16.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs17.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -3819,7 +3922,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs16.existsSync(path16.join(cwd, c))) return c;
+    if (fs17.existsSync(path17.join(cwd, c))) return c;
   }
   return null;
 }
@@ -3832,18 +3935,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path16.join(cwd, dir);
-    if (!fs16.existsSync(full)) continue;
+    const full = path17.join(cwd, dir);
+    if (!fs17.existsSync(full)) continue;
     let files;
     try {
-      files = fs16.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs17.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path16.join(full, file);
-        const content = fs16.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path17.join(full, file);
+        const content = fs17.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -3857,7 +3960,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path16.relative(cwd, filePath),
+          filePath: path17.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -3871,28 +3974,28 @@ var ADMIN_COMPONENT_DIRS = ["src/ui/admin", "src/admin/components", "src/compone
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path16.join(cwd, dir);
-    if (!fs16.existsSync(full)) continue;
+    const full = path17.join(cwd, dir);
+    if (!fs17.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs16.readdirSync(full, { withFileTypes: true });
+      entries = fs17.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path16.join(full, entry.name);
+      const entryPath = path17.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(path16.join(entryPath, f))
+          (f) => fs17.existsSync(path17.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path16.relative(cwd, path16.join(entryPath, indexFile));
+        filePath = path17.relative(cwd, path17.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path16.relative(cwd, entryPath);
+        filePath = path17.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -3900,7 +4003,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs16.readFileSync(path16.join(cwd, col.filePath), "utf-8");
+            const colContent = fs17.readFileSync(path17.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -3919,8 +4022,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path16.join(cwd, appDir, "api");
-    if (!fs16.existsSync(apiDir)) continue;
+    const apiDir = path17.join(cwd, appDir, "api");
+    if (!fs17.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -3929,14 +4032,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs16.readdirSync(dir, { withFileTypes: true });
+    entries = fs17.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs16.readFileSync(path16.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs17.readFileSync(path17.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)
       );
@@ -3944,7 +4047,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path16.relative(cwd, path16.join(dir, routeFile.name))
+          filePath: path17.relative(cwd, path17.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -3955,7 +4058,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(path16.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path17.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -3963,7 +4066,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path16.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path17.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -3983,10 +4086,10 @@ var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path16.join(cwd, envFile);
-    if (!fs16.existsSync(envPath)) continue;
+    const envPath = path17.join(cwd, envFile);
+    if (!fs17.existsSync(envPath)) continue;
     try {
-      const content = fs16.readFileSync(envPath, "utf-8");
+      const content = fs17.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -4034,9 +4137,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs17.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs18.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    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";
+    const pm = fs18.existsSync(path18.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs18.existsSync(path18.join(cwd, "yarn.lock")) ? "yarn" : fs18.existsSync(path18.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;
@@ -4046,8 +4149,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path17.join(cwd, appDir);
-    if (!fs17.existsSync(full)) continue;
+    const full = path18.join(cwd, appDir);
+    if (!fs18.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -4055,7 +4158,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs17.readdirSync(dir, { withFileTypes: true });
+    entries = fs18.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -4072,7 +4175,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(path17.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path18.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -4080,7 +4183,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path17.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path18.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -4097,23 +4200,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs17.existsSync(path17.join(cwd, c))) out.authFiles.push(c);
+    if (fs18.existsSync(path18.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 = path17.join(cwd, rp);
-    if (!fs17.existsSync(dir)) continue;
+    const dir = path18.join(cwd, rp);
+    if (!fs18.existsSync(dir)) continue;
     let files;
     try {
-      files = fs17.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs18.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs17.readFileSync(path17.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs18.readFileSync(path18.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) {
@@ -4344,8 +4447,8 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs20 from "fs";
+import * as path20 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -4596,8 +4699,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs18 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -4612,7 +4715,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 = path18.join(opts.cwd, opts.jobsDir);
+    this.absDir = path19.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -4627,7 +4730,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs18.mkdirSync(this.absDir, { recursive: true });
+    fs19.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -4656,7 +4759,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs18.existsSync(this.absDir)) {
+    if (!fs19.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -4672,11 +4775,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path18.join(this.cwd, relPath);
-    if (!fs18.existsSync(absPath)) {
+    const absPath = path19.join(this.cwd, relPath);
+    if (!fs19.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs18.readFileSync(absPath, "utf-8");
+    const raw = fs19.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -4693,10 +4796,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path18.join(this.cwd, loaded.path);
-    fs18.mkdirSync(path18.dirname(absPath), { recursive: true });
+    const absPath = path19.join(this.cwd, loaded.path);
+    fs19.mkdirSync(path19.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs18.writeFileSync(absPath, body, "utf-8");
+    fs19.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -4773,7 +4876,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path19.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path20.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -4872,17 +4975,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs19.readFileSync(path19.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs20.readFileSync(path20.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs19.existsSync(absDir)) return [];
+  if (!fs20.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs19.readdirSync(absDir, { withFileTypes: true });
+    entries = fs20.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -5483,7 +5586,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
 
 // src/gha.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -5494,10 +5597,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;
   }
@@ -5782,22 +5885,22 @@ var handleAbandonedGoal = async (ctx) => {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs21 from "fs";
-import * as path20 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 = path20.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 = "";
@@ -5807,9 +5910,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs22.existsSync(path21.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs22.existsSync(path21.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) {
@@ -5931,48 +6034,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path21.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 = path21.join(cwd, ".github", "workflows");
-  const workflowPath = path21.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(path21.join(cwd, "src/app")) || fs22.existsSync(path21.join(cwd, "app")) || fs22.existsSync(path21.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 = path21.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(path21.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 = path21.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 = path21.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path21.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);
     }
   }
@@ -5984,12 +6087,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path21.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;
@@ -6078,14 +6181,14 @@ var loadCoverageRules = async (ctx) => {
 };
 
 // src/goal/state.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs24 from "fs";
+import * as path23 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}:
+  constructor(path30, message) {
+    super(`Invalid goal state at ${path30}:
   ${message}`);
-    this.path = path29;
+    this.path = path30;
     this.name = "GoalStateError";
   }
   path;
@@ -6129,16 +6232,16 @@ function serializeGoalState(s) {
 `;
 }
 function goalStatePath(cwd, goalId) {
-  return path22.join(cwd, ".kody", "goals", goalId, "state.json");
+  return path23.join(cwd, ".kody", "goals", goalId, "state.json");
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs23.existsSync(file)) {
+  if (!fs24.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs23.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs24.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -6146,8 +6249,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs23.mkdirSync(path22.dirname(file), { recursive: true });
-  fs23.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs24.mkdirSync(path23.dirname(file), { recursive: true });
+  fs24.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -6241,8 +6344,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const slugArg = String(args?.slugArg ?? "job");
@@ -6250,11 +6353,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path23.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs24.existsSync(absPath)) {
+  const absPath = path24.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs25.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs24.readFileSync(absPath, "utf-8");
+  const raw = fs25.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);
@@ -6286,16 +6389,16 @@ function humanizeSlug(slug) {
 }
 
 // src/scripts/loadMemoryContext.ts
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path25 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 = path24.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-  if (!fs25.existsSync(memoryAbs)) {
+  const memoryAbs = path25.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+  if (!fs26.existsSync(memoryAbs)) {
     ctx.data.memoryContext = "";
     return;
   }
@@ -6320,21 +6423,21 @@ function collectPages(memoryAbs) {
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs25.statSync(file);
+      stat = fs26.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs25.readFileSync(file, "utf-8");
+      raw = fs26.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() ?? path24.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path25.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path24.relative(memoryAbs, file),
+      relPath: path25.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -6402,16 +6505,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs25.readdirSync(dir);
+      names = fs26.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path24.join(dir, name);
+      const full = path25.join(dir, name);
       let stat;
       try {
-        stat = fs25.statSync(full);
+        stat = fs26.statSync(full);
       } catch {
         continue;
       }
@@ -7249,30 +7352,21 @@ var recordOutcome = async (ctx, profile) => {
 
 // src/scripts/requireFeedbackActions.ts
 var MIN_ITEMS = 1;
-var requireFeedbackActions = async (ctx, profile) => {
+var requireFeedbackActions = async (ctx) => {
   if (!ctx.data.agentDone) return;
   const actions = String(ctx.data.feedbackActions ?? "").trim();
   const items = countActionItems(actions);
   ctx.data.feedbackAgentItemCount = items;
   if (items < MIN_ITEMS) {
-    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"
+    const reason = actions.length === 0 ? "FEEDBACK_ACTIONS block missing" : "FEEDBACK_ACTIONS block listed no items";
+    process.stderr.write(
+      `[kody requireFeedbackActions] warning: ${reason} \u2014 proceeding anyway (verifyFixAlignment + tests are the real gate)
+`
     );
+    ctx.data.feedbackActionsOmitted = actions.length === 0;
+    ctx.data.feedbackActionsMalformed = actions.length > 0;
   }
 };
-function fail2(ctx, profile, reason) {
-  ctx.data.agentDone = false;
-  ctx.data.agentFailureReason = reason;
-  const modeSeg = profile.name.replace(/-/g, "_").toUpperCase();
-  const failedAction6 = {
-    type: `${modeSeg}_FAILED`,
-    payload: { reason },
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  ctx.data.action = failedAction6;
-}
 function countActionItems(block) {
   if (!block.trim()) return 0;
   let count = 0;
@@ -7829,8 +7923,8 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs26 from "fs";
-import * as path25 from "path";
+import * as fs27 from "fs";
+import * as path26 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -7842,13 +7936,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path25.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs26.existsSync(jobPath)) {
+  const jobPath = path26.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs27.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs26.readFileSync(jobPath, "utf-8");
+  const raw = fs27.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -7856,8 +7950,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 = path25.isAbsolute(tickScript) ? tickScript : path25.join(ctx.cwd, tickScript);
-  if (!fs26.existsSync(scriptPath)) {
+  const scriptPath = path26.isAbsolute(tickScript) ? tickScript : path26.join(ctx.cwd, tickScript);
+  if (!fs27.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -8794,7 +8888,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -8816,7 +8910,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs27.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs28.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -8952,22 +9046,42 @@ function runShell(cmd, cwd, timeoutMs = 3e4) {
 // src/executor.ts
 var CONTAINER_MAX_ITERATIONS = 50;
 async function runExecutable(profileName, input) {
+  const stageStartedAt = Date.now();
+  emitEvent(input.cwd, { executable: profileName, kind: "stage_start" });
+  const finishAndEnd = (out) => {
+    emitEvent(input.cwd, {
+      executable: profileName,
+      kind: "stage_end",
+      durationMs: Date.now() - stageStartedAt,
+      outcome: out.exitCode === 0 ? "ok" : "failed",
+      meta: {
+        exitCode: out.exitCode,
+        ...out.reason ? { reason: out.reason } : {},
+        ...out.prUrl ? { prUrl: out.prUrl } : {}
+      }
+    });
+    if (out.prUrl) process.stdout.write(`PR_URL=${out.prUrl}
+`);
+    else if (out.reason) process.stdout.write(`PR_URL=FAILED: ${out.reason}
+`);
+    return out;
+  };
   const profilePath = resolveProfilePath(profileName);
   const profile = loadProfile(profilePath);
   const missing = validateScriptReferences(profile, allScriptNames);
   if (missing.length > 0) {
-    return finish({ exitCode: 99, reason: `profile references unknown scripts: ${missing.join(", ")}` });
+    return finishAndEnd({ exitCode: 99, reason: `profile references unknown scripts: ${missing.join(", ")}` });
   }
   let args;
   try {
     args = validateInputs(profile.inputs, input.cliArgs);
   } catch (err) {
-    return finish({ exitCode: 64, reason: err instanceof Error ? err.message : String(err) });
+    return finishAndEnd({ exitCode: 64, reason: err instanceof Error ? err.message : String(err) });
   }
   const toolResults = verifyCliTools(profile.cliTools, input.cwd);
   const firstFail = firstRequiredFailure(toolResults, profile.cliTools);
   if (firstFail) {
-    return finish({ exitCode: 99, reason: `required CLI tool check failed: ${firstFail.error}` });
+    return finishAndEnd({ exitCode: 99, reason: `required CLI tool check failed: ${firstFail.error}` });
   }
   let config;
   if (input.config) {
@@ -8983,7 +9097,7 @@ async function runExecutable(profileName, input) {
     try {
       config = loadConfig(input.cwd);
     } catch (err) {
-      return finish({ exitCode: 99, reason: `config error: ${err instanceof Error ? err.message : String(err)}` });
+      return finishAndEnd({ exitCode: 99, reason: `config error: ${err instanceof Error ? err.message : String(err)}` });
     }
   }
   const modelSpec = profile.claudeCode.model === "inherit" ? config.agent.model : profile.claudeCode.model;
@@ -8991,13 +9105,13 @@ async function runExecutable(profileName, input) {
   try {
     model = parseProviderModel(modelSpec);
   } catch (err) {
-    return finish({ exitCode: 99, reason: `agent.model invalid: ${err instanceof Error ? err.message : String(err)}` });
+    return finishAndEnd({ exitCode: 99, reason: `agent.model invalid: ${err instanceof Error ? err.message : String(err)}` });
   }
   let litellm = null;
   try {
     litellm = await startLitellmIfNeeded(model, input.cwd);
   } catch (err) {
-    return finish({
+    return finishAndEnd({
       exitCode: 99,
       reason: `litellm startup failed: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -9011,9 +9125,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path26.join(input.cwd, ".kody");
+  const ndjsonDir = path27.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path26.isAbsolute(p) ? p : path26.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path27.isAbsolute(p) ? p : path27.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -9037,15 +9151,39 @@ async function runExecutable(profileName, input) {
   ctx.data.__invokeAgent = invokeAgent;
   try {
     for (const entry of profile.scripts.preflight) {
-      if (!shouldRun(entry, ctx)) continue;
+      const preLabel = entry.script ?? entry.shell ?? "<unknown>";
+      if (!shouldRun(entry, ctx)) {
+        emitEvent(input.cwd, {
+          executable: profileName,
+          kind: "preflight",
+          name: preLabel,
+          outcome: "skipped"
+        });
+        continue;
+      }
+      const t0 = Date.now();
       if (entry.shell) {
         await runShellEntry(entry, ctx, profile);
+        emitEvent(input.cwd, {
+          executable: profileName,
+          kind: "preflight",
+          name: preLabel,
+          durationMs: Date.now() - t0,
+          outcome: ctx.output.exitCode && ctx.output.exitCode !== 0 ? "failed" : "ok"
+        });
       } else {
         const fn = preflightScripts[entry.script];
-        if (!fn) return finish({ exitCode: 99, reason: `preflight script not registered: ${entry.script}` });
+        if (!fn) return finishAndEnd({ exitCode: 99, reason: `preflight script not registered: ${entry.script}` });
         await fn(ctx, profile, entry.with);
+        emitEvent(input.cwd, {
+          executable: profileName,
+          kind: "preflight",
+          name: preLabel,
+          durationMs: Date.now() - t0,
+          outcome: ctx.skipAgent && ctx.output.exitCode && ctx.output.exitCode !== 0 ? "failed" : "ok"
+        });
         if (ctx.skipAgent && ctx.output.exitCode !== void 0 && ctx.output.exitCode !== 0) {
-          return finish(ctx.output);
+          return finishAndEnd(ctx.output);
         }
       }
     }
@@ -9056,9 +9194,21 @@ async function runExecutable(profileName, input) {
     } else if (!ctx.skipAgent) {
       const prompt = ctx.data.prompt;
       if (!prompt) {
-        return finish({ exitCode: 99, reason: "composePrompt did not produce a prompt (ctx.data.prompt missing)" });
+        return finishAndEnd({ exitCode: 99, reason: "composePrompt did not produce a prompt (ctx.data.prompt missing)" });
       }
+      emitEvent(input.cwd, { executable: profileName, kind: "agent_start" });
       agentResult = await invokeAgent(prompt);
+      emitEvent(input.cwd, {
+        executable: profileName,
+        kind: "agent_end",
+        durationMs: agentResult.durationMs,
+        outcome: agentResult.outcome === "completed" ? "ok" : "failed",
+        meta: {
+          ...agentResult.tokens ? { tokens: agentResult.tokens } : {},
+          ...typeof agentResult.messageCount === "number" ? { messageCount: agentResult.messageCount } : {},
+          ...agentResult.error ? { error: agentResult.error } : {}
+        }
+      });
     }
     for (const entry of profile.scripts.postflight) {
       const entryLabel = entry.script ?? entry.shell ?? "<unknown>";
@@ -9073,18 +9223,27 @@ async function runExecutable(profileName, input) {
           process.stderr.write(`[kody postflight] skip ${entryLabel}: ${reasons.join("; ")}
 `);
         }
+        emitEvent(input.cwd, {
+          executable: profileName,
+          kind: "postflight",
+          name: entryLabel,
+          outcome: "skipped"
+        });
         continue;
       }
       const label = entryLabel;
+      const t0 = Date.now();
+      let postOutcome = "ok";
       try {
         if (entry.shell) {
           await runShellEntry(entry, ctx, profile);
         } else {
           const fn = postflightScripts[entry.script];
-          if (!fn) return finish({ exitCode: 99, reason: `postflight script not registered: ${entry.script}` });
+          if (!fn) return finishAndEnd({ exitCode: 99, reason: `postflight script not registered: ${entry.script}` });
           await fn(ctx, profile, agentResult, entry.with);
         }
       } catch (err) {
+        postOutcome = "failed";
         const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`[kody] postflight "${label}" crashed: ${msg}
 `);
@@ -9092,8 +9251,15 @@ async function runExecutable(profileName, input) {
         ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${summary}` : summary;
         if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
       }
+      emitEvent(input.cwd, {
+        executable: profileName,
+        kind: "postflight",
+        name: label,
+        durationMs: Date.now() - t0,
+        outcome: postOutcome
+      });
     }
-    return finish({
+    return finishAndEnd({
       exitCode: ctx.output.exitCode ?? 0,
       prUrl: ctx.output.prUrl,
       reason: ctx.output.reason
@@ -9122,17 +9288,17 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path26.dirname(new URL(import.meta.url).pathname);
+  const here = path27.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path26.join(here, "executables", profileName, "profile.json"),
+    path27.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path26.join(here, "..", "executables", profileName, "profile.json"),
+    path27.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path26.join(here, "..", "src", "executables", profileName, "profile.json")
+    path27.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs28.existsSync(c)) return c;
+    if (fs29.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -9215,13 +9381,6 @@ function resolveDottedPath(root, key) {
   }
   return cur;
 }
-function finish(out) {
-  if (out.prUrl) process.stdout.write(`PR_URL=${out.prUrl}
-`);
-  else if (out.reason) process.stdout.write(`PR_URL=FAILED: ${out.reason}
-`);
-  return out;
-}
 var DEFAULT_SHELL_TIMEOUT_MS = 3e5;
 function resolveShellTimeoutMs(entry) {
   if (typeof entry.timeoutSec === "number" && entry.timeoutSec > 0) {
@@ -9236,8 +9395,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path26.join(profile.dir, shellName);
-  if (!fs28.existsSync(shellPath)) {
+  const shellPath = path27.join(profile.dir, shellName);
+  if (!fs29.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -9412,6 +9571,7 @@ async function runContainerLoop(profile, ctx, input) {
         cliArgs = { issue: issueNumber };
       }
       let childOut;
+      const childStartedAt = Date.now();
       try {
         childOut = await runChild(child.exec, {
           cliArgs,
@@ -9421,7 +9581,23 @@ async function runContainerLoop(profile, ctx, input) {
           verbose: input.verbose,
           quiet: input.quiet
         });
+        emitEvent(input.cwd, {
+          executable: profile.name,
+          kind: "container_child",
+          name: child.exec,
+          durationMs: Date.now() - childStartedAt,
+          outcome: childOut.exitCode === 0 ? "ok" : "failed",
+          meta: { exitCode: childOut.exitCode, iteration }
+        });
       } catch (err) {
+        emitEvent(input.cwd, {
+          executable: profile.name,
+          kind: "container_child",
+          name: child.exec,
+          durationMs: Date.now() - childStartedAt,
+          outcome: "failed",
+          meta: { iteration, error: err instanceof Error ? err.message : String(err) }
+        });
         const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`[kody container] child "${child.exec}" crashed: ${msg}
 `);
@@ -9650,9 +9826,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  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";
+  if (fs30.existsSync(path28.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs30.existsSync(path28.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs30.existsSync(path28.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -9739,11 +9915,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path27.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path28.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs29.existsSync(logPath)) {
-      const content = fs29.readFileSync(logPath, "utf-8");
+    if (fs30.existsSync(logPath)) {
+      const content = fs30.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -9768,7 +9944,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path27.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path28.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -9778,9 +9954,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 && fs29.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs30.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs29.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs30.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);
@@ -10025,9 +10201,9 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  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)));
+  const sessionFile = path29.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path29.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs31.existsSync(path29.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -10065,7 +10241,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path28.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path29.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -10117,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=${fs30.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs31.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -10154,6 +10330,206 @@ ${CHAT_HELP}`);
   }
 }
 
+// src/stats.ts
+function parseStatsArgs(argv) {
+  const out = { cwd: process.cwd() };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") out.asJson = true;
+    else if (a === "--cwd" && argv[i + 1]) {
+      out.cwd = argv[++i];
+    } else if (a === "--since" && argv[i + 1]) {
+      out.sinceMs = parseDuration(argv[++i]);
+    } else if (a === "--run" && argv[i + 1]) {
+      out.runId = argv[++i];
+    }
+  }
+  return out;
+}
+function parseDuration(s) {
+  const m = /^(\d+)\s*([smhd])$/i.exec(s.trim());
+  if (!m) return void 0;
+  const n = Number.parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * mult;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.floor(p / 100 * sorted.length)));
+  return sorted[idx];
+}
+function summarizeRun(events) {
+  if (events.length === 0) return null;
+  const sorted = [...events].sort((a, b) => a.ts.localeCompare(b.ts));
+  const start = sorted.find((e) => e.kind === "stage_start");
+  const ends = sorted.filter((e) => e.kind === "stage_end");
+  const lastEnd = ends.length > 0 ? ends[ends.length - 1] : void 0;
+  const startedAt = start?.ts ?? sorted[0].ts;
+  const endedAt = lastEnd?.ts ?? sorted[sorted.length - 1].ts;
+  const durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  const exitCodeRaw = lastEnd?.meta?.exitCode;
+  const exitCode = typeof exitCodeRaw === "number" ? exitCodeRaw : null;
+  const executables = Array.from(new Set(sorted.map((e) => e.executable)));
+  let tIn = 0;
+  let tOut = 0;
+  let tCacheR = 0;
+  for (const ev of sorted) {
+    if (ev.kind !== "agent_end") continue;
+    const tokens = ev.meta?.tokens;
+    if (tokens) {
+      tIn += Number(tokens.input ?? 0);
+      tOut += Number(tokens.output ?? 0);
+      tCacheR += Number(tokens.cacheRead ?? 0);
+    }
+  }
+  return {
+    runId: sorted[0].runId,
+    startedAt,
+    endedAt,
+    durationMs,
+    executables,
+    exitCode,
+    ok: exitCode === 0,
+    totalInputTokens: tIn,
+    totalOutputTokens: tOut,
+    totalCacheReadTokens: tCacheR
+  };
+}
+function rollupByExecutable(events) {
+  const byExec = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind !== "stage_end") continue;
+    if (!byExec.has(ev.executable)) byExec.set(ev.executable, []);
+    byExec.get(ev.executable).push(ev);
+  }
+  const rollups = [];
+  for (const [executable, stageEnds] of byExec) {
+    const durations = stageEnds.map((e) => e.durationMs ?? 0).filter((d) => d > 0).sort((a, b) => a - b);
+    const ok = stageEnds.filter((e) => e.outcome === "ok").length;
+    const failed = stageEnds.filter((e) => e.outcome === "failed").length;
+    let tIn = 0;
+    let tOut = 0;
+    let tCacheR = 0;
+    let tCacheC = 0;
+    for (const ev of events) {
+      if (ev.kind !== "agent_end") continue;
+      if (ev.executable !== executable) continue;
+      const tokens = ev.meta?.tokens;
+      if (tokens) {
+        tIn += Number(tokens.input ?? 0);
+        tOut += Number(tokens.output ?? 0);
+        tCacheR += Number(tokens.cacheRead ?? 0);
+        tCacheC += Number(tokens.cacheCreate ?? 0);
+      }
+    }
+    const mean = durations.length > 0 ? durations.reduce((s, n) => s + n, 0) / durations.length : 0;
+    rollups.push({
+      executable,
+      runs: stageEnds.length,
+      ok,
+      failed,
+      p50Ms: percentile(durations, 50),
+      p95Ms: percentile(durations, 95),
+      meanMs: Math.round(mean),
+      totalInputTokens: tIn,
+      totalOutputTokens: tOut,
+      totalCacheReadTokens: tCacheR,
+      totalCacheCreateTokens: tCacheC
+    });
+  }
+  rollups.sort((a, b) => b.runs - a.runs);
+  return rollups;
+}
+async function runStats(argv) {
+  const opts = parseStatsArgs(argv);
+  const runIds = opts.runId ? [opts.runId] : listRuns(opts.cwd);
+  if (runIds.length === 0) {
+    process.stdout.write(`no runs found under ${opts.cwd}/.kody/runs/
+`);
+    return 0;
+  }
+  const cutoff = opts.sinceMs ? Date.now() - opts.sinceMs : null;
+  const allEvents = [];
+  const runSummaries = [];
+  for (const id of runIds) {
+    const events = readEvents(opts.cwd, id);
+    if (events.length === 0) continue;
+    const summary = summarizeRun(events);
+    if (!summary) continue;
+    if (cutoff && new Date(summary.startedAt).getTime() < cutoff) continue;
+    allEvents.push(...events);
+    runSummaries.push(summary);
+  }
+  if (runSummaries.length === 0) {
+    process.stdout.write("no runs in the requested window\n");
+    return 0;
+  }
+  const byExec = rollupByExecutable(allEvents);
+  if (opts.asJson) {
+    process.stdout.write(`${JSON.stringify({ runs: runSummaries, byExecutable: byExec }, null, 2)}
+`);
+    return 0;
+  }
+  printReport(runSummaries, byExec);
+  return 0;
+}
+function printReport(runs, rollups) {
+  const totalRuns = runs.length;
+  const okRuns = runs.filter((r) => r.ok).length;
+  const okPct = totalRuns > 0 ? (okRuns / totalRuns * 100).toFixed(1) : "\u2014";
+  const durations = runs.map((r) => r.durationMs).sort((a, b) => a - b);
+  const meanMs = durations.length > 0 ? durations.reduce((s, n) => s + n, 0) / durations.length : 0;
+  process.stdout.write(`
+Kody run statistics \u2014 ${totalRuns} runs
+`);
+  process.stdout.write(`  success rate     : ${okRuns}/${totalRuns} (${okPct}%)
+`);
+  process.stdout.write(`  mean wall-clock  : ${formatMs(meanMs)}
+`);
+  process.stdout.write(`  p50 wall-clock   : ${formatMs(percentile(durations, 50))}
+`);
+  process.stdout.write(`  p95 wall-clock   : ${formatMs(percentile(durations, 95))}
+`);
+  const totalIn = runs.reduce((s, r) => s + r.totalInputTokens, 0);
+  const totalOut = runs.reduce((s, r) => s + r.totalOutputTokens, 0);
+  const totalCacheR = runs.reduce((s, r) => s + r.totalCacheReadTokens, 0);
+  process.stdout.write(`  total tokens     : ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out / ${totalCacheR.toLocaleString()} cache-read
+`);
+  process.stdout.write(`
+Per-executable (stage_end events)
+`);
+  const headers = ["executable", "runs", "ok", "failed", "p50", "p95", "mean", "tok-in", "tok-out", "cache-r"];
+  const widths = [22, 6, 6, 7, 9, 9, 9, 10, 10, 10];
+  process.stdout.write(headers.map((h, i) => h.padEnd(widths[i])).join("") + "\n");
+  process.stdout.write(widths.map((w) => "-".repeat(w - 1) + " ").join("") + "\n");
+  for (const r of rollups) {
+    const row = [
+      r.executable,
+      String(r.runs),
+      String(r.ok),
+      String(r.failed),
+      formatMs(r.p50Ms),
+      formatMs(r.p95Ms),
+      formatMs(r.meanMs),
+      r.totalInputTokens.toLocaleString(),
+      r.totalOutputTokens.toLocaleString(),
+      r.totalCacheReadTokens.toLocaleString()
+    ];
+    process.stdout.write(row.map((c, i) => c.padEnd(widths[i])).join("") + "\n");
+  }
+  process.stdout.write("\n");
+}
+function formatMs(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "\u2014";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = seconds / 60;
+  if (minutes < 60) return `${minutes.toFixed(1)}m`;
+  return `${(minutes / 60).toFixed(2)}h`;
+}
+
 // src/entry.ts
 var HELP_TEXT = `kody \u2014 single-session autonomous engineer
 
@@ -10166,6 +10542,7 @@ Usage:
   kody <other>                                [--cwd <path>] [--verbose|--quiet]
   kody ci      --issue <N> [preflight flags \u2014 see: kody ci --help]
   kody chat    [chat flags \u2014 see: kody chat --help]
+  kody stats   [--since 7d|--run <id>|--json|--cwd <path>]
   kody help
   kody version
 
@@ -10199,6 +10576,9 @@ function parseArgs(argv) {
   if (cmd === "chat") {
     return { ...result, command: "chat", chatArgv: argv.slice(1) };
   }
+  if (cmd === "stats") {
+    return { ...result, command: "stats", statsArgv: argv.slice(1) };
+  }
   if (hasExecutable(cmd)) {
     result.command = "__executable__";
     result.executableName = cmd;
@@ -10209,7 +10589,7 @@ function parseArgs(argv) {
     return result;
   }
   const discovered = listExecutables().map((e) => e.name);
-  const available = ["ci", "help", "version", ...discovered];
+  const available = ["ci", "chat", "stats", "help", "version", ...discovered];
   result.errors.push(`unknown command: ${cmd} (available: ${available.join(", ")})`);
   return result;
 }
@@ -10251,6 +10631,18 @@ ${HELP_TEXT}`);
       process.stderr.write(`[kody] fatal: ${msg}
 `);
       if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
+`);
+      return 99;
+    }
+  }
+  if (args.command === "stats") {
+    try {
+      return await runStats(args.statsArgv ?? []);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody] fatal: ${msg}
+`);
+      if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
 `);
       return 99;
     }