@kuznai/inception-engine 0.22.0 → 0.24.0

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;
 }
@@ -576,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/ownership.d.ts

@@ -21,6 +21,7 @@ export type VerifyExpected = {
     agent: AgentId;
 };
 export declare function registryPath(home: string): string;
+export declare function registryDirPath(home: string): string;
 export declare const defaultRegistryPersistence: RegistryPersistence;
 export type RegisterEntry = Omit<SkillDirRegistryEntry, "deployed"> | Omit<FileWriteRegistryEntry, "deployed"> | Omit<ConfigPatchRegistryEntry, "deployed"> | Omit<FrontmatterEmitRegistryEntry, "deployed">;
 export declare function registerDeployment(home: string, targetPath: string, entry: RegisterEntry, persistence?: RegistryPersistence): Promise<void>;

package/dist/src/core/ownership.js

@@ -1,4 +1,4 @@
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { RegistrySchema, } from "../schemas/registry.js";
 const REGISTRY_DIR = ".inception-engine";
@@ -6,8 +6,26 @@ const REGISTRY_FILE = "registry.json";
 export function registryPath(home) {
     return path.join(home, REGISTRY_DIR, REGISTRY_FILE);
 }
+export function registryDirPath(home) {
+    return path.join(home, REGISTRY_DIR);
+}
+async function assertSafeRegistryStoragePath(targetPath, label) {
+    try {
+        const stat = await lstat(targetPath);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Refusing to use ${label} symlink: ${targetPath}`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
 async function loadRegistry(home) {
     try {
+        await assertSafeRegistryStoragePath(registryDirPath(home), "registry directory");
+        await assertSafeRegistryStoragePath(registryPath(home), "registry file");
         const content = await readFile(registryPath(home), "utf-8");
         const parsed = JSON.parse(content);
         const result = RegistrySchema.safeParse(parsed);
@@ -18,9 +36,12 @@ async function loadRegistry(home) {
     }
 }
 async function saveRegistry(home, registry) {
-    const dir = path.join(home, REGISTRY_DIR);
+    const dir = registryDirPath(home);
+    await assertSafeRegistryStoragePath(dir, "registry directory");
     await mkdir(dir, { recursive: true });
+    await setDirectoryPermissions(dir);
     const filePath = registryPath(home);
+    await assertSafeRegistryStoragePath(filePath, "registry file");
     await writeFile(filePath, `${JSON.stringify(registry, null, 2)}\n`);
     await setFilePermissions(filePath);
 }
@@ -29,12 +50,21 @@ export const defaultRegistryPersistence = {
     save: saveRegistry,
 };
 /**
- * Ensure the file is not world-writable regardless of umask.
+ * Restrict access to the state directory regardless of umask.
+ * On Windows, the OS inherits ACLs from the parent directory — no-op is correct.
+ */
+async function setDirectoryPermissions(dirPath) {
+    if (process.platform !== "win32") {
+        await chmod(dirPath, 0o700);
+    }
+}
+/**
+ * Restrict the registry file to the current user regardless of umask.
  * On Windows, the OS inherits ACLs from the parent directory — no-op is correct.
  */
 async function setFilePermissions(filePath) {
     if (process.platform !== "win32") {
-        await chmod(filePath, 0o644);
+        await chmod(filePath, 0o600);
     }
 }
 function emptyRegistry() {

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

@@ -1,11 +1,12 @@
 import { lstat, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
 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";
+import { lookupDeployment, registryDirPath, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
 function buildSkillDirReverts(manifest, home, agentFilter) {
@@ -75,6 +76,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 +89,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)),
     ];
 }
@@ -121,6 +126,54 @@ function lstatOutcome(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { outcome: "fail", error: msg };
 }
+function normalizePathForComparison(candidate) {
+    const normalized = path.normalize(candidate);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isSameOrDescendantPath(candidate, root) {
+    const normalizedCandidate = normalizePathForComparison(candidate);
+    const normalizedRoot = normalizePathForComparison(root);
+    return (normalizedCandidate === normalizedRoot ||
+        normalizedCandidate.startsWith(normalizedRoot + path.sep));
+}
+function failReservedStateTarget(action, home) {
+    const reservedDir = registryDirPath(home);
+    if (!isSameOrDescendantPath(action.target, reservedDir)) {
+        return null;
+    }
+    return {
+        outcome: "fail",
+        error: `Refusing to modify inception-engine state directory "${reservedDir}" ` +
+            `via manifest-managed revert target "${action.target}"`,
+    };
+}
+async function preflightManagedSkillDirRevert(action, label, home, deps) {
+    const reservedTargetFailure = failReservedStateTarget(action, home);
+    if (reservedTargetFailure) {
+        if (reservedTargetFailure.outcome === "fail") {
+            logger.fail(label, reservedTargetFailure.error);
+        }
+        return reservedTargetFailure;
+    }
+    try {
+        await lstat(action.target);
+    }
+    catch (err) {
+        const result = lstatOutcome(err);
+        if (result.outcome === "skip") {
+            logger.skip(label, "(not found, skipping)");
+            return result;
+        }
+        logger.fail(label, result.error);
+        return result;
+    }
+    const entry = await lookupDeployment(home, action.target, deps.registry);
+    if (!entry || entry.skill !== action.skill || entry.agent !== action.agent) {
+        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
+        return { outcome: "skip" };
+    }
+    return null;
+}
 export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
     const failed = [];
     const planned = [];
@@ -194,6 +247,13 @@ async function applyFrontmatterRevert(action, frontmatterEntry) {
 }
 async function revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
+    const reservedTargetFailure = failReservedStateTarget(action, home);
+    if (reservedTargetFailure) {
+        if (reservedTargetFailure.outcome === "fail") {
+            logger.fail(label, reservedTargetFailure.error);
+        }
+        return reservedTargetFailure;
+    }
     try {
         await lstat(action.target);
     }
@@ -241,22 +301,9 @@ async function revertFrontmatterEmit(action, dryRun, verbose, home, planned, dep
 }
 async function executeRevertAction(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
-    try {
-        await lstat(action.target);
-    }
-    catch (err) {
-        const result = lstatOutcome(err);
-        if (result.outcome === "skip") {
-            logger.skip(label, "(not found, skipping)");
-            return result;
-        }
-        logger.fail(label, result.error);
-        return result;
-    }
-    const entry = await lookupDeployment(home, action.target, deps.registry);
-    if (!entry || entry.skill !== action.skill || entry.agent !== action.agent) {
-        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
-        return { outcome: "skip" };
+    const preflight = await preflightManagedSkillDirRevert(action, label, home, deps);
+    if (preflight) {
+        return preflight;
     }
     if (dryRun) {
         planned.push({
@@ -298,6 +345,13 @@ async function executeRevertAction(action, dryRun, verbose, home, planned, deps)
 }
 async function revertFileWrite(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
+    const reservedTargetFailure = failReservedStateTarget(action, home);
+    if (reservedTargetFailure) {
+        if (reservedTargetFailure.outcome === "fail") {
+            logger.fail(label, reservedTargetFailure.error);
+        }
+        return reservedTargetFailure;
+    }
     try {
         await lstat(action.target);
     }
@@ -349,6 +403,13 @@ async function revertFileWrite(action, dryRun, verbose, home, planned, deps) {
 }
 async function revertConfigPatch(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
+    const reservedTargetFailure = failReservedStateTarget(action, home);
+    if (reservedTargetFailure) {
+        if (reservedTargetFailure.outcome === "fail") {
+            logger.fail(label, reservedTargetFailure.error);
+        }
+        return reservedTargetFailure;
+    }
     try {
         await lstat(action.target);
     }
@@ -400,6 +461,13 @@ async function revertConfigPatch(action, dryRun, verbose, home, planned, deps) {
 }
 async function revertTomlPatch(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
+    const reservedTargetFailure = failReservedStateTarget(action, home);
+    if (reservedTargetFailure) {
+        if (reservedTargetFailure.outcome === "fail") {
+            logger.fail(label, reservedTargetFailure.error);
+        }
+        return reservedTargetFailure;
+    }
     try {
         await lstat(action.target);
     }

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

@@ -4,7 +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 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,9 +163,62 @@ 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.
+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();

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

@@ -81,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;
@@ -95,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<{
@@ -196,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;
@@ -239,6 +257,18 @@ export declare const ManifestSchema: 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>>>;
+    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>;
@@ -248,6 +278,7 @@ 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";

package/dist/src/schemas/manifest.js

@@ -92,7 +92,8 @@ export const McpServerEntrySchema = z.object({
         .enum(["global", "repo", "workspace", "devcontainer"])
         .default("global"),
 });
-export const AgentRuleEntrySchema = z.object({
+export const AgentRuleEntrySchema = z
+    .object({
     name: nameField,
     agents: agentsField,
     // Relative path to the rules/instruction file within the source bundle.
@@ -103,7 +104,33 @@ export const AgentRuleEntrySchema = z.object({
     // file (default), "repo" targets the project-root instruction file within the
     // deployed repository (e.g. {repo}/CLAUDE.md for claude-code), and "workspace"
     // targets the agent's workspace-local instruction surface.
-    scope: z.enum(["global", "repo", "workspace"]).default("global"),
+    // "copilot-repo" targets GitHub Copilot's native repo-level instruction file
+    // at {repo}/.github/copilot-instructions.md (github-copilot only).
+    // "copilot-scoped" targets {repo}/.github/instructions/{name}.instructions.md
+    // where {name} is the manifest entry name (github-copilot only).
+    scope: z
+        .enum(["global", "repo", "workspace", "copilot-repo", "copilot-scoped"])
+        .default("global"),
+    // Optional relative directory within the repo/workspace where the rule
+    // should be deployed. Only supported for scope: "repo" and scope: "workspace".
+    targetDir: z
+        .string()
+        .optional()
+        .refine((p) => !(p && nodePath.isAbsolute(p)), {
+        message: "targetDir must be a relative path",
+    })
+        .refine((p) => !(p && nodePath.normalize(p).startsWith("..")), {
+        message: "targetDir must not escape the target root",
+    }),
+})
+    .superRefine((data, ctx) => {
+    if (data.targetDir && data.scope !== "repo" && data.scope !== "workspace") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["targetDir"],
+            message: 'targetDir is only supported for scope "repo" or "workspace"',
+        });
+    }
 });
 export const PermissionsEntrySchema = z.object({
     name: nameField,
@@ -114,6 +141,13 @@ export const PermissionsEntrySchema = z.object({
     // For opencode: { permissions: { allow?: string[], ask?: string[], deny?: string[] } }
     config: z.record(z.string(), z.unknown()),
 });
+export const ExecutionConfigEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Raw execution config payload validated per agent by the execution-config adapter.
+    // For gemini-cli: { safeMode?: boolean, ... }
+    config: z.record(z.string(), z.unknown()),
+});
 export const AgentDefinitionEntrySchema = z.object({
     name: nameField,
     agents: agentsField,
@@ -130,7 +164,8 @@ 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.
+    // For claude-code: { hooks: { "<EventName>": [{ matcher?: string, hooks: [{ type: "command", command: string }] }] } }
+    // Event names follow Claude Code's settings.json hooks surface (e.g. PreToolUse, PostToolUse, Notification, Stop, SubagentStop).
     config: z.record(z.string(), z.unknown()),
 });
 export const ManifestSchema = z.object({
@@ -154,6 +189,7 @@ export const ManifestSchema = z.object({
     permissions: z.array(PermissionsEntrySchema).default([]),
     agentDefinitions: z.array(AgentDefinitionEntrySchema).default([]),
     hooks: z.array(HookEntrySchema).optional(),
+    executionConfigs: z.array(ExecutionConfigEntrySchema).optional(),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z