@kody-ade/kody-engine 0.4.60 → 0.4.62

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.60",
+  version: "0.4.62",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -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`);
@@ -5738,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";
@@ -9658,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;

package/package.json

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