@kody-ade/kody-engine 0.4.57 → 0.4.59

package/dist/bin/kody.js

@@ -1,9 +1,309 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/events.ts
+import * as crypto from "crypto";
+import * as fs3 from "fs";
+import * as path3 from "path";
+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 = path3.join(cwd, ".kody", "runs", runId, "events.jsonl");
+    fs3.mkdirSync(path3.dirname(eventsPath), { recursive: true });
+    fs3.appendFileSync(eventsPath, `${JSON.stringify(fullEvent)}
+`);
+  } catch {
+  }
+}
+function readEvents(cwd, runId) {
+  const eventsPath = path3.join(cwd, ".kody", "runs", runId, "events.jsonl");
+  if (!fs3.existsSync(eventsPath)) return [];
+  const lines = fs3.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 = path3.join(cwd, ".kody", "runs");
+  if (!fs3.existsSync(runsDir)) return [];
+  return fs3.readdirSync(runsDir).filter((name) => {
+    try {
+      return fs3.statSync(path3.join(runsDir, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+var cachedRunId;
+var init_events = __esm({
+  "src/events.ts"() {
+    "use strict";
+    cachedRunId = null;
+  }
+});
+
+// src/verify.ts
+import { spawn } from "child_process";
+function runCommand(command, cwd) {
+  return new Promise((resolve4) => {
+    const start = Date.now();
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const buffers = [];
+    let totalSize = 0;
+    const collect = (chunk) => {
+      buffers.push(chunk);
+      totalSize += chunk.length;
+      while (totalSize > TAIL_CHARS * 4 && buffers.length > 1) {
+        totalSize -= buffers[0].length;
+        buffers.shift();
+      }
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+    }, COMMAND_TIMEOUT_MS);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
+      resolve4({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve4({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+    });
+  });
+}
+async function verifyAll(config, cwd) {
+  const commands = [];
+  if (config.quality.typecheck) commands.push({ name: "typecheck", cmd: config.quality.typecheck });
+  if (config.quality.testUnit) commands.push({ name: "test", cmd: config.quality.testUnit });
+  if (config.quality.lint) commands.push({ name: "lint", cmd: config.quality.lint });
+  if (config.quality.format) commands.push({ name: "format", cmd: config.quality.format });
+  const failed = [];
+  const details = {};
+  for (const { name, cmd } of commands) {
+    const result = await runCommand(cmd, cwd);
+    details[name] = result;
+    if (result.exitCode !== 0) failed.push(name);
+  }
+  return { ok: failed.length === 0, failed, details };
+}
+async function applyTestRetries(initial, testCommand, cwd, runner, testRetries = DEFAULT_TEST_RETRIES) {
+  if (initial.ok) return { ...initial, recovered: [] };
+  const recovered = [];
+  const details = { ...initial.details };
+  let failed = [...initial.failed];
+  if (failed.includes("test") && testCommand && testRetries > 0) {
+    for (let attempt = 1; attempt <= testRetries; attempt++) {
+      const retry = await runner(testCommand, cwd);
+      details[`test (retry ${attempt})`] = retry;
+      if (retry.exitCode === 0) {
+        failed = failed.filter((f) => f !== "test");
+        recovered.push("test");
+        break;
+      }
+    }
+  }
+  return { ok: failed.length === 0, failed, details, recovered };
+}
+async function verifyAllWithRetry(config, cwd, opts) {
+  const initial = await verifyAll(config, cwd);
+  return applyTestRetries(initial, config.quality.testUnit, cwd, runCommand, opts?.testRetries);
+}
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function summarizeFailure(result) {
+  const lines = [`verify failed: ${result.failed.join(", ")}`];
+  for (const name of result.failed) {
+    const d = result.details[name];
+    if (!d) continue;
+    lines.push(`
+--- ${name} (exit ${d.exitCode}, ${(d.durationMs / 1e3).toFixed(1)}s) ---`);
+    lines.push(stripAnsi(d.tail));
+    for (let attempt = 1; ; attempt++) {
+      const retry = result.details[`${name} (retry ${attempt})`];
+      if (!retry) break;
+      lines.push(`
+--- ${name} (retry ${attempt}: exit ${retry.exitCode}, ${(retry.durationMs / 1e3).toFixed(1)}s) ---`);
+      lines.push(stripAnsi(retry.tail));
+    }
+  }
+  return lines.join("\n");
+}
+var TAIL_CHARS, COMMAND_TIMEOUT_MS, DEFAULT_TEST_RETRIES, ANSI_RE;
+var init_verify = __esm({
+  "src/verify.ts"() {
+    "use strict";
+    TAIL_CHARS = 4e3;
+    COMMAND_TIMEOUT_MS = 10 * 60 * 1e3;
+    DEFAULT_TEST_RETRIES = 2;
+    ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+  }
+});
+
+// src/verifyMcp.ts
+var verifyMcp_exports = {};
+__export(verifyMcp_exports, {
+  DEFAULT_MAX_VERIFY_ATTEMPTS: () => DEFAULT_MAX_VERIFY_ATTEMPTS,
+  buildVerifyMcpServer: () => buildVerifyMcpServer,
+  truncateVerifyResult: () => truncateVerifyResult
+});
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+function buildVerifyMcpServer(opts) {
+  const state = {
+    attempts: 0,
+    maxAttempts: opts.maxAttempts ?? DEFAULT_MAX_VERIFY_ATTEMPTS
+  };
+  const runVerify = opts.__runVerify ?? verifyAllWithRetry;
+  const verifyTool = tool(
+    "verify",
+    "Run the project's quality gates (typecheck, lint, tests). Returns ok=true with empty failures when everything passes. Call this before declaring DONE. If ok=false, read the truncated failures, fix the code, commit, and call verify() again. You have a bounded number of attempts; after that the tool stops accepting calls and you must wrap up with whatever state is current.",
+    {},
+    async (_args, _extra) => {
+      state.attempts++;
+      const attempt = state.attempts;
+      if (attempt > state.maxAttempts) {
+        emitEvent(opts.cwd, {
+          executable: opts.executable,
+          kind: "error",
+          name: "verify_tool",
+          outcome: "failed",
+          meta: { reason: "budget exhausted", attempts: attempt, maxAttempts: state.maxAttempts }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: false,
+                locked: true,
+                reason: `verify budget exhausted (${state.maxAttempts} attempts used)`
+              })
+            }
+          ]
+        };
+      }
+      const startedAt = Date.now();
+      const result = await runVerify(opts.config, opts.cwd);
+      const durationMs = Date.now() - startedAt;
+      emitEvent(opts.cwd, {
+        executable: opts.executable,
+        kind: "postflight",
+        name: `verify_attempt_${attempt}`,
+        durationMs,
+        outcome: result.ok ? "ok" : "failed",
+        meta: {
+          attempt,
+          failureCount: result.failed.length,
+          recovered: result.recovered ?? []
+        }
+      });
+      const payload = truncateVerifyResult(result, state, attempt);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(payload)
+          }
+        ]
+      };
+    }
+  );
+  return createSdkMcpServer({
+    name: "kody-verify",
+    version: "0.1.0",
+    tools: [verifyTool]
+  });
+}
+function truncateVerifyResult(result, state, attempt) {
+  const failures = result.failed.slice(0, 5).map((name) => {
+    const detail = result.details[name];
+    const tail = detail?.tail ?? "";
+    return {
+      name,
+      exitCode: detail?.exitCode ?? -1,
+      tail: tail.length > PER_FAILURE_TAIL_CHARS ? `\u2026${tail.slice(-PER_FAILURE_TAIL_CHARS)}` : tail
+    };
+  });
+  const payload = {
+    ok: result.ok,
+    attempt,
+    attemptsRemaining: Math.max(0, state.maxAttempts - attempt),
+    failures,
+    ...result.recovered && result.recovered.length > 0 ? { recovered: result.recovered } : {}
+  };
+  const json = JSON.stringify(payload);
+  if (json.length <= MAX_RESULT_BYTES) return payload;
+  for (const f of payload.failures) {
+    f.tail = f.tail.slice(-Math.max(120, Math.floor(PER_FAILURE_TAIL_CHARS / 4)));
+    if (JSON.stringify(payload).length <= MAX_RESULT_BYTES) return payload;
+  }
+  for (const f of payload.failures) f.tail = "";
+  return payload;
+}
+var DEFAULT_MAX_VERIFY_ATTEMPTS, MAX_RESULT_BYTES, PER_FAILURE_TAIL_CHARS;
+var init_verifyMcp = __esm({
+  "src/verifyMcp.ts"() {
+    "use strict";
+    init_events();
+    init_verify();
+    DEFAULT_MAX_VERIFY_ATTEMPTS = 4;
+    MAX_RESULT_BYTES = 2048;
+    PER_FAILURE_TAIL_CHARS = 600;
+  }
+});
 
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.57",
+  version: "0.4.59",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -29,7 +329,8 @@ var package_default = {
   },
   dependencies: {
     "@actions/cache": "^6.0.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.119"
+    "@anthropic-ai/claude-agent-sdk": "0.2.119",
+    zod: "^4.0.0"
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.12",
@@ -119,8 +420,8 @@ function makeRunId(sessionId, suffix) {
 }
 
 // src/agent.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/config.ts
@@ -412,10 +713,10 @@ function resolveTurnTimeoutMs(opts) {
   return DEFAULT_TURN_TIMEOUT_MS;
 }
 async function runAgent(opts) {
-  const ndjsonDir = opts.ndjsonDir ?? path3.join(opts.cwd, ".kody");
-  fs3.mkdirSync(ndjsonDir, { recursive: true });
-  const ndjsonPath = path3.join(ndjsonDir, "last-run.jsonl");
-  const fullLog = fs3.createWriteStream(ndjsonPath, { flags: "w" });
+  const ndjsonDir = opts.ndjsonDir ?? path4.join(opts.cwd, ".kody");
+  fs4.mkdirSync(ndjsonDir, { recursive: true });
+  const ndjsonPath = path4.join(ndjsonDir, "last-run.jsonl");
+  const fullLog = fs4.createWriteStream(ndjsonPath, { flags: "w" });
   const env = {
     ...process.env,
     SKIP_HOOKS: "1",
@@ -452,15 +753,27 @@ async function runAgent(opts) {
       permissionMode: opts.permissionModeOverride ?? "acceptEdits",
       env
     };
+    const mcpEntries = [];
     if (opts.mcpServers && opts.mcpServers.length > 0) {
-      queryOptions.mcpServers = Object.fromEntries(
-        opts.mcpServers.map((s) => {
-          const cfg = { command: s.command };
-          if (s.args) cfg.args = s.args;
-          if (s.env) cfg.env = s.env;
-          return [s.name, cfg];
-        })
-      );
+      for (const s of opts.mcpServers) {
+        const cfg = { command: s.command };
+        if (s.args) cfg.args = s.args;
+        if (s.env) cfg.env = s.env;
+        mcpEntries.push([s.name, cfg]);
+      }
+    }
+    if (opts.enableVerifyTool && opts.verifyConfig) {
+      const { buildVerifyMcpServer: buildVerifyMcpServer2 } = await Promise.resolve().then(() => (init_verifyMcp(), verifyMcp_exports));
+      const verifyServer = buildVerifyMcpServer2({
+        config: opts.verifyConfig,
+        cwd: opts.cwd,
+        executable: opts.executableName ?? "agent",
+        maxAttempts: typeof opts.verifyToolMaxAttempts === "number" && opts.verifyToolMaxAttempts > 0 ? opts.verifyToolMaxAttempts : void 0
+      });
+      mcpEntries.push(["kody-verify", verifyServer]);
+    }
+    if (mcpEntries.length > 0) {
+      queryOptions.mcpServers = Object.fromEntries(mcpEntries);
     }
     if (opts.pluginPaths && opts.pluginPaths.length > 0) {
       queryOptions.plugins = opts.pluginPaths.map((p) => ({ type: "local", path: p }));
@@ -588,14 +901,14 @@ async function runAgent(opts) {
 }
 
 // src/chat/session.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path4.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path5.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs4.existsSync(file)) return null;
-  const raw = fs4.readFileSync(file, "utf-8");
+  if (!fs5.existsSync(file)) return null;
+  const raw = fs5.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -608,8 +921,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs4.existsSync(file)) return [];
-  const raw = fs4.readFileSync(file, "utf-8").trim();
+  if (!fs5.existsSync(file)) return [];
+  const raw = fs5.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -625,14 +938,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs5.mkdirSync(path5.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs4.appendFileSync(file, `${line}
+  fs5.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -777,8 +1090,8 @@ async function emit(sink, type, sessionId, suffix, payload) {
 
 // src/chat/modes/interactive.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync } from "child_process";
@@ -935,9 +1248,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, verbose) {
-  const sessionRel = path5.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path5.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionRel, eventsRel].filter((p) => fs5.existsSync(path5.join(cwd, p)));
+  const sessionRel = path6.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path6.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionRel, eventsRel].filter((p) => fs6.existsSync(path6.join(cwd, p)));
   if (paths.length === 0) return;
   const stdio = verbose ? "inherit" : "pipe";
   const exec = (args) => execFileSync2("git", args, { cwd, stdio });
@@ -1017,7 +1330,7 @@ import * as fs31 from "fs";
 import * as path29 from "path";
 
 // src/dispatch.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -1082,48 +1395,48 @@ function cronMatchesInWindow(spec, end, windowSec) {
 }
 
 // src/registry.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 function getExecutablesRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "executables"),
+    path7.join(here, "executables"),
     // dev: src/
-    path6.join(here, "..", "executables"),
+    path7.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path6.join(here, "..", "src", "executables")
+    path7.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path6.join(process.cwd(), ".kody", "executables");
+  return path7.join(process.cwd(), ".kody", "executables");
 }
 function getBuiltinJobsRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "jobs"),
+    path7.join(here, "jobs"),
     // dev: src/
-    path6.join(here, "..", "jobs"),
+    path7.join(here, "..", "jobs"),
     // built: dist/bin → dist/jobs
-    path6.join(here, "..", "src", "jobs")
+    path7.join(here, "..", "src", "jobs")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
     if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
     const slug = ent.name.slice(0, -3);
-    out.push({ slug, filePath: path6.join(root, ent.name) });
+    out.push({ slug, filePath: path7.join(root, ent.name) });
   }
   out.sort((a, b) => a.slug.localeCompare(b.slug));
   return out;
@@ -1136,13 +1449,13 @@ function listExecutables(roots = getExecutableRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs6.existsSync(root)) continue;
-    const entries = fs6.readdirSync(root, { withFileTypes: true });
+    if (!fs7.existsSync(root)) continue;
+    const entries = fs7.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
-      const profilePath = path6.join(root, ent.name, "profile.json");
-      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+      const profilePath = path7.join(root, ent.name, "profile.json");
+      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -1154,8 +1467,8 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
   if (!isSafeName(name)) return null;
   const rootList = typeof roots === "string" ? [roots] : roots;
   for (const root of rootList) {
-    const profilePath = path6.join(root, name, "profile.json");
-    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+    const profilePath = path7.join(root, name, "profile.json");
+    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -1171,7 +1484,7 @@ function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -1220,10 +1533,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs7.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs8.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs7.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs8.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -1296,7 +1609,7 @@ function autoDispatchTyped(opts) {
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs7.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs8.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -1304,7 +1617,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs7.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs8.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -1338,7 +1651,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs7.readFileSync(exe.profilePath, "utf-8");
+      raw = fs8.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -1595,69 +1908,7 @@ function postPrReviewComment(prNumber, body, cwd) {
 import { execFileSync as execFileSync29, spawn as spawn5 } from "child_process";
 import * as fs30 from "fs";
 import * as path28 from "path";
-
-// 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();
-}
+init_events();
 
 // src/profile.ts
 import * as fs9 from "fs";
@@ -1792,6 +2043,8 @@ function parseClaudeCode(p, raw) {
     maxTurnTimeoutSec: typeof r.maxTurnTimeoutSec === "number" ? r.maxTurnTimeoutSec : null,
     systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
     cacheable: r.cacheable === true,
+    enableVerifyTool: r.enableVerifyTool === true,
+    verifyAttempts: typeof r.verifyAttempts === "number" && r.verifyAttempts > 0 ? r.verifyAttempts : null,
     tools,
     hooks: Array.isArray(r.hooks) ? r.hooks : [],
     skills: Array.isArray(r.skills) ? r.skills : [],
@@ -2085,7 +2338,7 @@ function errMsg(err) {
 }
 
 // src/litellm.ts
-import { execFileSync as execFileSync4, spawn } from "child_process";
+import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
 import * as fs10 from "fs";
 import * as os from "os";
 import * as path9 from "path";
@@ -2143,7 +2396,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const dotenvVars = readDotenvApiKeys(projectDir);
   const logPath = path9.join(os.tmpdir(), `kody-litellm-${Date.now()}.log`);
   const outFd = fs10.openSync(logPath, "w");
-  const child = spawn(cmd, args, {
+  const child = spawn2(cmd, args, {
     stdio: ["ignore", outFd, outFd],
     detached: true,
     env: stripBlockingEnv({ ...process.env, ...dotenvVars })
@@ -6744,6 +6997,9 @@ function formatReviewComments(raw) {
   }
 }
 
+// src/scripts/loadTaskContext.ts
+init_events();
+
 // src/taskContext.ts
 import * as fs27 from "fs";
 import * as path26 from "path";
@@ -8499,110 +8755,8 @@ function tryPostPr6(prNumber, body, cwd) {
   }
 }
 
-// src/verify.ts
-import { spawn as spawn2 } from "child_process";
-var TAIL_CHARS = 4e3;
-var COMMAND_TIMEOUT_MS = 10 * 60 * 1e3;
-var DEFAULT_TEST_RETRIES = 2;
-function runCommand(command, cwd) {
-  return new Promise((resolve4) => {
-    const start = Date.now();
-    const child = spawn2(command, {
-      cwd,
-      shell: true,
-      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const buffers = [];
-    let totalSize = 0;
-    const collect = (chunk) => {
-      buffers.push(chunk);
-      totalSize += chunk.length;
-      while (totalSize > TAIL_CHARS * 4 && buffers.length > 1) {
-        totalSize -= buffers[0].length;
-        buffers.shift();
-      }
-    };
-    child.stdout?.on("data", collect);
-    child.stderr?.on("data", collect);
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        if (!child.killed) child.kill("SIGKILL");
-      }, 5e3);
-    }, COMMAND_TIMEOUT_MS);
-    child.on("exit", (code) => {
-      clearTimeout(timer);
-      const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve4({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
-    });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      resolve4({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
-    });
-  });
-}
-async function verifyAll(config, cwd) {
-  const commands = [];
-  if (config.quality.typecheck) commands.push({ name: "typecheck", cmd: config.quality.typecheck });
-  if (config.quality.testUnit) commands.push({ name: "test", cmd: config.quality.testUnit });
-  if (config.quality.lint) commands.push({ name: "lint", cmd: config.quality.lint });
-  if (config.quality.format) commands.push({ name: "format", cmd: config.quality.format });
-  const failed = [];
-  const details = {};
-  for (const { name, cmd } of commands) {
-    const result = await runCommand(cmd, cwd);
-    details[name] = result;
-    if (result.exitCode !== 0) failed.push(name);
-  }
-  return { ok: failed.length === 0, failed, details };
-}
-async function applyTestRetries(initial, testCommand, cwd, runner, testRetries = DEFAULT_TEST_RETRIES) {
-  if (initial.ok) return { ...initial, recovered: [] };
-  const recovered = [];
-  const details = { ...initial.details };
-  let failed = [...initial.failed];
-  if (failed.includes("test") && testCommand && testRetries > 0) {
-    for (let attempt = 1; attempt <= testRetries; attempt++) {
-      const retry = await runner(testCommand, cwd);
-      details[`test (retry ${attempt})`] = retry;
-      if (retry.exitCode === 0) {
-        failed = failed.filter((f) => f !== "test");
-        recovered.push("test");
-        break;
-      }
-    }
-  }
-  return { ok: failed.length === 0, failed, details, recovered };
-}
-async function verifyAllWithRetry(config, cwd, opts) {
-  const initial = await verifyAll(config, cwd);
-  return applyTestRetries(initial, config.quality.testUnit, cwd, runCommand, opts?.testRetries);
-}
-var ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
-function stripAnsi(s) {
-  return s.replace(ANSI_RE, "");
-}
-function summarizeFailure(result) {
-  const lines = [`verify failed: ${result.failed.join(", ")}`];
-  for (const name of result.failed) {
-    const d = result.details[name];
-    if (!d) continue;
-    lines.push(`
---- ${name} (exit ${d.exitCode}, ${(d.durationMs / 1e3).toFixed(1)}s) ---`);
-    lines.push(stripAnsi(d.tail));
-    for (let attempt = 1; ; attempt++) {
-      const retry = result.details[`${name} (retry ${attempt})`];
-      if (!retry) break;
-      lines.push(`
---- ${name} (retry ${attempt}: exit ${retry.exitCode}, ${(retry.durationMs / 1e3).toFixed(1)}s) ---`);
-      lines.push(stripAnsi(retry.tail));
-    }
-  }
-  return lines.join("\n");
-}
-
 // src/scripts/verify.ts
+init_verify();
 var verify = async (ctx) => {
   try {
     const result = await verifyAllWithRetry(ctx.config, ctx.cwd);
@@ -9215,21 +9369,21 @@ function firstRequiredFailure(results, tools) {
   }
   return null;
 }
-function verifyOne(tool, cwd) {
-  const result = { name: tool.name, present: false, verified: false };
-  let present = runShell(tool.install.checkCommand, cwd);
-  if (!present && tool.install.installCommand) {
-    runShell(tool.install.installCommand, cwd, 12e4);
-    present = runShell(tool.install.checkCommand, cwd);
+function verifyOne(tool2, cwd) {
+  const result = { name: tool2.name, present: false, verified: false };
+  let present = runShell(tool2.install.checkCommand, cwd);
+  if (!present && tool2.install.installCommand) {
+    runShell(tool2.install.installCommand, cwd, 12e4);
+    present = runShell(tool2.install.checkCommand, cwd);
   }
   result.present = present;
   if (!present) {
-    result.error = `tool "${tool.name}" not on PATH (check: ${tool.install.checkCommand})`;
+    result.error = `tool "${tool2.name}" not on PATH (check: ${tool2.install.checkCommand})`;
     return result;
   }
-  const verified = runShell(tool.verify, cwd);
+  const verified = runShell(tool2.verify, cwd);
   result.verified = verified;
-  if (!verified) result.error = `tool "${tool.name}" failed verify: ${tool.verify}`;
+  if (!verified) result.error = `tool "${tool2.name}" failed verify: ${tool2.verify}`;
   return result;
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
@@ -9346,6 +9500,10 @@ async function runExecutable(profileName, input) {
       maxTurnTimeoutMs: typeof profile.claudeCode.maxTurnTimeoutSec === "number" ? Math.floor(profile.claudeCode.maxTurnTimeoutSec * 1e3) : void 0,
       systemPromptAppend: profile.claudeCode.systemPromptAppend,
       cacheable: profile.claudeCode.cacheable,
+      enableVerifyTool: profile.claudeCode.enableVerifyTool,
+      verifyToolMaxAttempts: profile.claudeCode.verifyAttempts ?? null,
+      verifyConfig: profile.claudeCode.enableVerifyTool ? config : void 0,
+      executableName: profileName,
       settingSources: profile.claudeCode.settingSources
     });
   };
@@ -10571,6 +10729,7 @@ ${CHAT_HELP}`);
 }
 
 // src/stats.ts
+init_events();
 function parseStatsArgs(argv) {
   const out = { cwd: process.cwd() };
   for (let i = 0; i < argv.length; i++) {

package/dist/executables/fix/profile.json

@@ -26,6 +26,8 @@
     "maxTurnTimeoutSec": 1200,
     "systemPromptAppend": null,
     "cacheable": true,
+    "enableVerifyTool": true,
+    "verifyAttempts": 4,
     "tools": [
       "Read",
       "Write",
@@ -33,7 +35,8 @@
       "Bash",
       "Grep",
       "Glob",
-      "mcp__playwright"
+      "mcp__playwright",
+      "mcp__kody-verify"
     ],
     "hooks": ["block-git"],
     "skills": [],

package/dist/executables/fix/prompt.md

@@ -32,7 +32,7 @@ If a prior-art block is present above, scan it before editing — those are earl
    - Read the **full** contents of every file you intend to change.
    - Read the test file for each of those files, if one exists.
    - Skipping the floor on the assumption "feedback says exactly what to change" is a hard failure when the change touches code with non-obvious invariants.
-4. **Verify** — run each quality command with Bash. Fix the root cause of any failure you introduced by this round of edits.
+4. **Verify** — before declaring DONE, call the `verify` tool (mcp__kody-verify__verify). It runs the project's typecheck/lint/test gates and returns `{ ok, failures, attemptsRemaining }`. If `ok: true`, proceed to DONE. If `ok: false`, read the truncated `failures` list, fix what you introduced this round (not pre-existing breakages unrelated to the feedback), and call `verify` again. Bounded by 4 attempts; after that the tool returns `locked: true` and you must wrap up. The postflight verifier still runs after this session as the final ratifier.
 5. Your FINAL message MUST use this exact format (or a single `FAILED: <reason>` line on failure). The `FEEDBACK_ACTIONS:` block is REQUIRED — omitting it or leaving it empty makes your DONE invalid.
 
    ```

package/dist/executables/fix-ci/profile.json

@@ -25,13 +25,16 @@
     "maxTurnTimeoutSec": 1200,
     "systemPromptAppend": null,
     "cacheable": true,
+    "enableVerifyTool": true,
+    "verifyAttempts": 4,
     "tools": [
       "Read",
       "Write",
       "Edit",
       "Bash",
       "Grep",
-      "Glob"
+      "Glob",
+      "mcp__kody-verify"
     ],
     "hooks": ["block-git"],
     "skills": [],

package/dist/executables/fix-ci/prompt.md

@@ -36,7 +36,7 @@ You are Kody, an autonomous engineer. A CI workflow on PR #{{pr.number}} (`{{bra
 
 2. **Make the minimum edits to fix the root cause.** Do not bundle unrelated cleanups into a CI fix.
 
-3. **Re-run the relevant quality command locally with Bash and confirm exit 0.**
+3. **Confirm green via the `verify` tool** — call `mcp__kody-verify__verify` to run the project's typecheck/lint/test gates. If `ok: false`, read the truncated `failures`, fix the root cause, and call `verify` again. Bounded by 4 attempts; after that the tool returns `locked: true` and you must wrap up with FAILED. The postflight verifier still runs after this session as the final ratifier.
 
 4. **Final message format** (or `FAILED: <reason>` on failure):
 

package/dist/executables/run/profile.json

@@ -25,13 +25,16 @@
     "maxTurnTimeoutSec": 1200,
     "systemPromptAppend": null,
     "cacheable": true,
+    "enableVerifyTool": true,
+    "verifyAttempts": 4,
     "tools": [
       "Read",
       "Write",
       "Edit",
       "Bash",
       "Grep",
-      "Glob"
+      "Glob",
+      "mcp__kody-verify"
     ],
     "hooks": ["block-git"],
     "skills": [],

package/dist/executables/run/prompt.md

@@ -40,7 +40,7 @@ If a prior-art block is present above, READ THE DIFFS — those are failed or su
 2. **Plan** — before any Edit/Write, output a short plan (5–10 lines): what files you'll change, the approach, what could go wrong. No fluff.
 3. **Build** — Edit/Write to implement the change. Stay within the plan; if you discover the plan was wrong, briefly say so and adjust.
 4. **Test** — for every new module you added and every behavior you changed, write or update tests. If the plan above contains a "Test plan" section, treat it as authoritative: every item there must produce a corresponding test. Before writing a test, open the newest existing file in the same test directory (`tests/int/`, `tests/unit/`, `tests/e2e/`, or sibling `*.test.ts`) and copy its imports, setup hooks, and auth pattern **verbatim**. Do NOT introduce a new test infrastructure (own testcontainers, `fetch` against relative URLs, alternate auth headers) when a working pattern already exists in that directory — divergence from the established pattern is a hard failure even if the test passes locally. Cover at least one happy path and one failure path per change. Skipping tests is a hard failure. A change may only be declared untestable if you can name the specific blocker (e.g., "no fake exists for the X SDK and stubbing it would mock the entire call surface"); vague "this is just config" claims are rejected. Untestable changes go in `PLAN_DEVIATIONS:` with the named blocker.
-5. **Verify** — run each quality command with Bash. On failure, fix the root cause and re-run. When reporting that a command passed, you MUST have just run it and seen exit code 0 in this session — do not paraphrase prior output.
+5. **Verify** — before declaring DONE, call the `verify` tool (mcp__kody-verify__verify). It runs typecheck/lint/tests with the project's configured commands and returns `{ ok, failures, attemptsRemaining }`. If `ok: true`, you may proceed to DONE. If `ok: false`, read the truncated `failures` list, fix the root cause, commit-equivalent edits, and call `verify` again. You have up to 4 total attempts; the tool will return `locked: true` after that and you must wrap up with FAILED. The postflight verifier runs again after this session ends and is the final ratifier — but it's also the gate that downgrades a self-reported DONE to FAILED if you skipped this step, so calling the tool is strictly cheaper than not.
 6. Your FINAL message must use this exact format (or a single `FAILED: <reason>` line on failure). The `PLAN_DEVIATIONS:` block is REQUIRED whenever a plan was provided.
 
    ```

package/dist/executables/types.ts

@@ -177,6 +177,21 @@ export interface ClaudeCodeSpec {
    * not support `excludeDynamicSections` (forward-compatible).
    */
   cacheable?: boolean
+  /**
+   * Phase 3 opt-in: expose an in-process `verify` MCP tool to the agent
+   * so it can iterate on typecheck/lint/test failures inside one SDK
+   * session instead of needing a `fix-ci` round trip. The tool is
+   * bounded by `verifyAttempts` (default 4). The postflight `verify`
+   * script still runs after the agent finishes as the final ratifier.
+   * Default false.
+   */
+  enableVerifyTool?: boolean
+  /**
+   * Hard cap on verify-tool invocations per agent session when
+   * `enableVerifyTool` is true. Default 4 (≈3 fix iterations after the
+   * first attempt). Set to 0 or omit to use the default.
+   */
+  verifyAttempts?: number | null
   /** SDK built-in tools this executable is allowed to use (capability pack). */
   tools: string[]
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.57",
+  "version": "0.4.59",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,21 +12,10 @@
     "templates",
     "kody.config.schema.json"
   ],
-  "scripts": {
-    "kody": "tsx bin/kody.ts",
-    "build": "tsup && node scripts/copy-assets.cjs",
-    "test": "vitest run tests/unit tests/int --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write",
-    "prepublishOnly": "pnpm build"
-  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.119"
+    "@anthropic-ai/claude-agent-sdk": "0.2.119",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
@@ -44,5 +33,16 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
+  "scripts": {
+    "kody": "tsx bin/kody.ts",
+    "build": "tsup && node scripts/copy-assets.cjs",
+    "test": "vitest run tests/unit tests/int --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write"
+  }
+}