@kody-ade/kody-engine 0.3.87 → 0.4.0

package/README.md

@@ -34,7 +34,7 @@ npx -y -p @kody-ade/kody-engine@latest kody init
 
 Required repo secrets: at least one model provider key (e.g. `MINIMAX_API_KEY`, `ANTHROPIC_API_KEY`). Recommended: `KODY_TOKEN` PAT so kody's commits trigger downstream CI and can modify `.github/workflows/*`.
 
-The consumer workflow listens on three triggers: `issue_comment` (for `@kody …` dispatch), `workflow_dispatch` (manual runs, chat mode, mission wake), and `pull_request: [closed]` (auto-finalizes a merged `release/vX.Y.Z` PR).
+The consumer workflow listens on three triggers: `issue_comment` (for `@kody …` dispatch), `workflow_dispatch` (manual runs, chat mode, job wake), and `pull_request: [closed]` (auto-finalizes a merged `release/vX.Y.Z` PR).
 
 ## Commands
 
@@ -58,9 +58,9 @@ kody bug       --issue <N>                             # plan → run → review
 kody spec      --issue <N>                             # research → plan (no code, terminates at plan)
 kody chore     --issue <N>                             # run → review (→ fix)
 
-# missions & watches (scheduled, coordinate work via issue state)
-kody mission-scheduler                                 # fans out to per-issue mission-tick
-kody mission-tick      --issue <N>                     # one tick of a kody:mission issue
+# jobs & watches (scheduled, coordinate work via issue state)
+kody job-scheduler                                 # fans out to per-issue job-tick
+kody job-tick      --issue <N>                     # one tick of a kody:job issue
 kody watch-stale-prs                                   # weekly stale-PR report
 kody memorize                                          # daily vault wiki update from recent PRs
 
@@ -78,11 +78,11 @@ kody chat      [--session <id>]                        # dashboard-driven chat s
 
 Each flow (`feature`, `bug`, `spec`, `chore`) is a declarative transition table: postflight entries dispatch the next executable based on `data.taskState.core.lastOutcome.type` via `runWhen`. No engine changes to add a new flow — drop a new `src/executables/<flow-name>/` with a different table. `classify` picks the flow for an unlabeled issue.
 
-### Missions
+### Jobs
 
-A **mission** is a stateful, bounded goal expressed as a labeled GitHub issue (`kody:mission`). A **watch** is a stateless repeating loop. A **manager** is a mission whose job happens to be overseeing other missions. All three run on the same scheduled-executable substrate.
+A **job** is a stateful, bounded goal expressed as a labeled GitHub issue (`kody:job`). A **watch** is a stateless repeating loop. A **manager** is a job whose job happens to be overseeing other jobs. All three run on the same scheduled-executable substrate.
 
-`mission-scheduler` wakes on cron (default `*/5 * * * *`) or empty `workflow_dispatch`, finds every open `kody:mission` issue, and calls `mission-tick` once per issue. The tick agent reads the issue body (human-owned prose) and a dedicated state comment (bot-owned JSON), decides the next step, and emits a fenced `kody-mission-next-state` block the postflight persists. Children are spawned via `gh workflow run kody.yml` (not `@kody` comments — the default `GITHUB_TOKEN` can dispatch workflows but can't post auto-triggering comments).
+`job-scheduler` wakes on cron (default `*/5 * * * *`) or empty `workflow_dispatch`, finds every open `kody:job` issue, and calls `job-tick` once per issue. The tick agent reads the issue body (human-owned prose) and a dedicated state comment (bot-owned JSON), decides the next step, and emits a fenced `kody-job-next-state` block the postflight persists. Children are spawned via `gh workflow run kody.yml` (not `@kody` comments — the default `GITHUB_TOKEN` can dispatch workflows but can't post auto-triggering comments).
 
 ### `ui-review`
 

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.87",
+  version: "0.4.0",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -188,10 +188,10 @@ function loadConfig(projectDir = process.cwd()) {
     aliases: mergeAliases(raw.aliases),
     classify: parseClassifyConfig(raw.classify),
     release: parseReleaseConfig(raw.release),
-    missions: parseMissionsConfig(raw.missions)
+    jobs: parseJobsConfig(raw.jobs)
   };
 }
-function parseMissionsConfig(raw) {
+function parseJobsConfig(raw) {
   if (!raw || typeof raw !== "object") return void 0;
   const r = raw;
   const out = {};
@@ -199,7 +199,7 @@ function parseMissionsConfig(raw) {
     out.stateBackend = r.stateBackend;
   } else if (typeof r.stateBackend === "string") {
     throw new Error(
-      `kody.config.json: missions.stateBackend must be "contents-api" or "local-file", got "${r.stateBackend}"`
+      `kody.config.json: jobs.stateBackend must be "contents-api" or "local-file", got "${r.stateBackend}"`
     );
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -3188,7 +3188,7 @@ function failedAction(reason) {
   return { type: "CLASSIFY_FAILED", payload: { reason }, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-// src/scripts/dispatchMissionFileTicks.ts
+// src/scripts/dispatchJobFileTicks.ts
 import * as fs18 from "fs";
 import * as path17 from "path";
 
@@ -3416,26 +3416,26 @@ function minimizeComment(nodeId, cwd) {
   gh2(["api", "graphql", "-f", `query=${mutation}`, "-f", `id=${nodeId}`], { cwd });
 }
 
-// src/scripts/missionState/backend.ts
+// src/scripts/jobState/backend.ts
 function isStateUnchanged(prev, next) {
   if (prev.cursor !== next.cursor) return false;
   if (prev.done !== next.done) return false;
   return JSON.stringify(prev.data) === JSON.stringify(next.data);
 }
-function stateFilePath(missionsDir, slug) {
-  return `${missionsDir.replace(/\/+$/, "")}/${slug}.state.json`;
+function stateFilePath(jobsDir, slug) {
+  return `${jobsDir.replace(/\/+$/, "")}/${slug}.state.json`;
 }
 function slugFromStateFilePath(filePath) {
   const last = filePath.split("/").pop() ?? filePath;
   return last.replace(/\.state\.json$/i, "");
 }
 
-// src/scripts/missionState/contentsApiBackend.ts
+// src/scripts/jobState/contentsApiBackend.ts
 var ContentsApiBackend = class {
   name = "contents-api";
   owner;
   repo;
-  missionsDir;
+  jobsDir;
   cwd;
   constructor(opts) {
     if (!opts.owner || !opts.repo) {
@@ -3443,11 +3443,11 @@ var ContentsApiBackend = class {
     }
     this.owner = opts.owner;
     this.repo = opts.repo;
-    this.missionsDir = opts.missionsDir;
+    this.jobsDir = opts.jobsDir;
     this.cwd = opts.cwd;
   }
   load(slug) {
-    const filePath = stateFilePath(this.missionsDir, slug);
+    const filePath = stateFilePath(this.jobsDir, slug);
     let raw = "";
     try {
       raw = gh2(["api", `/repos/${this.owner}/${this.repo}/contents/${filePath}`], { cwd: this.cwd });
@@ -3490,7 +3490,7 @@ var ContentsApiBackend = class {
     const slug = slugFromStateFilePath(loaded.path);
     const body = JSON.stringify(next, null, 2) + "\n";
     const payload = {
-      message: `chore(missions): update state for ${slug} (rev ${next.rev})`,
+      message: `chore(jobs): update state for ${slug} (rev ${next.rev})`,
       content: Buffer.from(body, "utf-8").toString("base64")
     };
     if (typeof loaded.handle === "string") payload.sha = loaded.handle;
@@ -3502,35 +3502,35 @@ var ContentsApiBackend = class {
   }
 };
 
-// src/scripts/missionState/localFileBackend.ts
+// src/scripts/jobState/localFileBackend.ts
 import * as fs17 from "fs";
 import * as path16 from "path";
 var LocalFileBackend = class {
   name = "local-file";
   cwd;
-  missionsDir;
+  jobsDir;
   absDir;
   owner;
   repo;
   cache;
   constructor(opts) {
     if (!opts.cwd) throw new Error("LocalFileBackend: cwd is required");
-    if (!opts.missionsDir) throw new Error("LocalFileBackend: missionsDir is required");
+    if (!opts.jobsDir) throw new Error("LocalFileBackend: jobsDir is required");
     if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
     this.cwd = opts.cwd;
-    this.missionsDir = opts.missionsDir;
-    this.absDir = path16.join(opts.cwd, opts.missionsDir);
+    this.jobsDir = opts.jobsDir;
+    this.absDir = path16.join(opts.cwd, opts.jobsDir);
     this.owner = opts.owner;
     this.repo = opts.repo;
     this.cache = opts.cache ?? defaultCacheAdapter();
   }
   /**
-   * Restore the mission directory from the most recent Actions cache entry
+   * Restore the job directory from the most recent Actions cache entry
    * for this repo. No-op when not running in Actions or when no cache exists.
    */
   async hydrate() {
     if (!this.cache.isAvailable()) {
-      process.stdout.write(`[missions/state] hydrate skipped: actions cache unavailable
+      process.stdout.write(`[jobs/state] hydrate skipped: actions cache unavailable
 `);
       return;
     }
@@ -3540,26 +3540,26 @@ var LocalFileBackend = class {
     try {
       const matched = await this.cache.restore([this.absDir], probeKey, [prefix]);
       if (matched) {
-        process.stdout.write(`[missions/state] hydrate hit: ${matched}
+        process.stdout.write(`[jobs/state] hydrate hit: ${matched}
 `);
       } else {
-        process.stdout.write(`[missions/state] hydrate miss (cold start)
+        process.stdout.write(`[jobs/state] hydrate miss (cold start)
 `);
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[missions/state] hydrate failed (continuing): ${msg}
+      process.stderr.write(`[jobs/state] hydrate failed (continuing): ${msg}
 `);
     }
   }
   /**
-   * Save the mission directory to the Actions cache under a unique key.
+   * Save the job directory to the Actions cache under a unique key.
    * No-op when not running in Actions. Errors are logged, never thrown —
    * callers run this in a finally block and must not swallow real errors.
    */
   async persist() {
     if (!this.cache.isAvailable()) {
-      process.stdout.write(`[missions/state] persist skipped: actions cache unavailable
+      process.stdout.write(`[jobs/state] persist skipped: actions cache unavailable
 `);
       return;
     }
@@ -3569,16 +3569,16 @@ var LocalFileBackend = class {
     const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
     try {
       await this.cache.save([this.absDir], key);
-      process.stdout.write(`[missions/state] persist saved: ${key}
+      process.stdout.write(`[jobs/state] persist saved: ${key}
 `);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[missions/state] persist failed (continuing): ${msg}
+      process.stderr.write(`[jobs/state] persist failed (continuing): ${msg}
 `);
     }
   }
   load(slug) {
-    const relPath = stateFilePath(this.missionsDir, slug);
+    const relPath = stateFilePath(this.jobsDir, slug);
     const absPath = path16.join(this.cwd, relPath);
     if (!fs17.existsSync(absPath)) {
       return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
@@ -3607,7 +3607,7 @@ var LocalFileBackend = class {
     return true;
   }
   cacheKeyPrefix() {
-    return `kody-mission-state-${sanitizeKey(this.owner)}-${sanitizeKey(this.repo)}-`;
+    return `kody-job-state-${sanitizeKey(this.owner)}-${sanitizeKey(this.repo)}-`;
   }
 };
 function sanitizeKey(s) {
@@ -3646,19 +3646,19 @@ function defaultCacheAdapter() {
   };
 }
 
-// src/scripts/missionState/index.ts
+// src/scripts/jobState/index.ts
 function resolveBackend(opts) {
   const owner = opts.config.github?.owner;
   const repo = opts.config.github?.repo;
   if (!owner || !repo) {
     throw new Error("resolveBackend: config.github.owner and config.github.repo must be set");
   }
-  const requested = opts.config.missions?.stateBackend ?? "contents-api";
+  const requested = opts.config.jobs?.stateBackend ?? "contents-api";
   switch (requested) {
     case "contents-api":
-      return new ContentsApiBackend({ owner, repo, missionsDir: opts.missionsDir, cwd: opts.cwd });
+      return new ContentsApiBackend({ owner, repo, jobsDir: opts.jobsDir, cwd: opts.cwd });
     case "local-file":
-      return new LocalFileBackend({ cwd: opts.cwd, missionsDir: opts.missionsDir, owner, repo });
+      return new LocalFileBackend({ cwd: opts.cwd, jobsDir: opts.jobsDir, owner, repo });
     default: {
       const _exhaustive = requested;
       throw new Error(`resolveBackend: unknown stateBackend "${String(_exhaustive)}"`);
@@ -3666,32 +3666,32 @@ function resolveBackend(opts) {
   }
 }
 
-// src/scripts/dispatchMissionFileTicks.ts
-var dispatchMissionFileTicks = async (ctx, _profile, args) => {
+// src/scripts/dispatchJobFileTicks.ts
+var dispatchJobFileTicks = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const targetExecutable = String(args?.targetExecutable ?? "");
   if (!targetExecutable) {
-    throw new Error("dispatchMissionFileTicks: `with.targetExecutable` is required");
+    throw new Error("dispatchJobFileTicks: `with.targetExecutable` is required");
   }
-  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
-  const slugArg = String(args?.slugArg ?? "mission");
-  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const slugArg = String(args?.slugArg ?? "job");
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   if (backend.hydrate) {
     await backend.hydrate();
   }
   try {
-    const slugs = listMissionSlugs(path17.join(ctx.cwd, missionsDir));
-    ctx.data.missionSlugCount = slugs.length;
+    const slugs = listJobSlugs(path17.join(ctx.cwd, jobsDir));
+    ctx.data.jobSlugCount = slugs.length;
     if (slugs.length === 0) {
-      process.stdout.write(`[missions] no mission files in ${missionsDir}
+      process.stdout.write(`[jobs] no job files in ${jobsDir}
 `);
       return;
     }
-    process.stdout.write(`[missions] ticking ${slugs.length} mission(s) via ${targetExecutable}
+    process.stdout.write(`[jobs] ticking ${slugs.length} job(s) via ${targetExecutable}
 `);
     const results = [];
     for (const slug of slugs) {
-      process.stdout.write(`[missions] \u2192 tick ${slug}
+      process.stdout.write(`[jobs] \u2192 tick ${slug}
 `);
       try {
         const out = await runExecutable(targetExecutable, {
@@ -3703,17 +3703,17 @@ var dispatchMissionFileTicks = async (ctx, _profile, args) => {
         });
         results.push({ slug, exitCode: out.exitCode, reason: out.reason });
         if (out.exitCode !== 0) {
-          process.stderr.write(`[missions] tick ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
+          process.stderr.write(`[jobs] tick ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
 `);
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[missions] tick ${slug} crashed: ${msg}
+        process.stderr.write(`[jobs] tick ${slug} crashed: ${msg}
 `);
         results.push({ slug, exitCode: 99, reason: msg });
       }
     }
-    ctx.data.missionTickResults = results;
+    ctx.data.jobTickResults = results;
     ctx.output.exitCode = 0;
   } finally {
     if (backend.persist) {
@@ -3721,13 +3721,13 @@ var dispatchMissionFileTicks = async (ctx, _profile, args) => {
         await backend.persist();
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[missions] backend persist failed: ${msg}
+        process.stderr.write(`[jobs] backend persist failed: ${msg}
 `);
       }
     }
   }
 };
-function listMissionSlugs(absDir) {
+function listJobSlugs(absDir) {
   if (!fs18.existsSync(absDir)) return [];
   let entries;
   try {
@@ -3738,26 +3738,26 @@ function listMissionSlugs(absDir) {
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, "")).filter((slug) => slug.length > 0 && !slug.startsWith("_") && !slug.startsWith(".")).sort();
 }
 
-// src/scripts/dispatchMissionTicks.ts
-var dispatchMissionTicks = async (ctx, _profile, args) => {
+// src/scripts/dispatchJobTicks.ts
+var dispatchJobTicks = async (ctx, _profile, args) => {
   ctx.skipAgent = true;
   const label = String(args?.label ?? "");
   const targetExecutable = String(args?.targetExecutable ?? "");
-  if (!label) throw new Error("dispatchMissionTicks: `with.label` is required");
-  if (!targetExecutable) throw new Error("dispatchMissionTicks: `with.targetExecutable` is required");
+  if (!label) throw new Error("dispatchJobTicks: `with.label` is required");
+  if (!targetExecutable) throw new Error("dispatchJobTicks: `with.targetExecutable` is required");
   const issueArg = String(args?.issueArg ?? "issue");
   const issues = listIssuesByLabel(label, ctx.cwd);
-  ctx.data.missionIssueCount = issues.length;
+  ctx.data.jobIssueCount = issues.length;
   if (issues.length === 0) {
-    process.stdout.write(`[missions] no open issues with label "${label}"
+    process.stdout.write(`[jobs] no open issues with label "${label}"
 `);
     return;
   }
-  process.stdout.write(`[missions] ticking ${issues.length} issue(s) via ${targetExecutable}
+  process.stdout.write(`[jobs] ticking ${issues.length} issue(s) via ${targetExecutable}
 `);
   const results = [];
   for (const issue of issues) {
-    process.stdout.write(`[missions] \u2192 tick #${issue.number}: ${issue.title}
+    process.stdout.write(`[jobs] \u2192 tick #${issue.number}: ${issue.title}
 `);
     try {
       const out = await runExecutable(targetExecutable, {
@@ -3769,17 +3769,17 @@ var dispatchMissionTicks = async (ctx, _profile, args) => {
       });
       results.push({ issue: issue.number, exitCode: out.exitCode, reason: out.reason });
       if (out.exitCode !== 0) {
-        process.stderr.write(`[missions] tick #${issue.number} failed (exit ${out.exitCode}): ${out.reason ?? ""}
+        process.stderr.write(`[jobs] tick #${issue.number} failed (exit ${out.exitCode}): ${out.reason ?? ""}
 `);
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[missions] tick #${issue.number} crashed: ${msg}
+      process.stderr.write(`[jobs] tick #${issue.number} crashed: ${msg}
 `);
       results.push({ issue: issue.number, exitCode: 99, reason: msg });
     }
   }
-  ctx.data.missionTickResults = results;
+  ctx.data.jobTickResults = results;
   ctx.output.exitCode = 0;
 };
 function listIssuesByLabel(label, cwd) {
@@ -4953,31 +4953,31 @@ var loadIssueStateComment = async (ctx, _profile, args) => {
   ctx.data.issueStateJson = loaded ? JSON.stringify(loaded.state, null, 2) : "null";
 };
 
-// src/scripts/loadMissionFromFile.ts
+// src/scripts/loadJobFromFile.ts
 import * as fs22 from "fs";
 import * as path20 from "path";
-var loadMissionFromFile = async (ctx, _profile, args) => {
-  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
-  const slugArg = String(args?.slugArg ?? "mission");
+var loadJobFromFile = async (ctx, _profile, args) => {
+  const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const slugArg = String(args?.slugArg ?? "job");
   const slug = String(ctx.args[slugArg] ?? "").trim();
   if (!slug) {
-    throw new Error(`loadMissionFromFile: ctx.args.${slugArg} must be a non-empty slug`);
+    throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
   }
-  const absPath = path20.join(ctx.cwd, missionsDir, `${slug}.md`);
+  const absPath = path20.join(ctx.cwd, jobsDir, `${slug}.md`);
   if (!fs22.existsSync(absPath)) {
-    throw new Error(`loadMissionFromFile: mission file not found: ${absPath}`);
+    throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
   }
   const raw = fs22.readFileSync(absPath, "utf-8");
-  const { title, body } = parseMissionFile(raw, slug);
-  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  const { title, body } = parseJobFile(raw, slug);
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   const loaded = await backend.load(slug);
-  ctx.data.missionSlug = slug;
-  ctx.data.missionTitle = title;
-  ctx.data.missionIntent = body;
-  ctx.data.missionState = loaded;
-  ctx.data.missionStateJson = JSON.stringify(loaded.state, null, 2);
+  ctx.data.jobSlug = slug;
+  ctx.data.jobTitle = title;
+  ctx.data.jobIntent = body;
+  ctx.data.jobState = loaded;
+  ctx.data.jobStateJson = JSON.stringify(loaded.state, null, 2);
 };
-function parseMissionFile(raw, slug) {
+function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
     const end = stripped.indexOf("\n---\n", 4);
@@ -5639,16 +5639,16 @@ function escapeRegex(s) {
   return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 
-// src/scripts/parseMissionStateFromAgentResult.ts
+// src/scripts/parseJobStateFromAgentResult.ts
 function isPartialEnvelope2(x) {
   if (x === null || typeof x !== "object") return false;
   const o = x;
   return typeof o.cursor === "string" && o.cursor.length > 0 && typeof o.done === "boolean" && o.data !== null && typeof o.data === "object" && !Array.isArray(o.data);
 }
-var parseMissionStateFromAgentResult = async (ctx, _profile, agentResult, args) => {
+var parseJobStateFromAgentResult = async (ctx, _profile, agentResult, args) => {
   const fenceLabel = String(args?.fenceLabel ?? "");
   if (!fenceLabel) {
-    throw new Error("parseMissionStateFromAgentResult: `with.fenceLabel` is required");
+    throw new Error("parseJobStateFromAgentResult: `with.fenceLabel` is required");
   }
   if (!agentResult) {
     ctx.data.nextStateParseError = "agent did not run";
@@ -5671,7 +5671,7 @@ var parseMissionStateFromAgentResult = async (ctx, _profile, agentResult, args)
     ctx.data.nextStateParseError = "state must be an object with string `cursor`, object `data`, and boolean `done`";
     return;
   }
-  const loaded = ctx.data.missionState;
+  const loaded = ctx.data.jobState;
   const prevRev = loaded?.state.rev ?? 0;
   const next = {
     version: 1,
@@ -5680,7 +5680,7 @@ var parseMissionStateFromAgentResult = async (ctx, _profile, agentResult, args)
     data: parsed.data,
     done: parsed.done
   };
-  ctx.data.nextMissionState = next;
+  ctx.data.nextJobState = next;
 };
 function escapeRegex2(s) {
   return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
@@ -7203,26 +7203,26 @@ var writeIssueStateComment = async (ctx, _profile, _agentResult, args) => {
   }
 };
 
-// src/scripts/writeMissionStateFile.ts
-var writeMissionStateFile = async (ctx, _profile, _agentResult, args) => {
+// src/scripts/writeJobStateFile.ts
+var writeJobStateFile = async (ctx, _profile, _agentResult, args) => {
   const parseError = ctx.data.nextStateParseError;
   if (parseError) {
-    process.stderr.write(`[kody] mission state write skipped: ${parseError}
+    process.stderr.write(`[kody] job state write skipped: ${parseError}
 `);
     if (ctx.output.exitCode === 0) ctx.output.exitCode = 1;
     if (!ctx.output.reason) ctx.output.reason = `next-state parse failed: ${parseError}`;
     return;
   }
-  const next = ctx.data.nextMissionState;
+  const next = ctx.data.nextJobState;
   if (!next) {
     return;
   }
-  const loaded = ctx.data.missionState;
+  const loaded = ctx.data.jobState;
   if (!loaded) {
-    throw new Error("writeMissionStateFile: ctx.data.missionState missing \u2014 preflight must run first");
+    throw new Error("writeJobStateFile: ctx.data.jobState missing \u2014 preflight must run first");
   }
-  const missionsDir = String(args?.missionsDir ?? ".kody/missions");
-  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, missionsDir });
+  const jobsDir = String(args?.jobsDir ?? ".kody/jobs");
+  const backend = resolveBackend({ config: ctx.config, cwd: ctx.cwd, jobsDir });
   await backend.save(loaded, next);
 };
 
@@ -7271,7 +7271,7 @@ var preflightScripts = {
   loadVaultContext,
   loadIssueContext,
   loadIssueStateComment,
-  loadMissionFromFile,
+  loadJobFromFile,
   loadConventions,
   loadCoverageRules,
   loadPriorArt,
@@ -7286,16 +7286,16 @@ var preflightScripts = {
   skipAgent,
   classifyByLabel,
   diagMcp,
-  dispatchMissionTicks,
-  dispatchMissionFileTicks
+  dispatchJobTicks,
+  dispatchJobFileTicks
 };
 var postflightScripts = {
   parseAgentResult: parseAgentResult2,
   parseIssueStateFromAgentResult,
-  parseMissionStateFromAgentResult,
+  parseJobStateFromAgentResult,
   parseReproOutput,
   writeIssueStateComment,
-  writeMissionStateFile,
+  writeJobStateFile,
   requireFeedbackActions,
   requirePlanDeviations,
   verify,

package/dist/executables/bug/profile.json

@@ -1,7 +1,7 @@
 {
   "name": "bug",
-  "role": "orchestrator",
-  "describe": "Sub-orchestrator for bug / enhancement issues — plan → run → review (→ fix on concerns/fail). No agent — the postflight entries ARE the transition table, evaluated top-to-bottom via runWhen.",
+  "role": "container",
+  "describe": "Bug / enhancement flow — reproduce → plan → run → review (→ fix on concerns/fail). Children run sequentially in one process via the container loop.",
   "inputs": [
     {
       "name": "issue",
@@ -45,33 +45,21 @@
         }
       },
       { "script": "loadIssueContext" },
-      { "script": "loadTaskState" },
-      { "script": "skipAgent" }
+      { "script": "loadTaskState" }
     ],
     "postflight": [
-      { "script": "startFlow", "with": { "entry": "plan", "target": "issue" } },
-
-      { "script": "dispatch", "with": { "next": "run", "target": "issue" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "PLAN_COMPLETED" } },
-
-      { "script": "dispatch", "with": { "next": "review", "target": "pr" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "RUN_COMPLETED" } },
-
       { "script": "finishFlow",
         "with": { "reason": "review-passed", "label": "kody:done", "color": "0e8a16", "description": "kody: PR ready for human review/merge" },
         "runWhen": { "data.taskState.core.lastOutcome.type": "REVIEW_PASS" } },
 
-      { "script": "dispatch", "with": { "next": "fix", "target": "pr" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": ["REVIEW_CONCERNS", "REVIEW_FAIL"] } },
+      { "script": "finishFlow",
+        "with": { "reason": "fix-applied", "label": "kody:done", "color": "0e8a16", "description": "kody: PR ready for human review/merge" },
+        "runWhen": { "data.taskState.core.lastOutcome.type": "FIX_COMPLETED" } },
 
       { "script": "finishFlow",
         "with": { "reason": "review-failed", "label": "kody:failed", "color": "e11d21", "description": "kody: flow failed" },
         "runWhen": { "data.taskState.core.lastOutcome.type": "REVIEW_FAILED" } },
 
-      { "script": "finishFlow",
-        "with": { "reason": "fix-applied", "label": "kody:done", "color": "0e8a16", "description": "kody: PR ready for human review/merge" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "FIX_COMPLETED" } },
-
       { "script": "finishFlow",
         "with": { "reason": "aborted", "label": "kody:failed", "color": "e11d21", "description": "kody: flow failed" },
         "runWhen": { "data.taskState.core.lastOutcome.type": ["PLAN_FAILED", "RUN_FAILED", "FIX_FAILED", "AGENT_NOT_RUN"] } },
@@ -79,9 +67,53 @@
       { "script": "persistFlowState" }
     ]
   },
+  "children": [
+    {
+      "exec": "reproduce",
+      "target": "issue",
+      "next": {
+        "REPRODUCE_COMPLETED": "plan",
+        "REPRODUCE_FAILED": "plan",
+        "*": "abort"
+      }
+    },
+    {
+      "exec": "plan",
+      "target": "issue",
+      "next": {
+        "PLAN_COMPLETED": "run",
+        "*": "abort"
+      }
+    },
+    {
+      "exec": "run",
+      "target": "issue",
+      "next": {
+        "RUN_COMPLETED": "review",
+        "*": "abort"
+      }
+    },
+    {
+      "exec": "review",
+      "target": "pr",
+      "next": {
+        "REVIEW_PASS": "done",
+        "REVIEW_CONCERNS": "fix",
+        "REVIEW_FAIL": "fix",
+        "*": "abort"
+      }
+    },
+    {
+      "exec": "fix",
+      "target": "pr",
+      "next": {
+        "FIX_COMPLETED": "done",
+        "*": "abort"
+      }
+    }
+  ],
   "output": {
     "actionTypes": [
-      "FLOW_STARTED",
       "FLOW_COMPLETED",
       "FLOW_ABORTED"
     ]

package/dist/executables/bug/prompt.md

@@ -1,7 +1,6 @@
 <!--
-This file exists only because the executor's profile loader expects a
-prompt.md sibling. The orchestrator-plan-build-review executable runs
-with maxTurns: 0 and a `skipAgent` preflight, so this prompt is never
-actually delivered to Claude. The transition logic lives entirely in
-profile.json's postflight entries.
+Container role: no agent runs. The transition logic lives entirely in
+profile.json's `children[].next` map (driven by the container loop in
+src/executor.ts:runContainerLoop). This file exists only because the
+profile loader expects a prompt.md sibling.
 -->

package/dist/executables/{mission-scheduler → job-scheduler}/profile.json

@@ -1,7 +1,7 @@
 {
-  "name": "mission-scheduler",
+  "name": "job-scheduler",
   "role": "watch",
-  "describe": "Scheduled: for every mission file under .kody/missions/, invoke mission-tick once. No agent on the scheduler itself.",
+  "describe": "Scheduled: for every job file under .kody/jobs/, invoke job-tick once. No agent on the scheduler itself.",
   "kind": "scheduled",
   "schedule": "*/5 * * * *",
   "inputs": [],
@@ -36,11 +36,11 @@
   "scripts": {
     "preflight": [
       {
-        "script": "dispatchMissionFileTicks",
+        "script": "dispatchJobFileTicks",
         "with": {
-          "missionsDir": ".kody/missions",
-          "targetExecutable": "mission-tick",
-          "slugArg": "mission"
+          "jobsDir": ".kody/jobs",
+          "targetExecutable": "job-tick",
+          "slugArg": "job"
         }
       }
     ],

package/dist/executables/{mission-tick → job-tick}/profile.json

@@ -1,15 +1,15 @@
 {
-  "name": "mission-tick",
+  "name": "job-tick",
   "role": "primitive",
-  "describe": "One classifier tick for one mission file: read intent + state, decide and execute via gh, emit next state.",
+  "describe": "One classifier tick for one job file: read intent + state, decide and execute via gh, emit next state.",
   "kind": "oneshot",
   "inputs": [
     {
-      "name": "mission",
-      "flag": "--mission",
+      "name": "job",
+      "flag": "--job",
       "type": "string",
       "required": true,
-      "describe": "Mission slug — basename (without .md) of the file under .kody/missions/."
+      "describe": "Job slug — basename (without .md) of the file under .kody/jobs/."
     }
   ],
   "claudeCode": {
@@ -43,10 +43,10 @@
   "scripts": {
     "preflight": [
       {
-        "script": "loadMissionFromFile",
+        "script": "loadJobFromFile",
         "with": {
-          "missionsDir": ".kody/missions",
-          "slugArg": "mission"
+          "jobsDir": ".kody/jobs",
+          "slugArg": "job"
         }
       },
       {
@@ -55,13 +55,13 @@
     ],
     "postflight": [
       {
-        "script": "parseMissionStateFromAgentResult",
+        "script": "parseJobStateFromAgentResult",
         "with": {
-          "fenceLabel": "kody-mission-next-state"
+          "fenceLabel": "kody-job-next-state"
         }
       },
       {
-        "script": "writeMissionStateFile"
+        "script": "writeJobStateFile"
       }
     ]
   }

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

@@ -0,0 +1,52 @@
+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.
+
+## 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.
+
+### Job 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 job'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 job is permanently over — for evergreen jobs this should always remain `false`.
+
+## What to do on this tick
+
+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 job body.** It may have changed since the last tick.
+3. **Execute exactly the work the body's `## Job` 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 job 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.
+- 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 job body's `## Restrictions` over any inferred shortcut.

package/kody.config.schema.json

@@ -383,14 +383,14 @@
       },
       "additionalProperties": false
     },
-    "missions": {
+    "jobs": {
       "type": "object",
-      "description": "File-based mission configuration. Missions are long-running scheduled executables defined under .kody/missions/<slug>.md.",
+      "description": "File-based job configuration. Jobs are long-running scheduled executables defined under .kody/jobs/<slug>.md.",
       "properties": {
         "stateBackend": {
           "type": "string",
           "enum": ["contents-api", "local-file"],
-          "description": "Storage backend for mission state. \"contents-api\" (default) commits state to a tracked file via the GitHub Contents API — durable across runs but creates a commit per change. \"local-file\" stores state on disk and snapshots it to the GitHub Actions cache between workflow runs — no commit churn, but bound to cache eviction (7-day idle).",
+          "description": "Storage backend for job state. \"contents-api\" (default) commits state to a tracked file via the GitHub Contents API — durable across runs but creates a commit per change. \"local-file\" stores state on disk and snapshots it to the GitHub Actions cache between workflow runs — no commit churn, but bound to cache eviction (7-day idle).",
           "default": "contents-api"
         }
       },

package/package.json

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

package/templates/kody.yml

@@ -49,7 +49,7 @@ on:
     types: [closed]
   schedule:
     # Wakes every 30 minutes; kody fans out to whichever scheduled executables
-    # (mission-scheduler, memorize, watch-stale-prs, …) match this tick.
+    # (job-scheduler, memorize, watch-stale-prs, …) match this tick.
     #
     # `memorize` writes to `.kody/vault/` and opens a daily PR. If your
     # `.gitignore` ignores `.kody/*`, add `!.kody/vault/` and `!.kody/vault/**`

package/dist/executables/bug-container/profile.json

@@ -1,121 +0,0 @@
-{
-  "name": "bug-container",
-  "role": "container",
-  "describe": "Container variant of `bug` — same plan → run → review (→ fix) flow, but children run sequentially in one process instead of as N comment-dispatched GHA runs. Strictly additive; the comment-driven `bug` orchestrator remains the default until classify is flipped.",
-  "inputs": [
-    {
-      "name": "issue",
-      "flag": "--issue",
-      "type": "int",
-      "required": true,
-      "describe": "GitHub issue number to drive the flow on."
-    }
-  ],
-  "claudeCode": {
-    "model": "inherit",
-    "permissionMode": "default",
-    "maxTurns": 0,
-    "maxThinkingTokens": null,
-    "systemPromptAppend": null,
-    "tools": [],
-    "hooks": [],
-    "skills": [],
-    "commands": [],
-    "subagents": [],
-    "plugins": [],
-    "mcpServers": []
-  },
-  "cliTools": [],
-  "scripts": {
-    "preflight": [
-      {
-        "script": "setLifecycleLabel",
-        "with": {
-          "label": "kody-flow:bug",
-          "color": "d73a4a",
-          "description": "kody flow: bug / enhancement"
-        }
-      },
-      {
-        "script": "setLifecycleLabel",
-        "with": {
-          "label": "kody:orchestrating",
-          "color": "1d76db",
-          "description": "kody: orchestrating a multi-stage flow"
-        }
-      },
-      { "script": "loadIssueContext" },
-      { "script": "loadTaskState" }
-    ],
-    "postflight": [
-      { "script": "finishFlow",
-        "with": { "reason": "review-passed", "label": "kody:done", "color": "0e8a16", "description": "kody: PR ready for human review/merge" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "REVIEW_PASS" } },
-
-      { "script": "finishFlow",
-        "with": { "reason": "fix-applied", "label": "kody:done", "color": "0e8a16", "description": "kody: PR ready for human review/merge" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "FIX_COMPLETED" } },
-
-      { "script": "finishFlow",
-        "with": { "reason": "review-failed", "label": "kody:failed", "color": "e11d21", "description": "kody: flow failed" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": "REVIEW_FAILED" } },
-
-      { "script": "finishFlow",
-        "with": { "reason": "aborted", "label": "kody:failed", "color": "e11d21", "description": "kody: flow failed" },
-        "runWhen": { "data.taskState.core.lastOutcome.type": ["PLAN_FAILED", "RUN_FAILED", "FIX_FAILED", "AGENT_NOT_RUN"] } },
-
-      { "script": "persistFlowState" }
-    ]
-  },
-  "children": [
-    {
-      "exec": "reproduce",
-      "target": "issue",
-      "next": {
-        "REPRODUCE_COMPLETED": "plan",
-        "REPRODUCE_FAILED": "plan",
-        "*": "abort"
-      }
-    },
-    {
-      "exec": "plan",
-      "target": "issue",
-      "next": {
-        "PLAN_COMPLETED": "run",
-        "*": "abort"
-      }
-    },
-    {
-      "exec": "run",
-      "target": "issue",
-      "next": {
-        "RUN_COMPLETED": "review",
-        "*": "abort"
-      }
-    },
-    {
-      "exec": "review",
-      "target": "pr",
-      "next": {
-        "REVIEW_PASS": "done",
-        "REVIEW_CONCERNS": "fix",
-        "REVIEW_FAIL": "fix",
-        "*": "abort"
-      }
-    },
-    {
-      "exec": "fix",
-      "target": "pr",
-      "next": {
-        "FIX_COMPLETED": "done",
-        "*": "abort"
-      }
-    }
-  ],
-  "output": {
-    "actionTypes": [
-      "FLOW_COMPLETED",
-      "FLOW_ABORTED"
-    ]
-  }
-}

package/dist/executables/bug-container/prompt.md

@@ -1,6 +0,0 @@
-<!--
-Container role: no agent runs. The transition logic lives entirely in
-profile.json's `children[].next` map (driven by the container loop in
-src/executor.ts:runContainerLoop). This file exists only because the
-profile loader expects a prompt.md sibling.
--->

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

@@ -1,52 +0,0 @@
-You are **kody mission-tick**, the coordinator for one file-based mission. 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 mission
-
-Slug **`{{missionSlug}}`** — *{{missionTitle}}*. The mission body below is authoritative: it states what success looks like, allowed commands, and restrictions. The mission file is human-edited — re-read it every tick.
-
-### Mission body
-
-{{missionIntent}}
-
-## Current state
-
-This is the state you wrote at the end of the previous tick (or `null` if this is the first tick):
-
-```json
-{{missionStateJson}}
-```
-
-`cursor` is *your* enum — pick whatever labels map cleanly to your mission'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 mission is permanently over — for evergreen missions this should always remain `false`.
-
-## What to do on this tick
-
-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 mission body.** It may have changed since the last tick.
-3. **Execute exactly the work the body's `## Mission` 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 mission 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-mission-next-state` language tag:
-
-````
-```kody-mission-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.
-- 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 mission body's `## Restrictions` over any inferred shortcut.