@kuznai/inception-engine 0.6.2 → 0.8.0

package/dist/core/ownership.d.ts

@@ -1,12 +1,24 @@
-import { type RegistryEntry } from "../schemas/registry.ts";
+import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, type RegistryEntry, type SkillDirRegistryEntry } from "../schemas/registry.ts";
 import type { AgentId } from "../types.ts";
 export type { RegistryEntry } from "../schemas/registry.ts";
-export declare function registryPath(home: string): string;
-export declare function registerDeployment(home: string, targetPath: string, entry: Omit<RegistryEntry, "deployed">): Promise<void>;
-export declare function unregisterDeployment(home: string, targetPath: string): Promise<void>;
-export declare function lookupDeployment(home: string, targetPath: string): Promise<RegistryEntry | null>;
-export declare function verifyDeployment(home: string, targetPath: string, expected: {
+export type VerifyExpected = {
+    kind: "skill-dir";
+    source: string;
+    skill: string;
+    agent: AgentId;
+} | {
+    kind: "file-write";
     source: string;
     skill: string;
     agent: AgentId;
-}): Promise<RegistryEntry | null>;
+} | {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+};
+export declare function registryPath(home: string): string;
+export type RegisterEntry = Omit<SkillDirRegistryEntry, "deployed"> | Omit<FileWriteRegistryEntry, "deployed"> | Omit<ConfigPatchRegistryEntry, "deployed">;
+export declare function registerDeployment(home: string, targetPath: string, entry: RegisterEntry): Promise<void>;
+export declare function unregisterDeployment(home: string, targetPath: string): Promise<void>;
+export declare function lookupDeployment(home: string, targetPath: string): Promise<RegistryEntry | null>;
+export declare function verifyDeployment(home: string, targetPath: string, expected: VerifyExpected): Promise<RegistryEntry | null>;

package/dist/core/ownership.js

@@ -59,9 +59,15 @@ export async function verifyDeployment(home, targetPath, expected) {
     const entry = await lookupDeployment(home, targetPath);
     if (!entry)
         return null;
-    if (entry.source !== expected.source ||
-        entry.skill !== expected.skill ||
-        entry.agent !== expected.agent) {
+    if (entry.kind !== expected.kind)
+        return null;
+    if (entry.skill !== expected.skill)
+        return null;
+    if (entry.agent !== expected.agent)
+        return null;
+    if ((expected.kind === "skill-dir" || expected.kind === "file-write") &&
+        (entry.kind === "skill-dir" || entry.kind === "file-write") &&
+        entry.source !== expected.source) {
         return null;
     }
     return entry;

package/dist/core/preflight.d.ts

@@ -1,6 +1,6 @@
-import type { CliOptions, Manifest } from "../types.ts";
+import type { AgentId, CliOptions, Manifest } from "../types.ts";
 export interface PreflightWarning {
     kind: "policy" | "config-authority" | "info";
     message: string;
 }
-export declare function runPreflight(_options: CliOptions, _manifest: Manifest, _home: string): Promise<PreflightWarning[]>;
+export declare function runPreflight(_options: CliOptions, _manifest: Manifest, _home: string, detectedAgents: AgentId[]): Promise<PreflightWarning[]>;

package/dist/core/preflight.js

@@ -1,6 +1,28 @@
-export async function runPreflight(_options, _manifest, _home) {
-    // Extension point for future enterprise policy checks.
-    // Future additions: check for local-config overrides, policy files,
-    // agent version constraints, etc.
-    return [];
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+export async function runPreflight(_options, _manifest, _home, detectedAgents) {
+    const warnings = [];
+    for (const agentId of detectedAgents) {
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        if (!agent)
+            continue;
+        if (agent.provenance.skills === "implementation-only") {
+            warnings.push({
+                kind: "config-authority",
+                message: `Agent "${agentId}" skill support is implementation-only: paths are derived from source inspection, not published documentation.`,
+            });
+        }
+        else if (agent.provenance.skills === "provisional") {
+            warnings.push({
+                kind: "config-authority",
+                message: `Agent "${agentId}" skill support is provisional: behavior has not been independently verified.`,
+            });
+        }
+        if (agent.policyNote) {
+            warnings.push({
+                kind: "policy",
+                message: `Agent "${agentId}": ${agent.policyNote}`,
+            });
+        }
+    }
+    return warnings;
 }

package/dist/core/revert.d.ts

@@ -1,4 +1,4 @@
-import type { AgentId, Manifest, RevertAction } from "../types.ts";
+import type { AgentId, Manifest, PlannedChange, RevertAction } from "../types.ts";
 export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string): RevertAction[];
 export declare function planRevertAll(manifest: Manifest, home: string): RevertAction[];
 export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean, home: string): Promise<{
@@ -8,4 +8,5 @@ export declare function executeRevert(actions: RevertAction[], dryRun: boolean,
         action: RevertAction;
         error: string;
     }>;
+    planned: PlannedChange[];
 }>;

package/dist/core/revert.js

@@ -1,46 +1,126 @@
-import { lstat, rm, unlink } from "node:fs/promises";
+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 { lookupDeployment, unregisterDeployment } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
-export function planRevert(manifest, detectedAgents, home) {
+function resolveTargetTemplate(template, home) {
+    const appdata = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    const xdgRaw = process.env.XDG_CONFIG_HOME;
+    const xdgConfig = xdgRaw && path.isAbsolute(xdgRaw) ? xdgRaw : path.join(home, ".config");
+    return template
+        .replace("{home}", home)
+        .replace("{appdata}", appdata)
+        .replace("{xdg_config}", xdgConfig);
+}
+function buildSkillDirReverts(manifest, home, agentFilter) {
     const actions = [];
     for (const skill of manifest.skills) {
         for (const agentId of skill.agents) {
-            if (!detectedAgents.includes(agentId))
+            if (agentFilter && !agentFilter.includes(agentId))
                 continue;
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
-            const target = resolveAgentSkillPath(agent, skill.name, home);
             actions.push({
                 kind: "skill-dir",
                 skill: skill.name,
                 agent: agentId,
-                target,
+                target: resolveAgentSkillPath(agent, skill.name, home),
             });
         }
     }
     return actions;
 }
-export function planRevertAll(manifest, home) {
+function buildFileWriteReverts(manifest, home, agentFilter) {
     const actions = [];
-    for (const skill of manifest.skills) {
-        for (const agentId of skill.agents) {
+    for (const fileEntry of manifest.files ?? []) {
+        for (const agentId of fileEntry.agents) {
+            if (agentFilter && !agentFilter.includes(agentId))
+                continue;
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
-            const target = resolveAgentSkillPath(agent, skill.name, home);
             actions.push({
-                kind: "skill-dir",
-                skill: skill.name,
+                kind: "file-write",
+                skill: fileEntry.name,
+                agent: agentId,
+                target: resolveTargetTemplate(fileEntry.target, home),
+            });
+        }
+    }
+    return actions;
+}
+function buildConfigPatchReverts(manifest, home, agentFilter) {
+    const actions = [];
+    for (const configEntry of manifest.configs ?? []) {
+        for (const agentId of configEntry.agents) {
+            if (agentFilter && !agentFilter.includes(agentId))
+                continue;
+            const agent = AGENT_REGISTRY_BY_ID[agentId];
+            if (!agent)
+                continue;
+            actions.push({
+                kind: "config-patch",
+                skill: configEntry.name,
                 agent: agentId,
-                target,
+                target: resolveTargetTemplate(configEntry.target, home),
             });
         }
     }
     return actions;
 }
+export function planRevert(manifest, detectedAgents, home) {
+    return [
+        ...buildSkillDirReverts(manifest, home, detectedAgents),
+        ...buildFileWriteReverts(manifest, home, detectedAgents),
+        ...buildConfigPatchReverts(manifest, home, detectedAgents),
+    ];
+}
+export function planRevertAll(manifest, home) {
+    return [
+        ...buildSkillDirReverts(manifest, home, null),
+        ...buildFileWriteReverts(manifest, home, null),
+        ...buildConfigPatchReverts(manifest, home, null),
+    ];
+}
+function recordOutcome(result, action, counts, failed) {
+    if (result.outcome === "fail") {
+        failed.push({ action, error: result.error });
+    }
+    else if (result.outcome === "skip") {
+        counts.skipped++;
+    }
+    else {
+        counts.succeeded++;
+    }
+}
+async function readJsonConfig(filePath) {
+    const rawContent = await readFile(filePath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        throw new Error(`Config file is not valid JSON: ${filePath}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config file is not a JSON object: ${filePath}`);
+    }
+    return parsed;
+}
+function applyUndoPatch(current, undoPatch) {
+    const restored = { ...current };
+    for (const [key, originalValue] of Object.entries(undoPatch)) {
+        if (originalValue === null) {
+            delete restored[key];
+        }
+        else {
+            restored[key] = originalValue;
+        }
+    }
+    return restored;
+}
 function lstatOutcome(err) {
     if (err.code === "ENOENT") {
         return { outcome: "skip" };
@@ -52,34 +132,33 @@ export async function executeRevert(actions, dryRun, verbose, home) {
     let succeeded = 0;
     let skipped = 0;
     const failed = [];
+    const planned = [];
+    const counts = { succeeded, skipped };
     for (const action of actions) {
+        let result;
         switch (action.kind) {
-            case "skill-dir": {
-                const result = await executeRevertAction(action, dryRun, verbose, home);
-                if (result.outcome === "fail") {
-                    failed.push({ action, error: result.error });
-                }
-                else if (result.outcome === "skip") {
-                    skipped++;
-                }
-                else {
-                    succeeded++;
-                }
+            case "skill-dir":
+                result = await executeRevertAction(action, dryRun, verbose, home, planned);
+                break;
+            case "file-write":
+                result = await revertFileWrite(action, dryRun, verbose, home, planned);
                 break;
-            }
-            default: {
-                const _ = action.kind;
-                throw new Error(`Unhandled revert action kind: ${_}`);
-            }
+            case "config-patch":
+                result = await revertConfigPatch(action, dryRun, verbose, home, planned);
+                break;
+            default:
+                throw new Error(`Unhandled revert action kind: ${action}`);
         }
+        recordOutcome(result, action, counts, failed);
     }
-    return { succeeded, skipped, failed };
+    succeeded = counts.succeeded;
+    skipped = counts.skipped;
+    return { succeeded, skipped, failed, planned };
 }
-async function executeRevertAction(action, dryRun, verbose, home) {
+async function executeRevertAction(action, dryRun, verbose, home, planned) {
     const label = `${action.skill} -> ${action.agent}`;
-    let stat;
     try {
-        stat = await lstat(action.target);
+        await lstat(action.target);
     }
     catch (err) {
         const result = lstatOutcome(err);
@@ -96,14 +175,20 @@ async function executeRevertAction(action, dryRun, verbose, home) {
         return { outcome: "skip" };
     }
     if (dryRun) {
-        logger.plan(label);
-        if (verbose) {
-            logger.detail(`would remove: ${action.target}`);
-        }
+        planned.push({
+            verb: "remove",
+            kind: "skill-dir",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
         return { outcome: "ok" };
     }
     try {
-        if (stat.isSymbolicLink()) {
+        // Re-stat immediately before deletion to minimise the window between the
+        // type-check and the removal syscall.
+        const currentStat = await lstat(action.target);
+        if (currentStat.isSymbolicLink()) {
             await unlink(action.target);
         }
         else {
@@ -116,6 +201,113 @@ async function executeRevertAction(action, dryRun, verbose, home) {
         }
         return { outcome: "ok" };
     }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            // Target disappeared between ownership check and removal — treat as skip.
+            logger.skip(label, "(disappeared before removal, skipping)");
+            return { outcome: "skip" };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { outcome: "fail", error: msg };
+    }
+}
+async function revertFileWrite(action, dryRun, verbose, home, planned) {
+    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);
+    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" };
+    }
+    if (dryRun) {
+        planned.push({
+            verb: "remove",
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        // Re-stat immediately before deletion to minimise the type-check to
+        // removal window; handle the case where the file has since disappeared.
+        await lstat(action.target);
+        await unlink(action.target);
+        await unregisterDeployment(home, action.target);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`removed: ${action.target}`);
+        }
+        return { outcome: "ok" };
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            logger.skip(label, "(disappeared before removal, skipping)");
+            return { outcome: "skip" };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { outcome: "fail", error: msg };
+    }
+}
+async function revertConfigPatch(action, dryRun, verbose, home, planned) {
+    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);
+    if (!entry ||
+        entry.kind !== "config-patch" ||
+        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 configPatchEntry = entry;
+    if (dryRun) {
+        planned.push({
+            verb: "unapply-patch",
+            kind: "config-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch: configPatchEntry.undoPatch,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        const current = await readJsonConfig(action.target);
+        const restored = applyUndoPatch(current, configPatchEntry.undoPatch);
+        await writeFile(action.target, `${JSON.stringify(restored, null, 2)}\n`, "utf-8");
+        await unregisterDeployment(home, action.target);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`unapplied patch from: ${action.target}`);
+        }
+        return { outcome: "ok" };
+    }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         logger.fail(label, msg);

package/dist/index.js

@@ -5,8 +5,8 @@ import { AGENT_REGISTRY } from "./config/agents.js";
 import { loadManifest } from "./config/manifest.js";
 import { executeDeploy, planDeploy } from "./core/deploy.js";
 import { detectInstalledAgents } from "./core/detect.js";
-import { resolveHome } from "./core/resolve.js";
 import { runPreflight } from "./core/preflight.js";
+import { resolveHome } from "./core/resolve.js";
 import { executeRevert, planRevert, planRevertAll } from "./core/revert.js";
 import { UserError } from "./errors.js";
 import { dryRunPrefix, logger } from "./logger.js";
@@ -106,15 +106,26 @@ async function main() {
     }
     const manifest = await loadManifest(options.directory);
     const home = resolveHome();
-    const preflightWarnings = await runPreflight(options, manifest, home);
-    for (const w of preflightWarnings) {
-        logger.warn("preflight", w.message);
-    }
     if (options.command === "deploy") {
         return runDeploy(options, manifest, home);
     }
     return runRevert(options, manifest, home);
 }
+function renderDryRunPlan(planned) {
+    for (const change of planned) {
+        logger.plan(`[${change.agent}] ${change.verb}  ${change.skill}`);
+        if (change.source !== undefined) {
+            logger.detail(`source: ${change.source}`);
+        }
+        logger.detail(`target: ${change.target}`);
+        if (change.verb === "patch-config" && change.patch !== undefined) {
+            logger.detail(`patch:  ${JSON.stringify(change.patch)}`);
+        }
+        else if (change.verb === "unapply-patch" && change.patch !== undefined) {
+            logger.detail(`undo:   ${JSON.stringify(change.patch)}`);
+        }
+    }
+}
 async function runDeploy(options, manifest, home) {
     let detectedAgents;
     if (options.agents) {
@@ -134,19 +145,34 @@ async function runDeploy(options, manifest, home) {
             logger.info(`Detected agents: ${detectedAgents.join(", ")}`);
         }
     }
-    const actions = await planDeploy(manifest, options.directory, detectedAgents, home);
+    const preflightWarnings = await runPreflight(options, manifest, home, detectedAgents);
+    for (const w of preflightWarnings) {
+        const label = w.kind === "policy" ? "policy" : "preflight";
+        logger.warn(label, w.message);
+    }
+    const { actions, warnings: planWarnings } = await planDeploy(manifest, options.directory, detectedAgents, home);
+    for (const w of planWarnings) {
+        logger.warn("plan", w.message);
+    }
     if (actions.length === 0) {
         logger.info("No skills to deploy for detected agents.");
         return 0;
     }
-    logger.info(`${dryRunPrefix(options.dryRun)}Deploying ${actions.length} skill(s):`);
-    const { succeeded, failed } = await executeDeploy(actions, options.dryRun, options.verbose, home);
+    logger.info(`${dryRunPrefix(options.dryRun)}Deploying ${actions.length} action(s):`);
+    const { succeeded, failed, planned } = await executeDeploy(actions, options.dryRun, options.verbose, home);
+    if (options.dryRun) {
+        logger.info("");
+        renderDryRunPlan(planned);
+        logger.info("");
+        logger.info(`${planned.length} action(s) would be applied (dry-run)`);
+        return 0;
+    }
     logger.info("");
     if (failed.length > 0) {
         logger.info(`${succeeded} succeeded, ${failed.length} failed`);
         return 1;
     }
-    logger.info(`${succeeded} skill(s) deployed${options.dryRun ? " (dry-run)" : ""}`);
+    logger.info(`${succeeded} action(s) deployed`);
     return 0;
 }
 async function runRevert(options, manifest, home) {
@@ -157,21 +183,28 @@ async function runRevert(options, manifest, home) {
         logger.info("No skills to revert.");
         return 0;
     }
-    logger.info(`${dryRunPrefix(options.dryRun)}Reverting ${actions.length} skill(s):`);
-    const { succeeded, skipped, failed } = await executeRevert(actions, options.dryRun, options.verbose, home);
+    logger.info(`${dryRunPrefix(options.dryRun)}Reverting ${actions.length} action(s):`);
+    const { succeeded, skipped, failed, planned } = await executeRevert(actions, options.dryRun, options.verbose, home);
+    if (options.dryRun) {
+        logger.info("");
+        renderDryRunPlan(planned);
+        logger.info("");
+        logger.info(`${planned.length} action(s) would be removed (dry-run)`);
+        return 0;
+    }
     logger.info("");
     if (failed.length > 0) {
         const parts = [`${succeeded} removed`];
         if (skipped > 0)
             parts.push(`${skipped} skipped`);
         parts.push(`${failed.length} failed`);
-        logger.info(`${parts.join(", ")}${options.dryRun ? " (dry-run)" : ""}`);
+        logger.info(parts.join(", "));
         return 1;
     }
     const parts = [`${succeeded} removed`];
     if (skipped > 0)
         parts.push(`${skipped} skipped`);
-    logger.info(`${parts.join(", ")}${options.dryRun ? " (dry-run)" : ""}`);
+    logger.info(parts.join(", "));
     return 0;
 }
 const USER_ERROR_EXIT = {

package/dist/schemas/manifest.d.ts

@@ -22,6 +22,38 @@ export declare const SkillEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
 }, z.core.$strip>;
+export declare const FileEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    target: 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")[]>>;
+}, z.core.$strip>;
+export declare const ConfigEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    target: z.ZodString;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    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")[]>>;
+}, z.core.$strip>;
+export declare const McpServerEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$loose>;
+export declare const AgentRuleEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$loose>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -35,10 +67,44 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     }, z.core.$strip>>;
-    mcpServers: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
-    agentRules: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        target: 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")[]>>;
+    }, z.core.$strip>>>;
+    configs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        target: z.ZodString;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        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")[]>>;
+    }, z.core.$strip>>>;
+    mcpServers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$loose>>>;
+    agentRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$loose>>>;
 }, 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 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";