@kuznai/inception-engine 0.14.1 → 0.16.0

package/README.md

@@ -8,7 +8,7 @@ GitHub Copilot is no longer treated as a separate instruction or skill target in
 
 The broader portability layer is the roadmap direction, but this README focuses on what is working now.
 
-`init` is available as a bootstrap command, but what works today is intentionally narrow: it scans for directories containing `SKILL.md` and generates starter `skills` entries plus empty `mcpServers` and `agentRules` arrays. It does not infer `files`, `configs`, MCP server definitions, or rules files from the repository yet.
+`init` is available as a bootstrap command. It scans for directories containing `SKILL.md`, discovers agent-rules Markdown files using the Claude-first portability conventions, and reads `mcp-servers.json` from the repo root to populate `mcpServers`. `files` and `configs` remain empty — `init` emits guidance when it detects a `files/` or `configs/` directory.
 
 ## Quick Start
 
@@ -50,7 +50,8 @@ Managed skills overwrite their previous version. If a target exists but was not
 | Config patch (JSON merge) | All agents via manifest and CLI | All agents |
 | MCP Servers | claude-code, gemini-cli, codex, antigravity, opencode; github-copilot repo-scoped surfaces are warned and skipped | claude-code, gemini-cli, codex, antigravity, opencode |
 | Global/Repo Rules Files | All agents (antigravity uses repo-local `.agents/rules/`); github-copilot reads CLAUDE.md natively (deploy via claude-code) | All agents |
-| `init` manifest generation | Scans `SKILL.md` directories and writes starter `skills` entries | N/A |
+| Permissions / Approval Config | claude-code (`~/.claude/settings.json`), codex (`~/.codex/config.toml`); other agents are warned and skipped | claude-code, codex |
+| `init` manifest generation | Scans `SKILL.md` directories (`skills`), `.md` files with Claude-first agent mapping (`agentRules`), and `mcp-servers.json` (`mcpServers`); emits hints for `files/` and `configs/` directories | N/A |
 
 Features that depend on agent-specific config surfaces are intentionally conservative: if a target path or schema is not implemented with enough confidence, inception-engine warns and skips it rather than guessing.
 
@@ -98,6 +99,18 @@ Create an `inception.json` file at the root of your skills directory:
       "path": "rules/CLAUDE.md",
       "agents": ["claude-code"]
     }
+  ],
+  "permissions": [
+    {
+      "name": "safety-defaults",
+      "agents": ["claude-code"],
+      "config": {
+        "permissions": {
+          "allow": ["Read", "Glob"],
+          "deny": ["Bash(rm:*)"]
+        }
+      }
+    }
   ]
 }
 ```
@@ -145,6 +158,47 @@ Each **agentRules** entry deploys a Markdown instruction file to an agent's supp
 
 Instruction rule deployment is supported for all agents. For most agents, this targets a single global rules file (e.g., `~/.claude/CLAUDE.md` for `claude-code`, `~/.codex/AGENTS.md` for `codex`, `~/.gemini/GEMINI.md` for `gemini-cli`, and `~/.config/opencode/AGENTS.md` for `opencode`). For `antigravity`, inception-engine deploys to repo-local instruction surfaces at `{repo}/.agents/rules/{name}.md`. For `github-copilot`, no separate deployment is needed because Copilot reads `CLAUDE.md` natively — target it via the `claude-code` agentRules entry and it reaches Copilot automatically. Revert removes the deployed rules file.
 
+Each **permissions** entry deploys execution and safety-oriented configuration to an agent's permission or approval surface:
+
+- **name** - Unique identifier (same format as skill names)
+- **agents** - Array of agent IDs to deploy this entry to
+- **config** - Permission config payload; shape is validated per agent (see below)
+
+Permission deployment is currently supported for `claude-code` and `codex`. Other agents emit a warning and are skipped.
+
+For `claude-code`, the config is merged into `~/.claude/settings.json`. Only the `permissions` key is accepted:
+
+```json
+{
+  "name": "safety-defaults",
+  "agents": ["claude-code"],
+  "config": {
+    "permissions": {
+      "allow": ["Read", "Glob", "Bash(git:*)"],
+      "deny": ["Bash(rm:*)"]
+    }
+  }
+}
+```
+
+Both `allow` and `deny` are optional string arrays. Tool patterns follow Claude Code's permission glob syntax (e.g., `Bash(git:*)` to allow all git commands).
+
+For `codex`, the config is merged into `~/.codex/config.toml`. Only the `approval_policy` key is accepted:
+
+```json
+{
+  "name": "codex-approval",
+  "agents": ["codex"],
+  "config": {
+    "approval_policy": "suggest"
+  }
+}
+```
+
+Valid `approval_policy` values are `"auto"`, `"manual"`, `"suggest"`, and `"on-failure"`.
+
+Revert restores the previous config values using the undo patch recorded at deploy time.
+
 ## Creating Skills
 
 Each skill is a directory containing at minimum a `SKILL.md` file with YAML frontmatter:
@@ -164,7 +218,7 @@ The `name` and `description` fields in the frontmatter are used by most agents.
 
 ## `init` Command
 
-`init` is meant to bootstrap a repository that already has skill folders. It recursively scans the target directory, treats any directory containing `SKILL.md` as a skill, and writes a starter `inception.json`.
+`init` is meant to bootstrap a repository that already has skills and related manifest assets. It recursively scans the target directory, treats any directory containing `SKILL.md` as a skill, discovers supported instruction and MCP conventions, and writes a starter `inception.json`.
 
 Current `init` behavior:
 
@@ -173,12 +227,58 @@ Current `init` behavior:
 - Applies either the `--agents` list or all currently known agent IDs
 - Refuses to overwrite an existing `inception.json` unless `--force` is provided
 - Supports `--dry-run` so you can inspect the generated manifest before writing it
+- Discovers agent-rules Markdown files in the root and conventional subdirectories (`rules/`, `instructions/`, `.github/`, `.agents/rules/`), mapping them to agents using Claude-first portability conventions: `copilot-instructions.md` maps to `claude-code` (Copilot reads `CLAUDE.md` natively), and the fallback for unrecognized files excludes agents whose agentRules surface is unsupported
+- Reads `mcp-servers.json` from the repo root (if present) and generates `mcpServers` entries; invalid entries are warned and skipped
+- Reads `files-manifest.json` from the repo root (if present) and generates `files` entries; invalid entries are warned and skipped
+- Reads `configs-manifest.json` from the repo root (if present) and generates `configs` entries; invalid entries are warned and skipped
+- Emits guidance to create a sidecar manifest when a `files/` or `configs/` directory is detected but the corresponding sidecar file is absent
 
 Current `init` limitations:
 
 - It does not reconcile generated manifest entries against `SKILL.md` frontmatter values
-- It does not infer `files`, `configs`, `mcpServers`, or `agentRules`
-- It does not reconcile generated output with the longer-term Claude-first portability direction
+- `files` and `configs` target paths are deployment-system-specific and cannot be inferred; they must be provided explicitly in `files-manifest.json` and `configs-manifest.json`
+
+### Repo Conventions Recognized by `init`
+
+Place a `mcp-servers.json` file at the repo root to have `init` populate the `mcpServers` section automatically. The file must be a JSON array of MCP server entries using the same schema as the `mcpServers` field in `inception.json`:
+
+```json
+[
+  {
+    "name": "my-server",
+    "agents": ["claude-code", "gemini-cli"],
+    "config": { "command": "npx", "args": ["-y", "my-mcp-server"] }
+  }
+]
+```
+
+Place a `files-manifest.json` file at the repo root to have `init` populate the `files` section automatically. The file must be a JSON array of file entries using the same schema as the `files` field in `inception.json`:
+
+```json
+[
+  {
+    "name": "my-settings",
+    "path": "files/settings.json",
+    "target": "{home}/.claude/settings.json",
+    "agents": ["claude-code"]
+  }
+]
+```
+
+Place a `configs-manifest.json` file at the repo root to have `init` populate the `configs` section automatically. The file must be a JSON array of config entries using the same schema as the `configs` field in `inception.json`:
+
+```json
+[
+  {
+    "name": "enable-feature",
+    "target": "{home}/.claude/settings.json",
+    "patch": { "someFeature": true },
+    "agents": ["claude-code"]
+  }
+]
+```
+
+Invalid entries are warned and skipped; the rest are written into the generated manifest verbatim.
 
 ## CLI Reference
 

package/dist/config/agents.js

@@ -17,6 +17,7 @@ export const AGENT_REGISTRY = [
             detectBinary: "documented",
             mcpConfig: "documented",
             agentRules: "documented",
+            permissions: "documented",
         },
         mcpSupport: {
             status: "supported",
@@ -34,6 +35,14 @@ export const AGENT_REGISTRY = [
                 windows: ["{home}", ".claude", "CLAUDE.md"],
             },
         },
+        permissionsSupport: {
+            status: "supported",
+            schemaLabel: "JSON permissions config",
+            path: {
+                posix: ["{home}", ".claude", "settings.json"],
+                windows: ["{home}", ".claude", "settings.json"],
+            },
+        },
     },
     {
         id: "codex",
@@ -52,6 +61,7 @@ export const AGENT_REGISTRY = [
             detectPaths: "documented",
             detectBinary: "documented",
             agentRules: "documented",
+            permissions: "documented",
         },
         mcpSupport: {
             status: "supported",
@@ -69,6 +79,14 @@ export const AGENT_REGISTRY = [
                 windows: ["{home}", ".codex", "AGENTS.md"],
             },
         },
+        permissionsSupport: {
+            status: "supported",
+            schemaLabel: "TOML approval policy config",
+            path: {
+                posix: ["{home}", ".codex", "config.toml"],
+                windows: ["{home}", ".codex", "config.toml"],
+            },
+        },
     },
     {
         id: "gemini-cli",
@@ -105,6 +123,11 @@ export const AGENT_REGISTRY = [
                 windows: ["{home}", ".gemini", "GEMINI.md"],
             },
         },
+        permissionsSupport: {
+            status: "unsupported",
+            schemaLabel: "global permissions surface",
+            reason: "Gemini CLI does not expose a documented global per-user permission or approval config surface",
+        },
     },
     {
         id: "antigravity",
@@ -139,6 +162,11 @@ export const AGENT_REGISTRY = [
                 windows: ["{repo}", ".agents", "rules", "{name}.md"],
             },
         },
+        permissionsSupport: {
+            status: "unsupported",
+            schemaLabel: "global permissions surface",
+            reason: "Antigravity does not expose a documented global per-user permission or approval config surface",
+        },
     },
     {
         id: "opencode",
@@ -175,6 +203,11 @@ export const AGENT_REGISTRY = [
                 windows: ["{appdata}", "opencode", "AGENTS.md"],
             },
         },
+        permissionsSupport: {
+            status: "unsupported",
+            schemaLabel: "global permissions surface",
+            reason: "OpenCode does not expose a documented global per-user permission or approval config surface",
+        },
     },
     {
         id: "github-copilot",
@@ -203,6 +236,11 @@ export const AGENT_REGISTRY = [
             schemaLabel: "Claude-native shared instructions",
             reason: 'GitHub Copilot reads CLAUDE.md natively, so deploy via the "claude-code" agentRules target instead of a separate rules surface',
         },
+        permissionsSupport: {
+            status: "unsupported",
+            schemaLabel: "global permissions surface",
+            reason: "GitHub Copilot permissions are managed via organization policy, not a deployable per-user config surface",
+        },
         policyNote: "Organization policies may override locally deployed skills. Verify with your GitHub org admin if deployed skills are not active.",
     },
 ];

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

@@ -1,11 +1,12 @@
-import type { AgentRuleEntry, McpServerEntry } from "../../schemas/manifest.ts";
+import type { AgentRuleEntry, McpServerEntry, PermissionsEntry } from "../../schemas/manifest.ts";
 import type { AgentId, ConfigPatchDeployAction, FileWriteDeployAction, FrontmatterEmitDeployAction, PlanWarning, TomlPatchDeployAction } from "../../types.ts";
 import { compileMcpServerReverts } from "./mcp.ts";
+import { compilePermissionsReverts } from "./permissions.ts";
 import { compileAgentRuleReverts } from "./rules.ts";
-export { compileAgentRuleReverts, compileMcpServerReverts };
+export { compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, };
 export type AdapterAction = ConfigPatchDeployAction | FileWriteDeployAction | TomlPatchDeployAction | FrontmatterEmitDeployAction;
 export interface AdapterResult {
     actions: AdapterAction[];
     warnings: PlanWarning[];
 }
-export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string): Promise<AdapterResult>;
+export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], permissions: PermissionsEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string): Promise<AdapterResult>;

package/dist/core/adapters/index.js

@@ -1,7 +1,8 @@
 import { compileMcpServerActions, compileMcpServerReverts } from "./mcp.js";
+import { compilePermissionsActions, compilePermissionsReverts, } from "./permissions.js";
 import { compileAgentRuleActions, compileAgentRuleReverts } from "./rules.js";
-export { compileAgentRuleReverts, compileMcpServerReverts };
-export async function compileAdapterActions(mcpServers, agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo) {
+export { compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, };
+export async function compileAdapterActions(mcpServers, agentRules, permissions, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo) {
     const actions = [];
     const warnings = [];
     for (const entry of mcpServers) {
@@ -14,5 +15,10 @@ export async function compileAdapterActions(mcpServers, agentRules, sourceDir, r
         actions.push(...r.actions);
         warnings.push(...r.warnings);
     }
+    for (const entry of permissions) {
+        const r = compilePermissionsActions(entry, detectedAgents, home);
+        actions.push(...r.actions);
+        warnings.push(...r.warnings);
+    }
     return { actions, warnings };
 }

package/dist/core/adapters/permissions.d.ts

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

package/dist/core/adapters/permissions.js

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { AGENT_REGISTRY_BY_ID } from "../../config/agents.js";
+import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
+import { validatePermissionsConfigShape } from "../validation.js";
+function isTomlTarget(targetPath) {
+    return path.extname(targetPath).toLowerCase() === ".toml";
+}
+export function compilePermissionsActions(entry, detectedAgents, home) {
+    const actions = [];
+    const warnings = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (!detectedAgents.includes(agentId))
+            continue;
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        const support = agent?.permissionsSupport;
+        if (!support || support.status === "unsupported") {
+            warnings.push({
+                kind: "confidence",
+                message: `permissions: agent "${agentId}" ${support?.status === "unsupported" ? support.reason : "does not expose a supported permissions adapter"} — skipping "${entry.name}"`,
+            });
+            continue;
+        }
+        validatePermissionsConfigShape(entry.config, entry.name, agentId);
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home);
+        const resolvedTarget = path.resolve(rawTarget);
+        const confidence = agent.provenance.permissions ?? "provisional";
+        if (isTomlTarget(resolvedTarget)) {
+            actions.push({
+                kind: "toml-patch",
+                skill: entry.name,
+                agent: agentId,
+                target: resolvedTarget,
+                config: entry.config,
+                confidence,
+            });
+        }
+        else {
+            actions.push({
+                kind: "config-patch",
+                skill: entry.name,
+                agent: agentId,
+                target: resolvedTarget,
+                patch: entry.config,
+                confidence,
+            });
+        }
+    }
+    return { actions, warnings };
+}
+export function compilePermissionsReverts(entry, agentFilter, home) {
+    const actions = [];
+    const platform = getPlatformKey();
+    for (const agentId of entry.agents) {
+        if (agentFilter && !agentFilter.includes(agentId))
+            continue;
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        const support = agent?.permissionsSupport;
+        if (!support || support.status === "unsupported")
+            continue;
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home);
+        const target = path.resolve(rawTarget);
+        if (isTomlTarget(target)) {
+            actions.push({
+                kind: "toml-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+        else {
+            actions.push({
+                kind: "config-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+    }
+    return actions;
+}

package/dist/core/deploy.js

@@ -192,7 +192,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);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...detectAmbiguities(detectedAgents, manifest),

package/dist/core/init.js

@@ -1,7 +1,8 @@
-import { access, readdir, writeFile } from "node:fs/promises";
+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 } from "../schemas/manifest.js";
+import { AGENT_IDS, 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 = [
@@ -17,7 +18,7 @@ const AGENT_RULES_FILE_PATTERNS = [
         fileNames: ["gemini.md", "gemini-instructions.md"],
         agents: ["gemini-cli", "antigravity"],
     },
-    { fileNames: ["copilot-instructions.md"], agents: ["github-copilot"] },
+    { fileNames: ["copilot-instructions.md"], agents: ["claude-code"] },
 ];
 // Conventional subdirectory names to scan one level deep for .md files.
 const AGENT_RULES_SUBDIRS = [
@@ -142,6 +143,9 @@ function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
         // 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)
+        if (agents.length === 0)
+            continue;
         // Resolve name collision with skill names
         let name = rawName;
         if (namesSeen.has(name)) {
@@ -160,6 +164,121 @@ function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
     }
     return rules;
 }
+async function loadMcpServers(baseDir) {
+    const filePath = path.join(baseDir, "mcp-servers.json");
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn("init", "mcp-servers.json: invalid JSON, skipping");
+        return [];
+    }
+    if (!Array.isArray(parsed)) {
+        logger.warn("init", "mcp-servers.json: expected a JSON array, skipping");
+        return [];
+    }
+    const results = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const result = McpServerEntrySchema.safeParse(parsed[i]);
+        if (result.success) {
+            results.push(result.data);
+        }
+        else {
+            logger.warn("init", `mcp-servers.json: entry[${i}] invalid, skipping`);
+        }
+    }
+    return results;
+}
+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 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));
+            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
+        }
+    }
+}
 async function manifestExists(manifestPath) {
     try {
         await access(manifestPath);
@@ -169,9 +288,39 @@ async function manifestExists(manifestPath) {
         return false;
     }
 }
+function logVerboseManifest(skills, agentRules, mcpServers, files, configs) {
+    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(", ")}]`);
+        }
+    }
+    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;
     const agents = options.agents ?? [...AGENT_IDS];
+    const agentRulesCapableAgents = agents.filter((id) => AGENT_REGISTRY_BY_ID[id].agentRulesSupport?.status !== "unsupported");
     const manifestPath = path.join(directory, "inception.json");
     if (!dryRun && (await manifestExists(manifestPath)) && !force) {
         logger.error(`Error: ${manifestPath} already exists. Use --force to overwrite.`);
@@ -186,33 +335,40 @@ 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, agents, skillNamesSeen);
+    const agentRules = buildAgentRules(agentRulesCandidates, agentRulesCapableAgents, skillNamesSeen);
+    const mcpServers = await loadMcpServers(directory);
+    const files = await loadFilesManifest(directory);
+    const configs = await loadConfigsManifest(directory);
     const manifest = {
         skills,
-        files: [],
-        configs: [],
-        mcpServers: [],
+        files,
+        configs,
+        mcpServers,
         agentRules,
     };
     const json = `${JSON.stringify(manifest, null, 2)}\n`;
+    function summarize() {
+        const parts = [
+            `${skills.length} skill(s)`,
+            `${agentRules.length} agentRule(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) and ${agentRules.length} agentRule(s):`);
+        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${summarize()}:`);
         logger.info("");
         logger.info(json);
+        await emitDirectoryHints(directory, files.length, configs.length);
         return 0;
     }
     await writeFile(manifestPath, json, "utf-8");
-    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s) and ${agentRules.length} agentRule(s).`);
+    logger.info(`Generated ${manifestPath} with ${summarize()}.`);
     if (verbose) {
-        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(", ")}]`);
-            }
-        }
+        logVerboseManifest(skills, agentRules, mcpServers, files, configs);
     }
+    await emitDirectoryHints(directory, files.length, configs.length);
     return 0;
 }

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 { compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
@@ -70,6 +70,7 @@ 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)),
     ];
 }
 export function planRevertAll(manifest, home, repo) {
@@ -79,6 +80,7 @@ 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)),
     ];
 }
 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,18 @@ 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 ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -135,12 +147,25 @@ 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>>>;
 }, 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 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,14 @@ 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 ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
         const seen = new Set();
@@ -108,6 +116,7 @@ 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([]),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/types.d.ts

@@ -23,6 +23,7 @@ export interface AgentProvenance {
     detectBinary: Confidence;
     mcpConfig?: Confidence;
     agentRules?: Confidence;
+    permissions?: Confidence;
 }
 export interface AgentConfig {
     id: AgentId;
@@ -33,6 +34,7 @@ export interface AgentConfig {
     provenance: AgentProvenance;
     mcpSupport?: AgentSurfaceSupport;
     agentRulesSupport?: AgentSurfaceSupport;
+    permissionsSupport?: AgentSurfaceSupport;
     policyNote?: string;
 }
 export interface PlanWarning {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",