@kody-ade/kody-engine 0.4.218 → 0.4.220

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.218",
+      version: "0.4.220",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -1981,68 +1981,224 @@ var init_agent = __esm({
   }
 });
 
-// src/registry.ts
+// src/scripts/scheduleEvery.ts
+function isScheduleEvery(value) {
+  return typeof value === "string" && SCHEDULE_EVERY_VALUES.includes(value);
+}
+function scheduleEveryToMs(every) {
+  const MIN = 60 * 1e3;
+  const HOUR = 60 * MIN;
+  const DAY = 24 * HOUR;
+  switch (every) {
+    case "15m":
+      return 15 * MIN;
+    case "30m":
+      return 30 * MIN;
+    case "1h":
+      return HOUR;
+    case "2h":
+      return 2 * HOUR;
+    case "6h":
+      return 6 * HOUR;
+    case "12h":
+      return 12 * HOUR;
+    case "1d":
+      return DAY;
+    case "3d":
+      return 3 * DAY;
+    case "7d":
+      return 7 * DAY;
+    case "manual":
+      return Number.POSITIVE_INFINITY;
+  }
+}
+var SCHEDULE_EVERY_VALUES;
+var init_scheduleEvery = __esm({
+  "src/scripts/scheduleEvery.ts"() {
+    "use strict";
+    SCHEDULE_EVERY_VALUES = [
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "6h",
+      "12h",
+      "1d",
+      "3d",
+      "7d",
+      "manual"
+    ];
+  }
+});
+
+// src/dutyFolders.ts
 import * as fs6 from "fs";
 import * as path6 from "path";
+function listDutyFolderSlugs(absDir) {
+  if (!fs6.existsSync(absDir)) return [];
+  let entries;
+  try {
+    entries = fs6.readdirSync(absDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isDutyFolder(path6.join(absDir, e.name))).map((e) => e.name).sort();
+}
+function isDutyFolder(dir) {
+  return fs6.existsSync(path6.join(dir, DUTY_PROFILE_FILE)) && fs6.existsSync(path6.join(dir, DUTY_BODY_FILE));
+}
+function readDutyFolder(root, slug) {
+  const dir = path6.join(root, slug);
+  const profilePath = path6.join(dir, DUTY_PROFILE_FILE);
+  const bodyPath = path6.join(dir, DUTY_BODY_FILE);
+  if (!fs6.existsSync(profilePath) || !fs6.statSync(profilePath).isFile()) return null;
+  if (!fs6.existsSync(bodyPath) || !fs6.statSync(bodyPath).isFile()) return null;
+  try {
+    const rawProfile = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const rawBody = fs6.readFileSync(bodyPath, "utf-8");
+    const { title, body } = parseDutyBody(rawBody, slug);
+    return {
+      slug,
+      dir,
+      profilePath,
+      bodyPath,
+      title,
+      body,
+      rawBody,
+      config: parseDutyConfig(rawProfile),
+      rawProfile
+    };
+  } catch {
+    return null;
+  }
+}
+function parseDutyConfig(raw) {
+  const tools = stringList(raw.tools ?? raw.dutyTools);
+  return {
+    action: stringField(raw.action),
+    executable: stringField(raw.executable),
+    every: isScheduleEvery(raw.every) ? raw.every : void 0,
+    tickScript: stringField(raw.tickScript),
+    disabled: typeof raw.disabled === "boolean" ? raw.disabled : void 0,
+    staff: stringField(raw.staff),
+    mentions: stringList(raw.mentions).map((m) => m.replace(/^@/, "")),
+    tools,
+    executables: stringList(raw.executables),
+    describe: stringField(raw.describe),
+    stage: stringField(raw.stage),
+    readsFrom: stringList(raw.readsFrom ?? raw.reads_from),
+    writesTo: stringList(raw.writesTo ?? raw.writes_to)
+  };
+}
+function parseDutyBody(raw, slug) {
+  const trimmed = raw.trim();
+  const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
+  const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
+  const title = h1 ? h1[1].trim() : humanizeSlug(slug);
+  const body = stripLeadingH1(raw);
+  return { title, body };
+}
+function stripLeadingH1(raw) {
+  const lines = raw.replace(/^\uFEFF/, "").split("\n");
+  let i = 0;
+  for (; ; ) {
+    while (i < lines.length && lines[i].trim() === "") i++;
+    if (i < lines.length && /^#\s+.+/.test(lines[i])) i++;
+    else break;
+  }
+  return lines.slice(i).join("\n");
+}
+function humanizeSlug(slug) {
+  return slug.split(/[-_]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function stringList(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => String(v).trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((v) => v.trim()).filter(Boolean);
+  }
+  return [];
+}
+var DUTY_PROFILE_FILE, DUTY_BODY_FILE;
+var init_dutyFolders = __esm({
+  "src/dutyFolders.ts"() {
+    "use strict";
+    init_scheduleEvery();
+    DUTY_PROFILE_FILE = "profile.json";
+    DUTY_BODY_FILE = "duty.md";
+  }
+});
+
+// src/registry.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
 function getExecutablesRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "executables"),
+    path7.join(here, "executables"),
     // dev: src/
-    path6.join(here, "..", "executables"),
+    path7.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path6.join(here, "..", "src", "executables")
+    path7.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path6.join(process.cwd(), ".kody", "executables");
+  return path7.join(process.cwd(), ".kody", "executables");
 }
 function getProjectDutiesRoot() {
-  return path6.join(process.cwd(), ".kody", "duties");
+  return path7.join(process.cwd(), ".kody", "duties");
 }
 function getBuiltinJobsRoot() {
-  const here = path6.dirname(new URL(import.meta.url).pathname);
+  const here = path7.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path6.join(here, "jobs"),
+    path7.join(here, "jobs"),
     // dev: src/
-    path6.join(here, "..", "jobs"),
+    path7.join(here, "..", "jobs"),
     // built: dist/bin → dist/jobs
-    path6.join(here, "..", "src", "jobs")
+    path7.join(here, "..", "src", "jobs")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+function getBuiltinDutiesRoot() {
+  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path7.join(here, "duties"),
+    // dev: src/
+    path7.join(here, "..", "duties"),
+    // built: dist/bin → dist/duties
+    path7.join(here, "..", "src", "duties")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
     if (ent.name.startsWith("_") || ent.name.startsWith(".")) continue;
-    const full = path6.join(root, ent.name);
+    const full = path7.join(root, ent.name);
     if (ent.isDirectory()) {
-      const profilePath = path6.join(full, "profile.json");
-      const promptPath = path6.join(full, "prompt.md");
-      if (!fs6.existsSync(profilePath) || !fs6.statSync(profilePath).isFile()) continue;
-      if (!fs6.existsSync(promptPath) || !fs6.statSync(promptPath).isFile()) continue;
-      out.push({ slug: ent.name, dir: full, profilePath, promptPath });
-      continue;
-    }
-    if (ent.isFile() && ent.name.endsWith(".md")) {
-      const slug = ent.name.slice(0, -3);
-      out.push({
-        slug,
-        dir: full,
-        profilePath: "",
-        promptPath: "",
-        filePath: full
-      });
+      const profilePath = path7.join(full, DUTY_PROFILE_FILE);
+      const bodyPath = path7.join(full, DUTY_BODY_FILE);
+      if (!fs7.existsSync(profilePath) || !fs7.statSync(profilePath).isFile()) continue;
+      if (!fs7.existsSync(bodyPath) || !fs7.statSync(bodyPath).isFile()) continue;
+      out.push({ slug: ent.name, dir: full, profilePath, bodyPath });
     }
   }
   out.sort((a, b) => a.slug.localeCompare(b.slug));
@@ -2056,8 +2212,8 @@ function builtinExecutableNames() {
   const out = /* @__PURE__ */ new Set();
   const root = getExecutablesRoot();
   try {
-    for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
-      if (ent.isDirectory() && fs6.existsSync(path6.join(root, ent.name, "profile.json"))) out.add(ent.name);
+    for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
+      if (ent.isDirectory() && fs7.existsSync(path7.join(root, ent.name, "profile.json"))) out.add(ent.name);
     }
   } catch {
   }
@@ -2073,14 +2229,15 @@ function listExecutables(roots = getExecutableRoots()) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs6.existsSync(root)) continue;
-    const entries = fs6.readdirSync(root, { withFileTypes: true });
+    if (!fs7.existsSync(root)) continue;
+    const entries = fs7.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
       if (root === dutiesRoot && isBuiltinExecutable(ent.name)) continue;
-      const profilePath = path6.join(root, ent.name, "profile.json");
-      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+      const profilePath = path7.join(root, ent.name, DUTY_PROFILE_FILE);
+      if (root === dutiesRoot && !fs7.existsSync(path7.join(root, ent.name, DUTY_BODY_FILE))) continue;
+      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -2094,8 +2251,9 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
   const dutiesRoot = getProjectDutiesRoot();
   for (const root of rootList) {
     if (root === dutiesRoot && isBuiltinExecutable(name)) continue;
-    const profilePath = path6.join(root, name, "profile.json");
-    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+    if (root === dutiesRoot && !fs7.existsSync(path7.join(root, name, DUTY_BODY_FILE))) continue;
+    const profilePath = path7.join(root, name, "profile.json");
+    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -2104,14 +2262,78 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
 function hasExecutable(name, roots = getExecutableRoots()) {
   return resolveExecutable(name, roots) !== null;
 }
+function listDutyActions(projectDutiesRoot = getProjectDutiesRoot()) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (action) => {
+    if (!isSafeName(action.action) || !isSafeName(action.duty) || !isSafeName(action.executable)) return;
+    if (seen.has(action.action)) return;
+    seen.add(action.action);
+    out.push(action);
+  };
+  for (const action of listProjectFolderDutyActions(projectDutiesRoot)) add(action);
+  for (const action of listBuiltinDutyActions()) add(action);
+  return out.sort((a, b) => a.action.localeCompare(b.action));
+}
+function resolveDutyAction(action, projectDutiesRoot = getProjectDutiesRoot()) {
+  if (!isSafeName(action)) return null;
+  return listDutyActions(projectDutiesRoot).find((d) => d.action === action) ?? null;
+}
+function hasDutyAction(action, projectDutiesRoot = getProjectDutiesRoot()) {
+  return resolveDutyAction(action, projectDutiesRoot) !== null;
+}
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
+function listProjectFolderDutyActions(root) {
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+  const out = [];
+  for (const slug of listDutyFolderSlugs(root)) {
+    if (!isSafeName(slug)) continue;
+    const duty = readDutyFolder(root, slug);
+    if (!duty) continue;
+    const action = duty.config.action ?? slug;
+    const executable = duty.config.executable ?? duty.config.executables?.[0] ?? (duty.config.tickScript ? "duty-tick-scripted" : "duty-tick");
+    out.push({
+      action,
+      duty: slug,
+      executable,
+      cliArgs: duty.config.executable ? {} : { duty: slug },
+      source: "project-folder",
+      describe: duty.config.describe ?? duty.title,
+      profilePath: duty.profilePath,
+      bodyPath: duty.bodyPath
+    });
+  }
+  return out.sort((a, b) => a.action.localeCompare(b.action));
+}
+function listBuiltinDutyActions(root = getBuiltinDutiesRoot()) {
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+  const out = [];
+  for (const slug of listDutyFolderSlugs(root)) {
+    if (!isSafeName(slug)) continue;
+    const duty = readDutyFolder(root, slug);
+    if (!duty) continue;
+    const action = duty.config.action ?? slug;
+    const executable = duty.config.executable ?? slug;
+    out.push({
+      action,
+      duty: slug,
+      executable,
+      cliArgs: {},
+      source: "builtin",
+      describe: duty.config.describe ?? duty.title,
+      profilePath: duty.profilePath,
+      bodyPath: duty.bodyPath
+    });
+  }
+  return out.sort((a, b) => a.action.localeCompare(b.action));
+}
 function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -2147,26 +2369,27 @@ var _builtinNames;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
+    init_dutyFolders();
     _builtinNames = null;
   }
 });
 
 // src/task-artifacts.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function prepareTaskArtifactsDir(cwd, taskId) {
   const safeId = String(taskId).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const relDir = path7.join(".kody", "tasks", safeId);
-  const absDir = path7.join(cwd, relDir);
-  fs7.mkdirSync(absDir, { recursive: true });
+  const relDir = path8.join(".kody", "tasks", safeId);
+  const absDir = path8.join(cwd, relDir);
+  fs8.mkdirSync(absDir, { recursive: true });
   return { taskId: safeId, absDir, relDir };
 }
 function verifyTaskArtifacts(absDir) {
   const missing = [];
   for (const name of TASK_ARTIFACT_FILES) {
-    const full = path7.join(absDir, name);
+    const full = path8.join(absDir, name);
     try {
-      const stat = fs7.statSync(full);
+      const stat = fs8.statSync(full);
       if (!stat.isFile() || stat.size === 0) missing.push(name);
     } catch {
       missing.push(name);
@@ -2400,31 +2623,31 @@ var init_lifecycles = __esm({
 });
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os2 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 function getPluginsCatalogRoot() {
-  const here = path12.dirname(new URL(import.meta.url).pathname);
+  const here = path13.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path12.join(here, "..", "plugins"),
+    path13.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path12.join(here, "..", "..", "plugins"),
+    path13.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path12.join(here, "..", "..", "src", "plugins")
+    path13.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs13.existsSync(c) && fs13.statSync(c).isDirectory()) return c;
+    if (fs14.existsSync(c) && fs14.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function copyDir(src, dst) {
-  fs13.mkdirSync(dst, { recursive: true });
-  for (const ent of fs13.readdirSync(src, { withFileTypes: true })) {
-    const s = path12.join(src, ent.name);
-    const d = path12.join(dst, ent.name);
+  fs14.mkdirSync(dst, { recursive: true });
+  for (const ent of fs14.readdirSync(src, { withFileTypes: true })) {
+    const s = path13.join(src, ent.name);
+    const d = path13.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs13.copyFileSync(s, d);
+    else if (ent.isFile()) fs14.copyFileSync(s, d);
   }
 }
 var buildSyntheticPlugin;
@@ -2437,45 +2660,45 @@ var init_buildSyntheticPlugin = __esm({
       if (!needsSynthetic) return;
       const catalog = getPluginsCatalogRoot();
       const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const root = path12.join(os2.tmpdir(), `kody-synth-${runId}`);
-      fs13.mkdirSync(path12.join(root, ".claude-plugin"), { recursive: true });
+      const root = path13.join(os2.tmpdir(), `kody-synth-${runId}`);
+      fs14.mkdirSync(path13.join(root, ".claude-plugin"), { recursive: true });
       const resolvePart = (bucket, entry) => {
-        const local = path12.join(profile.dir, bucket, entry);
-        if (fs13.existsSync(local)) return local;
-        const central = path12.join(catalog, bucket, entry);
-        if (fs13.existsSync(central)) return central;
+        const local = path13.join(profile.dir, bucket, entry);
+        if (fs14.existsSync(local)) return local;
+        const central = path13.join(catalog, bucket, entry);
+        if (fs14.existsSync(central)) return central;
         throw new Error(
           `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
         );
       };
       if (cc.skills.length > 0) {
-        const dst = path12.join(root, "skills");
-        fs13.mkdirSync(dst, { recursive: true });
+        const dst = path13.join(root, "skills");
+        fs14.mkdirSync(dst, { recursive: true });
         for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path12.join(dst, name));
+          copyDir(resolvePart("skills", name), path13.join(dst, name));
         }
       }
       if (cc.commands.length > 0) {
-        const dst = path12.join(root, "commands");
-        fs13.mkdirSync(dst, { recursive: true });
+        const dst = path13.join(root, "commands");
+        fs14.mkdirSync(dst, { recursive: true });
         for (const name of cc.commands) {
-          fs13.copyFileSync(resolvePart("commands", `${name}.md`), path12.join(dst, `${name}.md`));
+          fs14.copyFileSync(resolvePart("commands", `${name}.md`), path13.join(dst, `${name}.md`));
         }
       }
       if (cc.hooks.length > 0) {
-        const dst = path12.join(root, "hooks");
-        fs13.mkdirSync(dst, { recursive: true });
+        const dst = path13.join(root, "hooks");
+        fs14.mkdirSync(dst, { recursive: true });
         const merged = { hooks: {} };
         for (const name of cc.hooks) {
           const src = resolvePart("hooks", `${name}.json`);
-          const parsed = JSON.parse(fs13.readFileSync(src, "utf-8"));
+          const parsed = JSON.parse(fs14.readFileSync(src, "utf-8"));
           for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
             if (!Array.isArray(entries)) continue;
             if (!merged.hooks[event]) merged.hooks[event] = [];
             merged.hooks[event].push(...entries);
           }
         }
-        fs13.writeFileSync(path12.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+        fs14.writeFileSync(path13.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
       }
       const manifest = {
@@ -2485,7 +2708,7 @@ var init_buildSyntheticPlugin = __esm({
       };
       if (cc.skills.length > 0) manifest.skills = ["./skills/"];
       if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs13.writeFileSync(path12.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+      fs14.writeFileSync(path13.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       ctx.data.syntheticPluginPath = root;
     };
@@ -2493,8 +2716,8 @@ var init_buildSyntheticPlugin = __esm({
 });
 
 // src/subagents.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 function splitFrontmatter(raw) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
   if (!match) return { fm: {}, body: raw.trim() };
@@ -2507,10 +2730,10 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile(profileDir, name) {
-  const local = path13.join(profileDir, "agents", `${name}.md`);
-  if (fs14.existsSync(local)) return local;
-  const central = path13.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs14.existsSync(central)) return central;
+  const local = path14.join(profileDir, "agents", `${name}.md`);
+  if (fs15.existsSync(local)) return local;
+  const central = path14.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs15.existsSync(central)) return central;
   throw new Error(`loadSubagents: agent '${name}' not found in ${profileDir}/agents/ or shared catalog`);
 }
 function captureSubagentTemplates(profile) {
@@ -2519,7 +2742,7 @@ function captureSubagentTemplates(profile) {
   const out = {};
   for (const name of names) {
     try {
-      out[name] = fs14.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+      out[name] = fs15.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
     } catch {
     }
   }
@@ -2530,7 +2753,7 @@ function loadSubagents(profile) {
   if (!names || names.length === 0) return void 0;
   const agents = {};
   for (const name of names) {
-    const raw = profile.subagentTemplates?.[name] ?? fs14.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+    const raw = profile.subagentTemplates?.[name] ?? fs15.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
     const { fm, body } = splitFrontmatter(raw);
     if (!body) throw new Error(`loadSubagents: agent '${name}' has an empty prompt body`);
     const def = {
@@ -2554,15 +2777,15 @@ var init_subagents = __esm({
 });
 
 // src/profile.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 function loadProfile(profilePath) {
-  if (!fs15.existsSync(profilePath)) {
+  if (!fs16.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs15.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs16.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -2573,7 +2796,7 @@ function loadProfile(profilePath) {
   const unknownKeys = Object.keys(r).filter((k) => !KNOWN_PROFILE_KEYS.has(k));
   if (unknownKeys.length > 0) {
     process.stderr.write(
-      `[kody profile] ${path14.basename(path14.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path15.basename(path15.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -2587,11 +2810,12 @@ function loadProfile(profilePath) {
     return {
       ...base,
       name: requireString(profilePath, r, "name"),
+      action: typeof r.action === "string" && r.action.trim() ? r.action.trim() : void 0,
       executable: execRef,
       describe: typeof r.describe === "string" ? r.describe : base.describe,
       staff: typeof r.staff === "string" && r.staff.trim() ? r.staff.trim() : base.staff,
       every: typeof r.every === "string" && r.every.trim() ? r.every.trim() : void 0,
-      dutyTools: Array.isArray(r.dutyTools) ? r.dutyTools.map((t) => String(t).trim()).filter(Boolean) : base.dutyTools,
+      dutyTools: parseStringArray(r.dutyTools ?? r.tools) ?? base.dutyTools,
       mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : base.mentions
     };
   }
@@ -2630,14 +2854,15 @@ function loadProfile(profilePath) {
   }
   const profile = {
     name: requireString(profilePath, r, "name"),
+    action: typeof r.action === "string" && r.action.trim() ? r.action.trim() : void 0,
     executable: void 0,
     describe: typeof r.describe === "string" ? r.describe : "",
     // Optional persona to run as. Empty/blank string → undefined (no persona).
     staff: typeof r.staff === "string" && r.staff.trim() ? r.staff.trim() : void 0,
     // Optional recurrence cadence (scheduled duty). Blank → undefined (on-demand).
     every: typeof r.every === "string" && r.every.trim() ? r.every.trim() : void 0,
-    // Locked-toolbox palette + mentions (folder-duty successors to frontmatter).
-    dutyTools: Array.isArray(r.dutyTools) ? r.dutyTools.map((t) => String(t).trim()).filter(Boolean) : void 0,
+    // Locked-toolbox palette + mentions from folder-duty profile metadata.
+    dutyTools: parseStringArray(r.dutyTools ?? r.tools),
     mentions: Array.isArray(r.mentions) ? r.mentions.map((m) => String(m).trim()).filter(Boolean) : void 0,
     role,
     kind,
@@ -2660,8 +2885,8 @@ function loadProfile(profilePath) {
     // Phase 5 in-process handoff opt-in. Default false; containers
     // flip to true after end-to-end verification.
     preloadContext: r.preloadContext === true,
-    dir: path14.dirname(profilePath),
-    promptTemplates: readPromptTemplates(path14.dirname(profilePath))
+    dir: path15.dirname(profilePath),
+    promptTemplates: readPromptTemplates(path15.dirname(profilePath))
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -2693,15 +2918,16 @@ function readPromptTemplates(dir) {
   const out = {};
   const read = (p) => {
     try {
-      out[p] = fs15.readFileSync(p, "utf-8");
+      out[p] = fs16.readFileSync(p, "utf-8");
     } catch {
     }
   };
-  read(path14.join(dir, "prompt.md"));
+  read(path15.join(dir, "prompt.md"));
+  read(path15.join(dir, "duty.md"));
   try {
-    const promptsDir = path14.join(dir, "prompts");
-    for (const ent of fs15.readdirSync(promptsDir)) {
-      if (ent.endsWith(".md")) read(path14.join(promptsDir, ent));
+    const promptsDir = path15.join(dir, "prompts");
+    for (const ent of fs16.readdirSync(promptsDir)) {
+      if (ent.endsWith(".md")) read(path15.join(promptsDir, ent));
     }
   } catch {
   }
@@ -2721,6 +2947,11 @@ function requireString(p, r, key) {
   }
   return v;
 }
+function parseStringArray(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const values = raw.map((t) => String(t).trim()).filter(Boolean);
+  return values.length > 0 ? values : void 0;
+}
 function parseInputs(p, raw) {
   if (!Array.isArray(raw)) throw new ProfileError(p, `"inputs" must be an array`);
   const out = [];
@@ -2967,11 +3198,16 @@ var init_profile = __esm({
     VALID_PHASES = /* @__PURE__ */ new Set(["research", "planning", "implementing", "reviewing", "shipped", "failed", "idle"]);
     KNOWN_PROFILE_KEYS = /* @__PURE__ */ new Set([
       "name",
+      "action",
       "executable",
       "staff",
       "every",
       "dutyTools",
+      "tools",
       "mentions",
+      "stage",
+      "readsFrom",
+      "writesTo",
       "describe",
       "role",
       "kind",
@@ -3368,16 +3604,16 @@ var init_state = __esm({
 });
 
 // src/prompt.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path15.join(projectDir, rel);
-    if (!fs16.existsSync(abs)) continue;
+    const abs = path16.join(projectDir, rel);
+    if (!fs17.existsSync(abs)) continue;
     let content;
     try {
-      content = fs16.readFileSync(abs, "utf-8");
+      content = fs17.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -3612,28 +3848,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs17.statSync(file);
+      stat = fs18.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs17.readFileSync(file, "utf-8");
+      raw = fs18.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() ?? path16.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path17.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path16.relative(memoryAbs, file),
+      relPath: path17.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -3701,16 +3937,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs17.readdirSync(dir);
+      names = fs18.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path16.join(dir, name);
+      const full = path17.join(dir, name);
       let stat;
       try {
-        stat = fs17.statSync(full);
+        stat = fs18.statSync(full);
       } catch {
         continue;
       }
@@ -3733,8 +3969,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX2 = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path16.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs17.existsSync(memoryAbs)) {
+      const memoryAbs = path17.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs18.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -3778,11 +4014,11 @@ var init_loadCoverageRules = __esm({
 
 // src/container.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs18.existsSync(profilePath)) return null;
+    if (!fs19.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -4244,9 +4480,9 @@ var init_lifecycleLabels = __esm({
 
 // src/litellm.ts
 import { execFileSync as execFileSync4, spawn as spawn3 } from "child_process";
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as os3 from "os";
-import * as path17 from "path";
+import * as path18 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -4331,13 +4567,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   let child;
   let logPath;
   const spawnProxy = () => {
-    const configPath = path17.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
-    fs19.writeFileSync(configPath, generateLitellmConfigYaml(model));
+    const configPath = path18.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
+    fs20.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
-    const nextLogPath = path17.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
-    const outFd = fs19.openSync(nextLogPath, "w");
+    const nextLogPath = path18.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
+    const outFd = fs20.openSync(nextLogPath, "w");
     child = spawn3(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
-    fs19.closeSync(outFd);
+    fs20.closeSync(outFd);
     logPath = nextLogPath;
   };
   const waitForHealth = async () => {
@@ -4351,7 +4587,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const readLogTail = () => {
     if (!logPath) return "";
     try {
-      return fs19.readFileSync(logPath, "utf-8").slice(-2e3);
+      return fs20.readFileSync(logPath, "utf-8").slice(-2e3);
     } catch {
       return "";
     }
@@ -4403,10 +4639,10 @@ ${tail}`
   return { url, kill: killChild, isHealthy, ensureHealthy };
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path17.join(projectDir, ".env");
-  if (!fs19.existsSync(dotenvPath)) return {};
+  const dotenvPath = path18.join(projectDir, ".env");
+  if (!fs20.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs19.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs20.readFileSync(dotenvPath, "utf-8").split("\n")) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) continue;
     const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
@@ -4521,8 +4757,8 @@ var init_pushWithRetry = __esm({
 
 // src/commit.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 function git(args, cwd) {
   try {
     return execFileSync6("git", args, {
@@ -4560,18 +4796,18 @@ function ensureGitIdentity(cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path18.join(cwd ?? process.cwd(), ".git");
-  if (!fs20.existsSync(gitDir)) return aborted;
-  if (fs20.existsSync(path18.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path19.join(cwd ?? process.cwd(), ".git");
+  if (!fs21.existsSync(gitDir)) return aborted;
+  if (fs21.existsSync(path19.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs20.existsSync(path18.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs21.existsSync(path19.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs20.existsSync(path18.join(gitDir, "REVERT_HEAD"))) {
+  if (fs21.existsSync(path19.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs20.existsSync(path18.join(gitDir, "rebase-merge")) || fs20.existsSync(path18.join(gitDir, "rebase-apply"))) {
+  if (fs21.existsSync(path19.join(gitDir, "rebase-merge")) || fs21.existsSync(path19.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -4627,7 +4863,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs20.existsSync(path18.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs21.existsSync(path19.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -4864,7 +5100,7 @@ var init_advanceFlow = __esm({
 
 // src/gha.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -4875,10 +5111,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs21.existsSync(eventPath)) return;
+  if (!eventPath || !fs22.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs21.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs22.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -5212,11 +5448,11 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs22 from "fs";
-import * as path19 from "path";
+import * as fs23 from "fs";
+import * as path20 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path19.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+  return path20.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
 var DEFAULT_COMMIT_MESSAGE, commitAndPush2;
 var init_commitAndPush = __esm({
@@ -5233,9 +5469,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs22.existsSync(sentinel)) {
+      if (sentinel && fs23.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs22.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs23.readFileSync(sentinel, "utf-8"));
           ctx.data.commitResult = replay.commitResult ?? { committed: false, pushed: false };
           if (Array.isArray(replay.changedFiles)) ctx.data.changedFiles = replay.changedFiles;
           if (typeof replay.hasCommitsAhead === "boolean") ctx.data.hasCommitsAhead = replay.hasCommitsAhead;
@@ -5288,8 +5524,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs22.mkdirSync(path19.dirname(sentinel), { recursive: true });
-          fs22.writeFileSync(
+          fs23.mkdirSync(path20.dirname(sentinel), { recursive: true });
+          fs23.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -5311,8 +5547,8 @@ var init_commitAndPush = __esm({
 });
 
 // src/goal/state.ts
-import * as fs23 from "fs";
-import * as path20 from "path";
+import * as fs24 from "fs";
+import * as path21 from "path";
 function parseGoalState(filePath, raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     throw new GoalStateError(filePath, "must be a JSON object");
@@ -5364,10 +5600,10 @@ var init_state2 = __esm({
     "use strict";
     VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
     GoalStateError = class extends Error {
-      constructor(path42, message) {
-        super(`Invalid goal state at ${path42}:
+      constructor(path43, message) {
+        super(`Invalid goal state at ${path43}:
   ${message}`);
-        this.path = path42;
+        this.path = path43;
         this.name = "GoalStateError";
       }
       path;
@@ -5479,8 +5715,8 @@ var init_commitGoalState = __esm({
 });
 
 // src/scripts/composePrompt.ts
-import * as fs24 from "fs";
-import * as path21 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 function fenceUntrusted(value) {
   if (value.trim().length === 0) return value;
   const safe = value.replace(/-{3,}\s*END UNTRUSTED INPUT\s*-{3,}/gi, "[END UNTRUSTED INPUT]");
@@ -5569,6 +5805,10 @@ function formatDutyReference(data, profileName) {
   if (dutySchedule) {
     lines.push(`- Cadence: \`${dutySchedule}\``);
   }
+  const dutyBody = pickToken(data, "dutyIntent", "jobIntent");
+  if (dutyBody) {
+    lines.push("", "## Duty body", "", dutyBody);
+  }
   if (lines.length === 2) {
     return "";
   }
@@ -5597,9 +5837,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        explicit ? path21.join(profile.dir, explicit) : null,
-        mode ? path21.join(profile.dir, "prompts", `${mode}.md`) : null,
-        path21.join(profile.dir, "prompt.md")
+        explicit ? path22.join(profile.dir, explicit) : null,
+        mode ? path22.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path22.join(profile.dir, "prompt.md"),
+        path22.join(profile.dir, "duty.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -5612,7 +5853,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs24.readFileSync(c, "utf-8");
+          template = fs25.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -5623,7 +5864,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs24.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs25.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -6450,19 +6691,19 @@ var init_deriveQaScopeFromIssue = __esm({
 
 // src/scripts/diagMcp.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as os4 from "os";
-import * as path22 from "path";
+import * as path23 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
       const home = os4.homedir();
-      const cacheDir = path22.join(home, ".cache", "ms-playwright");
+      const cacheDir = path23.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs25.readdirSync(cacheDir);
+        entries = fs26.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -6490,13 +6731,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path24 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   try {
-    const pkg = JSON.parse(fs26.readFileSync(path23.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs27.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -6533,25 +6774,25 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs26.existsSync(path23.join(cwd, c))) return c;
+    if (fs27.existsSync(path24.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path23.join(cwd, dir);
-    if (!fs26.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs27.existsSync(full)) continue;
     let files;
     try {
-      files = fs26.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs27.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path23.join(full, file);
-        const content = fs26.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path24.join(full, file);
+        const content = fs27.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -6565,7 +6806,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path23.relative(cwd, filePath),
+          filePath: path24.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -6578,28 +6819,28 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path23.join(cwd, dir);
-    if (!fs26.existsSync(full)) continue;
+    const full = path24.join(cwd, dir);
+    if (!fs27.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs26.readdirSync(full, { withFileTypes: true });
+      entries = fs27.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path23.join(full, entry.name);
+      const entryPath = path24.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs26.existsSync(path23.join(entryPath, f))
+          (f) => fs27.existsSync(path24.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path23.relative(cwd, path23.join(entryPath, indexFile));
+        filePath = path24.relative(cwd, path24.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path23.relative(cwd, entryPath);
+        filePath = path24.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -6607,7 +6848,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs26.readFileSync(path23.join(cwd, col.filePath), "utf-8");
+            const colContent = fs27.readFileSync(path24.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -6625,8 +6866,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path23.join(cwd, appDir, "api");
-    if (!fs26.existsSync(apiDir)) continue;
+    const apiDir = path24.join(cwd, appDir, "api");
+    if (!fs27.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -6635,14 +6876,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs26.readdirSync(dir, { withFileTypes: true });
+    entries = fs27.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   const routeFile = entries.find((e) => e.isFile() && /^route\.(ts|js|tsx|jsx)$/.test(e.name));
   if (routeFile) {
     try {
-      const content = fs26.readFileSync(path23.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs27.readFileSync(path24.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
       const methods = HTTP_METHODS.filter(
         (m) => new RegExp(`export\\s+(?:async\\s+)?function\\s+${m}\\b`).test(content)
       );
@@ -6650,7 +6891,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path23.relative(cwd, path23.join(dir, routeFile.name))
+          filePath: path24.relative(cwd, path24.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -6661,7 +6902,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkApiRoutes(path23.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path24.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6669,16 +6910,16 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path23.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
   }
 }
 function scanEnvVars(cwd) {
   const candidates = [".env.example", ".env.local.example", ".env.template"];
   for (const envFile of candidates) {
-    const envPath = path23.join(cwd, envFile);
-    if (!fs26.existsSync(envPath)) continue;
+    const envPath = path24.join(cwd, envFile);
+    if (!fs27.existsSync(envPath)) continue;
     try {
-      const content = fs26.readFileSync(envPath, "utf-8");
+      const content = fs27.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -6723,8 +6964,8 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs27 from "fs";
-import * as path24 from "path";
+import * as fs28 from "fs";
+import * as path25 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -6755,9 +6996,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs27.readFileSync(path24.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs28.readFileSync(path25.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const pm = fs27.existsSync(path24.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs27.existsSync(path24.join(cwd, "yarn.lock")) ? "yarn" : fs27.existsSync(path24.join(cwd, "bun.lockb")) ? "bun" : "npm";
+    const pm = fs28.existsSync(path25.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs28.existsSync(path25.join(cwd, "yarn.lock")) ? "yarn" : fs28.existsSync(path25.join(cwd, "bun.lockb")) ? "bun" : "npm";
     if (pkg.scripts?.dev) out.devCommand = `${pm} dev`;
     if (allDeps.next || allDeps.nuxt) out.devPort = 3e3;
     else if (allDeps.vite) out.devPort = 5173;
@@ -6767,8 +7008,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path24.join(cwd, appDir);
-    if (!fs27.existsSync(full)) continue;
+    const full = path25.join(cwd, appDir);
+    if (!fs28.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -6776,7 +7017,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs27.readdirSync(dir, { withFileTypes: true });
+    entries = fs28.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -6793,7 +7034,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      walkFrontendRoutes(path24.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path25.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6801,7 +7042,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path25.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -6818,23 +7059,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs27.existsSync(path24.join(cwd, c))) out.authFiles.push(c);
+    if (fs28.existsSync(path25.join(cwd, c))) out.authFiles.push(c);
   }
 }
 function detectRoles(cwd, out) {
   const rolePaths = ["src/types", "src/lib", "src/utils", "src/constants", "src/access", "src/collections"];
   for (const rp of rolePaths) {
-    const dir = path24.join(cwd, rp);
-    if (!fs27.existsSync(dir)) continue;
+    const dir = path25.join(cwd, rp);
+    if (!fs28.existsSync(dir)) continue;
     let files;
     try {
-      files = fs27.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs28.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs27.readFileSync(path24.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs28.readFileSync(path25.join(dir, f), "utf-8").slice(0, 5e3);
         const roleMatches = content.match(/(?:role|Role|ROLE)\s*[=:]\s*['"](\w+)['"]/g);
         if (roleMatches) {
           for (const m of roleMatches) {
@@ -7041,10 +7282,12 @@ ${stateBody}`;
 
 // src/jobIdentity.ts
 function stableJobKey(job) {
-  const executable = job.executable ?? job.duty ?? "unknown";
+  const duty = job.duty ?? job.action;
+  const executable = job.executable ?? duty ?? "unknown";
   if (job.flavor === "scheduled" && job.duty) return `scheduled:${job.duty}:${executable}`;
   const target = typeof job.target === "number" ? job.target : targetFromCliArgs(job.cliArgs);
-  return target === void 0 ? `${job.flavor}:${executable}` : `${job.flavor}:${executable}:${target}`;
+  const work = duty ?? executable;
+  return target === void 0 ? `${job.flavor}:${work}` : `${job.flavor}:${work}:${target}`;
 }
 function targetFromCliArgs(cliArgs) {
   if (!cliArgs) return void 0;
@@ -7083,8 +7326,8 @@ function validateJob(input) {
     throw new InvalidJobError("job must be an object");
   }
   const j = input;
-  if (typeof j.executable !== "string" && typeof j.duty !== "string") {
-    throw new InvalidJobError("job must reference an executable or a duty");
+  if (typeof j.executable !== "string" && typeof j.duty !== "string" && typeof j.action !== "string") {
+    throw new InvalidJobError("job must reference a duty action, duty, or executable");
   }
   if (j.flavor !== "instant" && j.flavor !== "scheduled") {
     throw new InvalidJobError(`job.flavor must be "instant" or "scheduled" (got ${String(j.flavor)})`);
@@ -7093,6 +7336,7 @@ function validateJob(input) {
     throw new InvalidJobError("job.cliArgs must be an object when present");
   }
   return {
+    action: typeof j.action === "string" ? j.action : void 0,
     executable: typeof j.executable === "string" ? j.executable : void 0,
     duty: typeof j.duty === "string" ? j.duty : void 0,
     why: typeof j.why === "string" ? j.why : void 0,
@@ -7106,7 +7350,9 @@ function validateJob(input) {
 }
 async function runJob(job, base) {
   const valid = validateJob(job);
-  const profileName = valid.executable ?? valid.duty;
+  const action = valid.action ?? valid.duty;
+  const resolvedDuty = action ? resolveDutyAction(action) : null;
+  const profileName = valid.executable ?? resolvedDuty?.executable ?? valid.duty;
   if (!profileName) {
     throw new InvalidJobError("job resolves to no executable or duty");
   }
@@ -7115,25 +7361,54 @@ async function runJob(job, base) {
   preloadedData.jobKey = stableJobKey(valid);
   preloadedData.jobFlavor = valid.flavor;
   if (valid.target !== void 0) preloadedData.jobTarget = valid.target;
-  if (valid.duty !== void 0 && valid.duty.length > 0) preloadedData.jobDuty = valid.duty;
-  if (valid.executable !== void 0 && valid.executable.length > 0) preloadedData.jobExecutable = valid.executable;
+  if (valid.action !== void 0 && valid.action.length > 0) preloadedData.jobAction = valid.action;
+  const dutyIdentity = valid.duty ?? resolvedDuty?.duty;
+  if (dutyIdentity !== void 0 && dutyIdentity.length > 0) preloadedData.jobDuty = dutyIdentity;
+  const executableIdentity = valid.executable ?? resolvedDuty?.executable;
+  if (executableIdentity !== void 0 && executableIdentity.length > 0)
+    preloadedData.jobExecutable = executableIdentity;
   if (valid.schedule !== void 0 && valid.schedule.length > 0) preloadedData.jobSchedule = valid.schedule;
+  const dutyContext = loadDutyContext(dutyIdentity ?? valid.duty);
+  if (dutyContext) {
+    preloadedData.dutySlug = dutyContext.slug;
+    preloadedData.dutyTitle = dutyContext.title;
+    preloadedData.dutyIntent = dutyContext.body;
+    preloadedData.jobIntent = dutyContext.body;
+    if (preloadedData.jobDuty === void 0) preloadedData.jobDuty = dutyContext.slug;
+    if (dutyContext.config.staff && preloadedData.jobPersona === void 0) {
+      preloadedData.jobPersona = dutyContext.config.staff;
+    }
+    if (dutyContext.config.every && preloadedData.jobSchedule === void 0) {
+      preloadedData.jobSchedule = dutyContext.config.every;
+    }
+    if (dutyContext.config.mentions && dutyContext.config.mentions.length > 0) {
+      preloadedData.mentions = dutyContext.config.mentions.map((login) => `@${login}`).join(" ");
+    }
+  }
   if (valid.why !== void 0 && valid.why.length > 0) preloadedData.jobWhy = valid.why;
   if (valid.persona !== void 0) preloadedData.jobPersona = valid.persona;
   const input = {
     cliArgs: { ...valid.cliArgs },
     cwd: base.cwd,
     config: base.config,
+    skipConfig: base.skipConfig,
     verbose: base.verbose,
     quiet: base.quiet,
     preloadedData: Object.keys(preloadedData).length > 0 ? preloadedData : void 0
   };
+  input.cliArgs = resolvedDuty ? { ...resolvedDuty.cliArgs, ...input.cliArgs } : input.cliArgs;
   const run = base.chain === false ? runExecutable : runExecutableChain;
   return run(profileName, input);
 }
+function loadDutyContext(slug) {
+  if (!slug) return null;
+  return readDutyFolder(getProjectDutiesRoot(), slug) ?? readDutyFolder(getBuiltinDutiesRoot(), slug);
+}
 function mintInstantJob(dispatch2, opts) {
   return {
+    action: dispatch2.action,
     executable: dispatch2.executable,
+    duty: dispatch2.duty,
     why: opts?.why ?? dispatch2.why,
     persona: opts?.persona ?? DEFAULT_INSTANT_PERSONA,
     target: dispatch2.target,
@@ -7156,6 +7431,8 @@ var init_job = __esm({
   "src/job.ts"() {
     "use strict";
     init_executor();
+    init_dutyFolders();
+    init_registry();
     init_jobIdentity();
     init_jobIdentity();
     DEFAULT_INSTANT_PERSONA = "kody";
@@ -7169,106 +7446,6 @@ var init_job = __esm({
   }
 });
 
-// src/scripts/jobFrontmatter.ts
-function splitFrontmatter2(raw) {
-  const match = FRONTMATTER_RE.exec(raw);
-  if (!match) return { frontmatter: {}, body: raw };
-  const inner = match[1] ?? "";
-  const body = raw.slice(match[0].length);
-  return { frontmatter: parseFlatYaml(inner), body };
-}
-function isScheduleEvery(value) {
-  return typeof value === "string" && SCHEDULE_EVERY_VALUES.includes(value);
-}
-function scheduleEveryToMs(every) {
-  const MIN = 60 * 1e3;
-  const HOUR = 60 * MIN;
-  const DAY = 24 * HOUR;
-  switch (every) {
-    case "15m":
-      return 15 * MIN;
-    case "30m":
-      return 30 * MIN;
-    case "1h":
-      return HOUR;
-    case "2h":
-      return 2 * HOUR;
-    case "6h":
-      return 6 * HOUR;
-    case "12h":
-      return 12 * HOUR;
-    case "1d":
-      return DAY;
-    case "3d":
-      return 3 * DAY;
-    case "7d":
-      return 7 * DAY;
-    case "manual":
-      return Number.POSITIVE_INFINITY;
-  }
-}
-function parseFlatYaml(text) {
-  const out = {};
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const colon = line.indexOf(":");
-    if (colon < 0) continue;
-    const key = line.slice(0, colon).trim();
-    const value = stripQuotes(line.slice(colon + 1).trim());
-    if (key === "every" && isScheduleEvery(value)) {
-      out.every = value;
-    } else if (key === "tickScript" && value.length > 0) {
-      out.tickScript = value;
-    } else if (key === "disabled") {
-      const lower = value.toLowerCase();
-      if (lower === "true") out.disabled = true;
-      else if (lower === "false") out.disabled = false;
-    } else if (key === "staff" && value.length > 0) {
-      out.staff = value;
-    } else if (key === "mentions") {
-      const logins = value.split(",").map((s) => s.trim().replace(/^@/, "")).filter(Boolean);
-      if (logins.length > 0) out.mentions = logins;
-    } else if (key === "tools") {
-      const names = value.split(",").map((s) => s.trim()).filter(Boolean);
-      if (names.length > 0) out.tools = names;
-    } else if (key === "executables") {
-      const names = value.split(",").map((s) => s.trim()).filter(Boolean);
-      if (names.length > 0) out.executables = names;
-    }
-  }
-  return out;
-}
-function stripQuotes(value) {
-  if (value.length >= 2) {
-    const first = value[0];
-    const last = value[value.length - 1];
-    if (first === '"' && last === '"' || first === "'" && last === "'") {
-      return value.slice(1, -1);
-    }
-  }
-  return value;
-}
-var SCHEDULE_EVERY_VALUES, FRONTMATTER_RE;
-var init_jobFrontmatter = __esm({
-  "src/scripts/jobFrontmatter.ts"() {
-    "use strict";
-    SCHEDULE_EVERY_VALUES = [
-      "15m",
-      "30m",
-      "1h",
-      "2h",
-      "6h",
-      "12h",
-      "1d",
-      "3d",
-      "7d",
-      "manual"
-    ];
-    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-  }
-});
-
 // src/scripts/issueStateComment.ts
 function isStateEnvelope(x) {
   if (x === null || typeof x !== "object") return false;
@@ -7486,8 +7663,8 @@ var init_contentsApiBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs28 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -7543,7 +7720,7 @@ var init_localFileBackend = __esm({
         if (!opts.owner || !opts.repo) throw new Error("LocalFileBackend: owner and repo are required");
         this.cwd = opts.cwd;
         this.jobsDir = opts.jobsDir;
-        this.absDir = path25.join(opts.cwd, opts.jobsDir);
+        this.absDir = path26.join(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -7558,7 +7735,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs28.mkdirSync(this.absDir, { recursive: true });
+        fs29.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -7587,7 +7764,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs28.existsSync(this.absDir)) {
+        if (!fs29.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -7603,11 +7780,11 @@ var init_localFileBackend = __esm({
       }
       load(slug) {
         const relPath = stateFilePath(this.jobsDir, slug);
-        const absPath = path25.join(this.cwd, relPath);
-        if (!fs28.existsSync(absPath)) {
+        const absPath = path26.join(this.cwd, relPath);
+        if (!fs29.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs28.readFileSync(absPath, "utf-8");
+        const raw = fs29.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -7624,13 +7801,13 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path25.join(this.cwd, loaded.path);
-        fs28.mkdirSync(path25.dirname(absPath), { recursive: true });
+        const absPath = path26.join(this.cwd, loaded.path);
+        fs29.mkdirSync(path26.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs28.writeFileSync(tmpPath, body, "utf-8");
-        fs28.renameSync(tmpPath, absPath);
+        fs29.writeFileSync(tmpPath, body, "utf-8");
+        fs29.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -7782,8 +7959,7 @@ var init_planTaskJobs = __esm({
 });
 
 // src/scripts/dispatchDutyFileTicks.ts
-import * as fs29 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 async function decideShouldFire(every, slug, backend, now) {
   if (!every) return { skip: false, reason: "no schedule (every cron tick)" };
   if (every === "manual") {
@@ -7824,14 +8000,6 @@ function formatAgo(ms) {
   const day = Math.round(hr / 24);
   return `${day}d`;
 }
-function readJobFile(cwd, jobsDir, slug) {
-  try {
-    const raw = fs29.readFileSync(path26.join(cwd, jobsDir, `${slug}.md`), "utf-8");
-    return splitFrontmatter2(raw);
-  } catch {
-    return { frontmatter: {}, body: "" };
-  }
-}
 function parseDutyFilter(raw) {
   return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
 }
@@ -7840,21 +8008,21 @@ function filterSlugs(slugs, onlyDuty) {
 }
 function createDutyTaskIssue(opts) {
   const title = `Duty ${opts.slug} - multi-executable task`;
-  const body = buildDutyTaskIssueBody(opts.slug, opts.body, opts.frontmatter);
+  const body = buildDutyTaskIssueBody(opts.slug, opts.body, opts.config);
   const out = gh(["issue", "create", "--title", title, "--body-file", "-"], { input: body, cwd: opts.cwd });
   const url = out.split("\n").map((line) => line.trim()).filter(Boolean).pop() ?? "";
   const match = url.match(/\/issues\/(\d+)\b/);
   if (!match) throw new Error(`gh issue create returned unexpected output: ${out}`);
   return { number: Number(match[1]), url };
 }
-function buildDutyTaskIssueBody(slug, dutyBody, frontmatter) {
-  const specs = (frontmatter.executables ?? []).map((executable) => ({
+function buildDutyTaskIssueBody(slug, dutyBody, config) {
+  const specs = (config.executables ?? []).map((executable) => ({
     executable,
     duty: slug,
-    ...frontmatter.staff ? { staff: frontmatter.staff } : {},
+    ...config.staff ? { staff: config.staff } : {},
     reason: `Duty \`${slug}\` slice for \`${executable}\`.`,
     flavor: "scheduled",
-    ...frontmatter.every ? { schedule: frontmatter.every } : {}
+    ...config.every ? { schedule: config.every } : {}
   }));
   return [
     `# Duty task: ${slug}`,
@@ -7867,26 +8035,6 @@ function buildDutyTaskIssueBody(slug, dutyBody, frontmatter) {
     ""
   ].join("\n");
 }
-function listJobSlugs(absDir) {
-  if (!fs29.existsSync(absDir)) return [];
-  let entries;
-  try {
-    entries = fs29.readdirSync(absDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  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();
-}
-function listFolderDutySlugs(absDir) {
-  if (!fs29.existsSync(absDir)) return [];
-  let entries;
-  try {
-    entries = fs29.readdirSync(absDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => fs29.existsSync(path26.join(absDir, e.name, "profile.json"))).map((e) => e.name).sort();
-}
 async function stampFired(backend, slug, now, task) {
   try {
     const loaded = await backend.load(slug);
@@ -7905,10 +8053,10 @@ var dispatchDutyFileTicks;
 var init_dispatchDutyFileTicks = __esm({
   "src/scripts/dispatchDutyFileTicks.ts"() {
     "use strict";
+    init_dutyFolders();
     init_issue();
     init_job();
-    init_profile();
-    init_jobFrontmatter();
+    init_scheduleEvery();
     init_jobState();
     init_planTaskJobs();
     dispatchDutyFileTicks = async (ctx, _profile, args) => {
@@ -7926,107 +8074,54 @@ var init_dispatchDutyFileTicks = __esm({
       }
       try {
         const onlyDuty = parseDutyFilter(ctx.args.duty);
-        const jobsPath = path26.join(ctx.cwd, jobsDir);
-        const slugs = filterSlugs(listJobSlugs(jobsPath), onlyDuty);
-        const folderSlugList = filterSlugs(listFolderDutySlugs(jobsPath), onlyDuty);
-        ctx.data.jobSlugCount = slugs.length + folderSlugList.length;
-        if (slugs.length === 0 && folderSlugList.length === 0) {
+        const jobsPath = path27.join(ctx.cwd, jobsDir);
+        const slugs = filterSlugs(listDutyFolderSlugs(jobsPath), onlyDuty);
+        ctx.data.jobSlugCount = slugs.length;
+        if (slugs.length === 0) {
           const filter = onlyDuty ? ` matching ${onlyDuty}` : "";
-          process.stdout.write(`[jobs] no job files${filter} in ${jobsDir}
+          process.stdout.write(`[jobs] no duty folders${filter} in ${jobsDir}
 `);
           return;
         }
         const filtered = onlyDuty ? ` matching ${onlyDuty}` : "";
-        process.stdout.write(
-          `[jobs] ticking ${slugs.length + folderSlugList.length} job(s)${filtered} via ${targetExecutable}
-`
-        );
+        process.stdout.write(`[jobs] ticking ${slugs.length} dut(y/ies)${filtered} via ${targetExecutable}
+`);
         const results = [];
         const now = Date.now();
-        const folderDutySlugs = new Set(folderSlugList);
-        const scheduledDuties = folderSlugList.map((slug) => {
-          try {
-            const p = loadProfile(path26.join(ctx.cwd, jobsDir, slug, "profile.json"));
-            return { slug, every: p.every, staff: p.staff };
-          } catch (err) {
-            process.stderr.write(`[jobs] \u23ED  skip folder-duty ${slug}: profile load failed: ${String(err)}
-`);
-            return null;
-          }
-        }).filter((d) => d !== null && Boolean(d.every));
-        process.stdout.write(`[jobs] ${scheduledDuties.length} scheduled folder-dut(y/ies) to consider
-`);
-        for (const { slug, every, staff } of scheduledDuties) {
-          if (!staff || staff.trim().length === 0) {
-            process.stderr.write(`[jobs] \u23ED  skip ${slug}: scheduled duty has no staff
-`);
-            results.push({ slug, exitCode: 0, skipped: true, reason: "no staff assigned" });
-            continue;
-          }
-          const decision = await decideShouldFire(every, slug, backend, now);
-          if (decision.skip) {
-            process.stdout.write(`[jobs] \u23ED  skip ${slug}: ${decision.reason}
-`);
-            results.push({ slug, exitCode: 0, skipped: true, reason: decision.reason });
-            continue;
-          }
-          await stampFired(backend, slug, now);
-          process.stdout.write(`[jobs] \u2192 run scheduled duty ${slug} (one-shot, as ${staff})
-`);
-          try {
-            const out = await runJob(mintScheduledJob({ duty: slug, executable: slug, schedule: every }), {
-              cwd: ctx.cwd,
-              config: ctx.config,
-              verbose: ctx.verbose,
-              quiet: ctx.quiet,
-              chain: false
-            });
-            results.push({ slug, exitCode: out.exitCode, reason: out.reason });
-            if (out.exitCode !== 0) {
-              process.stderr.write(`[jobs] scheduled duty ${slug} failed (exit ${out.exitCode}): ${out.reason ?? ""}
-`);
-            }
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`[jobs] scheduled duty ${slug} crashed: ${msg}
-`);
-            results.push({ slug, exitCode: 99, reason: msg });
-          }
-        }
         for (const slug of slugs) {
-          if (folderDutySlugs.has(slug)) {
-            process.stdout.write(`[jobs] \u23ED  skip ${slug}: handled as folder-duty (folder wins over .md)
+          const duty = readDutyFolder(jobsPath, slug);
+          if (!duty) {
+            process.stderr.write(`[jobs] \u23ED  skip ${slug}: duty folder is missing profile.json or duty.md
 `);
-            results.push({ slug, exitCode: 0, skipped: true, reason: "handled as folder-duty" });
+            results.push({ slug, exitCode: 0, skipped: true, reason: "incomplete duty folder" });
             continue;
           }
-          const dutyFile = readJobFile(ctx.cwd, jobsDir, slug);
-          const frontmatter = dutyFile.frontmatter;
-          if (frontmatter.disabled === true) {
-            process.stdout.write(`[jobs] \u23ED  skip ${slug}: disabled in frontmatter
+          const config = duty.config;
+          if (config.disabled === true) {
+            process.stdout.write(`[jobs] \u23ED  skip ${slug}: disabled in profile.json
 `);
             results.push({ slug, exitCode: 0, skipped: true, reason: "disabled" });
             continue;
           }
-          if (!frontmatter.staff || frontmatter.staff.trim().length === 0) {
-            process.stderr.write(`[jobs] \u23ED  skip ${slug}: no staff assigned (add 'staff: <slug>' frontmatter)
+          if (!config.staff || config.staff.trim().length === 0) {
+            process.stderr.write(`[jobs] \u23ED  skip ${slug}: no staff assigned (add "staff" to profile.json)
 `);
             results.push({ slug, exitCode: 0, skipped: true, reason: "no staff assigned" });
             continue;
           }
-          const decision = await decideShouldFire(frontmatter.every, slug, backend, now);
+          const decision = await decideShouldFire(config.every, slug, backend, now);
           if (decision.skip) {
             process.stdout.write(`[jobs] \u23ED  skip ${slug}: ${decision.reason}
 `);
             results.push({ slug, exitCode: 0, skipped: true, reason: decision.reason });
             continue;
           }
-          if (frontmatter.executables && frontmatter.executables.length > 0) {
+          if (config.executables && config.executables.length > 0) {
             try {
               const task = createDutyTaskIssue({
                 slug,
-                body: dutyFile.body,
-                frontmatter,
+                body: duty.body,
+                config,
                 cwd: ctx.cwd
               });
               await stampFired(backend, slug, now, task);
@@ -8036,8 +8131,8 @@ var init_dispatchDutyFileTicks = __esm({
                 mintScheduledJob({
                   duty: slug,
                   executable: "task-jobs",
-                  schedule: frontmatter.every,
-                  persona: frontmatter.staff,
+                  schedule: config.every,
+                  persona: config.staff,
                   cliArgs: { issue: task.number }
                 }),
                 { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet }
@@ -8055,7 +8150,8 @@ var init_dispatchDutyFileTicks = __esm({
             }
             continue;
           }
-          const slugTarget = frontmatter.tickScript ? scriptedExecutable : targetExecutable;
+          const slugTarget = config.tickScript ? scriptedExecutable : config.executable ?? targetExecutable;
+          const cliArgs = config.executable ? {} : { [slugArg]: slug };
           process.stdout.write(`[jobs] \u2192 tick ${slug} (${slugTarget})
 `);
           try {
@@ -8063,8 +8159,9 @@ var init_dispatchDutyFileTicks = __esm({
               mintScheduledJob({
                 duty: slug,
                 executable: slugTarget,
-                schedule: frontmatter.every,
-                cliArgs: { [slugArg]: slug }
+                schedule: config.every,
+                persona: config.staff,
+                cliArgs
               }),
               { cwd: ctx.cwd, config: ctx.config, verbose: ctx.verbose, quiet: ctx.quiet, chain: false }
             );
@@ -9307,11 +9404,11 @@ var init_handleAbandonedGoal = __esm({
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync16 } from "child_process";
 import * as fs30 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 function detectPackageManager(cwd) {
-  if (fs30.existsSync(path27.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs30.existsSync(path27.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs30.existsSync(path27.join(cwd, "bun.lockb"))) return "bun";
+  if (fs30.existsSync(path28.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs30.existsSync(path28.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs30.existsSync(path28.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -9383,7 +9480,7 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path27.join(cwd, "kody.config.json");
+  const configPath = path28.join(cwd, "kody.config.json");
   if (fs30.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
@@ -9392,8 +9489,8 @@ function performInit(cwd, force) {
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path27.join(cwd, ".github", "workflows");
-  const workflowPath = path27.join(workflowDir, "kody.yml");
+  const workflowDir = path28.join(cwd, ".github", "workflows");
+  const workflowPath = path28.join(workflowDir, "kody.yml");
   if (fs30.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
@@ -9403,37 +9500,26 @@ function performInit(cwd, force) {
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path27.join(cwd, ".kody", "duties");
+    const jobsDir = path28.join(cwd, ".kody", "duties");
     fs30.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      if (job.filePath && !job.profilePath) {
-        const rel = path27.join(".kody", "duties", `${job.slug}.md`);
-        const target = path27.join(cwd, rel);
-        if (fs30.existsSync(target) && !force) {
-          skipped.push(rel);
-          continue;
-        }
-        fs30.writeFileSync(target, fs30.readFileSync(job.filePath, "utf-8"));
-        wrote.push(rel);
-        continue;
-      }
-      const targetDir = path27.join(jobsDir, job.slug);
-      const relProfile = path27.join(".kody", "duties", job.slug, "profile.json");
-      const relPrompt = path27.join(".kody", "duties", job.slug, "prompt.md");
-      if (fs30.existsSync(targetDir) && fs30.existsSync(path27.join(targetDir, "profile.json")) && !force) {
+      const targetDir = path28.join(jobsDir, job.slug);
+      const relProfile = path28.join(".kody", "duties", job.slug, "profile.json");
+      const relBody = path28.join(".kody", "duties", job.slug, "duty.md");
+      if (fs30.existsSync(targetDir) && fs30.existsSync(path28.join(targetDir, "profile.json")) && !force) {
         skipped.push(relProfile);
-        skipped.push(relPrompt);
+        skipped.push(relBody);
         continue;
       }
       fs30.mkdirSync(targetDir, { recursive: true });
-      fs30.writeFileSync(path27.join(targetDir, "profile.json"), fs30.readFileSync(job.profilePath, "utf-8"));
-      fs30.writeFileSync(path27.join(targetDir, "prompt.md"), fs30.readFileSync(job.promptPath, "utf-8"));
+      fs30.writeFileSync(path28.join(targetDir, "profile.json"), fs30.readFileSync(job.profilePath, "utf-8"));
+      fs30.writeFileSync(path28.join(targetDir, "duty.md"), fs30.readFileSync(job.bodyPath, "utf-8"));
       wrote.push(relProfile);
-      wrote.push(relPrompt);
+      wrote.push(relBody);
     }
   }
-  const staffDir = path27.join(cwd, ".kody", "staff");
-  const staffPath = path27.join(staffDir, "kody.md");
+  const staffDir = path28.join(cwd, ".kody", "staff");
+  const staffPath = path28.join(staffDir, "kody.md");
   if (fs30.existsSync(staffPath) && !force) {
     skipped.push(".kody/staff/kody.md");
   } else {
@@ -9449,7 +9535,7 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path27.join(workflowDir, `kody-${exe.name}.yml`);
+    const target = path28.join(workflowDir, `kody-${exe.name}.yml`);
     if (fs30.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
@@ -9775,7 +9861,7 @@ var init_loadIssueStateComment = __esm({
 
 // src/scripts/loadJobFromFile.ts
 import * as fs31 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -9791,17 +9877,17 @@ function parseJobFile(raw, slug) {
     const rest = trimmed.slice(firstLine2.length).replace(/^\n+/, "");
     return { title: h1[1].trim(), body: rest };
   }
-  return { title: humanizeSlug(slug), body: trimmed };
+  return { title: humanizeSlug2(slug), body: trimmed };
 }
-function humanizeSlug(slug) {
+function humanizeSlug2(slug) {
   return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
 }
 var DUTY_TOOL_PALETTE2, loadJobFromFile;
 var init_loadJobFromFile = __esm({
   "src/scripts/loadJobFromFile.ts"() {
     "use strict";
+    init_dutyFolders();
     init_dutyMcp();
-    init_jobFrontmatter();
     init_jobState();
     DUTY_TOOL_PALETTE2 = new Set(DUTY_MCP_TOOL_NAMES);
     loadJobFromFile = async (ctx, profile, args) => {
@@ -9812,19 +9898,17 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const absPath = path28.join(ctx.cwd, jobsDir, `${slug}.md`);
-      if (!fs31.existsSync(absPath)) {
-        throw new Error(`loadJobFromFile: job file not found: ${absPath}`);
+      const duty = readDutyFolder(path29.join(ctx.cwd, jobsDir), slug);
+      if (!duty) {
+        throw new Error(`loadJobFromFile: duty folder not found or incomplete: ${path29.join(ctx.cwd, jobsDir, slug)}`);
       }
-      const raw = fs31.readFileSync(absPath, "utf-8");
-      const { title, body } = parseJobFile(raw, slug);
-      const frontmatter = splitFrontmatter2(raw).frontmatter;
-      const mentions = (frontmatter.mentions ?? []).map((login) => `@${login}`).join(" ");
-      const workerSlug = (frontmatter.staff ?? "").trim();
+      const { title, body, config } = duty;
+      const mentions = (config.mentions ?? []).map((login) => `@${login}`).join(" ");
+      const workerSlug = (config.staff ?? "").trim();
       let workerTitle = "";
       let workerPersona = "";
       if (workerSlug) {
-        const workerPath = path28.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+        const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
         if (!fs31.existsSync(workerPath)) {
           throw new Error(`loadJobFromFile: duty '${slug}' declares staff '${workerSlug}' but ${workerPath} does not exist`);
         }
@@ -9849,8 +9933,8 @@ var init_loadJobFromFile = __esm({
       ctx.data.staffSlug = workerSlug;
       ctx.data.staffTitle = workerTitle;
       ctx.data.executableSlug = profile.name;
-      ctx.data.dutySchedule = "";
-      const declaredTools = frontmatter.tools ?? [];
+      ctx.data.dutySchedule = config.every ?? "";
+      const declaredTools = config.tools ?? [];
       if (declaredTools.length > 0) {
         const unknown = declaredTools.filter((name) => !DUTY_TOOL_PALETTE2.has(name));
         if (unknown.length > 0) {
@@ -9903,9 +9987,9 @@ ${truncate2(issue.body, FINDING_BODY_MAX_BYTES)}`;
 
 // src/scripts/kodyVariables.ts
 import * as fs32 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 function readKodyVariables(cwd) {
-  const full = path29.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path30.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
     raw = fs32.readFileSync(full, "utf-8");
@@ -9934,7 +10018,7 @@ var init_kodyVariables = __esm({
 
 // src/scripts/loadQaContext.ts
 import * as fs33 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -9942,7 +10026,7 @@ function parseSlugList(value) {
   ).filter(Boolean);
 }
 function readProfileStaff(raw) {
-  const m = FRONTMATTER_RE2.exec(raw);
+  const m = FRONTMATTER_RE.exec(raw);
   if (!m) return { staff: ["kody"], body: raw };
   const body = raw.slice(m[0].length);
   let staff = null;
@@ -9963,7 +10047,7 @@ function readProfileStaff(raw) {
   return { staff: staff ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path30.join(cwd, CONTEXT_DIR_REL_PATH);
+  const dir = path31.join(cwd, CONTEXT_DIR_REL_PATH);
   if (!fs33.existsSync(dir)) return "";
   let entries;
   try {
@@ -9974,7 +10058,7 @@ function readProfile(cwd) {
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs33.readFileSync(path30.join(dir, file), "utf-8");
+      const raw = fs33.readFileSync(path31.join(dir, file), "utf-8");
       const { staff, body } = readProfileStaff(raw);
       if (!staff.includes(QA_STAFF) && !staff.includes(ALL_STAFF)) continue;
       blocks.push(`## ${file}
@@ -9997,7 +10081,7 @@ function composeAuthBlock(authProfile, login, password) {
   }
   return "Auth: no QA credentials configured (set the `LOGIN_USER` variable and the `LOGIN_PASSWORD` vault secret). Browse public routes only; note auth-gated surfaces as gaps.";
 }
-var CONTEXT_DIR_REL_PATH, QA_STAFF, ALL_STAFF, LEGACY_AUDIENCE_TO_STAFF, FRONTMATTER_RE2, loadQaContext;
+var CONTEXT_DIR_REL_PATH, QA_STAFF, ALL_STAFF, LEGACY_AUDIENCE_TO_STAFF, FRONTMATTER_RE, loadQaContext;
 var init_loadQaContext = __esm({
   "src/scripts/loadQaContext.ts"() {
     "use strict";
@@ -10006,7 +10090,7 @@ var init_loadQaContext = __esm({
     QA_STAFF = "qa-engineer";
     ALL_STAFF = "*";
     LEGACY_AUDIENCE_TO_STAFF = { chat: "kody", qa: QA_STAFF };
-    FRONTMATTER_RE2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
     loadQaContext = async (ctx) => {
       const vars = readKodyVariables(ctx.cwd);
       const login = vars.LOGIN_USER ?? "";
@@ -10021,7 +10105,7 @@ var init_loadQaContext = __esm({
 
 // src/taskContext.ts
 import * as fs34 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -10036,9 +10120,9 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path31.join(cwd, ".kody", "runs", ctx.runId);
+    const dir = path32.join(cwd, ".kody", "runs", ctx.runId);
     fs34.mkdirSync(dir, { recursive: true });
-    const file = path31.join(dir, "task-context.json");
+    const file = path32.join(dir, "task-context.json");
     fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
@@ -10128,7 +10212,7 @@ var init_loadTaskState = __esm({
 
 // src/scripts/loadWorkerAdhoc.ts
 import * as fs35 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -10162,7 +10246,7 @@ function stripDirective(body) {
   return lines.slice(start).join("\n").trim();
 }
 function parsePersona(raw, slug) {
-  const stripped = splitFrontmatter2(raw).body;
+  const stripped = stripLeadingFrontmatter(raw);
   const trimmed = stripped.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
   const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
@@ -10170,23 +10254,26 @@ function parsePersona(raw, slug) {
     const rest = trimmed.slice(firstLine2.length).replace(/^\n+/, "");
     return { title: h1[1].trim(), body: rest };
   }
-  return { title: humanizeSlug2(slug), body: trimmed };
+  return { title: humanizeSlug3(slug), body: trimmed };
 }
-function humanizeSlug2(slug) {
+function stripLeadingFrontmatter(raw) {
+  const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(raw);
+  return match ? raw.slice(match[0].length) : raw;
+}
+function humanizeSlug3(slug) {
   return slug.split(/[-_]+/).filter((s) => s.length > 0).map((s) => s[0].toUpperCase() + s.slice(1)).join(" ");
 }
 var loadWorkerAdhoc;
 var init_loadWorkerAdhoc = __esm({
   "src/scripts/loadWorkerAdhoc.ts"() {
     "use strict";
-    init_jobFrontmatter();
     loadWorkerAdhoc = async (ctx, _profile, args) => {
       const workersDir = String(args?.workersDir ?? ".kody/staff");
       const workerSlug = String(ctx.args.worker ?? "").trim();
       if (!workerSlug) {
         throw new Error("loadWorkerAdhoc: ctx.args.worker must be a non-empty slug");
       }
-      const workerPath = path32.join(ctx.cwd, workersDir, `${workerSlug}.md`);
+      const workerPath = path33.join(ctx.cwd, workersDir, `${workerSlug}.md`);
       if (!fs35.existsSync(workerPath)) {
         throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
       }
@@ -12061,12 +12148,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path33 from "path";
+import * as path34 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path33.dirname(fileURLToPath(import.meta.url));
+  const here = path34.dirname(fileURLToPath(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path33.join(here, "preview-build-templates", file);
+  return path34.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -12325,10 +12412,10 @@ var init_runPreviewBuild = __esm({
         console.log(`[preview-build] vault: ${Object.keys(buildEnv).length} secrets, mode=${buildMode}`);
         if (Object.keys(buildEnv).length > 0) {
           const lines = Object.entries(buildEnv).map(([k, v]) => `${k}=${JSON.stringify(v)}`);
-          await writeFile(path33.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path34.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path33.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path34.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -12431,7 +12518,7 @@ var init_runPreviewBuild = __esm({
 // src/scripts/runTickScript.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import * as fs36 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 function buildChildEnv(parent, force) {
   const allow = /* @__PURE__ */ new Set([
     "PATH",
@@ -12479,7 +12566,7 @@ var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
     "use strict";
-    init_jobFrontmatter();
+    init_dutyFolders();
     init_jobState();
     init_parseJobStateFromAgentResult();
     runTickScript = async (ctx, _profile, args) => {
@@ -12493,21 +12580,19 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const jobPath = path34.join(ctx.cwd, jobsDir, `${slug}.md`);
-      if (!fs36.existsSync(jobPath)) {
+      const duty = readDutyFolder(path35.join(ctx.cwd, jobsDir), slug);
+      if (!duty) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: job file not found: ${jobPath}`;
+        ctx.output.reason = `runTickScript: duty folder not found or incomplete: ${path35.join(ctx.cwd, jobsDir, slug)}`;
         return;
       }
-      const raw = fs36.readFileSync(jobPath, "utf-8");
-      const { frontmatter } = splitFrontmatter2(raw);
-      const tickScript = frontmatter.tickScript;
+      const tickScript = duty.config.tickScript;
       if (!tickScript) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: duty ${slug} has no \`tickScript:\` frontmatter \u2014 route via duty-tick instead`;
+        ctx.output.reason = `runTickScript: duty ${slug} has no \`tickScript\` in profile.json \u2014 route via duty-tick instead`;
         return;
       }
-      const scriptPath = path34.isAbsolute(tickScript) ? tickScript : path34.join(ctx.cwd, tickScript);
+      const scriptPath = path35.isAbsolute(tickScript) ? tickScript : path35.join(ctx.cwd, tickScript);
       if (!fs36.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
@@ -13706,7 +13791,7 @@ var init_scripts = __esm({
 
 // src/staff.ts
 import * as fs38 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 function stripFrontmatter(raw) {
   const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
   return (match ? match[1] : raw).trim();
@@ -13714,7 +13799,7 @@ function stripFrontmatter(raw) {
 function loadStaffPersona(cwd, slug, staffDir = DEFAULT_STAFF_DIR) {
   const trimmed = slug.trim();
   if (!trimmed) throw new Error("loadStaffPersona: empty staff slug");
-  const staffPath = path35.join(cwd, staffDir, `${trimmed}.md`);
+  const staffPath = path36.join(cwd, staffDir, `${trimmed}.md`);
   if (fs38.existsSync(staffPath)) {
     const body = stripFrontmatter(fs38.readFileSync(staffPath, "utf-8"));
     if (body) return body;
@@ -13830,7 +13915,7 @@ var init_tools = __esm({
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
 import * as fs39 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
 }
@@ -13981,13 +14066,13 @@ async function runExecutable(profileName, input) {
       })
     };
   })() : null;
-  const ndjsonDir = path36.join(input.cwd, ".kody");
+  const ndjsonDir = path37.join(input.cwd, ".kody");
   const personaSlug = typeof profile.staff === "string" && profile.staff.length > 0 ? profile.staff : typeof ctx.data.jobPersona === "string" && ctx.data.jobPersona.length > 0 ? ctx.data.jobPersona : null;
   const staffPersona = personaSlug ? framePersona(personaSlug, loadStaffPersona(input.cwd, personaSlug)) : null;
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path36.isAbsolute(p) ? p : path36.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path37.isAbsolute(p) ? p : path37.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     const agents = loadSubagents(profile);
@@ -14028,7 +14113,7 @@ async function runExecutable(profileName, input) {
       enableVerifyTool: profile.claudeCode.enableVerifyTool,
       enableSubmitTool: profile.claudeCode.enableSubmitTool,
       // Locked-toolbox duty mode: `loadJobFromFile` flips `ctx.data.dutyTools`
-      // when a duty declares `tools:` frontmatter. The executor doesn't need
+      // when a duty declares `tools` in profile.json. The executor doesn't need
       // to know the palette — it just forwards the flag so agent.ts can spin
       // up the in-process `kody-duty` MCP server with the right context.
       enableDutyTool: Array.isArray(ctx.data.dutyTools) && ctx.data.dutyTools.length > 0,
@@ -14313,13 +14398,13 @@ function clearStampedLifecycleLabels(profile, ctx) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path36.dirname(new URL(import.meta.url).pathname);
+  const here = path37.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path36.join(here, "executables", profileName, "profile.json"),
+    path37.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path36.join(here, "..", "executables", profileName, "profile.json"),
+    path37.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path36.join(here, "..", "src", "executables", profileName, "profile.json")
+    path37.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
@@ -14421,7 +14506,7 @@ function resolveShellTimeoutMs(entry) {
 }
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path36.join(profile.dir, shellName);
+  const shellPath = path37.join(profile.dir, shellName);
   if (!fs39.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
@@ -14678,18 +14763,18 @@ function translateOpenAISseToBrain(opts) {
 // src/servers/brain-serve.ts
 import * as fs42 from "fs";
 import { createServer } from "http";
-import * as path39 from "path";
+import * as path40 from "path";
 
 // src/chat/loop.ts
 init_agent();
 init_registry();
 init_task_artifacts();
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 
 // src/chat/attachments.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 var INLINE_ATTACHMENT_RE = /(?:\[(?:Image|File): ([^\]]*)\]\n)?data:([\w.+-]+\/[\w.+-]+);base64,([A-Za-z0-9+/=]+)/g;
 var EXT_BY_MIME = {
   "image/png": "png",
@@ -14705,7 +14790,7 @@ function extFor(mime) {
   return EXT_BY_MIME[mime.toLowerCase()] ?? mime.split("/")[1]?.replace(/[^\w]/g, "") ?? "bin";
 }
 function attachmentsDir(cwd, sessionId) {
-  return path8.join(cwd, ".kody", "tmp", "attachments", sessionId);
+  return path9.join(cwd, ".kody", "tmp", "attachments", sessionId);
 }
 function prepareAttachments(turns, cwd, sessionId) {
   const imagePaths = [];
@@ -14722,11 +14807,11 @@ function prepareAttachments(turns, cwd, sessionId) {
         if (!isImage) return `[File: ${name}]`;
         try {
           if (!dirEnsured) {
-            fs8.mkdirSync(dir, { recursive: true });
+            fs9.mkdirSync(dir, { recursive: true });
             dirEnsured = true;
           }
-          const filePath = path8.join(dir, `${imageCounter}.${extFor(mime)}`);
-          fs8.writeFileSync(filePath, Buffer.from(data, "base64"));
+          const filePath = path9.join(dir, `${imageCounter}.${extFor(mime)}`);
+          fs9.writeFileSync(filePath, Buffer.from(data, "base64"));
           imageCounter += 1;
           imagePaths.push(filePath);
           return `[Image "${name}" is attached \u2014 saved to ${filePath}. Use the Read tool on that exact path to view it.]`;
@@ -14742,10 +14827,10 @@ function prepareAttachments(turns, cwd, sessionId) {
 }
 
 // src/chat/events.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function eventsFilePath(cwd, sessionId) {
-  return path9.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
+  return path10.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
 }
 var FileSink = class {
   constructor(file) {
@@ -14753,8 +14838,8 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs9.mkdirSync(path9.dirname(this.file), { recursive: true });
-    fs9.appendFileSync(this.file, `${JSON.stringify(event)}
+    fs10.mkdirSync(path10.dirname(this.file), { recursive: true });
+    fs10.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
 };
@@ -14808,14 +14893,14 @@ function makeRunId(sessionId, suffix) {
 }
 
 // src/chat/session.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path10.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path11.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs10.existsSync(file)) return null;
-  const raw = fs10.readFileSync(file, "utf-8");
+  if (!fs11.existsSync(file)) return null;
+  const raw = fs11.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -14828,8 +14913,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs10.existsSync(file)) return [];
-  const raw = fs10.readFileSync(file, "utf-8").trim();
+  if (!fs11.existsSync(file)) return [];
+  const raw = fs11.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -14845,14 +14930,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  fs11.mkdirSync(path11.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs10.appendFileSync(file, `${line}
+  fs11.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -14971,7 +15056,7 @@ function buildExecutableCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs11.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs12.readFileSync(profilePath, "utf-8"));
       const describe = typeof raw.describe === "string" ? raw.describe : "";
       const firstSentence = describe.split(/(?<=[.!?])\s+/, 1)[0] ?? "";
       entries.push({ name, describe: firstSentence.trim() });
@@ -15139,10 +15224,10 @@ async function emit(sink, type, sessionId, suffix, payload) {
 var MEMORY_INDEX_REL = ".kody/memory/INDEX.md";
 var MAX_INDEX_BYTES = 8e3;
 function readMemoryIndexBlock(cwd) {
-  const indexPath = path11.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path12.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs11.readFileSync(indexPath, "utf-8");
+    raw = fs12.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -15160,17 +15245,17 @@ function readMemoryIndexBlock(cwd) {
 var CONTEXT_DIR_REL = ".kody/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path11.join(cwd, CONTEXT_DIR_REL);
+  const dir = path12.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs11.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs12.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs11.readFileSync(path11.join(dir, file), "utf-8").trim();
+      const content = fs12.readFileSync(path12.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -15193,10 +15278,10 @@ _\u2026 (context truncated; see \`.kody/context/\` for the full text)_` : joined
 var INSTRUCTIONS_REL = ".kody/instructions.md";
 var MAX_INSTRUCTIONS_BYTES = 8e3;
 function readInstructionsBlock(cwd) {
-  const instructionsPath = path11.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path12.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs11.readFileSync(instructionsPath, "utf-8");
+    raw = fs12.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -15220,7 +15305,7 @@ init_config();
 // src/kody-cli.ts
 import { execFileSync as execFileSync26 } from "child_process";
 import * as fs40 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 
 // src/app-auth.ts
 import { createSign } from "crypto";
@@ -15297,7 +15382,7 @@ init_config();
 
 // src/dispatch.ts
 init_config();
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -15370,17 +15455,55 @@ function primaryNumericInputName(executable) {
   const intInput = inputs.find((i) => i.type === "int" && i.required);
   return intInput?.name ?? null;
 }
+function resolveOperatorAction(action) {
+  return resolveDutyAction(action);
+}
+function resolveConfiguredAction(action) {
+  const resolved = resolveDutyAction(action);
+  if (resolved) return resolved;
+  return compatibilityDutyAction(action);
+}
+function requiredRoute(action) {
+  return resolveConfiguredAction(action) ?? {
+    action,
+    duty: action,
+    executable: action,
+    cliArgs: {},
+    source: "builtin"
+  };
+}
+function compatibilityDutyAction(action) {
+  if (!/^[a-z][a-z0-9-]*$/.test(action)) return null;
+  return {
+    action,
+    duty: action,
+    executable: action,
+    cliArgs: {},
+    source: "builtin"
+  };
+}
+function routeResult(route, cliArgs, target, why) {
+  const result = {
+    action: route.action,
+    duty: route.duty,
+    executable: route.executable,
+    cliArgs: { ...route.cliArgs, ...cliArgs },
+    target
+  };
+  if (why !== void 0 && why.length > 0) result.why = why;
+  return result;
+}
 function autoDispatch(opts) {
   const explicit = opts?.explicit;
   if (explicit?.issueNumber && explicit.issueNumber > 0) {
-    return { executable: "run", cliArgs: { issue: explicit.issueNumber }, target: explicit.issueNumber };
+    return routeResult(requiredRoute("run"), { issue: explicit.issueNumber }, explicit.issueNumber);
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs12.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs13.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -15388,25 +15511,29 @@ function autoDispatch(opts) {
     const inputs2 = objectValue(event.inputs);
     const n = parseInt(String(inputs2?.issue_number ?? ""), 10);
     if (!Number.isNaN(n) && n > 0) {
-      const exe = String(inputs2?.executable ?? "").trim() || "run";
+      const actionName = String(inputs2?.executable ?? "").trim() || "run";
+      const route2 = resolveConfiguredAction(actionName);
+      if (!route2) return null;
       const base = String(inputs2?.base ?? "").trim();
-      const targetKey = primaryNumericInputName(exe) ?? "issue";
+      const targetKey = primaryNumericInputName(route2.executable) ?? "issue";
       const cliArgs = { [targetKey]: n };
       if (base) cliArgs.base = base;
-      return { executable: exe, cliArgs, target: n };
+      return routeResult(route2, cliArgs, n);
     }
     return null;
   }
   if (eventName === "schedule") return null;
   if (eventName === "pull_request") {
-    const exe = opts?.config?.onPullRequest?.trim();
+    const actionName = opts?.config?.onPullRequest?.trim();
     const action = String(event.action ?? "");
-    if (exe && (action === "opened" || action === "synchronize" || action === "reopened")) {
+    if (actionName && (action === "opened" || action === "synchronize" || action === "reopened")) {
+      const route2 = resolveConfiguredAction(actionName);
+      if (!route2) return null;
       const pullRequest = objectValue(event.pull_request);
       const prNum = Number(pullRequest?.number ?? event.number ?? 0);
       if (prNum > 0) {
-        const targetKey = primaryNumericInputName(exe) ?? "pr";
-        return { executable: exe, cliArgs: { [targetKey]: prNum }, target: prNum };
+        const targetKey = primaryNumericInputName(route2.executable) ?? "pr";
+        return routeResult(route2, { [targetKey]: prNum }, prNum);
       }
     }
     return null;
@@ -15430,21 +15557,22 @@ function autoDispatch(opts) {
   const firstToken = firstTokenRaw && POLITE_WORDS.has(firstTokenRaw) ? null : firstTokenRaw;
   const aliases = opts?.config?.aliases ?? BUILTIN_ALIASES;
   const aliased = firstToken ? aliases[firstToken] ?? firstToken : null;
-  let executable = null;
+  let route = null;
   let consumedFirstToken = false;
   if (aliased) {
-    if (getProfileInputs(aliased) !== null) {
-      executable = aliased;
+    route = resolveOperatorAction(aliased);
+    if (route) {
       consumedFirstToken = true;
     } else if (firstToken && aliases[firstToken] && aliases[firstToken] === aliased) {
       process.stderr.write(
-        `[kody] dispatch: alias '${firstToken}' \u2192 '${aliased}' has no matching executable; falling back to default
+        `[kody] dispatch: alias '${firstToken}' \u2192 '${aliased}' has no matching duty action; falling back to default
 `
       );
     }
   }
-  if (!executable && !firstToken) {
-    executable = isPr ? opts?.config?.defaultPrExecutable ?? null : opts?.config?.defaultExecutable ?? null;
+  if (!route && !firstToken) {
+    const defaultAction = isPr ? opts?.config?.defaultPrExecutable ?? null : opts?.config?.defaultExecutable ?? null;
+    route = defaultAction ? resolveConfiguredAction(defaultAction) : null;
   }
   if (isBotAuthor && !consumedFirstToken) {
     process.stderr.write(
@@ -15453,16 +15581,16 @@ function autoDispatch(opts) {
     );
     return null;
   }
-  if (!executable) {
+  if (!route) {
     if (!firstToken) return null;
-    const profileMissing = aliased ? getProfileInputs(aliased) === null : true;
+    const profileMissing = aliased ? resolveOperatorAction(aliased) === null : true;
     process.stderr.write(
-      `[kody] dispatch: no executable resolved for issue_comment (firstToken=${firstToken ?? "<none>"}, aliased=${aliased ?? "<none>"}, profileFound=${!profileMissing}, defaultExecutable=${opts?.config?.defaultExecutable ?? "<unset>"}, defaultPrExecutable=${opts?.config?.defaultPrExecutable ?? "<unset>"})
+      `[kody] dispatch: no duty action resolved for issue_comment (firstToken=${firstToken ?? "<none>"}, aliased=${aliased ?? "<none>"}, actionFound=${!profileMissing}, defaultExecutable=${opts?.config?.defaultExecutable ?? "<unset>"}, defaultPrExecutable=${opts?.config?.defaultPrExecutable ?? "<unset>"})
 `
     );
     return null;
   }
-  const inputs = getProfileInputs(executable);
+  const inputs = getProfileInputs(route.executable);
   const effectiveInputs = inputs ?? [];
   const unknownProfile = inputs === null;
   const rest = extractCommentRest(afterTag, consumedFirstToken ? firstToken : null);
@@ -15479,14 +15607,14 @@ function autoDispatch(opts) {
   } else if (leftover.length > 0) {
     why = leftover;
   }
-  return { executable, cliArgs: args, target: targetNum, why };
+  return routeResult(route, args, targetNum, why);
 }
 function autoDispatchTyped(opts) {
   const legacy = autoDispatch(opts);
   if (legacy) return { kind: "route", ...legacy };
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs12.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs13.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -15494,7 +15622,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -15527,7 +15655,7 @@ function autoDispatchTyped(opts) {
       reason: tokenRaw ? `polite-word lead-in '${tokenRaw}', no default executable configured` : "no subcommand token, no default executable configured"
     };
   }
-  const available = listExecutables().map((e) => e.name).filter((n) => !n.startsWith("goal-") && !n.startsWith("job-")).sort();
+  const available = listDutyActions().map((e) => e.action).filter((n) => !n.startsWith("goal-") && !n.startsWith("job-")).sort();
   return { kind: "unrecognized", token: tokenRaw, target: targetNum, isPr, available };
 }
 function dispatchScheduledWatches(opts) {
@@ -15538,7 +15666,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs12.readFileSync(exe.profilePath, "utf-8");
+      raw = fs13.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -15564,7 +15692,7 @@ function dispatchScheduledWatches(opts) {
         continue;
       }
     }
-    out.push({ executable: exe.name, cliArgs: {}, target: 0 });
+    out.push({ action: exe.name, duty: exe.name, executable: exe.name, cliArgs: {}, target: 0 });
   }
   return out;
 }
@@ -15670,6 +15798,7 @@ init_executor();
 init_gha();
 init_issue();
 init_job();
+init_registry();
 var CI_HELP = `kody ci \u2014 minimal-YAML autonomous engineer (CI preflight + run)
 
 Usage:
@@ -15780,9 +15909,9 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs40.existsSync(path37.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs40.existsSync(path37.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs40.existsSync(path37.join(cwd, "bun.lockb"))) return "bun";
+  if (fs40.existsSync(path38.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs40.existsSync(path38.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs40.existsSync(path38.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
@@ -15869,7 +15998,7 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path37.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path38.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
     if (fs40.existsSync(logPath)) {
@@ -15898,7 +16027,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path37.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path38.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   let earlyConfigError;
   try {
@@ -15910,7 +16039,7 @@ async function runCi(argv) {
   const eventName = process.env.GITHUB_EVENT_NAME;
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
-  let forceRunDuty = null;
+  let forceRunAction = null;
   if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs40.existsSync(dispatchEventPath)) {
     try {
       const evt = JSON.parse(fs40.readFileSync(dispatchEventPath, "utf-8"));
@@ -15918,15 +16047,21 @@ async function runCi(argv) {
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       const exeInput = String(evt?.inputs?.executable ?? "").trim();
       const noTarget = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
-      if (noTarget && exeInput) forceRunDuty = exeInput;
+      if (noTarget && exeInput) forceRunAction = exeInput;
       else manualWorkflowDispatch = noTarget;
     } catch {
       manualWorkflowDispatch = false;
     }
   }
-  if (forceRunDuty) {
+  if (forceRunAction) {
     const config = earlyConfig ?? loadConfig(cwd);
-    process.stdout.write(`\u2192 kody: manual one-shot run of duty ${forceRunDuty}
+    const route = resolveDutyAction(forceRunAction);
+    if (!route) {
+      process.stderr.write(`[kody] manual one-shot action '${forceRunAction}' has no duty action
+`);
+      return 64;
+    }
+    process.stdout.write(`\u2192 kody: manual one-shot run of duty action ${route.action} (${route.duty})
 
 `);
     try {
@@ -15957,13 +16092,22 @@ async function runCi(argv) {
 `);
       return 99;
     }
-    const result = await runExecutableChain(forceRunDuty, {
-      cliArgs: {},
-      cwd,
-      config,
-      verbose: args.verbose,
-      quiet: args.quiet
-    });
+    const result = await runJob(
+      {
+        action: route.action,
+        duty: route.duty,
+        executable: route.executable,
+        cliArgs: route.cliArgs,
+        flavor: "instant",
+        force: true
+      },
+      {
+        cwd,
+        config,
+        verbose: args.verbose,
+        quiet: args.quiet
+      }
+    );
     const ec = result.exitCode;
     return ec === 0 || ec === 1 || ec === 2 ? ec : 99;
   }
@@ -16024,13 +16168,17 @@ ${CI_HELP}`);
     return 64;
   }
   const dispatch2 = autoFallback ?? {
+    action: "run",
+    duty: "run",
     executable: "run",
     cliArgs: { issue: args.issueNumber },
     target: args.issueNumber
   };
   const issueNumber = dispatch2.target;
-  process.stdout.write(`\u2192 kody preflight (cwd=${cwd}, executable=${dispatch2.executable}, target=${issueNumber})
-`);
+  process.stdout.write(
+    `\u2192 kody preflight (cwd=${cwd}, action=${dispatch2.action}, duty=${dispatch2.duty}, executable=${dispatch2.executable}, target=${issueNumber})
+`
+  );
   try {
     const n = unpackAllSecrets();
     if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
@@ -16190,10 +16338,10 @@ init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
 import * as fs41 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath(dir, chatId) {
-  return path38.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
+  return path39.join(dir, ".kody", "brain-events", `${chatId}.jsonl`);
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath(dir, chatId);
@@ -16236,7 +16384,7 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath(dir, chatId);
-  fs41.mkdirSync(path38.dirname(p), { recursive: true });
+  fs41.mkdirSync(path39.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
@@ -16511,7 +16659,7 @@ async function handleChatTurn(req, res, chatId, opts) {
   const repo = strField(body, "repo");
   const repoToken = strField(body, "repoToken");
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs42.mkdirSync(path39.dirname(sessionFile), { recursive: true });
+  fs42.mkdirSync(path40.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -16558,7 +16706,7 @@ async function handleChatTurn(req, res, chatId, opts) {
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;
   const cloneRepo = opts.cloneRepo ?? defaultCloneRepo;
-  const reposRoot = opts.reposRoot ?? path39.join(path39.dirname(path39.resolve(opts.cwd)), "repos");
+  const reposRoot = opts.reposRoot ?? path40.join(path40.dirname(path40.resolve(opts.cwd)), "repos");
   return createServer(async (req, res) => {
     if (!req.method || !req.url) {
       sendJson(res, 400, { error: "bad request" });
@@ -17152,13 +17300,13 @@ async function loadConfigSafe() {
 // src/chat-cli.ts
 import { execFileSync as execFileSync29 } from "child_process";
 import * as fs44 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 
 // src/chat/modes/interactive.ts
 init_issue();
 import { execFileSync as execFileSync28 } from "child_process";
 import * as fs43 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync as execFileSync27 } from "child_process";
@@ -17317,9 +17465,9 @@ function findNextUserTurn(turns, fromIdx) {
   return -1;
 }
 function commitTurn(cwd, sessionId, _verbose) {
-  const sessionRel = path40.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsRel = path40.relative(cwd, eventsFilePath(cwd, sessionId));
-  const rels = [sessionRel, eventsRel].filter((p) => fs43.existsSync(path40.join(cwd, p)));
+  const sessionRel = path41.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsRel = path41.relative(cwd, eventsFilePath(cwd, sessionId));
+  const rels = [sessionRel, eventsRel].filter((p) => fs43.existsSync(path41.join(cwd, p)));
   if (rels.length === 0) return;
   const repository = process.env.GITHUB_REPOSITORY;
   if (!repository) {
@@ -17331,8 +17479,8 @@ function commitTurn(cwd, sessionId, _verbose) {
   }
   const branch = defaultBranch(cwd) ?? "main";
   for (const rel of rels) {
-    const repoPath = rel.split(path40.sep).join("/");
-    const localText = fs43.readFileSync(path40.join(cwd, rel), "utf-8");
+    const repoPath = rel.split(path41.sep).join("/");
+    const localText = fs43.readFileSync(path41.join(cwd, rel), "utf-8");
     putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
@@ -17469,12 +17617,12 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path41.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path41.relative(cwd, eventsFilePath(cwd, sessionId));
+  const sessionFile = path42.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path42.relative(cwd, eventsFilePath(cwd, sessionId));
   const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const tasksDir = path41.join(".kody", "tasks", safeSession);
+  const tasksDir = path42.join(".kody", "tasks", safeSession);
   const candidatePaths = [sessionFile, eventsFile, tasksDir];
-  const paths = candidatePaths.filter((p) => fs44.existsSync(path41.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs44.existsSync(path42.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
@@ -17518,7 +17666,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path41.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path42.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {
@@ -17610,6 +17758,7 @@ ${CHAT_HELP}`);
 // src/entry.ts
 init_config();
 init_executor();
+init_job();
 init_registry();
 
 // src/servers/pool-serve.ts
@@ -17726,8 +17875,8 @@ var FlyClient = class {
   get fetch() {
     return this.opts.fetchImpl ?? fetch;
   }
-  async call(path42, init = {}) {
-    const res = await this.fetch(`${FLY_API_BASE}${path42}`, {
+  async call(path43, init = {}) {
+    const res = await this.fetch(`${FLY_API_BASE}${path43}`, {
       method: init.method ?? "GET",
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -17738,7 +17887,7 @@ var FlyClient = class {
     if (res.status === 404 && init.allow404) return null;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Fly API ${res.status} on ${path42}: ${text.slice(0, 200) || res.statusText}`);
+      throw new Error(`Fly API ${res.status} on ${path43}: ${text.slice(0, 200) || res.statusText}`);
     }
     if (res.status === 204) return null;
     const raw = await res.text();
@@ -18998,16 +19147,17 @@ Usage:
   kody-engine preview-build --pr <N>                 [--cwd <path>] [--verbose|--quiet]
   kody-engine release --issue <N>                    [--cwd <path>] [--verbose|--quiet]
   kody-engine init                                   [--cwd <path>] [--verbose|--quiet]
-  kody-engine <executable>                           [--cwd <path>] [--verbose|--quiet]
+  kody-engine <action>                               [--cwd <path>] [--verbose|--quiet]
+  kody-engine exec <executable>                      [--cwd <path>] [--verbose|--quiet]
   kody-engine ci      [preflight flags \u2014 see: kody-engine ci --help]
   kody-engine chat    [chat flags \u2014 see: kody-engine chat --help]
   kody-engine stats   [--since 7d|--run <id>|--json|--cwd <path>]
   kody-engine help
   kody-engine version
 
-Each top-level command is a discovered executable under
-\`src/executables/<name>/profile.json\`. Drop in a new directory to add a new
-command; consumer repos can also provide their own executable profiles.
+Top-level work commands are duty actions. A duty owns the public action name
+and selects an implementation executable. \`exec <executable>\` is the low-level
+debug path for engine internals and migration compatibility.
 
 Exit codes:
   0   success (PR opened, verify passed \u2014 or resolve produced a merge commit)
@@ -19048,6 +19198,33 @@ function parseArgs(argv) {
     result.serverArgs = argv.slice(1).filter((a) => !a.startsWith("-"));
     return result;
   }
+  if (cmd === "exec") {
+    const executableName = argv[1];
+    if (!executableName) {
+      result.errors.push("exec requires an executable name");
+      return result;
+    }
+    if (!hasExecutable(executableName)) {
+      result.errors.push(`unknown executable: ${executableName}`);
+      return result;
+    }
+    result.command = "__executable__";
+    result.executableName = executableName;
+    result.cliArgs = parseGenericFlags(argv.slice(2));
+    if (typeof result.cliArgs.cwd === "string") result.cwd = result.cliArgs.cwd;
+    if (result.cliArgs.verbose === true) result.verbose = true;
+    if (result.cliArgs.quiet === true) result.quiet = true;
+    return result;
+  }
+  if (hasDutyAction(cmd)) {
+    result.command = "__duty__";
+    result.actionName = cmd;
+    result.cliArgs = parseGenericFlags(argv.slice(1));
+    if (typeof result.cliArgs.cwd === "string") result.cwd = result.cliArgs.cwd;
+    if (result.cliArgs.verbose === true) result.verbose = true;
+    if (result.cliArgs.quiet === true) result.quiet = true;
+    return result;
+  }
   if (hasExecutable(cmd)) {
     result.command = "__executable__";
     result.executableName = cmd;
@@ -19057,8 +19234,9 @@ function parseArgs(argv) {
     if (result.cliArgs.quiet === true) result.quiet = true;
     return result;
   }
-  const discovered = listExecutables().map((e) => e.name);
-  const available = ["ci", "chat", "stats", "help", "version", ...discovered];
+  const discoveredActions = listDutyActions().map((e) => e.action);
+  const discoveredExecutables = listExecutables().map((e) => `exec ${e.name}`);
+  const available = ["ci", "chat", "stats", "help", "version", ...discoveredActions, ...discoveredExecutables];
   result.errors.push(`unknown command: ${cmd} (available: ${available.join(", ")})`);
   return result;
 }
@@ -19148,6 +19326,48 @@ ${HELP_TEXT}`);
   }
   const cwd = args.cwd ?? process.cwd();
   const configlessCommands = /* @__PURE__ */ new Set(["init", "goal-scheduler"]);
+  if (args.command === "__duty__") {
+    const route = resolveDutyAction(args.actionName);
+    if (!route) {
+      process.stderr.write(`error: unknown duty action '${args.actionName}'
+`);
+      return 64;
+    }
+    const cliArgs = { ...route.cliArgs, ...args.cliArgs ?? {} };
+    const skipConfig2 = configlessCommands.has(route.executable);
+    try {
+      const result = await runJob(
+        {
+          action: route.action,
+          duty: route.duty,
+          executable: route.executable,
+          cliArgs,
+          target: numericTarget(cliArgs),
+          flavor: "instant"
+        },
+        {
+          cwd,
+          skipConfig: skipConfig2,
+          verbose: args.verbose,
+          quiet: args.quiet
+        }
+      );
+      if (result.exitCode !== 0 && result.reason) {
+        process.stderr.write(`error: ${result.reason}
+`);
+      }
+      return result.exitCode;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody] ${args.actionName} crashed: ${msg}
+`);
+      if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
+`);
+      process.stdout.write(`PR_URL=FAILED: ${args.actionName} crashed: ${msg}
+`);
+      return 99;
+    }
+  }
   const skipConfig = configlessCommands.has(args.executableName ?? "");
   try {
     const result = await runExecutableChain(args.executableName, {
@@ -19173,6 +19393,14 @@ ${HELP_TEXT}`);
     return 99;
   }
 }
+function numericTarget(cliArgs) {
+  for (const key of ["issue", "pr"]) {
+    const raw = cliArgs[key];
+    const n = typeof raw === "number" ? raw : typeof raw === "string" ? parseInt(raw, 10) : Number.NaN;
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return void 0;
+}
 
 // bin/kody.ts
 main().then((code) => {