@kuznai/inception-engine 0.15.0 → 0.17.0

package/dist/core/adapters/rules.js

@@ -21,6 +21,13 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
             });
             continue;
         }
+        if (support.status === "planned") {
+            warnings.push({
+                kind: "confidence",
+                message: `agentRules: agent "${agentId}" rules support is planned via ${support.plannedSurface} — skipping "${entry.name}" until that surface is implemented`,
+            });
+            continue;
+        }
         supportedTargets.push({
             agentId,
             confidence: agent.provenance.agentRules ?? "provisional",
@@ -56,7 +63,9 @@ export function compileAgentRuleReverts(entry, agentFilter, home, repo) {
             continue;
         const agent = AGENT_REGISTRY_BY_ID[agentId];
         const support = agent?.agentRulesSupport;
-        if (!support || support.status === "unsupported")
+        if (!support ||
+            support.status === "unsupported" ||
+            support.status === "planned")
             continue;
         const target = resolvePlaceholders(support.path[platform], entry.name, home, repo);
         actions.push({

package/dist/core/deploy.js

@@ -91,7 +91,7 @@ function detectAmbiguities(detectedAgents, manifest) {
         if (bothAgents(entry.agents)) {
             warnings.push({
                 kind: "ambiguity",
-                message: `Both "gemini-cli" and "antigravity" are listed in agentRules entry "${entry.name}". They share a GEMINI.md-backed instruction shared surface — verify that deploying to both does not create conflicting behavior.`,
+                message: `Both "gemini-cli" and "antigravity" are listed in agentRules entry "${entry.name}". They write to distinct surfaces ("gemini-cli" → ~/.gemini/GEMINI.md, "antigravity" → {repo}/.agents/rules/${entry.name}.md) from the same source file — verify that deploying to both produces the intended behavior on each agent.`,
             });
         }
     }
@@ -119,6 +119,8 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
+            if (!agent.skills)
+                continue;
             actions.push({
                 kind: "skill-dir",
                 skill: skill.name,
@@ -126,7 +128,7 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
                 source,
                 target: resolveAgentSkillPath(agent, skill.name, home),
                 method,
-                confidence: agent.provenance.skills,
+                confidence: agent.provenance.skills ?? "provisional",
             });
         }
     }
@@ -192,7 +194,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
         ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
         ...planConfigPatchActions(manifest, detectedAgents, home),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, undefined, manifest.agentDefinitions ?? []);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...detectAmbiguities(detectedAgents, manifest),

package/dist/core/init.js

@@ -2,7 +2,7 @@ import { access, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { dryRunPrefix, logger } from "../logger.js";
-import { AGENT_IDS, McpServerEntrySchema } from "../schemas/manifest.js";
+import { AGENT_IDS, AgentDefinitionEntrySchema, ConfigEntrySchema, FileEntrySchema, McpServerEntrySchema, } from "../schemas/manifest.js";
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 // Ordered list: first match wins. Catch-all is applied at call site.
 const AGENT_RULES_FILE_PATTERNS = [
@@ -27,6 +27,16 @@ const AGENT_RULES_SUBDIRS = [
     ".github",
     ".agents/rules",
 ];
+// Conventional subdirectories that contain agent definition files.
+// These are the agent-specific directories that each agent scans for
+// subagent/persona definitions at runtime.
+const AGENT_DEFINITION_SUBDIRS = [
+    ".claude/agents",
+    ".gemini/agents",
+    ".agents/rules",
+    ".opencode/agents",
+    ".github/agents",
+];
 async function findSkillDirs(baseDir, dir, found) {
     let entries;
     try {
@@ -164,6 +174,117 @@ function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
     }
     return rules;
 }
+/**
+ * Derives the name for an agent definition entry from its file name.
+ * For GitHub Copilot's `{name}.agent.md` naming convention, strips the
+ * `.agent` infix in addition to the `.md` extension.
+ */
+function deriveAgentDefinitionName(relPath, fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    // Strip the extension to get the base name, then strip any trailing ".agent"
+    // suffix (GitHub Copilot convention: foo.agent.md → foo).
+    let baseName = path.basename(fileName, ext);
+    if (baseName.endsWith(".agent")) {
+        baseName = baseName.slice(0, -".agent".length);
+    }
+    const rawName = baseName.toLowerCase().replace(/[^a-zA-Z0-9._-]/g, "-");
+    if (!SAFE_NAME_RE.test(rawName)) {
+        logger.warn("init", `Skipping "${relPath}": could not derive a valid agentDefinitions name`);
+        return null;
+    }
+    return rawName;
+}
+/**
+ * Maps a known agent-definition subdirectory to the agent IDs that own it.
+ * Returns null when the subdir is not agent-specific (fall back to all agents
+ * that support agentDefinitions).
+ */
+function agentsForDefinitionSubdir(subdir) {
+    switch (subdir) {
+        case ".claude/agents":
+            return ["claude-code"];
+        case ".gemini/agents":
+            return ["gemini-cli"];
+        case ".agents/rules":
+            return ["antigravity"];
+        case ".opencode/agents":
+            return ["opencode"];
+        case ".github/agents":
+            return ["github-copilot"];
+        default:
+            return null;
+    }
+}
+async function scanDefinitionSubdir(subdir, baseDir, seen, skillDirRelPaths, agentRulesRelPaths, candidates) {
+    const suggestedAgents = agentsForDefinitionSubdir(subdir) ?? [];
+    const dir = path.join(baseDir, subdir);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (ext !== ".md" && ext !== ".markdown")
+            continue;
+        const absPath = path.join(dir, entry.name);
+        const relPath = path.relative(baseDir, absPath).split(path.sep).join("/");
+        if (seen.has(relPath) ||
+            isInsideSkillDir(relPath, skillDirRelPaths) ||
+            agentRulesRelPaths.has(relPath))
+            continue;
+        const name = deriveAgentDefinitionName(relPath, entry.name);
+        if (name === null)
+            continue;
+        seen.add(relPath);
+        candidates.push({ relPath, name, suggestedAgents });
+    }
+}
+async function findAgentDefinitionCandidates(baseDir, skillDirRelPaths, agentRulesRelPaths) {
+    const candidates = [];
+    const seen = new Set();
+    for (const subdir of AGENT_DEFINITION_SUBDIRS) {
+        await scanDefinitionSubdir(subdir, baseDir, seen, skillDirRelPaths, agentRulesRelPaths, candidates);
+    }
+    return candidates;
+}
+function buildAgentDefinitions(candidates, activeAgents, namesSeen) {
+    const definitions = [];
+    const localNamesSeen = new Set(namesSeen);
+    const definitionsCapableAgents = activeAgents.filter((id) => AGENT_REGISTRY_BY_ID[id].agentDefinitionsSupport?.status !==
+        "unsupported");
+    for (const { relPath, name: rawName, suggestedAgents } of candidates) {
+        // Use suggested agents (from the dir that was scanned), intersected with
+        // active agents that support agentDefinitions. Fall back to all capable
+        // agents if the intersection is empty.
+        const intersection = suggestedAgents.length > 0
+            ? suggestedAgents.filter((a) => definitionsCapableAgents.includes(a))
+            : [];
+        const agents = intersection.length > 0 ? intersection : definitionsCapableAgents;
+        if (agents.length === 0)
+            continue;
+        // Resolve name collision
+        let name = rawName;
+        if (localNamesSeen.has(name)) {
+            const candidate = `${name}-agent`;
+            if (SAFE_NAME_RE.test(candidate)) {
+                logger.warn("init", `agentDefinitions name "${name}" collides with an existing name; using "${candidate}"`);
+                name = candidate;
+            }
+            else {
+                logger.warn("init", `Skipping "${relPath}": name "${name}" collides and fallback is invalid`);
+                continue;
+            }
+        }
+        localNamesSeen.add(name);
+        definitions.push({ name, path: relPath, agents });
+    }
+    return definitions;
+}
 async function loadMcpServers(baseDir) {
     const filePath = path.join(baseDir, "mcp-servers.json");
     let raw;
@@ -197,14 +318,115 @@ async function loadMcpServers(baseDir) {
     }
     return results;
 }
-async function emitDirectoryHints(baseDir) {
-    for (const [dir, section] of [
-        ["files", "files"],
-        ["configs", "configs"],
+async function loadFilesManifest(baseDir) {
+    const filePath = path.join(baseDir, "files-manifest.json");
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn("init", "files-manifest.json: invalid JSON, skipping");
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        logger.warn("init", "files-manifest.json: expected a JSON array, skipping");
+        return [];
+    }
+    const results = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const result = FileEntrySchema.safeParse(parsed[i]);
+        if (result.success) {
+            results.push(result.data);
+        }
+        else {
+            logger.warn("init", `files-manifest.json: entry[${i}] invalid, skipping`);
+        }
+    }
+    return results;
+}
+async function loadConfigsManifest(baseDir) {
+    const filePath = path.join(baseDir, "configs-manifest.json");
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn("init", "configs-manifest.json: invalid JSON, skipping");
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        logger.warn("init", "configs-manifest.json: expected a JSON array, skipping");
+        return [];
+    }
+    const results = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const result = ConfigEntrySchema.safeParse(parsed[i]);
+        if (result.success) {
+            results.push(result.data);
+        }
+        else {
+            logger.warn("init", `configs-manifest.json: entry[${i}] invalid, skipping`);
+        }
+    }
+    return results;
+}
+async function loadAgentDefinitionsManifest(baseDir) {
+    const filePath = path.join(baseDir, "agent-definitions-manifest.json");
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn("init", "agent-definitions-manifest.json: invalid JSON, skipping");
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        logger.warn("init", "agent-definitions-manifest.json: expected a JSON array, skipping");
+        return [];
+    }
+    const results = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const result = AgentDefinitionEntrySchema.safeParse(parsed[i]);
+        if (result.success) {
+            results.push(result.data);
+        }
+        else {
+            logger.warn("init", `agent-definitions-manifest.json: entry[${i}] invalid, skipping`);
+        }
+    }
+    return results;
+}
+async function emitDirectoryHints(baseDir, filesLoaded, configsLoaded) {
+    for (const [dir, section, loaded, sidecar] of [
+        ["files", "files", filesLoaded, "files-manifest.json"],
+        ["configs", "configs", configsLoaded, "configs-manifest.json"],
     ]) {
         try {
             await access(path.join(baseDir, dir));
-            logger.info(`Detected ${dir}/ directory — add ${section} entries manually to the generated manifest with target paths.`);
+            if (loaded === 0) {
+                logger.info(`Detected ${dir}/ directory — create ${sidecar} at the repo root to have init populate ${section} entries automatically.`);
+            }
         }
         catch {
             // directory does not exist — silent
@@ -220,22 +442,38 @@ async function manifestExists(manifestPath) {
         return false;
     }
 }
-function logVerboseManifest(skills, agentRules, mcpServers) {
+function logPathAgentEntries(label, entries) {
+    if (entries.length === 0)
+        return;
+    logger.detail(`${label}:`);
+    for (const e of entries) {
+        logger.detail(`  ${e.name}  →  ${e.path}  [${e.agents.join(", ")}]`);
+    }
+}
+function logVerboseManifest(skills, agentRules, mcpServers, files, configs, agentDefinitions) {
     for (const s of skills) {
         logger.detail(`${s.name}  →  ${s.path}`);
     }
-    if (agentRules.length > 0) {
-        logger.detail("agentRules:");
-        for (const r of agentRules) {
-            logger.detail(`  ${r.name}  →  ${r.path}  [${r.agents.join(", ")}]`);
-        }
-    }
+    logPathAgentEntries("agentRules", agentRules);
+    logPathAgentEntries("agentDefinitions", agentDefinitions);
     if (mcpServers.length > 0) {
         logger.detail("mcpServers:");
         for (const m of mcpServers) {
             logger.detail(`  ${m.name}  [${m.agents.join(", ")}]`);
         }
     }
+    if (files.length > 0) {
+        logger.detail("files:");
+        for (const f of files) {
+            logger.detail(`  ${f.name}  →  ${f.target}  [${f.agents.join(", ")}]`);
+        }
+    }
+    if (configs.length > 0) {
+        logger.detail("configs:");
+        for (const c of configs) {
+            logger.detail(`  ${c.name}  →  ${c.target}  [${c.agents.join(", ")}]`);
+        }
+    }
 }
 export async function runInit(options) {
     const { directory, dryRun, force, verbose } = options;
@@ -256,27 +494,51 @@ export async function runInit(options) {
     const skillDirRelPaths = new Set(found.map((f) => f.relPath));
     const agentRulesCandidates = await findAgentRulesCandidates(directory, skillDirRelPaths);
     const agentRules = buildAgentRules(agentRulesCandidates, agentRulesCapableAgents, skillNamesSeen);
+    const allNamesSeen = new Set([
+        ...skillNamesSeen,
+        ...agentRules.map((r) => r.name),
+    ]);
+    const agentRulesRelPaths = new Set(agentRules.map((r) => r.path));
+    const agentDefinitionCandidates = await findAgentDefinitionCandidates(directory, skillDirRelPaths, agentRulesRelPaths);
+    const discoveredDefinitions = buildAgentDefinitions(agentDefinitionCandidates, agents, allNamesSeen);
+    // Sidecar file overrides take precedence over auto-discovery
+    const sidecarDefinitions = await loadAgentDefinitionsManifest(directory);
+    const agentDefinitions = sidecarDefinitions.length > 0 ? sidecarDefinitions : discoveredDefinitions;
     const mcpServers = await loadMcpServers(directory);
+    const files = await loadFilesManifest(directory);
+    const configs = await loadConfigsManifest(directory);
     const manifest = {
         skills,
-        files: [],
-        configs: [],
+        files,
+        configs,
         mcpServers,
         agentRules,
+        agentDefinitions,
     };
     const json = `${JSON.stringify(manifest, null, 2)}\n`;
+    function summarize() {
+        const parts = [
+            `${skills.length} skill(s)`,
+            `${agentRules.length} agentRule(s)`,
+            `${agentDefinitions.length} agentDefinition(s)`,
+            `${mcpServers.length} mcpServer(s)`,
+            `${files.length} file(s)`,
+            `${configs.length} config(s)`,
+        ];
+        return parts.join(", ");
+    }
     if (dryRun) {
-        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${skills.length} skill(s), ${agentRules.length} agentRule(s), and ${mcpServers.length} mcpServer(s):`);
+        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${summarize()}:`);
         logger.info("");
         logger.info(json);
-        await emitDirectoryHints(directory);
+        await emitDirectoryHints(directory, files.length, configs.length);
         return 0;
     }
     await writeFile(manifestPath, json, "utf-8");
-    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s), ${agentRules.length} agentRule(s), and ${mcpServers.length} mcpServer(s).`);
+    logger.info(`Generated ${manifestPath} with ${summarize()}.`);
     if (verbose) {
-        logVerboseManifest(skills, agentRules, mcpServers);
+        logVerboseManifest(skills, agentRules, mcpServers, files, configs, agentDefinitions);
     }
-    await emitDirectoryHints(directory);
+    await emitDirectoryHints(directory, files.length, configs.length);
     return 0;
 }

package/dist/core/resolve.js

@@ -85,6 +85,10 @@ export function getDeployMethod() {
     return process.platform === "win32" ? "copy" : "symlink";
 }
 export function resolveAgentSkillPathFor(agent, skillName, home, platform) {
+    if (!agent.skills) {
+        throw new Error(`Agent "${agent.id}" does not have a skills deployment path. ` +
+            `Deploy skills via another agent target that covers this agent natively (e.g. claude-code for github-copilot).`);
+    }
     return resolvePlaceholders(agent.skills[platform], skillName, home);
 }
 export function resolveAgentDetectPathFor(agent, home, platform) {

package/dist/core/revert.js

@@ -1,7 +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 { compileAgentRuleReverts, compileMcpServerReverts, } from "./adapters/index.js";
+import { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
@@ -15,6 +15,8 @@ function buildSkillDirReverts(manifest, home, agentFilter) {
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
+            if (!agent.skills)
+                continue;
             actions.push({
                 kind: "skill-dir",
                 skill: skill.name,
@@ -70,6 +72,8 @@ export function planRevert(manifest, detectedAgents, home, repo) {
         ...buildConfigPatchReverts(manifest, home, detectedAgents),
         ...(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.agentDefinitions ?? []).flatMap((e) => compileAgentDefinitionReverts(e, detectedAgents, home, repo)),
     ];
 }
 export function planRevertAll(manifest, home, repo) {
@@ -79,6 +83,8 @@ export function planRevertAll(manifest, home, repo) {
         ...buildConfigPatchReverts(manifest, home, null),
         ...(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.agentDefinitions ?? []).flatMap((e) => compileAgentDefinitionReverts(e, null, home, repo)),
     ];
 }
 function recordOutcome(result, action, counts, failed) {

package/dist/core/validation.d.ts

@@ -2,5 +2,6 @@ export declare function sourceAccessError(err: unknown, sourcePath: string): str
 export declare function validateSourcePath(source: string, skillPath: string, resolvedSourceDir: string, realRoot: string): Promise<void>;
 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 validateAgentRuleMarkdownPath(manifestPath: string, agentId: string): void;
 export declare function validateSkillDefinitionFile(sourcePath: string, manifestPath: string): Promise<void>;

package/dist/core/validation.js

@@ -96,6 +96,51 @@ export function validateMcpServerConfigShape(config, entryName, agentId) {
         throw new UserError("DEPLOY_FAILED", `mcpServers entry "${entryName}" for agent "${agentId}" must define "env" as an object of string values when present`);
     }
 }
+const CODEX_APPROVAL_POLICY_VALUES = [
+    "auto",
+    "manual",
+    "suggest",
+    "on-failure",
+];
+function rejectUnknownKeys(config, allowed, entryName, agentId) {
+    const unknownKeys = Object.keys(config).filter((k) => !allowed.includes(k));
+    if (unknownKeys.length > 0) {
+        throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "${agentId}" contains unrecognized keys: ${unknownKeys.join(", ")}. Only ${allowed.map((k) => `"${k}"`).join(", ")} is allowed.`);
+    }
+}
+function validateClaudeCodePermissions(config, entryName) {
+    rejectUnknownKeys(config, ["permissions"], entryName, "claude-code");
+    const perms = config.permissions;
+    if (perms === undefined)
+        return;
+    if (typeof perms !== "object" || perms === null || Array.isArray(perms)) {
+        throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "claude-code" must define "permissions" as an object`);
+    }
+    const permsObj = perms;
+    for (const key of ["allow", "deny"]) {
+        const val = permsObj[key];
+        if (val !== undefined &&
+            (!Array.isArray(val) || val.some((item) => typeof item !== "string"))) {
+            throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "claude-code" must define "permissions.${key}" as an array of strings when present`);
+        }
+    }
+}
+function validateCodexPermissions(config, entryName) {
+    rejectUnknownKeys(config, ["approval_policy"], entryName, "codex");
+    const policy = config.approval_policy;
+    if (policy !== undefined &&
+        !CODEX_APPROVAL_POLICY_VALUES.includes(policy)) {
+        throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "codex" must define "approval_policy" as one of: ${CODEX_APPROVAL_POLICY_VALUES.join(", ")}`);
+    }
+}
+export function validatePermissionsConfigShape(config, entryName, agentId) {
+    if (agentId === "claude-code") {
+        validateClaudeCodePermissions(config, entryName);
+    }
+    else if (agentId === "codex") {
+        validateCodexPermissions(config, entryName);
+    }
+}
 export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
     const extension = path.extname(manifestPath).toLowerCase();
     if (extension !== ".md" && extension !== ".markdown") {

package/dist/schemas/manifest.d.ts

@@ -72,6 +72,30 @@ export declare const AgentRuleEntrySchema: z.ZodObject<{
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     path: z.ZodString;
 }, z.core.$strip>;
+export declare const PermissionsEntrySchema: 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<{
+        "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")[]>>;
+    path: z.ZodString;
+}, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -135,12 +159,38 @@ 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")[]>>;
         path: z.ZodString;
     }, z.core.$strip>>>;
+    permissions: z.ZodDefault<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>>>;
+    agentDefinitions: z.ZodDefault<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")[]>>;
+        path: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;
 export type FileEntry = z.infer<typeof FileEntrySchema>;
 export type ConfigEntry = z.infer<typeof ConfigEntrySchema>;
 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 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/schemas/manifest.js

@@ -90,6 +90,22 @@ export const AgentRuleEntrySchema = z.object({
     // Relative path to the rules/instruction file within the source bundle.
     path: sourcePathField,
 });
+export const PermissionsEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Raw permission config payload validated per agent by the permissions adapter.
+    // For claude-code: { permissions: { allow?: string[], deny?: string[] } }
+    // For codex: { approval_policy?: "auto" | "manual" | "suggest" | "on-failure" }
+    config: z.record(z.string(), z.unknown()),
+});
+export const AgentDefinitionEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Relative path to the agent definition Markdown file within the source bundle.
+    // Must be a .md or .markdown file containing YAML frontmatter that describes
+    // the agent's persona, instructions, and any tool configuration.
+    path: sourcePathField,
+});
 export const ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
         const seen = new Set();
@@ -108,6 +124,8 @@ export const ManifestSchema = z.object({
     configs: z.array(ConfigEntrySchema).default([]),
     mcpServers: z.array(McpServerEntrySchema).default([]),
     agentRules: z.array(AgentRuleEntrySchema).default([]),
+    permissions: z.array(PermissionsEntrySchema).default([]),
+    agentDefinitions: z.array(AgentDefinitionEntrySchema).default([]),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z