@kody-ade/kody-engine 0.4.223 → 0.4.225

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.223",
+      version: "0.4.225",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -205,6 +205,7 @@ function loadConfig(projectDir = process.cwd()) {
     agent: {
       model: String(agent.model),
       ...parsePerExecutable(agent.perExecutable),
+      ...parsePerExecutableReasoningEffort(agent.perExecutableReasoningEffort),
       ...parseAgentReasoningEffort(agent.reasoningEffort)
     },
     issueContext: parseIssueContext(raw.issueContext),
@@ -216,6 +217,7 @@ function loadConfig(projectDir = process.cwd()) {
     classify: parseClassifyConfig(raw.classify),
     release: parseReleaseConfig(raw.release),
     jobs: parseJobsConfig(raw.jobs),
+    company: parseCompanyConfig(raw.company),
     access: parseAccessConfig(raw.access)
   };
 }
@@ -262,6 +264,28 @@ function parseJobsConfig(raw) {
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
+function parseCompanyConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  if (r.activeDuties !== void 0) out.activeDuties = parseSlugArray(r.activeDuties, "company.activeDuties");
+  if (r.activeGoals !== void 0) out.activeGoals = parseSlugArray(r.activeGoals, "company.activeGoals");
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseSlugArray(raw, field) {
+  if (!Array.isArray(raw)) throw new Error(`kody.config.json: ${field} must be an array of strings`);
+  const out = [];
+  for (const value of raw) {
+    if (typeof value !== "string") throw new Error(`kody.config.json: ${field} entries must be strings`);
+    const slug = value.trim();
+    if (!slug) continue;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(slug)) {
+      throw new Error(`kody.config.json: ${field} contains invalid slug "${value}"`);
+    }
+    out.push(slug);
+  }
+  return [...new Set(out)];
+}
 function recordValue(raw) {
   return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
 }
@@ -282,6 +306,15 @@ function parsePerExecutable(raw) {
   }
   return Object.keys(out).length > 0 ? { perExecutable: out } : {};
 }
+function parsePerExecutableReasoningEffort(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const effort = typeof v === "string" ? parseReasoningEffort(v) : null;
+    if (effort) out[k] = effort;
+  }
+  return Object.keys(out).length > 0 ? { perExecutableReasoningEffort: out } : {};
+}
 function parseAgentReasoningEffort(raw) {
   if (typeof raw !== "string") return {};
   return { reasoningEffort: parseReasoningEffort(raw) ?? void 0 };
@@ -562,7 +595,7 @@ var init_events = __esm({
 // src/verify.ts
 import { spawn } from "child_process";
 function runCommand(command, cwd) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const start = Date.now();
     const child = spawn(command, {
       cwd,
@@ -591,11 +624,11 @@ function runCommand(command, cwd) {
     child.on("exit", (code) => {
       clearTimeout(timer);
       const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve6({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      resolve7({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve6({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      resolve7({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
     });
   });
 }
@@ -1450,7 +1483,7 @@ var init_dutyMcp = __esm({
     TRUST_STATE_BRANCH = "kody-state";
     THREAD_BODY_MAX = 4e3;
     CHECK_FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "STARTUP_FAILURE", "ACTION_REQUIRED"]);
-    DEFAULT_IGNORE_CHECKS = ["run", "kody", "duty-tick", "goal-tick", "worker-ask", "chat"];
+    DEFAULT_IGNORE_CHECKS = ["run", "kody", "duty-tick", "worker-ask", "chat"];
     trackMarker = (key) => `<!-- kody-track:${key} -->`;
     commentMarker = (key) => `<!-- kody-track-comment:${key} -->`;
     GATE_EXEMPT_DUTIES = /* @__PURE__ */ new Set(["qa-engineer", "ui-review"]);
@@ -1513,7 +1546,7 @@ var init_repoWorkspace = __esm({
     defaultCloneRepo = (repo, token, dir) => {
       fs4.mkdirSync(path4.dirname(dir), { recursive: true });
       const authUrl = token ? `https://x-access-token:${token}@github.com/${repo}.git` : `https://github.com/${repo}.git`;
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const child = spawn2("git", ["clone", "--depth=1", authUrl, dir], {
           stdio: "inherit"
         });
@@ -1529,7 +1562,7 @@ var init_repoWorkspace = __esm({
             spawnSync("git", ["-C", dir, "config", "user.email", email]);
           } catch {
           }
-          resolve6();
+          resolve7();
         });
         child.on("error", reject);
       });
@@ -1614,6 +1647,10 @@ function classifySubtype(subtype) {
   if (lower.includes("error")) return "model_error";
   return "generic_failed";
 }
+function isClaudeLoginRequiredText(text) {
+  const normalized = text.toLowerCase();
+  return normalized.includes("not logged in") && normalized.includes("/login");
+}
 function resolveTurnTimeoutMs(opts) {
   if (opts.maxTurnTimeoutMs !== void 0 && opts.maxTurnTimeoutMs !== null) {
     return opts.maxTurnTimeoutMs > 0 ? opts.maxTurnTimeoutMs : 0;
@@ -1696,6 +1733,7 @@ async function runAgent(opts) {
     messageCount = 0;
     let sawMutatingTool = false;
     let sawTerminalSuccess = false;
+    let sawLoginRequired = false;
     let noWorkSuccess = false;
     try {
       const queryOptions = {
@@ -1809,10 +1847,10 @@ async function runAgent(opts) {
         let timer;
         let next;
         if (turnTimeoutMs > 0) {
-          const timeoutPromise = new Promise((resolve6) => {
+          const timeoutPromise = new Promise((resolve7) => {
             timer = setTimeout(() => {
               timedOut = true;
-              resolve6({ done: true, value: void 0 });
+              resolve7({ done: true, value: void 0 });
             }, turnTimeoutMs);
           });
           next = await Promise.race([nextPromise, timeoutPromise]);
@@ -1845,8 +1883,11 @@ async function runAgent(opts) {
           }
         }
         const line = renderEvent(msg, { verbose: opts.verbose, quiet: opts.quiet });
-        if (line) process.stdout.write(`${line}
+        if (line) {
+          if (isClaudeLoginRequiredText(line)) sawLoginRequired = true;
+          process.stdout.write(`${line}
 `);
+        }
         const m = msg;
         if (opts.onProgress) {
           const blocks = m.message?.content ?? [];
@@ -1919,6 +1960,7 @@ async function runAgent(opts) {
             outcomeKind = "ok";
             sawTerminalSuccess = true;
             const text = (typeof m.result === "string" ? m.result : "").trim();
+            if (isClaudeLoginRequiredText(text)) sawLoginRequired = true;
             if (text) resultTexts.push(text);
           } else {
             outcome = "failed";
@@ -1948,6 +1990,11 @@ async function runAgent(opts) {
       );
     }
     finalText = resultTexts.join("\n\n---\n\n");
+    if (outcome === "completed" && sawLoginRequired) {
+      outcome = "failed";
+      outcomeKind = "model_error";
+      errorMessage = "Claude Code reported it is not logged in; refusing to mark agent run successful";
+    }
     if (outcome === "completed" && !sawMutatingTool) {
       const backendDead = opts.isBackendHealthy ? !await opts.isBackendHealthy() : false;
       const zeroOutput = tokens.output === 0 && finalText === "";
@@ -2011,6 +2058,107 @@ var init_agent = __esm({
   }
 });
 
+// src/companyStore.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as crypto2 from "crypto";
+import * as fs6 from "fs";
+import * as os2 from "os";
+import * as path6 from "path";
+function getCompanyStoreRoot() {
+  const store = resolveCompanyStore();
+  if (!store) return null;
+  const key = `${store.repo}#${store.ref}`;
+  if (memo?.key === key) return memo.root;
+  const root = fetchCompanyStore(store.repo, store.ref);
+  memo = { key, root };
+  return root;
+}
+function getCompanyStoreAssetRoot(kind) {
+  const root = getCompanyStoreRoot();
+  if (!root) return null;
+  return path6.join(root, ".kody", kind);
+}
+function resolveCompanyStore() {
+  const envStore = process.env[STORE_ENV]?.trim();
+  if (!envStore && process.env.VITEST) return null;
+  const repo = envStore || DEFAULT_COMPANY_STORE;
+  if (repo === "0" || repo === "false" || repo === "off") return null;
+  const ref = process.env[REF_ENV]?.trim() || DEFAULT_COMPANY_STORE_REF;
+  if (!ref) return null;
+  return { repo, ref };
+}
+function fetchCompanyStore(repo, ref) {
+  const localRoot = localStoreRoot(repo);
+  if (localRoot) return localRoot;
+  const url = repoToGitUrl(repo);
+  const cacheDir = path6.join(cacheRoot(), cacheKey(repo, ref));
+  try {
+    if (isGitHubShorthand(repo)) setupGithubGitAuth();
+    fs6.mkdirSync(path6.dirname(cacheDir), { recursive: true });
+    if (!fs6.existsSync(path6.join(cacheDir, ".git"))) {
+      fs6.rmSync(cacheDir, { recursive: true, force: true });
+      runGit(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
+    }
+    runGit(["-C", cacheDir, "remote", "set-url", "origin", url]);
+    runGit(["-C", cacheDir, "fetch", "--depth=1", "origin", ref]);
+    runGit(["-C", cacheDir, "checkout", "--detach", "FETCH_HEAD"]);
+    return cacheDir;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[company-store] failed to fetch ${repo}#${ref}: ${msg}
+`);
+    return null;
+  }
+}
+function localStoreRoot(repo) {
+  if (!path6.isAbsolute(repo) && !repo.startsWith(".")) return null;
+  const root = path6.resolve(repo);
+  if (!fs6.existsSync(path6.join(root, ".kody"))) return null;
+  return root;
+}
+function repoToGitUrl(repo) {
+  if (/^(https?:|ssh:|git@|file:)/.test(repo)) return repo;
+  if (isGitHubShorthand(repo)) {
+    return `https://github.com/${repo}.git`;
+  }
+  return repo;
+}
+function isGitHubShorthand(repo) {
+  return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo);
+}
+function cacheRoot() {
+  return process.env[CACHE_ENV]?.trim() || path6.join(os2.homedir(), ".cache", "kody", "company-store");
+}
+function cacheKey(repo, ref) {
+  return crypto2.createHash("sha256").update(`${repo}#${ref}`).digest("hex").slice(0, 24);
+}
+function runGit(args) {
+  execFileSync2("git", args, { stdio: ["ignore", "ignore", "pipe"] });
+}
+function setupGithubGitAuth() {
+  const token = process.env.KODY_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_PAT;
+  if (!token) return;
+  try {
+    execFileSync2("gh", ["auth", "setup-git", "--hostname", "github.com"], {
+      env: { ...process.env, GH_TOKEN: token },
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+  } catch {
+  }
+}
+var DEFAULT_COMPANY_STORE, DEFAULT_COMPANY_STORE_REF, STORE_ENV, REF_ENV, CACHE_ENV, memo;
+var init_companyStore = __esm({
+  "src/companyStore.ts"() {
+    "use strict";
+    DEFAULT_COMPANY_STORE = "aharonyaircohen/kody-company-store";
+    DEFAULT_COMPANY_STORE_REF = "stable";
+    STORE_ENV = "KODY_COMPANY_STORE";
+    REF_ENV = "KODY_COMPANY_STORE_REF";
+    CACHE_ENV = "KODY_COMPANY_STORE_CACHE";
+    memo = null;
+  }
+});
+
 // src/scripts/scheduleEvery.ts
 function isScheduleEvery(value) {
   return typeof value === "string" && SCHEDULE_EVERY_VALUES.includes(value);
@@ -2062,30 +2210,30 @@ var init_scheduleEvery = __esm({
 });
 
 // src/dutyFolders.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 function listDutyFolderSlugs(absDir) {
-  if (!fs6.existsSync(absDir)) return [];
+  if (!fs7.existsSync(absDir)) return [];
   let entries;
   try {
-    entries = fs6.readdirSync(absDir, { withFileTypes: true });
+    entries = fs7.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();
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isDutyFolder(path7.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));
+  return fs7.existsSync(path7.join(dir, DUTY_PROFILE_FILE)) && fs7.existsSync(path7.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;
+  const dir = path7.join(root, slug);
+  const profilePath = path7.join(dir, DUTY_PROFILE_FILE);
+  const bodyPath = path7.join(dir, DUTY_BODY_FILE);
+  if (!fs7.existsSync(profilePath) || !fs7.statSync(profilePath).isFile()) return null;
+  if (!fs7.existsSync(bodyPath) || !fs7.statSync(bodyPath).isFile()) return null;
   try {
-    const rawProfile = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
-    const rawBody = fs6.readFileSync(bodyPath, "utf-8");
+    const rawProfile = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+    const rawBody = fs7.readFileSync(bodyPath, "utf-8");
     const { title, body } = parseDutyBody(rawBody, slug);
     return {
       slug,
@@ -2164,70 +2312,76 @@ var init_dutyFolders = __esm({
 });
 
 // src/registry.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 function getExecutablesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path8.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "executables"),
+    path8.join(here, "executables"),
     // dev: src/
-    path7.join(here, "..", "executables"),
+    path8.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path7.join(here, "..", "src", "executables")
+    path8.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getProjectExecutablesRoot() {
-  return path7.join(process.cwd(), ".kody", "executables");
+  return path8.join(process.cwd(), ".kody", "executables");
 }
 function getProjectDutiesRoot() {
-  return path7.join(process.cwd(), ".kody", "duties");
+  return path8.join(process.cwd(), ".kody", "duties");
+}
+function getCompanyStoreExecutablesRoot() {
+  return getCompanyStoreAssetRoot("executables");
+}
+function getCompanyStoreDutiesRoot() {
+  return getCompanyStoreAssetRoot("duties");
 }
 function getBuiltinJobsRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path8.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "jobs"),
+    path8.join(here, "jobs"),
     // dev: src/
-    path7.join(here, "..", "jobs"),
+    path8.join(here, "..", "jobs"),
     // built: dist/bin → dist/jobs
-    path7.join(here, "..", "src", "jobs")
+    path8.join(here, "..", "src", "jobs")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function getBuiltinDutiesRoot() {
-  const here = path7.dirname(new URL(import.meta.url).pathname);
+  const here = path8.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path7.join(here, "duties"),
+    path8.join(here, "duties"),
     // dev: src/
-    path7.join(here, "..", "duties"),
+    path8.join(here, "..", "duties"),
     // built: dist/bin → dist/duties
-    path7.join(here, "..", "src", "duties")
+    path8.join(here, "..", "src", "duties")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs7.existsSync(c) && fs7.statSync(c).isDirectory()) return c;
+    if (fs8.existsSync(c) && fs8.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listBuiltinJobs(root = getBuiltinJobsRoot()) {
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
-  for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
+  for (const ent of fs8.readdirSync(root, { withFileTypes: true })) {
     if (ent.name.startsWith("_") || ent.name.startsWith(".")) continue;
-    const full = path7.join(root, ent.name);
+    const full = path8.join(root, ent.name);
     if (ent.isDirectory()) {
-      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;
+      const profilePath = path8.join(full, DUTY_PROFILE_FILE);
+      const bodyPath = path8.join(full, DUTY_BODY_FILE);
+      if (!fs8.existsSync(profilePath) || !fs8.statSync(profilePath).isFile()) continue;
+      if (!fs8.existsSync(bodyPath) || !fs8.statSync(bodyPath).isFile()) continue;
       out.push({ slug: ent.name, dir: full, profilePath, bodyPath });
     }
   }
@@ -2235,20 +2389,25 @@ function listBuiltinJobs(root = getBuiltinJobsRoot()) {
   return out;
 }
 function getExecutableRoots() {
-  return [getProjectExecutablesRoot(), getExecutablesRoot()];
+  const storeRoot = getCompanyStoreExecutablesRoot();
+  return [getProjectExecutablesRoot(), ...storeRoot ? [storeRoot] : [], getExecutablesRoot()];
+}
+function getDutyRoots(projectDutiesRoot = getProjectDutiesRoot()) {
+  const storeRoot = getCompanyStoreDutiesRoot();
+  return [projectDutiesRoot, ...storeRoot ? [storeRoot] : [], getBuiltinDutiesRoot()];
 }
 function listExecutables(roots = getExecutableRoots()) {
   const rootList = typeof roots === "string" ? [roots] : roots;
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const root of rootList) {
-    if (!fs7.existsSync(root)) continue;
-    const entries = fs7.readdirSync(root, { withFileTypes: true });
+    if (!fs8.existsSync(root)) continue;
+    const entries = fs8.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
-      const profilePath = path7.join(root, ent.name, DUTY_PROFILE_FILE);
-      if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
+      const profilePath = path8.join(root, ent.name, DUTY_PROFILE_FILE);
+      if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile()) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -2260,8 +2419,8 @@ function resolveExecutable(name, roots = getExecutableRoots()) {
   if (!isSafeName(name)) return null;
   const rootList = typeof roots === "string" ? [roots] : roots;
   for (const root of rootList) {
-    const profilePath = path7.join(root, name, "profile.json");
-    if (fs7.existsSync(profilePath) && fs7.statSync(profilePath).isFile()) {
+    const profilePath = path8.join(root, name, "profile.json");
+    if (fs8.existsSync(profilePath) && fs8.statSync(profilePath).isFile()) {
       return profilePath;
     }
   }
@@ -2276,8 +2435,14 @@ function listDutyActions(projectDutiesRoot = getProjectDutiesRoot()) {
     seen.add(action.action);
     out.push(action);
   };
-  for (const action of listProjectFolderDutyActions(projectDutiesRoot)) add(action);
-  for (const action of listBuiltinDutyActions()) add(action);
+  const roots = getDutyRoots(projectDutiesRoot);
+  for (const action of listFolderDutyActions(roots[0], "project-folder")) add(action);
+  if (roots.length === 3) {
+    for (const action of listFolderDutyActions(roots[1], "company-store")) add(action);
+    for (const action of listBuiltinDutyActions(roots[2])) add(action);
+  } else {
+    for (const action of listBuiltinDutyActions(roots[1])) add(action);
+  }
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
 function resolveDutyAction(action, projectDutiesRoot = getProjectDutiesRoot()) {
@@ -2287,11 +2452,19 @@ function resolveDutyAction(action, projectDutiesRoot = getProjectDutiesRoot()) {
 function hasDutyAction(action, projectDutiesRoot = getProjectDutiesRoot()) {
   return resolveDutyAction(action, projectDutiesRoot) !== null;
 }
+function resolveDutyFolder(slug, projectDutiesRoot = getProjectDutiesRoot()) {
+  if (!isSafeName(slug)) return null;
+  for (const root of getDutyRoots(projectDutiesRoot)) {
+    const duty = readDutyFolder(root, slug);
+    if (duty) return duty;
+  }
+  return null;
+}
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
-function listProjectFolderDutyActions(root) {
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+function listFolderDutyActions(root, source) {
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
   for (const slug of listDutyFolderSlugs(root)) {
     if (!isSafeName(slug)) continue;
@@ -2304,7 +2477,7 @@ function listProjectFolderDutyActions(root) {
       duty: slug,
       executable,
       cliArgs: duty.config.executable ? {} : { duty: slug },
-      source: "project-folder",
+      source,
       describe: duty.config.describe ?? duty.title,
       profilePath: duty.profilePath,
       bodyPath: duty.bodyPath
@@ -2313,7 +2486,7 @@ function listProjectFolderDutyActions(root) {
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
 function listBuiltinDutyActions(root = getBuiltinDutiesRoot()) {
-  if (!fs7.existsSync(root) || !fs7.statSync(root).isDirectory()) return [];
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) return [];
   const out = [];
   for (const slug of listDutyFolderSlugs(root)) {
     if (!isSafeName(slug)) continue;
@@ -2338,7 +2511,7 @@ function getProfileInputs(name, roots = getExecutableRoots()) {
   const profilePath = resolveExecutable(name, roots);
   if (!profilePath) return null;
   try {
-    const raw = JSON.parse(fs7.readFileSync(profilePath, "utf-8"));
+    const raw = JSON.parse(fs8.readFileSync(profilePath, "utf-8"));
     if (!raw || typeof raw !== "object" || !Array.isArray(raw.inputs)) return [];
     return raw.inputs;
   } catch {
@@ -2373,26 +2546,27 @@ function parseGenericFlags(argv) {
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
+    init_companyStore();
     init_dutyFolders();
   }
 });
 
 // src/task-artifacts.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function prepareTaskArtifactsDir(cwd, taskId) {
   const safeId = String(taskId).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const relDir = path8.join(".kody", "tasks", safeId);
-  const absDir = path8.join(cwd, relDir);
-  fs8.mkdirSync(absDir, { recursive: true });
+  const relDir = path9.join(".kody", "tasks", safeId);
+  const absDir = path9.join(cwd, relDir);
+  fs9.mkdirSync(absDir, { recursive: true });
   return { taskId: safeId, absDir, relDir };
 }
 function verifyTaskArtifacts(absDir) {
   const missing = [];
   for (const name of TASK_ARTIFACT_FILES) {
-    const full = path8.join(absDir, name);
+    const full = path9.join(absDir, name);
     try {
-      const stat = fs8.statSync(full);
+      const stat = fs9.statSync(full);
       if (!stat.isFile() || stat.size === 0) missing.push(name);
     } catch {
       missing.push(name);
@@ -2467,8 +2641,8 @@ var init_task_artifacts = __esm({
 });
 
 // src/gha.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import * as fs14 from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import * as fs15 from "fs";
 function getRunUrl() {
   const server = process.env.GITHUB_SERVER_URL;
   const repo = process.env.GITHUB_REPOSITORY;
@@ -2479,10 +2653,10 @@ function getRunUrl() {
 function reactToTriggerComment(cwd) {
   if (process.env.GITHUB_EVENT_NAME !== "issue_comment") return;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs14.existsSync(eventPath)) return;
+  if (!eventPath || !fs15.existsSync(eventPath)) return;
   let event = null;
   try {
-    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs15.readFileSync(eventPath, "utf-8"));
   } catch {
     return;
   }
@@ -2510,7 +2684,7 @@ function reactToTriggerComment(cwd) {
   for (let attempt = 0; attempt < 3; attempt++) {
     if (attempt > 0) sleepMs(attempt === 1 ? 500 : 1500);
     try {
-      execFileSync2("gh", args, opts);
+      execFileSync3("gh", args, opts);
       return;
     } catch (err) {
       lastErr = err;
@@ -2523,7 +2697,7 @@ function reactToTriggerComment(cwd) {
 }
 function sleepMs(ms) {
   try {
-    execFileSync2("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
+    execFileSync3("sleep", [(ms / 1e3).toString()], { stdio: "ignore", timeout: ms + 1e3 });
   } catch {
   }
 }
@@ -2693,31 +2867,31 @@ var init_lifecycles = __esm({
 });
 
 // src/scripts/buildSyntheticPlugin.ts
-import * as fs15 from "fs";
-import * as os2 from "os";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as os3 from "os";
+import * as path14 from "path";
 function getPluginsCatalogRoot() {
-  const here = path13.dirname(new URL(import.meta.url).pathname);
+  const here = path14.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path13.join(here, "..", "plugins"),
+    path14.join(here, "..", "plugins"),
     // dev: src/scripts → src/plugins
-    path13.join(here, "..", "..", "plugins"),
+    path14.join(here, "..", "..", "plugins"),
     // built: dist/scripts → dist/plugins
-    path13.join(here, "..", "..", "src", "plugins")
+    path14.join(here, "..", "..", "src", "plugins")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) return c;
+    if (fs16.existsSync(c) && fs16.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function copyDir(src, dst) {
-  fs15.mkdirSync(dst, { recursive: true });
-  for (const ent of fs15.readdirSync(src, { withFileTypes: true })) {
-    const s = path13.join(src, ent.name);
-    const d = path13.join(dst, ent.name);
+  fs16.mkdirSync(dst, { recursive: true });
+  for (const ent of fs16.readdirSync(src, { withFileTypes: true })) {
+    const s = path14.join(src, ent.name);
+    const d = path14.join(dst, ent.name);
     if (ent.isDirectory()) copyDir(s, d);
-    else if (ent.isFile()) fs15.copyFileSync(s, d);
+    else if (ent.isFile()) fs16.copyFileSync(s, d);
   }
 }
 var buildSyntheticPlugin;
@@ -2730,45 +2904,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 = path13.join(os2.tmpdir(), `kody-synth-${runId}`);
-      fs15.mkdirSync(path13.join(root, ".claude-plugin"), { recursive: true });
+      const root = path14.join(os3.tmpdir(), `kody-synth-${runId}`);
+      fs16.mkdirSync(path14.join(root, ".claude-plugin"), { recursive: true });
       const resolvePart = (bucket, entry) => {
-        const local = path13.join(profile.dir, bucket, entry);
-        if (fs15.existsSync(local)) return local;
-        const central = path13.join(catalog, bucket, entry);
-        if (fs15.existsSync(central)) return central;
+        const local = path14.join(profile.dir, bucket, entry);
+        if (fs16.existsSync(local)) return local;
+        const central = path14.join(catalog, bucket, entry);
+        if (fs16.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 = path13.join(root, "skills");
-        fs15.mkdirSync(dst, { recursive: true });
+        const dst = path14.join(root, "skills");
+        fs16.mkdirSync(dst, { recursive: true });
         for (const name of cc.skills) {
-          copyDir(resolvePart("skills", name), path13.join(dst, name));
+          copyDir(resolvePart("skills", name), path14.join(dst, name));
         }
       }
       if (cc.commands.length > 0) {
-        const dst = path13.join(root, "commands");
-        fs15.mkdirSync(dst, { recursive: true });
+        const dst = path14.join(root, "commands");
+        fs16.mkdirSync(dst, { recursive: true });
         for (const name of cc.commands) {
-          fs15.copyFileSync(resolvePart("commands", `${name}.md`), path13.join(dst, `${name}.md`));
+          fs16.copyFileSync(resolvePart("commands", `${name}.md`), path14.join(dst, `${name}.md`));
         }
       }
       if (cc.hooks.length > 0) {
-        const dst = path13.join(root, "hooks");
-        fs15.mkdirSync(dst, { recursive: true });
+        const dst = path14.join(root, "hooks");
+        fs16.mkdirSync(dst, { recursive: true });
         const merged = { hooks: {} };
         for (const name of cc.hooks) {
           const src = resolvePart("hooks", `${name}.json`);
-          const parsed = JSON.parse(fs15.readFileSync(src, "utf-8"));
+          const parsed = JSON.parse(fs16.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);
           }
         }
-        fs15.writeFileSync(path13.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
+        fs16.writeFileSync(path14.join(dst, "hooks.json"), `${JSON.stringify(merged, null, 2)}
 `);
       }
       const manifest = {
@@ -2778,7 +2952,7 @@ var init_buildSyntheticPlugin = __esm({
       };
       if (cc.skills.length > 0) manifest.skills = ["./skills/"];
       if (cc.commands.length > 0) manifest.commands = ["./commands/"];
-      fs15.writeFileSync(path13.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
+      fs16.writeFileSync(path14.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       ctx.data.syntheticPluginPath = root;
     };
@@ -2786,8 +2960,8 @@ var init_buildSyntheticPlugin = __esm({
 });
 
 // src/subagents.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
+import * as fs17 from "fs";
+import * as path15 from "path";
 function splitFrontmatter(raw) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
   if (!match) return { fm: {}, body: raw.trim() };
@@ -2800,10 +2974,10 @@ function splitFrontmatter(raw) {
   return { fm, body: (match[2] ?? "").trim() };
 }
 function resolveAgentFile(profileDir, name) {
-  const local = path14.join(profileDir, "agents", `${name}.md`);
-  if (fs16.existsSync(local)) return local;
-  const central = path14.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
-  if (fs16.existsSync(central)) return central;
+  const local = path15.join(profileDir, "agents", `${name}.md`);
+  if (fs17.existsSync(local)) return local;
+  const central = path15.join(getPluginsCatalogRoot(), "agents", `${name}.md`);
+  if (fs17.existsSync(central)) return central;
   throw new Error(`loadSubagents: agent '${name}' not found in ${profileDir}/agents/ or shared catalog`);
 }
 function captureSubagentTemplates(profile) {
@@ -2812,7 +2986,7 @@ function captureSubagentTemplates(profile) {
   const out = {};
   for (const name of names) {
     try {
-      out[name] = fs16.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+      out[name] = fs17.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
     } catch {
     }
   }
@@ -2823,7 +2997,7 @@ function loadSubagents(profile) {
   if (!names || names.length === 0) return void 0;
   const agents = {};
   for (const name of names) {
-    const raw = profile.subagentTemplates?.[name] ?? fs16.readFileSync(resolveAgentFile(profile.dir, name), "utf-8");
+    const raw = profile.subagentTemplates?.[name] ?? fs17.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 = {
@@ -2847,15 +3021,15 @@ var init_subagents = __esm({
 });
 
 // src/profile.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
+import * as fs18 from "fs";
+import * as path16 from "path";
 function loadProfile(profilePath) {
-  if (!fs17.existsSync(profilePath)) {
+  if (!fs18.existsSync(profilePath)) {
     throw new ProfileError(profilePath, "file not found");
   }
   let raw;
   try {
-    raw = JSON.parse(fs17.readFileSync(profilePath, "utf-8"));
+    raw = JSON.parse(fs18.readFileSync(profilePath, "utf-8"));
   } catch (err) {
     throw new ProfileError(profilePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -2866,7 +3040,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] ${path15.basename(path15.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
+      `[kody profile] ${path16.basename(path16.dirname(profilePath))}: unknown top-level keys ignored: ${unknownKeys.join(", ")}
 `
     );
   }
@@ -2955,8 +3129,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: path15.dirname(profilePath),
-    promptTemplates: readPromptTemplates(path15.dirname(profilePath))
+    dir: path16.dirname(profilePath),
+    promptTemplates: readPromptTemplates(path16.dirname(profilePath))
   };
   if (lifecycle) {
     applyLifecycle(profile, profilePath);
@@ -2988,16 +3162,16 @@ function readPromptTemplates(dir) {
   const out = {};
   const read = (p) => {
     try {
-      out[p] = fs17.readFileSync(p, "utf-8");
+      out[p] = fs18.readFileSync(p, "utf-8");
     } catch {
     }
   };
-  read(path15.join(dir, "prompt.md"));
-  read(path15.join(dir, "duty.md"));
+  read(path16.join(dir, "prompt.md"));
+  read(path16.join(dir, "duty.md"));
   try {
-    const promptsDir = path15.join(dir, "prompts");
-    for (const ent of fs17.readdirSync(promptsDir)) {
-      if (ent.endsWith(".md")) read(path15.join(promptsDir, ent));
+    const promptsDir = path16.join(dir, "prompts");
+    for (const ent of fs18.readdirSync(promptsDir)) {
+      if (ent.endsWith(".md")) read(path16.join(promptsDir, ent));
     }
   } catch {
   }
@@ -3072,6 +3246,7 @@ function parseClaudeCode(p, raw) {
     permissionMode,
     maxTurns: typeof r.maxTurns === "number" ? r.maxTurns : null,
     maxThinkingTokens: typeof r.maxThinkingTokens === "number" ? r.maxThinkingTokens : null,
+    reasoningEffort: typeof r.reasoningEffort === "string" ? parseReasoningEffort(r.reasoningEffort) : null,
     maxTurnTimeoutSec: typeof r.maxTurnTimeoutSec === "number" ? r.maxTurnTimeoutSec : null,
     systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
     cacheable: r.cacheable === true,
@@ -3255,6 +3430,7 @@ var VALID_INPUT_TYPES, VALID_PERMISSION_MODES, VALID_ROLES, VALID_CONTAINER_CHIL
 var init_profile = __esm({
   "src/profile.ts"() {
     "use strict";
+    init_config();
     init_dutyMcp();
     init_lifecycles();
     init_profile_error();
@@ -3304,7 +3480,7 @@ var init_profile = __esm({
 });
 
 // src/state.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 function emptyState() {
   return {
     schemaVersion: 1,
@@ -3327,7 +3503,7 @@ function ghToken2() {
 function gh2(args, input, cwd) {
   const token = ghToken2();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync3("gh", args, {
+  return execFileSync4("gh", args, {
     encoding: "utf-8",
     timeout: API_TIMEOUT_MS2,
     cwd,
@@ -3674,16 +3850,16 @@ var init_state = __esm({
 });
 
 // src/prompt.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs19 from "fs";
+import * as path17 from "path";
 function loadProjectConventions(projectDir) {
   const out = [];
   for (const rel of CONVENTION_FILES) {
-    const abs = path16.join(projectDir, rel);
-    if (!fs18.existsSync(abs)) continue;
+    const abs = path17.join(projectDir, rel);
+    if (!fs19.existsSync(abs)) continue;
     let content;
     try {
-      content = fs18.readFileSync(abs, "utf-8");
+      content = fs19.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -3918,28 +4094,28 @@ var loadMemoryContext_exports = {};
 __export(loadMemoryContext_exports, {
   loadMemoryContext: () => loadMemoryContext
 });
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 function collectPages(memoryAbs) {
   const out = [];
   walkMd(memoryAbs, (file) => {
     let stat;
     try {
-      stat = fs19.statSync(file);
+      stat = fs20.statSync(file);
     } catch {
       return;
     }
     let raw;
     try {
-      raw = fs19.readFileSync(file, "utf-8");
+      raw = fs20.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() ?? path17.basename(file, ".md");
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path18.basename(file, ".md");
     const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
     out.push({
-      relPath: path17.relative(memoryAbs, file),
+      relPath: path18.relative(memoryAbs, file),
       title,
       updated,
       content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
@@ -4007,16 +4183,16 @@ function walkMd(root, visit) {
     const dir = stack.pop();
     let names;
     try {
-      names = fs19.readdirSync(dir);
+      names = fs20.readdirSync(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.startsWith(".")) continue;
-      const full = path17.join(dir, name);
+      const full = path18.join(dir, name);
       let stat;
       try {
-        stat = fs19.statSync(full);
+        stat = fs20.statSync(full);
       } catch {
         continue;
       }
@@ -4039,8 +4215,8 @@ var init_loadMemoryContext = __esm({
     TRUNCATED_SUFFIX2 = "\n\n\u2026 (truncated)";
     loadMemoryContext = async (ctx) => {
       if (typeof ctx.data.memoryContext === "string") return;
-      const memoryAbs = path17.join(ctx.cwd, MEMORY_DIR_RELATIVE);
-      if (!fs19.existsSync(memoryAbs)) {
+      const memoryAbs = path18.join(ctx.cwd, MEMORY_DIR_RELATIVE);
+      if (!fs20.existsSync(memoryAbs)) {
         ctx.data.memoryContext = "";
         return;
       }
@@ -4083,12 +4259,12 @@ var init_loadCoverageRules = __esm({
 });
 
 // src/container.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import * as fs20 from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
+import * as fs21 from "fs";
 function getProfileInputsForChild(profileName, _cwd) {
   try {
     const profilePath = resolveProfilePath(profileName);
-    if (!fs20.existsSync(profilePath)) return null;
+    if (!fs21.existsSync(profilePath)) return null;
     return loadProfile(profilePath).inputs;
   } catch {
     return null;
@@ -4322,7 +4498,7 @@ async function runContainerLoop(profile, ctx, input) {
 }
 function resetWorkingTree(cwd) {
   try {
-    execFileSync4("git", ["reset", "--hard", "HEAD"], {
+    execFileSync5("git", ["reset", "--hard", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -4421,6 +4597,91 @@ here \u2014 never substitute it for the truth.`;
   }
 });
 
+// src/dutyReport.ts
+function parseDutyReportsFromText(text) {
+  const reports = [];
+  for (const match of text.matchAll(REPORT_LINE)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      const parsed = parseDutyReport(JSON.parse(raw));
+      if (parsed) reports.push(parsed);
+    } catch {
+    }
+  }
+  return reports;
+}
+function parseDutyReport(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw;
+  const target = parseTarget(obj.target);
+  if (!target) return null;
+  const evidence = parseBooleanRecord(obj.evidence);
+  const facts = parseFacts(obj.facts);
+  if (!evidence && !facts) return null;
+  return {
+    target,
+    ...evidence ? { evidence } : {},
+    ...facts ? { facts } : {}
+  };
+}
+function applyDutyReportToGoalState(state, report) {
+  const priorFacts = parseFacts(state.extra.facts) ?? {};
+  const nextFacts = { ...priorFacts };
+  for (const [key, value] of Object.entries(report.facts ?? {})) {
+    if (CONTROL_FACT_KEYS.has(key)) continue;
+    nextFacts[key] = value;
+  }
+  for (const [key, value] of Object.entries(report.evidence ?? {})) {
+    nextFacts[key] = value;
+  }
+  const pending = nextFacts.pendingEvidence;
+  if (typeof pending === "string" && Object.hasOwn(report.evidence ?? {}, pending)) {
+    delete nextFacts.pendingEvidence;
+  }
+  return {
+    ...state,
+    extra: {
+      ...state.extra,
+      facts: nextFacts
+    }
+  };
+}
+function parseTarget(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const target = raw;
+  if (target.type !== "goal" && target.type !== "task" && target.type !== "duty") return null;
+  if (typeof target.id !== "string" || target.id.trim().length === 0) return null;
+  return { type: target.type, id: target.id.trim() };
+}
+function parseBooleanRecord(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof key !== "string" || key.length === 0 || typeof value !== "boolean") return null;
+    out[key] = value;
+  }
+  return out;
+}
+function parseFacts(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof key !== "string" || key.length === 0) return null;
+    if (CONTROL_FACT_KEYS.has(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+var REPORT_LINE, CONTROL_FACT_KEYS;
+var init_dutyReport = __esm({
+  "src/dutyReport.ts"() {
+    "use strict";
+    REPORT_LINE = /^KODY_DUTY_REPORT=(.+)$/gm;
+    CONTROL_FACT_KEYS = /* @__PURE__ */ new Set(["blockers", "destination", "duties", "route", "stage", "state"]);
+  }
+});
+
 // src/lifecycleLabels.ts
 function groupOf(label) {
   const idx = label.indexOf(":");
@@ -4549,10 +4810,10 @@ var init_lifecycleLabels = __esm({
 });
 
 // src/litellm.ts
-import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
-import * as fs21 from "fs";
-import * as os3 from "os";
-import * as path18 from "path";
+import { execFileSync as execFileSync6, spawn as spawn3 } from "child_process";
+import * as fs22 from "fs";
+import * as os4 from "os";
+import * as path19 from "path";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -4582,7 +4843,7 @@ function generateLitellmConfigYaml(model) {
 }
 function litellmImportable() {
   try {
-    execFileSync5("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+    execFileSync6("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -4590,7 +4851,7 @@ function litellmImportable() {
 }
 function locateLitellmScript() {
   try {
-    const out = execFileSync5(
+    const out = execFileSync6(
       "python3",
       [
         "-c",
@@ -4605,7 +4866,7 @@ function locateLitellmScript() {
 }
 function resolveLitellmCommand() {
   try {
-    execFileSync5("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync6("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     return "litellm";
   } catch {
     if (!litellmImportable()) {
@@ -4613,7 +4874,7 @@ function resolveLitellmCommand() {
       let installed = false;
       for (const pip of ["pip", "pip3"]) {
         try {
-          execFileSync5(pip, ["install", "litellm[proxy]"], { timeout: 3e5, stdio: "inherit" });
+          execFileSync6(pip, ["install", "litellm[proxy]"], { timeout: 3e5, stdio: "inherit" });
           installed = true;
           break;
         } catch {
@@ -4637,13 +4898,13 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   let child;
   let logPath;
   const spawnProxy = () => {
-    const configPath = path18.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
-    fs21.writeFileSync(configPath, generateLitellmConfigYaml(model));
+    const configPath = path19.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.yaml`);
+    fs22.writeFileSync(configPath, generateLitellmConfigYaml(model));
     const args = ["--config", configPath, "--port", port];
-    const nextLogPath = path18.join(os3.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
-    const outFd = fs21.openSync(nextLogPath, "w");
+    const nextLogPath = path19.join(os4.tmpdir(), `kody-local-litellm-${Date.now()}.log`);
+    const outFd = fs22.openSync(nextLogPath, "w");
     child = spawn3(cmd, args, { stdio: ["ignore", outFd, outFd], detached: true, env: childEnv });
-    fs21.closeSync(outFd);
+    fs22.closeSync(outFd);
     logPath = nextLogPath;
   };
   const waitForHealth = async () => {
@@ -4657,7 +4918,7 @@ async function startLitellmIfNeeded(model, projectDir, url = LITELLM_DEFAULT_URL
   const readLogTail = () => {
     if (!logPath) return "";
     try {
-      return fs21.readFileSync(logPath, "utf-8").slice(-2e3);
+      return fs22.readFileSync(logPath, "utf-8").slice(-2e3);
     } catch {
       return "";
     }
@@ -4709,10 +4970,10 @@ ${tail}`
   return { url, kill: killChild, isHealthy, ensureHealthy };
 }
 function readDotenvApiKeys(projectDir) {
-  const dotenvPath = path18.join(projectDir, ".env");
-  if (!fs21.existsSync(dotenvPath)) return {};
+  const dotenvPath = path19.join(projectDir, ".env");
+  if (!fs22.existsSync(dotenvPath)) return {};
   const result = {};
-  for (const rawLine of fs21.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  for (const rawLine of fs22.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)=(.*)$/);
@@ -4744,14 +5005,14 @@ var init_litellm = __esm({
 });
 
 // src/pushWithRetry.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 function sleepSync(ms) {
   if (ms <= 0) return;
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function runGit(args, cwd) {
+function runGit2(args, cwd) {
   try {
-    const stdout = execFileSync6("git", args, {
+    const stdout = execFileSync7("git", args, {
       cwd,
       encoding: "utf-8",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -4767,7 +5028,7 @@ function runGit(args, cwd) {
 }
 function resolveBranch(cwd, explicit) {
   if (explicit?.trim()) return explicit.trim();
-  const r = runGit(["symbolic-ref", "--short", "HEAD"], cwd);
+  const r = runGit2(["symbolic-ref", "--short", "HEAD"], cwd);
   return r.ok ? r.stdout.trim() : "";
 }
 function pushWithRetry(opts = {}) {
@@ -4781,14 +5042,14 @@ function pushWithRetry(opts = {}) {
   const pushArgs = opts.setUpstream ? ["push", "-u", "origin", `HEAD:${branch}`] : ["push", "origin", "HEAD"];
   let lastError = "";
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    const push = runGit(pushArgs, cwd);
+    const push = runGit2(pushArgs, cwd);
     if (push.ok) return { ok: true, attempts: attempt };
     lastError = push.stderr || push.stdout || "(no error detail)";
     if (!NON_FAST_FORWARD_RE.test(lastError)) {
       return { ok: false, reason: `push failed (not retryable): ${lastError.trim().slice(-400)}`, attempts: attempt };
     }
     if (attempt === maxRetries) break;
-    const fetch2 = runGit(["fetch", "origin", branch], cwd);
+    const fetch2 = runGit2(["fetch", "origin", branch], cwd);
     if (!fetch2.ok) {
       return {
         ok: false,
@@ -4796,9 +5057,9 @@ function pushWithRetry(opts = {}) {
         attempts: attempt
       };
     }
-    const rebase = runGit(["rebase", "--rebase-merges", `origin/${branch}`], cwd);
+    const rebase = runGit2(["rebase", "--rebase-merges", `origin/${branch}`], cwd);
     if (!rebase.ok) {
-      runGit(["rebase", "--abort"], cwd);
+      runGit2(["rebase", "--abort"], cwd);
       return {
         ok: false,
         reason: `rebase onto origin/${branch} failed (conflict?): ${(rebase.stderr || rebase.stdout).trim().slice(-400)}`,
@@ -4826,12 +5087,12 @@ var init_pushWithRetry = __esm({
 });
 
 // src/commit.ts
-import { execFileSync as execFileSync7 } from "child_process";
-import * as fs22 from "fs";
-import * as path19 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
+import * as fs23 from "fs";
+import * as path20 from "path";
 function git(args, cwd) {
   try {
-    return execFileSync7("git", args, {
+    return execFileSync8("git", args, {
       encoding: "utf-8",
       timeout: 12e4,
       cwd,
@@ -4866,18 +5127,18 @@ function ensureGitIdentity(cwd) {
 }
 function abortUnfinishedGitOps(cwd) {
   const aborted = [];
-  const gitDir = path19.join(cwd ?? process.cwd(), ".git");
-  if (!fs22.existsSync(gitDir)) return aborted;
-  if (fs22.existsSync(path19.join(gitDir, "MERGE_HEAD"))) {
+  const gitDir = path20.join(cwd ?? process.cwd(), ".git");
+  if (!fs23.existsSync(gitDir)) return aborted;
+  if (fs23.existsSync(path20.join(gitDir, "MERGE_HEAD"))) {
     if (tryGit(["merge", "--abort"], cwd)) aborted.push("merge");
   }
-  if (fs22.existsSync(path19.join(gitDir, "CHERRY_PICK_HEAD"))) {
+  if (fs23.existsSync(path20.join(gitDir, "CHERRY_PICK_HEAD"))) {
     if (tryGit(["cherry-pick", "--abort"], cwd)) aborted.push("cherry-pick");
   }
-  if (fs22.existsSync(path19.join(gitDir, "REVERT_HEAD"))) {
+  if (fs23.existsSync(path20.join(gitDir, "REVERT_HEAD"))) {
     if (tryGit(["revert", "--abort"], cwd)) aborted.push("revert");
   }
-  if (fs22.existsSync(path19.join(gitDir, "rebase-merge")) || fs22.existsSync(path19.join(gitDir, "rebase-apply"))) {
+  if (fs23.existsSync(path20.join(gitDir, "rebase-merge")) || fs23.existsSync(path20.join(gitDir, "rebase-apply"))) {
     if (tryGit(["rebase", "--abort"], cwd)) aborted.push("rebase");
   }
   try {
@@ -4898,7 +5159,7 @@ function isForbiddenPath(p) {
   return false;
 }
 function listChangedFiles(cwd) {
-  const raw = execFileSync7("git", ["status", "--porcelain=v1", "-z"], {
+  const raw = execFileSync8("git", ["status", "--porcelain=v1", "-z"], {
     encoding: "utf-8",
     cwd,
     env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -4910,7 +5171,7 @@ function listChangedFiles(cwd) {
 }
 function listFilesInCommit(ref = "HEAD", cwd) {
   try {
-    const raw = execFileSync7("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
+    const raw = execFileSync8("git", ["show", "--name-only", "--pretty=format:", "-z", ref], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
@@ -4933,7 +5194,7 @@ function normalizeCommitMessage(raw) {
 function commitAndPush(branch, agentMessage, cwd) {
   const allChanged = listChangedFiles(cwd);
   const allowedFiles = allChanged.filter((f) => !isForbiddenPath(f));
-  const mergeHeadExists = fs22.existsSync(path19.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
+  const mergeHeadExists = fs23.existsSync(path20.join(cwd ?? process.cwd(), ".git", "MERGE_HEAD"));
   if (allowedFiles.length === 0 && !mergeHeadExists) {
     return { committed: false, pushed: false, sha: "", message: "" };
   }
@@ -5089,10 +5350,10 @@ var init_saveTaskState = __esm({
 });
 
 // src/scripts/advanceFlow.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 function ghComment(issueNumber, body, cwd, label) {
   try {
-    execFileSync8("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync9("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       timeout: API_TIMEOUT_MS3,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5168,6 +5429,291 @@ var init_advanceFlow = __esm({
   }
 });
 
+// src/goal/manager.ts
+function evidenceSatisfied(goal, evidence) {
+  return goal.facts[evidence] === true;
+}
+function firstMissingEvidence(goal) {
+  return goal.destination.evidence.find((evidence) => !evidenceSatisfied(goal, evidence));
+}
+function pushBlocker(goal, reason) {
+  if (!goal.blockers.includes(reason)) goal.blockers.push(reason);
+}
+function isSimpleGoal(goal) {
+  return goal.type === SIMPLE_GOAL_TYPE;
+}
+function applySimpleGoalTaskSummary(goal, summary) {
+  goal.facts.simpleAttachedTaskCount = summary.total;
+  goal.facts.simpleOpenTaskCount = summary.open;
+  goal.facts[SIMPLE_GOAL_EVIDENCE] = summary.total > 0 && summary.open === 0;
+}
+function isFactReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return Object.keys(record).length === 1 && typeof record.fact === "string" && record.fact.length > 0;
+}
+function isCliArgValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function resolveRouteArgs(goal, step) {
+  const cliArgs = {};
+  for (const [name, value] of Object.entries(step.args ?? {})) {
+    if (!isFactReference(value)) {
+      cliArgs[name] = value;
+      continue;
+    }
+    const factValue = goal.facts[value.fact];
+    if (factValue === void 0 || factValue === null) {
+      return { ok: false, reason: `route arg ${name} needs missing fact ${value.fact}` };
+    }
+    if (!isCliArgValue(factValue)) {
+      return { ok: false, reason: `route arg ${name} needs scalar fact ${value.fact}` };
+    }
+    cliArgs[name] = factValue;
+  }
+  return { ok: true, cliArgs };
+}
+function planManagedGoalTick(goal) {
+  goal.blockers = [];
+  const missing = firstMissingEvidence(goal);
+  if (!missing) {
+    goal.stage = "done";
+    delete goal.facts.pendingEvidence;
+    return { kind: "done" };
+  }
+  const pending = goal.facts.pendingEvidence;
+  if (pending === missing) {
+    const stage = typeof goal.stage === "string" ? goal.stage : "waiting";
+    return { kind: "wait", evidence: missing, stage, reason: `waiting for evidence: ${missing}` };
+  }
+  const step = goal.route.find((candidate) => candidate.evidence === missing);
+  if (!step) {
+    if (isSimpleGoal(goal) && missing === SIMPLE_GOAL_EVIDENCE) {
+      goal.stage = "waiting";
+      delete goal.facts.pendingEvidence;
+      const total = typeof goal.facts.simpleAttachedTaskCount === "number" ? goal.facts.simpleAttachedTaskCount : 0;
+      const open = typeof goal.facts.simpleOpenTaskCount === "number" ? goal.facts.simpleOpenTaskCount : 0;
+      return {
+        kind: "wait",
+        evidence: missing,
+        stage: "waiting",
+        reason: total === 0 ? "waiting for labelled tasks" : `waiting for ${open} open labelled task(s)`
+      };
+    }
+    const reason = `no route step for evidence: ${missing}`;
+    goal.stage = "blocked";
+    pushBlocker(goal, reason);
+    return { kind: "blocked", evidence: missing, stage: "blocked", reason };
+  }
+  if (!goal.duties.includes(step.duty)) {
+    const reason = `route duty ${step.duty} is not attached to this goal`;
+    goal.stage = "blocked";
+    pushBlocker(goal, reason);
+    return { kind: "blocked", evidence: missing, stage: step.stage, reason };
+  }
+  const resolved = resolveRouteArgs(goal, step);
+  if (!resolved.ok) {
+    goal.stage = "blocked";
+    pushBlocker(goal, resolved.reason);
+    return { kind: "blocked", evidence: missing, stage: step.stage, reason: resolved.reason };
+  }
+  goal.stage = step.stage;
+  goal.facts.pendingEvidence = missing;
+  return {
+    kind: "dispatch",
+    evidence: missing,
+    stage: step.stage,
+    duty: step.duty,
+    executable: step.executable,
+    cliArgs: resolved.cliArgs
+  };
+}
+function asStringArray(value) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) return null;
+  return [...value];
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return { ...value };
+}
+function asRoute(value) {
+  if (!Array.isArray(value)) return null;
+  const route = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const raw = item;
+    if (typeof raw.evidence !== "string" || typeof raw.stage !== "string" || typeof raw.duty !== "string") {
+      return null;
+    }
+    const args = raw.args === void 0 ? void 0 : asRecord(raw.args);
+    if (raw.args !== void 0 && !args) return null;
+    route.push({
+      evidence: raw.evidence,
+      stage: raw.stage,
+      duty: raw.duty,
+      executable: typeof raw.executable === "string" ? raw.executable : void 0,
+      args: args ?? void 0
+    });
+  }
+  return route;
+}
+function managedGoalFromState(state) {
+  const extra = state.extra;
+  const destination = asRecord(extra.destination);
+  const evidence = asStringArray(destination?.evidence);
+  const duties = asStringArray(extra.duties);
+  const route = asRoute(extra.route);
+  const facts = asRecord(extra.facts);
+  const blockers = asStringArray(extra.blockers);
+  if (typeof extra.type !== "string" || !destination || typeof destination.outcome !== "string" || !evidence || !duties || !route || !facts || !blockers) {
+    return null;
+  }
+  return {
+    type: extra.type,
+    destination: { outcome: destination.outcome, evidence },
+    duties,
+    route,
+    stage: typeof extra.stage === "string" ? extra.stage : void 0,
+    facts,
+    blockers
+  };
+}
+function writeManagedGoalToState(state, goal) {
+  return {
+    ...state,
+    extra: {
+      ...state.extra,
+      type: goal.type,
+      destination: goal.destination,
+      duties: goal.duties,
+      route: goal.route,
+      stage: goal.stage,
+      facts: goal.facts,
+      blockers: goal.blockers
+    }
+  };
+}
+var SIMPLE_GOAL_TYPE, SIMPLE_GOAL_EVIDENCE;
+var init_manager = __esm({
+  "src/goal/manager.ts"() {
+    "use strict";
+    SIMPLE_GOAL_TYPE = "simple";
+    SIMPLE_GOAL_EVIDENCE = "labelledTasksComplete";
+  }
+});
+
+// src/goal/state.ts
+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 JSON object");
+  }
+  const r = raw;
+  const stateValue = r.state;
+  if (typeof stateValue !== "string" || !VALID_STATES.has(stateValue)) {
+    throw new GoalStateError(
+      filePath,
+      `"state" is required and must be one of: ${[...VALID_STATES].join(" | ")} (got ${JSON.stringify(stateValue)})`
+    );
+  }
+  const parsed = {
+    state: stateValue,
+    extra: {}
+  };
+  for (const ts of ["updatedAt", "createdAt", "startedAt"]) {
+    const v = r[ts];
+    if (typeof v === "string" && v.length > 0) parsed[ts] = v;
+  }
+  const known = /* @__PURE__ */ new Set(["state", "updatedAt", "createdAt", "startedAt"]);
+  for (const [k, v] of Object.entries(r)) {
+    if (!known.has(k)) parsed.extra[k] = v;
+  }
+  return parsed;
+}
+function serializeGoalState(s) {
+  const obj = { ...s.extra, state: s.state };
+  if (s.createdAt !== void 0) obj.createdAt = s.createdAt;
+  if (s.startedAt !== void 0) obj.startedAt = s.startedAt;
+  if (s.updatedAt !== void 0) obj.updatedAt = s.updatedAt;
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+var VALID_STATES, GoalStateError;
+var init_state2 = __esm({
+  "src/goal/state.ts"() {
+    "use strict";
+    VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "done"]);
+    GoalStateError = class extends Error {
+      constructor(path45, message) {
+        super(`Invalid goal state at ${path45}:
+  ${message}`);
+        this.path = path45;
+        this.name = "GoalStateError";
+      }
+      path;
+    };
+  }
+});
+
+// src/scripts/advanceManagedGoal.ts
+function readSimpleGoalTaskSummary(goalId, cwd) {
+  const raw = gh(
+    ["issue", "list", "--state", "all", "--label", `goal:${goalId}`, "--limit", "1000", "--json", "number,state"],
+    { cwd }
+  );
+  const issues = JSON.parse(raw);
+  const total = issues.length;
+  const open = issues.filter((issue) => String(issue.state ?? "").toLowerCase() === "open").length;
+  return { total, open };
+}
+var advanceManagedGoal;
+var init_advanceManagedGoal = __esm({
+  "src/scripts/advanceManagedGoal.ts"() {
+    "use strict";
+    init_manager();
+    init_state2();
+    init_issue();
+    advanceManagedGoal = async (ctx) => {
+      ctx.skipAgent = true;
+      const goal = ctx.data.goal;
+      if (!goal?.raw) {
+        ctx.output.exitCode = 1;
+        ctx.output.reason = "advanceManagedGoal requires loadGoalState first";
+        return;
+      }
+      ctx.data.goalOriginalStateText = serializeGoalState(goal.raw);
+      const managed = managedGoalFromState(goal.raw);
+      if (!managed) {
+        ctx.output.reason = "goal has no managed-goal contract; nothing to advance";
+        return;
+      }
+      if (isSimpleGoal(managed)) {
+        applySimpleGoalTaskSummary(managed, readSimpleGoalTaskSummary(goal.id, ctx.cwd));
+      }
+      const decision = planManagedGoalTick(managed);
+      ctx.data.managedGoalDecision = decision;
+      if (decision.kind === "done") {
+        goal.state = "done";
+      }
+      goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
+      if (decision.kind === "blocked" || decision.kind === "wait" || decision.kind === "idle" || decision.kind === "done") {
+        ctx.output.reason = decision.kind === "done" ? "managed goal complete" : decision.reason;
+        return;
+      }
+      ctx.output.nextDispatch = {
+        duty: decision.duty,
+        executable: decision.executable,
+        cliArgs: decision.cliArgs
+      };
+      ctx.output.reason = `dispatch ${decision.duty} for ${decision.evidence}`;
+    };
+  }
+});
+
 // src/stateBranch.ts
 function is404(err) {
   const msg = err instanceof Error ? err.message : String(err);
@@ -5285,14 +5831,126 @@ var init_appendCompanyActivity = __esm({
   }
 });
 
-// src/coverage.ts
-import { execFileSync as execFileSync9 } from "child_process";
-function patternToRegex(pattern) {
-  let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
-  s = s.replace(/§S/g, "(?:.*/)?").replace(/§A/g, ".*");
-  return new RegExp(`^${s}$`);
-}
+// src/goal/stateStore.ts
+function statePath(goalId) {
+  return `.kody/goals/instances/${goalId}/state.json`;
+}
+function is4042(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
+}
+function fetchGoalState(owner, repo, goalId, cwd) {
+  const filePath = statePath(goalId);
+  let raw;
+  try {
+    raw = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
+  } catch (err) {
+    if (is4042(err)) return null;
+    throw err;
+  }
+  const o = JSON.parse(raw);
+  if (!o.content) return null;
+  const decoded = Buffer.from(o.content, "base64").toString("utf-8");
+  return parseGoalState(filePath, JSON.parse(decoded));
+}
+function putGoalState(owner, repo, goalId, state, message, cwd) {
+  ensureStateBranch(owner, repo, cwd);
+  const filePath = statePath(goalId);
+  const content = Buffer.from(serializeGoalState(state), "utf-8").toString("base64");
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    let sha;
+    try {
+      const cur = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
+      const o = JSON.parse(cur);
+      if (o.sha) sha = o.sha;
+    } catch (err) {
+      if (!is4042(err)) throw err;
+    }
+    const payload = { message, content, branch: STATE_BRANCH };
+    if (sha) payload.sha = sha;
+    try {
+      gh(["api", "--method", "PUT", `/repos/${owner}/${repo}/contents/${filePath}`, "--input", "-"], {
+        cwd,
+        input: JSON.stringify(payload)
+      });
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const conflict = /HTTP 409/i.test(msg) || /HTTP 422/i.test(msg) || /does not match|but expected/i.test(msg);
+      if (!conflict || attempt === 3) throw err;
+    }
+  }
+}
+var init_stateStore = __esm({
+  "src/goal/stateStore.ts"() {
+    "use strict";
+    init_issue();
+    init_stateBranch();
+    init_state2();
+  }
+});
+
+// src/scripts/applyDutyReports.ts
+function collectReports(raw, agentResult) {
+  const out = [];
+  if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (isDutyReport(item)) out.push(item);
+    }
+  }
+  if (agentResult?.finalText) out.push(...parseDutyReportsFromText(agentResult.finalText));
+  return out;
+}
+function isDutyReport(raw) {
+  return !!raw && typeof raw === "object" && !Array.isArray(raw) && !!raw.target && (raw.target.type === "goal" || raw.target.type === "task" || raw.target.type === "duty") && typeof raw.target.id === "string";
+}
+function describeMessage(report) {
+  const keys = [
+    ...Object.keys(report.evidence ?? {}).map((key) => `evidence:${key}`),
+    ...Object.keys(report.facts ?? {}).map((key) => `fact:${key}`)
+  ];
+  return `chore(goals): apply duty report for ${report.target.id}${keys.length ? ` (${keys.join(", ")})` : ""}`;
+}
+var applyDutyReports;
+var init_applyDutyReports = __esm({
+  "src/scripts/applyDutyReports.ts"() {
+    "use strict";
+    init_dutyReport();
+    init_state2();
+    init_stateStore();
+    applyDutyReports = async (ctx, _profile, agentResult) => {
+      const reports = collectReports(ctx.data.dutyReports, agentResult);
+      if (reports.length === 0) return;
+      const owner = ctx.config.github?.owner;
+      const repo = ctx.config.github?.repo;
+      if (!owner || !repo) {
+        process.stderr.write("[kody duty-report] missing github owner/repo; cannot apply reports\n");
+        return;
+      }
+      const goalReports = reports.filter((report) => report.target.type === "goal");
+      for (const report of goalReports) {
+        const prior = fetchGoalState(owner, repo, report.target.id, ctx.cwd);
+        if (!prior) {
+          process.stderr.write(`[kody duty-report] goal ${report.target.id} missing on kody-state; report skipped
+`);
+          continue;
+        }
+        const next = applyDutyReportToGoalState(prior, report);
+        if (serializeGoalState(next) === serializeGoalState(prior)) continue;
+        putGoalState(owner, repo, report.target.id, { ...next, updatedAt: nowIso() }, describeMessage(report), ctx.cwd);
+      }
+    };
+  }
+});
+
+// src/coverage.ts
+import { execFileSync as execFileSync10 } from "child_process";
+function patternToRegex(pattern) {
+  let s = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  s = s.replace(/\*\*\//g, "\xA7S").replace(/\*\*/g, "\xA7A").replace(/\*/g, "[^/]*");
+  s = s.replace(/§S/g, "(?:.*/)?").replace(/§A/g, ".*");
+  return new RegExp(`^${s}$`);
+}
 function renderSiblingPath(file, requireSibling) {
   const lastSlash = file.lastIndexOf("/");
   const dir = lastSlash === -1 ? "" : file.slice(0, lastSlash + 1);
@@ -5304,7 +5962,7 @@ function renderSiblingPath(file, requireSibling) {
 }
 function safeGit(args, cwd) {
   try {
-    return execFileSync9("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
+    return execFileSync10("git", args, { encoding: "utf-8", cwd, env: { ...process.env, HUSKY: "0" } }).trim();
   } catch {
     return "";
   }
@@ -5451,11 +6109,11 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs23 from "fs";
-import * as path20 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path20.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
+  return path22.join(cwd, ".kody", "runs", runId, `commit-${profileName}.lock`);
 }
 var DEFAULT_COMMIT_MESSAGE, commitAndPush2;
 var init_commitAndPush = __esm({
@@ -5472,9 +6130,9 @@ var init_commitAndPush = __esm({
       }
       const idempotencyEnabled = process.env.KODY_COMMIT_IDEMPOTENCY !== "0";
       const sentinel = idempotencyEnabled ? sentinelPathForStage(ctx.cwd, profile.name) : null;
-      if (sentinel && fs23.existsSync(sentinel)) {
+      if (sentinel && fs25.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs23.readFileSync(sentinel, "utf-8"));
+          const replay = JSON.parse(fs25.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;
@@ -5527,8 +6185,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs23.mkdirSync(path20.dirname(sentinel), { recursive: true });
-          fs23.writeFileSync(
+          fs25.mkdirSync(path22.dirname(sentinel), { recursive: true });
+          fs25.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -5549,148 +6207,17 @@ var init_commitAndPush = __esm({
   }
 });
 
-// src/goal/state.ts
-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");
-  }
-  const r = raw;
-  const stateValue = r.state;
-  if (typeof stateValue !== "string" || !VALID_STATES.has(stateValue)) {
-    throw new GoalStateError(
-      filePath,
-      `"state" is required and must be one of: ${[...VALID_STATES].join(" | ")} (got ${JSON.stringify(stateValue)})`
-    );
-  }
-  const parsed = {
-    state: stateValue,
-    extra: {}
-  };
-  if (typeof r.mergeApproved === "boolean") {
-    parsed.mergeApproved = r.mergeApproved;
-  }
-  if (typeof r.lastDispatchedIssue === "number" && Number.isFinite(r.lastDispatchedIssue)) {
-    parsed.lastDispatchedIssue = r.lastDispatchedIssue;
-  }
-  for (const ts of ["updatedAt", "createdAt", "startedAt"]) {
-    const v = r[ts];
-    if (typeof v === "string" && v.length > 0) parsed[ts] = v;
-  }
-  const known = /* @__PURE__ */ new Set(["state", "mergeApproved", "lastDispatchedIssue", "updatedAt", "createdAt", "startedAt"]);
-  for (const [k, v] of Object.entries(r)) {
-    if (!known.has(k)) parsed.extra[k] = v;
-  }
-  return parsed;
-}
-function serializeGoalState(s) {
-  const obj = { ...s.extra, state: s.state };
-  if (s.mergeApproved !== void 0) obj.mergeApproved = s.mergeApproved;
-  if (s.lastDispatchedIssue !== void 0) obj.lastDispatchedIssue = s.lastDispatchedIssue;
-  if (s.createdAt !== void 0) obj.createdAt = s.createdAt;
-  if (s.startedAt !== void 0) obj.startedAt = s.startedAt;
-  if (s.updatedAt !== void 0) obj.updatedAt = s.updatedAt;
-  return `${JSON.stringify(obj, null, 2)}
-`;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-var VALID_STATES, GoalStateError;
-var init_state2 = __esm({
-  "src/goal/state.ts"() {
-    "use strict";
-    VALID_STATES = /* @__PURE__ */ new Set(["active", "abandoned", "closed", "awaiting-merge", "done"]);
-    GoalStateError = class extends Error {
-      constructor(path45, message) {
-        super(`Invalid goal state at ${path45}:
-  ${message}`);
-        this.path = path45;
-        this.name = "GoalStateError";
-      }
-      path;
-    };
-  }
-});
-
-// src/goal/stateStore.ts
-function statePath(goalId) {
-  return `.kody/goals/${goalId}/state.json`;
-}
-function is4042(err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  return /HTTP 404/i.test(msg) || /Not Found/i.test(msg);
-}
-function fetchGoalState(owner, repo, goalId, cwd) {
-  const filePath = statePath(goalId);
-  let raw;
-  try {
-    raw = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
-  } catch (err) {
-    if (is4042(err)) return null;
-    throw err;
-  }
-  const o = JSON.parse(raw);
-  if (!o.content) return null;
-  const decoded = Buffer.from(o.content, "base64").toString("utf-8");
-  return parseGoalState(filePath, JSON.parse(decoded));
-}
-function putGoalState(owner, repo, goalId, state, message, cwd) {
-  ensureStateBranch(owner, repo, cwd);
-  const filePath = statePath(goalId);
-  const content = Buffer.from(serializeGoalState(state), "utf-8").toString("base64");
-  for (let attempt = 1; attempt <= 3; attempt++) {
-    let sha;
-    try {
-      const cur = gh(["api", `/repos/${owner}/${repo}/contents/${filePath}?ref=${STATE_BRANCH}`], { cwd });
-      const o = JSON.parse(cur);
-      if (o.sha) sha = o.sha;
-    } catch (err) {
-      if (!is4042(err)) throw err;
-    }
-    const payload = { message, content, branch: STATE_BRANCH };
-    if (sha) payload.sha = sha;
-    try {
-      gh(["api", "--method", "PUT", `/repos/${owner}/${repo}/contents/${filePath}`, "--input", "-"], {
-        cwd,
-        input: JSON.stringify(payload)
-      });
-      return;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      const conflict = /HTTP 409/i.test(msg) || /HTTP 422/i.test(msg) || /does not match|but expected/i.test(msg);
-      if (!conflict || attempt === 3) throw err;
-    }
-  }
-}
-var init_stateStore = __esm({
-  "src/goal/stateStore.ts"() {
-    "use strict";
-    init_issue();
-    init_stateBranch();
-    init_state2();
-  }
-});
-
 // src/scripts/commitGoalState.ts
 function describeCommitMessage(goal) {
-  if (goal.state === "closed") return `chore(goals): abandon ${goal.id} (cleanup complete)`;
-  if (goal.state === "awaiting-merge") return `chore(goals): park ${goal.id} awaiting merge`;
-  if (goal.state === "done") return `chore(goals): mark ${goal.id} done`;
-  if (goal.lastDispatchedIssue !== void 0) {
-    return `chore(goals): dispatched #${goal.lastDispatchedIssue} for ${goal.id}`;
-  }
-  if (goal.phase === "in-flight") {
-    return `chore(goals): tick ${goal.id} (waiting for in-flight task)`;
-  }
-  return `chore(goals): tick ${goal.id} (idle)`;
+  if (goal.state === "done") return `chore(goals): complete ${goal.id}`;
+  return `chore(goals): update ${goal.id}`;
 }
-var commitGoalState, STATE_BRANCH_LABEL;
+var STATE_BRANCH_LABEL, commitGoalState;
 var init_commitGoalState = __esm({
   "src/scripts/commitGoalState.ts"() {
     "use strict";
     init_stateStore();
+    STATE_BRANCH_LABEL = "kody-state";
     commitGoalState = async (ctx) => {
       const goal = ctx.data.goal;
       if (!goal) return;
@@ -5700,7 +6227,7 @@ var init_commitGoalState = __esm({
       const owner = ctx.config.github?.owner;
       const repo = ctx.config.github?.repo;
       if (!owner || !repo) {
-        process.stderr.write(`[goal-tick] commitGoalState: missing github owner/repo; cannot persist ${goal.id}
+        process.stderr.write(`[goal-manager] commitGoalState: missing github owner/repo; cannot persist ${goal.id}
 `);
         return;
       }
@@ -5708,18 +6235,17 @@ var init_commitGoalState = __esm({
         putGoalState(owner, repo, goal.id, updated, describeCommitMessage(goal), ctx.cwd);
       } catch (err) {
         process.stderr.write(
-          `[goal-tick] commitGoalState: persist to ${STATE_BRANCH_LABEL} failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
+          `[goal-manager] commitGoalState: persist to ${STATE_BRANCH_LABEL} failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
 `
         );
       }
     };
-    STATE_BRANCH_LABEL = "kody-state";
   }
 });
 
 // src/scripts/composePrompt.ts
-import * as fs25 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path23 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]");
@@ -5840,10 +6366,10 @@ var init_composePrompt = __esm({
       const explicit = ctx.data.promptTemplate;
       const mode = ctx.args.mode;
       const candidates = [
-        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")
+        explicit ? path23.join(profile.dir, explicit) : null,
+        mode ? path23.join(profile.dir, "prompts", `${mode}.md`) : null,
+        path23.join(profile.dir, "prompt.md"),
+        path23.join(profile.dir, "duty.md")
       ].filter(Boolean);
       let templatePath = "";
       let template = "";
@@ -5856,7 +6382,7 @@ var init_composePrompt = __esm({
           break;
         }
         try {
-          template = fs25.readFileSync(c, "utf-8");
+          template = fs26.readFileSync(c, "utf-8");
           templatePath = c;
           break;
         } catch (err) {
@@ -5867,7 +6393,7 @@ var init_composePrompt = __esm({
       if (!templatePath) {
         let dirState;
         try {
-          dirState = `dir contents: [${fs25.readdirSync(profile.dir).join(", ")}]`;
+          dirState = `dir contents: [${fs26.readdirSync(profile.dir).join(", ")}]`;
         } catch (err) {
           dirState = `readdir(${profile.dir}) failed: ${err?.code ?? String(err)}`;
         }
@@ -6168,6 +6694,25 @@ function createTaskIssue(finding, goalId, manifestNumber, cwd) {
   if (!m) throw new Error(`gh issue create returned unexpected output: ${out}`);
   return { number: Number(m[1]), url };
 }
+function buildQaManagedGoal(goalId, verdict, opened, failed) {
+  return {
+    type: "qa",
+    destination: {
+      outcome: `QA findings filed for ${goalId}`,
+      evidence: ["qaFindingsFiled"]
+    },
+    duties: ["qa-goal"],
+    route: [],
+    stage: "filed",
+    facts: {
+      qaFindingsFiled: true,
+      verdict,
+      findingsOpened: opened,
+      findingsFailed: failed
+    },
+    blockers: failed > 0 ? [`${failed} QA finding issue(s) failed to open`] : []
+  };
+}
 async function promoteReportToGoal(ctx, finalText, scopeArg, explicitGoalArg) {
   const { markdown, data, jsonError } = splitReport(finalText);
   const verdict = detectVerdict(markdown);
@@ -6271,7 +6816,13 @@ ${markdown}`, ctx.cwd);
     }
   }
   const now = nowIso();
-  const goalState = { state: "active", startedAt: now, updatedAt: now, extra: { version: 1 } };
+  const managedGoal = buildQaManagedGoal(goalId, verdict, opened.length, failed.length);
+  const goalState = {
+    state: "active",
+    startedAt: now,
+    updatedAt: now,
+    extra: { version: 1, ...managedGoal }
+  };
   try {
     putGoalState(
       ctx.config.github.owner,
@@ -6384,279 +6935,6 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
   }
 });
 
-// src/goal/labels.ts
-function goalLabel(goalId) {
-  return `goal:${goalId}`;
-}
-var QA_GATE_LABEL;
-var init_labels = __esm({
-  "src/goal/labels.ts"() {
-    "use strict";
-    QA_GATE_LABEL = "kody:qa-gate";
-  }
-});
-
-// src/goal/operations.ts
-function fail(err) {
-  if (err instanceof Error) {
-    const lines = err.message.split("\n").filter(Boolean);
-    return { ok: false, error: lines[0] ?? err.message };
-  }
-  return { ok: false, error: String(err) };
-}
-function listGoalIssues(goalId, cwd) {
-  try {
-    const out = gh(
-      [
-        "api",
-        `repos/{owner}/{repo}/issues?labels=${goalLabel(goalId)}&state=all&per_page=100`,
-        "--jq",
-        `[.[] | select(.pull_request == null) | {number, state: (.state | ascii_upcase), isQaGate: ([.labels[].name] | any(. == "${QA_GATE_LABEL}"))}]`
-      ],
-      { cwd }
-    );
-    return { ok: true, value: JSON.parse(out) };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function listOpenPrs(cwd) {
-  try {
-    const out = gh(
-      ["pr", "list", "--state", "open", "--limit", "200", "--json", "number,url,isDraft,headRefName,baseRefName,body"],
-      { cwd }
-    );
-    return { ok: true, value: JSON.parse(out) };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function pairIssuesWithPrs(issues, openPrs) {
-  const prByIssue = /* @__PURE__ */ new Map();
-  for (const pr of openPrs) claimPrForIssue(pr, prByIssue);
-  return issues.map((i) => {
-    const pr = prByIssue.get(i.number);
-    let prState = "absent";
-    if (pr) prState = pr.isDraft ? "draft" : "ready";
-    return { number: i.number, state: i.state, prState, isQaGate: i.isQaGate };
-  });
-}
-function claimPrForIssue(pr, prByIssue) {
-  for (const issueNum of extractClosesIssues(pr.body)) {
-    if (!prByIssue.has(issueNum)) {
-      prByIssue.set(issueNum, pr);
-      return;
-    }
-  }
-  const headMatch = pr.headRefName.match(/^(\d+)-/);
-  if (headMatch) {
-    const n = Number.parseInt(headMatch[1], 10);
-    if (Number.isFinite(n) && !prByIssue.has(n)) prByIssue.set(n, pr);
-  }
-}
-function extractClosesIssues(body) {
-  const out = [];
-  const re = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+#(\d+)\b/gi;
-  for (let m = re.exec(body); m !== null; m = re.exec(body)) {
-    const n = Number.parseInt(m[1], 10);
-    if (Number.isFinite(n)) out.push(n);
-  }
-  return out;
-}
-function pickLeafPr(prs) {
-  if (prs.length === 0) return void 0;
-  const bases = new Set(prs.map((p) => p.baseRefName));
-  const leaves = prs.filter((p) => !bases.has(p.headRefName));
-  return leaves.sort((a, b) => b.number - a.number)[0];
-}
-function commentOnIssue(issueNumber, body, cwd) {
-  try {
-    gh(["issue", "comment", String(issueNumber), "--body", body], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function dispatchTaskRun(issueNumber, base, cwd) {
-  try {
-    gh(
-      [
-        "workflow",
-        "run",
-        GOAL_TASK_WORKFLOW,
-        "-f",
-        `issue_number=${issueNumber}`,
-        "-f",
-        "duty=classify",
-        "-f",
-        `base=${base}`
-      ],
-      { cwd }
-    );
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function closeIssue(issueNumber, options, cwd) {
-  try {
-    if (options.comment) {
-      gh(["issue", "comment", String(issueNumber), "--body", options.comment], { cwd });
-    }
-    const args = ["issue", "close", String(issueNumber)];
-    if (options.reason) args.push("--reason", options.reason);
-    gh(args, { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function closePr(prNumber, comment, cwd) {
-  try {
-    gh(["pr", "close", String(prNumber), "--comment", comment], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function mergePrSquash(prNumber, cwd) {
-  try {
-    gh(["pr", "merge", String(prNumber), "--squash", "--delete-branch"], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function editPrBase(prNumber, baseBranch, cwd) {
-  try {
-    gh(["api", "--method", "PATCH", `repos/{owner}/{repo}/pulls/${prNumber}`, "-f", `base=${baseBranch}`], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function branchContains(leafHead, candidateHead, cwd) {
-  if (leafHead === candidateHead) return { ok: true, value: true };
-  try {
-    const out = gh(
-      [
-        "api",
-        `repos/{owner}/{repo}/compare/${encodeURIComponent(leafHead)}...${encodeURIComponent(candidateHead)}`,
-        "--jq",
-        ".ahead_by"
-      ],
-      { cwd }
-    );
-    return { ok: true, value: Number.parseInt(out.trim(), 10) === 0 };
-  } catch (err) {
-    return fail(err);
-  }
-}
-function markPrReady(prNumber, cwd) {
-  try {
-    gh(["pr", "ready", String(prNumber)], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
-  }
-}
-var GOAL_TASK_WORKFLOW;
-var init_operations = __esm({
-  "src/goal/operations.ts"() {
-    "use strict";
-    init_issue();
-    init_labels();
-    GOAL_TASK_WORKFLOW = "kody.yml";
-  }
-});
-
-// src/goal/phase.ts
-function derivePhase(snap) {
-  if (!snap.lifecycleState) return "missing";
-  if (snap.lifecycleState === "abandoned") return "abandoned";
-  if (snap.lifecycleState === "closed" || snap.lifecycleState === "done") return "terminal";
-  if (snap.lifecycleState === "awaiting-merge") return "awaiting-merge";
-  const tasks = snap.childTasks.filter((t) => !t.isQaGate);
-  const qaGateOpen = snap.childTasks.some((t) => t.isQaGate && t.state === "OPEN");
-  const hasInFlight = tasks.some((t) => t.state === "OPEN" && t.prState === "draft");
-  if (hasInFlight) return "in-flight";
-  if (tasks.length === 0) return "idle";
-  const dispatchable = tasks.some((t) => t.state === "OPEN" && t.prState === "absent");
-  if (dispatchable) return "ready-to-dispatch";
-  const allDone = tasks.every((t) => t.state === "CLOSED" || t.prState === "ready");
-  if (allDone) return qaGateOpen ? "idle" : "all-done";
-  return "idle";
-}
-function pickNextDispatchable(snap) {
-  return snap.childTasks.filter((t) => !t.isQaGate && t.state === "OPEN" && t.prState === "absent").sort((a, b) => a.number - b.number)[0];
-}
-var init_phase = __esm({
-  "src/goal/phase.ts"() {
-    "use strict";
-  }
-});
-
-// src/scripts/deriveGoalPhase.ts
-function filterGoalTaskPrs(prs, taskIssueNumbers) {
-  const taskSet = new Set(taskIssueNumbers);
-  return prs.filter((pr) => {
-    for (const n of extractClosesIssues(pr.body)) {
-      if (taskSet.has(n)) return true;
-    }
-    const headMatch = pr.headRefName.match(/^(\d+)-/);
-    if (headMatch) {
-      const n = Number.parseInt(headMatch[1], 10);
-      if (Number.isFinite(n) && taskSet.has(n)) return true;
-    }
-    return false;
-  });
-}
-var deriveGoalPhase;
-var init_deriveGoalPhase = __esm({
-  "src/scripts/deriveGoalPhase.ts"() {
-    "use strict";
-    init_operations();
-    init_phase();
-    deriveGoalPhase = async (ctx) => {
-      const goal = ctx.data.goal;
-      if (!goal) return;
-      const issues = listGoalIssues(goal.id, ctx.cwd);
-      if (!issues.ok) {
-        process.stderr.write(`[goal-tick] deriveGoalPhase: list issues failed: ${issues.error}
-`);
-        goal.childTasks = [];
-        goal.openTaskPrs = [];
-        goal.phase = "idle";
-        return;
-      }
-      const rawIssues = issues.value ?? [];
-      const allPrs = listOpenPrs(ctx.cwd);
-      if (!allPrs.ok) {
-        process.stderr.write(`[goal-tick] deriveGoalPhase: list PRs failed: ${allPrs.error}
-`);
-        goal.childTasks = rawIssues.map((i) => ({ ...i, prState: "absent" }));
-        goal.openTaskPrs = [];
-        goal.phase = "idle";
-        return;
-      }
-      const taskPrs = filterGoalTaskPrs(
-        allPrs.value ?? [],
-        rawIssues.map((i) => i.number)
-      );
-      goal.openTaskPrs = taskPrs;
-      goal.leafPr = pickLeafPr(taskPrs);
-      goal.childTasks = pairIssuesWithPrs(rawIssues, taskPrs);
-      goal.phase = derivePhase({
-        lifecycleState: goal.state,
-        childTasks: goal.childTasks
-      });
-      process.stdout.write(
-        `[goal-tick] phase=${goal.phase} goal=${goal.id} tasks=${rawIssues.length} stack=${taskPrs.length}` + (goal.leafPr ? ` leaf=#${goal.leafPr.number}` : "") + "\n"
-      );
-    };
-  }
-});
-
 // src/scripts/deriveQaScopeFromIssue.ts
 var TITLE_PATTERN, deriveQaScopeFromIssue;
 var init_deriveQaScopeFromIssue = __esm({
@@ -6693,20 +6971,20 @@ var init_deriveQaScopeFromIssue = __esm({
 });
 
 // src/scripts/diagMcp.ts
-import { execFileSync as execFileSync10 } from "child_process";
-import * as fs26 from "fs";
-import * as os4 from "os";
-import * as path23 from "path";
+import { execFileSync as execFileSync11 } from "child_process";
+import * as fs27 from "fs";
+import * as os5 from "os";
+import * as path24 from "path";
 var diagMcp;
 var init_diagMcp = __esm({
   "src/scripts/diagMcp.ts"() {
     "use strict";
     diagMcp = async (_ctx) => {
-      const home = os4.homedir();
-      const cacheDir = path23.join(home, ".cache", "ms-playwright");
+      const home = os5.homedir();
+      const cacheDir = path24.join(home, ".cache", "ms-playwright");
       let entries = [];
       try {
-        entries = fs26.readdirSync(cacheDir);
+        entries = fs27.readdirSync(cacheDir);
       } catch {
       }
       const hasChromium = entries.some((e) => e.startsWith("chromium"));
@@ -6717,7 +6995,7 @@ var init_diagMcp = __esm({
       process.stderr.write(`[kody diag] chromium present: ${hasChromium ? "yes" : "no"}
 `);
       try {
-        const v = execFileSync10("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
+        const v = execFileSync11("npx", ["-y", "--package=@playwright/mcp@latest", "--", "playwright-mcp", "--version"], {
           stdio: "pipe",
           timeout: 6e4,
           encoding: "utf8"
@@ -6734,13 +7012,13 @@ var init_diagMcp = __esm({
 });
 
 // src/scripts/frameworkDetectors.ts
-import * as fs27 from "fs";
-import * as path24 from "path";
+import * as fs28 from "fs";
+import * as path25 from "path";
 function detectFrameworks(cwd) {
   const out = [];
   let deps = {};
   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"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return out;
@@ -6777,25 +7055,25 @@ function detectFrameworks(cwd) {
 }
 function findFile(cwd, candidates) {
   for (const c of candidates) {
-    if (fs27.existsSync(path24.join(cwd, c))) return c;
+    if (fs28.existsSync(path25.join(cwd, c))) return c;
   }
   return null;
 }
 function discoverPayloadCollections(cwd) {
   const out = [];
   for (const dir of COLLECTION_DIRS) {
-    const full = path24.join(cwd, dir);
-    if (!fs27.existsSync(full)) continue;
+    const full = path25.join(cwd, dir);
+    if (!fs28.existsSync(full)) continue;
     let files;
     try {
-      files = fs27.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs28.readdirSync(full).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const filePath = path24.join(full, file);
-        const content = fs27.readFileSync(filePath, "utf-8").slice(0, 1e4);
+        const filePath = path25.join(full, file);
+        const content = fs28.readFileSync(filePath, "utf-8").slice(0, 1e4);
         const slugMatch = content.match(/slug:\s*['"]([a-z0-9-]+)['"]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
@@ -6809,7 +7087,7 @@ function discoverPayloadCollections(cwd) {
         out.push({
           name,
           slug,
-          filePath: path24.relative(cwd, filePath),
+          filePath: path25.relative(cwd, filePath),
           fields: fields.slice(0, 20),
           hasAdmin
         });
@@ -6822,28 +7100,28 @@ function discoverPayloadCollections(cwd) {
 function discoverAdminComponents(cwd, collections) {
   const out = [];
   for (const dir of ADMIN_COMPONENT_DIRS) {
-    const full = path24.join(cwd, dir);
-    if (!fs27.existsSync(full)) continue;
+    const full = path25.join(cwd, dir);
+    if (!fs28.existsSync(full)) continue;
     let entries;
     try {
-      entries = fs27.readdirSync(full, { withFileTypes: true });
+      entries = fs28.readdirSync(full, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path24.join(full, entry.name);
+      const entryPath = path25.join(full, entry.name);
       let name;
       let filePath;
       if (entry.isDirectory()) {
         const indexFile = ["index.tsx", "index.ts", "index.jsx", "index.js"].find(
-          (f) => fs27.existsSync(path24.join(entryPath, f))
+          (f) => fs28.existsSync(path25.join(entryPath, f))
         );
         if (!indexFile) continue;
         name = entry.name;
-        filePath = path24.relative(cwd, path24.join(entryPath, indexFile));
+        filePath = path25.relative(cwd, path25.join(entryPath, indexFile));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
         name = entry.name.replace(/\.(tsx?|jsx?)$/, "");
-        filePath = path24.relative(cwd, entryPath);
+        filePath = path25.relative(cwd, entryPath);
       } else {
         continue;
       }
@@ -6851,7 +7129,7 @@ function discoverAdminComponents(cwd, collections) {
       if (collections) {
         for (const col of collections) {
           try {
-            const colContent = fs27.readFileSync(path24.join(cwd, col.filePath), "utf-8");
+            const colContent = fs28.readFileSync(path25.join(cwd, col.filePath), "utf-8");
             if (colContent.includes(name)) {
               usedInCollection = col.slug;
               break;
@@ -6869,8 +7147,8 @@ function scanApiRoutes(cwd) {
   const out = [];
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const apiDir = path24.join(cwd, appDir, "api");
-    if (!fs27.existsSync(apiDir)) continue;
+    const apiDir = path25.join(cwd, appDir, "api");
+    if (!fs28.existsSync(apiDir)) continue;
     walkApiRoutes(apiDir, "/api", cwd, out);
     break;
   }
@@ -6879,14 +7157,14 @@ function scanApiRoutes(cwd) {
 function walkApiRoutes(dir, prefix, cwd, out) {
   let entries;
   try {
-    entries = fs27.readdirSync(dir, { withFileTypes: true });
+    entries = fs28.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 = fs27.readFileSync(path24.join(dir, routeFile.name), "utf-8").slice(0, 5e3);
+      const content = fs28.readFileSync(path25.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)
       );
@@ -6894,7 +7172,7 @@ function walkApiRoutes(dir, prefix, cwd, out) {
         out.push({
           path: prefix,
           methods,
-          filePath: path24.relative(cwd, path24.join(dir, routeFile.name))
+          filePath: path25.relative(cwd, path25.join(dir, routeFile.name))
         });
       }
     } catch {
@@ -6905,7 +7183,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(path24.join(dir, entry.name), prefix, cwd, out);
+      walkApiRoutes(path25.join(dir, entry.name), prefix, cwd, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -6913,16 +7191,16 @@ function walkApiRoutes(dir, prefix, cwd, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkApiRoutes(path24.join(dir, entry.name), `${prefix}/${segment}`, cwd, out);
+    walkApiRoutes(path25.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 = path24.join(cwd, envFile);
-    if (!fs27.existsSync(envPath)) continue;
+    const envPath = path25.join(cwd, envFile);
+    if (!fs28.existsSync(envPath)) continue;
     try {
-      const content = fs27.readFileSync(envPath, "utf-8");
+      const content = fs28.readFileSync(envPath, "utf-8");
       const vars = [];
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -6967,8 +7245,8 @@ var init_frameworkDetectors = __esm({
 });
 
 // src/scripts/discoverQaContext.ts
-import * as fs28 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 function runQaDiscovery(cwd) {
   const out = {
     routes: [],
@@ -6999,9 +7277,9 @@ function runQaDiscovery(cwd) {
 }
 function detectDevServer(cwd, out) {
   try {
-    const pkg = JSON.parse(fs28.readFileSync(path25.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs29.readFileSync(path26.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    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";
+    const pm = fs29.existsSync(path26.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs29.existsSync(path26.join(cwd, "yarn.lock")) ? "yarn" : fs29.existsSync(path26.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;
@@ -7011,8 +7289,8 @@ function detectDevServer(cwd, out) {
 function scanFrontendRoutes(cwd, out) {
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
-    const full = path25.join(cwd, appDir);
-    if (!fs28.existsSync(full)) continue;
+    const full = path26.join(cwd, appDir);
+    if (!fs29.existsSync(full)) continue;
     walkFrontendRoutes(full, "", out);
     break;
   }
@@ -7020,7 +7298,7 @@ function scanFrontendRoutes(cwd, out) {
 function walkFrontendRoutes(dir, prefix, out) {
   let entries;
   try {
-    entries = fs28.readdirSync(dir, { withFileTypes: true });
+    entries = fs29.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -7037,7 +7315,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(path25.join(dir, entry.name), prefix, out);
+      walkFrontendRoutes(path26.join(dir, entry.name), prefix, out);
       continue;
     }
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
@@ -7045,7 +7323,7 @@ function walkFrontendRoutes(dir, prefix, out) {
     } else if (segment.startsWith("[") && segment.endsWith("]")) {
       segment = `:${segment.slice(1, -1)}`;
     }
-    walkFrontendRoutes(path25.join(dir, entry.name), `${prefix}/${segment}`, out);
+    walkFrontendRoutes(path26.join(dir, entry.name), `${prefix}/${segment}`, out);
   }
 }
 function detectAuthFiles(cwd, out) {
@@ -7062,23 +7340,23 @@ function detectAuthFiles(cwd, out) {
     "src/app/api/oauth"
   ];
   for (const c of candidates) {
-    if (fs28.existsSync(path25.join(cwd, c))) out.authFiles.push(c);
+    if (fs29.existsSync(path26.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 = path25.join(cwd, rp);
-    if (!fs28.existsSync(dir)) continue;
+    const dir = path26.join(cwd, rp);
+    if (!fs29.existsSync(dir)) continue;
     let files;
     try {
-      files = fs28.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+      files = fs29.readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
     } catch {
       continue;
     }
     for (const f of files) {
       try {
-        const content = fs28.readFileSync(path25.join(dir, f), "utf-8").slice(0, 5e3);
+        const content = fs29.readFileSync(path26.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) {
@@ -7221,7 +7499,7 @@ var init_dispatch = __esm({
 });
 
 // src/scripts/dispatchClassified.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 var API_TIMEOUT_MS4, VALID_CLASSES2, dispatchClassified;
 var init_dispatchClassified = __esm({
   "src/scripts/dispatchClassified.ts"() {
@@ -7251,7 +7529,7 @@ ${stateBody}`;
       try {
         const existing = findStateComment("issue", issueNumber, ctx.cwd);
         if (existing) {
-          execFileSync11(
+          execFileSync12(
             "gh",
             ["api", `repos/{owner}/{repo}/issues/comments/${existing.id}`, "-X", "PATCH", "-F", "body=@-"],
             {
@@ -7262,7 +7540,7 @@ ${stateBody}`;
             }
           );
         } else {
-          execFileSync11("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+          execFileSync12("gh", ["issue", "comment", String(issueNumber), "--body", body], {
             cwd: ctx.cwd,
             timeout: API_TIMEOUT_MS4,
             stdio: ["ignore", "pipe", "pipe"]
@@ -7504,8 +7782,8 @@ var init_contentsApiBackend = __esm({
 });
 
 // src/scripts/jobState/localFileBackend.ts
-import * as fs29 from "fs";
-import * as path26 from "path";
+import * as fs30 from "fs";
+import * as path27 from "path";
 function sanitizeKey(s) {
   return s.replace(/[^A-Za-z0-9._-]/g, "-");
 }
@@ -7561,7 +7839,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 = path26.join(opts.cwd, opts.jobsDir);
+        this.absDir = path27.join(opts.cwd, opts.jobsDir);
         this.owner = opts.owner;
         this.repo = opts.repo;
         this.cache = opts.cache ?? defaultCacheAdapter();
@@ -7576,7 +7854,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        fs29.mkdirSync(this.absDir, { recursive: true });
+        fs30.mkdirSync(this.absDir, { recursive: true });
         const prefix = this.cacheKeyPrefix();
         const probeKey = `${prefix}probe-${Date.now()}`;
         try {
@@ -7605,7 +7883,7 @@ var init_localFileBackend = __esm({
 `);
           return;
         }
-        if (!fs29.existsSync(this.absDir)) {
+        if (!fs30.existsSync(this.absDir)) {
           return;
         }
         const key = `${this.cacheKeyPrefix()}${process.env.GITHUB_RUN_ID ?? "norunid"}-${Date.now()}`;
@@ -7621,11 +7899,11 @@ var init_localFileBackend = __esm({
       }
       load(slug) {
         const relPath = stateFilePath(this.jobsDir, slug);
-        const absPath = path26.join(this.cwd, relPath);
-        if (!fs29.existsSync(absPath)) {
+        const absPath = path27.join(this.cwd, relPath);
+        if (!fs30.existsSync(absPath)) {
           return { path: relPath, handle: null, state: initialStateEnvelope("seed"), created: true };
         }
-        const raw = fs29.readFileSync(absPath, "utf-8");
+        const raw = fs30.readFileSync(absPath, "utf-8");
         let parsed;
         try {
           parsed = JSON.parse(raw);
@@ -7642,13 +7920,13 @@ var init_localFileBackend = __esm({
         if (!loaded.created && isStateUnchanged(loaded.state, next)) {
           return false;
         }
-        const absPath = path26.join(this.cwd, loaded.path);
-        fs29.mkdirSync(path26.dirname(absPath), { recursive: true });
+        const absPath = path27.join(this.cwd, loaded.path);
+        fs30.mkdirSync(path27.dirname(absPath), { recursive: true });
         const body = `${JSON.stringify(next, null, 2)}
 `;
         const tmpPath = `${absPath}.${process.pid}.tmp`;
-        fs29.writeFileSync(tmpPath, body, "utf-8");
-        fs29.renameSync(tmpPath, absPath);
+        fs30.writeFileSync(tmpPath, body, "utf-8");
+        fs30.renameSync(tmpPath, absPath);
         return true;
       }
       cacheKeyPrefix() {
@@ -7823,7 +8101,7 @@ var init_planTaskJobs = __esm({
 });
 
 // src/scripts/dispatchDutyFileTicks.ts
-import * as path27 from "path";
+import * as path28 from "path";
 async function decideShouldFire(every, slug, backend, now) {
   if (!every) return { skip: false, reason: "no schedule (every cron tick)" };
   if (every === "manual") {
@@ -7870,6 +8148,24 @@ function parseDutyFilter(raw) {
 function filterSlugs(slugs, onlyDuty) {
   return onlyDuty ? slugs.filter((slug) => slug === onlyDuty) : slugs;
 }
+function listActivatedDutySlugs(projectRoot, storeRoot, activeStoreDuties) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const slug of listDutyFolderSlugs(projectRoot)) {
+    if (seen.has(slug)) continue;
+    seen.add(slug);
+    out.push(slug);
+  }
+  const active = new Set(activeStoreDuties ?? []);
+  if (storeRoot && active.size > 0) {
+    for (const slug of listDutyFolderSlugs(storeRoot)) {
+      if (!active.has(slug) || seen.has(slug)) continue;
+      seen.add(slug);
+      out.push(slug);
+    }
+  }
+  return out.sort();
+}
 function createDutyTaskIssue(opts) {
   const title = `Duty ${opts.slug} - multi-executable task`;
   const body = buildDutyTaskIssueBody(opts.slug, opts.body, opts.config);
@@ -7920,6 +8216,7 @@ var init_dispatchDutyFileTicks = __esm({
     init_dutyFolders();
     init_issue();
     init_job();
+    init_registry();
     init_jobState();
     init_planTaskJobs();
     init_scheduleEvery();
@@ -7938,8 +8235,12 @@ var init_dispatchDutyFileTicks = __esm({
       }
       try {
         const onlyDuty = parseDutyFilter(ctx.args.duty);
-        const jobsPath = path27.join(ctx.cwd, jobsDir);
-        const slugs = filterSlugs(listDutyFolderSlugs(jobsPath), onlyDuty);
+        const jobsPath = path28.join(ctx.cwd, jobsDir);
+        const storeJobsPath = getCompanyStoreDutiesRoot();
+        const slugs = filterSlugs(
+          listActivatedDutySlugs(jobsPath, storeJobsPath, ctx.config.company?.activeDuties),
+          onlyDuty
+        );
         ctx.data.jobSlugCount = slugs.length;
         if (slugs.length === 0) {
           const filter = onlyDuty ? ` matching ${onlyDuty}` : "";
@@ -7953,7 +8254,7 @@ var init_dispatchDutyFileTicks = __esm({
         const results = [];
         const now = Date.now();
         for (const slug of slugs) {
-          const duty = readDutyFolder(jobsPath, slug);
+          const duty = resolveDutyFolder(slug, jobsPath);
           if (!duty) {
             process.stderr.write(`[jobs] \u23ED  skip ${slug}: duty folder is missing profile.json or duty.md
 `);
@@ -8130,38 +8431,6 @@ var init_dispatchDutyTicks = __esm({
   }
 });
 
-// src/scripts/dispatchNextTask.ts
-var dispatchNextTask;
-var init_dispatchNextTask = __esm({
-  "src/scripts/dispatchNextTask.ts"() {
-    "use strict";
-    init_operations();
-    init_phase();
-    dispatchNextTask = async (ctx) => {
-      const goal = ctx.data.goal;
-      if (!goal?.childTasks) return;
-      const next = pickNextDispatchable({
-        lifecycleState: goal.state,
-        childTasks: goal.childTasks
-      });
-      if (!next) {
-        process.stdout.write("[goal-tick] no dispatchable task \u2014 idle\n");
-        return;
-      }
-      const base = goal.leafPr?.headRefName ?? goal.defaultBranch;
-      process.stdout.write(`[goal-tick] dispatching #${next.number} via workflow_dispatch (classify, --base ${base})
-`);
-      const res = dispatchTaskRun(next.number, base, ctx.cwd);
-      if (!res.ok) {
-        process.stderr.write(`[goal-tick] dispatchNextTask: workflow_dispatch on #${next.number} failed: ${res.error}
-`);
-        return;
-      }
-      goal.lastDispatchedIssue = next.number;
-    };
-  }
-});
-
 // src/scripts/dispatchNextTaskJob.ts
 function taskJobToJob(job, issueArg) {
   const target = typeof job.target === "number" ? job.target : typeof issueArg === "number" ? issueArg : void 0;
@@ -8206,7 +8475,7 @@ var init_dispatchNextTaskJob = __esm({
 });
 
 // src/pr.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 function prMergeStatus(prNumber, cwd) {
   try {
     const out = gh(["pr", "view", String(prNumber), "--json", "mergeable,mergeStateStatus"], { cwd });
@@ -8327,7 +8596,7 @@ function isAlreadyExistsError(err) {
   return ALREADY_EXISTS_RE.test(msg);
 }
 function git2(args, cwd) {
-  return execFileSync12("git", args, {
+  return execFileSync13("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -8528,140 +8797,13 @@ var init_failOnceTaskJob = __esm({
       const state = ctx.data.taskState;
       const runs = state?.jobs?.[jobKey]?.runs ?? [];
       const hasFailedBefore = runs.some((run) => run.status === "failed");
-      if (!hasFailedBefore) {
-        ctx.output.exitCode = 1;
-        ctx.output.reason = "intentional first-attempt failure for task job live test";
-        return;
-      }
-      ctx.output.exitCode = 0;
-      ctx.output.reason = "task job live test succeeded after prior failure";
-    };
-  }
-});
-
-// src/scripts/finalizeGoal.ts
-function prIssueNumbers(pr) {
-  const nums = new Set(extractClosesIssues(pr.body));
-  const headMatch = pr.headRefName.match(/^(\d+)-/);
-  if (headMatch) {
-    const n = Number.parseInt(headMatch[1], 10);
-    if (Number.isFinite(n)) nums.add(n);
-  }
-  return [...nums];
-}
-var finalizeGoal;
-var init_finalizeGoal = __esm({
-  "src/scripts/finalizeGoal.ts"() {
-    "use strict";
-    init_operations();
-    finalizeGoal = async (ctx) => {
-      const goal = ctx.data.goal;
-      if (!goal) return;
-      process.stdout.write(`[goal-tick] all task(s) done \u2014 preparing deliverable PR for goal ${goal.id}
-`);
-      const leaf = goal.leafPr;
-      if (!leaf) {
-        process.stdout.write(`[goal-tick] no leaf PR \u2014 marking goal done without a deliverable PR
-`);
-        goal.state = "done";
-        return;
-      }
-      if (leaf.baseRefName !== goal.defaultBranch) {
-        process.stdout.write(
-          `[goal-tick] retargeting leaf PR #${leaf.number} base ${leaf.baseRefName} \u2192 ${goal.defaultBranch}
-`
-        );
-        const retarget = editPrBase(leaf.number, goal.defaultBranch, ctx.cwd);
-        if (!retarget.ok) {
-          process.stderr.write(`[goal-tick] finalizeGoal: editPrBase #${leaf.number} failed: ${retarget.error}
-`);
-          return;
-        }
-      }
-      if (leaf.isDraft) {
-        process.stdout.write(`[goal-tick] promoting draft leaf PR #${leaf.number} \u2192 ready-for-review
-`);
-        const ready = markPrReady(leaf.number, ctx.cwd);
-        if (!ready.ok) {
-          process.stderr.write(`[goal-tick] finalizeGoal: markPrReady #${leaf.number} failed: ${ready.error}
-`);
-          return;
-        }
-      }
-      process.stdout.write(
-        `[goal-tick] leaf PR #${leaf.number} is the deliverable (cumulative goal diff vs ${goal.defaultBranch}) \u2014 left open for human merge
-`
-      );
-      const uncarriedIssues = /* @__PURE__ */ new Set();
-      const others = (goal.openTaskPrs ?? []).filter((p) => p.number !== leaf.number);
-      for (const pr of others) {
-        const contained = branchContains(leaf.headRefName, pr.headRefName, ctx.cwd);
-        if (!contained.ok || contained.value !== true) {
-          const why = contained.ok ? `commits on \`${pr.headRefName}\` are NOT reachable from the deliverable leaf \`${leaf.headRefName}\`` : `could not verify containment (${contained.error})`;
-          process.stderr.write(
-            `[goal-tick] finalizeGoal: NOT closing PR #${pr.number} \u2014 ${why}; leaving it open (broken stack)
-`
-          );
-          for (const n of prIssueNumbers(pr)) uncarriedIssues.add(n);
-          commentOnIssue(
-            pr.number,
-            `\u26A0\uFE0F _Stacked-PR finalize: this PR's commits are **not** carried by the goal's deliverable PR #${leaf.number} (the stack chain was broken). Leaving this PR open so its work isn't lost \u2014 review and land it manually._`,
-            ctx.cwd
-          );
-          continue;
-        }
-        process.stdout.write(`[goal-tick] closing intermediate stacked PR #${pr.number} (carried by deliverable leaf)
-`);
-        const closed = closePr(
-          pr.number,
-          `_Stacked-PR finalize: this PR's content is carried by the goal's single deliverable PR #${leaf.number} (open against \`${goal.defaultBranch}\`, awaiting human merge)._`,
-          ctx.cwd
-        );
-        if (!closed.ok) {
-          process.stderr.write(`[goal-tick] finalizeGoal: closePr #${pr.number} failed: ${closed.error}
-`);
-        }
-      }
-      const leafIssues = new Set(prIssueNumbers(leaf));
-      const openIssues = (goal.childTasks ?? []).filter((t) => t.state === "OPEN");
-      for (const t of openIssues) {
-        if (uncarriedIssues.has(t.number)) {
-          process.stderr.write(
-            `[goal-tick] finalizeGoal: NOT closing task issue #${t.number} \u2014 its PR's work is not carried by the deliverable (broken stack)
-`
-          );
-          continue;
-        }
-        if (leafIssues.has(t.number)) {
-          process.stdout.write(
-            `[goal-tick] leaving leaf task issue #${t.number} OPEN as the review anchor for deliverable PR #${leaf.number}
-`
-          );
-          commentOnIssue(
-            t.number,
-            `_Goal \`${goal.id}\` finalized \u2014 this task's PR #${leaf.number} (open against \`${goal.defaultBranch}\`) is the goal's single deliverable and carries every task's changes. This issue stays open as the review anchor; merge PR #${leaf.number} to ship._`,
-            ctx.cwd
-          );
-          continue;
-        }
-        process.stdout.write(
-          `[goal-tick] closing task issue #${t.number} (goal finalized \u2014 carried by PR #${leaf.number})
-`
-        );
-        const closed = closeIssue(
-          t.number,
-          {
-            comment: `_Goal \`${goal.id}\` finalized \u2014 its single deliverable PR #${leaf.number} (open against \`${goal.defaultBranch}\`) carries this task's changes. Merge that PR to ship._`,
-            reason: "completed"
-          },
-          ctx.cwd
-        );
-        if (!closed.ok) {
-          process.stderr.write(`[goal-tick] finalizeGoal: closeIssue #${t.number} failed: ${closed.error}
-`);
-        }
+      if (!hasFailedBefore) {
+        ctx.output.exitCode = 1;
+        ctx.output.reason = "intentional first-attempt failure for task job live test";
+        return;
       }
-      goal.state = "done";
+      ctx.output.exitCode = 0;
+      ctx.output.reason = "task job live test succeeded after prior failure";
     };
   }
 });
@@ -8721,7 +8863,7 @@ var init_finalizeTerminal = __esm({
 });
 
 // src/scripts/finishFlow.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var TERMINAL_PHASE, API_TIMEOUT_MS5, STATUS_ICON, finishFlow;
 var init_finishFlow = __esm({
   "src/scripts/finishFlow.ts"() {
@@ -8768,7 +8910,7 @@ var init_finishFlow = __esm({
 **PR:** ${state.core.prUrl}` : "";
       const body = `${icon} kody flow \`${flowName}\` finished \u2014 \`${reason}\`${prSuffix}`;
       try {
-        execFileSync13("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+        execFileSync14("gh", ["issue", "comment", String(issueNumber), "--body", body], {
           timeout: API_TIMEOUT_MS5,
           cwd: ctx.cwd,
           stdio: ["ignore", "pipe", "pipe"]
@@ -8800,9 +8942,9 @@ var init_finishFlow = __esm({
 });
 
 // src/branch.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 function git3(args, cwd) {
-  return execFileSync14("git", args, {
+  return execFileSync15("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -8819,11 +8961,11 @@ function getCurrentBranch(cwd) {
 }
 function resetWorkingTree2(cwd) {
   try {
-    execFileSync14("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync15("git", ["reset", "--hard", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync14("git", ["clean", "-fd", "-e", ".kody"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync15("git", ["clean", "-fd", "-e", ".kody"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
 }
@@ -8835,11 +8977,11 @@ function checkoutPrBranch(prNumber, cwd) {
     GH_TOKEN: process.env.GH_PAT?.trim() || process.env.GH_TOKEN || ""
   };
   try {
-    execFileSync14("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+    execFileSync15("git", ["reset", "--hard", "HEAD"], { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
   } catch {
   }
   try {
-    execFileSync14("git", ["clean", "-fd", "-e", ".kody"], {
+    execFileSync15("git", ["clean", "-fd", "-e", ".kody"], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -8847,7 +8989,7 @@ function checkoutPrBranch(prNumber, cwd) {
     });
   } catch {
   }
-  execFileSync14("gh", ["pr", "checkout", String(prNumber)], {
+  execFileSync15("gh", ["pr", "checkout", String(prNumber)], {
     cwd,
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -8880,7 +9022,7 @@ function mergeBase(baseBranch, cwd) {
 }
 function restoreKodyAssets(cwd) {
   try {
-    execFileSync14("git", ["checkout", "HEAD", "--", ".kody"], {
+    execFileSync15("git", ["checkout", "HEAD", "--", ".kody"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 3e4
@@ -8994,14 +9136,14 @@ var init_branch = __esm({
 });
 
 // src/workflow.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 function ghToken3() {
   return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
 }
 function gh3(args, cwd) {
   const token = ghToken3();
   const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync15("gh", args, {
+  return execFileSync16("gh", args, {
     encoding: "utf-8",
     timeout: GH_TIMEOUT_MS,
     cwd,
@@ -9215,66 +9357,14 @@ var init_fixFlow = __esm({
   }
 });
 
-// src/scripts/handleAbandonedGoal.ts
-var handleAbandonedGoal;
-var init_handleAbandonedGoal = __esm({
-  "src/scripts/handleAbandonedGoal.ts"() {
-    "use strict";
-    init_operations();
-    handleAbandonedGoal = async (ctx) => {
-      const goal = ctx.data.goal;
-      if (!goal || goal.state !== "abandoned") return;
-      process.stdout.write(`[goal-tick] ${goal.id} is abandoned \u2014 running cleanup
-`);
-      const issues = listGoalIssues(goal.id, ctx.cwd);
-      if (!issues.ok) {
-        process.stderr.write(`[goal-tick] handleAbandonedGoal: list issues failed: ${issues.error}
-`);
-      } else {
-        const issueNumbers = /* @__PURE__ */ new Set();
-        for (const i of issues.value ?? []) {
-          if (i.state !== "OPEN") continue;
-          issueNumbers.add(i.number);
-          const r = closeIssue(
-            i.number,
-            {
-              comment: "_Goal abandoned \u2014 closing this task without dispatch._",
-              reason: "not planned"
-            },
-            ctx.cwd
-          );
-          if (!r.ok) {
-            process.stderr.write(`[goal-tick] handleAbandonedGoal: failed to close #${i.number}: ${r.error}
-`);
-          }
-        }
-        const prs = listOpenPrs(ctx.cwd);
-        if (prs.ok) {
-          for (const pr of prs.value ?? []) {
-            const headMatch = pr.headRefName.match(/^(\d+)-/);
-            const headIssue = headMatch ? Number.parseInt(headMatch[1], 10) : NaN;
-            if (!Number.isFinite(headIssue) || !issueNumbers.has(headIssue)) continue;
-            const r = closePr(pr.number, "_Goal abandoned \u2014 closing stacked PR._", ctx.cwd);
-            if (!r.ok) {
-              process.stderr.write(`[goal-tick] handleAbandonedGoal: failed to close PR #${pr.number}: ${r.error}
-`);
-            }
-          }
-        }
-      }
-      goal.state = "closed";
-    };
-  }
-});
-
 // src/scripts/initFlow.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs30 from "fs";
-import * as path28 from "path";
+import { execFileSync as execFileSync17 } from "child_process";
+import * as fs31 from "fs";
+import * as path29 from "path";
 function detectPackageManager(cwd) {
-  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";
+  if (fs31.existsSync(path29.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs31.existsSync(path29.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs31.existsSync(path29.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -9294,7 +9384,7 @@ function schemaUrlFromPkg() {
 function detectOwnerRepo(cwd) {
   let url;
   try {
-    url = execFileSync16("git", ["remote", "get-url", "origin"], {
+    url = execFileSync17("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -9322,7 +9412,7 @@ function makeConfig(pm, ownerRepo, defaultBranch2) {
 }
 function defaultBranchFromGit(cwd) {
   try {
-    const ref = execFileSync16("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync17("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -9330,7 +9420,7 @@ function defaultBranchFromGit(cwd) {
     return ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      return execFileSync16("git", ["branch", "--show-current"], {
+      return execFileSync17("git", ["branch", "--show-current"], {
         cwd,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -9346,51 +9436,51 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch2 = defaultBranchFromGit(cwd);
-  const configPath = path28.join(cwd, "kody.config.json");
-  if (fs30.existsSync(configPath) && !force) {
+  const configPath = path29.join(cwd, "kody.config.json");
+  if (fs31.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch2);
-    fs30.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs31.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path28.join(cwd, ".github", "workflows");
-  const workflowPath = path28.join(workflowDir, "kody.yml");
-  if (fs30.existsSync(workflowPath) && !force) {
+  const workflowDir = path29.join(cwd, ".github", "workflows");
+  const workflowPath = path29.join(workflowDir, "kody.yml");
+  if (fs31.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody.yml");
   } else {
-    fs30.mkdirSync(workflowDir, { recursive: true });
-    fs30.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs31.mkdirSync(workflowDir, { recursive: true });
+    fs31.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody.yml");
   }
   const builtinJobs = listBuiltinJobs();
   if (builtinJobs.length > 0) {
-    const jobsDir = path28.join(cwd, ".kody", "duties");
-    fs30.mkdirSync(jobsDir, { recursive: true });
+    const jobsDir = path29.join(cwd, ".kody", "duties");
+    fs31.mkdirSync(jobsDir, { recursive: true });
     for (const job of builtinJobs) {
-      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) {
+      const targetDir = path29.join(jobsDir, job.slug);
+      const relProfile = path29.join(".kody", "duties", job.slug, "profile.json");
+      const relBody = path29.join(".kody", "duties", job.slug, "duty.md");
+      if (fs31.existsSync(targetDir) && fs31.existsSync(path29.join(targetDir, "profile.json")) && !force) {
         skipped.push(relProfile);
         skipped.push(relBody);
         continue;
       }
-      fs30.mkdirSync(targetDir, { recursive: true });
-      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"));
+      fs31.mkdirSync(targetDir, { recursive: true });
+      fs31.writeFileSync(path29.join(targetDir, "profile.json"), fs31.readFileSync(job.profilePath, "utf-8"));
+      fs31.writeFileSync(path29.join(targetDir, "duty.md"), fs31.readFileSync(job.bodyPath, "utf-8"));
       wrote.push(relProfile);
       wrote.push(relBody);
     }
   }
-  const staffDir = path28.join(cwd, ".kody", "staff");
-  const staffPath = path28.join(staffDir, "kody.md");
-  if (fs30.existsSync(staffPath) && !force) {
+  const staffDir = path29.join(cwd, ".kody", "staff");
+  const staffPath = path29.join(staffDir, "kody.md");
+  if (fs31.existsSync(staffPath) && !force) {
     skipped.push(".kody/staff/kody.md");
   } else {
-    fs30.mkdirSync(staffDir, { recursive: true });
-    fs30.writeFileSync(staffPath, DEFAULT_STAFF_PERSONA);
+    fs31.mkdirSync(staffDir, { recursive: true });
+    fs31.writeFileSync(staffPath, DEFAULT_STAFF_PERSONA);
     wrote.push(".kody/staff/kody.md");
   }
   for (const exe of listExecutables()) {
@@ -9401,12 +9491,12 @@ function performInit(cwd, force) {
       continue;
     }
     if (profile.kind !== "scheduled" || !profile.schedule) continue;
-    const target = path28.join(workflowDir, `kody-${exe.name}.yml`);
-    if (fs30.existsSync(target) && !force) {
+    const target = path29.join(workflowDir, `kody-${exe.name}.yml`);
+    if (fs31.existsSync(target) && !force) {
       skipped.push(`.github/workflows/kody-${exe.name}.yml`);
       continue;
     }
-    fs30.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    fs31.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
     wrote.push(`.github/workflows/kody-${exe.name}.yml`);
   }
   let labels;
@@ -9419,7 +9509,7 @@ function performInit(cwd, force) {
 }
 function renderScheduledWorkflow(name, cron) {
   return `# Scheduled kody duty: ${name}
-# Generated by \`kody init\`. Regenerate with \`kody init --force\`.
+# Generated by \`kody-engine init\`. Regenerate with \`kody-engine init --force\`.
 # Edit the cron below or the duty's implementation profile.json#schedule.
 
 name: kody ${name}
@@ -9482,6 +9572,16 @@ on:
         description: "GitHub issue number"
         required: true
         type: string
+      duty:
+        description: "Duty action to run (default: run)"
+        required: false
+        type: string
+        default: ""
+      executable:
+        description: "Legacy alias for duty action"
+        required: false
+        type: string
+        default: ""
   issue_comment:
     types: [created]
 
@@ -9527,7 +9627,7 @@ When a duty writes a report or dispatches work, keep the output factual and conc
       const force = ctx.args.force === true;
       const cwd = ctx.cwd;
       const { wrote, skipped, labels } = performInit(cwd, force);
-      process.stdout.write("\u2192 kody init\n");
+      process.stdout.write("\u2192 kody-engine init\n");
       for (const f of wrote) process.stdout.write(`  wrote    ${f}
 `);
       for (const f of skipped) process.stdout.write(`  skipped  ${f} (already exists; pass --force to overwrite)
@@ -9630,7 +9730,7 @@ var init_loadGoalState = __esm({
       try {
         const state = fetchGoalState(owner, repo, goalId, ctx.cwd);
         if (!state) {
-          process.stdout.write(`[goal-tick] no goal state for ${goalId} on ${owner}/${repo} \u2014 nothing to tick
+          process.stdout.write(`[goal-manager] no goal state for ${goalId} on ${owner}/${repo}; nothing to tick
 `);
           ctx.skipAgent = true;
           ctx.output.exitCode = 0;
@@ -9640,17 +9740,11 @@ var init_loadGoalState = __esm({
         ctx.data.goal = {
           id: goalId,
           state: state.state,
-          lastDispatchedIssue: state.lastDispatchedIssue,
-          // Cache the full parsed object so saveGoalState can preserve `extra`.
           raw: state,
-          // `phase`, `childTasks`, `openTaskPrs`, `leafPr` are populated by
-          // deriveGoalPhase later in the chain. Initialize to undefined so
-          // runWhen on `data.goal.phase` can match correctly.
-          phase: void 0,
           defaultBranch: ctx.config.git.defaultBranch
         };
       } catch (err) {
-        process.stdout.write(`[goal-tick] ${err instanceof Error ? err.message : String(err)}
+        process.stdout.write(`[goal-manager] ${err instanceof Error ? err.message : String(err)}
 `);
         ctx.skipAgent = true;
         ctx.output.exitCode = 0;
@@ -9725,9 +9819,63 @@ var init_loadIssueStateComment = __esm({
   }
 });
 
+// src/staff.ts
+import * as fs32 from "fs";
+import * as path30 from "path";
+function stripFrontmatter(raw) {
+  const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
+  return (match ? match[1] : raw).trim();
+}
+function loadStaffPersona(cwd, slug, staffDir = DEFAULT_STAFF_DIR) {
+  const trimmed = slug.trim();
+  if (!trimmed) throw new Error("loadStaffPersona: empty staff slug");
+  const staffPath = resolveStaffPersonaFile(cwd, trimmed, staffDir);
+  if (fs32.existsSync(staffPath)) {
+    const body = stripFrontmatter(fs32.readFileSync(staffPath, "utf-8"));
+    if (body) return body;
+    const builtinForEmpty = BUILTIN_PERSONAS[trimmed];
+    if (builtinForEmpty) return builtinForEmpty;
+    throw new Error(`loadStaffPersona: staff '${trimmed}' persona body is empty (${staffPath})`);
+  }
+  const builtin = BUILTIN_PERSONAS[trimmed];
+  if (builtin) return builtin;
+  throw new Error(`loadStaffPersona: staff '${trimmed}' declared but ${staffPath} does not exist`);
+}
+function resolveStaffPersonaFile(cwd, slug, staffDir = DEFAULT_STAFF_DIR) {
+  const localPath = path30.join(cwd, staffDir, `${slug}.md`);
+  if (fs32.existsSync(localPath)) return localPath;
+  const storeStaffRoot = getCompanyStoreAssetRoot("staff");
+  if (storeStaffRoot) {
+    const storePath = path30.join(storeStaffRoot, `${slug}.md`);
+    if (fs32.existsSync(storePath)) return storePath;
+  }
+  return localPath;
+}
+function framePersona(slug, persona) {
+  return [
+    `## Who you are \u2014 staff persona (authoritative identity)`,
+    ``,
+    `You are operating as staff member \`${slug}\`. This persona defines *who* you are:`,
+    `your authority, doctrine, voice, and hard limits. Honour it exactly. Where the`,
+    `persona's restrictions are stricter than the task, **the persona wins** \u2014 a task`,
+    `can never grant you authority your persona withholds.`,
+    ``,
+    persona
+  ].join("\n");
+}
+var DEFAULT_STAFF_DIR, BUILTIN_PERSONAS;
+var init_staff = __esm({
+  "src/staff.ts"() {
+    "use strict";
+    init_companyStore();
+    DEFAULT_STAFF_DIR = ".kody/staff";
+    BUILTIN_PERSONAS = {};
+  }
+});
+
 // src/scripts/loadJobFromFile.ts
-import * as fs31 from "fs";
-import * as path29 from "path";
+import * as fs33 from "fs";
+import * as path31 from "path";
 function parseJobFile(raw, slug) {
   let stripped = raw;
   if (stripped.startsWith("---\n")) {
@@ -9752,8 +9900,9 @@ var DUTY_TOOL_PALETTE2, loadJobFromFile;
 var init_loadJobFromFile = __esm({
   "src/scripts/loadJobFromFile.ts"() {
     "use strict";
-    init_dutyFolders();
     init_dutyMcp();
+    init_registry();
+    init_staff();
     init_jobState();
     DUTY_TOOL_PALETTE2 = new Set(DUTY_MCP_TOOL_NAMES);
     loadJobFromFile = async (ctx, profile, args) => {
@@ -9764,9 +9913,9 @@ var init_loadJobFromFile = __esm({
       if (!slug) {
         throw new Error(`loadJobFromFile: ctx.args.${slugArg} must be a non-empty slug`);
       }
-      const duty = readDutyFolder(path29.join(ctx.cwd, jobsDir), slug);
+      const duty = resolveDutyFolder(slug, path31.join(ctx.cwd, jobsDir));
       if (!duty) {
-        throw new Error(`loadJobFromFile: duty folder not found or incomplete: ${path29.join(ctx.cwd, jobsDir, slug)}`);
+        throw new Error(`loadJobFromFile: duty folder not found or incomplete: ${path31.join(ctx.cwd, jobsDir, slug)}`);
       }
       const { title, body, config } = duty;
       const mentions = (config.mentions ?? []).map((login) => `@${login}`).join(" ");
@@ -9774,11 +9923,11 @@ var init_loadJobFromFile = __esm({
       let workerTitle = "";
       let workerPersona = "";
       if (workerSlug) {
-        const workerPath = path29.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-        if (!fs31.existsSync(workerPath)) {
+        const workerPath = resolveStaffPersonaFile(ctx.cwd, workerSlug, workersDir);
+        if (!fs33.existsSync(workerPath)) {
           throw new Error(`loadJobFromFile: duty '${slug}' declares staff '${workerSlug}' but ${workerPath} does not exist`);
         }
-        const workerRaw = fs31.readFileSync(workerPath, "utf-8");
+        const workerRaw = fs33.readFileSync(workerPath, "utf-8");
         const parsed = parseJobFile(workerRaw, workerSlug);
         workerTitle = parsed.title;
         workerPersona = parsed.body;
@@ -9852,13 +10001,13 @@ ${truncate2(issue.body, FINDING_BODY_MAX_BYTES)}`;
 });
 
 // src/scripts/kodyVariables.ts
-import * as fs32 from "fs";
-import * as path30 from "path";
+import * as fs34 from "fs";
+import * as path32 from "path";
 function readKodyVariables(cwd) {
-  const full = path30.join(cwd, KODY_VARIABLES_REL_PATH);
+  const full = path32.join(cwd, KODY_VARIABLES_REL_PATH);
   let raw;
   try {
-    raw = fs32.readFileSync(full, "utf-8");
+    raw = fs34.readFileSync(full, "utf-8");
   } catch {
     return {};
   }
@@ -9883,8 +10032,8 @@ var init_kodyVariables = __esm({
 });
 
 // src/scripts/loadQaContext.ts
-import * as fs33 from "fs";
-import * as path31 from "path";
+import * as fs35 from "fs";
+import * as path33 from "path";
 function parseSlugList(value) {
   const inner = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
   return inner.split(",").map(
@@ -9913,18 +10062,18 @@ function readProfileStaff(raw) {
   return { staff: staff ?? legacy ?? ["kody"], body };
 }
 function readProfile(cwd) {
-  const dir = path31.join(cwd, CONTEXT_DIR_REL_PATH);
-  if (!fs33.existsSync(dir)) return "";
+  const dir = path33.join(cwd, CONTEXT_DIR_REL_PATH);
+  if (!fs35.existsSync(dir)) return "";
   let entries;
   try {
-    entries = fs33.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    entries = fs35.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const blocks = [];
   for (const file of entries) {
     try {
-      const raw = fs33.readFileSync(path31.join(dir, file), "utf-8");
+      const raw = fs35.readFileSync(path33.join(dir, file), "utf-8");
       const { staff, body } = readProfileStaff(raw);
       if (!staff.includes(QA_STAFF) && !staff.includes(ALL_STAFF)) continue;
       blocks.push(`## ${file}
@@ -9970,8 +10119,8 @@ var init_loadQaContext = __esm({
 });
 
 // src/taskContext.ts
-import * as fs34 from "fs";
-import * as path32 from "path";
+import * as fs36 from "fs";
+import * as path34 from "path";
 function buildTaskContext(args) {
   return {
     schemaVersion: TASK_CONTEXT_SCHEMA_VERSION,
@@ -9986,10 +10135,10 @@ function buildTaskContext(args) {
 }
 function persistTaskContext(cwd, ctx) {
   try {
-    const dir = path32.join(cwd, ".kody", "runs", ctx.runId);
-    fs34.mkdirSync(dir, { recursive: true });
-    const file = path32.join(dir, "task-context.json");
-    fs34.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
+    const dir = path34.join(cwd, ".kody", "runs", ctx.runId);
+    fs36.mkdirSync(dir, { recursive: true });
+    const file = path34.join(dir, "task-context.json");
+    fs36.writeFileSync(file, `${JSON.stringify(ctx, null, 2)}
 `);
     return file;
   } catch (err) {
@@ -10077,8 +10226,7 @@ var init_loadTaskState = __esm({
 });
 
 // src/scripts/loadWorkerAdhoc.ts
-import * as fs35 from "fs";
-import * as path33 from "path";
+import * as fs37 from "fs";
 function resolveMessage(messageArg) {
   const fromComment = readCommentBody();
   if (fromComment) return stripDirective(fromComment);
@@ -10086,9 +10234,9 @@ function resolveMessage(messageArg) {
 }
 function readCommentBody() {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !fs35.existsSync(eventPath)) return "";
+  if (!eventPath || !fs37.existsSync(eventPath)) return "";
   try {
-    const event = JSON.parse(fs35.readFileSync(eventPath, "utf-8"));
+    const event = JSON.parse(fs37.readFileSync(eventPath, "utf-8"));
     return String(event.comment?.body ?? "");
   } catch {
     return "";
@@ -10133,17 +10281,18 @@ var loadWorkerAdhoc;
 var init_loadWorkerAdhoc = __esm({
   "src/scripts/loadWorkerAdhoc.ts"() {
     "use strict";
+    init_staff();
     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 = path33.join(ctx.cwd, workersDir, `${workerSlug}.md`);
-      if (!fs35.existsSync(workerPath)) {
+      const workerPath = resolveStaffPersonaFile(ctx.cwd, workerSlug, workersDir);
+      if (!fs37.existsSync(workerPath)) {
         throw new Error(`loadWorkerAdhoc: worker persona not found: ${workerPath}`);
       }
-      const { title, body } = parsePersona(fs35.readFileSync(workerPath, "utf-8"), workerSlug);
+      const { title, body } = parsePersona(fs37.readFileSync(workerPath, "utf-8"), workerSlug);
       const message = resolveMessage(ctx.args.message);
       if (!message) {
         throw new Error(
@@ -10173,6 +10322,37 @@ var init_markFlowSuccess = __esm({
   }
 });
 
+// src/goal/operations.ts
+function fail(err) {
+  if (err instanceof Error) {
+    const lines = err.message.split("\n").filter(Boolean);
+    return { ok: false, error: lines[0] ?? err.message };
+  }
+  return { ok: false, error: String(err) };
+}
+function commentOnIssue(issueNumber, body, cwd) {
+  try {
+    gh(["issue", "comment", String(issueNumber), "--body", body], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+function mergePrSquash(prNumber, cwd) {
+  try {
+    gh(["pr", "merge", String(prNumber), "--squash", "--delete-branch"], { cwd });
+    return { ok: true };
+  } catch (err) {
+    return fail(err);
+  }
+}
+var init_operations = __esm({
+  "src/goal/operations.ts"() {
+    "use strict";
+    init_issue();
+  }
+});
+
 // src/scripts/mergeFlow.ts
 function readPr(prNumber, cwd) {
   const out = gh(["pr", "view", String(prNumber), "--json", "state,isDraft,mergeable,mergeStateStatus,title,url"], {
@@ -10286,7 +10466,7 @@ var init_mergeFlow = __esm({
 });
 
 // src/scripts/mergeReleasePr.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 function makeAction(type, payload) {
   return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
 }
@@ -10318,7 +10498,7 @@ var init_mergeReleasePr = __esm({
       process.stderr.write(`[kody mergeReleasePr] merging PR #${prNumber} (${prUrl})
 `);
       try {
-        const out = execFileSync17("gh", ["pr", "merge", String(prNumber), "--merge"], {
+        const out = execFileSync18("gh", ["pr", "merge", String(prNumber), "--merge"], {
           timeout: API_TIMEOUT_MS6,
           cwd: ctx.cwd,
           stdio: ["ignore", "pipe", "pipe"]
@@ -11114,7 +11294,7 @@ var init_promoteQaGoal = __esm({
 });
 
 // src/scripts/recordClassification.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 function parseClassification(prSummary) {
   if (!prSummary) return null;
   const classMatch = prSummary.match(/classification:\s*(feature|bug|spec|chore)\b/i);
@@ -11126,7 +11306,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync18("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync19("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS7,
       stdio: ["ignore", "pipe", "pipe"]
@@ -11306,7 +11486,7 @@ var init_resolveArtifacts = __esm({
 });
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 function buildPreferBlock(prefer, baseBranch) {
   if (prefer !== "ours" && prefer !== "theirs") return "";
   const keepSide = prefer === "ours" ? "HEAD (this PR branch)" : `origin/${baseBranch} (base branch)`;
@@ -11326,7 +11506,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync19("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync20("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -11341,7 +11521,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync19("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync20("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -11365,12 +11545,12 @@ function tryPostPr3(prNumber, body, cwd) {
 function pushEmptyCommit(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync19(
+    execFileSync20(
       "git",
       ["commit", "--allow-empty", "-m", "chore: kody resolve refresh \u2014 empty commit to recompute mergeable status"],
       { cwd, env, stdio: ["ignore", "pipe", "pipe"] }
     );
-    execFileSync19("git", ["push", "-u", "origin", branch], {
+    execFileSync20("git", ["push", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -11556,10 +11736,10 @@ var init_resolvePreviewUrl = __esm({
 });
 
 // src/scripts/resolveQaUrl.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 function ghQuery(args, cwd) {
   try {
-    const out = execFileSync20("gh", args, {
+    const out = execFileSync21("gh", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
@@ -11636,7 +11816,7 @@ var init_resolveQaUrl = __esm({
 });
 
 // src/scripts/revertFlow.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 function buildCommitMessage(resolved) {
   if (resolved.length === 1) {
     const { full, subject } = resolved[0];
@@ -11649,7 +11829,7 @@ function buildPrSummary(resolved) {
   return resolved.map((r) => `- Reverted \`${r.full.slice(0, 7)}\`${r.subject ? ` \u2014 ${r.subject}` : ""}`).join("\n");
 }
 function git4(args, cwd) {
-  return execFileSync21("git", args, {
+  return execFileSync22("git", args, {
     encoding: "utf-8",
     timeout: 3e4,
     cwd,
@@ -11659,7 +11839,7 @@ function git4(args, cwd) {
 }
 function isAncestorOfHead(sha, cwd) {
   try {
-    execFileSync21("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+    execFileSync22("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
       cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: ["ignore", "ignore", "ignore"]
@@ -11854,9 +12034,9 @@ var init_runFlow = __esm({
 });
 
 // src/scripts/previewBuildHelpers.ts
-import { createDecipheriv, createHash } from "crypto";
+import { createDecipheriv, createHash as createHash2 } from "crypto";
 function shortHash(s) {
-  return createHash("sha256").update(s).digest("hex").slice(0, 6);
+  return createHash2("sha256").update(s).digest("hex").slice(0, 6);
 }
 function previewAppName(repo, pr) {
   const [owner, name] = repo.split("/");
@@ -11910,7 +12090,7 @@ function formatPreviewComment(args) {
   ].join("\n");
 }
 function defaultImageTag(repo, ref) {
-  return createHash("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
+  return createHash2("sha256").update(`${repo}@${ref}`).digest("hex").slice(0, 12);
 }
 var NEVER_PASS_TO_BUILD;
 var init_previewBuildHelpers = __esm({
@@ -11930,7 +12110,7 @@ var init_previewBuildHelpers = __esm({
 // src/scripts/previewBuildRun.ts
 import { spawn as spawn4 } from "child_process";
 async function runCmd(cmd, args, opts = {}) {
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     const child = spawn4(cmd, args, {
       cwd: opts.cwd,
       env: { ...process.env, ...opts.env ?? {} },
@@ -11942,7 +12122,7 @@ async function runCmd(cmd, args, opts = {}) {
     }
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}`));
     });
   });
@@ -12014,12 +12194,12 @@ fi
 
 // src/scripts/runPreviewBuild.ts
 import { copyFile, writeFile } from "fs/promises";
-import * as path34 from "path";
+import * as path35 from "path";
 import { fileURLToPath } from "url";
 function bundledDockerfilePath(mode) {
-  const here = path34.dirname(fileURLToPath(import.meta.url));
+  const here = path35.dirname(fileURLToPath(import.meta.url));
   const file = mode === "dev" ? "default-Dockerfile.preview.dev" : "default-Dockerfile.preview.prod";
-  return path34.join(here, "preview-build-templates", file);
+  return path35.join(here, "preview-build-templates", file);
 }
 function required(name) {
   const v = (process.env[name] ?? "").trim();
@@ -12278,10 +12458,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(path34.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
+          await writeFile(path35.join(ctx.cwd, ".env.production.local"), `${lines.join("\n")}
 `, "utf8");
         }
-        const consumerDockerfile = path34.join(ctx.cwd, "Dockerfile.preview");
+        const consumerDockerfile = path35.join(ctx.cwd, "Dockerfile.preview");
         const { stat } = await import("fs/promises");
         let hasConsumerDockerfile = false;
         try {
@@ -12461,8 +12641,8 @@ var init_tickShellRunner = __esm({
 });
 
 // src/scripts/runScheduledExecutableTick.ts
-import * as fs36 from "fs";
-import * as path35 from "path";
+import * as fs38 from "fs";
+import * as path36 from "path";
 var runScheduledExecutableTick;
 var init_runScheduledExecutableTick = __esm({
   "src/scripts/runScheduledExecutableTick.ts"() {
@@ -12482,14 +12662,14 @@ var init_runScheduledExecutableTick = __esm({
         ctx.output.reason = `runScheduledExecutableTick: ctx.args.${slugArg} must be non-empty duty slug`;
         return;
       }
-      const duty = readDutyFolder(path35.join(ctx.cwd, jobsDir), slug);
+      const duty = readDutyFolder(path36.join(ctx.cwd, jobsDir), slug);
       if (!duty) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runScheduledExecutableTick: duty folder not found or incomplete: ${path35.join(jobsDir, slug)}`;
+        ctx.output.reason = `runScheduledExecutableTick: duty folder not found or incomplete: ${path36.join(jobsDir, slug)}`;
         return;
       }
-      const shellPath = path35.join(profile.dir, shell);
-      if (!fs36.existsSync(shellPath)) {
+      const shellPath = path36.join(profile.dir, shell);
+      if (!fs38.existsSync(shellPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runScheduledExecutableTick: shell not found: ${shell} (looked in ${profile.dir})`;
         return;
@@ -12520,8 +12700,8 @@ var init_runScheduledExecutableTick = __esm({
 });
 
 // src/scripts/runTickScript.ts
-import * as fs37 from "fs";
-import * as path36 from "path";
+import * as fs39 from "fs";
+import * as path37 from "path";
 var runTickScript;
 var init_runTickScript = __esm({
   "src/scripts/runTickScript.ts"() {
@@ -12540,10 +12720,10 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: ctx.args.${slugArg} must be a non-empty slug`;
         return;
       }
-      const duty = readDutyFolder(path36.join(ctx.cwd, jobsDir), slug);
+      const duty = readDutyFolder(path37.join(ctx.cwd, jobsDir), slug);
       if (!duty) {
         ctx.output.exitCode = 99;
-        ctx.output.reason = `runTickScript: duty folder not found or incomplete: ${path36.join(ctx.cwd, jobsDir, slug)}`;
+        ctx.output.reason = `runTickScript: duty folder not found or incomplete: ${path37.join(ctx.cwd, jobsDir, slug)}`;
         return;
       }
       const tickScript = duty.config.tickScript;
@@ -12552,8 +12732,8 @@ var init_runTickScript = __esm({
         ctx.output.reason = `runTickScript: duty ${slug} has no \`tickScript\` in profile.json \u2014 route via duty-tick instead`;
         return;
       }
-      const scriptPath = path36.isAbsolute(tickScript) ? tickScript : path36.join(ctx.cwd, tickScript);
-      if (!fs37.existsSync(scriptPath)) {
+      const scriptPath = path37.isAbsolute(tickScript) ? tickScript : path37.join(ctx.cwd, tickScript);
+      if (!fs39.existsSync(scriptPath)) {
         ctx.output.exitCode = 99;
         ctx.output.reason = `runTickScript: tickScript not found: ${scriptPath}`;
         return;
@@ -12582,29 +12762,21 @@ var init_runTickScript = __esm({
   }
 });
 
-// src/scripts/saveGoalState.ts
-var saveGoalState;
-var init_saveGoalState = __esm({
-  "src/scripts/saveGoalState.ts"() {
+// src/scripts/saveManagedGoalState.ts
+var saveManagedGoalState;
+var init_saveManagedGoalState = __esm({
+  "src/scripts/saveManagedGoalState.ts"() {
     "use strict";
     init_state2();
-    saveGoalState = async (ctx) => {
+    saveManagedGoalState = async (ctx) => {
+      ctx.skipAgent = true;
       const goal = ctx.data.goal;
-      if (!goal) {
-        ctx.skipAgent = true;
-        return;
-      }
-      const prev = goal.raw;
-      const changed = !prev || prev.state !== goal.state || prev.lastDispatchedIssue !== goal.lastDispatchedIssue;
-      const updated = {
-        ...prev ?? { state: goal.state, extra: {} },
-        state: goal.state,
-        lastDispatchedIssue: goal.lastDispatchedIssue,
-        updatedAt: changed ? nowIso() : prev?.updatedAt
-      };
+      if (!goal?.raw) return;
+      const original = typeof ctx.data.goalOriginalStateText === "string" ? ctx.data.goalOriginalStateText : "";
+      const changedBeforeTimestamp = original !== serializeGoalState(goal.raw);
+      const updated = changedBeforeTimestamp ? { ...goal.raw, updatedAt: nowIso() } : goal.raw;
       ctx.data.goalPersistState = updated;
-      ctx.data.goalPersistChanged = changed;
-      ctx.skipAgent = true;
+      ctx.data.goalPersistChanged = original !== serializeGoalState(updated);
     };
   }
 });
@@ -12674,7 +12846,7 @@ var init_skipAgent = __esm({
 });
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync22 } from "child_process";
+import { execFileSync as execFileSync23 } from "child_process";
 var stageMergeConflicts;
 var init_stageMergeConflicts = __esm({
   "src/scripts/stageMergeConflicts.ts"() {
@@ -12682,7 +12854,7 @@ var init_stageMergeConflicts = __esm({
     stageMergeConflicts = async (ctx) => {
       if (ctx.data.agentDone === false) return;
       try {
-        execFileSync22("git", ["add", "-A"], {
+        execFileSync23("git", ["add", "-A"], {
           cwd: ctx.cwd,
           env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
           stdio: "pipe"
@@ -12736,7 +12908,7 @@ var init_startFlow = __esm({
 });
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync23 } from "child_process";
+import { execFileSync as execFileSync24 } from "child_process";
 function restoreDone(prNumber, cwd) {
   try {
     setKodyLabel(prNumber, DONE2, cwd);
@@ -12753,7 +12925,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync23("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync24("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -12896,7 +13068,7 @@ function stripAnsi2(s) {
   return s.replace(ANSI_RE2, "");
 }
 function runCommand2(command, cwd) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn5(command, {
       cwd,
       shell: true,
@@ -12923,11 +13095,11 @@ function runCommand2(command, cwd) {
     }, TEST_TIMEOUT_MS);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve6({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+      resolve7({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve6({ exitCode: -1, output: err.message });
+      resolve7({ exitCode: -1, output: err.message });
     });
   });
 }
@@ -13094,10 +13266,10 @@ var init_verifyWithRetry = __esm({
 });
 
 // src/scripts/waitForCi.ts
-import { execFileSync as execFileSync24 } from "child_process";
+import { execFileSync as execFileSync25 } from "child_process";
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync24("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync25("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS8,
       cwd,
@@ -13332,21 +13504,21 @@ function lineStream(stream) {
     tryDeliver();
   });
   return {
-    next: (timeoutMs) => new Promise((resolve6) => {
+    next: (timeoutMs) => new Promise((resolve7) => {
       if (queue.length > 0) {
-        resolve6(queue.shift());
+        resolve7(queue.shift());
         return;
       }
       if (ended) {
-        resolve6(null);
+        resolve7(null);
         return;
       }
-      waiter = resolve6;
+      waiter = resolve7;
       const t = setTimeout(
         () => {
-          if (waiter === resolve6) {
+          if (waiter === resolve7) {
             waiter = null;
-            resolve6(null);
+            resolve7(null);
           }
         },
         Math.max(0, timeoutMs)
@@ -13486,7 +13658,7 @@ var init_writeJobStateFile = __esm({
 });
 
 // src/scripts/writeRunSummary.ts
-import * as fs38 from "fs";
+import * as fs40 from "fs";
 var writeRunSummary;
 var init_writeRunSummary = __esm({
   "src/scripts/writeRunSummary.ts"() {
@@ -13512,7 +13684,7 @@ var init_writeRunSummary = __esm({
       if (reason) lines.push(`- **Reason:** ${reason}`);
       lines.push("");
       try {
-        fs38.appendFileSync(summaryPath, `${lines.join("\n")}
+        fs40.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
       } catch {
       }
@@ -13527,7 +13699,9 @@ var init_scripts = __esm({
     "use strict";
     init_abortUnfinishedGitOps();
     init_advanceFlow();
+    init_advanceManagedGoal();
     init_appendCompanyActivity();
+    init_applyDutyReports();
     init_buildSyntheticPlugin();
     init_checkCoverageWithRetry();
     init_classifyByLabel();
@@ -13535,7 +13709,6 @@ var init_scripts = __esm({
     init_commitGoalState();
     init_composePrompt();
     init_createQaGoal();
-    init_deriveGoalPhase();
     init_deriveQaScopeFromIssue();
     init_diagMcp();
     init_discoverQaContext();
@@ -13543,16 +13716,13 @@ var init_scripts = __esm({
     init_dispatchClassified();
     init_dispatchDutyFileTicks();
     init_dispatchDutyTicks();
-    init_dispatchNextTask();
     init_dispatchNextTaskJob();
     init_ensurePr();
     init_failOnceTaskJob();
-    init_finalizeGoal();
     init_finalizeTerminal();
     init_finishFlow();
     init_fixCiFlow();
     init_fixFlow();
-    init_handleAbandonedGoal();
     init_initFlow();
     init_loadConventions();
     init_loadCoverageRules();
@@ -13601,7 +13771,7 @@ var init_scripts = __esm({
     init_runPreviewBuild();
     init_runScheduledExecutableTick();
     init_runTickScript();
-    init_saveGoalState();
+    init_saveManagedGoalState();
     init_saveTaskState();
     init_setCommentTarget();
     init_setLifecycleLabel();
@@ -13661,12 +13831,9 @@ var init_scripts = __esm({
       runScheduledExecutableTick,
       runTickScript,
       runPreviewBuild,
+      advanceManagedGoal,
       loadGoalState,
-      handleAbandonedGoal,
-      deriveGoalPhase,
-      dispatchNextTask,
-      finalizeGoal,
-      saveGoalState
+      saveManagedGoalState
     };
     postflightScripts = {
       parseAgentResult: parseAgentResult2,
@@ -13701,6 +13868,7 @@ var init_scripts = __esm({
       finalizeTerminal,
       advanceFlow,
       persistFlowState,
+      applyDutyReports,
       recordClassification,
       dispatchClassified,
       notifyTerminal,
@@ -13720,67 +13888,8 @@ var init_scripts = __esm({
   }
 });
 
-// src/staff.ts
-import * as fs39 from "fs";
-import * as path37 from "path";
-function stripFrontmatter(raw) {
-  const match = /^---\n[\s\S]*?\n---\n?([\s\S]*)$/.exec(raw);
-  return (match ? match[1] : raw).trim();
-}
-function loadStaffPersona(cwd, slug, staffDir = DEFAULT_STAFF_DIR) {
-  const trimmed = slug.trim();
-  if (!trimmed) throw new Error("loadStaffPersona: empty staff slug");
-  const staffPath = path37.join(cwd, staffDir, `${trimmed}.md`);
-  if (fs39.existsSync(staffPath)) {
-    const body = stripFrontmatter(fs39.readFileSync(staffPath, "utf-8"));
-    if (body) return body;
-    const builtinForEmpty = BUILTIN_PERSONAS[trimmed];
-    if (builtinForEmpty) return builtinForEmpty;
-    throw new Error(`loadStaffPersona: staff '${trimmed}' persona body is empty (${staffPath})`);
-  }
-  const builtin = BUILTIN_PERSONAS[trimmed];
-  if (builtin) return builtin;
-  throw new Error(`loadStaffPersona: staff '${trimmed}' declared but ${staffPath} does not exist`);
-}
-function framePersona(slug, persona) {
-  return [
-    `## Who you are \u2014 staff persona (authoritative identity)`,
-    ``,
-    `You are operating as staff member \`${slug}\`. This persona defines *who* you are:`,
-    `your authority, doctrine, voice, and hard limits. Honour it exactly. Where the`,
-    `persona's restrictions are stricter than the task, **the persona wins** \u2014 a task`,
-    `can never grant you authority your persona withholds.`,
-    ``,
-    persona
-  ].join("\n");
-}
-var DEFAULT_STAFF_DIR, BUILTIN_PERSONAS;
-var init_staff = __esm({
-  "src/staff.ts"() {
-    "use strict";
-    DEFAULT_STAFF_DIR = ".kody/staff";
-    BUILTIN_PERSONAS = {
-      kody: [
-        "You are **kody**, the repository's autonomous engineer.",
-        "",
-        "- You work the way this repo already works: follow its conventions, its",
-        "  existing patterns, and its tests. Read before you write.",
-        "- You ship small, correct, reviewable changes. You don't refactor beyond the",
-        "  task, and you don't add scope nobody asked for.",
-        "- You are honest about outcomes: if something failed, didn't run, or you're",
-        "  unsure, you say so plainly rather than papering over it.",
-        "- The request that triggered you IS your authorization to do the work:",
-        "  opening a PR, pushing commits, and commenting are exactly what you're for \u2014",
-        "  do them without waiting for extra approval.",
-        "- You still don't weaken security, delete work you didn't create, or take",
-        "  destructive actions beyond the task you were given."
-      ].join("\n")
-    };
-  }
-});
-
 // src/tools.ts
-import { execFileSync as execFileSync25 } from "child_process";
+import { execFileSync as execFileSync26 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -13817,7 +13926,7 @@ function verifyOne(tool5, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    const stdout = execFileSync25("sh", ["-c", cmd], {
+    const stdout = execFileSync26("sh", ["-c", cmd], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       timeout: timeoutMs,
@@ -13845,7 +13954,7 @@ var init_tools = __esm({
 
 // src/executor.ts
 import { spawn as spawn7 } from "child_process";
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as path38 from "path";
 function isMutatingPostflight(scriptName) {
   return MUTATING_POSTFLIGHTS.has(scriptName ?? "");
@@ -13950,6 +14059,8 @@ async function runExecutable(profileName, input) {
   }
   const perExecutableModel = config.agent.perExecutable?.[profileName];
   const modelSpec = perExecutableModel ? perExecutableModel : profile.claudeCode.model === "inherit" ? config.agent.model : profile.claudeCode.model;
+  const profileHasThinkingTokens = typeof profile.claudeCode.maxThinkingTokens === "number" && profile.claudeCode.maxThinkingTokens > 0;
+  const reasoningEffort = config.agent.perExecutableReasoningEffort?.[profileName] ?? profile.claudeCode.reasoningEffort ?? (profileHasThinkingTokens ? void 0 : config.agent.reasoningEffort);
   let model;
   try {
     model = parseProviderModel(modelSpec);
@@ -14025,6 +14136,7 @@ async function runExecutable(profileName, input) {
       pluginPaths: pluginPaths.length > 0 ? pluginPaths : void 0,
       agents,
       maxTurns: profile.claudeCode.maxTurns,
+      reasoningEffort,
       maxThinkingTokens: profile.claudeCode.maxThinkingTokens,
       maxTurnTimeoutMs: typeof profile.claudeCode.maxTurnTimeoutSec === "number" ? Math.floor(profile.claudeCode.maxTurnTimeoutSec * 1e3) : void 0,
       // DISCIPLINE leads so the stable, role-agnostic block sits at the front
@@ -14382,7 +14494,7 @@ function resolveProfilePath(profileName) {
     // fallback
   ];
   for (const c of candidates) {
-    if (fs40.existsSync(c)) return c;
+    if (fs41.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -14481,7 +14593,7 @@ function resolveShellTimeoutMs(entry) {
 async function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
   const shellPath = path38.join(profile.dir, shellName);
-  if (!fs40.existsSync(shellPath)) {
+  if (!fs41.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -14519,14 +14631,14 @@ async function runShellEntry(entry, ctx, profile) {
   let killTimer;
   let escalateTimer;
   const result = await new Promise(
-    (resolve6) => {
+    (resolve7) => {
       let settled = false;
       const settle = (code, signal, spawnErr) => {
         if (settled) return;
         settled = true;
         if (killTimer) clearTimeout(killTimer);
         if (escalateTimer) clearTimeout(escalateTimer);
-        resolve6({ code, signal, spawnErr });
+        resolve7({ code, signal, spawnErr });
       };
       child.on("error", (err) => settle(null, null, err));
       child.on("close", (code, signal) => settle(code, signal));
@@ -14562,6 +14674,11 @@ async function runShellEntry(entry, ctx, profile) {
   if (prUrlMatch?.[1]) ctx.output.prUrl = prUrlMatch[1].trim();
   const reasonMatch = stdout.match(/^KODY_REASON=(.+)$/m);
   if (reasonMatch?.[1]) ctx.output.reason = reasonMatch[1].trim();
+  const dutyReports = parseDutyReportsFromText(stdout);
+  if (dutyReports.length > 0) {
+    const prior = Array.isArray(ctx.data.dutyReports) ? ctx.data.dutyReports : [];
+    ctx.data.dutyReports = [...prior, ...dutyReports];
+  }
   if (timedOut) {
     ctx.skipAgent = true;
     const seconds = Math.round(timeoutMs / 1e3);
@@ -14611,6 +14728,7 @@ var init_executor = __esm({
     init_config();
     init_container();
     init_discipline();
+    init_dutyReport();
     init_events();
     init_lifecycleLabels();
     init_litellm();
@@ -14621,7 +14739,7 @@ var init_executor = __esm({
     init_subagents();
     init_task_artifacts();
     init_tools();
-    MUTATING_POSTFLIGHTS = /* @__PURE__ */ new Set(["commitAndPush", "ensurePr"]);
+    MUTATING_POSTFLIGHTS = /* @__PURE__ */ new Set(["commitAndPush", "ensurePr", "applyDutyReports"]);
     MAX_CHAIN_HOPS = 60;
     DEFAULT_SHELL_TIMEOUT_MS = 3e5;
     SIGKILL_GRACE_MS = 5e3;
@@ -14733,7 +14851,7 @@ async function runJob(job, base) {
 }
 function loadDutyContext(slug, cwd) {
   if (!slug) return null;
-  return readDutyFolder(path39.join(cwd, ".kody", "duties"), slug) ?? readDutyFolder(getProjectDutiesRoot(), slug) ?? readDutyFolder(getBuiltinDutiesRoot(), slug);
+  return resolveDutyFolder(slug, path39.join(cwd, ".kody", "duties"));
 }
 function mintInstantJob(dispatch2, opts) {
   return {
@@ -14762,7 +14880,6 @@ var DEFAULT_INSTANT_PERSONA, localJobSeq, InvalidJobError;
 var init_job = __esm({
   "src/job.ts"() {
     "use strict";
-    init_dutyFolders();
     init_executor();
     init_registry();
     init_jobIdentity();
@@ -14885,7 +15002,7 @@ function translateOpenAISseToBrain(opts) {
 }
 
 // src/servers/brain-serve.ts
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import { createServer } from "http";
 import * as path42 from "path";
 
@@ -14893,12 +15010,12 @@ import * as path42 from "path";
 init_agent();
 init_registry();
 init_task_artifacts();
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 
 // src/chat/attachments.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 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",
@@ -14914,7 +15031,7 @@ function extFor(mime) {
   return EXT_BY_MIME[mime.toLowerCase()] ?? mime.split("/")[1]?.replace(/[^\w]/g, "") ?? "bin";
 }
 function attachmentsDir(cwd, sessionId) {
-  return path9.join(cwd, ".kody", "tmp", "attachments", sessionId);
+  return path10.join(cwd, ".kody", "tmp", "attachments", sessionId);
 }
 function prepareAttachments(turns, cwd, sessionId) {
   const imagePaths = [];
@@ -14931,11 +15048,11 @@ function prepareAttachments(turns, cwd, sessionId) {
         if (!isImage) return `[File: ${name}]`;
         try {
           if (!dirEnsured) {
-            fs9.mkdirSync(dir, { recursive: true });
+            fs10.mkdirSync(dir, { recursive: true });
             dirEnsured = true;
           }
-          const filePath = path9.join(dir, `${imageCounter}.${extFor(mime)}`);
-          fs9.writeFileSync(filePath, Buffer.from(data, "base64"));
+          const filePath = path10.join(dir, `${imageCounter}.${extFor(mime)}`);
+          fs10.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.]`;
@@ -14951,10 +15068,10 @@ function prepareAttachments(turns, cwd, sessionId) {
 }
 
 // src/chat/events.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 function eventsFilePath(cwd, sessionId) {
-  return path10.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
+  return path11.join(cwd, ".kody", "events", `${sessionId}.jsonl`);
 }
 var FileSink = class {
   constructor(file) {
@@ -14962,8 +15079,8 @@ var FileSink = class {
   }
   file;
   async emit(event) {
-    fs10.mkdirSync(path10.dirname(this.file), { recursive: true });
-    fs10.appendFileSync(this.file, `${JSON.stringify(event)}
+    fs11.mkdirSync(path11.dirname(this.file), { recursive: true });
+    fs11.appendFileSync(this.file, `${JSON.stringify(event)}
 `);
   }
 };
@@ -15017,14 +15134,14 @@ function makeRunId(sessionId, suffix) {
 }
 
 // src/chat/session.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 function sessionFilePath(cwd, sessionId) {
-  return path11.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
+  return path12.join(cwd, ".kody", "sessions", `${sessionId}.jsonl`);
 }
 function readMeta(file) {
-  if (!fs11.existsSync(file)) return null;
-  const raw = fs11.readFileSync(file, "utf-8");
+  if (!fs12.existsSync(file)) return null;
+  const raw = fs12.readFileSync(file, "utf-8");
   const firstLine2 = raw.split("\n", 1)[0]?.trim();
   if (!firstLine2) return null;
   try {
@@ -15037,8 +15154,8 @@ function readMeta(file) {
   }
 }
 function readSession(file) {
-  if (!fs11.existsSync(file)) return [];
-  const raw = fs11.readFileSync(file, "utf-8").trim();
+  if (!fs12.existsSync(file)) return [];
+  const raw = fs12.readFileSync(file, "utf-8").trim();
   if (!raw) return [];
   const turns = [];
   for (const line of raw.split("\n")) {
@@ -15054,14 +15171,14 @@ function readSession(file) {
   return turns;
 }
 function appendTurn(file, turn) {
-  fs11.mkdirSync(path11.dirname(file), { recursive: true });
+  fs12.mkdirSync(path12.dirname(file), { recursive: true });
   const line = JSON.stringify({
     role: turn.role,
     content: turn.content,
     timestamp: turn.timestamp,
     toolCalls: turn.toolCalls ?? []
   });
-  fs11.appendFileSync(file, `${line}
+  fs12.appendFileSync(file, `${line}
 `);
 }
 function seedInitialMessage(file, message) {
@@ -15180,7 +15297,7 @@ function buildExecutableCatalog() {
   const entries = [];
   for (const { name, profilePath } of discovered) {
     try {
-      const raw = JSON.parse(fs12.readFileSync(profilePath, "utf-8"));
+      const raw = JSON.parse(fs13.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() });
@@ -15349,10 +15466,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 = path12.join(cwd, MEMORY_INDEX_REL);
+  const indexPath = path13.join(cwd, MEMORY_INDEX_REL);
   let raw;
   try {
-    raw = fs12.readFileSync(indexPath, "utf-8");
+    raw = fs13.readFileSync(indexPath, "utf-8");
   } catch {
     return "";
   }
@@ -15370,17 +15487,17 @@ function readMemoryIndexBlock(cwd) {
 var CONTEXT_DIR_REL = ".kody/context";
 var MAX_CONTEXT_BYTES = 12e3;
 function readContextBlock(cwd) {
-  const dir = path12.join(cwd, CONTEXT_DIR_REL);
+  const dir = path13.join(cwd, CONTEXT_DIR_REL);
   let files;
   try {
-    files = fs12.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    files = fs13.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return "";
   }
   const sections = [];
   for (const file of files) {
     try {
-      const content = fs12.readFileSync(path12.join(dir, file), "utf-8").trim();
+      const content = fs13.readFileSync(path13.join(dir, file), "utf-8").trim();
       if (content) sections.push(`### ${file.replace(/\.md$/, "")}
 
 ${content}`);
@@ -15403,10 +15520,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 = path12.join(cwd, INSTRUCTIONS_REL);
+  const instructionsPath = path13.join(cwd, INSTRUCTIONS_REL);
   let raw;
   try {
-    raw = fs12.readFileSync(instructionsPath, "utf-8");
+    raw = fs13.readFileSync(instructionsPath, "utf-8");
   } catch {
     return "";
   }
@@ -15428,8 +15545,8 @@ _\u2026 (instructions truncated)_` : trimmed;
 init_config();
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync26 } from "child_process";
-import * as fs41 from "fs";
+import { execFileSync as execFileSync27 } from "child_process";
+import * as fs42 from "fs";
 import * as path40 from "path";
 
 // src/app-auth.ts
@@ -15507,7 +15624,7 @@ init_config();
 
 // src/dispatch.ts
 init_config();
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 
 // src/cron-match.ts
 var FIELD_BOUNDS = [
@@ -15609,10 +15726,10 @@ function autoDispatch(opts) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs13.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -15723,7 +15840,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 || !fs13.existsSync(eventPath)) {
+  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) {
     return { kind: "silent", reason: "no GHA event context" };
   }
   if (eventName !== "issue_comment") {
@@ -15731,7 +15848,7 @@ function autoDispatchTyped(opts) {
   }
   let event = {};
   try {
-    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
   } catch {
     return { kind: "silent", reason: "GHA event payload unreadable" };
   }
@@ -15775,7 +15892,7 @@ function dispatchScheduledWatches(opts) {
   for (const exe of listExecutables()) {
     let raw;
     try {
-      raw = fs13.readFileSync(exe.profilePath, "utf-8");
+      raw = fs14.readFileSync(exe.profilePath, "utf-8");
     } catch {
       continue;
     }
@@ -16025,14 +16142,14 @@ async function resolveAuthToken(env = process.env) {
   return void 0;
 }
 function detectPackageManager2(cwd) {
-  if (fs41.existsSync(path40.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs41.existsSync(path40.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs41.existsSync(path40.join(cwd, "bun.lockb"))) return "bun";
+  if (fs42.existsSync(path40.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs42.existsSync(path40.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs42.existsSync(path40.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync26(cmd, args, {
+    execFileSync27(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -16045,7 +16162,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync26("which", [bin], { stdio: "pipe" });
+    execFileSync27("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -16086,7 +16203,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync26("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync27("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -16096,16 +16213,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync26("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync27("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync26("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync27("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync26("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync27("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -16117,8 +16234,8 @@ function postFailureTail(issueNumber, cwd, reason) {
   const logPath = path40.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs41.existsSync(logPath)) {
-      const content = fs41.readFileSync(logPath, "utf-8");
+    if (fs42.existsSync(logPath)) {
+      const content = fs42.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -16156,9 +16273,9 @@ async function runCi(argv) {
   const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
   let manualWorkflowDispatch = false;
   let forceRunAction = null;
-  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs41.existsSync(dispatchEventPath)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs42.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs41.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs42.readFileSync(dispatchEventPath, "utf-8"));
       const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
       const sessionInput = String(evt?.inputs?.sessionId ?? "");
       const dutyInput = String(evt?.inputs?.duty ?? evt?.inputs?.executable ?? "").trim();
@@ -16458,7 +16575,7 @@ init_litellm();
 init_repoWorkspace();
 
 // src/scripts/brainTurnLog.ts
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path41 from "path";
 var live = /* @__PURE__ */ new Map();
 function eventsPath(dir, chatId) {
@@ -16466,8 +16583,8 @@ function eventsPath(dir, chatId) {
 }
 function lastPersistedSeq(dir, chatId) {
   const p = eventsPath(dir, chatId);
-  if (!fs42.existsSync(p)) return 0;
-  const lines = fs42.readFileSync(p, "utf-8").split("\n").filter(Boolean);
+  if (!fs43.existsSync(p)) return 0;
+  const lines = fs43.readFileSync(p, "utf-8").split("\n").filter(Boolean);
   if (lines.length === 0) return 0;
   try {
     return JSON.parse(lines[lines.length - 1]).seq || 0;
@@ -16477,9 +16594,9 @@ function lastPersistedSeq(dir, chatId) {
 }
 function readSince(dir, chatId, since) {
   const p = eventsPath(dir, chatId);
-  if (!fs42.existsSync(p)) return [];
+  if (!fs43.existsSync(p)) return [];
   const out = [];
-  for (const line of fs42.readFileSync(p, "utf-8").split("\n")) {
+  for (const line of fs43.readFileSync(p, "utf-8").split("\n")) {
     if (!line) continue;
     try {
       const rec = JSON.parse(line);
@@ -16505,12 +16622,12 @@ function beginTurn(dir, chatId) {
   };
   live.set(chatId, state);
   const p = eventsPath(dir, chatId);
-  fs42.mkdirSync(path41.dirname(p), { recursive: true });
+  fs43.mkdirSync(path41.dirname(p), { recursive: true });
   return (event) => {
     state.seq += 1;
     const rec = { seq: state.seq, turn, ts: Date.now(), event };
     try {
-      fs42.appendFileSync(p, `${JSON.stringify(rec)}
+      fs43.appendFileSync(p, `${JSON.stringify(rec)}
 `);
     } catch (err) {
       process.stderr.write(
@@ -16549,7 +16666,7 @@ function endTurnIfUnterminated(dir, chatId, errMessage) {
     event: { type: "error", error: errMessage || "turn ended unexpectedly", chatId }
   };
   try {
-    fs42.appendFileSync(eventsPath(dir, chatId), `${JSON.stringify(rec)}
+    fs43.appendFileSync(eventsPath(dir, chatId), `${JSON.stringify(rec)}
 `);
   } catch {
   }
@@ -16642,17 +16759,17 @@ function authOk(req, expected) {
   return false;
 }
 function readJsonBody(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve6({});
+        resolve7({});
         return;
       }
       try {
-        resolve6(JSON.parse(raw));
+        resolve7(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -16780,7 +16897,7 @@ async function handleChatTurn(req, res, chatId, opts) {
   const repo = strField(body, "repo");
   const repoToken = strField(body, "repoToken");
   const sessionFile = sessionFilePath(opts.cwd, chatId);
-  fs43.mkdirSync(path42.dirname(sessionFile), { recursive: true });
+  fs44.mkdirSync(path42.dirname(sessionFile), { recursive: true });
   appendTurn(sessionFile, {
     role: "user",
     content: message,
@@ -16901,11 +17018,11 @@ async function brainServe(opts) {
     model,
     litellmUrl
   });
-  await new Promise((resolve6) => {
+  await new Promise((resolve7) => {
     server.listen(port, "0.0.0.0", () => {
       process.stdout.write(`[brain-serve] listening on 0.0.0.0:${port} (cwd=${opts.cwd})
 `);
-      resolve6();
+      resolve7();
     });
   });
   const shutdown = (signal) => {
@@ -17155,14 +17272,14 @@ async function startBrainProxy(opts) {
   const { httpServer, handler } = buildBrainProxy(opts);
   const port = opts.port ?? 0;
   const host = opts.host ?? "127.0.0.1";
-  await new Promise((resolve6) => httpServer.listen(port, host, () => resolve6()));
+  await new Promise((resolve7) => httpServer.listen(port, host, () => resolve7()));
   const addr = httpServer.address();
   return {
     httpServer,
     port: addr.port,
     url: `http://${host}:${addr.port}`,
-    stop: () => new Promise((resolve6) => {
-      httpServer.close(() => resolve6());
+    stop: () => new Promise((resolve7) => {
+      httpServer.close(() => resolve7());
     }),
     handler
   };
@@ -17312,23 +17429,23 @@ function buildMcpHttpServer(opts) {
     httpServer,
     routes,
     port,
-    stop: () => new Promise((resolve6) => {
+    stop: () => new Promise((resolve7) => {
       let pending = transports.size;
       if (pending === 0) {
-        httpServer.close(() => resolve6());
+        httpServer.close(() => resolve7());
         return;
       }
       for (const transport of transports.values()) {
         void transport.close().finally(() => {
           pending--;
-          if (pending === 0) httpServer.close(() => resolve6());
+          if (pending === 0) httpServer.close(() => resolve7());
         });
       }
     })
   };
 }
 function listenMcpHttpServer(server, host = "127.0.0.1") {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     server.httpServer.once("error", reject);
     server.httpServer.listen(server.port, host, () => {
       server.httpServer.off("error", reject);
@@ -17336,7 +17453,7 @@ function listenMcpHttpServer(server, host = "127.0.0.1") {
       if (addr && typeof addr === "object") {
         server.port = addr.port;
       }
-      resolve6();
+      resolve7();
     });
   });
 }
@@ -17419,18 +17536,18 @@ async function loadConfigSafe() {
 }
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync29 } from "child_process";
-import * as fs45 from "fs";
+import { execFileSync as execFileSync30 } from "child_process";
+import * as fs46 from "fs";
 import * as path44 from "path";
 
 // src/chat/modes/interactive.ts
 init_issue();
-import { execFileSync as execFileSync28 } from "child_process";
-import * as fs44 from "fs";
+import { execFileSync as execFileSync29 } from "child_process";
+import * as fs45 from "fs";
 import * as path43 from "path";
 
 // src/chat/inbox.ts
-import { execFileSync as execFileSync27 } from "child_process";
+import { execFileSync as execFileSync28 } from "child_process";
 var DEFAULT_POLL_MS = 3e3;
 async function waitForNextUserMessage(opts) {
   const pollMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
@@ -17447,13 +17564,13 @@ async function waitForNextUserMessage(opts) {
       try {
         const branch = currentBranch(opts.cwd);
         if (branch) {
-          execFileSync27("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
-          execFileSync27("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
+          execFileSync28("git", ["fetch", "--quiet", "origin", branch], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync28("git", ["merge", "--ff-only", "--quiet", `origin/${branch}`], {
             cwd: opts.cwd,
             stdio: "pipe"
           });
         } else {
-          execFileSync27("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
+          execFileSync28("git", ["fetch", "--quiet", "--all"], { cwd: opts.cwd, stdio: "pipe" });
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -17475,11 +17592,11 @@ async function waitForNextUserMessage(opts) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function currentBranch(cwd) {
   try {
-    const out = execFileSync27("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = execFileSync28("git", ["symbolic-ref", "--short", "HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -17589,7 +17706,7 @@ function findNextUserTurn(turns, fromIdx) {
 function commitTurn(cwd, sessionId, _verbose) {
   const sessionRel = path43.relative(cwd, sessionFilePath(cwd, sessionId));
   const eventsRel = path43.relative(cwd, eventsFilePath(cwd, sessionId));
-  const rels = [sessionRel, eventsRel].filter((p) => fs44.existsSync(path43.join(cwd, p)));
+  const rels = [sessionRel, eventsRel].filter((p) => fs45.existsSync(path43.join(cwd, p)));
   if (rels.length === 0) return;
   const repository = process.env.GITHUB_REPOSITORY;
   if (!repository) {
@@ -17602,7 +17719,7 @@ function commitTurn(cwd, sessionId, _verbose) {
   const branch = defaultBranch(cwd) ?? "main";
   for (const rel of rels) {
     const repoPath = rel.split(path43.sep).join("/");
-    const localText = fs44.readFileSync(path43.join(cwd, rel), "utf-8");
+    const localText = fs45.readFileSync(path43.join(cwd, rel), "utf-8");
     putJsonlViaContents(repository, branch, repoPath, localText, sessionId, cwd);
   }
 }
@@ -17663,7 +17780,7 @@ function putJsonlViaContents(repository, branch, repoPath, localText, sessionId,
 }
 function defaultBranch(cwd) {
   try {
-    const out = execFileSync28("git", ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], {
+    const out = execFileSync29("git", ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -17752,12 +17869,12 @@ function commitChatFiles(cwd, sessionId, verbose) {
   const safeSession = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
   const tasksDir = path44.join(".kody", "tasks", safeSession);
   const candidatePaths = [sessionFile, eventsFile, tasksDir];
-  const paths = candidatePaths.filter((p) => fs45.existsSync(path44.join(cwd, p)));
+  const paths = candidatePaths.filter((p) => fs46.existsSync(path44.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync29("git", ["add", "-f", ...paths], opts);
-    execFileSync29("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync30("git", ["add", "-f", ...paths], opts);
+    execFileSync30("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[kody:chat] commit skipped: ${msg}
@@ -17849,7 +17966,7 @@ ${CHAT_HELP}`);
   const sink = buildSink(cwd, sessionId, args.dashboardUrl);
   const meta = readMeta(sessionFile);
   process.stdout.write(
-    `\u2192 kody:chat: session file=${sessionFile} exists=${fs45.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
+    `\u2192 kody:chat: session file=${sessionFile} exists=${fs46.existsSync(sessionFile)} meta=${meta ? meta.mode : "none"}
 `
   );
   try {
@@ -18590,14 +18707,14 @@ function sendJson2(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readJsonBody2(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
-      if (!raw.trim()) return resolve6({});
+      if (!raw.trim()) return resolve7({});
       try {
-        resolve6(JSON.parse(raw));
+        resolve7(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -18723,10 +18840,10 @@ async function poolServe() {
     }
   });
   const apiHost = process.env.POOL_API_HOST ?? "::";
-  await new Promise((resolve6) => {
+  await new Promise((resolve7) => {
     server.listen(apiPort, apiHost, () => {
       log(`listening on ${apiHost}:${apiPort} (min=${min}, app=${app}, region=${region})`);
-      resolve6();
+      resolve7();
     });
   });
   const shutdown = (signal) => {
@@ -18744,7 +18861,7 @@ async function poolServe() {
 
 // src/servers/runner-serve.ts
 import { spawn as spawn8 } from "child_process";
-import * as fs46 from "fs";
+import * as fs47 from "fs";
 import { createServer as createServer5 } from "http";
 var DEFAULT_PORT2 = 8080;
 var DEFAULT_WORKDIR = "/workspace/repo";
@@ -18765,17 +18882,17 @@ function authOk2(req, expected) {
   return false;
 }
 function readJsonBody3(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve6({});
+        resolve7({});
         return;
       }
       try {
-        resolve6(JSON.parse(raw));
+        resolve7(JSON.parse(raw));
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -18824,8 +18941,8 @@ async function defaultRunJob(job) {
   const workdir = process.env.RUNNER_WORKDIR ?? DEFAULT_WORKDIR;
   const branch = job.ref ?? "main";
   const authUrl = `https://x-access-token:${job.githubToken}@github.com/${job.repo}.git`;
-  fs46.rmSync(workdir, { recursive: true, force: true });
-  fs46.mkdirSync(workdir, { recursive: true });
+  fs47.rmSync(workdir, { recursive: true, force: true });
+  fs47.mkdirSync(workdir, { recursive: true });
   const allSecrets = typeof job.allSecrets === "string" ? job.allSecrets : JSON.stringify(job.allSecrets ?? {});
   const interactive = job.mode === "interactive";
   const scheduled = job.mode === "scheduled";
@@ -18854,13 +18971,13 @@ async function defaultRunJob(job) {
     ...interactive && job.idleExitMs ? { KODY_IDLE_EXIT_MS: String(job.idleExitMs) } : {},
     ...interactive && job.hardCapMs ? { KODY_HARD_CAP_MS: String(job.hardCapMs) } : {}
   };
-  const run = (cmd, args, cwd) => new Promise((resolve6) => {
+  const run = (cmd, args, cwd) => new Promise((resolve7) => {
     const child = spawn8(cmd, args, { stdio: "inherit", env: childEnv, cwd });
-    child.on("exit", (code) => resolve6(code ?? 0));
+    child.on("exit", (code) => resolve7(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`[runner-serve] ${cmd} failed: ${err.message}
 `);
-      resolve6(1);
+      resolve7(1);
     });
   });
   process.stdout.write(`[runner-serve] job ${job.jobId}: cloning ${job.repo}@${branch}
@@ -18937,11 +19054,11 @@ async function runnerServe() {
   const port = Number(process.env.PORT ?? DEFAULT_PORT2);
   const server = buildServer2({ apiKey });
   const host = process.env.RUNNER_HOST ?? "::";
-  await new Promise((resolve6) => {
+  await new Promise((resolve7) => {
     server.listen(port, host, () => {
       process.stdout.write(`[runner-serve] listening on ${host}:${port} (idle, awaiting job)
 `);
-      resolve6();
+      resolve7();
     });
   });
   const shutdown = (signal) => {
@@ -18960,7 +19077,7 @@ async function runnerServe() {
 init_config();
 init_litellm();
 import { spawn as spawn9 } from "child_process";
-function parseTarget(positional) {
+function parseTarget2(positional) {
   if (!Array.isArray(positional) || positional.length === 0) return "none";
   const first = String(positional[0]).toLowerCase();
   if (first === "vscode" || first === "code") return "vscode";
@@ -18975,7 +19092,7 @@ function buildProxyEnv(url) {
   };
 }
 async function serve(opts) {
-  const target = parseTarget(opts.args);
+  const target = parseTarget2(opts.args);
   const model = parseProviderModel(opts.config.agent.model);
   const usesProxy = needsLitellmProxy(model);
   let handle = null;
@@ -19010,14 +19127,14 @@ async function serve(opts) {
 `);
     const args = ["--dangerously-skip-permissions", "--model", model.model];
     const child = spawn9("claude", args, { stdio: "inherit", env: editorEnv, cwd: opts.cwd });
-    const exitCode = await new Promise((resolve6) => {
-      child.on("exit", (code) => resolve6(code ?? 0));
+    const exitCode = await new Promise((resolve7) => {
+      child.on("exit", (code) => resolve7(code ?? 0));
       child.on("error", (err) => {
         process.stderr.write(`[kody serve] failed to launch Claude Code: ${err.message}
 `);
         process.stderr.write(`  Install: https://docs.anthropic.com/claude/docs/claude-code
 `);
-        resolve6(1);
+        resolve7(1);
       });
     });
     killProxy();