@kody-ade/kody-engine 0.4.224 → 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.224",
+      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);
       });
@@ -1814,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]);
@@ -2055,6 +2088,8 @@ function resolveCompanyStore() {
   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 {
@@ -2075,6 +2110,12 @@ function fetchCompanyStore(repo, ref) {
     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)) {
@@ -3205,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,
@@ -3388,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();
@@ -4554,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(":");
@@ -5301,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);
@@ -5418,6 +5831,118 @@ var init_appendCompanyActivity = __esm({
   }
 });
 
+// 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) {
@@ -5584,11 +6109,11 @@ var init_classifyByLabel = __esm({
 });
 
 // src/scripts/commitAndPush.ts
-import * as fs24 from "fs";
-import * as path21 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 function sentinelPathForStage(cwd, profileName) {
   const runId = resolveRunId();
-  return path21.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({
@@ -5605,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 && fs24.existsSync(sentinel)) {
+      if (sentinel && fs25.existsSync(sentinel)) {
         try {
-          const replay = JSON.parse(fs24.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;
@@ -5660,8 +6185,8 @@ var init_commitAndPush = __esm({
       const result = ctx.data.commitResult;
       if (sentinel && result?.committed) {
         try {
-          fs24.mkdirSync(path21.dirname(sentinel), { recursive: true });
-          fs24.writeFileSync(
+          fs25.mkdirSync(path22.dirname(sentinel), { recursive: true });
+          fs25.writeFileSync(
             sentinel,
             JSON.stringify(
               {
@@ -5682,148 +6207,17 @@ var init_commitAndPush = __esm({
   }
 });
 
-// src/goal/state.ts
-import * as fs25 from "fs";
-import * as path22 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;
@@ -5833,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;
       }
@@ -5841,12 +6235,11 @@ 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";
   }
 });
 
@@ -6301,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);
@@ -6404,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,
@@ -6415,377 +6833,104 @@ ${markdown}`, ctx.cwd);
       ctx.cwd
     );
   } catch (err) {
-    process.stderr.write(
-      `[createQaGoal] failed to persist goal state to kody-state: ${err instanceof Error ? err.message : String(err)}
-[createQaGoal]   goal-scheduler will not see ${goalId} until this succeeds.
-`
-    );
-  }
-  const repoUrl = `https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}`;
-  if (manifestIssueNumber !== null) {
-    const verb = manifestUpdated ? manifestCreated ? "OPENED" : "UPDATED" : "TARGETED";
-    process.stdout.write(
-      `
-QA_GOAL_${verb}=${repoUrl}/issues/${manifestIssueNumber} (id: ${goalId}, verdict: ${verdict})
-`
-    );
-  } else {
-    process.stdout.write(`
-QA_GOAL_TARGETED=(no manifest issue) (id: ${goalId}, verdict: ${verdict})
-`);
-  }
-  for (const o of opened) {
-    process.stdout.write(`QA_FINDING_OPENED=${o.url} (severity: ${o.severity})
-`);
-  }
-  if (failed.length > 0) {
-    process.stdout.write(`QA_FINDINGS_FAILED=${failed.length} (see stderr above)
-`);
-  }
-  ctx.data.action = qaAction(verdict, {
-    goalId,
-    manifestIssue: manifestIssueNumber ?? void 0,
-    findingsOpened: opened.length,
-    findingsFailed: failed.length,
-    mode: explicitGoal ? "goal-attach" : manifestCreated ? "goal-create" : "goal-append"
-  });
-  ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-}
-var MANIFEST_LABEL, MANIFEST_TITLE, MANIFEST_START, MANIFEST_END, FINDING_LABEL, REPORT_JSON_OPEN, REPORT_JSON_CLOSE, SEVERITY_COLORS, createQaGoal;
-var init_createQaGoal = __esm({
-  "src/scripts/createQaGoal.ts"() {
-    "use strict";
-    init_state2();
-    init_stateStore();
-    init_issue();
-    init_postReviewResult();
-    MANIFEST_LABEL = "kody:goals-manifest";
-    MANIFEST_TITLE = "Kody Goals Manifest";
-    MANIFEST_START = "<!-- kody-goals-start -->";
-    MANIFEST_END = "<!-- kody-goals-end -->";
-    FINDING_LABEL = "kody:qa-finding";
-    REPORT_JSON_OPEN = "<!-- KODY_QA_REPORT_JSON";
-    REPORT_JSON_CLOSE = "-->";
-    SEVERITY_COLORS = {
-      P0: "b60205",
-      P1: "d93f0b",
-      P2: "fbca04",
-      P3: "0e8a16"
-    };
-    createQaGoal = async (ctx, _profile, agentResult) => {
-      if (!agentResult || agentResult.outcome !== "completed") {
-        const reason = agentResult?.error ?? "agent did not complete";
-        process.stderr.write(`[createQaGoal] ${reason}
-`);
-        ctx.output.exitCode = 1;
-        ctx.output.reason = reason;
-        ctx.data.action = failedAction2(reason);
-        return;
-      }
-      const finalText = agentResult.finalText.trim();
-      if (!finalText) {
-        process.stderr.write("[createQaGoal] agent produced no report body\n");
-        ctx.output.exitCode = 1;
-        ctx.output.reason = "empty report body";
-        ctx.data.action = failedAction2("empty report body");
-        return;
-      }
-      const { markdown } = splitReport(finalText);
-      const verdict = detectVerdict(markdown);
-      const existingIssue = ctx.args.issue;
-      if (typeof existingIssue === "number" && existingIssue > 0) {
-        try {
-          postIssueComment(existingIssue, finalText, ctx.cwd);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          ctx.output.exitCode = 4;
-          ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
-          ctx.data.action = failedAction2(ctx.output.reason);
-          return;
-        }
-        process.stdout.write(
-          `
-QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
-`
-        );
-        ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
-        ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
-        return;
-      }
-      await promoteReportToGoal(ctx, finalText, ctx.args.scope, ctx.args.goal);
-    };
-  }
-});
-
-// 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);
+    process.stderr.write(
+      `[createQaGoal] failed to persist goal state to kody-state: ${err instanceof Error ? err.message : String(err)}
+[createQaGoal]   goal-scheduler will not see ${goalId} until this succeeds.
+`
+    );
   }
-}
-function markPrReady(prNumber, cwd) {
-  try {
-    gh(["pr", "ready", String(prNumber)], { cwd });
-    return { ok: true };
-  } catch (err) {
-    return fail(err);
+  const repoUrl = `https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}`;
+  if (manifestIssueNumber !== null) {
+    const verb = manifestUpdated ? manifestCreated ? "OPENED" : "UPDATED" : "TARGETED";
+    process.stdout.write(
+      `
+QA_GOAL_${verb}=${repoUrl}/issues/${manifestIssueNumber} (id: ${goalId}, verdict: ${verdict})
+`
+    );
+  } else {
+    process.stdout.write(`
+QA_GOAL_TARGETED=(no manifest issue) (id: ${goalId}, verdict: ${verdict})
+`);
   }
-}
-var GOAL_TASK_WORKFLOW;
-var init_operations = __esm({
-  "src/goal/operations.ts"() {
-    "use strict";
-    init_issue();
-    init_labels();
-    GOAL_TASK_WORKFLOW = "kody.yml";
+  for (const o of opened) {
+    process.stdout.write(`QA_FINDING_OPENED=${o.url} (severity: ${o.severity})
+`);
   }
-});
-
-// 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";
+  if (failed.length > 0) {
+    process.stdout.write(`QA_FINDINGS_FAILED=${failed.length} (see stderr above)
+`);
   }
-});
-
-// 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;
+  ctx.data.action = qaAction(verdict, {
+    goalId,
+    manifestIssue: manifestIssueNumber ?? void 0,
+    findingsOpened: opened.length,
+    findingsFailed: failed.length,
+    mode: explicitGoal ? "goal-attach" : manifestCreated ? "goal-create" : "goal-append"
   });
+  ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
 }
-var deriveGoalPhase;
-var init_deriveGoalPhase = __esm({
-  "src/scripts/deriveGoalPhase.ts"() {
+var MANIFEST_LABEL, MANIFEST_TITLE, MANIFEST_START, MANIFEST_END, FINDING_LABEL, REPORT_JSON_OPEN, REPORT_JSON_CLOSE, SEVERITY_COLORS, createQaGoal;
+var init_createQaGoal = __esm({
+  "src/scripts/createQaGoal.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}
+    init_state2();
+    init_stateStore();
+    init_issue();
+    init_postReviewResult();
+    MANIFEST_LABEL = "kody:goals-manifest";
+    MANIFEST_TITLE = "Kody Goals Manifest";
+    MANIFEST_START = "<!-- kody-goals-start -->";
+    MANIFEST_END = "<!-- kody-goals-end -->";
+    FINDING_LABEL = "kody:qa-finding";
+    REPORT_JSON_OPEN = "<!-- KODY_QA_REPORT_JSON";
+    REPORT_JSON_CLOSE = "-->";
+    SEVERITY_COLORS = {
+      P0: "b60205",
+      P1: "d93f0b",
+      P2: "fbca04",
+      P3: "0e8a16"
+    };
+    createQaGoal = async (ctx, _profile, agentResult) => {
+      if (!agentResult || agentResult.outcome !== "completed") {
+        const reason = agentResult?.error ?? "agent did not complete";
+        process.stderr.write(`[createQaGoal] ${reason}
 `);
-        goal.childTasks = [];
-        goal.openTaskPrs = [];
-        goal.phase = "idle";
+        ctx.output.exitCode = 1;
+        ctx.output.reason = reason;
+        ctx.data.action = failedAction2(reason);
         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";
+      const finalText = agentResult.finalText.trim();
+      if (!finalText) {
+        process.stderr.write("[createQaGoal] agent produced no report body\n");
+        ctx.output.exitCode = 1;
+        ctx.output.reason = "empty report body";
+        ctx.data.action = failedAction2("empty report body");
         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"
-      );
+      const { markdown } = splitReport(finalText);
+      const verdict = detectVerdict(markdown);
+      const existingIssue = ctx.args.issue;
+      if (typeof existingIssue === "number" && existingIssue > 0) {
+        try {
+          postIssueComment(existingIssue, finalText, ctx.cwd);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          ctx.output.exitCode = 4;
+          ctx.output.reason = `failed to comment on issue #${existingIssue}: ${msg}`;
+          ctx.data.action = failedAction2(ctx.output.reason);
+          return;
+        }
+        process.stdout.write(
+          `
+QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.repo}/issues/${existingIssue} (verdict: ${verdict})
+`
+        );
+        ctx.data.action = qaAction(verdict, { issueNumber: existingIssue, mode: "comment" });
+        ctx.output.exitCode = verdict === "FAIL" ? 1 : 0;
+        return;
+      }
+      await promoteReportToGoal(ctx, finalText, ctx.args.scope, ctx.args.goal);
     };
   }
 });
@@ -8003,12 +8148,18 @@ function parseDutyFilter(raw) {
 function filterSlugs(slugs, onlyDuty) {
   return onlyDuty ? slugs.filter((slug) => slug === onlyDuty) : slugs;
 }
-function listDutySlugs(roots) {
+function listActivatedDutySlugs(projectRoot, storeRoot, activeStoreDuties) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const root of roots) {
-    for (const slug of listDutyFolderSlugs(root)) {
-      if (seen.has(slug)) continue;
+  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);
     }
@@ -8086,8 +8237,10 @@ var init_dispatchDutyFileTicks = __esm({
         const onlyDuty = parseDutyFilter(ctx.args.duty);
         const jobsPath = path28.join(ctx.cwd, jobsDir);
         const storeJobsPath = getCompanyStoreDutiesRoot();
-        const dutyRoots = [jobsPath, ...storeJobsPath ? [storeJobsPath] : []];
-        const slugs = filterSlugs(listDutySlugs(dutyRoots), onlyDuty);
+        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}` : "";
@@ -8278,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;
@@ -8687,133 +8808,6 @@ var init_failOnceTaskJob = __esm({
   }
 });
 
-// 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}
-`);
-        }
-      }
-      goal.state = "done";
-    };
-  }
-});
-
 // src/scripts/finalizeTerminal.ts
 var DONE, FAILED, finalizeTerminal;
 var init_finalizeTerminal = __esm({
@@ -9363,58 +9357,6 @@ 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 execFileSync17 } from "child_process";
 import * as fs31 from "fs";
@@ -9788,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;
@@ -9798,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;
@@ -9933,23 +9869,7 @@ var init_staff = __esm({
     "use strict";
     init_companyStore();
     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")
-    };
+    BUILTIN_PERSONAS = {};
   }
 });
 
@@ -10402,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"], {
@@ -12159,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 ?? {} },
@@ -12171,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}`));
     });
   });
@@ -12811,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);
     };
   }
 });
@@ -13125,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,
@@ -13152,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 });
     });
   });
 }
@@ -13561,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)
@@ -13756,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();
@@ -13764,7 +13709,6 @@ var init_scripts = __esm({
     init_commitGoalState();
     init_composePrompt();
     init_createQaGoal();
-    init_deriveGoalPhase();
     init_deriveQaScopeFromIssue();
     init_diagMcp();
     init_discoverQaContext();
@@ -13772,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();
@@ -13830,7 +13771,7 @@ var init_scripts = __esm({
     init_runPreviewBuild();
     init_runScheduledExecutableTick();
     init_runTickScript();
-    init_saveGoalState();
+    init_saveManagedGoalState();
     init_saveTaskState();
     init_setCommentTarget();
     init_setLifecycleLabel();
@@ -13890,12 +13831,9 @@ var init_scripts = __esm({
       runScheduledExecutableTick,
       runTickScript,
       runPreviewBuild,
+      advanceManagedGoal,
       loadGoalState,
-      handleAbandonedGoal,
-      deriveGoalPhase,
-      dispatchNextTask,
-      finalizeGoal,
-      saveGoalState
+      saveManagedGoalState
     };
     postflightScripts = {
       parseAgentResult: parseAgentResult2,
@@ -13930,6 +13868,7 @@ var init_scripts = __esm({
       finalizeTerminal,
       advanceFlow,
       persistFlowState,
+      applyDutyReports,
       recordClassification,
       dispatchClassified,
       notifyTerminal,
@@ -14120,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);
@@ -14195,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
@@ -14689,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));
@@ -14732,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);
@@ -14781,6 +14728,7 @@ var init_executor = __esm({
     init_config();
     init_container();
     init_discipline();
+    init_dutyReport();
     init_events();
     init_lifecycleLabels();
     init_litellm();
@@ -14791,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;
@@ -16811,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)));
       }
@@ -17070,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) => {
@@ -17324,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
   };
@@ -17481,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);
@@ -17505,7 +17453,7 @@ function listenMcpHttpServer(server, host = "127.0.0.1") {
       if (addr && typeof addr === "object") {
         server.port = addr.port;
       }
-      resolve6();
+      resolve7();
     });
   });
 }
@@ -17644,7 +17592,7 @@ 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 {
@@ -18759,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)));
       }
@@ -18892,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) => {
@@ -18934,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)));
       }
@@ -19023,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}
@@ -19106,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) => {
@@ -19129,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";
@@ -19144,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;
@@ -19179,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();