@kody-ade/kody-engine 0.4.78 → 0.4.80

package/dist/bin/kody.js

@@ -49,17 +49,17 @@ function emitEvent(cwd, ev) {
       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)}
+    const eventsPath2 = path3.join(cwd, ".kody", "runs", runId, "events.jsonl");
+    fs3.mkdirSync(path3.dirname(eventsPath2), { recursive: true });
+    fs3.appendFileSync(eventsPath2, `${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 eventsPath2 = path3.join(cwd, ".kody", "runs", runId, "events.jsonl");
+  if (!fs3.existsSync(eventsPath2)) return [];
+  const lines = fs3.readFileSync(eventsPath2, "utf-8").split("\n");
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -213,7 +213,7 @@ function buildVerifyMcpServer(opts) {
     attempts: 0,
     maxAttempts: opts.maxAttempts ?? DEFAULT_MAX_VERIFY_ATTEMPTS
   };
-  const runVerify = opts.__runVerify ?? verifyAllWithRetry;
+  const runVerify2 = 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.",
@@ -243,7 +243,7 @@ function buildVerifyMcpServer(opts) {
         };
       }
       const startedAt = Date.now();
-      const result = await runVerify(opts.config, opts.cwd);
+      const result = await runVerify2(opts.config, opts.cwd);
       const durationMs = Date.now() - startedAt;
       emitEvent(opts.cwd, {
         executable: opts.executable,
@@ -868,7 +868,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.78",
+  version: "0.4.80",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -923,8 +923,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs35 from "fs";
-import * as path32 from "path";
+import * as fs36 from "fs";
+import * as path33 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1699,7 +1699,7 @@ function seedInitialMessage(file, message) {
 var CHAT_SYSTEM_PROMPT = [
   "You are Kody, an AI assistant for the Kody Operations Dashboard. Reply to the",
   "user's latest message using the full conversation below as context. Keep replies",
-  "focused, technical when appropriate, and formatted in Markdown.",
+  "short and simple. Prefer one-liners and short paragraphs. Use plain terms, not jargon.",
   "",
   "# Your environment and capabilities",
   "You run inside a sandboxed runner with a full clone of the user's repository",
@@ -2178,8 +2178,8 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs34 from "fs";
-import * as path31 from "path";
+import * as fs35 from "fs";
+import * as path32 from "path";
 
 // src/dispatch.ts
 import * as fs9 from "fs";
@@ -2501,8 +2501,8 @@ init_issue();
 
 // src/executor.ts
 import { execFileSync as execFileSync29, spawn as spawn6 } from "child_process";
-import * as fs33 from "fs";
-import * as path30 from "path";
+import * as fs34 from "fs";
+import * as path31 from "path";
 init_events();
 
 // src/lifecycleLabels.ts
@@ -2546,7 +2546,7 @@ function prBranchLifecycle(profile, profilePath) {
   const afterPreflight = cfg.context === "minimal" && cfg.contextExtras.length === 0 ? [{ script: "composePrompt" }] : [...contextBundle, { script: "composePrompt" }];
   profile.scripts.preflight = [...before, ...profile.scripts.preflight, ...afterPreflight];
   const beforePostflight = [{ script: "parseAgentResult" }];
-  const verifyChain = cfg.verify ? [{ script: "verify" }, { script: "checkCoverageWithRetry" }, { script: "abortUnfinishedGitOps" }] : [];
+  const verifyChain = cfg.verify ? [{ script: "verifyWithRetry" }, { script: "checkCoverageWithRetry" }, { script: "abortUnfinishedGitOps" }] : [];
   const tail = [
     ...verifyChain,
     { script: "commitAndPush" },
@@ -5586,6 +5586,10 @@ function parseFlatYaml(text) {
       out.every = value;
     } else if (key === "tickScript" && value.length > 0) {
       out.tickScript = value;
+    } else if (key === "disabled") {
+      const lower = value.toLowerCase();
+      if (lower === "true") out.disabled = true;
+      else if (lower === "false") out.disabled = false;
     }
   }
   return out;
@@ -5946,6 +5950,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     throw new Error("dispatchJobFileTicks: `with.targetExecutable` is required");
   }
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const scriptedExecutable = String(args?.scriptedExecutable ?? "job-tick-scripted");
   const slugArg = String(args?.slugArg ?? "job");
   const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   if (backend.hydrate) {
@@ -5965,6 +5970,12 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
     const now = Date.now();
     for (const slug of slugs) {
       const frontmatter = readJobFrontmatter(ctx.cwd, jobsDir, slug);
+      if (frontmatter.disabled === true) {
+        process.stdout.write(`[jobs] \u23ED  skip ${slug}: disabled in frontmatter
+`);
+        results.push({ slug, exitCode: 0, skipped: true, reason: "disabled" });
+        continue;
+      }
       const decision = await decideShouldFire(frontmatter.every, slug, backend, now);
       if (decision.skip) {
         process.stdout.write(`[jobs] \u23ED  skip ${slug}: ${decision.reason}
@@ -5972,7 +5983,7 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
         results.push({ slug, exitCode: 0, skipped: true, reason: decision.reason });
         continue;
       }
-      const slugTarget = frontmatter.tickScript ? "job-tick-scripted" : targetExecutable;
+      const slugTarget = frontmatter.tickScript ? scriptedExecutable : targetExecutable;
       process.stdout.write(`[jobs] \u2192 tick ${slug} (${slugTarget})
 `);
       try {
@@ -7336,10 +7347,10 @@ import * as fs26 from "fs";
 import * as path24 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
 var GoalStateError = class extends Error {
-  constructor(path33, message) {
-    super(`Invalid goal state at ${path33}:
+  constructor(path34, message) {
+    super(`Invalid goal state at ${path34}:
   ${message}`);
-    this.path = path33;
+    this.path = path34;
     this.name = "GoalStateError";
   }
   path;
@@ -9063,8 +9074,168 @@ function buildChildEnv(parent, force) {
 
 // src/scripts/brainServe.ts
 import { createServer } from "http";
+import * as fs32 from "fs";
+import * as path30 from "path";
+
+// src/scripts/brainTurnLog.ts
 import * as fs31 from "fs";
 import * as path29 from "path";
+var live = /* @__PURE__ */ new Map();
+function eventsPath(dir, chatId) {
+  return path29.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+}
+function lastPersistedSeq(dir, chatId) {
+  const p = eventsPath(dir, chatId);
+  if (!fs31.existsSync(p)) return 0;
+  const lines = fs31.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (lines.length === 0) return 0;
+  try {
+    return JSON.parse(lines[lines.length - 1]).seq || 0;
+  } catch {
+    return 0;
+  }
+}
+function readSince(dir, chatId, since) {
+  const p = eventsPath(dir, chatId);
+  if (!fs31.existsSync(p)) return [];
+  const out = [];
+  for (const line of fs31.readFileSync(p, "utf-8").split("\n")) {
+    if (!line) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (rec.seq > since) out.push(rec);
+    } catch {
+    }
+  }
+  return out;
+}
+function isTerminal(event) {
+  return event.type === "done" || event.type === "error";
+}
+function beginTurn(dir, chatId) {
+  const existing = live.get(chatId);
+  const seqFloor = existing ? existing.seq : lastPersistedSeq(dir, chatId);
+  const turn = (existing?.turn ?? 0) + 1;
+  const state = {
+    seq: seqFloor,
+    turn,
+    status: "running",
+    terminal: null,
+    subscribers: /* @__PURE__ */ new Set()
+  };
+  live.set(chatId, state);
+  const p = eventsPath(dir, chatId);
+  fs31.mkdirSync(path29.dirname(p), { recursive: true });
+  return (event) => {
+    state.seq += 1;
+    const rec = { seq: state.seq, turn, ts: Date.now(), event };
+    try {
+      fs31.appendFileSync(p, JSON.stringify(rec) + "\n");
+    } catch (err) {
+      process.stderr.write(
+        `[brain-turn-log] append failed for ${chatId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    for (const fn of state.subscribers) {
+      try {
+        fn(rec);
+      } catch {
+      }
+    }
+    if (isTerminal(event)) {
+      state.status = "ended";
+      state.terminal = rec;
+      const subs = [...state.subscribers];
+      state.subscribers.clear();
+      for (const fn of subs) {
+        try {
+          fn(null);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function endTurnIfUnterminated(dir, chatId, errMessage) {
+  const state = live.get(chatId);
+  if (!state || state.status === "ended") return;
+  state.seq += 1;
+  const rec = {
+    seq: state.seq,
+    turn: state.turn,
+    ts: Date.now(),
+    event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
+  };
+  try {
+    fs31.appendFileSync(eventsPath(dir, chatId), JSON.stringify(rec) + "\n");
+  } catch {
+  }
+  state.status = "ended";
+  state.terminal = rec;
+  const subs = [...state.subscribers];
+  state.subscribers.clear();
+  for (const fn of subs) {
+    try {
+      fn(rec);
+      fn(null);
+    } catch {
+    }
+  }
+}
+function subscribe(dir, chatId, since, onRecord, onClose) {
+  const backlog = readSince(dir, chatId, since);
+  for (const rec of backlog) onRecord(rec);
+  const lastReplayed = backlog.length ? backlog[backlog.length - 1] : null;
+  if (lastReplayed && isTerminal(lastReplayed.event)) {
+    onClose();
+    return () => {
+    };
+  }
+  const state = live.get(chatId);
+  if (state && state.status === "running") {
+    const fn = (rec) => {
+      if (rec === null) {
+        state.subscribers.delete(fn);
+        onClose();
+        return;
+      }
+      if (rec.seq > since) onRecord(rec);
+    };
+    state.subscribers.add(fn);
+    return () => {
+      state.subscribers.delete(fn);
+    };
+  }
+  if (state && state.status === "ended" && state.terminal) {
+    if (state.terminal.seq > since && !lastReplayed) onRecord(state.terminal);
+    onClose();
+    return () => {
+    };
+  }
+  if (lastReplayed) {
+    onRecord({
+      seq: lastReplayed.seq + 1,
+      turn: lastReplayed.turn,
+      ts: Date.now(),
+      event: {
+        type: "error",
+        error: "stream interrupted (server restarted mid-reply) \u2014 resend your message",
+        chatId
+      }
+    });
+  }
+  onClose();
+  return () => {
+  };
+}
+function getLastSeq(dir, chatId) {
+  const state = live.get(chatId);
+  if (state) return state.seq;
+  return lastPersistedSeq(dir, chatId);
+}
+
+// src/scripts/brainServe.ts
 var DEFAULT_PORT = 8080;
 function getApiKey() {
   const key = (process.env.BRAIN_API_KEY ?? "").trim();
@@ -9120,47 +9291,86 @@ function emitSse(res, event) {
 
 `);
 }
-var BrainSseSink = class {
-  constructor(res, chatId) {
-    this.res = res;
+function translateChatEvent(event, chatId) {
+  switch (event.event) {
+    case "chat.message": {
+      const content = String(event.payload.content ?? "");
+      if (content.length === 0) return null;
+      return { type: "text", text: content, chatId };
+    }
+    case "chat.tool": {
+      if (event.payload.phase !== "use") return null;
+      return {
+        type: "tool_use",
+        name: typeof event.payload.name === "string" ? event.payload.name : "tool",
+        input: event.payload.input ?? {},
+        chatId
+      };
+    }
+    case "chat.done":
+      return { type: "done", chatId };
+    case "chat.error":
+      return {
+        type: "error",
+        error: typeof event.payload.error === "string" ? event.payload.error : "agent error",
+        chatId
+      };
+    default:
+      return null;
+  }
+}
+var BrokerSink = class {
+  constructor(emitToLog, chatId) {
+    this.emitToLog = emitToLog;
     this.chatId = chatId;
   }
-  res;
+  emitToLog;
   chatId;
   async emit(event) {
-    switch (event.event) {
-      case "chat.message": {
-        const content = String(event.payload.content ?? "");
-        if (content.length > 0) {
-          emitSse(this.res, { type: "text", text: content, chatId: this.chatId });
+    const be = translateChatEvent(event, this.chatId);
+    if (be) this.emitToLog(be);
+  }
+};
+var chatQueues = /* @__PURE__ */ new Map();
+function enqueue(chatId, fn) {
+  const prev = chatQueues.get(chatId) ?? Promise.resolve();
+  const next = prev.catch(() => {
+  }).then(fn);
+  chatQueues.set(
+    chatId,
+    next.finally(() => {
+      if (chatQueues.get(chatId) === next) chatQueues.delete(chatId);
+    })
+  );
+  return next;
+}
+function streamToRes(res, dir, chatId, since) {
+  writeSseHeaders(res);
+  emitSse(res, { type: "chat", chatId });
+  let maxSent = since;
+  const unsubscribe = subscribe(
+    dir,
+    chatId,
+    since,
+    (rec) => {
+      if (rec.seq <= maxSent) return;
+      maxSent = rec.seq;
+      if (res.writableEnded) return;
+      res.write(`data: ${JSON.stringify({ ...rec.event, seq: rec.seq })}
+
+`);
+    },
+    () => {
+      if (!res.writableEnded) {
+        try {
+          res.end();
+        } catch {
         }
-        return;
       }
-      case "chat.tool": {
-        if (event.payload.phase !== "use") return;
-        emitSse(this.res, {
-          type: "tool_use",
-          name: typeof event.payload.name === "string" ? event.payload.name : "tool",
-          input: event.payload.input ?? {},
-          chatId: this.chatId
-        });
-        return;
-      }
-      case "chat.done": {
-        emitSse(this.res, { type: "done", chatId: this.chatId });
-        return;
-      }
-      case "chat.error": {
-        const errMsg2 = typeof event.payload.error === "string" ? event.payload.error : "agent error";
-        emitSse(this.res, { type: "error", error: errMsg2, chatId: this.chatId });
-        return;
-      }
-      // chat.thinking / chat.ready / chat.exit — not part of the Brain protocol.
-      default:
-        return;
     }
-  }
-};
+  );
+  res.on("close", unsubscribe);
+}
 async function handleChatTurn(req, res, chatId, opts) {
   let body;
   try {
@@ -9175,38 +9385,34 @@ async function handleChatTurn(req, res, chatId, opts) {
     return;
   }
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs31.mkdirSync(path29.dirname(sessionFile), { recursive: true });
+  fs32.mkdirSync(path30.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeSseHeaders(res);
-  emitSse(res, { type: "chat", chatId });
-  const sink = new BrainSseSink(res, chatId);
-  try {
-    await opts.runTurn({
+  const sinceFloor = getLastSeq(opts.cwd, chatId);
+  const emitToLog = beginTurn(opts.cwd, chatId);
+  const sink = new BrokerSink(emitToLog, chatId);
+  void enqueue(
+    chatId,
+    () => opts.runTurn({
       sessionId: chatId,
       sessionFile,
       cwd: opts.cwd,
       model: opts.model,
       litellmUrl: opts.litellmUrl,
       sink
-    });
-  } catch (err) {
-    const errMsg2 = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[brain-serve] chat turn failed: ${errMsg2}
+    }).catch((err) => {
+      const errMsg2 = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[brain-serve] chat turn failed: ${errMsg2}
 `);
-    try {
-      emitSse(res, { type: "error", error: errMsg2, chatId });
-    } catch {
-    }
-  } finally {
-    try {
-      res.end();
-    } catch {
-    }
-  }
+      endTurnIfUnterminated(opts.cwd, chatId, errMsg2);
+    }).finally(() => {
+      endTurnIfUnterminated(opts.cwd, chatId, "turn ended without a result");
+    })
+  );
+  streamToRes(res, opts.cwd, chatId, sinceFloor);
 }
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
@@ -9239,6 +9445,18 @@ function buildServer(opts) {
       });
       return;
     }
+    const sm = url.pathname.match(/^\/chats\/([^/]+)\/stream\/?$/);
+    if (req.method === "GET" && sm) {
+      const chatId = decodeURIComponent(sm[1] ?? "");
+      if (!chatId) {
+        sendJson(res, 400, { error: "chatId required" });
+        return;
+      }
+      const sinceRaw = url.searchParams.get("since");
+      const since = Number.isFinite(Number(sinceRaw)) ? Number(sinceRaw) : 0;
+      streamToRes(res, opts.cwd, chatId, since);
+      return;
+    }
     sendJson(res, 404, { error: "not found" });
   });
 }
@@ -9796,6 +10014,96 @@ function downgrade2(ctx, reason) {
   ctx.data.agentDone = false;
 }
 
+// src/scripts/verifyWithRetry.ts
+init_prompt();
+init_verify();
+async function runVerify(ctx) {
+  try {
+    const result = await verifyAllWithRetry(ctx.config, ctx.cwd);
+    ctx.data.verifyOk = result.ok;
+    ctx.data.verifyReason = result.ok ? "" : summarizeFailure(result);
+    ctx.data.verifyRecovered = result.recovered ?? [];
+    if (result.recovered && result.recovered.length > 0) {
+      process.stderr.write(
+        `[kody verify] caught flake on: ${result.recovered.join(", ")} (passed on retry)
+`
+      );
+    }
+  } catch (err) {
+    ctx.data.verifyOk = false;
+    ctx.data.verifyReason = `verify crashed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function downgradeActionOnFailure(ctx) {
+  if (ctx.data.verifyOk !== false) return;
+  const action = ctx.data.action;
+  if (!action || !action.type.endsWith("_COMPLETED")) return;
+  const reason = ctx.data.verifyReason || "verify failed";
+  ctx.data.action = {
+    type: action.type.replace(/_COMPLETED$/, "_FAILED"),
+    payload: { reason, downgradedFrom: action.type },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function upgradeActionOnPass(ctx) {
+  if (ctx.data.verifyOk !== true) return;
+  const action = ctx.data.action;
+  if (!action || !action.type.endsWith("_FAILED")) return;
+  const downgradedFrom = action.payload?.downgradedFrom;
+  if (!downgradedFrom || !downgradedFrom.endsWith("_COMPLETED")) return;
+  ctx.data.action = {
+    type: downgradedFrom,
+    payload: {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var verifyWithRetry = async (ctx) => {
+  await runVerify(ctx);
+  if (ctx.data.verifyOk !== false) return;
+  if (!ctx.data.agentDone) {
+    downgradeActionOnFailure(ctx);
+    return;
+  }
+  const invoker = ctx.data.__invokeAgent;
+  const basePrompt = ctx.data.prompt;
+  if (!invoker || !basePrompt) {
+    downgradeActionOnFailure(ctx);
+    return;
+  }
+  const reason = ctx.data.verifyReason || "verify failed";
+  process.stderr.write(`[kody] verify failed; retrying agent once with verify output as feedback
+`);
+  const retryPrompt = [
+    basePrompt,
+    "",
+    "# Verify failure (retry)",
+    "",
+    "The quality gate failed after your previous attempt. Read the output below,",
+    "fix the underlying issue (do NOT relax the gate or skip tests), then re-emit",
+    "your result. You have one retry \u2014 make it count.",
+    "",
+    reason
+  ].join("\n");
+  try {
+    const retry = await invoker(retryPrompt);
+    const parsed = parseAgentResult(retry.finalText);
+    if (retry.outcome === "completed" && parsed.done) {
+      ctx.data.agentDone = true;
+      ctx.data.commitMessage = parsed.commitMessage || ctx.data.commitMessage;
+      ctx.data.prSummary = parsed.prSummary || ctx.data.prSummary;
+    }
+  } catch (err) {
+    process.stderr.write(`[kody] verify retry crashed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  await runVerify(ctx);
+  if (ctx.data.verifyOk === true) {
+    upgradeActionOnPass(ctx);
+  } else {
+    downgradeActionOnFailure(ctx);
+  }
+};
+
 // src/scripts/waitForCi.ts
 init_issue();
 import { execFileSync as execFileSync27 } from "child_process";
@@ -10134,7 +10442,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -10156,7 +10464,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs32.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs33.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -10216,6 +10524,7 @@ var postflightScripts = {
   requireFeedbackActions,
   requirePlanDeviations,
   verify,
+  verifyWithRetry,
   verifyReproFails,
   checkCoverageWithRetry,
   abortUnfinishedGitOps: abortUnfinishedGitOps2,
@@ -10379,9 +10688,9 @@ async function runExecutable(profileName, input) {
     data: { ...input.preloadedData ?? {} },
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path30.join(input.cwd, ".kody");
+  const ndjsonDir = path31.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path30.isAbsolute(p) ? p : path30.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path31.isAbsolute(p) ? p : path31.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -10576,7 +10885,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs33.existsSync(profilePath)) return null;
+    if (!fs34.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -10585,17 +10894,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path30.dirname(new URL(import.meta.url).pathname);
+  const here = path31.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path30.join(here, "executables", profileName, "profile.json"),
+    path31.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path30.join(here, "..", "executables", profileName, "profile.json"),
+    path31.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path30.join(here, "..", "src", "executables", profileName, "profile.json")
+    path31.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs33.existsSync(c)) return c;
+    if (fs34.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -10695,8 +11004,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path30.join(profile.dir, shellName);
-  if (!fs33.existsSync(shellPath)) {
+  const shellPath = path31.join(profile.dir, shellName);
+  if (!fs34.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -11175,9 +11484,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs34.existsSync(path31.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs34.existsSync(path31.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs34.existsSync(path31.join(cwd, "bun.lockb"))) return "bun";
+  if (fs35.existsSync(path32.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs35.existsSync(path32.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs35.existsSync(path32.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -11264,11 +11573,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path31.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path32.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs34.existsSync(logPath)) {
-      const content = fs34.readFileSync(logPath, "utf-8");
+    if (fs35.existsSync(logPath)) {
+      const content = fs35.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -11293,7 +11602,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path31.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path32.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -11303,9 +11612,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 && fs34.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs35.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs34.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs35.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);
@@ -11564,9 +11873,9 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path32.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path32.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs35.existsSync(path32.join(cwd, p)));
+  const sessionFile = path33.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path33.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs36.existsSync(path33.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -11604,7 +11913,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path32.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path33.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -11656,7 +11965,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs35.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs36.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {

package/dist/executables/worker-scheduler/profile.json

@@ -0,0 +1,50 @@
+{
+  "name": "worker-scheduler",
+  "role": "watch",
+  "describe": "Scheduled: for every worker file under .kody/workers/, invoke worker-tick once. No agent on the scheduler itself. Parallel to job-scheduler.",
+  "kind": "scheduled",
+  "schedule": "*/5 * * * *",
+  "inputs": [],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": null,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "",
+      "allowedUses": ["api", "issue", "pr"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      {
+        "script": "dispatchJobFileTicks",
+        "with": {
+          "jobsDir": ".kody/workers",
+          "targetExecutable": "worker-tick",
+          "scriptedExecutable": "worker-tick-scripted",
+          "slugArg": "job"
+        }
+      }
+    ],
+    "postflight": []
+  }
+}

package/dist/executables/worker-tick/profile.json

@@ -0,0 +1,74 @@
+{
+  "name": "worker-tick",
+  "role": "primitive",
+  "describe": "One classifier tick for one worker file: read intent + state, decide and execute via gh, emit next state. Parallel to job-tick but reads .kody/workers/.",
+  "kind": "oneshot",
+  "inputs": [
+    {
+      "name": "job",
+      "flag": "--job",
+      "type": "string",
+      "required": true,
+      "describe": "Worker slug — basename (without .md) of the file under .kody/workers/."
+    },
+    {
+      "name": "force",
+      "flag": "--force",
+      "type": "bool",
+      "describe": "When true, the agent ignores the worker body's cadence guard and executes the work this tick. All other body rules (allowed commands, restrictions, state schema) still apply. Used for manual triggers from the dashboard's 'Run now' button."
+    }
+  ],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": 20,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": ["Bash", "Read"],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "Use `gh` for all GitHub actions: `gh pr list ...` to enumerate candidate PRs, `gh pr comment <n> --body \"...\"` to issue a Kody command, `gh pr view <n> --json mergeable,statusCheckRollup,headRefOid` to inspect state, `gh api ...` for anything else. NEVER edit files in the working tree.",
+      "allowedUses": ["pr", "api", "issue"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      {
+        "script": "loadJobFromFile",
+        "with": {
+          "jobsDir": ".kody/workers",
+          "slugArg": "job"
+        }
+      },
+      {
+        "script": "composePrompt"
+      }
+    ],
+    "postflight": [
+      {
+        "script": "parseJobStateFromAgentResult",
+        "with": {
+          "fenceLabel": "kody-job-next-state"
+        }
+      },
+      {
+        "script": "writeJobStateFile"
+      }
+    ]
+  }
+}

package/dist/executables/worker-tick/prompt.md

@@ -0,0 +1,65 @@
+You are **kody worker-tick**, the coordinator for one file-based worker. You do **not** touch code, do **not** commit, and do **not** edit files. You coordinate by inspecting GitHub state and issuing Kody commands as PR comments.
+
+## The worker
+
+Slug **`{{jobSlug}}`** — *{{jobTitle}}*. The worker body below is authoritative: it states what success looks like, allowed commands, and restrictions. The worker file is human-edited — re-read it every tick.
+
+### Worker body
+
+{{jobIntent}}
+
+## Current state
+
+This is the state you wrote at the end of the previous tick (or `null` if this is the first tick):
+
+```json
+{{jobStateJson}}
+```
+
+`cursor` is *your* enum — pick whatever labels map cleanly to your worker's phases. `data` is where you stash anything you need on the next tick (per-PR attempt counters, last-seen SHAs, etc). `done: true` is how you signal that the worker is permanently over — for evergreen workers this should always remain `false`.
+
+## What to do on this tick
+
+`forceRun = {{args.force}}` — set to `true` when an operator clicked "Run now" on the dashboard. When `forceRun` is `true`, ignore the worker body's `**Cadence guard.**` paragraph (or any equivalent "skip if last run was within X" rule) and execute the work as if the guard had passed. All other body rules — allowed commands, restrictions, state schema — still apply. Force only overrides cadence.
+
+1. **Check `done`.** If the prior state has `done: true`, emit the same state back unchanged and exit without any action.
+2. **Re-read the worker body.** It may have changed since the last tick.
+3. **Execute exactly the work the body's `## Worker` section describes**, subject to its `## Allowed Commands` and `## Restrictions`. Use the `## State` section to interpret and update `data`.
+4. **Optionally post a short narration** wherever the worker tells you to (typically a PR comment alongside the action). Keep it terse.
+5. **Emit the new state** at the very end of your response using the fenced block below. Do not include `version` or `rev` — the postflight script manages those.
+
+## Output contract (MANDATORY, exactly once, at the end)
+
+End your response with a single fenced block using the `kody-job-next-state` language tag:
+
+````
+```kody-job-next-state
+{
+  "cursor": "<your-next-cursor>",
+  "data": { ... },
+  "done": <true|false>
+}
+```
+````
+
+If you fail to emit this block, or the JSON is invalid, the tick fails and the gist state is NOT updated. On the next wake you'll see the same prior state and can retry.
+
+## Rules
+
+- Never edit, create, or delete files in the working tree.
+- Never commit or push via `git`. The only permitted commit path is `gh api -X PUT` against the report file (see exception below).
+- Only shell calls allowed: `gh`. Everything must go through it.
+- Keep each tick focused: do one action per candidate per wake. The cron will call you again.
+- If state says you're waiting on something, just check and re-emit — don't spawn a duplicate.
+- Honour the worker body's `## Restrictions` over any inferred shortcut.
+
+### Single permitted write: the worker's report file
+
+A worker MAY (optionally — only if its body asks for it) write a single
+markdown report file at the canonical path:
+
+```
+.kody/reports/{{jobSlug}}.md
+```
+
+Only that exact path. Only via `gh api -X PUT /repos/<owner>/<repo>/contents/.kody/reports/{{jobSlug}}.md` (with base64 content + `sha` of the existing file when updating). All other writes — code files, other report paths, other slugs — remain forbidden. The dashboard's `/reports` page surfaces these files automatically; this is the canonical channel for a worker's diagnostic output when an issue comment isn't expressive enough.

package/dist/executables/worker-tick-scripted/profile.json

@@ -0,0 +1,69 @@
+{
+  "name": "worker-tick-scripted",
+  "role": "utility",
+  "describe": "Deterministic worker tick: runs the slug's `tickScript:` (declared in worker frontmatter), parses next-state from its stdout, persists. No agent. Parallel to job-tick-scripted but reads .kody/workers/.",
+  "kind": "oneshot",
+  "inputs": [
+    {
+      "name": "job",
+      "flag": "--job",
+      "type": "string",
+      "required": true,
+      "describe": "Worker slug — basename (without .md) of the file under .kody/workers/."
+    },
+    {
+      "name": "force",
+      "flag": "--force",
+      "type": "bool",
+      "describe": "Accepted for parity with `worker-tick`. Scripted ticks have no agent cadence guard to bypass — the dispatcher already gated on frontmatter `every:`. Forwarded to the script via env if it cares."
+    }
+  ],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": null,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "Available to the tickScript via PATH; this executable shells out to `bash <tickScript>`. Scripts use `gh pr list`, `gh pr comment`, etc.",
+      "allowedUses": ["pr", "api", "issue"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      {
+        "script": "runTickScript",
+        "with": {
+          "jobsDir": ".kody/workers",
+          "slugArg": "job",
+          "fenceLabel": "kody-job-next-state"
+        }
+      }
+    ],
+    "postflight": [
+      {
+        "script": "writeJobStateFile",
+        "with": {
+          "jobsDir": ".kody/workers"
+        }
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.78",
+  "version": "0.4.80",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,23 @@
     "templates",
     "kody.config.schema.json"
   ],
+  "scripts": {
+    "kody:run": "tsx bin/kody.ts",
+    "serve": "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
+    "build": "tsup && node scripts/copy-assets.cjs",
+    "check:modularity": "tsx scripts/check-script-modularity.ts",
+    "pretest": "pnpm check:modularity",
+    "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",
@@ -33,21 +50,5 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
-  "scripts": {
-    "kody:run": "tsx bin/kody.ts",
-    "serve": "tsx bin/kody.ts serve",
-    "serve:vscode": "tsx bin/kody.ts serve vscode",
-    "serve:claude": "tsx bin/kody.ts serve claude",
-    "build": "tsup && node scripts/copy-assets.cjs",
-    "check:modularity": "tsx scripts/check-script-modularity.ts",
-    "pretest": "pnpm check:modularity",
-    "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"
-  }
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
+}

package/templates/kody.yml

@@ -90,4 +90,4 @@ jobs:
           INIT_MESSAGE:  ${{ inputs.message }}
           MODEL:         ${{ inputs.model }}
           DASHBOARD_URL: ${{ inputs.dashboardUrl }}
-        run: npx -y -p @kody-ade/kody-engine@0.4.78 kody-engine
+        run: npx -y -p @kody-ade/kody-engine@0.4.79 kody-engine