@kody-ade/kody-engine 0.4.258 → 0.4.260

package/README.md

@@ -27,7 +27,7 @@ kody:  reads the issue → writes the code → runs your tests → opens a PR
 - **No infrastructure.** Runs on the GitHub Actions you already have. One ~20-line
   workflow file, installed via `npx`. Nothing to deploy or keep online.
 - **Whole PR lifecycle, not just authoring.** `run`, `resolve`, `sync`, `merge`,
-  `revert`, previews, releases, and scheduled agentResponsibilities — one executor, many verbs.
+  `revert`, previews, releases, and scheduled capabilities — one executor, many verbs.
 - **Declarative & extensible.** Every command is a folder of `profile.json` +
   `prompt.md` + shell. Add a command by dropping a folder — no engine changes.
 - **Bring your own model.** Anthropic native, or any provider via the built-in
@@ -74,19 +74,31 @@ See [SECURITY.md](SECURITY.md) to report a vulnerability.
 ┌─────────────────────────────────────────────┐
 │ kody-engine CLI (@kody-ade/kody-engine)    │
 │   bin/kody.ts — entrypoint                  │
-│   src/dispatch.ts — agentResponsibility-driven routing     │
-│   src/executor.ts — runs agentResponsibility implementations│
+│   src/dispatch.ts — capability-driven routing              │
+│   src/executor.ts — runs capability implementations         │
+│   .kody/capabilities/<slug>/                                │
+│     profile.json · capability.md · optional skills/scripts  │
 │   .kody/agent-responsibilities/<slug>/                      │
-│     profile.json · agent-responsibility.md                  │
-│   src/agent-actions/<name>/                   │
-│     profile.json · prompt.md · *.sh         │
+│     legacy fallback: profile.json · agent-responsibility.md │
+│   .kody/agent-actions/<name>/                               │
+│     legacy fallback: profile.json · prompt.md · *.sh        │
 │   src/scripts/*.ts — cross-cutting catalog  │
 └─────────────────────────────────────────────┘
 ```
 
-Every top-level command is an auto-discovered agentResponsibility action. The router has **zero agentAction names hardcoded** — comment dispatch resolves the first token after `@kody` through `config.aliases`, then falls back to the legacy-named `config.defaultAgentAction` / `config.defaultPrAgentAction` fields as default agentResponsibility actions. Drop a new `.kody/agent-responsibilities/<slug>/` directory with `profile.json` + `agent-responsibility.md`; that agentResponsibility chooses its implementation agentAction.
+Every top-level command is an auto-discovered capability action. The router has
+**zero agentAction names hardcoded** - comment dispatch resolves the first token
+after `@kody` through `config.aliases`, then falls back to the legacy-named
+`config.defaultAgentAction` / `config.defaultPrAgentAction` fields as default
+capability actions. Drop a new `.kody/capabilities/<slug>/` directory with
+`profile.json` + `capability.md`; legacy `.kody/agent-responsibilities/` and
+`.kody/agent-actions/` roots still load while repos migrate.
 
-AgentAction directories are private implementation units and contain **only** three kinds of files: `profile.json` (declaration), `prompt.md` (agent instructions), and `.sh` scripts (mechanical side-effect work). Cross-cutting TypeScript lives in [src/scripts/](src/scripts/); it can't import from `src/agent-actions/` and can't branch on `profile.name`.
+Legacy AgentAction directories are private implementation units and contain
+**only** three kinds of files: `profile.json` (declaration), `prompt.md` (agent
+instructions), and `.sh` scripts (mechanical side-effect work). Cross-cutting
+TypeScript lives in [src/scripts/](src/scripts/); it can't import from
+`src/agent-actions/` and can't branch on `profile.name`.
 
 ## Install in a consumer repo
 
@@ -94,7 +106,10 @@ AgentAction directories are private implementation units and contain **only** th
 npx -y -p @kody-ade/kody-engine@latest kody-engine init
 ```
 
-`kody-engine init` scaffolds [kody.config.json](kody.config.schema.json), `.github/workflows/kody.yml` (generated from `WORKFLOW_TEMPLATE` in [src/scripts/initFlow.ts](src/scripts/initFlow.ts)), and per-scheduled-agentResponsibility workflow files. Idempotent — pass `--force` to overwrite.
+`kody-engine init` scaffolds [kody.config.json](kody.config.schema.json),
+`.github/workflows/kody.yml` (generated from `WORKFLOW_TEMPLATE` in
+[src/scripts/initFlow.ts](src/scripts/initFlow.ts)), and scheduled capability
+workflow files. Idempotent — pass `--force` to overwrite.
 
 Required repo secrets: at least one model provider key (e.g. `MINIMAX_API_KEY`, `ANTHROPIC_API_KEY`). Recommended: `KODY_TOKEN` PAT so kody's commits trigger downstream CI and can modify `.github/workflows/*`.
 
@@ -123,10 +138,10 @@ kody-engine release-publish   --issue <N> [--dry-run]
 kody-engine release-deploy    --issue <N> [--dry-run]
 kody-engine npm-publish       [--tag latest] [--access public] [--dry-run]
 
-# scheduled agentResponsibilities and goals
-kody-engine agent-responsibility-scheduler                                    # fan out due .kody/agent-responsibilities/<slug>/ folders
-kody-engine agent-responsibility-tick          --agentResponsibility <slug> [--force]        # one agent tick for one agentResponsibility
-kody-engine agent-responsibility-tick-scripted --agentResponsibility <slug> [--force]        # one deterministic tickScript agentResponsibility tick
+# scheduled capabilities and goals
+kody-engine agent-responsibility-scheduler                                    # fan out due .kody/capabilities/<slug>/ folders plus legacy fallbacks
+kody-engine agent-responsibility-tick          --agentResponsibility <slug> [--force]        # one agent tick for one capability
+kody-engine agent-responsibility-tick-scripted --agentResponsibility <slug> [--force]        # one deterministic tickScript capability tick
 kody-engine goal-scheduler                                    # fan out active goal instances in configured state repo
 kody-engine goal-manager      --goal <id>                     # advance one managed goal instance
 
@@ -142,11 +157,19 @@ kody-engine agent-ask        --agent <slug> --message "..." # ad-hoc agent run
 kody-engine stats                                             # inspect run/event history
 ```
 
-### AgentResponsibilities
+### Capabilities
 
-A **agentResponsibility** is a folder at `.kody/agent-responsibilities/<slug>/` with `profile.json` metadata (`every`, `agent`, `action`, `agentAction`, `stage`, and related fields) plus human-owned prose in `agent-responsibility.md`. `agent-responsibility-scheduler` wakes on cron, finds due agentResponsibilities, and dispatches either `agent-responsibility-tick` for an agent tick or `agent-responsibility-tick-scripted` for a deterministic `tickScript` agentResponsibility. `kody-engine init` copies built-in starter agentResponsibilities and scaffolds `.kody/agents/kody.md`.
+A **capability** is a folder at `.kody/capabilities/<slug>/` with
+`profile.json` metadata (`action`, `capabilityKind`, `agent`, `every`, and
+related fields) plus human-owned prose in `capability.md`. The scheduler wakes
+on cron, finds due capabilities, and dispatches either
+`agent-responsibility-tick` for an agent tick or
+`agent-responsibility-tick-scripted` for a deterministic `tickScript`
+capability. The CLI names are still legacy during migration.
 
-Locked-toolbox agentResponsibilities can declare `"tools": [...]` in `profile.json` to run with only the named high-level MCP intents plus `submit_state`; agentResponsibilities without `tools` keep the legacy Bash/gh toolbox.
+Locked-toolbox capabilities can declare `"tools": [...]` in `profile.json` to
+run with only the named high-level MCP intents plus `submit_state`; capabilities
+without `tools` keep the legacy Bash/gh toolbox.
 
 ### `release`
 
@@ -154,7 +177,11 @@ Locked-toolbox agentResponsibilities can declare `"tools": [...]` in `profile.js
 
 ## Profiles
 
-A profile is declarative JSON + an adjacent `prompt.md`. See any directory under [src/agent-actions/](src/agent-actions/) for examples. Adding a new command = new directory + profile + prompt + any `.sh` scripts + registering any new shared TS utilities under [src/scripts/](src/scripts/). No executor, entry, or dispatch changes.
+A profile is declarative JSON plus an adjacent markdown body. New public work
+should live under `.kody/capabilities/<slug>/` with `capability.md`; legacy
+implementations under [src/agent-actions/](src/agent-actions/) still show the
+older split profile + prompt shape. Adding a new capability should not require
+executor, entry, or dispatch changes.
 
 See [AGENTS.md](AGENTS.md) for the full architectural contract.
 

package/dist/agent-actions/agent-factory/prompt.md

@@ -22,10 +22,16 @@ Design the smallest Kody model structure that satisfies the request. You may cre
 
 Use the current Kody vocabulary:
 
+- intent: why the agency should care
+- goal: what should become true
+- loop: when to check or wake work
 - agent: who runs
-- agentResponsibility: why/when and public action ownership
-- agentAction: how work runs
-- goal: related task list/state
+- capability: how the agency can produce a result
+
+Use current storage names when producing files:
+
+- agentResponsibility: capability contract, public action ownership, kind, agent, cadence, and output contract
+- agentAction: capability implementation
 
 # Boundaries
 

package/dist/agent-actions/types.ts

@@ -56,11 +56,12 @@ export interface Profile {
    */
   role: "primitive" | "orchestrator" | "container" | "watch" | "utility"
   /**
-   * A agentResponsibility is the WHY layer: it references an agentAction (the HOW) by name
-   * rather than embedding it. When set, loader resolves the agentAction's
-   * full profile (claudeCode/scripts/prompt/agents) and overlays agentResponsibility's
-   * name + agent (WHO) + mentions. Absent -> this profile IS an
-   * agentAction (defines its own how). agentAction = how, agent = who, agentResponsibility = why.
+   * A agentResponsibility is the capability contract storage layer: it references
+   * an agentAction implementation by name rather than embedding it. When set,
+   * loader resolves the agentAction's full profile (claudeCode/scripts/prompt/agents)
+   * and overlays agentResponsibility name + agent (who) + mentions. Absent -> this
+   * profile IS an agentAction implementation. Intent = why, agent = who,
+   * capability = how, agentAction = implementation.
    */
   agentAction?: string
   /**
@@ -469,23 +470,23 @@ export interface Context {
      * `@kody <next>` comment, which is silently ignored when Kody comments as
      * a GitHub App (bot author), stalling the pipeline at classify.
      */
-  nextDispatch?: {
-    action?: string
-    agentResponsibility?: string
-    agentAction?: string
-    cliArgs: Record<string, unknown>
-    saveReport?: boolean
-  }
+    nextDispatch?: {
+      action?: string
+      agentResponsibility?: string
+      agentAction?: string
+      cliArgs: Record<string, unknown>
+      saveReport?: boolean
+    }
     /** In-process hand-off to a full Job, preserving job identity in task state. */
     nextJob?: Job
     /** Where to return after nextJob succeeds. Used by task-jobs to keep draining pending work. */
-  afterNextJob?: {
-    action?: string
-    agentResponsibility?: string
-    agentAction?: string
-    cliArgs: Record<string, unknown>
-    saveReport?: boolean
-  }
+    afterNextJob?: {
+      action?: string
+      agentResponsibility?: string
+      agentAction?: string
+      cliArgs: Record<string, unknown>
+      saveReport?: boolean
+    }
   }
   /**
    * If a preflight script sets this to true, the executor skips the agent
@@ -517,8 +518,9 @@ export type AnyScript = PreflightScript | PostflightScript
 // Job — the unified work request (task-state jobs collect run attempts).
 //
 // A Job is the required work the engine tries to execute, regardless of how it
-// was triggered. It must reference a agentResponsibility/action (why). The agentAction is only
-// the agentResponsibility-selected implementation detail (how), never a standalone request.
+// was triggered. It must reference an agentResponsibility/action capability
+// contract. The agentAction is only the selected implementation detail, never a
+// standalone request.
 // Task state stores this durable job separately from individual run attempts.
 // Two flavors:
 //   - "instant"   — run once now (an `@kody <verb>` comment or a manual dispatch)
@@ -552,6 +554,6 @@ export interface Job {
   flavor: JobFlavor
   /** Manual force-run (bypass cadence) for a scheduled job. */
   force?: boolean
-  /** Save this responsibility run output as reports/<responsibility>.md. */
+  /** Ask the owning goal/loop to refresh reports/<goal-or-loop>.md after its persisted decision. */
   saveReport?: boolean
 }

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.258",
+      version: "0.4.260",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
       license: "MIT",
       type: "module",
@@ -1364,12 +1364,14 @@ function listAgentResponsibilityFolderSlugs(absDir) {
   return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).filter((e) => isAgentResponsibilityFolder(path6.join(absDir, e.name))).map((e) => e.name).sort();
 }
 function isAgentResponsibilityFolder(dir) {
-  return fs4.existsSync(path6.join(dir, AGENT_RESPONSIBILITY_PROFILE_FILE)) && fs4.existsSync(path6.join(dir, AGENT_RESPONSIBILITY_BODY_FILE));
+  return fs4.existsSync(path6.join(dir, AGENT_RESPONSIBILITY_PROFILE_FILE)) && (fs4.existsSync(path6.join(dir, CAPABILITY_BODY_FILE)) || fs4.existsSync(path6.join(dir, AGENT_RESPONSIBILITY_BODY_FILE)));
 }
 function readAgentResponsibilityFolder(root, slug2) {
   const dir = path6.join(root, slug2);
   const profilePath = path6.join(dir, AGENT_RESPONSIBILITY_PROFILE_FILE);
-  const bodyPath = path6.join(dir, AGENT_RESPONSIBILITY_BODY_FILE);
+  const capabilityBodyPath = path6.join(dir, CAPABILITY_BODY_FILE);
+  const legacyBodyPath = path6.join(dir, AGENT_RESPONSIBILITY_BODY_FILE);
+  const bodyPath = fs4.existsSync(capabilityBodyPath) ? capabilityBodyPath : legacyBodyPath;
   if (!fs4.existsSync(profilePath) || !fs4.statSync(profilePath).isFile()) return null;
   if (!fs4.existsSync(bodyPath) || !fs4.statSync(bodyPath).isFile()) return null;
   try {
@@ -1403,6 +1405,7 @@ function parseAgentResponsibilityConfig(raw) {
     tools,
     agentActions: stringList(raw.agentActions),
     capabilityKind: capabilityKindField(raw.capabilityKind),
+    role: stringField(raw.role),
     describe: stringField(raw.describe),
     stage: stringField(raw.stage),
     readsFrom: stringList(raw.readsFrom ?? raw.reads_from),
@@ -1446,12 +1449,13 @@ function capabilityKindField(value) {
   if (value === "observe" || value === "act" || value === "verify") return value;
   return void 0;
 }
-var AGENT_RESPONSIBILITY_PROFILE_FILE, AGENT_RESPONSIBILITY_BODY_FILE;
+var AGENT_RESPONSIBILITY_PROFILE_FILE, AGENT_RESPONSIBILITY_BODY_FILE, CAPABILITY_BODY_FILE;
 var init_agent_responsibilityFolders = __esm({
   "src/agent-responsibilityFolders.ts"() {
     "use strict";
     AGENT_RESPONSIBILITY_PROFILE_FILE = "profile.json";
     AGENT_RESPONSIBILITY_BODY_FILE = "agent-responsibility.md";
+    CAPABILITY_BODY_FILE = "capability.md";
   }
 });
 
@@ -1474,6 +1478,7 @@ function getCompanyStoreAssetRoot(kind) {
   const root = getCompanyStoreRoot();
   if (!root) return null;
   const folderByKind = {
+    capabilities: "capabilities",
     agentResponsibilities: "agent-responsibilities",
     agentActions: "agent-actions",
     goals: "goals",
@@ -1583,12 +1588,18 @@ function getAgentActionsRoot() {
 function getProjectAgentActionsRoot() {
   return path8.join(process.cwd(), ".kody", "agent-actions");
 }
+function getProjectCapabilitiesRoot() {
+  return path8.join(process.cwd(), ".kody", "capabilities");
+}
 function getProjectAgentResponsibilitiesRoot() {
   return path8.join(process.cwd(), ".kody", "agent-responsibilities");
 }
 function getCompanyStoreAgentActionsRoot() {
   return getCompanyStoreAssetRoot("agentActions");
 }
+function getCompanyStoreCapabilitiesRoot() {
+  return getCompanyStoreAssetRoot("capabilities");
+}
 function getCompanyStoreAgentResponsibilitiesRoot() {
   return getCompanyStoreAssetRoot("agentResponsibilities");
 }
@@ -1608,12 +1619,28 @@ function getBuiltinAgentResponsibilitiesRoot() {
   return candidates[0];
 }
 function getAgentActionRoots() {
+  const projectCapabilitiesRoot = getProjectCapabilitiesRoot();
+  const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
   const storeRoot = getCompanyStoreAgentActionsRoot();
-  return [getProjectAgentActionsRoot(), ...storeRoot ? [storeRoot] : [], getAgentActionsRoot()];
+  return [
+    projectCapabilitiesRoot,
+    getProjectAgentActionsRoot(),
+    ...storeCapabilitiesRoot ? [storeCapabilitiesRoot] : [],
+    ...storeRoot ? [storeRoot] : [],
+    getAgentActionsRoot()
+  ];
 }
 function getAgentResponsibilityRoots(projectAgentResponsibilitiesRoot = getProjectAgentResponsibilitiesRoot()) {
+  const projectCapabilitiesRoot = getProjectCapabilitiesRoot();
+  const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
   const storeRoot = getCompanyStoreAgentResponsibilitiesRoot();
-  return [projectAgentResponsibilitiesRoot, ...storeRoot ? [storeRoot] : [], getBuiltinAgentResponsibilitiesRoot()];
+  return [
+    projectCapabilitiesRoot,
+    projectAgentResponsibilitiesRoot,
+    ...storeCapabilitiesRoot ? [storeCapabilitiesRoot] : [],
+    ...storeRoot ? [storeRoot] : [],
+    getBuiltinAgentResponsibilitiesRoot()
+  ];
 }
 function listAgentActions(roots = getAgentActionRoots()) {
   const rootList = typeof roots === "string" ? [roots] : roots;
@@ -1621,12 +1648,13 @@ function listAgentActions(roots = getAgentActionRoots()) {
   const out = [];
   for (const root of rootList) {
     if (!fs6.existsSync(root)) continue;
+    const requireImplementationProfile = isCapabilityRoot(root);
     const entries = fs6.readdirSync(root, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
       if (seen.has(ent.name)) continue;
       const profilePath = path8.join(root, ent.name, AGENT_RESPONSIBILITY_PROFILE_FILE);
-      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+      if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile() && isImplementationProfile(profilePath, requireImplementationProfile)) {
         out.push({ name: ent.name, profilePath });
         seen.add(ent.name);
       }
@@ -1639,7 +1667,7 @@ function resolveAgentAction(name, roots = getAgentActionRoots()) {
   const rootList = typeof roots === "string" ? [roots] : roots;
   for (const root of rootList) {
     const profilePath = path8.join(root, name, "profile.json");
-    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile()) {
+    if (fs6.existsSync(profilePath) && fs6.statSync(profilePath).isFile() && isImplementationProfile(profilePath, isCapabilityRoot(root))) {
       return profilePath;
     }
   }
@@ -1654,18 +1682,29 @@ function listAgentResponsibilityActions(projectAgentResponsibilitiesRoot = getPr
     seen.add(action.action);
     out.push(action);
   };
-  const roots = getAgentResponsibilityRoots(projectAgentResponsibilitiesRoot);
   const executableRoots = getAgentActionRoots();
-  for (const action of listFolderAgentResponsibilityActions(roots[0], "project-folder")) add(action);
-  for (const action of listAgentActionResponsibilityActions(executableRoots[0], "project-agentAction")) add(action);
-  if (roots.length === 3) {
-    for (const action of listFolderAgentResponsibilityActions(roots[1], "company-store")) add(action);
-    for (const action of listAgentActionResponsibilityActions(executableRoots[1], "company-store-agentAction"))
-      add(action);
-    for (const action of listBuiltinAgentResponsibilityActions(roots[2])) add(action);
-  } else {
-    for (const action of listBuiltinAgentResponsibilityActions(roots[1])) add(action);
-  }
+  const projectCapabilitiesRoot = getProjectCapabilitiesRoot();
+  const projectLegacyRoot = projectAgentResponsibilitiesRoot;
+  const storeCapabilitiesRoot = getCompanyStoreCapabilitiesRoot();
+  const storeLegacyRoot = getCompanyStoreAgentResponsibilitiesRoot();
+  const projectExecutableRoots = executableRoots.slice(0, 2);
+  const storeExecutableRoots = executableRoots.slice(2, -1);
+  for (const action of listFolderAgentResponsibilityActions(projectCapabilitiesRoot, "project-folder", true))
+    add(action);
+  for (const action of listFolderAgentResponsibilityActions(projectLegacyRoot, "project-folder")) add(action);
+  for (const root of projectExecutableRoots) {
+    for (const action of listAgentActionResponsibilityActions(root, "project-agentAction")) add(action);
+  }
+  if (storeCapabilitiesRoot) {
+    for (const action of listFolderAgentResponsibilityActions(storeCapabilitiesRoot, "company-store", true)) add(action);
+  }
+  if (storeLegacyRoot) {
+    for (const action of listFolderAgentResponsibilityActions(storeLegacyRoot, "company-store")) add(action);
+  }
+  for (const root of storeExecutableRoots) {
+    for (const action of listAgentActionResponsibilityActions(root, "company-store-agentAction")) add(action);
+  }
+  for (const action of listBuiltinAgentResponsibilityActions(getBuiltinAgentResponsibilitiesRoot())) add(action);
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
 function resolveAgentResponsibilityAction(action, projectAgentResponsibilitiesRoot = getProjectAgentResponsibilitiesRoot()) {
@@ -1684,7 +1723,7 @@ function resolveAgentResponsibilityFolder(slug2, projectAgentResponsibilitiesRoo
   return null;
 }
 function resolveAgentResponsibilityExecution(agentResponsibility) {
-  const agentAction = agentResponsibility.config.agentAction ?? agentResponsibility.config.agentActions?.[0] ?? (agentResponsibility.config.tickScript ? "agent-responsibility-tick-scripted" : "agent-responsibility-tick");
+  const agentAction = agentResponsibility.config.agentAction ?? agentResponsibility.config.agentActions?.[0] ?? (agentResponsibility.config.role ? agentResponsibility.slug : void 0) ?? (agentResponsibility.config.tickScript ? "agent-responsibility-tick-scripted" : "agent-responsibility-tick");
   const cliArgs = agentActionDeclaresInput(agentAction, "agentResponsibility") ? { agentResponsibility: agentResponsibility.slug } : {};
   return { agentAction, cliArgs };
 }
@@ -1706,6 +1745,19 @@ function agentActionDeclaresInput(agentAction, inputName) {
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
 }
+function isCapabilityRoot(root) {
+  const normalized = path8.normalize(root);
+  return path8.basename(normalized) === "capabilities" && path8.basename(path8.dirname(normalized)) === ".kody";
+}
+function isImplementationProfile(profilePath, requireImplementationProfile) {
+  if (!requireImplementationProfile) return true;
+  try {
+    const raw = JSON.parse(fs6.readFileSync(profilePath, "utf-8"));
+    return typeof raw.role === "string" && PUBLIC_AGENT_ACTION_ACTION_ROLES.has(raw.role);
+  } catch {
+    return false;
+  }
+}
 function listAgentActionResponsibilityActions(root, source) {
   if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
   const out = [];
@@ -1734,13 +1786,14 @@ function listAgentActionResponsibilityActions(root, source) {
   }
   return out.sort((a, b) => a.action.localeCompare(b.action));
 }
-function listFolderAgentResponsibilityActions(root, source) {
+function listFolderAgentResponsibilityActions(root, source, requireCapabilityKind = false) {
   if (!fs6.existsSync(root) || !fs6.statSync(root).isDirectory()) return [];
   const out = [];
   for (const slug2 of listAgentResponsibilityFolderSlugs(root)) {
     if (!isSafeName(slug2)) continue;
     const agentResponsibility = readAgentResponsibilityFolder(root, slug2);
     if (!agentResponsibility) continue;
+    if (requireCapabilityKind && !agentResponsibility.config.capabilityKind) continue;
     const action = agentResponsibility.config.action ?? slug2;
     const { agentAction, cliArgs } = resolveAgentResponsibilityExecution(agentResponsibility);
     out.push({
@@ -8241,6 +8294,224 @@ var init_agent_responsibilityEvidence = __esm({
   }
 });
 
+// src/goal/report.ts
+function goalDashboardReportRequested(data, state) {
+  return data.jobSaveReport === true || state?.extra.saveReport === true;
+}
+function refreshGoalDashboardReport(input) {
+  const evidenceItems = input.evidenceItems ?? [];
+  if (!goalDashboardReportRequested(input.data, input.state)) return null;
+  if (!REPORT_SLUG_RE.test(input.goalId)) {
+    throw new Error(`goal report: invalid goal id "${input.goalId}"`);
+  }
+  const filePath = `reports/${input.goalId}.md`;
+  const body = goalReportBody(
+    input.goalId,
+    input.state,
+    snapshotFromState(input.goalId, input.state),
+    latestGoalRunLogEvent(input.data, input.goalId),
+    evidenceItems
+  );
+  const current = readStateText(input.config, input.cwd, filePath);
+  if (current?.content === body) {
+    const report2 = { slug: input.goalId, path: current.path, changed: false };
+    recordGoalReport(input.data, report2);
+    return report2;
+  }
+  upsertStateText(input.config, input.cwd, filePath, body, `chore(reports): refresh ${input.goalId}`);
+  const report = { slug: input.goalId, path: filePath, changed: true };
+  recordGoalReport(input.data, report);
+  return report;
+}
+function responsibilityEvidenceOutput(evidence) {
+  return {
+    kind: "responsibility-evidence",
+    sources: evidence.sources,
+    status: evidence.status,
+    summary: evidence.summary,
+    evidence: evidence.evidence ?? {},
+    facts: evidence.facts,
+    artifacts: evidence.artifacts,
+    missingEvidence: evidence.missingEvidence,
+    blockers: evidence.blockers
+  };
+}
+function goalReportBody(goalId, state, snapshot, latestEvent, evidenceItems) {
+  const outputs = evidenceItems.map(responsibilityEvidenceOutput);
+  const latestOutput = outputs.at(-1);
+  const facts = recordField2(snapshot, "facts") ?? recordField2(state.extra, "facts") ?? {};
+  const blockers = uniqueStrings2([
+    ...stringArrayField(snapshot, "blockers"),
+    ...stringArrayField(latestEvent, "blockers"),
+    ...evidenceItems.flatMap((item) => item.blockers)
+  ]);
+  const missingEvidence = uniqueStrings2([
+    ...stringArrayField(snapshot, "missingEvidence"),
+    ...evidenceItems.flatMap((item) => item.missingEvidence)
+  ]);
+  const artifacts = uniqueArtifacts2([
+    ...evidenceItems.flatMap((item) => item.artifacts),
+    ...artifactArrayField(latestEvent, "artifacts")
+  ]);
+  return [
+    `# ${goalId}`,
+    "",
+    "## Status",
+    `- State: ${state.state}`,
+    `- Stage: ${stringField3(snapshot, "stage") ?? stringField3(state.extra, "stage") ?? "unknown"}`,
+    `- Next step: ${nextStepFromEvent(state, snapshot, latestOutput, latestEvent)}`,
+    `- Updated: ${state.updatedAt ?? state.createdAt ?? state.startedAt ?? "unknown"}`,
+    "",
+    "## Decision",
+    `- Event: ${stringField3(latestEvent, "event") ?? "unknown"}`,
+    `- Reason: ${decisionReason(state, latestEvent, latestOutput, missingEvidence, blockers)}`,
+    `- Required evidence: ${listOrNone(stringArrayField(snapshot, "requiredEvidence"))}`,
+    `- Satisfied evidence: ${listOrNone(stringArrayField(snapshot, "satisfiedEvidence"))}`,
+    `- Missing evidence: ${listOrNone(missingEvidence)}`,
+    `- Blockers: ${listOrNone(blockers)}`,
+    "",
+    "## Responsibility Evidence",
+    ...responsibilityEvidenceMarkdown(outputs),
+    "",
+    "## Facts",
+    fencedJson(facts),
+    "",
+    "## Artifacts",
+    ...artifactMarkdown(artifacts),
+    ""
+  ].join("\n");
+}
+function responsibilityEvidenceMarkdown(outputs) {
+  if (outputs.length === 0) return ["- none"];
+  return outputs.flatMap((output, index) => evidenceOutputMarkdown(index + 1, output));
+}
+function decisionReason(state, latestEvent, latestOutput, missingEvidence, blockers) {
+  if (state.state === "done") return "destination evidence satisfied";
+  if (blockers.length > 0) return blockers[0] ?? "blocked";
+  const eventReason = stringField3(latestEvent, "reason") ?? stringField3(recordField2(latestEvent, "decision"), "reason");
+  if (eventReason) return eventReason;
+  const summary = stringField3(latestOutput, "summary");
+  if (summary) return summary;
+  if (missingEvidence.length > 0) return `waiting for ${missingEvidence[0]}`;
+  return "waiting for more evidence";
+}
+function evidenceOutputMarkdown(index, output) {
+  return [
+    `### Output ${index}`,
+    `- Status: ${stringField3(output, "status") ?? "unknown"}`,
+    `- Summary: ${stringField3(output, "summary") ?? "no summary"}`,
+    `- Sources: ${listOrNone(stringArrayField(output, "sources"))}`,
+    `- Evidence values: ${inlineJson(recordField2(output, "evidence") ?? {})}`,
+    `- Missing evidence: ${listOrNone(stringArrayField(output, "missingEvidence"))}`,
+    `- Blockers: ${listOrNone(stringArrayField(output, "blockers"))}`,
+    ""
+  ];
+}
+function artifactMarkdown(artifacts) {
+  if (artifacts.length === 0) return ["- none"];
+  return artifacts.map((artifact) => {
+    if (artifact.url) return `- [${artifact.label}](${artifact.url})`;
+    return `- ${artifact.label}: ${artifact.path}`;
+  });
+}
+function fencedJson(value) {
+  return ["```json", JSON.stringify(value, null, 2), "```"].join("\n");
+}
+function inlineJson(value) {
+  return JSON.stringify(value);
+}
+function listOrNone(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function uniqueStrings2(values) {
+  return [...new Set(values)].sort();
+}
+function stringField3(record2, key) {
+  const value = record2?.[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function recordField2(record2, key) {
+  const value = record2?.[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : void 0;
+}
+function stringArrayField(record2, key) {
+  const value = record2?.[key];
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function artifactArrayField(record2, key) {
+  const value = record2?.[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter(isArtifact);
+}
+function isArtifact(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record2 = value;
+  return typeof record2.label === "string" && (record2.url === void 0 || typeof record2.url === "string") && (record2.path === void 0 || typeof record2.path === "string");
+}
+function uniqueArtifacts2(artifacts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const artifact of artifacts) {
+    const key = `${artifact.label}
+${artifact.url ?? ""}
+${artifact.path ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(artifact);
+  }
+  return out;
+}
+function nextStepFromEvent(state, goalAfter, responsibilityOutput, latestEvent) {
+  if (state.state === "done") return "done";
+  const decisionKind = stringField3(recordField2(latestEvent, "decision"), "kind") ?? stringField3(latestEvent, "status");
+  if (decisionKind === "done") return "done";
+  if (decisionKind === "dispatch") return "dispatch";
+  if (decisionKind === "blocked" || decisionKind === "reject-evidence") return "block";
+  if (decisionKind === "wait" || decisionKind === "idle" || decisionKind === "no-state-change") return "wait";
+  if (responsibilityOutput) return nextStepFromEvidence(goalAfter, responsibilityOutput);
+  return "wait";
+}
+function nextStepFromEvidence(goalAfter, responsibilityOutput) {
+  const status = typeof responsibilityOutput.status === "string" ? responsibilityOutput.status : "";
+  const outputBlockers = stringArrayField(responsibilityOutput, "blockers");
+  const goalBlockers = stringArrayField(goalAfter, "blockers");
+  const missingEvidence = stringArrayField(goalAfter, "missingEvidence");
+  if (goalAfter && missingEvidence.length === 0) return "done";
+  if (status === "fail" || status === "blocked" || outputBlockers.length > 0) return "rescue";
+  if (goalBlockers.length > 0) return "block";
+  if (missingEvidence.length > 0 && status !== "noop") return "dispatch";
+  return "wait";
+}
+function snapshotFromState(goalId, state) {
+  const managed = managedGoalFromState(state);
+  return managed ? goalRunLogSnapshot(goalId, state.state, managed) : null;
+}
+function latestGoalRunLogEvent(data, goalId) {
+  const logs = data[GOAL_LOGS_KEY];
+  if (!logs || typeof logs !== "object" || Array.isArray(logs)) return void 0;
+  const log2 = logs[goalId];
+  if (!log2 || typeof log2 !== "object" || Array.isArray(log2)) return void 0;
+  const events = log2.events;
+  if (!Array.isArray(events)) return void 0;
+  const latest = events.at(-1);
+  return latest && typeof latest === "object" && !Array.isArray(latest) ? latest : void 0;
+}
+function recordGoalReport(data, report) {
+  const prior = Array.isArray(data.goalReports) ? data.goalReports : [];
+  data.goalReports = [...prior, report];
+}
+var REPORT_SLUG_RE, GOAL_LOGS_KEY;
+var init_report = __esm({
+  "src/goal/report.ts"() {
+    "use strict";
+    init_stateRepo();
+    init_manager();
+    init_runLog();
+    REPORT_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+    GOAL_LOGS_KEY = "__goalRunLogs";
+  }
+});
+
 // src/scripts/applyAgentResponsibilityReports.ts
 function flushLogs(ctx) {
   try {
@@ -8252,6 +8523,24 @@ function flushLogs(ctx) {
     );
   }
 }
+function refreshReportOrFail(ctx, goalId, state, evidenceItems) {
+  try {
+    refreshGoalDashboardReport({
+      config: ctx.config,
+      cwd: ctx.cwd,
+      data: ctx.data,
+      goalId,
+      state,
+      evidenceItems
+    });
+  } catch (err) {
+    fail(ctx, err instanceof Error ? err.message : String(err));
+  }
+}
+function fail(ctx, reason) {
+  ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${reason}` : reason;
+  if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
+}
 function collectReports(raw, agentResult) {
   const out = [];
   if (Array.isArray(raw)) {
@@ -8304,23 +8593,10 @@ function completeSatisfiedManagedGoal(state) {
   if (decision.kind !== "done") return state;
   return writeManagedGoalToState({ ...state, state: "done" }, managed);
 }
-function snapshotFromState(goalId, state) {
+function snapshotFromState2(goalId, state) {
   const managed = managedGoalFromState(state);
   return managed ? goalRunLogSnapshot(goalId, state.state, managed) : null;
 }
-function responsibilityEvidenceOutput(evidence) {
-  return {
-    kind: "responsibility-evidence",
-    sources: evidence.sources,
-    status: evidence.status,
-    summary: evidence.summary,
-    evidence: evidence.evidence ?? {},
-    facts: evidence.facts,
-    artifacts: evidence.artifacts,
-    missingEvidence: evidence.missingEvidence,
-    blockers: evidence.blockers
-  };
-}
 function evidenceInspection(goalBefore, goalAfter, responsibilityOutput, explicitEvidence) {
   return {
     expectedEvidence: {
@@ -8342,22 +8618,22 @@ function evidenceDecision(change, goalAfter, responsibilityOutput) {
   return {
     kind: change ? "accept-evidence" : "no-state-change",
     status: responsibilityOutput.status,
-    nextStep: nextStepFromEvidence(goalAfter, responsibilityOutput),
+    nextStep: nextStepFromEvidence2(goalAfter, responsibilityOutput),
     reason: responsibilityOutput.summary
   };
 }
-function nextStepFromEvidence(goalAfter, responsibilityOutput) {
+function nextStepFromEvidence2(goalAfter, responsibilityOutput) {
   const status = typeof responsibilityOutput.status === "string" ? responsibilityOutput.status : "";
-  const outputBlockers = stringArrayField(responsibilityOutput, "blockers");
-  const goalBlockers = stringArrayField(goalAfter, "blockers");
-  const missingEvidence = stringArrayField(goalAfter, "missingEvidence");
+  const outputBlockers = stringArrayField2(responsibilityOutput, "blockers");
+  const goalBlockers = stringArrayField2(goalAfter, "blockers");
+  const missingEvidence = stringArrayField2(goalAfter, "missingEvidence");
   if (goalAfter && missingEvidence.length === 0) return "done";
   if (status === "fail" || status === "blocked" || outputBlockers.length > 0) return "rescue";
   if (goalBlockers.length > 0) return "block";
   if (missingEvidence.length > 0 && status !== "noop") return "dispatch";
   return "wait";
 }
-function stringArrayField(record2, key) {
+function stringArrayField2(record2, key) {
   const value = record2?.[key];
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
 }
@@ -8373,6 +8649,7 @@ var init_applyAgentResponsibilityReports = __esm({
     init_agent_responsibilityReport();
     init_agent_responsibilityResult();
     init_manager();
+    init_report();
     init_runLog();
     init_state2();
     init_stateStore();
@@ -8410,9 +8687,9 @@ var init_applyAgentResponsibilityReports = __esm({
         }
         let next = prior;
         for (const evidence of goalEvidence) {
-          const beforeSnapshot = snapshotFromState(goalId, next);
+          const beforeSnapshot = snapshotFromState2(goalId, next);
           next = applyAgentResponsibilityEvidenceToGoalState(next, evidence);
-          const afterSnapshot = snapshotFromState(goalId, next);
+          const afterSnapshot = snapshotFromState2(goalId, next);
           const change = goalRunLogChange(beforeSnapshot, afterSnapshot);
           const output = responsibilityEvidenceOutput(evidence);
           stageGoalRunLogEvent(ctx.data, goalId, {
@@ -8435,9 +8712,9 @@ var init_applyAgentResponsibilityReports = __esm({
             change
           });
         }
-        const beforeCompletionSnapshot = snapshotFromState(goalId, next);
+        const beforeCompletionSnapshot = snapshotFromState2(goalId, next);
         next = completeSatisfiedManagedGoal(next);
-        const afterCompletionSnapshot = snapshotFromState(goalId, next);
+        const afterCompletionSnapshot = snapshotFromState2(goalId, next);
         if (prior.state !== "done" && next.state === "done") {
           stageGoalRunLogEvent(ctx.data, goalId, {
             source: "goal-loop",
@@ -8455,12 +8732,16 @@ var init_applyAgentResponsibilityReports = __esm({
             change: goalRunLogChange(beforeCompletionSnapshot, afterCompletionSnapshot)
           });
         }
-        if (serializeGoalState(next) === serializeGoalState(prior)) {
+        const changed = serializeGoalState(next) !== serializeGoalState(prior);
+        const nextForOutput = changed ? { ...next, updatedAt: nowIso() } : next;
+        try {
+          if (changed) {
+            putGoalState(ctx.config, goalId, nextForOutput, describeMessage(goalId, goalEvidence), ctx.cwd);
+          }
+          refreshReportOrFail(ctx, goalId, nextForOutput, goalEvidence);
+        } finally {
           flushLogs(ctx);
-          continue;
         }
-        putGoalState(ctx.config, goalId, { ...next, updatedAt: nowIso() }, describeMessage(goalId, goalEvidence), ctx.cwd);
-        flushLogs(ctx);
       }
     };
   }
@@ -8732,6 +9013,22 @@ var init_commitAndPush = __esm({
 });
 
 // src/scripts/commitGoalState.ts
+function refreshReportOrFail2(ctx, goalId, state) {
+  if (!state) return;
+  try {
+    refreshGoalDashboardReport({
+      config: ctx.config,
+      cwd: ctx.cwd,
+      data: ctx.data,
+      goalId,
+      state
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${reason}` : reason;
+    if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
+  }
+}
 function flushLogs2(ctx) {
   try {
     flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
@@ -8750,6 +9047,7 @@ var commitGoalState;
 var init_commitGoalState = __esm({
   "src/scripts/commitGoalState.ts"() {
     "use strict";
+    init_report();
     init_runLog();
     init_stateStore();
     commitGoalState = async (ctx) => {
@@ -8759,6 +9057,7 @@ var init_commitGoalState = __esm({
         return;
       }
       if (ctx.data.goalPersistChanged !== true) {
+        refreshReportOrFail2(ctx, goal.id, goal.raw);
         flushLogs2(ctx);
         return;
       }
@@ -8769,6 +9068,7 @@ var init_commitGoalState = __esm({
       }
       try {
         putGoalState(ctx.config, goal.id, updated, describeCommitMessage(goal), ctx.cwd);
+        refreshReportOrFail2(ctx, goal.id, updated);
       } catch (err) {
         process.stderr.write(
           `[goal-manager] commitGoalState: persist to state repo failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
@@ -12039,7 +12339,7 @@ var init_markFlowSuccess = __esm({
 });
 
 // src/goal/operations.ts
-function fail(err) {
+function fail2(err) {
   if (err instanceof Error) {
     const lines = err.message.split("\n").filter(Boolean);
     return { ok: false, error: lines[0] ?? err.message };
@@ -12051,7 +12351,7 @@ function commentOnIssue(issueNumber, body, cwd) {
     gh(["issue", "comment", String(issueNumber), "--body", body], { cwd });
     return { ok: true };
   } catch (err) {
-    return fail(err);
+    return fail2(err);
   }
 }
 function mergePrSquash(prNumber, cwd) {
@@ -12059,7 +12359,7 @@ function mergePrSquash(prNumber, cwd) {
     gh(["pr", "merge", String(prNumber), "--squash", "--delete-branch"], { cwd });
     return { ok: true };
   } catch (err) {
-    return fail(err);
+    return fail2(err);
   }
 }
 var init_operations = __esm({
@@ -12590,21 +12890,21 @@ var init_openQaIssue = __esm({
         ctx.data.action = failedAction3(reason);
         return;
       }
-      const reportBody2 = agentResult.finalText.trim();
-      if (!reportBody2) {
+      const reportBody = agentResult.finalText.trim();
+      if (!reportBody) {
         process.stderr.write("qa-engineer: agent produced no report body\n");
         ctx.output.exitCode = 1;
         ctx.output.reason = "empty report body";
         ctx.data.action = failedAction3("empty report body");
         return;
       }
-      const verdict = detectVerdict(reportBody2);
+      const verdict = detectVerdict(reportBody);
       ctx.data.qaVerdict = verdict;
-      ctx.data.qaReport = reportBody2;
+      ctx.data.qaReport = reportBody;
       const existingIssue = ctx.args.issue;
       if (typeof existingIssue === "number" && Number.isFinite(existingIssue) && existingIssue > 0) {
         try {
-          postIssueComment(existingIssue, reportBody2, ctx.cwd);
+          postIssueComment(existingIssue, reportBody, ctx.cwd);
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           ctx.output.exitCode = 4;
@@ -12626,7 +12926,7 @@ QA_REPORT_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.gith
       const hasLabel = ensureLabel2(ctx.cwd);
       let created;
       try {
-        created = createQaIssue(title, reportBody2, hasLabel, ctx.cwd);
+        created = createQaIssue(title, reportBody, hasLabel, ctx.cwd);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         ctx.output.exitCode = 4;
@@ -15958,86 +16258,6 @@ var init_writeJobStateFile = __esm({
   }
 });
 
-// src/scripts/writeResponsibilityReport.ts
-function writeReport(ctx, profile, agentResult) {
-  const slug2 = responsibilitySlug(ctx);
-  if (!slug2) {
-    fail2(ctx, "writeResponsibilityReport: missing responsibility slug");
-    return;
-  }
-  if (!REPORT_SLUG_RE.test(slug2)) {
-    fail2(ctx, `writeResponsibilityReport: invalid responsibility slug "${slug2}"`);
-    return;
-  }
-  const body = reportBody(ctx, agentResult, profile);
-  if (!body.trim()) {
-    fail2(ctx, `writeResponsibilityReport: ${slug2} produced no report output`);
-    return;
-  }
-  const filePath = `reports/${slug2}.md`;
-  const current = readStateText(ctx.config, ctx.cwd, filePath);
-  if (current?.content === body) {
-    ctx.data.responsibilityReport = { slug: slug2, path: current.path, changed: false };
-    return;
-  }
-  upsertStateText(
-    ctx.config,
-    ctx.cwd,
-    filePath,
-    body,
-    `chore(reports): refresh ${slug2}`
-  );
-  ctx.data.responsibilityReport = { slug: slug2, path: filePath, changed: true };
-}
-function responsibilitySlug(ctx) {
-  const candidates = [
-    ctx.data.jobAgentResponsibility,
-    ctx.data.agentResponsibilitySlug,
-    ctx.data.jobSlug
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
-  }
-  return null;
-}
-function reportBody(ctx, agentResult, profile) {
-  const prSummary = ctx.data.prSummary;
-  if (typeof prSummary === "string" && prSummary.trim()) return ensureTrailingNewline(prSummary.trim());
-  if (agentResult?.finalText.trim()) return ensureTrailingNewline(agentResult.finalText.trim());
-  const reason = ctx.output.reason || ctx.data.agentFailureReason || agentResult?.error;
-  if (typeof reason === "string" && reason.trim()) {
-    return `# ${profile.name}
-
-FAILED: ${reason.trim()}
-`;
-  }
-  return "";
-}
-function fail2(ctx, reason) {
-  ctx.output.reason = ctx.output.reason ? `${ctx.output.reason}; ${reason}` : reason;
-  if (ctx.output.exitCode === 0) ctx.output.exitCode = 99;
-}
-function ensureTrailingNewline(value) {
-  return value.endsWith("\n") ? value : `${value}
-`;
-}
-var REPORT_SLUG_RE, writeResponsibilityReport;
-var init_writeResponsibilityReport = __esm({
-  "src/scripts/writeResponsibilityReport.ts"() {
-    "use strict";
-    init_stateRepo();
-    REPORT_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
-    writeResponsibilityReport = async (ctx, profile, agentResult) => {
-      if (ctx.data.jobSaveReport !== true) return;
-      try {
-        writeReport(ctx, profile, agentResult);
-      } catch (err) {
-        fail2(ctx, `writeResponsibilityReport: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    };
-  }
-});
-
 // src/scripts/index.ts
 var preflightScripts, postflightScripts, allScriptNames;
 var init_scripts = __esm({
@@ -16139,7 +16359,6 @@ var init_scripts = __esm({
     init_writeAgentRunSummary();
     init_writeIssueStateComment();
     init_writeJobStateFile();
-    init_writeResponsibilityReport();
     preflightScripts = {
       runFlow,
       fixFlow,
@@ -16218,7 +16437,6 @@ var init_scripts = __esm({
       postReviewResult,
       persistArtifacts,
       writeAgentRunSummary,
-      writeResponsibilityReport,
       saveTaskState,
       mirrorStateToPr,
       startFlow,
@@ -16778,7 +16996,6 @@ async function runAgentAction(profileName, input) {
         outcome: postOutcome
       });
     }
-    await writeResponsibilityReport(ctx, profile, agentResult);
     return finishAndEnd({
       exitCode: ctx.output.exitCode ?? 0,
       prUrl: ctx.output.prUrl,
@@ -17176,9 +17393,8 @@ var init_executor = __esm({
     init_registry();
     init_runtimePaths();
     init_scripts();
-    init_writeResponsibilityReport();
-    init_subagents();
     init_stateWorkspace();
+    init_subagents();
     init_task_artifacts();
     init_tools();
     MUTATING_POSTFLIGHTS = /* @__PURE__ */ new Set([

package/package.json

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