@kody-ade/kody-engine 0.4.94 → 0.4.96

package/dist/bin/kody.js

@@ -313,14 +313,14 @@ var init_verifyMcp = __esm({
 });
 
 // src/issue.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync } from "child_process";
 function ghToken() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
 }
 function gh(args, options) {
   const token = ghToken();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync3("gh", args, {
+  return execFileSync("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS,
     cwd: options?.cwd,
@@ -626,28 +626,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs32 from "fs";
+import * as path30 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs31.statSync(file);
+      stat = fs32.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs31.readFileSync(file, "utf-8");
+      raw = fs32.readFileSync(file, "utf-8");
     } catch {
       return;
     }
     const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
-    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path29.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path30.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path29.relative(memoryAbs, file),
+      relPath: path30.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX : raw,
@@ -715,16 +715,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs31.readdirSync(dir);
+      names = fs32.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path29.join(dir, name);
+      const full = path30.join(dir, name);
       let stat;
       try {
-        stat = fs31.statSync(full);
+        stat = fs32.statSync(full);
       } catch {
         continue;
       }
@@ -747,8 +747,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path29.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs31.existsSync(memoryAbs)) {
+      const memoryAbs = path30.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs32.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -877,7 +877,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.94",
+  version: "0.4.96",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -932,8 +932,8 @@ var package_default = {
 
 // src/chat-cli.ts
 import { execFileSync as execFileSync31 } from "child_process";
-import * as fs37 from "fs";
-import * as path34 from "path";
+import * as fs38 from "fs";
+import * as path35 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -1988,13 +1988,13 @@ async function emit(sink, type, sessionId, suffix, payload) {
 }
 
 // src/chat/modes/interactive.ts
-import { execFileSync as execFileSync2 } from "child_process";
+init_issue();
+import { execFileSync as execFileSync3 } from "child_process";
 import * as fs9 from "fs";
-import * as os2 from "os";
 import * as path8 from "path";
 
 // src/chat/inbox.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 var DEFAULT_POLL_MS = 3e3;
 async function waitForNextUserMessage(opts) {
   const pollMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
@@ -2011,13 +2011,13 @@ async function waitForNextUserMessage(opts) {
       try {
         const branch = currentBranch(opts.cwd);
         if (branch) {
-          execFileSync("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
-          execFileSync("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
+          execFileSync2("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync2("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
             cwd: opts.cwd,
             stdio: "pipe"
           });
         } else {
-          execFileSync("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync2("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -2043,7 +2043,7 @@ function sleep(ms) {
 }
 function currentBranch(cwd) {
   try {
-    const out = execFileSync("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = execFileSync2("git", ["symbolic-ref", "--short", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -2068,8 +2068,10 @@ async function runInteractiveMode(opts) {
   const repository = process.env.GITHUB_REPOSITORY;
   const serverUrl = process.env.GITHUB_SERVER_URL ?? "https://github.com";
   const runUrl = runId && repository ? `${serverUrl}/${repository}/actions/runs/${runId}` : void 0;
-  process.stdout.write(`\u2192 kody:chat:interactive: emitting chat.ready (idleExitMs=${idleExitMs}, hardCapMs=${hardCapMs}, runUrl=${runUrl ?? "n/a"})
-`);
+  process.stdout.write(
+    `\u2192 kody:chat:interactive: emitting chat.ready (idleExitMs=${idleExitMs}, hardCapMs=${hardCapMs}, runUrl=${runUrl ?? "n/a"})
+`
+  );
   await emit2(opts.sink, "chat.ready", opts.sessionId, "ready", {
     sessionId: opts.sessionId,
     startedAt: new Date(startedAt).toISOString(),
@@ -2147,117 +2149,89 @@ function findNextUserTurn(turns, fromIdx) {
   if (turns.length > 0 && turns[turns.length - 1].role === "user") return turns.length - 1;
   return -1;
 }
-function commitTurn(cwd, sessionId, verbose) {
+function commitTurn(cwd, sessionId, _verbose) {
   const sessionRel = path8.relative(cwd, sessionFilePath(cwd, sessionId));
   const eventsRel = path8.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionRel, eventsRel].filter((p) => fs9.existsSync(path8.join(cwd, p)));
-  if (paths.length === 0) return;
-  const startBranch = currentBranch2(cwd);
-  const eventsBranch = defaultBranch(cwd) ?? "main";
-  if (startBranch === eventsBranch) {
-    commitPathsAndPush(cwd, paths, sessionId, verbose, "HEAD");
+  const rels = [sessionRel, eventsRel].filter((p) => fs9.existsSync(path8.join(cwd, p)));
+  if (rels.length === 0) return;
+  const repository = process.env.GITHUB_REPOSITORY;
+  if (!repository) {
+    process.stderr.write(
+      `[kody:chat:interactive] GITHUB_REPOSITORY unset; cannot persist session/events via Contents API
+`
+    );
     return;
   }
-  const stdio = verbose ? "inherit" : "pipe";
-  const exec = (args) => execFileSync2("git", args, { cwd, stdio });
-  const worktreeDir = fs9.mkdtempSync(path8.join(os2.tmpdir(), "kody-events-"));
-  let worktreeAdded = false;
-  try {
-    exec(["fetch", "--quiet", "origin", eventsBranch]);
-    exec(["worktree", "add", "--detach", "--quiet", worktreeDir, `origin/${eventsBranch}`]);
-    worktreeAdded = true;
-    for (const rel of paths) {
-      const src = path8.join(cwd, rel);
-      const dst = path8.join(worktreeDir, rel);
-      fs9.mkdirSync(path8.dirname(dst), { recursive: true });
-      fs9.copyFileSync(src, dst);
-    }
-    commitPathsAndPush(worktreeDir, paths, sessionId, verbose, `HEAD:${eventsBranch}`);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody:chat:interactive] worktree commit failed: ${msg}
-`);
-  } finally {
-    if (worktreeAdded) {
-      try {
-        exec(["worktree", "remove", "--force", "--quiet", worktreeDir]);
-      } catch {
-      }
-    }
-    try {
-      fs9.rmSync(worktreeDir, { recursive: true, force: true });
-    } catch {
-    }
+  const branch = defaultBranch(cwd) ?? "main";
+  for (const rel of rels) {
+    const repoPath = rel.split(path8.sep).join("/");
+    const localText = fs9.readFileSync(path8.join(cwd, rel), "utf-8");
+    putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
-function commitPathsAndPush(cwd, paths, sessionId, verbose, pushSpec) {
-  const stdio = verbose ? "inherit" : "pipe";
-  const exec = (args) => execFileSync2("git", args, { cwd, stdio });
+function jsonlLines(text) {
+  return text.split("\n").filter((l) => l.length > 0);
+}
+function getRemoteBlob(repository, branch, repoPath, cwd) {
   try {
-    exec(["add", "-f", ...paths]);
-    exec(["commit", "--quiet", "-m", `chat: interactive turn for ${sessionId}`]);
+    const raw = gh(["api", `/repos/${repository}/contents/${repoPath}?ref=${encodeURIComponent(branch)}`], { cwd });
+    const o = JSON.parse(raw);
+    if (o.type === "file" && o.encoding === "base64" && typeof o.content === "string" && typeof o.sha === "string") {
+      return { sha: o.sha, lines: jsonlLines(Buffer.from(o.content, "base64").toString("utf-8")) };
+    }
+    return { sha: null, lines: [] };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody:chat:interactive] commit failed: ${msg}
-`);
-    return;
+    if (/HTTP 404/i.test(msg) || /Not Found/i.test(msg)) return { sha: null, lines: [] };
+    throw err;
   }
+}
+function putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd) {
   for (let attempt = 1; attempt <= 3; attempt++) {
+    const remote = getRemoteBlob(repository, branch, repoPath, cwd);
+    let body = localText;
+    if (attempt > 1 && remote.lines.length > 0) {
+      const localLines = jsonlLines(localText);
+      const localSet = new Set(localLines);
+      const extra = remote.lines.filter((l) => !localSet.has(l));
+      if (extra.length > 0) body = [...localLines, ...extra].join("\n") + "\n";
+    }
+    const payload = {
+      message: `chat: interactive turn for ${sessionId}`,
+      content: Buffer.from(body, "utf-8").toString("base64"),
+      branch
+    };
+    if (remote.sha) payload.sha = remote.sha;
     try {
-      exec(["push", "--quiet", "origin", pushSpec]);
+      gh(["api", "--method", "PUT", `/repos/${repository}/contents/${repoPath}`, "--input", "-"], {
+        cwd,
+        input: JSON.stringify(payload)
+      });
       return;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      const isNonFf = /non-fast-forward|fetch first|rejected/i.test(msg);
-      if (!isNonFf || attempt === 3) {
-        process.stderr.write(`[kody:chat:interactive] push failed (attempt ${attempt}): ${msg}
-`);
-        return;
-      }
-      process.stderr.write(`[kody:chat:interactive] push rejected (attempt ${attempt}); fetch+rebase+retry
-`);
-      try {
-        exec(["fetch", "--quiet", "origin"]);
-        const upstream = pushSpec.includes(":") ? `origin/${pushSpec.split(":")[1]}` : (() => {
-          const branch = currentBranch2(cwd);
-          return branch ? `origin/${branch}` : null;
-        })();
-        if (!upstream) {
-          process.stderr.write(`[kody:chat:interactive] cannot rebase: no upstream resolved
-`);
-          return;
-        }
-        exec(["rebase", "--quiet", upstream]);
-      } catch (rebaseErr) {
-        const rmsg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
-        process.stderr.write(`[kody:chat:interactive] rebase failed: ${rmsg}
+      const isConflict = /HTTP 409/i.test(msg) || /HTTP 422/i.test(msg) || /does not match|but expected/i.test(msg);
+      if (!isConflict || attempt === 3) {
+        process.stderr.write(`[kody:chat:interactive] Contents PUT failed (${repoPath}, attempt ${attempt}): ${msg}
 `);
         return;
       }
+      process.stderr.write(
+        `[kody:chat:interactive] Contents PUT conflict (${repoPath}, attempt ${attempt}); refetch+union+retry
+`
+      );
     }
   }
 }
 function defaultBranch(cwd) {
   try {
-    const out = execFileSync2(
-      "git",
-      ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
-      { cwd, stdio: ["ignore", "pipe", "ignore"] }
-    );
-    const symbolic = out.toString("utf-8").trim();
-    if (symbolic.startsWith("origin/")) return symbolic.slice("origin/".length);
-    return symbolic || null;
-  } catch {
-    return null;
-  }
-}
-function currentBranch2(cwd) {
-  try {
-    const out = execFileSync2("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = execFileSync3("git", ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
-    return out.toString("utf-8").trim() || null;
+    const symbolic = out.toString("utf-8").trim();
+    if (symbolic.startsWith("origin/")) return symbolic.slice("origin/".length);
+    return symbolic || null;
   } catch {
     return null;
   }
@@ -2281,8 +2255,8 @@ async function emit2(sink, type, sessionId, suffix, payload) {
 
 // src/kody-cli.ts
 import { execFileSync as execFileSync30 } from "child_process";
-import * as fs36 from "fs";
-import * as path33 from "path";
+import * as fs37 from "fs";
+import * as path34 from "path";
 
 // src/dispatch.ts
 import * as fs10 from "fs";
@@ -2604,8 +2578,8 @@ init_issue();
 
 // src/executor.ts
 import { execFileSync as execFileSync29, spawn as spawn6 } from "child_process";
-import * as fs35 from "fs";
-import * as path32 from "path";
+import * as fs36 from "fs";
+import * as path33 from "path";
 init_events();
 
 // src/lifecycleLabels.ts
@@ -3229,7 +3203,7 @@ function errMsg(err) {
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
 import * as fs12 from "fs";
-import * as os3 from "os";
+import * as os2 from "os";
 import * as path10 from "path";
 async function checkLitellmHealth(url) {
   try {
@@ -3277,13 +3251,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
       throw new Error("litellm not installed \u2014 run: pip install 'litellm[proxy]'");
     }
   }
-  const configPath = path10.join(os3.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
+  const configPath = path10.join(os2.tmpdir(), `kody-litellm-${Date.now()}.yaml`);
   fs12.writeFileSync(configPath, generateLitellmConfigYaml(model));
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   const args = cmd === "litellm" ? ["--config", configPath, "--port", port] : ["-m", "litellm", "--config", configPath, "--port", port];
   const dotenvVars = readDotenvApiKeys(projectDir);
-  const logPath = path10.join(os3.tmpdir(), `kody-litellm-${Date.now()}.log`);
+  const logPath = path10.join(os2.tmpdir(), `kody-litellm-${Date.now()}.log`);
   const outFd = fs12.openSync(logPath, "w");
   const child = spawn2(cmd, args, {
     stdio: ["ignore", outFd, outFd],
@@ -4244,7 +4218,7 @@ var brainServe = async (ctx) => {
 
 // src/scripts/buildSyntheticPlugin.ts
 import * as fs16 from "fs";
-import * as os4 from "os";
+import * as os3 from "os";
 import * as path14 from "path";
 function getPluginsCatalogRoot() {
   const here = path14.dirname(new URL(import.meta.url).pathname);
@@ -4267,7 +4241,7 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   if (!needsSynthetic) return;
   const catalog = getPluginsCatalogRoot();
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const root = path14.join(os4.tmpdir(), `kody-synth-${runId}`);
+  const root = path14.join(os3.tmpdir(), `kody-synth-${runId}`);
   fs16.mkdirSync(path14.join(root, ".claude-plugin"), { recursive: true });
   const resolvePart = (bucket, entry) => {
     const local = path14.join(profile.dir, bucket, entry);
@@ -5490,10 +5464,10 @@ function filterGoalTaskPrs(prs, taskIssueNumbers) {
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync11 } from "child_process";
 import * as fs21 from "fs";
-import * as os5 from "os";
+import * as os4 from "os";
 import * as path20 from "path";
 var diagMcp = async (_ctx) => {
-  const home = os5.homedir();
+  const home = os4.homedir();
   const cacheDir = path20.join(home, ".cache", "ms-playwright");
   let entries = [];
   try {
@@ -6168,6 +6142,8 @@ function parseFlatYaml(text) {
       const lower = value.toLowerCase();
       if (lower === "true") out.disabled = true;
       else if (lower === "false") out.disabled = false;
+    } else if (key === "worker" && value.length > 0) {
+      out.worker = value;
     }
   }
   return out;
@@ -6554,6 +6530,14 @@ var dispatchJobFileTicks = async (ctx, _profile, args) => {
         results.push({ slug, exitCode: 0, skipped: true, reason: "disabled" });
         continue;
       }
+      if (!frontmatter.worker || frontmatter.worker.trim().length === 0) {
+        process.stderr.write(
+          `[jobs] \u23ED  skip ${slug}: no worker assigned (add 'worker: <slug>' frontmatter)
+`
+        );
+        results.push({ slug, exitCode: 0, skipped: true, reason: "no worker assigned" });
+        continue;
+      }
       const decision = await decideShouldFire(frontmatter.every, slug, backend, now);
       if (decision.skip) {
         process.stdout.write(`[jobs] \u23ED  skip ${slug}: ${decision.reason}
@@ -7999,10 +7983,10 @@ import * as fs29 from "fs";
 import * as path27 from "path";
 var VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
 var GoalStateError = class extends Error {
-  constructor(path35, message) {
-    super(`Invalid goal state at ${path35}:
+  constructor(path36, message) {
+    super(`Invalid goal state at ${path36}:
   ${message}`);
-    this.path = path35;
+    this.path = path36;
     this.name = "GoalStateError";
   }
   path;
@@ -8169,6 +8153,7 @@ import * as fs30 from "fs";
 import * as path28 from "path";
 var loadJobFromFile = async (ctx, _profile, args) => {
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const workersDir = String(args?.workersDir ?? ".kody/workers");
   const slugArg = String(args?.slugArg ?? "job");
   const slug = String(ctx.args[slugArg] ?? "").trim();
   if (!slug) {
@@ -8180,6 +8165,21 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   }
   const raw = fs30.readFileSync(absPath, "utf-8");
   const { title, body } = parseJobFile(raw, slug);
+  const workerSlug = (splitFrontmatter(raw).frontmatter.worker ?? "").trim();
+  let workerTitle = "";
+  let workerPersona = "";
+  if (workerSlug) {
+    const workerPath = path28.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+    if (!fs30.existsSync(workerPath)) {
+      throw new Error(
+        `loadJobFromFile: job '${slug}' declares worker '${workerSlug}' but ${workerPath} does not exist`
+      );
+    }
+    const workerRaw = fs30.readFileSync(workerPath, "utf-8");
+    const parsed = parseJobFile(workerRaw, workerSlug);
+    workerTitle = parsed.title;
+    workerPersona = parsed.body;
+  }
   const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   const loaded = await backend.load(slug);
   ctx.data.jobSlug = slug;
@@ -8187,6 +8187,9 @@ var loadJobFromFile = async (ctx, _profile, args) => {
   ctx.data.jobIntent = body;
   ctx.data.jobState = loaded;
   ctx.data.jobStateJson = JSON.stringify(loaded.state, null, 2);
+  ctx.data.workerSlug = workerSlug;
+  ctx.data.workerTitle = workerTitle;
+  ctx.data.workerPersona = workerPersona;
 };
 function parseJobFile(raw, slug) {
   let stripped = raw;
@@ -8209,6 +8212,79 @@ function humanizeSlug(slug) {
   return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
 }
 
+// src/scripts/loadWorkerAdhoc.ts
+import * as fs31 from "fs";
+import * as path29 from "path";
+var loadWorkerAdhoc = async (ctx, _profile, args) => {
+  const workersDir = String(args?.workersDir ?? ".kody/workers");
+  const workerSlug = String(ctx.args.worker ?? "").trim();
+  if (!workerSlug) {
+    throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
+  }
+  const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+  if (!fs31.existsSync(workerPath)) {
+    throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
+  }
+  const { title, body } = parsePersona(fs31.readFileSync(workerPath, "utf-8"), workerSlug);
+  const message = resolveMessage(ctx.args.message);
+  if (!message) {
+    throw new Error(
+      "loadWorkerAdhoc: no message \u2014 neither the dispatching comment body nor ctx.args.message provided one"
+    );
+  }
+  ctx.data.workerSlug = workerSlug;
+  ctx.data.workerTitle = title;
+  ctx.data.workerPersona = body;
+  ctx.data.message = message;
+  ctx.data.thread = String(ctx.args.thread ?? "").trim();
+};
+function resolveMessage(messageArg) {
+  const fromComment = readCommentBody();
+  if (fromComment) return stripDirective(fromComment);
+  return String(messageArg ?? "").trim();
+}
+function readCommentBody() {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !fs31.existsSync(eventPath)) return "";
+  try {
+    const event = JSON.parse(fs31.readFileSync(eventPath, "utf-8"));
+    return String(event.comment?.body ?? "");
+  } catch {
+    return "";
+  }
+}
+function stripDirective(body) {
+  const lines = body.split("\n");
+  let start = 0;
+  while (start < lines.length) {
+    const line = lines[start].trim();
+    if (line.length === 0) {
+      start++;
+      continue;
+    }
+    if (/@kody\s+worker-ask\b/i.test(line)) {
+      start++;
+      continue;
+    }
+    break;
+  }
+  return lines.slice(start).join("\n").trim();
+}
+function parsePersona(raw, slug) {
+  const stripped = splitFrontmatter(raw).body;
+  const trimmed = stripped.trim();
+  const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
+  const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
+  if (h1) {
+    const rest = trimmed.slice(firstLine2.length).replace(/^\n+/, "");
+    return { title: h1[1].trim(), body: rest };
+  }
+  return { title: humanizeSlug2(slug), body: trimmed };
+}
+function humanizeSlug2(slug) {
+  return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
+}
+
 // src/scripts/index.ts
 init_loadMemoryContext();
 init_loadPriorArt();
@@ -8217,8 +8293,8 @@ init_loadPriorArt();
 init_events();
 
 // src/taskContext.ts
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 var TASK_CONTEXT_SCHEMA_VERSION = 1;
 function buildTaskContext(args) {
   return {
@@ -8234,10 +8310,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path30.join(cwd, ".kody", "runs", ctx.runId);
-    fs32.mkdirSync(dir, { recursive: true });
-    const file = path30.join(dir, "task-context.json");
-    fs32.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path31.join(cwd, ".kody", "runs", ctx.runId);
+    fs33.mkdirSync(dir, { recursive: true });
+    const file = path31.join(dir, "task-context.json");
+    fs33.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -9600,8 +9676,8 @@ function resolveBaseOverride(value) {
 
 // src/scripts/runTickScript.ts
 import { spawnSync } from "child_process";
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 var runTickScript = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
@@ -9613,13 +9689,13 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
     return;
   }
-  const jobPath = path31.join(ctx.cwd, jobsDir, `${slug}.md`);
-  if (!fs33.existsSync(jobPath)) {
+  const jobPath = path32.join(ctx.cwd, jobsDir, `${slug}.md`);
+  if (!fs34.existsSync(jobPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
     return;
   }
-  const raw = fs33.readFileSync(jobPath, "utf-8");
+  const raw = fs34.readFileSync(jobPath, "utf-8");
   const { frontmatter } = splitFrontmatter(raw);
   const tickScript = frontmatter.tickScript;
   if (!tickScript) {
@@ -9627,8 +9703,8 @@ var runTickScript = async (ctx, _profile, args) => {
     ctx.output.reason = `runTickScript: job ${slug} has no \`tickScript:\` frontmatter \u2014 route via job-tick instead`;
     return;
   }
-  const scriptPath = path31.isAbsolute(tickScript) ? tickScript : path31.join(ctx.cwd, tickScript);
-  if (!fs33.existsSync(scriptPath)) {
+  const scriptPath = path32.isAbsolute(tickScript) ? tickScript : path32.join(ctx.cwd, tickScript);
+  if (!fs34.existsSync(scriptPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
     return;
@@ -10650,7 +10726,7 @@ var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -10672,7 +10748,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs34.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs35.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -10693,6 +10769,7 @@ var preflightScripts = {
   loadIssueContext,
   loadIssueStateComment,
   loadJobFromFile,
+  loadWorkerAdhoc,
   loadConventions,
   loadCoverageRules,
   loadMemoryContext,
@@ -10897,9 +10974,9 @@ async function runExecutable(profileName, input) {
     data: { ...input.preloadedData ?? {} },
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path32.join(input.cwd, ".kody");
+  const ndjsonDir = path33.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path32.isAbsolute(p) ? p : path32.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path33.isAbsolute(p) ? p : path33.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -11094,7 +11171,7 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs35.existsSync(profilePath)) return null;
+    if (!fs36.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -11103,17 +11180,17 @@ function getProfileInputsForChild(profileName, _cwd) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path32.dirname(new URL(import.meta.url).pathname);
+  const here = path33.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path32.join(here, "executables", profileName, "profile.json"),
+    path33.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path32.join(here, "..", "executables", profileName, "profile.json"),
+    path33.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path32.join(here, "..", "src", "executables", profileName, "profile.json")
+    path33.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs35.existsSync(c)) return c;
+    if (fs36.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -11213,8 +11290,8 @@ function resolveShellTimeoutMs(entry) {
 var SIGKILL_GRACE_MS = 5e3;
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path32.join(profile.dir, shellName);
-  if (!fs35.existsSync(shellPath)) {
+  const shellPath = path33.join(profile.dir, shellName);
+  if (!fs36.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -11693,9 +11770,9 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs36.existsSync(path33.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs36.existsSync(path33.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs36.existsSync(path33.join(cwd, "bun.lockb"))) return "bun";
+  if (fs37.existsSync(path34.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs37.existsSync(path34.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs37.existsSync(path34.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -11782,11 +11859,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path33.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path34.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs36.existsSync(logPath)) {
-      const content = fs36.readFileSync(logPath, "utf-8");
+    if (fs37.existsSync(logPath)) {
+      const content = fs37.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -11811,7 +11888,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path33.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path34.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -11821,9 +11898,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 && fs36.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs37.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs36.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs37.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);
@@ -12082,9 +12159,9 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path34.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path34.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs37.existsSync(path34.join(cwd, p)));
+  const sessionFile = path35.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path35.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs38.existsSync(path35.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -12122,7 +12199,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path34.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path35.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -12174,7 +12251,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs37.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs38.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {

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

@@ -1,8 +1,14 @@
-You are **kody job-tick**, the coordinator for one file-based job. 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.
+You are **{{workerTitle}}** (worker `{{workerSlug}}`), operating through **kody job-tick** — the coordinator for one file-based job. 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.
+
+## Who you are — worker persona (authoritative identity)
+
+The job below assigns you, worker **`{{workerSlug}}`**, as its executor. This persona defines *who* runs the job: your authority, doctrine, voice, and hard limits. Where the persona's restrictions are stricter than the job body, **the persona wins** — a job can never grant you authority your worker persona withholds.
+
+{{workerPersona}}
 
 ## The job
 
-Slug **`{{jobSlug}}`** — *{{jobTitle}}*. The job body below is authoritative: it states what success looks like, allowed commands, and restrictions. The job file is human-edited — re-read it every tick.
+Slug **`{{jobSlug}}`** — *{{jobTitle}}*, assigned to worker **`{{workerSlug}}`**. The job body below is authoritative for *what* to do, *when* (cadence), allowed commands, and state schema. It is human-edited — re-read it every tick. Execute it **as** the persona above.
 
 ### Job body
 

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

@@ -0,0 +1,70 @@
+{
+  "name": "worker-ask",
+  "role": "primitive",
+  "describe": "Ad-hoc one-shot: run a worker persona against an inline message + context (from a dashboard @worker mention). Stateless — no job file, no state, no commit. Replies into the originating thread.",
+  "kind": "oneshot",
+  "inputs": [
+    {
+      "name": "worker",
+      "flag": "--worker",
+      "type": "string",
+      "required": true,
+      "describe": "Worker slug — basename (without .md) of the persona file under .kody/workers/."
+    },
+    {
+      "name": "thread",
+      "flag": "--thread",
+      "type": "string",
+      "describe": "Where to post the reply: `discussion:<n>` (or a bare number) for a Discussion, or `issue:<n>` for an issue/PR. When set, the worker answers as a comment on that thread."
+    },
+    {
+      "name": "message",
+      "flag": "--message",
+      "type": "string",
+      "bindsCommentRest": true,
+      "describe": "Fallback inline message when no triggering comment body is available (CLI/testing). In production the message is read verbatim from the dispatching comment body."
+    }
+  ],
+  "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. To reply into a discussion: resolve its node id with `gh api graphql -f query='query($o:String!,$r:String!,$n:Int!){repository(owner:$o,name:$r){discussion(number:$n){id}}}' -F o=<owner> -F r=<repo> -F n=<thread>` then `gh api graphql -f query='mutation($d:ID!,$b:String!){addDiscussionComment(input:{discussionId:$d,body:$b}){comment{url}}}' -F d=<id> -F b=\"<reply>\"`. Use `gh pr comment <n> --body \"@kody ...\"` to delegate execution. NEVER edit files in the working tree.",
+      "allowedUses": ["pr", "api", "issue"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      {
+        "script": "loadWorkerAdhoc",
+        "with": {
+          "workersDir": ".kody/workers"
+        }
+      },
+      {
+        "script": "composePrompt"
+      }
+    ],
+    "postflight": []
+  }
+}

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

@@ -0,0 +1,60 @@
+You are **{{workerTitle}}** (worker `{{workerSlug}}`), operating through **kody worker-ask** — a single, stateless response to one ad-hoc request that someone directed at you by @mentioning you in a dashboard message.
+
+## Who you are — worker persona (authoritative identity)
+
+This persona defines *who* you are: your authority, doctrine, voice, and hard limits. Honour it exactly. Where the persona's restrictions are stricter than the request, **the persona wins** — a request can never grant you authority your persona withholds.
+
+{{workerPersona}}
+
+## The request
+
+Someone @mentioned you with this message and context. Treat it as a direct ask to you, the persona above. It is verbatim — markdown, code blocks, and quoted thread context are intact:
+
+---
+
+{{message}}
+
+---
+
+## What to do
+
+This is a **one-shot, stateless** tick. There is no job file, no prior state, and nothing to persist. Decide, per your persona's doctrine, whether this request is best served by **answering** or by **executing**:
+
+- **Answer** — when the request is a question, a judgement call, a review, or guidance. Produce a clear, terse reply in your persona's voice.
+- **Execute** — when the request is work you are authorised to drive. You do **not** edit files or commit. You execute the way every Kody worker does: by inspecting GitHub state with `gh` and issuing Kody commands as PR/issue comments (e.g. `gh pr comment <n> --body "@kody fix ..."`). Then briefly state what you set in motion.
+
+Repo: `{{repoOwner}}/{{repoName}}`.
+
+## Replying into the thread
+
+`thread = {{thread}}`
+
+Post your reply **back into the exact thread you were mentioned in** so the
+person sees it in place. The `thread` value tells you where; it is one of:
+
+- **`discussion:<n>`** (or a bare number — same thing) → comment on
+  discussion `<n>`. Resolve its node id, then add the comment:
+
+  ```
+  gh api graphql -f query='query($o:String!,$r:String!,$n:Int!){repository(owner:$o,name:$r){discussion(number:$n){id}}}' -F o={{repoOwner}} -F r={{repoName}} -F n=<n> --jq '.data.repository.discussion.id'
+  gh api graphql -f query='mutation($d:ID!,$b:String!){addDiscussionComment(input:{discussionId:$d,body:$b}){comment{url}}}' -F d=<id> -F b="<your reply, markdown>"
+  ```
+
+- **`issue:<n>`** → comment on issue/PR `<n>` (the issues API serves both):
+
+  ```
+  gh api -X POST repos/{{repoOwner}}/{{repoName}}/issues/<n>/comments -f body="<your reply, markdown>"
+  ```
+
+Sign the reply so it reads as you, e.g. lead with `**{{workerTitle}}** —`.
+
+If `thread` is empty, just produce your reply as your final response (no
+GitHub post).
+
+## Rules
+
+- Never edit, create, or delete files in the working tree. Never `git commit`/`push`.
+- The only shell tool is `gh`. Everything goes through it.
+- Stay inside your persona's authority and restrictions at all times.
+- Be terse. One focused reply; do not spawn duplicate work.
+- There is **no state output contract** — do not emit a state fenced block. When you have replied (or posted to the thread), you are done.

package/package.json

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

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

@@ -1,50 +0,0 @@
-{
-  "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

@@ -1,74 +0,0 @@
-{
-  "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

@@ -1,65 +0,0 @@
-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

@@ -1,69 +0,0 @@
-{
-  "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"
-        }
-      }
-    ]
-  }
-}