@kody-ade/kody-engine 0.4.259 → 0.4.261

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
   /**
@@ -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
-  /** Ask the owning goal/loop to refresh reports/<goal-or-loop>.md after it applies evidence. */
+  /** 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.259",
+      version: "0.4.261",
       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,73 +8294,84 @@ var init_agent_responsibilityEvidence = __esm({
   }
 });
 
-// src/scripts/applyAgentResponsibilityReports.ts
-function flushLogs(ctx) {
-  try {
-    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
-  } catch (err) {
-    process.stderr.write(
-      `[kody agentResponsibility-report] goal log persist failed (${err instanceof Error ? err.message : String(err)})
-`
-    );
-  }
-}
-function writeGoalDashboardReport(ctx, goalId, state, snapshot, evidenceItems) {
-  if (ctx.data.jobSaveReport !== true) return;
-  if (!REPORT_SLUG_RE.test(goalId)) {
-    fail(ctx, `goal report: invalid goal id "${goalId}"`);
-    return;
-  }
-  const filePath = `reports/${goalId}.md`;
-  const body = goalReportBody(goalId, state, snapshot, evidenceItems);
-  try {
-    const current = readStateText(ctx.config, ctx.cwd, filePath);
-    if (current?.content === body) {
-      recordGoalReport(ctx.data, { slug: goalId, path: current.path, changed: false });
-      return;
-    }
-    upsertStateText(ctx.config, ctx.cwd, filePath, body, `chore(reports): refresh ${goalId}`);
-    recordGoalReport(ctx.data, { slug: goalId, path: filePath, changed: true });
-  } catch (err) {
-    fail(ctx, `goal report: ${err instanceof Error ? err.message : String(err)}`);
+// 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 recordGoalReport(data, report) {
-  const prior = Array.isArray(data.goalReports) ? data.goalReports : [];
-  data.goalReports = [...prior, 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, evidenceItems) {
+function goalReportBody(goalId, state, snapshot, latestEvent, evidenceItems) {
   const outputs = evidenceItems.map(responsibilityEvidenceOutput);
   const latestOutput = outputs.at(-1);
-  const nextStep = state.state === "done" ? "done" : latestOutput ? nextStepFromEvidence(snapshot, latestOutput) : "wait";
   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));
+  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: ${nextStep}`,
+    `- Next step: ${nextStepFromEvent(state, snapshot, latestOutput, latestEvent)}`,
     `- Updated: ${state.updatedAt ?? state.createdAt ?? state.startedAt ?? "unknown"}`,
     "",
     "## Decision",
-    `- Reason: ${decisionReason(state, latestOutput, missingEvidence, blockers)}`,
+    `- 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",
-    ...outputs.flatMap((output, index) => evidenceOutputMarkdown(index + 1, output)),
+    ...responsibilityEvidenceMarkdown(outputs),
     "",
     "## Facts",
     fencedJson(facts),
@@ -8317,9 +8381,15 @@ function goalReportBody(goalId, state, snapshot, evidenceItems) {
     ""
   ].join("\n");
 }
-function decisionReason(state, latestOutput, missingEvidence, blockers) {
+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]}`;
@@ -8364,6 +8434,20 @@ 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 = [];
@@ -8377,6 +8461,82 @@ ${artifact.path ?? ""}`;
   }
   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 {
+    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
+  } catch (err) {
+    process.stderr.write(
+      `[kody agentResponsibility-report] goal log persist failed (${err instanceof Error ? err.message : String(err)})
+`
+    );
+  }
+}
+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;
@@ -8433,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: {
@@ -8471,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 : [];
 }
@@ -8494,7 +8641,7 @@ function describeMessage(goalId, evidenceItems) {
   const pieces = evidenceItems.map((evidence) => `${evidence.sources.join("+")}:${evidence.status}`);
   return `Apply agentResponsibility output to ${goalId}${pieces.length > 0 ? ` (${pieces.join("; ")})` : ""}`;
 }
-var REPORT_SLUG_RE, applyAgentResponsibilityReports;
+var applyAgentResponsibilityReports;
 var init_applyAgentResponsibilityReports = __esm({
   "src/scripts/applyAgentResponsibilityReports.ts"() {
     "use strict";
@@ -8502,11 +8649,10 @@ var init_applyAgentResponsibilityReports = __esm({
     init_agent_responsibilityReport();
     init_agent_responsibilityResult();
     init_manager();
+    init_report();
     init_runLog();
     init_state2();
     init_stateStore();
-    init_stateRepo();
-    REPORT_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
     applyAgentResponsibilityReports = async (ctx, _profile, agentResult) => {
       const reports = collectReports(ctx.data.agentResponsibilityReports, agentResult);
       const results = collectResults(ctx.data.dutyResults, agentResult);
@@ -8541,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, {
@@ -8566,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",
@@ -8588,19 +8734,14 @@ var init_applyAgentResponsibilityReports = __esm({
         }
         const changed = serializeGoalState(next) !== serializeGoalState(prior);
         const nextForOutput = changed ? { ...next, updatedAt: nowIso() } : next;
-        writeGoalDashboardReport(
-          ctx,
-          goalId,
-          nextForOutput,
-          afterCompletionSnapshot ?? beforeCompletionSnapshot,
-          goalEvidence
-        );
-        if (!changed) {
+        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, nextForOutput, describeMessage(goalId, goalEvidence), ctx.cwd);
-        flushLogs(ctx);
       }
     };
   }
@@ -8872,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);
@@ -8890,6 +9047,7 @@ var commitGoalState;
 var init_commitGoalState = __esm({
   "src/scripts/commitGoalState.ts"() {
     "use strict";
+    init_report();
     init_runLog();
     init_stateStore();
     commitGoalState = async (ctx) => {
@@ -8899,6 +9057,7 @@ var init_commitGoalState = __esm({
         return;
       }
       if (ctx.data.goalPersistChanged !== true) {
+        refreshReportOrFail2(ctx, goal.id, goal.raw);
         flushLogs2(ctx);
         return;
       }
@@ -8909,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
@@ -22078,9 +22238,9 @@ Usage:
   kody-engine help
   kody-engine version
 
-Top-level work commands are agentResponsibility actions. A agentResponsibility owns the public action name
-and selects an implementation agentAction. Use exec only for internal agentAction
-profiles such as scheduled helpers.
+Top-level work commands are capabilities. A capability owns the public command name
+and resolves the implementation that runs it. Use exec only for internal implementation
+profiles and legacy scheduled helpers.
 
 Exit codes:
   0   success (PR opened, verify passed \u2014 or resolve produced a merge commit)

package/package.json

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