@kuznai/inception-engine 0.21.0 → 0.23.0

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

@@ -2,6 +2,37 @@ import path from "node:path";
 import { planCapabilityForDeploy, resolveCapabilitySurface, } from "../capabilities.js";
 import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
 import { validateAgentRuleMarkdownPath, validateInstructionFileRequirements, validateSourceFile, validateSourcePath, } from "../validation.js";
+function requiresRepoPath(scope) {
+    return (scope === "repo" || scope === "copilot-repo" || scope === "copilot-scoped");
+}
+function deduplicateTargets(supportedTargets, scope) {
+    const seenTargetPaths = new Set();
+    const dedupedTargets = [];
+    for (const t of supportedTargets) {
+        const surface = resolveCapabilitySurface(t.agentId, "agentRules", scope);
+        if (surface.surfaceKind === "shared-via" &&
+            surface.sharedVia &&
+            supportedTargets.some((o) => o.agentId === surface.sharedVia && o.target === t.target)) {
+            continue;
+        }
+        if (!seenTargetPaths.has(t.target)) {
+            seenTargetPaths.add(t.target);
+            dedupedTargets.push(t);
+        }
+    }
+    return dedupedTargets;
+}
+function injectTargetDir(pathSegments, targetDir) {
+    if (!targetDir)
+        return pathSegments;
+    const placeholderIndex = pathSegments.findIndex((seg) => seg === "{repo}" || seg === "{workspace}");
+    if (placeholderIndex === -1)
+        return pathSegments;
+    const dirSegments = targetDir.split(/[\\/]+/).filter(Boolean);
+    const result = [...pathSegments];
+    result.splice(placeholderIndex + 1, 0, ...dirSegments);
+    return result;
+}
 function resolveAgentTarget(agentId, entry, home, repo, platform, workspace, allTargetAgentIds) {
     const plan = planCapabilityForDeploy({
         agentId,
@@ -28,10 +59,17 @@ function resolveAgentTarget(agentId, entry, home, repo, platform, workspace, all
             message: `agentRules: scope "workspace" requires a workspace or repository path but none was resolved — skipping "${entry.name}" for agent "${agentId}"`,
         };
     }
+    if ((entry.scope === "copilot-repo" || entry.scope === "copilot-scoped") &&
+        !repo) {
+        return {
+            kind: "confidence",
+            message: `agentRules: scope "${entry.scope}" requires a repository path but none was resolved — skipping "${entry.name}" for agent "${agentId}"`,
+        };
+    }
     return {
         agentId,
         confidence: plan.confidence,
-        target: resolvePlaceholders(support?.path[platform] ?? [], entry.name, home, repo, workspace),
+        target: resolvePlaceholders(injectTargetDir(support?.path[platform] ?? [], entry.targetDir), entry.name, home, repo, workspace),
     };
 }
 export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
@@ -61,29 +99,22 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
     // Deduplicate: when a shared-via rider's primary is also in supportedTargets,
     // skip the rider — the primary agent writes the shared surface. As a fallback,
     // also dedup by resolved path so no target file is written twice.
-    const seenTargetPaths = new Set();
-    const dedupedTargets = [];
-    for (const t of supportedTargets) {
-        const surface = resolveCapabilitySurface(t.agentId, "agentRules", entry.scope);
-        if (surface.surfaceKind === "shared-via" &&
-            surface.sharedVia &&
-            supportedTargets.some((o) => o.agentId === surface.sharedVia && o.target === t.target)) {
-            // Primary agent is present and writes the same target — skip rider.
-            continue;
-        }
-        if (!seenTargetPaths.has(t.target)) {
-            seenTargetPaths.add(t.target);
-            dedupedTargets.push(t);
-        }
-    }
+    const dedupedTargets = deduplicateTargets(supportedTargets, entry.scope);
     // Validate the shared source file only when at least one target uses the
     // current rules adapter surface.
     const source = path.resolve(sourceDir, entry.path);
     await validateSourcePath(source, entry.path, resolvedSourceDir, realRoot);
     await validateSourceFile(source, entry.path);
+    // Native Copilot instruction files (.github/copilot-instructions.md and
+    // .github/instructions/*.instructions.md) are plain markdown and do not
+    // require agent-definition-style frontmatter (tools/instructions keys).
+    // Skip the instructionFrontmatterRequired check for these scopes.
+    const skipFrontmatterValidation = entry.scope === "copilot-repo" || entry.scope === "copilot-scoped";
     for (const target of dedupedTargets) {
         validateAgentRuleMarkdownPath(entry.path, target.agentId);
-        await validateInstructionFileRequirements(source, entry.path, target.agentId);
+        if (!skipFrontmatterValidation) {
+            await validateInstructionFileRequirements(source, entry.path, target.agentId);
+        }
         actions.push({
             kind: "file-write",
             skill: entry.name,
@@ -107,11 +138,11 @@ export function compileAgentRuleReverts(entry, agentFilter, home, repo, workspac
         if (surface.supportStatus !== "supported" || !support) {
             continue;
         }
-        if (entry.scope === "repo" && !repo)
+        if (requiresRepoPath(entry.scope) && !repo)
             continue;
         if (entry.scope === "workspace" && !workspace && !repo)
             continue;
-        const target = resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace);
+        const target = resolvePlaceholders(injectTargetDir(support.path[platform], entry.targetDir), entry.name, home, repo, workspace);
         if (seenRevertTargets.has(target))
             continue;
         seenRevertTargets.add(target);

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

@@ -1,5 +1,5 @@
 import type { AgentId, AgentSurfaceSupport, CapabilityKind, Confidence, PlanWarning, SupportedAgentSurface } from "../types.ts";
-type CapabilityScope = "global" | "repo" | "workspace";
+type CapabilityScope = "global" | "repo" | "workspace" | "devcontainer" | "copilot-repo" | "copilot-scoped";
 export interface ResolvedCapabilitySurface {
     agentId: AgentId;
     capability: CapabilityKind;

package/dist/src/core/capabilities.js

@@ -1,6 +1,12 @@
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 function resolveAgentRulesSupport(agentId, scope) {
     const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "copilot-repo") {
+        return agent?.agentRulesCopilotRepoSupport;
+    }
+    if (scope === "copilot-scoped") {
+        return agent?.agentRulesCopilotScopedSupport;
+    }
     if (scope === "repo") {
         return agent?.agentRulesRepoSupport ?? agent?.agentRulesSupport;
     }
@@ -19,6 +25,11 @@ function resolveMcpSupport(agentId, scope) {
     if (scope === "workspace") {
         return (agent?.mcpWorkspaceSupport ?? agent?.mcpRepoSupport ?? agent?.mcpSupport);
     }
+    if (scope === "devcontainer") {
+        return (agent?.mcpDevcontainerSupport ??
+            agent?.mcpRepoSupport ??
+            agent?.mcpSupport);
+    }
     return agent?.mcpSupport;
 }
 function resolveAgentDefinitionsSupport(agentId, scope) {
@@ -45,6 +56,10 @@ function capabilityLabel(capability) {
             return "permissions";
         case "agentDefinitions":
             return "agentDefinitions";
+        case "hooks":
+            return "hooks";
+        case "executionConfigs":
+            return "executionConfigs";
     }
 }
 function capabilitySurfaceLabel(capability) {
@@ -59,6 +74,10 @@ function capabilitySurfaceLabel(capability) {
             return "permissions";
         case "agentDefinitions":
             return "agent-definitions";
+        case "hooks":
+            return "hooks";
+        case "executionConfigs":
+            return "execution-config";
     }
 }
 function resolveSkillsCapability(agentId) {
@@ -110,9 +129,21 @@ function getSurfaceRecordAndConfidence(agentId, capability, scope) {
             confidence: agent.provenance.permissions,
         };
     }
+    if (capability === "agentDefinitions") {
+        return {
+            supportRecord: resolveAgentDefinitionsSupport(agentId, scope),
+            confidence: agent.provenance.agentDefinitions,
+        };
+    }
+    if (capability === "hooks") {
+        return {
+            supportRecord: agent.hooksSupport,
+            confidence: agent.provenance.hooks,
+        };
+    }
     return {
-        supportRecord: resolveAgentDefinitionsSupport(agentId, scope),
-        confidence: agent.provenance.agentDefinitions,
+        supportRecord: agent.executionConfigSupport,
+        confidence: agent.provenance.executionConfig,
     };
 }
 function resolveUnsupportedSurface(agentId, capability, supportRecord, confidence) {

package/dist/src/core/deploy.js

@@ -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 ?? [], manifest.executionConfigs ?? []);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...skillPlan.warnings,

package/dist/src/core/init.js

@@ -32,9 +32,10 @@ const AGENT_RULES_FILE_PATTERNS = (() => {
             fileNames: [filename, filename.replace(".md", "-instructions.md")],
             agents,
         })),
-        // Convention mapping: copilot-instructions.md → claude-code. Copilot reads
-        // CLAUDE.md natively; this filename is a well-known convention that cannot
-        // be derived from any agent path template.
+        // Convention mapping for copilot-instructions.md found outside .github/:
+        // map to claude-code since Copilot reads CLAUDE.md natively. Files at
+        // .github/copilot-instructions.md are handled separately as a native
+        // Copilot surface via the copilot-repo scope.
         {
             fileNames: ["copilot-instructions.md"],
             agents: ["claude-code"],
@@ -183,18 +184,73 @@ async function findAgentRulesCandidates(baseDir, skillDirRelPaths) {
     for (const subdir of AGENT_RULES_SUBDIRS) {
         await scanDirForMarkdown(path.join(baseDir, subdir), baseDir, skillDirRelPaths, seen, candidates);
     }
+    // Promote .github/copilot-instructions.md to the native copilot-repo scope.
+    // The general scanDirForMarkdown pass above picks it up via AGENT_RULES_SUBDIRS
+    // (".github"), so we just patch the candidate that was already added.
+    const copilotRepoRelPath = ".github/copilot-instructions.md";
+    const copilotRepoCandidate = candidates.find((c) => c.relPath === copilotRepoRelPath);
+    if (copilotRepoCandidate) {
+        copilotRepoCandidate.defaultAgents = ["github-copilot"];
+        copilotRepoCandidate.scope = "copilot-repo";
+    }
+    // Discover .github/instructions/*.instructions.md as copilot-scoped entries.
+    // These are not covered by the general scan (it only looks for .md/.markdown
+    // and the stem derivation would lose the .instructions suffix).
+    const instructionsDir = path.join(baseDir, ".github", "instructions");
+    let instrEntries;
+    try {
+        instrEntries = await readdir(instructionsDir, {
+            withFileTypes: true,
+            encoding: "utf-8",
+        });
+    }
+    catch {
+        instrEntries = [];
+    }
+    for (const entry of instrEntries) {
+        if (!entry.isFile())
+            continue;
+        const lower = entry.name.toLowerCase();
+        if (!lower.endsWith(".instructions.md"))
+            continue;
+        const absPath = path.join(instructionsDir, entry.name);
+        const relPath = path.relative(baseDir, absPath).split(path.sep).join("/");
+        if (seen.has(relPath) || isInsideSkillDir(relPath, skillDirRelPaths))
+            continue;
+        // Derive name by stripping ".instructions.md" suffix
+        const baseStem = entry.name.slice(0, -".instructions.md".length);
+        const rawName = baseStem.toLowerCase().replace(/[^a-zA-Z0-9._-]/g, "-");
+        if (!SAFE_NAME_RE.test(rawName)) {
+            logger.warn("init", `Skipping "${relPath}": could not derive a valid agentRules name`);
+            continue;
+        }
+        seen.add(relPath);
+        candidates.push({
+            relPath,
+            name: rawName,
+            defaultAgents: ["github-copilot"],
+            scope: "copilot-scoped",
+        });
+    }
     return candidates;
 }
-function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
+function buildAgentRules(candidates, activeAgents, allAgents, skillNamesSeen) {
     const rules = [];
     const namesSeen = new Set(skillNamesSeen);
-    for (const { relPath, name: rawName } of candidates) {
-        const fileName = path.basename(relPath);
-        const defaultAgents = defaultAgentsForFile(fileName, activeAgents);
-        // Intersect with active agents; fall back to full active list if empty
-        const intersection = defaultAgents.filter((a) => activeAgents.includes(a));
-        const agents = intersection.length > 0 ? intersection : activeAgents;
-        // Skip if no capable agents remain (e.g. --agents github-copilot only)
+    for (const { relPath, name: rawName, defaultAgents: presetAgents, scope: presetScope, } of candidates) {
+        let agents;
+        if (presetAgents.length > 0) {
+            // Candidates with preset agents (e.g. copilot-repo, copilot-scoped) use
+            // those agents directly, intersected with the full agents list.
+            agents = presetAgents.filter((a) => allAgents.includes(a));
+        }
+        else {
+            // Derive from filename pattern and intersect with active (capable) agents.
+            const defaults = defaultAgentsForFile(path.basename(relPath), activeAgents);
+            const ix = defaults.filter((a) => activeAgents.includes(a));
+            agents = ix.length > 0 ? ix : activeAgents;
+        }
+        // Skip if excluded by --agents or no capable agents remain
         if (agents.length === 0)
             continue;
         // Resolve name collision with skill names
@@ -211,7 +267,7 @@ function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
             }
         }
         namesSeen.add(name);
-        rules.push({ name, path: relPath, agents, scope: "global" });
+        rules.push({ name, path: relPath, agents, scope: presetScope ?? "global" });
     }
     return rules;
 }
@@ -269,16 +325,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;
@@ -568,7 +632,7 @@ export async function runInit(options) {
     const skillNamesSeen = new Set(skills.map((s) => s.name));
     const skillDirRelPaths = new Set(found.map((f) => f.relPath));
     const agentRulesCandidates = await findAgentRulesCandidates(directory, skillDirRelPaths);
-    const agentRules = buildAgentRules(agentRulesCandidates, agentRulesCapableAgents, skillNamesSeen);
+    const agentRules = buildAgentRules(agentRulesCandidates, agentRulesCapableAgents, agents, skillNamesSeen);
     const allNamesSeen = new Set([
         ...skillNamesSeen,
         ...agentRules.map((r) => r.name),

package/dist/src/core/preflight.js

@@ -118,12 +118,37 @@ function detectMultipleActiveInstructionScopes(agentId, rulesForAgent) {
         },
     ];
 }
+/**
+ * Warns when github-copilot has both a shared-via CLAUDE.md agentRules entry
+ * (scope: "repo" or "global") AND a native Copilot instruction entry
+ * (scope: "copilot-repo" or "copilot-scoped"). GitHub Copilot merges all
+ * active instruction sources at runtime, so duplicate or conflicting rules
+ * across these surfaces may cause unexpected agent behavior.
+ */
+function detectCopilotInstructionPrecedence(rulesForAgent) {
+    const hasSharedVia = (rulesForAgent ?? []).some((e) => e.scope === "repo" || e.scope === "global");
+    const hasNative = (rulesForAgent ?? []).some((e) => e.scope === "copilot-repo" || e.scope === "copilot-scoped");
+    if (!(hasSharedVia && hasNative))
+        return [];
+    return [
+        {
+            kind: "precedence",
+            message: `Agent "github-copilot" will load both a CLAUDE.md-shared instruction file` +
+                ` and a native Copilot instruction file (.github/copilot-instructions.md or` +
+                ` .github/instructions/). GitHub Copilot merges all active instruction` +
+                ` sources - ensure content is non-conflicting and does not duplicate rules.`,
+        },
+    ];
+}
 function detectInstructionPrecedence(detectedAgents, manifest) {
     const warnings = [];
     for (const agentId of detectedAgents) {
         const rulesForAgent = (manifest.agentRules ?? []).filter((e) => e.agents.includes(agentId));
         warnings.push(...detectScopeOverlaps(agentId, rulesForAgent));
         warnings.push(...detectMultipleActiveInstructionScopes(agentId, rulesForAgent));
+        if (agentId === "github-copilot") {
+            warnings.push(...detectCopilotInstructionPrecedence(rulesForAgent));
+        }
     }
     return warnings;
 }
@@ -239,6 +264,9 @@ function collectManifestCapabilityWarnings(manifest, detectedAgents) {
     for (const entry of manifest.agentDefinitions ?? []) {
         collectCapabilityWarningsForTargets(acc, entry.agents.filter((agentId) => detectedAgents.includes(agentId)), "agentDefinitions", entry.name, entry.scope);
     }
+    for (const entry of manifest.executionConfigs ?? []) {
+        collectCapabilityWarningsForTargets(acc, entry.agents.filter((agentId) => detectedAgents.includes(agentId)), "executionConfigs", entry.name);
+    }
     return acc.warnings;
 }
 function detectCapabilityPlanningWarnings(manifest, detectedAgents) {

package/dist/src/core/revert.js

@@ -2,7 +2,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 { compileAgentDefinitionReverts, compileAgentRuleReverts, compileExecutionConfigReverts, compileHookReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { applyUndoPatch } from "./merge-patch.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
@@ -75,6 +75,8 @@ export function planRevert(manifest, detectedAgents, home, repo) {
         ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, detectedAgents, home, repo)),
         ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, detectedAgents, home, repo)),
         ...(manifest.permissions ?? []).flatMap((e) => compilePermissionsReverts(e, detectedAgents, home)),
+        ...(manifest.hooks ?? []).flatMap((e) => compileHookReverts(e, detectedAgents, home)),
+        ...(manifest.executionConfigs ?? []).flatMap((e) => compileExecutionConfigReverts(e, detectedAgents, home)),
         ...(manifest.agentDefinitions ?? []).flatMap((e) => compileAgentDefinitionReverts(e, detectedAgents, home, repo)),
     ];
 }
@@ -86,6 +88,8 @@ export function planRevertAll(manifest, home, repo) {
         ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, null, home, repo)),
         ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, null, home, repo)),
         ...(manifest.permissions ?? []).flatMap((e) => compilePermissionsReverts(e, null, home)),
+        ...(manifest.hooks ?? []).flatMap((e) => compileHookReverts(e, null, home)),
+        ...(manifest.executionConfigs ?? []).flatMap((e) => compileExecutionConfigReverts(e, null, home)),
         ...(manifest.agentDefinitions ?? []).flatMap((e) => compileAgentDefinitionReverts(e, null, home, repo)),
     ];
 }

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,63 @@ export function validatePermissionsConfigShape(config, entryName, agentId) {
         validateOpenCodePermissions(config, entryName);
     }
 }
+function validateClaudeHookCommand(cmd, path) {
+    if (typeof cmd !== "object" || cmd === null || Array.isArray(cmd)) {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path} must be an object`);
+    }
+    const cmdObj = cmd;
+    if (cmdObj.type !== "command") {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path}.type must be "command"`);
+    }
+    if (typeof cmdObj.command !== "string") {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path}.command must be a string`);
+    }
+}
+function validateClaudeHookMatcher(matcher, path) {
+    if (typeof matcher !== "object" ||
+        matcher === null ||
+        Array.isArray(matcher)) {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path} must be an object`);
+    }
+    const matcherObj = matcher;
+    if (matcherObj.matcher !== undefined &&
+        typeof matcherObj.matcher !== "string") {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path}.matcher must be a string when present`);
+    }
+    const matcherHooks = matcherObj.hooks;
+    if (!Array.isArray(matcherHooks)) {
+        throw new UserError("DEPLOY_FAILED", `hooks entry ${path}.hooks must be an array`);
+    }
+    for (const [cmdIdx, cmd] of matcherHooks.entries()) {
+        validateClaudeHookCommand(cmd, `${path}.hooks[${cmdIdx}]`);
+    }
+}
+function validateClaudeCodeHooks(config, entryName) {
+    const unknownKeys = Object.keys(config).filter((k) => k !== "hooks");
+    if (unknownKeys.length > 0) {
+        throw new UserError("DEPLOY_FAILED", `hooks entry "${entryName}" for agent "claude-code" contains unrecognized keys: ${unknownKeys.join(", ")}. Only "hooks" is allowed.`);
+    }
+    const hooks = config.hooks;
+    if (hooks === undefined)
+        return;
+    if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+        throw new UserError("DEPLOY_FAILED", `hooks entry "${entryName}" for agent "claude-code" must define "hooks" as an object`);
+    }
+    const hooksObj = hooks;
+    for (const [eventName, matchers] of Object.entries(hooksObj)) {
+        if (!Array.isArray(matchers)) {
+            throw new UserError("DEPLOY_FAILED", `hooks entry "${entryName}" for agent "claude-code": "hooks.${eventName}" must be an array`);
+        }
+        for (const [idx, matcher] of matchers.entries()) {
+            validateClaudeHookMatcher(matcher, `"${entryName}" for agent "claude-code": "hooks.${eventName}[${idx}]"`);
+        }
+    }
+}
+export function validateHookConfigShape(config, entryName, agentId) {
+    if (agentId === "claude-code") {
+        validateClaudeCodeHooks(config, entryName);
+    }
+}
 export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
     const extension = path.extname(manifestPath).toLowerCase();
     if (extension !== ".md" && extension !== ".markdown") {

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<{
@@ -80,7 +81,10 @@ export declare const AgentRuleEntrySchema: z.ZodObject<{
         global: "global";
         repo: "repo";
         workspace: "workspace";
+        "copilot-repo": "copilot-repo";
+        "copilot-scoped": "copilot-scoped";
     }>>;
+    targetDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const PermissionsEntrySchema: z.ZodObject<{
     name: z.ZodString;
@@ -94,6 +98,18 @@ export declare const PermissionsEntrySchema: z.ZodObject<{
     }>>>, 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 ExecutionConfigEntrySchema: 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 AgentDefinitionEntrySchema: z.ZodObject<{
     name: z.ZodString;
     agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
@@ -111,6 +127,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 +193,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<{
@@ -182,7 +211,10 @@ export declare const ManifestSchema: z.ZodObject<{
             global: "global";
             repo: "repo";
             workspace: "workspace";
+            "copilot-repo": "copilot-repo";
+            "copilot-scoped": "copilot-scoped";
         }>>;
+        targetDir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     permissions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -213,6 +245,30 @@ 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>>>;
+    executionConfigs: 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 +277,8 @@ 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 ExecutionConfigEntry = z.infer<typeof ExecutionConfigEntrySchema>;
 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";