@kuznai/inception-engine 0.21.0 → 0.23.0

package/README.md

@@ -50,9 +50,11 @@ Before executing, the deploy command runs preflight analysis on instruction file
 | Skills (SKILL.md) | All agents via manifest and CLI | All agents |
 | File write | All agents via manifest and CLI | All agents |
 | Config patch (JSON merge) | All agents via manifest and CLI | All agents |
-| MCP Servers | claude-code (`scope: "global"` → `~/.claude.json`; `scope: "repo"` → `{repo}/.claude/mcp.json`; `scope: "workspace"` → `{workspace}/.claude/mcp.json`), gemini-cli, codex, antigravity, opencode; github-copilot with `scope: "repo"` deploys to `{repo}/.vscode/mcp.json` and `scope: "workspace"` deploys to `{workspace}/.vscode/mcp.json`; github-copilot with `scope: "global"` (default) is unsupported and warns | claude-code, gemini-cli, codex, antigravity, opencode, github-copilot |
-| Global/Repo/Workspace Rules Files | `scope: "global"` and `scope: "repo"` are supported on the implemented agent surfaces; `scope: "workspace"` is supported for `claude-code`, `codex`, and `gemini-cli`; `github-copilot` reads Claude-native rules via `claude-code` and has no separate rules deployment target | All supported agents |
+| MCP Servers | claude-code (`scope: "global"` → `~/.claude.json`; `scope: "repo"` → `{repo}/.claude/mcp.json`; `scope: "workspace"` → `{workspace}/.claude/mcp.json`), gemini-cli, codex, antigravity (`scope: "global"` → `~/.gemini/antigravity/mcp_config.json`; `scope: "repo"` → `{repo}/.agents/rules/{name}.md`), opencode; github-copilot with `scope: "repo"` deploys to `{repo}/.vscode/mcp.json` and `scope: "workspace"` deploys to `{workspace}/.vscode/mcp.json`; github-copilot with `scope: "global"` (default) is unsupported and warns | claude-code, gemini-cli, codex, antigravity, opencode, github-copilot |
+| Global/Repo/Workspace Rules Files | `scope: "global"` and `scope: "repo"` are supported on the implemented agent surfaces; `scope: "workspace"` is supported for `claude-code`, `codex`, and `gemini-cli`; `github-copilot` reads Claude-native rules via `claude-code` (shared-via) and also supports native `scope: "copilot-repo"` (`{repo}/.github/copilot-instructions.md`) and `scope: "copilot-scoped"` (`{repo}/.github/instructions/{name}.instructions.md`) | All supported agents |
 | Permissions / Approval Config | claude-code (`~/.claude/settings.json`), codex (`~/.codex/config.toml`), opencode (`~/.config/opencode/opencode.json` on POSIX, `%APPDATA%\\opencode\\opencode.json` on Windows); other agents are warned and skipped | claude-code, codex, opencode |
+| Execution Hooks | claude-code (`~/.claude/settings.json`), github-copilot (`planned`); other agents are warned and skipped | claude-code |
+| Execution / Safety Config | gemini-cli (`~/.gemini/settings.json`); other agents are warned and skipped | gemini-cli |
 | Agent Definitions | claude-code (`{repo}/.claude/agents/{name}.md`), gemini-cli (`{repo}/.gemini/agents/{name}.md` or `.toml`, plus `scope: "global"` to `~/.gemini/agents/{name}.md` or `.toml`), antigravity (`{repo}/.agents/rules/{name}.md`), opencode (`{repo}/.opencode/agents/{name}.md`, plus `scope: "global"` to the user config dir), github-copilot (`{repo}/.github/copilot/agents/{name}.md`, with migration from legacy `.github/agents/{name}.agent.md`); codex is warned and skipped | All supported agents |
 | `init` manifest generation | Scans `SKILL.md` directories (`skills`), `.md` files with Claude-first agent mapping (`agentRules`), `mcp-servers.json` (`mcpServers`), and agent-definition Markdown files (`agentDefinitions`); shared surfaces default to the primary deploy target instead of shared riders; emits hints for `files/` and `configs/` directories | N/A |
 | Instruction preflight analysis | Emits capability warnings for implementation-only, planned, unsupported, and shared-through surfaces used by the manifest; emits `precedence` warnings when an agent has multiple `agentRules` scopes active simultaneously or the same source file is deployed to multiple scopes; emits `budget` warnings when `agentRules` or `agentDefinitions` source files exceed 50 KB; emits GitHub Copilot enterprise-policy warnings when local configuration may be overridden; emits a `config-authority` warning when Gemini CLI's `settings.json` contains an `instructionFilename` override that differs from the deploy target | N/A |
@@ -135,6 +137,36 @@ Create an `inception.json` file at the root of your skills directory:
       "path": "agents/code-reviewer.md",
       "agents": ["claude-code", "opencode", "github-copilot"]
     }
+  ],
+  "hooks": [
+    {
+      "name": "pre-exec-check",
+      "agents": ["claude-code"],
+      "config": {
+        "hooks": {
+          "PreToolUse": [
+            {
+              "matcher": "Bash",
+              "hooks": [{ "type": "command", "command": "scripts/check-env.sh" }]
+            }
+          ],
+          "Stop": [
+            {
+              "hooks": [{ "type": "command", "command": "scripts/notify.sh" }]
+            }
+          ]
+        }
+      }
+    }
+  ],
+  "executionConfigs": [
+    {
+      "name": "gemini-safety",
+      "agents": ["gemini-cli"],
+      "config": {
+        "safeMode": true
+      }
+    }
   ]
 }
 ```
@@ -166,17 +198,18 @@ Each **mcpServer** entry registers an MCP server into the agent's config file by
 - **name** - Unique identifier (same format as skill names); used as the server's key in the config
 - **agents** - Array of agent IDs to register this server with
 - **config** - Raw server descriptor object. For the currently supported JSON-backed adapters, inception-engine requires at least one non-empty `command` or `url` field, validates `args` as an array of strings when present, and validates `env` as a string-to-string object when present. Additional keys are passed through verbatim.
-- **scope** - `"global"` (default), `"repo"`, or `"workspace"`. For most agents this field is ignored (they have only a single user-level config path). For `github-copilot`, `scope` selects the target file:
+- **scope** - `"global"` (default), `"repo"`, `"workspace"`, or `"devcontainer"`. For most agents this field is ignored (they have only a single user-level config path). For `github-copilot`, `scope` selects the target file:
   - `"global"` — unsupported; emits a warning and is skipped
   - `"repo"` — deploys to `{repo}/.vscode/mcp.json` under the `servers` key
   - `"workspace"` — deploys to `{workspace}/.vscode/mcp.json` under the `servers` key
+  - `"devcontainer"` — deploys to `{repo}/.devcontainer/devcontainer.json` under the `customizations.vscode.mcp.servers` key
 
   GitHub Copilot's `.vscode/mcp.json` uses `servers` (not `mcpServers`) as the top-level key and optionally accepts a `type` field (`"stdio"` | `"sse"` | `"http"`) in the server descriptor, which is passed through verbatim.
 
 MCP server registration is supported for all agents. Inception-engine automatically uses the correct adapter for each agent's configuration schema:
-- **JSON (Merge Patch)**: `claude-code` (`~/.claude.json` for `scope: "global"`; `{repo}/.claude/mcp.json` for `scope: "repo"`; `{workspace}/.claude/mcp.json` for `scope: "workspace"`), `gemini-cli` (`~/.gemini/settings.json`), `opencode` (`~/.config/opencode/opencode.json` using the custom `"mcp"` key), and `github-copilot` (`{repo}/.vscode/mcp.json` or `{workspace}/.vscode/mcp.json` using the `"servers"` key).
+- **JSON (Merge Patch)**: `claude-code` (`~/.claude.json` for `scope: "global"`; `{repo}/.claude/mcp.json` for `scope: "repo"`; `{workspace}/.claude/mcp.json` for `scope: "workspace"`), `gemini-cli` (`~/.gemini/settings.json`), `antigravity` (`~/.gemini/antigravity/mcp_config.json` for `scope: "global"`), `opencode` (`~/.config/opencode/opencode.json` using the custom `"mcp"` key), and `github-copilot` (`{repo}/.vscode/mcp.json`, `{workspace}/.vscode/mcp.json`, or `{repo}/.devcontainer/devcontainer.json`).
 - **TOML (Patch)**: `codex` (`~/.codex/config.toml`).
-- **Markdown Frontmatter (Emit)**: `antigravity` (repo-local `.agents/rules/{name}.md` files).
+- **Markdown Frontmatter (Emit)**: `antigravity` (`{repo}/.agents/rules/{name}.md` for `scope: "repo"`).
 
 For Markdown frontmatter targets, inception-engine now records patch-level provenance for the emitted frontmatter block. Deploy merges only the owned frontmatter keys, preserves unrelated frontmatter and Markdown body content, and `revert` removes only the engine-owned keys instead of deleting the whole file unless inception-engine originally created an otherwise-empty file.
 
@@ -189,10 +222,12 @@ Each **agentRules** entry deploys a Markdown instruction file to an agent's supp
 - **name** - Unique identifier (same format as skill names)
 - **path** - Relative path to the source Markdown file within the repo; supported rules adapters require a `.md` or `.markdown` source path
 - **agents** - Array of agent IDs to deploy this file to
-- **scope** - `"global"` (default), `"repo"`, or `"workspace"`. Controls which instruction surface is targeted:
+- **scope** - `"global"` (default), `"repo"`, `"workspace"`, `"copilot-repo"`, or `"copilot-scoped"`. Controls which instruction surface is targeted:
   - `"global"` — deploys to the agent's home-directory instruction file when that surface is supported (e.g., `~/.claude/CLAUDE.md` for `claude-code`)
   - `"repo"` — deploys to the project-root instruction file inside the deployed repository when that surface is supported (e.g., `{repo}/CLAUDE.md` for `claude-code`)
   - `"workspace"` — deploys to the workspace-root instruction file when an agent exposes one (e.g., `{workspace}/CLAUDE.md` for `claude-code`); when unsupported, deployment is skipped with a warning
+  - `"copilot-repo"` — deploys to GitHub Copilot's native repo-level instruction file at `{repo}/.github/copilot-instructions.md` (`github-copilot` only; other agents are warned and skipped)
+  - `"copilot-scoped"` — deploys to `{repo}/.github/instructions/{name}.instructions.md` where `{name}` is the manifest entry name (`github-copilot` only; other agents are warned and skipped)
 
 Instruction rule deployment is supported for implemented global, repo, and workspace surfaces. The target path depends on the agent and the `scope`:
 
@@ -205,7 +240,13 @@ Instruction rule deployment is supported for implemented global, repo, and works
 | `opencode` | `~/.config/opencode/AGENTS.md` | `{repo}/AGENTS.md` | unsupported; warns and skips |
 | `github-copilot` | unsupported / Claude-first | deploy via `claude-code` | unsupported; deploy via `claude-code` with `scope: "workspace"` |
 
-For `antigravity`, `agentRules` now targets the shared GEMINI.md surface (`~/.gemini/GEMINI.md` for `global`, `{repo}/GEMINI.md` for `repo`) — the same paths used by `gemini-cli`. When both agents appear in the same entry, deduplication ensures only one write action is emitted. `workspace` scope is not supported and is skipped with a warning. For `github-copilot`, no separate deployment is needed — target it via the `claude-code` agentRules entry and it reaches Copilot automatically. Revert removes the deployed rules file.
+GitHub Copilot also exposes two native instruction surfaces via dedicated scope values:
+
+| Agent | `scope: "copilot-repo"` | `scope: "copilot-scoped"` |
+|---|---|---|
+| `github-copilot` | `{repo}/.github/copilot-instructions.md` | `{repo}/.github/instructions/{name}.instructions.md` |
+
+For `antigravity`, `agentRules` now targets the shared GEMINI.md surface (`~/.gemini/GEMINI.md` for `global`, `{repo}/GEMINI.md` for `repo`) — the same paths used by `gemini-cli`. When both agents appear in the same entry, deduplication ensures only one write action is emitted. `workspace` scope is not supported and is skipped with a warning. For `github-copilot`, the Claude-first path (targeting via `claude-code` agentRules) remains the recommended approach for shared rules; the `copilot-repo` and `copilot-scoped` scopes are for Copilot-specific instructions that should not be shared with other agents. When both are present, preflight emits a precedence warning. Revert removes the deployed rules file.
 
 Each **permissions** entry deploys execution and safety-oriented configuration to an agent's permission or approval surface:
 
@@ -248,6 +289,40 @@ Valid `approval_policy` values are `"auto"`, `"manual"`, `"suggest"`, and `"on-f
 
 Revert restores the previous config values using the undo patch recorded at deploy time.
 
+Each **hooks** entry deploys lifecycle-binding configurations to an agent's execution hook surface:
+
+- **name** - Unique identifier (same format as skill names)
+- **agents** - Array of agent IDs to deploy this entry to
+- **config** - Hook configuration payload; shape is validated per agent (see below)
+
+Hook deployment is currently supported for `claude-code`. For `github-copilot`, it is marked as `planned`. Other agents emit a warning and are skipped.
+
+For `claude-code`, the config is merged into `~/.claude/settings.json`. Only the `hooks` key is accepted. Event names follow Claude Code's settings.json hooks surface (e.g. `PreToolUse`, `PostToolUse`, `Notification`, `Stop`, `SubagentStop`). Each event maps to an array of hook matchers; each matcher has an optional `matcher` string and a required `hooks` array of `{ type: "command", command: string }` objects:
+
+```json
+{
+  "name": "pre-exec-check",
+  "agents": ["claude-code"],
+  "config": {
+    "hooks": {
+      "PreToolUse": [
+        {
+          "matcher": "Bash",
+          "hooks": [{ "type": "command", "command": "scripts/check-env.sh" }]
+        }
+      ],
+      "Stop": [
+        {
+          "hooks": [{ "type": "command", "command": "scripts/notify.sh" }]
+        }
+      ]
+    }
+  }
+}
+```
+
+Revert restores the previous config values using the undo patch recorded at deploy time.
+
 Each **agentDefinitions** entry deploys an agent-definition file to the agent-definition directory of each targeted agent. `scope: "repo"` is the default, and some agents also support `scope: "global"`:
 
 - **name** - Unique identifier (same format as skill names); used as the definition filename
@@ -303,7 +378,7 @@ Current `init` behavior:
 - Applies either the `--agents` list or all currently known agent IDs
 - Refuses to overwrite an existing `inception.json` unless `--force` is provided
 - Supports `--plan` so you can inspect the generated manifest before writing it
-- Discovers agent-rules Markdown files in the root and conventional subdirectories (`rules/`, `instructions/`, `.github/`), mapping them to agents using Claude-first portability conventions: `copilot-instructions.md` maps to `claude-code` (Copilot reads `CLAUDE.md` natively), and the fallback for unrecognized files excludes unsupported agents plus shared-surface riders that should default to their primary deploy target
+- Discovers agent-rules Markdown files in the root and conventional subdirectories (`rules/`, `instructions/`, `.github/`), mapping them to agents using Claude-first portability conventions: `copilot-instructions.md` found outside `.github/` maps to `claude-code` (Copilot reads `CLAUDE.md` natively), `.github/copilot-instructions.md` maps to `github-copilot` with `scope: "copilot-repo"`, and `*.instructions.md` files in `.github/instructions/` map to `github-copilot` with `scope: "copilot-scoped"`; the fallback for unrecognized files excludes unsupported agents plus shared-surface riders that should default to their primary deploy target
 - Reads `mcp-servers.json` from the repo root (if present) and generates `mcpServers` entries; invalid entries are warned and skipped
 - Reads `files-manifest.json` from the repo root (if present) and generates `files` entries; invalid entries are warned and skipped
 - Reads `configs-manifest.json` from the repo root (if present) and generates `configs` entries; invalid entries are warned and skipped

package/dist/src/config/agents.js

@@ -18,6 +18,7 @@ export const AGENT_REGISTRY = [
             mcpConfig: "documented",
             agentRules: "documented",
             permissions: "documented",
+            hooks: "documented",
             agentDefinitions: "documented",
         },
         mcpSupport: {
@@ -68,6 +69,14 @@ export const AGENT_REGISTRY = [
                 windows: ["{home}", ".claude", "settings.json"],
             },
         },
+        hooksSupport: {
+            status: "supported",
+            schemaLabel: "JSON hooks config",
+            path: {
+                posix: ["{home}", ".claude", "settings.json"],
+                windows: ["{home}", ".claude", "settings.json"],
+            },
+        },
         agentDefinitionsRepoSupport: {
             status: "supported",
             schemaLabel: "repo-local agent definition Markdown file",
@@ -103,6 +112,7 @@ export const AGENT_REGISTRY = [
             detectBinary: "documented",
             agentRules: "documented",
             permissions: "documented",
+            hooks: "provisional",
         },
         mcpSupport: {
             status: "supported",
@@ -136,6 +146,11 @@ export const AGENT_REGISTRY = [
                 windows: ["{home}", ".codex", "config.toml"],
             },
         },
+        hooksSupport: {
+            status: "unsupported",
+            schemaLabel: "global hooks surface",
+            reason: "OpenAI Codex does not expose a documented lifecycle-hook config surface in config.toml",
+        },
         agentDefinitionsRepoSupport: {
             status: "unsupported",
             schemaLabel: "dedicated agent definition directory",
@@ -168,7 +183,9 @@ export const AGENT_REGISTRY = [
             detectBinary: "documented",
             mcpConfig: "documented",
             agentRules: "documented",
+            hooks: "provisional",
             agentDefinitions: "documented",
+            executionConfig: "provisional",
         },
         mcpSupport: {
             status: "supported",
@@ -202,6 +219,12 @@ export const AGENT_REGISTRY = [
             schemaLabel: "global permissions surface",
             reason: "Gemini CLI does not expose a documented global per-user permission or approval config surface",
         },
+        hooksSupport: {
+            status: "planned",
+            schemaLabel: "global hooks surface",
+            plannedSurface: "settings.json hooks field",
+            reason: "Gemini CLI execution hooks are emerging and not yet settled",
+        },
         agentDefinitionsSupport: {
             status: "supported",
             schemaLabel: "global agent definition Markdown file",
@@ -234,6 +257,14 @@ export const AGENT_REGISTRY = [
                 windows: ["{repo}", ".gemini", "agents", "{name}.toml"],
             },
         },
+        executionConfigSupport: {
+            status: "supported",
+            schemaLabel: "Settings execution config",
+            path: {
+                posix: ["{home}", ".gemini", "settings.json"],
+                windows: ["{home}", ".gemini", "settings.json"],
+            },
+        },
         agentRulesWorkspaceSupport: {
             status: "supported",
             schemaLabel: "workspace-local GEMINI.md",
@@ -263,6 +294,14 @@ export const AGENT_REGISTRY = [
             agentDefinitions: "documented",
         },
         mcpSupport: {
+            status: "supported",
+            schemaLabel: "global mcp_config.json",
+            path: {
+                posix: ["{home}", ".gemini", "antigravity", "mcp_config.json"],
+                windows: ["{home}", ".gemini", "antigravity", "mcp_config.json"],
+            },
+        },
+        mcpRepoSupport: {
             status: "supported",
             schemaLabel: "repo-local frontmatter-emit MCP rules",
             path: {
@@ -296,6 +335,11 @@ export const AGENT_REGISTRY = [
             schemaLabel: "global permissions surface",
             reason: "Antigravity does not expose a documented global per-user permission or approval config surface",
         },
+        hooksSupport: {
+            status: "unsupported",
+            schemaLabel: "global hooks surface",
+            reason: "Antigravity does not expose a documented global per-user hook config surface",
+        },
         agentDefinitionsRepoSupport: {
             status: "supported",
             schemaLabel: "repo-local agent definition Markdown file",
@@ -330,6 +374,7 @@ export const AGENT_REGISTRY = [
             agentRules: "documented",
             agentDefinitions: "documented",
             permissions: "documented",
+            hooks: "provisional",
         },
         mcpSupport: {
             status: "supported",
@@ -364,6 +409,11 @@ export const AGENT_REGISTRY = [
                 windows: ["{appdata}", "opencode", "opencode.json"],
             },
         },
+        hooksSupport: {
+            status: "unsupported",
+            schemaLabel: "global hooks surface",
+            reason: "OpenCode does not expose a documented lifecycle-hook surface",
+        },
         agentDefinitionsSupport: {
             status: "supported",
             schemaLabel: "global agent definition Markdown file",
@@ -402,8 +452,10 @@ export const AGENT_REGISTRY = [
         provenance: {
             detectPaths: "documented",
             detectBinary: "documented",
+            agentRules: "documented",
             agentDefinitions: "documented",
             mcpConfig: "documented",
+            hooks: "provisional",
         },
         mcpSupport: {
             status: "unsupported",
@@ -472,17 +524,55 @@ export const AGENT_REGISTRY = [
                 windows: ["{workspace}", "CLAUDE.md"],
             },
         },
+        // GitHub Copilot native repo-level instruction file. Not shared via
+        // CLAUDE.md; this is Copilot's own .github/copilot-instructions.md surface
+        // deployed directly without the shared-via deduplication path.
+        agentRulesCopilotRepoSupport: {
+            status: "supported",
+            surfaceKind: { kind: "agent-specific" },
+            schemaLabel: "repo-local .github/copilot-instructions.md",
+            path: {
+                posix: ["{repo}", ".github", "copilot-instructions.md"],
+                windows: ["{repo}", ".github", "copilot-instructions.md"],
+            },
+        },
+        // GitHub Copilot scoped instruction files. Each entry deploys to
+        // .github/instructions/{name}.instructions.md where {name} comes from
+        // the manifest entry name field.
+        agentRulesCopilotScopedSupport: {
+            status: "supported",
+            surfaceKind: { kind: "agent-specific" },
+            schemaLabel: "scoped .github/instructions/{name}.instructions.md",
+            path: {
+                posix: ["{repo}", ".github", "instructions", "{name}.instructions.md"],
+                windows: [
+                    "{repo}",
+                    ".github",
+                    "instructions",
+                    "{name}.instructions.md",
+                ],
+            },
+        },
         mcpDevcontainerSupport: {
-            status: "planned",
+            status: "supported",
             schemaLabel: "devcontainer.json MCP surface",
-            plannedSurface: "devcontainer.json customizations.vscode.mcp.servers",
-            reason: 'devcontainer.json MCP support is planned — use scope: "repo" or scope: "workspace" to target .vscode/mcp.json in the meantime',
+            mcpPatchKey: "customizations.vscode.mcp.servers",
+            path: {
+                posix: ["{repo}", ".devcontainer", "devcontainer.json"],
+                windows: ["{repo}", ".devcontainer", "devcontainer.json"],
+            },
         },
         permissionsSupport: {
             status: "unsupported",
             schemaLabel: "global permissions surface",
             reason: "GitHub Copilot permissions are managed via organization policy, not a deployable per-user config surface",
         },
+        hooksSupport: {
+            status: "planned",
+            schemaLabel: "binary execution hooks",
+            plannedSurface: "agent frontmatter pre_exec/post_exec hooks",
+            reason: "GitHub Copilot binary hook support is planned and requires further validation of the stdin/stdout contract",
+        },
         agentDefinitionsRepoSupport: {
             status: "supported",
             schemaLabel: "repo-local agent definition Markdown file",
@@ -504,14 +594,7 @@ export const AGENT_REGISTRY = [
             },
         },
         policyNote: "Organization policies may override locally deployed configuration. Verify with your GitHub org admin if deployed skills or rules are not active.",
-        unsupportedSurfaces: [
-            {
-                status: "planned",
-                schemaLabel: "devcontainer.json MCP surface",
-                plannedSurface: "devcontainer.json customizations.vscode.mcp.servers",
-                reason: 'devcontainer.json MCP support is planned — use scope: "repo" or scope: "workspace" to target .vscode/mcp.json in the meantime',
-            },
-        ],
+        unsupportedSurfaces: [],
         instructionFrontmatterRequired: true,
         enterprisePolicyDetection: true,
     },

package/dist/src/core/adapters/execution-config.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionConfigEntry } from "../../schemas/manifest.ts";
+import type { AgentId, ConfigPatchDeployAction, ConfigPatchRevertAction, PlanWarning } from "../../types.ts";
+export interface ExecutionConfigAdapterResult {
+    actions: ConfigPatchDeployAction[];
+    warnings: PlanWarning[];
+}
+/**
+ * Compiles deploy actions for executionConfigs manifest entries.
+ *
+ * Execution configuration settings (like Gemini CLI's safeMode) are patched
+ * directly into the agent's primary settings file using config-patch actions.
+ */
+export declare function compileExecutionConfigActions(entry: ExecutionConfigEntry, detectedAgents: AgentId[], home: string): ExecutionConfigAdapterResult;
+export declare function compileExecutionConfigReverts(entry: ExecutionConfigEntry, agentFilter: AgentId[] | null, home: string): ConfigPatchRevertAction[];

package/dist/src/core/adapters/execution-config.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import { AGENT_REGISTRY_BY_ID } from "../../config/agents.js";
+import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
+/**
+ * Compiles deploy actions for executionConfigs manifest entries.
+ *
+ * Execution configuration settings (like Gemini CLI's safeMode) are patched
+ * directly into the agent's primary settings file using config-patch actions.
+ */
+export function compileExecutionConfigActions(entry, detectedAgents, home) {
+    const actions = [];
+    const warnings = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (!detectedAgents.includes(agentId))
+            continue;
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        if (!agent?.executionConfigSupport ||
+            agent.executionConfigSupport.status !== "supported") {
+            warnings.push({
+                kind: "confidence",
+                message: `Agent "${agentId}" does not support modeled execution configuration surfaces — skipping "${entry.name}"`,
+            });
+            continue;
+        }
+        const rawTarget = resolvePlaceholders(agent.executionConfigSupport.path[platform], entry.name, home);
+        const target = path.resolve(rawTarget);
+        actions.push({
+            kind: "config-patch",
+            skill: entry.name,
+            agent: agentId,
+            target,
+            patch: entry.config,
+            confidence: "provisional",
+        });
+    }
+    return { actions, warnings };
+}
+export function compileExecutionConfigReverts(entry, agentFilter, home) {
+    const actions = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (agentFilter && !agentFilter.includes(agentId))
+            continue;
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        if (!agent?.executionConfigSupport ||
+            agent.executionConfigSupport.status !== "supported") {
+            continue;
+        }
+        const rawTarget = resolvePlaceholders(agent.executionConfigSupport.path[platform], entry.name, home);
+        const target = path.resolve(rawTarget);
+        actions.push({
+            kind: "config-patch",
+            skill: entry.name,
+            agent: agentId,
+            target,
+        });
+    }
+    return actions;
+}

package/dist/src/core/adapters/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { HookEntry } from "../../schemas/manifest.ts";
+import type { AgentId, ConfigPatchDeployAction, ConfigPatchRevertAction, PlanWarning, TomlPatchDeployAction, TomlPatchRevertAction } from "../../types.ts";
+export interface HooksAdapterResult {
+    actions: Array<ConfigPatchDeployAction | TomlPatchDeployAction>;
+    warnings: PlanWarning[];
+}
+export declare function compileHookActions(entry: HookEntry, detectedAgents: AgentId[], home: string): HooksAdapterResult;
+export declare function compileHookReverts(entry: HookEntry, agentFilter: AgentId[] | null, home: string): Array<ConfigPatchRevertAction | TomlPatchRevertAction>;

package/dist/src/core/adapters/hooks.js

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { planCapabilityForDeploy, resolveCapabilitySurface, } from "../capabilities.js";
+import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
+import { validateHookConfigShape } from "../validation.js";
+function isTomlTarget(targetPath) {
+    return path.extname(targetPath).toLowerCase() === ".toml";
+}
+export function compileHookActions(entry, detectedAgents, home) {
+    const actions = [];
+    const warnings = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (!detectedAgents.includes(agentId))
+            continue;
+        const plan = planCapabilityForDeploy({
+            agentId,
+            capability: "hooks",
+            entryName: entry.name,
+            targetAgentIds: entry.agents,
+        });
+        if (plan.outcome === "warn") {
+            warnings.push(plan.warning);
+            continue;
+        }
+        if (plan.outcome === "native" || plan.outcome === "redundant")
+            continue;
+        const support = resolveCapabilitySurface(agentId, "hooks").support;
+        if (!support)
+            continue;
+        validateHookConfigShape(entry.config, entry.name, agentId);
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home);
+        const resolvedTarget = path.resolve(rawTarget);
+        const confidence = plan.confidence ?? "provisional";
+        if (isTomlTarget(resolvedTarget)) {
+            actions.push({
+                kind: "toml-patch",
+                skill: entry.name,
+                agent: agentId,
+                target: resolvedTarget,
+                config: entry.config,
+                confidence,
+            });
+        }
+        else {
+            actions.push({
+                kind: "config-patch",
+                skill: entry.name,
+                agent: agentId,
+                target: resolvedTarget,
+                patch: entry.config,
+                confidence,
+            });
+        }
+    }
+    return { actions, warnings };
+}
+export function compileHookReverts(entry, agentFilter, home) {
+    const actions = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (agentFilter && !agentFilter.includes(agentId))
+            continue;
+        const support = resolveCapabilitySurface(agentId, "hooks").support;
+        if (!support)
+            continue;
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home);
+        const target = path.resolve(rawTarget);
+        if (isTomlTarget(target)) {
+            actions.push({
+                kind: "toml-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+        else {
+            actions.push({
+                kind: "config-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+    }
+    return actions;
+}

package/dist/src/core/adapters/index.d.ts

@@ -1,13 +1,15 @@
-import type { AgentDefinitionEntry, AgentRuleEntry, McpServerEntry, PermissionsEntry } from "../../schemas/manifest.ts";
+import type { AgentDefinitionEntry, AgentRuleEntry, ExecutionConfigEntry, HookEntry, McpServerEntry, PermissionsEntry } from "../../schemas/manifest.ts";
 import type { AgentId, ConfigPatchDeployAction, FileWriteDeployAction, FrontmatterEmitDeployAction, PlanWarning, TomlPatchDeployAction } from "../../types.ts";
 import { compileAgentDefinitionReverts } from "./agent-definitions.ts";
+import { compileExecutionConfigReverts } from "./execution-config.ts";
+import { compileHookReverts } from "./hooks.ts";
 import { compileMcpServerReverts } from "./mcp.ts";
 import { compilePermissionsReverts } from "./permissions.ts";
 import { compileAgentRuleReverts } from "./rules.ts";
-export { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, };
+export { compileAgentDefinitionReverts, compileAgentRuleReverts, compileExecutionConfigReverts, compileHookReverts, compileMcpServerReverts, compilePermissionsReverts, };
 export type AdapterAction = ConfigPatchDeployAction | FileWriteDeployAction | TomlPatchDeployAction | FrontmatterEmitDeployAction;
 export interface AdapterResult {
     actions: AdapterAction[];
     warnings: PlanWarning[];
 }
-export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], permissions: PermissionsEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string, agentDefinitions?: AgentDefinitionEntry[], workspace?: string): Promise<AdapterResult>;
+export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], permissions: PermissionsEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string, agentDefinitions?: AgentDefinitionEntry[], workspace?: string, hooks?: HookEntry[], executionConfigs?: ExecutionConfigEntry[]): Promise<AdapterResult>;

package/dist/src/core/adapters/index.js

@@ -1,8 +1,10 @@
 import { compileAgentDefinitionActions, compileAgentDefinitionReverts, } from "./agent-definitions.js";
+import { compileExecutionConfigActions, compileExecutionConfigReverts, } from "./execution-config.js";
+import { compileHookActions, compileHookReverts } from "./hooks.js";
 import { compileMcpServerActions, compileMcpServerReverts } from "./mcp.js";
 import { compilePermissionsActions, compilePermissionsReverts, } from "./permissions.js";
 import { compileAgentRuleActions, compileAgentRuleReverts } from "./rules.js";
-export { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, };
+export { compileAgentDefinitionReverts, compileAgentRuleReverts, compileExecutionConfigReverts, compileHookReverts, compileMcpServerReverts, compilePermissionsReverts, };
 async function compileAll(entries, fn) {
     const results = await Promise.all(entries.map(fn));
     return {
@@ -10,16 +12,18 @@ async function compileAll(entries, fn) {
         warnings: results.flatMap((r) => r.warnings),
     };
 }
-export async function compileAdapterActions(mcpServers, agentRules, permissions, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, agentDefinitions, workspace) {
+export async function compileAdapterActions(mcpServers, agentRules, permissions, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, agentDefinitions, workspace, hooks = [], executionConfigs = []) {
     const actions = [];
     const warnings = [];
-    const [mcp, rules, perms, defs] = await Promise.all([
+    const [mcp, rules, perms, defs, hookResults, execResults] = await Promise.all([
         compileAll(mcpServers, (entry) => compileMcpServerActions(entry, detectedAgents, home, repo, workspace)),
         compileAll(agentRules, (entry) => compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace)),
         compileAll(permissions, (entry) => compilePermissionsActions(entry, detectedAgents, home)),
         compileAll(agentDefinitions ?? [], (entry) => compileAgentDefinitionActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace)),
+        compileAll(hooks, (entry) => compileHookActions(entry, detectedAgents, home)),
+        compileAll(executionConfigs, (entry) => compileExecutionConfigActions(entry, detectedAgents, home)),
     ]);
-    actions.push(...mcp.actions, ...rules.actions, ...perms.actions, ...defs.actions);
-    warnings.push(...mcp.warnings, ...rules.warnings, ...perms.warnings, ...defs.warnings);
+    actions.push(...mcp.actions, ...rules.actions, ...perms.actions, ...defs.actions, ...hookResults.actions, ...execResults.actions);
+    warnings.push(...mcp.warnings, ...rules.warnings, ...perms.warnings, ...defs.warnings, ...hookResults.warnings, ...execResults.warnings);
     return { actions, warnings };
 }

package/dist/src/core/adapters/mcp.js

@@ -16,6 +16,20 @@ function isMarkdownTarget(targetPath) {
     const ext = path.extname(targetPath).toLowerCase();
     return ext === ".md" || ext === ".markdown";
 }
+/**
+ * Builds a nested object from a dot-separated key path.
+ * e.g. ("a.b", {c: 1}) -> {a: {b: {c: 1}}}
+ */
+function buildNestedPatch(keyPath, leafValue) {
+    const parts = keyPath.split(".");
+    let current = {
+        [parts[parts.length - 1]]: leafValue,
+    };
+    for (let i = parts.length - 2; i >= 0; i--) {
+        current = { [parts[i]]: current };
+    }
+    return current;
+}
 function buildMcpDeployAction(entry, agentId, resolvedTarget, confidence, mcpPatchKey) {
     if (isMarkdownTarget(resolvedTarget)) {
         return {
@@ -42,7 +56,7 @@ function buildMcpDeployAction(entry, agentId, resolvedTarget, confidence, mcpPat
         skill: entry.name,
         agent: agentId,
         target: resolvedTarget,
-        patch: { [mcpPatchKey]: { [entry.name]: entry.config } },
+        patch: buildNestedPatch(mcpPatchKey, { [entry.name]: entry.config }),
         confidence,
     };
 }