@kody-ade/kody-engine 0.4.219 → 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.219",
+      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,14 +1981,7 @@ var init_agent = __esm({
   }
 });
 
-// src/scripts/jobFrontmatter.ts
-function splitFrontmatter(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 };
-}
+// src/scripts/scheduleEvery.ts
 function isScheduleEvery(value) {
   return typeof value === "string" && SCHEDULE_EVERY_VALUES.includes(value);
 }
@@ -2019,55 +2012,9 @@ function scheduleEveryToMs(every) {
       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 === "action" && value.length > 0) {
-      out.action = value;
-    } else if (key === "executable" && value.length > 0) {
-      out.executable = value;
-    } else 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"() {
+var SCHEDULE_EVERY_VALUES;
+var init_scheduleEvery = __esm({
+  "src/scripts/scheduleEvery.ts"() {
     "use strict";
     SCHEDULE_EVERY_VALUES = [
       "15m",
@@ -2081,87 +2028,177 @@ var init_jobFrontmatter = __esm({
       "7d",
       "manual"
     ];
-    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
   }
 });
 
-// src/registry.ts
+// 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 (fs6.existsSync(c) && fs6.statSync(c).isDirectory()) return c;
+    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getBuiltinDutiesRoot() {
-  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, "duties"),
+    path7.join(here, "duties"),
     // dev: src/
-    path6.join(here, "..", "duties"),
+    path7.join(here, "..", "duties"),
     // built: dist/bin → dist/duties
-    path6.join(here, "..", "src", "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));
@@ -2175,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 {
   }
@@ -2192,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);
       }
@@ -2213,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;
     }
   }
@@ -2233,7 +2272,6 @@ function listDutyActions(projectDutiesRoot = getProjectDutiesRoot()) {
     out.push(action);
   };
   for (const action of listProjectFolderDutyActions(projectDutiesRoot)) add(action);
-  for (const action of listProjectMarkdownDutyActions(projectDutiesRoot)) add(action);
   for (const action of listBuiltinDutyActions()) add(action);
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
@@ -2248,108 +2286,54 @@ function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
 function listProjectFolderDutyActions(root) {
-  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 })) {
-    if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name.startsWith("_")) continue;
-    if (!isSafeName(ent.name)) continue;
-    const profilePath = path6.join(root, ent.name, "profile.json");
-    if (!fs6.existsSync(profilePath) || !fs6.statSync(profilePath).isFile()) continue;
-    try {
-      const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
-      const action = stringOr(raw.action, ent.name);
-      const executable = stringOr(raw.executable, ent.name);
-      out.push({
-        action,
-        duty: ent.name,
-        executable,
-        cliArgs: {},
-        source: "project-folder",
-        describe: typeof raw.describe === "string" ? raw.describe : void 0,
-        profilePath
-      });
-    } catch {
-      continue;
-    }
+  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 listProjectMarkdownDutyActions(root) {
-  if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
+function listBuiltinDutyActions(root = getBuiltinDutiesRoot()) {
+  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
-    if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
-    const duty = ent.name.slice(0, -3);
-    if (!isSafeName(duty)) continue;
-    const filePath = path6.join(root, ent.name);
-    try {
-      const raw = fs6.readFileSync(filePath, "utf-8");
-      const { frontmatter } = splitFrontmatter(raw);
-      const action = frontmatter.action?.trim() || duty;
-      const implementation = markdownDutyImplementation(duty, frontmatter);
-      out.push({
-        action,
-        duty,
-        executable: implementation.executable,
-        cliArgs: implementation.cliArgs,
-        source: "project-markdown",
-        filePath
-      });
-    } catch {
-      continue;
-    }
+  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 markdownDutyImplementation(duty, frontmatter) {
-  if (frontmatter.executable?.trim()) {
-    return { executable: frontmatter.executable.trim(), cliArgs: {} };
-  }
-  if (frontmatter.executables?.length === 1 && frontmatter.executables[0]?.trim()) {
-    return { executable: frontmatter.executables[0].trim(), cliArgs: {} };
-  }
-  if (frontmatter.tickScript?.trim()) {
-    return { executable: "duty-tick-scripted", cliArgs: { duty } };
-  }
-  return { executable: "duty-tick", cliArgs: { duty } };
-}
-function listBuiltinDutyActions(root = getBuiltinDutiesRoot()) {
-  const filePath = path6.join(root, "public-actions.json");
-  if (!fs6.existsSync(filePath) || !fs6.statSync(filePath).isFile()) return [];
-  try {
-    const raw = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
-    if (!Array.isArray(raw)) return [];
-    const out = [];
-    for (const item of raw) {
-      if (!item || typeof item !== "object") continue;
-      const r = item;
-      const duty = stringOr(r.duty, stringOr(r.name, ""));
-      const action = stringOr(r.action, duty);
-      const executable = stringOr(r.executable, duty);
-      if (!duty || !action || !executable) continue;
-      out.push({
-        action,
-        duty,
-        executable,
-        cliArgs: {},
-        source: "builtin",
-        describe: typeof r.describe === "string" ? r.describe : void 0,
-        filePath
-      });
-    }
-    return out.sort((a, b) => a.action.localeCompare(b.action));
-  } catch {
-    return [];
-  }
-}
-function stringOr(value, fallback) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
-}
 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 {
@@ -2385,27 +2369,27 @@ var _builtinNames;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
-    init_jobFrontmatter();
+    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);
@@ -2639,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;
@@ -2676,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 = {
@@ -2724,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;
     };
@@ -2732,9 +2716,9 @@ var init_buildSyntheticPlugin = __esm({
 });
 
 // src/subagents.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
-function splitFrontmatter2(raw) {
+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() };
   const fm = {};
@@ -2746,10 +2730,10 @@ function splitFrontmatter2(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) {
@@ -2758,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 {
     }
   }
@@ -2769,8 +2753,8 @@ 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 { fm, body } = splitFrontmatter2(raw);
+    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 = {
       description: fm.description ?? `Subagent ${name}`,
@@ -2793,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)}`);
   }
@@ -2812,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(", ")}
 `
     );
   }
@@ -2831,7 +2815,7 @@ function loadProfile(profilePath) {
       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
     };
   }
@@ -2877,8 +2861,8 @@ function loadProfile(profilePath) {
     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,
@@ -2901,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);
@@ -2934,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 {
   }
@@ -2962,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 = [];
@@ -3213,7 +3203,11 @@ var init_profile = __esm({
       "staff",
       "every",
       "dutyTools",
+      "tools",
       "mentions",
+      "stage",
+      "readsFrom",
+      "writesTo",
       "describe",
       "role",
       "kind",
@@ -3610,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;
     }
@@ -3854,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,
@@ -3943,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;
       }
@@ -3975,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;
       }
@@ -4020,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;
@@ -4486,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) });
@@ -4573,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 () => {
@@ -4593,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 "";
     }
@@ -4645,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)=(.*)$/);
@@ -4763,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, {
@@ -4802,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 {
@@ -4869,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: "" };
   }
@@ -5106,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;
@@ -5117,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;
   }
@@ -5454,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({
@@ -5475,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;
@@ -5530,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(
               {
@@ -5553,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");
@@ -5606,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;
@@ -5721,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]");
@@ -5811,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 "";
   }
@@ -5839,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 = "";
@@ -5854,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) {
@@ -5865,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)}`;
         }
@@ -6692,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"));
@@ -6732,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;
@@ -6775,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];
@@ -6807,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
         });
@@ -6820,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;
       }
@@ -6849,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;
@@ -6867,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;
   }
@@ -6877,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)
       );
@@ -6892,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 {
@@ -6903,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("]]")) {
@@ -6911,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();
@@ -6965,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: [],
@@ -6997,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;
@@ -7009,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;
   }
@@ -7018,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;
   }
@@ -7035,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("]]")) {
@@ -7043,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) {
@@ -7060,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) {
@@ -7369,6 +7368,23 @@ async function runJob(job, base) {
   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 = {
@@ -7384,6 +7400,10 @@ async function runJob(job, base) {
   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,
@@ -7411,6 +7431,7 @@ var init_job = __esm({
   "src/job.ts"() {
     "use strict";
     init_executor();
+    init_dutyFolders();
     init_registry();
     init_jobIdentity();
     init_jobIdentity();
@@ -7642,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, "-");
 }
@@ -7699,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();
@@ -7714,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 {
@@ -7743,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()}`;
@@ -7759,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);
@@ -7780,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() {
@@ -7938,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") {
@@ -7980,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 splitFrontmatter(raw);
-  } catch {
-    return { frontmatter: {}, body: "" };
-  }
-}
 function parseDutyFilter(raw) {
   return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
 }
@@ -7996,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}`,
@@ -8023,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);
@@ -8061,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) => {
@@ -8082,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);
@@ -8192,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 }
@@ -8211,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 {
@@ -8219,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 }
             );
@@ -9463,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) {
@@ -9539,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 {
@@ -9548,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 {
@@ -9559,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 {
@@ -9605,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;
@@ -9931,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")) {
@@ -9947,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) => {
@@ -9968,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 = splitFrontmatter(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`);
         }
@@ -10005,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) {
@@ -10059,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");
@@ -10090,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(
@@ -10098,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;
@@ -10119,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 {
@@ -10130,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}
@@ -10153,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";
@@ -10162,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 ?? "";
@@ -10177,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,
@@ -10192,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;
@@ -10284,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);
@@ -10318,7 +10246,7 @@ function stripDirective(body) {
   return lines.slice(start).join("\n").trim();
 }
 function parsePersona(raw, slug) {
-  const stripped = splitFrontmatter(raw).body;
+  const stripped = stripLeadingFrontmatter(raw);
   const trimmed = stripped.trim();
   const firstLine2 = trimmed.split("\n", 1)[0] ?? "";
   const h1 = /^#\s+(.+?)\s*$/.exec(firstLine2);
@@ -10326,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}`);
       }
@@ -12217,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();
@@ -12481,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 {
@@ -12587,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",
@@ -12635,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) => {
@@ -12649,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 } = splitFrontmatter(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}`;
@@ -13862,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();
@@ -13870,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;
@@ -13986,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 ?? "");
 }
@@ -14137,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);
@@ -14184,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,
@@ -14469,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) {
@@ -14577,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;
@@ -14834,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",
@@ -14861,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 = [];
@@ -14878,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.]`;
@@ -14898,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) {
@@ -14909,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)}
 `);
   }
 };
@@ -14964,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 {
@@ -14984,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")) {
@@ -15001,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) {
@@ -15127,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() });
@@ -15295,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 "";
   }
@@ -15316,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}`);
@@ -15349,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 "";
   }
@@ -15376,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";
@@ -15453,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 = [
@@ -15571,10 +15500,10 @@ function autoDispatch(opts) {
   }
   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;
   }
@@ -15685,7 +15614,7 @@ function autoDispatchTyped(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") {
@@ -15693,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" };
   }
@@ -15737,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;
     }
@@ -15980,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) {
@@ -16069,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)) {
@@ -16098,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 {
@@ -16409,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);
@@ -16455,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 };
@@ -16730,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,
@@ -16777,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" });
@@ -17371,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";
@@ -17536,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) {
@@ -17550,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);
   }
 }
@@ -17688,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 {
@@ -17737,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) {
@@ -17946,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}`,
@@ -17958,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();