@kody-ade/kody-engine 0.4.94 → 0.4.95

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.94",
+  "version": "0.4.95",
   "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"
-        }
-      }
-    ]
-  }
-}