@kody-ade/kody-engine 0.4.79 → 0.4.81

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();
@@ -868,7 +868,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.79",
+  version: "0.4.81",
   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,10 @@ 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.",
+  "When you diagnose something, answer in this shape: a few words on the issue, a",
+  "few words on the fix, then a single question asking whether to proceed. Do not",
+  "pad it with preamble, restated context, or a trailing summary.",
   "",
   "# Your environment and capabilities",
   "You run inside a sandboxed runner with a full clone of the user's repository",
@@ -1724,6 +1727,22 @@ var CHAT_SYSTEM_PROMPT = [
   "      pytest, go test, cargo, etc., whatever the project uses).",
   "    - standard Unix utilities (curl, jq, sed, awk, find, etc.).",
   "",
+  "# Clarify before you act (HARD RULE)",
+  "If the user's request is ambiguous or under-specified \u2014 you can read it two",
+  "plausible ways, or you'd have to guess what they actually want \u2014 ask",
+  "clarifying questions and stop. Ask as many as you genuinely need; do NOT",
+  "pick an interpretation and run with it. This check comes first: confirm",
+  "intent before you start investigating or making changes.",
+  "",
+  "# Answer first, act second (HARD RULE)",
+  "If the user asked a question, answer it \u2014 do not start changing code, running",
+  "mutating commands, or opening PRs. Investigating (read-only Glob/Grep/Read/`git",
+  "log`/`gh ... view`) to ground the answer is expected; making changes is not.",
+  "Before any mutating work (Edit/Write, `git commit`, `gh pr create`, anything",
+  "that alters the repo or remote state) state the plan in a couple of bullets and",
+  "stop for the user's go-ahead. Treat 'can we\u2026', 'is there a way\u2026', 'why does\u2026'",
+  "as questions about what exists, not as instructions to build.",
+  "",
   "# Investigate before you answer (HARD RULE)",
   "Do not answer from assumptions, training memory, or what the code 'probably'",
   "does. Before replying to any question about this repo \u2014 its code, behavior,",
@@ -1854,6 +1873,11 @@ ${catalog}` : basePrompt;
     return { exitCode: 99, error };
   }
   const reply = result.finalText.trim();
+  if (reply.length === 0) {
+    const error = "agent completed without producing a reply \u2014 please resend your message";
+    await emit(opts.sink, "chat.error", opts.sessionId, "error", { error });
+    return { exitCode: 99, error };
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   appendTurn(opts.sessionFile, {
     role: "assistant",
@@ -2178,8 +2202,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 +2525,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
@@ -5586,6 +5610,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 +5974,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 +5994,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 +6007,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 +7371,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 +9098,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 +9315,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 +9409,38 @@ 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}
-`);
-    try {
-      emitSse(res, { type: "error", error: errMsg2, chatId });
-    } catch {
-    }
-  } finally {
-    try {
-      res.end();
-    } catch {
-    }
-  }
+    }).catch((err) => {
+      const errMsg2 = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[brain-serve] chat turn failed: ${errMsg2}
+`);
+      endTurnIfUnterminated(opts.cwd, chatId, errMsg2);
+    }).finally(() => {
+      endTurnIfUnterminated(
+        opts.cwd,
+        chatId,
+        "Brain turn ended without a reply (the machine may have restarted mid-turn) \u2014 please resend your message"
+      );
+    })
+  );
+  streamToRes(res, opts.cwd, chatId, sinceFloor);
 }
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
@@ -9239,6 +9473,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" });
   });
 }
@@ -9591,7 +9837,6 @@ var syncFlow = async (ctx, _profile, args) => {
     if (announceOnSuccess) {
       ctx.output.exitCode = 0;
       ctx.output.reason = `already up to date with origin/${baseBranch}`;
-      tryPostPr6(prNumber, `\u2139\uFE0F kody sync: already up to date with origin/${baseBranch}`, ctx.cwd);
     }
     return;
   }
@@ -9606,13 +9851,6 @@ var syncFlow = async (ctx, _profile, args) => {
   if (announceOnSuccess) {
     ctx.output.exitCode = 0;
     ctx.output.reason = `merged origin/${baseBranch} into ${ctx.data.branch}`;
-    const runUrl = getRunUrl();
-    const runSuffix = runUrl ? ` ([logs](${runUrl}))` : "";
-    tryPostPr6(
-      prNumber,
-      `\u2705 kody sync: merged \`origin/${baseBranch}\` into \`${ctx.data.branch}\`${runSuffix}`,
-      ctx.cwd
-    );
   }
 };
 function bail2(ctx, prNumber, reason) {
@@ -10224,7 +10462,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;
@@ -10246,7 +10484,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 {
   }
@@ -10470,9 +10708,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({
@@ -10667,7 +10905,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;
@@ -10676,17 +10914,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];
 }
@@ -10786,8 +11024,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})`;
@@ -11266,9 +11504,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) {
@@ -11355,11 +11593,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 {
@@ -11384,7 +11622,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);
@@ -11394,9 +11632,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);
@@ -11655,9 +11893,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 {
@@ -11695,7 +11933,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) {
@@ -11747,7 +11985,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/fix-ci/profile.json

@@ -47,9 +47,9 @@
   "lifecycle": "pr-branch",
   "lifecycleConfig": {
     "label": {
-      "name": "kody:fixing",
+      "name": "kody:fixing-ci",
       "color": "e99695",
-      "description": "kody: applying review feedback"
+      "description": "kody: fixing CI failures"
     },
     "context": "ci-fix",
     "advance": false

package/dist/executables/ui-review/profile.json

@@ -67,7 +67,7 @@
   "outputArtifacts": [],
   "scripts": {
     "preflight": [
-      { "script": "setLifecycleLabel", "with": { "label": "kody:reviewing", "color": "d93f0b", "description": "kody: reviewing a PR" } },
+      { "script": "setLifecycleLabel", "with": { "label": "kody:reviewing-ui", "color": "d93f0b", "description": "kody: UI-reviewing a PR" } },
       { "script": "reviewFlow" },
       { "script": "loadTaskState" },
       { "script": "loadConventions" },

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.79",
+  "version": "0.4.81",
   "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"
+}