@kody-ade/kody-engine 0.4.59 → 0.4.61

package/dist/bin/kody.js

@@ -10,6 +10,14 @@ var __export = (target, all) => {
 };
 
 // src/events.ts
+var events_exports = {};
+__export(events_exports, {
+  __resetRunIdCache: () => __resetRunIdCache,
+  emitEvent: () => emitEvent,
+  listRuns: () => listRuns,
+  readEvents: () => readEvents,
+  resolveRunId: () => resolveRunId
+});
 import * as crypto from "crypto";
 import * as fs3 from "fs";
 import * as path3 from "path";
@@ -28,6 +36,10 @@ function resolveRunId() {
   process.env.KODY_RUN_ID = cachedRunId;
   return cachedRunId;
 }
+function __resetRunIdCache() {
+  cachedRunId = null;
+  delete process.env.KODY_RUN_ID;
+}
 function emitEvent(cwd, ev) {
   if (process.env.KODY_EVENTS === "0") return;
   try {
@@ -303,7 +315,7 @@ var init_verifyMcp = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.59",
+  version: "0.4.61",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -353,8 +365,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1326,8 +1338,8 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 
 // src/dispatch.ts
 import * as fs8 from "fs";
@@ -1906,8 +1918,8 @@ function postPrReviewComment(prNumber, body, cwd) {
 
 // src/executor.ts
 import { execFileSync as execFileSync29, spawn as spawn5 } from "child_process";
-import * as fs30 from "fs";
-import * as path28 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 init_events();
 
 // src/profile.ts
@@ -1918,6 +1930,27 @@ var VALID_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits",
 var VALID_ROLES = /* @__PURE__ */ new Set(["primitive", "orchestrator", "container", "watch", "utility"]);
 var VALID_CONTAINER_CHILD_TARGETS = /* @__PURE__ */ new Set(["issue", "pr"]);
 var VALID_PHASES = /* @__PURE__ */ new Set(["research", "planning", "implementing", "reviewing", "shipped", "failed", "idle"]);
+var KNOWN_PROFILE_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "describe",
+  "role",
+  "kind",
+  "schedule",
+  "phase",
+  "inputs",
+  "claudeCode",
+  "cliTools",
+  "scripts",
+  "outputContract",
+  "inputArtifacts",
+  "outputArtifacts",
+  "input",
+  // legacy JSON name for inputArtifacts source
+  "output",
+  // legacy JSON name for outputArtifacts source
+  "children",
+  "resetBetweenChildren"
+]);
 var ProfileError = class extends Error {
   constructor(profilePath, message) {
     super(`Invalid profile at ${profilePath}:
@@ -1941,6 +1974,13 @@ function loadProfile(profilePath) {
     throw new ProfileError(profilePath, "profile must be a JSON object");
   }
   const r = raw;
+  const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
+  if (unknownKeys.length > 0) {
+    process.stderr.write(
+      `[kody profile] ${path8.basename(path8.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+`
+    );
+  }
   const kind = r.kind === "scheduled" ? "scheduled" : "oneshot";
   if (kind === "scheduled" && typeof r.schedule !== "string") {
     throw new ProfileError(profilePath, `kind: "scheduled" requires a "schedule" cron string`);
@@ -1972,6 +2012,10 @@ function loadProfile(profilePath) {
     inputArtifacts: parseInputArtifacts(profilePath, r.input),
     outputArtifacts: parseOutputArtifacts(profilePath, r.output),
     children,
+    // Default true: preserves legacy bug-safe behaviour where each
+    // container child sees a clean tracked tree (see executor.ts).
+    // Containers opt out by setting `"resetBetweenChildren": false`.
+    resetBetweenChildren: typeof r.resetBetweenChildren === "boolean" ? r.resetBetweenChildren : true,
     dir: path8.dirname(profilePath)
   };
   return profile;
@@ -3230,13 +3274,36 @@ function defaultLabelMap() {
 }
 
 // src/scripts/commitAndPush.ts
+import * as fs14 from "fs";
+import * as path13 from "path";
+init_events();
 var DEFAULT_COMMIT_MESSAGE = "chore: kody changes";
-var commitAndPush2 = async (ctx) => {
+function sentinelPathForStage(cwd, profileName) {
+  const runId = resolveRunId();
+  return path13.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+}
+var commitAndPush2 = async (ctx, profile) => {
   const branch = ctx.data.branch;
   if (!branch) {
     ctx.data.commitResult = { committed: false, pushed: false };
     return;
   }
+  const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
+  const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
+  if (sentinel && fs14.existsSync(sentinel)) {
+    try {
+      const replay = JSON.parse(fs14.readFileSync(sentinel, "utf-8"));
+      ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
+      if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
+      if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
+      if (replay.salvagedFromMissingMarker) ctx.data.salvagedFromMissingMarker = true;
+      ctx.data.commitIdempotencyReplay = true;
+      process.stderr.write(`[kody commitAndPush] idempotency replay (sentinel ${sentinel})
+`);
+      return;
+    } catch {
+    }
+  }
   const markerMissing = ctx.data.agentMarkerMissing === true;
   if (ctx.data.agentDone === false && !markerMissing) {
     ctx.data.commitResult = { committed: false, pushed: false, skippedReason: "agentDone=false" };
@@ -3248,12 +3315,12 @@ var commitAndPush2 = async (ctx) => {
   }
   const message = ctx.data.commitMessage || DEFAULT_COMMIT_MESSAGE;
   try {
-    const result = commitAndPush(branch, message, ctx.cwd);
-    ctx.data.commitResult = result;
-    const postCommitFiles = result.committed ? listFilesInCommit("HEAD", ctx.cwd) : listChangedFiles(ctx.cwd);
+    const result2 = commitAndPush(branch, message, ctx.cwd);
+    ctx.data.commitResult = result2;
+    const postCommitFiles = result2.committed ? listFilesInCommit("HEAD", ctx.cwd) : listChangedFiles(ctx.cwd);
     ctx.data.changedFiles = postCommitFiles.filter((f) => !isForbiddenPath(f));
-    if (result.committed && !result.pushed) {
-      const reason = result.pushError ?? "push failed (no error detail)";
+    if (result2.committed && !result2.pushed) {
+      const reason = result2.pushError ?? "push failed (no error detail)";
       ctx.data.commitCrash = reason;
       if (ctx.output.exitCode === void 0 || ctx.output.exitCode === 0) {
         ctx.output.exitCode = 4;
@@ -3270,15 +3337,36 @@ var commitAndPush2 = async (ctx) => {
 `);
   }
   ctx.data.hasCommitsAhead = hasCommitsAhead(branch, ctx.config.git.defaultBranch, ctx.cwd);
+  const result = ctx.data.commitResult;
+  if (sentinel && result?.committed) {
+    try {
+      fs14.mkdirSync(path13.dirname(sentinel), { recursive: true });
+      fs14.writeFileSync(
+        sentinel,
+        JSON.stringify(
+          {
+            commitResult: ctx.data.commitResult,
+            changedFiles: ctx.data.changedFiles,
+            hasCommitsAhead: ctx.data.hasCommitsAhead,
+            salvagedFromMissingMarker: ctx.data.salvagedFromMissingMarker === true,
+            writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          null,
+          2
+        )
+      );
+    } catch {
+    }
+  }
 };
 
 // src/scripts/commitGoalState.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import * as path13 from "path";
+import * as path14 from "path";
 var commitGoalState = async (ctx) => {
   const goal = ctx.data.goal;
   if (!goal) return;
-  const stateRel = path13.posix.join(".kody", "goals", goal.id, "state.json");
+  const stateRel = path14.posix.join(".kody", "goals", goal.id, "state.json");
   try {
     execFileSync9("git", ["add", stateRel], { cwd: ctx.cwd, stdio: "pipe" });
   } catch (err) {
@@ -3322,20 +3410,20 @@ function describeCommitMessage(goal) {
 }
 
 // src/scripts/composePrompt.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 var MUSTACHE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
 var composePrompt = async (ctx, profile) => {
   const explicit = ctx.data.promptTemplate;
   const mode = ctx.args.mode;
   const candidates = [
-    explicit ? path14.join(profile.dir, explicit) : null,
-    mode ? path14.join(profile.dir, "prompts", `${mode}.md`) : null,
-    path14.join(profile.dir, "prompt.md")
+    explicit ? path15.join(profile.dir, explicit) : null,
+    mode ? path15.join(profile.dir, "prompts", `${mode}.md`) : null,
+    path15.join(profile.dir, "prompt.md")
   ].filter(Boolean);
   let templatePath = "";
   for (const c of candidates) {
-    if (fs14.existsSync(c)) {
+    if (fs15.existsSync(c)) {
       templatePath = c;
       break;
     }
@@ -3343,7 +3431,7 @@ var composePrompt = async (ctx, profile) => {
   if (!templatePath) {
     throw new Error(`profile at ${profile.dir}: no prompt template found (tried ${candidates.join(", ")})`);
   }
-  const template = fs14.readFileSync(templatePath, "utf-8");
+  const template = fs15.readFileSync(templatePath, "utf-8");
   const tokens = {
     ...stringifyAll(ctx.args, "args."),
     ...stringifyAll(ctx.data, ""),
@@ -3421,8 +3509,8 @@ function formatToolsUsage(profile) {
 
 // src/scripts/createQaGoal.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 
 // src/scripts/postReviewResult.ts
 function detectVerdict(body) {
@@ -3674,8 +3762,8 @@ function createOrUpdateManifestIssue(number, manifest, cwd) {
   return { number: Number(m[1]), created: true };
 }
 function writeStateFile(cwd, goalId, lastDispatchedIssue) {
-  const dir = path15.join(cwd, ".kody", "goals", goalId);
-  fs15.mkdirSync(dir, { recursive: true });
+  const dir = path16.join(cwd, ".kody", "goals", goalId);
+  fs16.mkdirSync(dir, { recursive: true });
   const state = {
     version: 1,
     state: "active",
@@ -3683,8 +3771,8 @@ function writeStateFile(cwd, goalId, lastDispatchedIssue) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...typeof lastDispatchedIssue === "number" ? { lastDispatchedIssue } : {}
   };
-  const filePath = path15.join(dir, "state.json");
-  fs15.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
+  const filePath = path16.join(dir, "state.json");
+  fs16.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}
 `);
   return filePath;
 }
@@ -4089,7 +4177,10 @@ function mergePrSquash(prNumber, cwd) {
 }
 function editPrBase(prNumber, baseBranch, cwd) {
   try {
-    gh(["pr", "edit", String(prNumber), "--base", baseBranch], { cwd });
+    gh(
+      ["api", "--method", "PATCH", `repos/{owner}/{repo}/pulls/${prNumber}`, "-f", `base=${baseBranch}`],
+      { cwd }
+    );
     return { ok: true };
   } catch (err) {
     return fail(err);
@@ -4174,15 +4265,15 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as os3 from "os";
-import * as path16 from "path";
+import * as path17 from "path";
 var diagMcp = async (_ctx) => {
   const home = os3.homedir();
-  const cacheDir = path16.join(home, ".cache", "ms-playwright");
+  const cacheDir = path17.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
-    entries = fs16.readdirSync(cacheDir);
+    entries = fs17.readdirSync(cacheDir);
   } catch {
   }
   const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -4208,17 +4299,17 @@ var diagMcp = async (_ctx) => {
 };
 
 // src/scripts/discoverQaContext.ts
-import * as fs18 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 
 // src/scripts/frameworkDetectors.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path18 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   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"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -4255,7 +4346,7 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs17.existsSync(path17.join(cwd, c))) return c;
+    if (fs18.existsSync(path18.join(cwd, c))) return c;
   }
   return null;
 }
@@ -4268,18 +4359,18 @@ var COLLECTION_DIRS = [
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path17.join(cwd, dir);
-    if (!fs17.existsSync(full)) continue;
+    const full = path18.join(cwd, dir);
+    if (!fs18.existsSync(full)) continue;
     let files;
     try {
-      files = fs17.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs18.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path17.join(full, file);
-        const content = fs17.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path18.join(full, file);
+        const content = fs18.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -4293,7 +4384,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path17.relative(cwd, filePath),
+          filePath: path18.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -4307,28 +4398,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 = path17.join(cwd, dir);
-    if (!fs17.existsSync(full)) continue;
+    const full = path18.join(cwd, dir);
+    if (!fs18.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs17.readdirSync(full, { withFileTypes: true });
+      entries = fs18.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path17.join(full, entry.name);
+      const entryPath = path18.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs17.existsSync(path17.join(entryPath, f))
+          (f) => fs18.existsSync(path18.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path17.relative(cwd, path17.join(entryPath, indexFile));
+        filePath = path18.relative(cwd, path18.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path17.relative(cwd, entryPath);
+        filePath = path18.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -4336,7 +4427,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs17.readFileSync(path17.join(cwd, col.filePath), "utf-8");
+            const colContent = fs18.readFileSync(path18.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -4355,8 +4446,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path17.join(cwd, appDir, "api");
-    if (!fs17.existsSync(apiDir)) continue;
+    const apiDir = path18.join(cwd, appDir, "api");
+    if (!fs18.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -4365,14 +4456,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs17.readdirSync(dir, { withFileTypes: true });
+    entries = fs18.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 = fs17.readFileSync(path17.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs18.readFileSync(path18.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)
       );
@@ -4380,7 +4471,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path17.relative(cwd, path17.join(dir, routeFile.name))
+          filePath: path18.relative(cwd, path18.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -4391,7 +4482,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(path17.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path18.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -4399,7 +4490,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path17.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path18.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 var BUILTIN_ENV_VARS = /* @__PURE__ */ new Set([
@@ -4419,10 +4510,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 = path17.join(cwd, envFile);
-    if (!fs17.existsSync(envPath)) continue;
+    const envPath = path18.join(cwd, envFile);
+    if (!fs18.existsSync(envPath)) continue;
     try {
-      const content = fs17.readFileSync(envPath, "utf-8");
+      const content = fs18.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -4470,9 +4561,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs18.readFileSync(path18.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs19.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    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";
+    const pm = fs19.existsSync(path19.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs19.existsSync(path19.join(cwd, "yarn.lock")) ? "yarn" : fs19.existsSync(path19.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;
@@ -4482,8 +4573,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path18.join(cwd, appDir);
-    if (!fs18.existsSync(full)) continue;
+    const full = path19.join(cwd, appDir);
+    if (!fs19.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -4491,7 +4582,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs19.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -4508,7 +4599,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(path18.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path19.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -4516,7 +4607,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path18.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path19.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -4533,23 +4624,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs18.existsSync(path18.join(cwd, c))) out.authFiles.push(c);
+    if (fs19.existsSync(path19.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 = path18.join(cwd, rp);
-    if (!fs18.existsSync(dir)) continue;
+    const dir = path19.join(cwd, rp);
+    if (!fs19.existsSync(dir)) continue;
     let files;
     try {
-      files = fs18.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs19.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs18.readFileSync(path18.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs19.readFileSync(path19.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) {
@@ -4782,8 +4873,8 @@ function failedAction3(reason) {
 }
 
 // src/scripts/dispatchJobFileTicks.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
+import * as fs21 from "fs";
+import * as path21 from "path";
 
 // src/scripts/jobFrontmatter.ts
 var SCHEDULE_EVERY_VALUES = [
@@ -5034,8 +5125,8 @@ var ContentsApiBackend = class {
 };
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs20 from "fs";
+import * as path20 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
@@ -5050,7 +5141,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 = path19.join(opts.cwd, opts.jobsDir);
+    this.absDir = path20.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
@@ -5065,7 +5156,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    fs19.mkdirSync(this.absDir, { recursive: true });
+    fs20.mkdirSync(this.absDir, { recursive: true });
     const prefix = this.cacheKeyPrefix();
     const probeKey = `${prefix}probe-${Date.now()}`;
     try {
@@ -5094,7 +5185,7 @@ var LocalFileBackend = class {
 `);
       return;
     }
-    if (!fs19.existsSync(this.absDir)) {
+    if (!fs20.existsSync(this.absDir)) {
       return;
     }
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -5110,11 +5201,11 @@ var LocalFileBackend = class {
   }
   load(slug) {
     const relPath = stateFilePath(this.jobsDir, slug);
-    const absPath = path19.join(this.cwd, relPath);
-    if (!fs19.existsSync(absPath)) {
+    const absPath = path20.join(this.cwd, relPath);
+    if (!fs20.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
     }
-    const raw = fs19.readFileSync(absPath, "utf-8");
+    const raw = fs20.readFileSync(absPath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -5131,10 +5222,10 @@ var LocalFileBackend = class {
     if (!loaded.created && isStateUnchanged(loaded.state, next)) {
       return false;
     }
-    const absPath = path19.join(this.cwd, loaded.path);
-    fs19.mkdirSync(path19.dirname(absPath), { recursive: true });
+    const absPath = path20.join(this.cwd, loaded.path);
+    fs20.mkdirSync(path20.dirname(absPath), { recursive: true });
     const body = JSON.stringify(next, null, 2) + "\n";
-    fs19.writeFileSync(absPath, body, "utf-8");
+    fs20.writeFileSync(absPath, body, "utf-8");
     return true;
   }
   cacheKeyPrefix() {
@@ -5211,7 +5302,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     await backend.hydrate();
   }
   try {
-    const slugs = listJobSlugs(path20.join(ctx.cwd, jobsDir));
+    const slugs = listJobSlugs(path21.join(ctx.cwd, jobsDir));
     ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
       process.stdout.write(`[jobs] no job files in ${jobsDir}
@@ -5310,17 +5401,17 @@ function formatAgo(ms) {
 }
 function readJobFrontmatter(cwd, jobsDir, slug) {
   try {
-    const raw = fs20.readFileSync(path20.join(cwd, jobsDir, `${slug}.md`), "utf-8");
+    const raw = fs21.readFileSync(path21.join(cwd, jobsDir, `${slug}.md`), "utf-8");
     return splitFrontmatter(raw).frontmatter;
   } catch {
     return {};
   }
 }
 function listJobSlugs(absDir) {
-  if (!fs20.existsSync(absDir)) return [];
+  if (!fs21.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs20.readdirSync(absDir, { withFileTypes: true });
+    entries = fs21.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -5687,54 +5778,61 @@ var finalizeGoal = async (ctx) => {
   if (!goal) return;
   process.stdout.write(`[goal-tick] all task(s) done \u2014 finalising goal ${goal.id}
 `);
-  const taskPrs = goal.openTaskPrs ?? [];
-  if (taskPrs.length === 0) {
-    process.stdout.write(`[goal-tick] no open task PRs \u2014 marking goal done without merge
+  const leaf = goal.leafPr;
+  if (!leaf) {
+    process.stdout.write(`[goal-tick] no leaf PR \u2014 marking goal done without merge
 `);
     goal.state = "done";
     return;
   }
-  const ordered = [...taskPrs].sort((a, b) => extractIssueNumber(a) - extractIssueNumber(b));
-  for (const pr of ordered) {
-    if (pr.baseRefName === goal.defaultBranch) continue;
+  if (leaf.baseRefName !== goal.defaultBranch) {
     process.stdout.write(
-      `[goal-tick] retargeting PR #${pr.number} base ${pr.baseRefName} \u2192 ${goal.defaultBranch}
+      `[goal-tick] retargeting leaf PR #${leaf.number} base ${leaf.baseRefName} \u2192 ${goal.defaultBranch}
 `
     );
-    const retarget = editPrBase(pr.number, goal.defaultBranch, ctx.cwd);
+    const retarget = editPrBase(leaf.number, goal.defaultBranch, ctx.cwd);
     if (!retarget.ok) {
-      process.stderr.write(`[goal-tick] finalizeGoal: editPrBase #${pr.number} failed: ${retarget.error}
+      process.stderr.write(`[goal-tick] finalizeGoal: editPrBase #${leaf.number} failed: ${retarget.error}
 `);
       return;
     }
   }
-  for (const pr of ordered) {
-    if (pr.isDraft) {
-      process.stdout.write(`[goal-tick] promoting draft PR #${pr.number} \u2192 ready
+  if (leaf.isDraft) {
+    process.stdout.write(`[goal-tick] promoting draft leaf PR #${leaf.number} \u2192 ready
 `);
-      const ready = markPrReady(pr.number, ctx.cwd);
-      if (!ready.ok) {
-        process.stderr.write(`[goal-tick] finalizeGoal: markPrReady #${pr.number} failed: ${ready.error}
+    const ready = markPrReady(leaf.number, ctx.cwd);
+    if (!ready.ok) {
+      process.stderr.write(`[goal-tick] finalizeGoal: markPrReady #${leaf.number} failed: ${ready.error}
 `);
-        return;
-      }
+      return;
     }
-    process.stdout.write(`[goal-tick] squash-merging PR #${pr.number} \u2192 ${goal.defaultBranch} (head=${pr.headRefName})
+  }
+  process.stdout.write(
+    `[goal-tick] squash-merging leaf PR #${leaf.number} \u2192 ${goal.defaultBranch} (cumulative goal diff)
+`
+  );
+  const merged = mergePrSquash(leaf.number, ctx.cwd);
+  if (!merged.ok) {
+    process.stderr.write(`[goal-tick] finalizeGoal: mergePrSquash #${leaf.number} failed: ${merged.error}
 `);
-    const merged = mergePrSquash(pr.number, ctx.cwd);
-    if (!merged.ok) {
-      process.stderr.write(`[goal-tick] finalizeGoal: mergePrSquash #${pr.number} failed: ${merged.error}
+    return;
+  }
+  const others = (goal.openTaskPrs ?? []).filter((p) => p.number !== leaf.number);
+  for (const pr of others) {
+    process.stdout.write(`[goal-tick] closing intermediate stacked PR #${pr.number} (subsumed by leaf merge)
+`);
+    const closed = closePr(
+      pr.number,
+      `_Stacked-PR finalize: this PR's content is included in the leaf squash to \`${goal.defaultBranch}\` (#${leaf.number})._`,
+      ctx.cwd
+    );
+    if (!closed.ok) {
+      process.stderr.write(`[goal-tick] finalizeGoal: closePr #${pr.number} failed: ${closed.error}
 `);
-      return;
     }
   }
   goal.state = "done";
 };
-function extractIssueNumber(pr) {
-  const m = pr.headRefName.match(/^(\d+)-/);
-  if (m?.[1]) return Number.parseInt(m[1], 10);
-  return pr.number;
-}
 
 // src/scripts/finishFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
@@ -5965,7 +6063,7 @@ function ensureFeatureBranch(issueNumber, title, defaultBranch, cwd, baseBranch)
 
 // src/gha.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -5976,10 +6074,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs21.existsSync(eventPath)) return;
+  if (!eventPath || !fs22.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs21.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs22.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -6264,22 +6362,22 @@ var handleAbandonedGoal = async (ctx) => {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 
 // src/scripts/loadQaGuide.ts
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs23 from "fs";
+import * as path22 from "path";
 var QA_GUIDE_REL_PATH = ".kody/qa-guide.md";
 var loadQaGuide = async (ctx) => {
-  const full = path21.join(ctx.cwd, QA_GUIDE_REL_PATH);
-  if (!fs22.existsSync(full)) {
+  const full = path22.join(ctx.cwd, QA_GUIDE_REL_PATH);
+  if (!fs23.existsSync(full)) {
     ctx.data.qaGuide = "";
     ctx.data.qaGuidePath = "";
     return;
   }
   try {
-    ctx.data.qaGuide = fs22.readFileSync(full, "utf-8");
+    ctx.data.qaGuide = fs23.readFileSync(full, "utf-8");
     ctx.data.qaGuidePath = QA_GUIDE_REL_PATH;
   } catch {
     ctx.data.qaGuide = "";
@@ -6289,9 +6387,9 @@ var loadQaGuide = async (ctx) => {
 
 // src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  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";
+  if (fs24.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs24.existsSync(path23.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs24.existsSync(path23.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -6413,48 +6511,48 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path22.join(cwd, "kody.config.json");
-  if (fs23.existsSync(configPath) && !force) {
+  const configPath = path23.join(cwd, "kody.config.json");
+  if (fs24.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs23.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs24.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path22.join(cwd, ".github", "workflows");
-  const workflowPath = path22.join(workflowDir, "kody.yml");
-  if (fs23.existsSync(workflowPath) && !force) {
+  const workflowDir = path23.join(cwd, ".github", "workflows");
+  const workflowPath = path23.join(workflowDir, "kody.yml");
+  if (fs24.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs23.mkdirSync(workflowDir, { recursive: true });
-    fs23.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs24.mkdirSync(workflowDir, { recursive: true });
+    fs24.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
-  const hasUi = fs23.existsSync(path22.join(cwd, "src/app")) || fs23.existsSync(path22.join(cwd, "app")) || fs23.existsSync(path22.join(cwd, "pages"));
+  const hasUi = fs24.existsSync(path23.join(cwd, "src/app")) || fs24.existsSync(path23.join(cwd, "app")) || fs24.existsSync(path23.join(cwd, "pages"));
   if (hasUi) {
-    const qaGuidePath = path22.join(cwd, QA_GUIDE_REL_PATH);
-    if (fs23.existsSync(qaGuidePath) && !force) {
+    const qaGuidePath = path23.join(cwd, QA_GUIDE_REL_PATH);
+    if (fs24.existsSync(qaGuidePath) && !force) {
       skipped.push(QA_GUIDE_REL_PATH);
     } else {
-      fs23.mkdirSync(path22.dirname(qaGuidePath), { recursive: true });
+      fs24.mkdirSync(path23.dirname(qaGuidePath), { recursive: true });
       const discovery = runQaDiscovery(cwd);
-      fs23.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
+      fs24.writeFileSync(qaGuidePath, generateQaGuideTemplate(discovery));
       wrote.push(QA_GUIDE_REL_PATH);
     }
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path22.join(cwd, ".kody", "jobs");
-    fs23.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path23.join(cwd, ".kody", "jobs");
+    fs24.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      const rel = path22.join(".kody", "jobs", `${job.slug}.md`);
-      const target = path22.join(cwd, rel);
-      if (fs23.existsSync(target) && !force) {
+      const rel = path23.join(".kody", "jobs", `${job.slug}.md`);
+      const target = path23.join(cwd, rel);
+      if (fs24.existsSync(target) && !force) {
         skipped.push(rel);
         continue;
       }
-      fs23.writeFileSync(target, fs23.readFileSync(job.filePath, "utf-8"));
+      fs24.writeFileSync(target, fs24.readFileSync(job.filePath, "utf-8"));
       wrote.push(rel);
     }
   }
@@ -6466,12 +6564,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path22.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs23.existsSync(target) && !force) {
+    const target = path23.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs24.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs23.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs24.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -6560,14 +6658,14 @@ var loadCoverageRules = async (ctx) => {
 };
 
 // src/goal/state.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
 var GoalStateError = class extends Error {
-  constructor(path31, message) {
-    super(`Invalid goal state at ${path31}:
+  constructor(path32, message) {
+    super(`Invalid goal state at ${path32}:
   ${message}`);
-    this.path = path31;
+    this.path = path32;
     this.name = "GoalStateError";
   }
   path;
@@ -6611,16 +6709,16 @@ function serializeGoalState(s) {
 `;
 }
 function goalStatePath(cwd, goalId) {
-  return path23.join(cwd, ".kody", "goals", goalId, "state.json");
+  return path24.join(cwd, ".kody", "goals", goalId, "state.json");
 }
 function readGoalState(cwd, goalId) {
   const file = goalStatePath(cwd, goalId);
-  if (!fs24.existsSync(file)) {
+  if (!fs25.existsSync(file)) {
     throw new GoalStateError(file, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs24.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs25.readFileSync(file, "utf-8"));
   } catch (err) {
     throw new GoalStateError(file, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -6628,8 +6726,8 @@ function readGoalState(cwd, goalId) {
 }
 function writeGoalState(cwd, goalId, state) {
   const file = goalStatePath(cwd, goalId);
-  fs24.mkdirSync(path23.dirname(file), { recursive: true });
-  fs24.writeFileSync(file, serializeGoalState(state), "utf-8");
+  fs25.mkdirSync(path24.dirname(file), { recursive: true });
+  fs25.writeFileSync(file, serializeGoalState(state), "utf-8");
 }
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -6723,8 +6821,8 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
 };
 
 // src/scripts/loadJobFromFile.ts
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
   const slugArg = String(args?.slugArg ?? "job");
@@ -6732,11 +6830,11 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   if (!slug) {
     throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path24.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs25.existsSync(absPath)) {
+  const absPath = path25.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs26.existsSync(absPath)) {
     throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
-  const raw = fs25.readFileSync(absPath, "utf-8");
+  const raw = fs26.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);
@@ -6768,16 +6866,16 @@ function humanizeSlug(slug) {
 }
 
 // src/scripts/loadMemoryContext.ts
-import * as fs26 from "fs";
-import * as path25 from "path";
+import * as fs27 from "fs";
+import * as path26 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 = path25.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-  if (!fs26.existsSync(memoryAbs)) {
+  const memoryAbs = path26.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+  if (!fs27.existsSync(memoryAbs)) {
     ctx.data.memoryContext = "";
     return;
   }
@@ -6802,21 +6900,21 @@ function collectPages(memoryAbs) {
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs26.statSync(file);
+      stat = fs27.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs26.readFileSync(file, "utf-8");
+      raw = fs27.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() ?? path25.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path26.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path25.relative(memoryAbs, file),
+      relPath: path26.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -6884,16 +6982,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs26.readdirSync(dir);
+      names = fs27.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path25.join(dir, name);
+      const full = path26.join(dir, name);
       let stat;
       try {
-        stat = fs26.statSync(full);
+        stat = fs27.statSync(full);
       } catch {
         continue;
       }
@@ -7001,8 +7099,8 @@ function formatReviewComments(raw) {
 init_events();
 
 // src/taskContext.ts
-import * as fs27 from "fs";
-import * as path26 from "path";
+import * as fs28 from "fs";
+import * as path27 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -7018,10 +7116,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path26.join(cwd, ".kody", "runs", ctx.runId);
-    fs27.mkdirSync(dir, { recursive: true });
-    const file = path26.join(dir, "task-context.json");
-    fs27.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path27.join(cwd, ".kody", "runs", ctx.runId);
+    fs28.mkdirSync(dir, { recursive: true });
+    const file = path27.join(dir, "task-context.json");
+    fs28.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -8376,8 +8474,8 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs28 from "fs";
-import * as path27 from "path";
+import * as fs29 from "fs";
+import * as path28 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -8389,13 +8487,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path27.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs28.existsSync(jobPath)) {
+  const jobPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs29.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs28.readFileSync(jobPath, "utf-8");
+  const raw = fs29.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -8403,8 +8501,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 = path27.isAbsolute(tickScript) ? tickScript : path27.join(ctx.cwd, tickScript);
-  if (!fs28.existsSync(scriptPath)) {
+  const scriptPath = path28.isAbsolute(tickScript) ? tickScript : path28.join(ctx.cwd, tickScript);
+  if (!fs29.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -9239,7 +9337,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -9261,7 +9359,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs29.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs30.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -9478,9 +9576,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path28.join(input.cwd, ".kody");
+  const ndjsonDir = path29.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path28.isAbsolute(p) ? p : path28.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path29.isAbsolute(p) ? p : path29.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -9607,6 +9705,33 @@ async function runExecutable(profileName, input) {
         const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`[kody] postflight "${label}" crashed: ${msg}
 `);
+        try {
+          const fsMod = await import("fs");
+          const pathMod = await import("path");
+          const { resolveRunId: resolveRunId2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+          const runId = resolveRunId2();
+          const dir = pathMod.join(input.cwd, ".kody", "runs", runId, "crashes");
+          fsMod.mkdirSync(dir, { recursive: true });
+          const file = pathMod.join(
+            dir,
+            `${label.replace(/[^a-zA-Z0-9_-]/g, "_")}-${Date.now()}.json`
+          );
+          fsMod.writeFileSync(
+            file,
+            JSON.stringify(
+              {
+                executable: profileName,
+                postflight: label,
+                message: msg,
+                stack: err instanceof Error ? err.stack : void 0,
+                ts: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            )
+          );
+        } catch {
+        }
         const summary = `postflight ${label} crashed: ${msg}`;
         ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${summary}` : summary;
         if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
@@ -9648,7 +9773,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs30.existsSync(profilePath)) return null;
+    if (!fs31.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -9657,17 +9782,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path28.dirname(new URL(import.meta.url).pathname);
+  const here = path29.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path28.join(here, "executables", profileName, "profile.json"),
+    path29.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path28.join(here, "..", "executables", profileName, "profile.json"),
+    path29.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path28.join(here, "..", "src", "executables", profileName, "profile.json")
+    path29.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs30.existsSync(c)) return c;
+    if (fs31.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -9764,8 +9889,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path28.join(profile.dir, shellName);
-  if (!fs30.existsSync(shellPath)) {
+  const shellPath = path29.join(profile.dir, shellName);
+  if (!fs31.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -9900,7 +10025,12 @@ async function runContainerLoop(profile, ctx, input) {
     const child = children[currentIdx];
     process.stderr.write(`[kody container] step ${iteration}: invoking ${child.exec}
 `);
-    resetWorkingTree(input.cwd);
+    if (profile.resetBetweenChildren !== false) {
+      resetWorkingTree(input.cwd);
+    } else {
+      process.stderr.write(`[kody container] resetBetweenChildren=false; preserving tracked tree
+`);
+    }
     const priorState = readContainerState(ctx, child, reader);
     if (priorState.core?.prUrl) knownPrUrl = priorState.core.prUrl;
     const priorAction = priorState.executables?.[child.exec]?.lastAction;
@@ -10210,9 +10340,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs31.existsSync(path29.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs31.existsSync(path29.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs31.existsSync(path29.join(cwd, "bun.lockb"))) return "bun";
+  if (fs32.existsSync(path30.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs32.existsSync(path30.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs32.existsSync(path30.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -10299,11 +10429,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path29.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path30.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs31.existsSync(logPath)) {
-      const content = fs31.readFileSync(logPath, "utf-8");
+    if (fs32.existsSync(logPath)) {
+      const content = fs32.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -10328,7 +10458,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path29.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path30.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -10338,9 +10468,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 && fs31.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs32.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs31.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs32.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);
@@ -10599,9 +10729,9 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path30.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path30.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs32.existsSync(path30.join(cwd, p)));
+  const sessionFile = path31.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path31.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs33.existsSync(path31.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -10639,7 +10769,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path30.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path31.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -10691,7 +10821,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs32.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs33.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {

package/dist/executables/types.ts

@@ -74,6 +74,16 @@ export interface Profile {
    * Defines the in-process step sequence and routing map. See ContainerChild.
    */
   children?: ContainerChild[]
+  /**
+   * Whether the container should `git reset --hard HEAD` between
+   * children to discard tracked-file modifications a prior child left
+   * behind. Default `true` (preserves the legacy bug-safe behaviour
+   * — see executor.ts:runContainerLoop notes). Set `false` for
+   * containers whose children are expected to share intermediate
+   * state (e.g. bug's `reproduce` writing a failing test that `run`
+   * then makes pass). Only honoured when `role === "container"`.
+   */
+  resetBetweenChildren?: boolean
   /** Absolute directory the profile was loaded from. Used to resolve prompt.md. */
   dir: string
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.59",
+  "version": "0.4.61",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",