@kody-ade/kody-engine 0.4.261 → 0.4.263

package/dist/capabilities/agent-factory/capability.md

@@ -0,0 +1,10 @@
+# Agent Factory
+
+## Purpose
+
+Create or assemble Kody agency model definitions from an operator request.
+
+## Instructions
+
+Use the `agent-factory` implementation for the execution details.
+The capability owns the public action name and review boundary; the implementation owns model reasoning and state-repo PR creation.

package/dist/{agent-responsibilities → capabilities}/agent-factory/profile.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-factory",
   "action": "agent-factory",
-  "agentAction": "agent-factory",
+  "implementation": "agent-factory",
   "capabilityKind": "act",
   "describe": "Create or assemble Kody agency model definitions from an operator request."
 }

package/dist/capabilities/run/capability.md

@@ -0,0 +1,10 @@
+# Run
+
+## Purpose
+
+Implement a GitHub issue end-to-end.
+
+## Instructions
+
+Use the `run` implementation for the execution details.
+The capability owns the public action name and the reason this action exists; the implementation owns the method.

package/dist/{agent-responsibilities → capabilities}/run/profile.json

@@ -1,6 +1,6 @@
 {
   "name": "run",
   "action": "run",
-  "agentAction": "run",
+  "implementation": "run",
   "describe": "Implement a GitHub issue end-to-end."
 }

package/dist/{agent-actions → executables}/agent-factory/prompt.md

@@ -6,7 +6,7 @@ You are Kody's agent factory. Convert the operator request into review-ready Kod
 - Default branch: {{defaultBranch}}
 - Issue #{{issue.number}}: {{issue.title}}
 
-{{agentResponsibilityReference}}
+{{capabilityReference}}
 
 # Operator Request
 
@@ -18,7 +18,7 @@ You are Kody's agent factory. Convert the operator request into review-ready Kod
 
 # Task
 
-Design the smallest Kody model structure that satisfies the request. You may create or assemble simple agentActions, agentResponsibilities, loops, goals, and agents.
+Design the smallest Kody model structure that satisfies the request. You may create or assemble simple executables, capabilities, loops, goals, and agents.
 
 Use the current Kody vocabulary:
 
@@ -30,8 +30,8 @@ Use the current Kody vocabulary:
 
 Use current storage names when producing files:
 
-- agentResponsibility: capability contract, public action ownership, kind, agent, cadence, and output contract
-- agentAction: capability implementation
+- capability: capability contract, public action ownership, kind, agent, cadence, and output contract
+- executable: capability implementation
 
 # Boundaries
 
@@ -40,7 +40,7 @@ Use current storage names when producing files:
 - Do not activate generated definitions yourself.
 - Do not create a consumer-repo PR.
 - The deterministic postflight will open a review PR in the configured state repo under the configured state path.
-- Put generated file paths relative to the configured state path, for example `agent-actions/...`, `agent-responsibilities/...`, `agents/...`, `goals/...`, or `memory/...`.
+- Put generated file paths relative to the configured state path, for example `executables/...`, `capabilities/...`, `agents/...`, `goals/...`, or `memory/...`.
 - Produce complete file contents. Do not describe patches.
 - Prefer a small bundle over a broad framework. Include assumptions in the summary.
 
@@ -59,7 +59,7 @@ PR_SUMMARY:
   "summary": "human explanation and assumptions",
   "files": [
     {
-      "path": "agent-actions/example/profile.json",
+      "path": "executables/example/profile.json",
       "content": "{\n  \"name\": \"example\"\n}\n"
     }
   ]

package/dist/{agent-actions → executables}/run/prompt.md

@@ -76,6 +76,6 @@ If a prior-art block is present above, READ THE DIFFS — those are failed or su
 - Stay on the current branch (`{{branch}}`). It is already checked out for you.
 - Do NOT modify files under: `.kody/`, `.kody-engine/`, `.kody-lean/`, `.kody/`, `node_modules/`, `dist/`, `build/`, `.env`, or any `*.log`.
 - Do NOT post issue comments — the wrapper handles that.
-- Pre-existing quality-gate failures: assume they are NOT your responsibility unless your edits touched related code.
+- Pre-existing quality-gate failures: assume they are NOT yours unless your edits touched related code.
 - Keep the plan and reasoning concise. Long monologues waste turns.
 {{systemPromptAppend}}

package/dist/{agent-actions → executables}/types.ts

@@ -1,5 +1,5 @@
 /**
- * Types shared by the generic executor and agentActions.
+ * Types shared by the generic executor and executables.
  *
  * The executor reads a Profile, validates the user's CLI args against
  * Profile.inputs, then runs the declared preflight scripts → agent →
@@ -20,50 +20,49 @@ export type CapabilityKind = "observe" | "act" | "verify"
 export interface Profile {
   name: string
   /**
-   * Public action name owned by a agentResponsibility. A user may type `@kody <action>`;
-   * dispatch resolves that action to the agentResponsibility, then the agentResponsibility selects the
-   * implementation agentAction. Absent → the agentResponsibility slug/name is the action.
+   * Public action name owned by a capability. A user may type `@kody <action>`;
+   * dispatch resolves that action to the capability, then the capability selects the
+   * implementation executable. Absent → the capability slug/name is the action.
    */
   action?: string
   /**
-   * Optional agent this agentAction runs *as*. When set, the executor
+   * Optional agent this executable runs *as*. When set, the executor
    * loads hydrated `.kody/agents/<agent>.md` and injects that agent (authoritative
-   * identity) ahead of the agentAction's own system-prompt append. This is the
-   * unification hook: a "agentResponsibility" is just an agentAction + an agent. Absent →
+   * identity) ahead of the executable's own system-prompt append. This is the
+   * unification hook: a "capability" is just an executable + an agent. Absent →
    * runs with no agent (unchanged legacy behaviour). A declared-but-missing
    * agent file is fatal at run time (see src/agents.ts).
    */
   agent?: string
   describe: string
   /**
-   * Author-facing capability promise for a agentResponsibility/agentAction. This classifies the
+   * Author-facing capability promise for a capability/executable. This classifies the
    * shape of result it should return; it does not change executor control flow.
    */
   capabilityKind?: CapabilityKind
   /**
-   * Semantic role — what this agentAction IS, not when it runs.
+   * Semantic role — what this executable IS, not when it runs.
    *   - primitive:    single-step agent executor (flow → agent → verify → commit → PR).
    *   - orchestrator: no-agent, drives primitives via a postflight transition table
    *                   (comment-based, one GHA run per step).
    *   - container:    no-agent, runs declared `children` sequentially in-process
    *                   (one GHA run for the whole flow). Routing is done by per-child
    *                   `next` maps over action types — no @kody comments dispatched.
-   *   - watch:        scheduled observer that inspects repo state and may trigger other agentActions.
+   *   - watch:        scheduled observer that inspects repo state and may trigger other executables.
    *   - utility:      no-agent, one-off administrative work (scaffolding, release, etc.).
    *
    * Roles enforce shape at profile-load time and let help/dispatch treat
-   * agentActions differently by category.
+   * executables differently by category.
    */
   role: "primitive" | "orchestrator" | "container" | "watch" | "utility"
   /**
-   * 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.
+   * Capability contract profiles can point at a separate implementation by name.
+   * `executable` remains a legacy alias while old assets migrate.
    */
-  agentAction?: string
+  implementation?: string
+  executable?: string
+  implementations?: string[]
+  executables?: string[]
   /**
    * Execution model — orthogonal to `role`.
    * `oneshot` (default): single invocation on demand.
@@ -72,23 +71,23 @@ export interface Profile {
    */
   kind: "oneshot" | "scheduled"
   /**
-   * Locked-toolbox palette (unified successor to a markdown agentResponsibility's `tools:`
-   * metadata). When non-empty, loadAgentResponsibilityState sets ctx.data.agentResponsibilityTools so the
-   * executor spins up the in-process kody-agentResponsibility MCP server and the agent runs
+   * Locked-toolbox palette (unified successor to a markdown capability's `tools:`
+   * metadata). When non-empty, loadCapabilityState sets ctx.data.capabilityTools so the
+   * executor spins up the in-process kody-capability MCP server and the agent runs
    * MCP-only (Bash/Read revoked unless also in claudeCode.tools). Absent →
    * normal SDK tools.
    */
-  agentResponsibilityTools?: string[]
+  capabilityTools?: string[]
   /**
-   * GitHub logins (no leading `@`) this agentResponsibility's output should mention. Rendered
-   * to `@a @b` and exposed to the prompt as {{mentions}} (and as the agentResponsibility-MCP
-   * operator mention), mirroring a markdown agentResponsibility's `mentions:` metadata.
+   * GitHub logins (no leading `@`) this capability's output should mention. Rendered
+   * to `@a @b` and exposed to the prompt as {{mentions}} (and as the capability-MCP
+   * operator mention), mirroring a markdown capability's `mentions:` metadata.
    */
   mentions?: string[]
   /** Cron expression for scheduled profiles (e.g. "0 8 * * MON"). */
   schedule?: string
   /**
-   * Task-state phase label emitted when this agentAction completes successfully.
+   * Task-state phase label emitted when this executable completes successfully.
    * Failing actions always set phase to "failed" regardless. Omitted → "idle".
    * Lets state.ts stay generic — phase semantics live on the profile.
    */
@@ -104,7 +103,7 @@ export interface Profile {
    *
    * Lifecycles exist to consolidate orchestration boilerplate (label,
    * context loading, verify, commit, comment) that recurs across many
-   * agentActions. Per-agentAction specifics still go in `scripts.preflight`
+   * executables. Per-executable specifics still go in `scripts.preflight`
    * and `scripts.postflight` — the lifecycle wraps them, it doesn't
    * replace them.
    */
@@ -120,14 +119,14 @@ export interface Profile {
   }
   outputContract?: OutputContract
   /**
-   * Declared artifacts consumed by this agentAction. The resolveArtifacts
+   * Declared artifacts consumed by this executable. The resolveArtifacts
    * preflight loads each into ctx.data.artifacts[name] from the task-state
-   * comment. If `required: true` and the artifact is absent, the agentAction
+   * comment. If `required: true` and the artifact is absent, the executable
    * fails fast.
    */
   inputArtifacts: InputArtifactSpec[]
   /**
-   * Declared artifacts produced by this agentAction. The persistArtifacts
+   * Declared artifacts produced by this executable. The persistArtifacts
    * postflight reads the named source field from ctx.data and writes an
    * Artifact entry into the task state's `artifacts` map.
    */
@@ -168,16 +167,16 @@ export interface Profile {
    * preflight runs. composePrompt prefers these over a fresh disk read so the
    * template survives working-tree churn from runFlow's branch setup — on the CI
    * runner a branch checkout can drop the tracked-but-ignore-negated
-   * `.kody/agent-actions/<name>/` dir, and reading prompt.md afterwards fails with
+   * `.kody/executables/<name>/` dir, and reading prompt.md afterwards fails with
    * ENOENT even though profile.json (read here, earlier) loaded fine.
    */
   promptTemplates?: Record<string, string>
   /**
    * Subagent markdown captured (by declared name) at load time, BEFORE any
    * task branch switch — same rationale as promptTemplates. loadSubagents
-   * prefers this snapshot so a agentResponsibility's `agents/` surviving only on the default
-   * checkout (e.g. `.kody/agent-responsibilities/<slug>/agents/` absent on a PR branch) doesn't
-   * crash a PR-targeted agentResponsibility. Populated by captureSubagentTemplates.
+   * prefers this snapshot so a capability's `agents/` surviving only on the default
+   * checkout (e.g. `.kody/capabilities/<slug>/agents/` absent on a PR branch) doesn't
+   * crash a PR-targeted capability. Populated by captureSubagentTemplates.
    */
   subagentTemplates?: Record<string, string>
 }
@@ -193,7 +192,7 @@ export interface Profile {
  *   - no match → container aborts
  */
 export interface ContainerChild {
-  /** Name of the agentAction to invoke (must resolve via the registry). */
+  /** Name of the executable to invoke (must resolve via the registry). */
   exec: string
   /**
    * Where to source the target identifier from when invoking this child.
@@ -214,7 +213,7 @@ export interface ContainerChild {
 export interface InputArtifactSpec {
   /** Artifact name (the key in state.artifacts). */
   name: string
-  /** If true, the agentAction fails when this artifact is missing from state. */
+  /** If true, the executable fails when this artifact is missing from state. */
   required?: boolean
 }
 
@@ -295,7 +294,7 @@ export interface ClaudeCodeSpec {
   /**
    * Opt-in: expose an in-process `submit_state` tool the agent calls to
    * persist its next state, instead of relying on a trailing fenced
-   * `kody-job-next-state` block it must remember to emit. Used by agent-responsibility-tick.
+   * `kody-job-next-state` block it must remember to emit. Used by capability-tick.
    * The fenced block stays supported as a fallback. Default false.
    */
   enableSubmitTool?: boolean
@@ -305,7 +304,7 @@ export interface ClaudeCodeSpec {
    * first attempt). Set to 0 or omit to use the default.
    */
   verifyAttempts?: number | null
-  /** SDK built-in tools this agentAction is allowed to use (capability pack). */
+  /** SDK built-in tools this executable is allowed to use (capability pack). */
   tools: string[]
   /**
    * Names of bundled hook configs to load (from src/plugins/hooks/<name>.json).
@@ -353,7 +352,7 @@ export interface ScriptEntry {
    */
   script?: string
   /**
-   * Filename of a shell script colocated with the agentAction
+   * Filename of a shell script colocated with the executable
    * (e.g. "apply-prefer.sh"). Resolved relative to the profile's
    * directory. Invoked via `bash <path> <with-args>` with ctx.args
    * exposed as env vars (KODY_ARG_<UPPER_NAME>=<value>). A stdout
@@ -472,8 +471,8 @@ export interface Context {
      */
     nextDispatch?: {
       action?: string
-      agentResponsibility?: string
-      agentAction?: string
+      capability?: string
+      executable?: string
       cliArgs: Record<string, unknown>
       saveReport?: boolean
     }
@@ -482,8 +481,8 @@ export interface Context {
     /** Where to return after nextJob succeeds. Used by task-jobs to keep draining pending work. */
     afterNextJob?: {
       action?: string
-      agentResponsibility?: string
-      agentAction?: string
+      capability?: string
+      executable?: string
       cliArgs: Record<string, unknown>
       saveReport?: boolean
     }
@@ -518,8 +517,8 @@ 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 an agentResponsibility/action capability
-// contract. The agentAction is only the selected implementation detail, never a
+// was triggered. It must reference an capability/action capability
+// contract. The executable is only the selected implementation detail, never a
 // standalone request.
 // Task state stores this durable job separately from individual run attempts.
 // Two flavors:
@@ -527,18 +526,18 @@ export type AnyScript = PreflightScript | PostflightScript
 //   - "scheduled" — fired on `schedule` (cron) by the tick path
 //
 // `runJob` (src/job.ts) lowers a Job onto the private executor after resolving
-// the agentResponsibility, and seeds both stable job metadata and per-run metadata.
+// the capability, and seeds both stable job metadata and per-run metadata.
 // ────────────────────────────────────────────────────────────────────────────
 
 export type JobFlavor = "instant" | "scheduled"
 
 export interface Job {
-  /** Public action the user/operator invoked. Mirrors the agentResponsibility action. */
+  /** Public action the user/operator invoked. Mirrors the capability action. */
   action?: string
-  /** How: implementation profile selected by the agentResponsibility. Not valid by itself. */
-  agentAction?: string
-  /** Why (referenced): a agentResponsibility slug whose intent drives the run. */
-  agentResponsibility?: string
+  /** How: implementation profile selected by the capability. Not valid by itself. */
+  executable?: string
+  /** Why (referenced): a capability slug whose intent drives the run. */
+  capability?: string
   /** Why (inline): free-text intent, e.g. an `@kody` comment body. Untrusted —
    *  fenced where it enters a prompt, not here. */
   why?: string
@@ -548,7 +547,7 @@ export interface Job {
   schedule?: string
   /** The issue/PR number this job acts on, when applicable. */
   target?: number
-  /** Args passed through to the agentAction (mirrors DispatchResult.cliArgs). */
+  /** Args passed through to the executable (mirrors DispatchResult.cliArgs). */
   cliArgs: Record<string, unknown>
   /** Run once now ("instant") or on the schedule ("scheduled"). */
   flavor: JobFlavor

package/dist/plugins/hooks/block-write.json

@@ -7,7 +7,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node -e 'process.stderr.write(\"kody read-only mode: this agentAction does not modify files; do not call Write/Edit/NotebookEdit\\n\");process.exit(2)'"
+            "command": "node -e 'process.stderr.write(\"kody read-only mode: this executable does not modify files; do not call Write/Edit/NotebookEdit\\n\");process.exit(2)'"
           }
         ]
       }

package/kody.config.schema.json

@@ -84,9 +84,9 @@
           "enum": ["off", "low", "medium", "high"],
           "description": "Default thinking effort for the Claude Agent SDK. Maps to maxThinkingTokens. 'off' (default) skips the thinking block entirely — no reasoning preamble, no extra tokens. 'low'/'medium'/'high' enable extended thinking with budgets 2_048/10_000/32_000. Overridable per-session via the REASONING_EFFORT env var or the dashboard's chat-level thinking dropdown."
         },
-        "perAgentAction": {
+        "perExecutable": {
           "type": "object",
-          "description": "Optional provider/model override by agentAction name.",
+          "description": "Optional provider/model override by executable name.",
           "additionalProperties": {
             "type": "string",
             "pattern": "^[^/]+/.+$"
@@ -120,22 +120,22 @@
         }
       }
     },
-    "defaultAgentAction": {
+    "defaultExecutable": {
       "type": "string",
-      "description": "AgentAction used for bare @kody comments on issues.",
+      "description": "Executable used for bare @kody comments on issues.",
       "default": "run"
     },
-    "defaultPrAgentAction": {
+    "defaultPrExecutable": {
       "type": "string",
-      "description": "Optional agentAction used for bare @kody comments on PRs. Leave unset to require explicit PR commands."
+      "description": "Optional executable used for bare @kody comments on PRs. Leave unset to require explicit PR commands."
     },
     "onPullRequest": {
       "type": "string",
-      "description": "Optional agentAction to run on pull_request opened, synchronize, or reopened events."
+      "description": "Optional executable to run on pull_request opened, synchronize, or reopened events."
     },
     "aliases": {
       "type": "object",
-      "description": "Comment subcommand aliases, mapping typed word to agentAction name.",
+      "description": "Comment subcommand aliases, mapping typed word to executable name.",
       "additionalProperties": {
         "type": "string"
       }

package/package.json

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

package/dist/agent-responsibilities/agent-factory/agent-responsibility.md

@@ -1,10 +0,0 @@
-# Agent Factory
-
-## Purpose
-
-Create or assemble Kody agency model definitions from an operator request.
-
-## Instructions
-
-Use the `agent-factory` agentAction for the implementation details.
-The agentResponsibility owns the public action name and review boundary; the agentAction owns model reasoning and state-repo PR creation.

package/dist/agent-responsibilities/run/agent-responsibility.md

@@ -1,10 +0,0 @@
-# Run
-
-## Purpose
-
-Implement a GitHub issue end-to-end.
-
-## Instructions
-
-Use the `run` agentAction for the implementation details.
-The agentResponsibility owns the public action name and the reason this action exists; the agentAction owns the method.