@kuznai/inception-engine 0.20.0 → 0.22.0

package/dist/src/core/deploy.js

@@ -4,7 +4,9 @@ import path from "node:path";
 import { AGENT_REGISTRY, AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
+import * as frontmatterAdapter from "./adapters/frontmatter.js";
 import { compileAdapterActions } from "./adapters/index.js";
+import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { planCapabilityForDeploy } from "./capabilities.js";
 import { applyMergePatch, computeUndoPatch, isPlainObject, } from "./merge-patch.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
@@ -105,7 +107,7 @@ function checkPairAgentRuleAmbiguities(manifest, primary, rider) {
             JSON.stringify(primarySupport.path) === JSON.stringify(riderSupport.path)) {
             warnings.push({
                 kind: "ambiguity",
-                message: `Both "${primary}" and "${rider}" are listed in agentRules entry "${entry.name}". Both target the same surface — listing both is redundant but harmless; deduplication ensures only one write action is emitted.`,
+                message: `Both "${primary}" and "${rider}" are listed in agentRules entry "${entry.name}". Both target the same surface - listing both is redundant but harmless; deduplication ensures only one write action is emitted.`,
             });
         }
     }
@@ -122,7 +124,7 @@ function checkPairMcpAmbiguities(manifest, primary, rider) {
             continue;
         warnings.push({
             kind: "ambiguity",
-            message: `Both "${primary}" and "${rider}" are listed in mcpServers entry "${entry.name}". "${primary}" writes to a shared MCP surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
+            message: `Both "${primary}" and "${rider}" are listed in mcpServers entry "${entry.name}". "${primary}" writes to a shared MCP surface - verify that deploying to both does not produce conflicting MCP server behavior.`,
         });
     }
     return warnings;
@@ -134,7 +136,7 @@ function checkPairAgentDefinitionAmbiguities(manifest, primary, rider) {
             continue;
         warnings.push({
             kind: "ambiguity",
-            message: `Both "${primary}" and "${rider}" are listed in agentDefinitions entry "${entry.name}". They write to distinct surfaces — verify that this behavioral divergence is intended.`,
+            message: `Both "${primary}" and "${rider}" are listed in agentDefinitions entry "${entry.name}". They write to distinct surfaces - verify that this behavioral divergence is intended.`,
         });
     }
     return warnings;
@@ -162,7 +164,7 @@ function checkAntigravityPathCollisions(manifest) {
         if (defNames.has(entry.name)) {
             warnings.push({
                 kind: "collision",
-                message: `agentDefinitions entry "${entry.name}" and mcpServers entry "${entry.name}" for agent "antigravity" both resolve to {repo}/.agents/rules/${entry.name}.md — one will silently overwrite the other; use different names or remove one entry`,
+                message: `agentDefinitions entry "${entry.name}" and mcpServers entry "${entry.name}" for agent "antigravity" both resolve to {repo}/.agents/rules/${entry.name}.md - one will silently overwrite the other; use different names or remove one entry`,
             });
         }
     }
@@ -212,17 +214,15 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
             });
         }
     }
-    for (const skill of manifest.skills) {
-        await planSkillEntry(skill);
-    }
+    await Promise.all(manifest.skills.map(planSkillEntry));
     return { actions, warnings };
 }
 async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
     const actions = [];
-    for (const fileEntry of manifest.files ?? []) {
+    await Promise.all((manifest.files ?? []).map(async (fileEntry) => {
         const targetAgents = fileEntry.agents.filter((agentId) => detectedAgents.includes(agentId));
         if (targetAgents.length === 0)
-            continue;
+            return;
         const source = path.resolve(sourceDir, fileEntry.path);
         await validateSourcePath(source, fileEntry.path, resolvedSourceDir, realRoot);
         await validateSourceFile(source, fileEntry.path);
@@ -236,10 +236,10 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
                 agent: agentId,
                 source,
                 target: resolveTargetTemplate(fileEntry.target, home, repo, workspace),
-                confidence: agent.provenance.skills,
+                confidence: "implementation-only",
             });
         }
-    }
+    }));
     return actions;
 }
 function planConfigPatchActions(manifest, detectedAgents, home, repo, workspace) {
@@ -280,7 +280,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home, repo
         ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, workspace)),
         ...planConfigPatchActions(manifest, detectedAgents, home, repoDir, workspace),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace, manifest.hooks ?? []);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...skillPlan.warnings,
@@ -370,7 +370,7 @@ async function backupManagedFileWriteTarget(action, home, deps) {
         agent: action.agent,
     }, deps.registry);
     if (!isOwned) {
-        throw new Error(`Target "${action.target}" exists but is not managed by inception-engine — refusing to overwrite`);
+        throw new Error(`Target "${action.target}" exists but is not managed by inception-engine - refusing to overwrite`);
     }
     const backupPath = `${action.target}.inception-backup`;
     await (deps.fileOps ?? defaultDeployFileOps).rm(backupPath, {
@@ -528,7 +528,7 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
         if (existingEntry &&
             (existingEntry.skill !== action.skill ||
                 existingEntry.agent !== action.agent)) {
-            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
+            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" - refusing to double-patch`);
         }
         const original = await readJsonConfigFile(action.target);
         const undoPatch = computeUndoPatch(original, patch);
@@ -576,7 +576,7 @@ async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
     try {
         const { previousValue } = await (deps.registry
             ? Promise.resolve({ previousValue: null })
-            : (await import("./adapters/toml.js")).applyTomlMcpPatch(action.target, action.skill, action.config));
+            : applyTomlMcpPatch(action.target, action.skill, action.config));
         // Note: To truly support custom deps here we'd need to refactor toml adapter to accept deps.
         // For now we assume standard adapter for TOML.
         await registerDeployment(home, action.target, {
@@ -622,9 +622,8 @@ async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, dep
             (existingEntry.kind !== "frontmatter-emit" ||
                 existingEntry.skill !== action.skill ||
                 existingEntry.agent !== action.agent)) {
-            throw new Error(`Frontmatter target "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
+            throw new Error(`Frontmatter target "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" - refusing to double-patch`);
         }
-        const frontmatterAdapter = await import("./adapters/frontmatter.js");
         const existing = await frontmatterAdapter.readFrontmatterDocumentFile(action.target);
         const undoPatch = computeUndoPatch(existing.attributes, action.frontmatter);
         const patchedFrontmatter = applyMergePatch(existing.attributes, action.frontmatter);
@@ -712,7 +711,7 @@ async function assertTargetAbsent(targetPath) {
     catch (err) {
         if (err instanceof Error && err.message.startsWith("Target path appeared"))
             throw err;
-        // ENOENT is expected — target should not exist after backup
+        // ENOENT is expected - target should not exist after backup
     }
 }
 async function createDeployTarget(action, home, deps) {
@@ -775,7 +774,7 @@ async function backupExisting(targetPath, verbose, home, expected, deps) {
         skill: expected.skill,
         agent: expected.agent,
     }, deps.registry))) {
-        throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine — refusing to overwrite`);
+        throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine - refusing to overwrite`);
     }
     const backupPath = `${targetPath}.inception-backup`;
     if (verbose) {

package/dist/src/core/detect.js

@@ -8,13 +8,8 @@ const defaultExecFn = async (cmd, args) => {
     await execFileAsync(cmd, args);
 };
 export async function detectInstalledAgents(home) {
-    const detected = [];
-    for (const agent of AGENT_REGISTRY) {
-        if (await isAgentInstalled(agent, home)) {
-            detected.push(agent.id);
-        }
-    }
-    return detected;
+    const results = await Promise.all(AGENT_REGISTRY.map((agent) => isAgentInstalled(agent, home)));
+    return AGENT_REGISTRY.filter((_, i) => results[i]).map((a) => a.id);
 }
 async function isAgentInstalled(agent, home) {
     const detectPath = resolveAgentDetectPath(agent, home);

package/dist/src/core/init.js

@@ -269,16 +269,24 @@ function agentsForDefinitionSubdir(subdir) {
  */
 async function isSkippedMcpFile(subdir, absPath, relPath) {
     const hasMcpSurfaceHere = AGENT_REGISTRY.some((agent) => {
-        const support = agent.mcpSupport;
-        if (support?.status !== "supported")
-            return false;
-        const tmpl = support.path.posix;
-        const repoIdx = tmpl.indexOf("{repo}");
-        const nameIdx = tmpl.findIndex((s) => s.includes("{name}"));
-        if (repoIdx === -1 || nameIdx === -1 || nameIdx <= repoIdx)
-            return false;
-        const prefix = tmpl.slice(repoIdx + 1, nameIdx).join("/");
-        return prefix === subdir;
+        const supports = [
+            agent.mcpSupport,
+            agent.mcpRepoSupport,
+            agent.mcpWorkspaceSupport,
+        ];
+        for (const support of supports) {
+            if (support?.status !== "supported")
+                continue;
+            const tmpl = support.path.posix;
+            const repoIdx = tmpl.indexOf("{repo}");
+            const nameIdx = tmpl.findIndex((s) => s.includes("{name}"));
+            if (repoIdx === -1 || nameIdx === -1 || nameIdx <= repoIdx)
+                continue;
+            const prefix = tmpl.slice(repoIdx + 1, nameIdx).join("/");
+            if (prefix === subdir)
+                return true;
+        }
+        return false;
     });
     if (!hasMcpSurfaceHere)
         return false;
@@ -521,7 +529,8 @@ function logPathAgentEntries(label, entries) {
         return;
     logger.detail(`${label}:`);
     for (const e of entries) {
-        logger.detail(`  ${e.name}  →  ${e.path}  [${e.agents.join(", ")}]`);
+        const entryAgents = e.agents ?? [];
+        logger.detail(`  ${e.name}  →  ${e.path}  [${entryAgents.join(", ")}]`);
     }
 }
 function logVerboseManifest(skills, agentRules, mcpServers, files, configs, agentDefinitions) {

package/dist/src/core/preflight.js

@@ -155,12 +155,22 @@ async function detectInstructionBudgetRisk(detectedAgents, manifest, sourceDir)
             // will produce the proper UserError during action compilation.
         }
     }
+    const entries = [];
     for (const entry of manifest.agentRules ?? []) {
-        await checkEntry(entry.path, "agentRules", entry.agents);
+        entries.push({
+            path: entry.path,
+            label: "agentRules",
+            agents: entry.agents,
+        });
     }
     for (const entry of manifest.agentDefinitions ?? []) {
-        await checkEntry(entry.path, "agentDefinitions", entry.agents);
+        entries.push({
+            path: entry.path,
+            label: "agentDefinitions",
+            agents: entry.agents,
+        });
     }
+    await Promise.all(entries.map((e) => checkEntry(e.path, e.label, e.agents)));
     return warnings;
 }
 function pushCapabilityWarning(acc, kind, message) {
@@ -169,6 +179,21 @@ function pushCapabilityWarning(acc, kind, message) {
     acc.seen.add(`${kind}:${message}`);
     acc.warnings.push({ kind, message });
 }
+function collectPlannedSurfaceWarnings(acc, agentId, capability) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (!agent?.unsupportedSurfaces ||
+        (capability !== "mcpServers" && capability !== "permissions")) {
+        return;
+    }
+    for (const surface of agent.unsupportedSurfaces) {
+        if (surface.status === "planned") {
+            pushCapabilityWarning(acc, "info", `Agent "${agentId}": ${surface.reason ?? surface.plannedSurface}`);
+        }
+        else if (surface.status === "unsupported") {
+            pushCapabilityWarning(acc, "config-authority", `Agent "${agentId}": ${surface.reason ?? surface.schemaLabel}`);
+        }
+    }
+}
 function collectCapabilityWarningsForAgent(acc, agentId, capability, entryName, targetAgents, scope) {
     const plan = planCapabilityForDeploy({
         agentId,
@@ -181,24 +206,13 @@ function collectCapabilityWarningsForAgent(acc, agentId, capability, entryName,
         pushCapabilityWarning(acc, "info", plan.warning.message);
         return;
     }
-    // Evaluate undocumented/planned surfaces warning
-    const agent = AGENT_REGISTRY_BY_ID[agentId];
-    if (agent?.unsupportedSurfaces) {
-        for (const surface of agent.unsupportedSurfaces) {
-            if (surface.status === "planned") {
-                pushCapabilityWarning(acc, "info", `Agent "${agentId}": ${surface.reason ?? surface.plannedSurface}`);
-            }
-            else if (surface.status === "unsupported") {
-                pushCapabilityWarning(acc, "config-authority", `Agent "${agentId}": ${surface.reason ?? surface.schemaLabel}`);
-            }
+    if (capability !== "skills") {
+        const confidence = describeCapabilityConfidence(agentId, capability, scope);
+        if (confidence.message) {
+            pushCapabilityWarning(acc, "config-authority", confidence.message);
         }
     }
-    if (capability === "skills")
-        return;
-    const confidence = describeCapabilityConfidence(agentId, capability, scope);
-    if (confidence.message) {
-        pushCapabilityWarning(acc, "config-authority", confidence.message);
-    }
+    collectPlannedSurfaceWarnings(acc, agentId, capability);
 }
 function collectCapabilityWarningsForTargets(acc, targetAgents, capability, entryName, scope) {
     for (const agentId of targetAgents) {
@@ -252,7 +266,9 @@ async function collectAgentWarnings(agentId, manifest, home) {
         });
     }
     else if (agent.policyNote &&
-        !agent.policyNote.includes("Organization policies may override")) {
+        !agent.policyNote
+            .toLowerCase()
+            .includes("organization policies may override")) {
         warnings.push({
             kind: "policy",
             message: `Agent "${agentId}": ${agent.policyNote}`,

package/dist/src/core/revert.js

@@ -1,6 +1,7 @@
 import { lstat, readFile, rm, unlink, writeFile } from "node:fs/promises";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
+import * as frontmatterAdapter from "./adapters/frontmatter.js";
 import { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { applyUndoPatch } from "./merge-patch.js";
@@ -177,7 +178,6 @@ function planFrontmatterRevert(action, frontmatterEntry, planned) {
     return { outcome: "ok" };
 }
 async function applyFrontmatterRevert(action, frontmatterEntry) {
-    const frontmatterAdapter = await import("./adapters/frontmatter.js");
     const current = await frontmatterAdapter.readFrontmatterDocumentFile(action.target);
     const restoredFrontmatter = applyUndoPatch(current.attributes, frontmatterEntry.undoPatch ?? {});
     const shouldDeleteFile = frontmatterEntry.created === true &&

package/dist/src/core/validation.d.ts

@@ -4,6 +4,7 @@ export declare function validateSourcePath(source: string, skillPath: string, re
 export declare function validateSourceFile(sourcePath: string, manifestPath: string): Promise<void>;
 export declare function validateMcpServerConfigShape(config: Record<string, unknown>, entryName: string, agentId: string): void;
 export declare function validatePermissionsConfigShape(config: Record<string, unknown>, entryName: string, agentId: string): void;
+export declare function validateHookConfigShape(_config: Record<string, unknown>, _entryName: string, _agentId: string): void;
 export declare function validateAgentRuleMarkdownPath(manifestPath: string, agentId: string): void;
 export declare function validateSkillDefinitionFile(sourcePath: string, manifestPath: string): Promise<{
     attributes: Record<string, unknown>;

package/dist/src/core/validation.js

@@ -163,6 +163,10 @@ export function validatePermissionsConfigShape(config, entryName, agentId) {
         validateOpenCodePermissions(config, entryName);
     }
 }
+export function validateHookConfigShape(_config, _entryName, _agentId) {
+    // Placeholder for agent-specific hook validation logic.
+    // Currently allows any record as a hook payload.
+}
 export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
     const extension = path.extname(manifestPath).toLowerCase();
     if (extension !== ".md" && extension !== ".markdown") {
@@ -218,6 +222,17 @@ function validateGithubCopilotRequirements(attributes, manifestPath) {
     if (!(hasTools || hasInstructions)) {
         throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "github-copilot" must define "tools" or "instructions" in frontmatter`);
     }
+    if (hasTools) {
+        const tools = attributes.tools;
+        if (!Array.isArray(tools)) {
+            throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "github-copilot" has a "tools" field that must be an array`);
+        }
+        for (const tool of tools) {
+            if (typeof tool !== "string") {
+                throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "github-copilot" has a "tools" entry that must be a string`);
+            }
+        }
+    }
 }
 function validateAntigravityRequirements(attributes, manifestPath) {
     const mcpServers = attributes["mcp-servers"] ?? attributes.mcpServers;

package/dist/src/errors.d.ts

@@ -1,5 +1,7 @@
 export type ErrorCode = "INVALID_ARGS" | "MANIFEST_INVALID" | "DEPLOY_FAILED" | "RESOLVE_FAILED";
 export declare class UserError extends Error {
     readonly code: ErrorCode;
-    constructor(code: ErrorCode, message: string);
+    constructor(code: ErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
 }

package/dist/src/errors.js

@@ -1,7 +1,7 @@
 export class UserError extends Error {
     code;
-    constructor(code, message) {
-        super(message);
+    constructor(code, message, options) {
+        super(message, options);
         this.name = "UserError";
         this.code = code;
     }

package/dist/src/schemas/manifest.d.ts

@@ -63,6 +63,7 @@ export declare const McpServerEntrySchema: z.ZodObject<{
         global: "global";
         repo: "repo";
         workspace: "workspace";
+        devcontainer: "devcontainer";
     }>>;
 }, z.core.$strip>;
 export declare const AgentRuleEntrySchema: z.ZodObject<{
@@ -111,6 +112,18 @@ export declare const AgentDefinitionEntrySchema: z.ZodObject<{
         workspace: "workspace";
     }>>;
 }, z.core.$strip>;
+export declare const HookEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -165,6 +178,7 @@ export declare const ManifestSchema: z.ZodObject<{
             global: "global";
             repo: "repo";
             workspace: "workspace";
+            devcontainer: "devcontainer";
         }>>;
     }, z.core.$strip>>>;
     agentRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -213,6 +227,18 @@ export declare const ManifestSchema: z.ZodObject<{
             workspace: "workspace";
         }>>;
     }, z.core.$strip>>>;
+    hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "gemini-cli": "gemini-cli";
+            antigravity: "antigravity";
+            opencode: "opencode";
+            "github-copilot": "github-copilot";
+        }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;
 export type FileEntry = z.infer<typeof FileEntrySchema>;
@@ -221,6 +247,7 @@ export type McpServerEntry = z.infer<typeof McpServerEntrySchema>;
 export type AgentRuleEntry = z.infer<typeof AgentRuleEntrySchema>;
 export type PermissionsEntry = z.infer<typeof PermissionsEntrySchema>;
 export type AgentDefinitionEntry = z.infer<typeof AgentDefinitionEntrySchema>;
+export type HookEntry = z.infer<typeof HookEntrySchema>;
 export type Manifest = z.infer<typeof ManifestSchema>;
 export declare const AgentListSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>, z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
     "claude-code": "claude-code";

package/dist/src/schemas/manifest.js

@@ -88,7 +88,9 @@ export const McpServerEntrySchema = z.object({
     // config files for agents that support them (e.g. GitHub Copilot's
     // .vscode/mcp.json). For agents without scope-specific surfaces the
     // adapter falls back to the global surface or emits a warning.
-    scope: z.enum(["global", "repo", "workspace"]).default("global"),
+    scope: z
+        .enum(["global", "repo", "workspace", "devcontainer"])
+        .default("global"),
 });
 export const AgentRuleEntrySchema = z.object({
     name: nameField,
@@ -124,6 +126,13 @@ export const AgentDefinitionEntrySchema = z.object({
     // within the deployed repository (default).
     scope: z.enum(["global", "repo", "workspace"]).default("repo"),
 });
+export const HookEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Raw hook config payload validated per agent by the hooks adapter.
+    // Supports lifecycle-binding hooks (e.g. pre-exec, post-exec) for various agents.
+    config: z.record(z.string(), z.unknown()),
+});
 export const ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
         const seen = new Set();
@@ -144,6 +153,7 @@ export const ManifestSchema = z.object({
     agentRules: z.array(AgentRuleEntrySchema).default([]),
     permissions: z.array(PermissionsEntrySchema).default([]),
     agentDefinitions: z.array(AgentDefinitionEntrySchema).default([]),
+    hooks: z.array(HookEntrySchema).optional(),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/src/types.d.ts

@@ -1,11 +1,11 @@
 import type { AgentId } from "./schemas/manifest.ts";
-export type { AgentDefinitionEntry, AgentId, ConfigEntry, FileEntry, Manifest, SkillEntry, } from "./schemas/manifest.ts";
+export type { AgentDefinitionEntry, AgentId, ConfigEntry, FileEntry, HookEntry, Manifest, SkillEntry, } from "./schemas/manifest.ts";
 export interface AgentPaths {
     posix: string[];
     windows: string[];
 }
 export type Confidence = "documented" | "implementation-only" | "provisional";
-export type CapabilityKind = "skills" | "mcpServers" | "agentRules" | "permissions" | "agentDefinitions";
+export type CapabilityKind = "skills" | "mcpServers" | "agentRules" | "permissions" | "hooks" | "agentDefinitions";
 export interface SupportedAgentSurface {
     status: "supported";
     /**
@@ -67,6 +67,7 @@ export interface AgentProvenance {
     mcpConfig?: Confidence;
     agentRules?: Confidence;
     permissions?: Confidence;
+    hooks?: Confidence;
     agentDefinitions?: Confidence;
 }
 export interface AgentConfig {
@@ -97,11 +98,16 @@ export interface AgentConfig {
     agentRulesRepoSupport?: AgentSurfaceSupport;
     agentRulesWorkspaceSupport?: AgentSurfaceSupport;
     permissionsSupport?: AgentSurfaceSupport;
+    hooksSupport?: AgentSurfaceSupport;
+    hooksRepoSupport?: AgentSurfaceSupport;
+    hooksWorkspaceSupport?: AgentSurfaceSupport;
     agentDefinitionsSupport?: AgentSurfaceSupport;
     agentDefinitionsRepoSupport?: AgentSurfaceSupport;
     agentDefinitionsWorkspaceSupport?: AgentSurfaceSupport;
     agentDefinitionsTomlSupport?: AgentSurfaceSupport;
     agentDefinitionsTomlRepoSupport?: AgentSurfaceSupport;
+    mcpDevcontainerSupport?: AgentSurfaceSupport;
+    mcpAgentFrontmatterSupport?: AgentSurfaceSupport;
     policyNote?: string;
     /**
      * A list of documented surfaces that are currently not safe to support directly.

package/dist/test/os/windows/agentRules-integration.test.d.ts

@@ -0,0 +1 @@
+export {};