@kuznai/inception-engine 0.18.0 → 0.19.0

package/dist/core/deploy.js

@@ -1,7 +1,7 @@
 import { constants } from "node:fs";
 import { access, copyFile, cp, lstat, mkdir, readFile, realpath, rename, rm, symlink, unlink, writeFile, } from "node:fs/promises";
 import path from "node:path";
-import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+import { AGENT_REGISTRY, AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
 import { compileAdapterActions } from "./adapters/index.js";
@@ -80,26 +80,118 @@ function detectCollisions(actions) {
     }
     return warnings;
 }
-function detectAmbiguities(detectedAgents, manifest) {
-    const warnings = [];
-    if (!(detectedAgents.includes("gemini-cli") &&
-        detectedAgents.includes("antigravity"))) {
-        return warnings;
+/**
+ * Finds all (primary, rider) pairs among detected agents where the rider has
+ * at least one surface annotated as `shared-via` the primary and the primary
+ * is also detected. Used to drive ambiguity warnings without hardcoding agent
+ * IDs.
+ */
+function findSharedSurfacePairs(detectedAgents) {
+    const pairs = [];
+    for (const agent of AGENT_REGISTRY) {
+        if (!detectedAgents.includes(agent.id))
+            continue;
+        const surfaces = [
+            agent.agentRulesSupport,
+            agent.agentRulesRepoSupport,
+            agent.agentRulesWorkspaceSupport,
+            agent.mcpSupport,
+            agent.agentDefinitionsSupport,
+        ];
+        for (const surface of surfaces) {
+            if (surface?.status === "supported" &&
+                surface.surfaceKind?.kind === "shared-via") {
+                const via = surface.surfaceKind.via;
+                if (detectedAgents.includes(via) &&
+                    !pairs.some((p) => p.primary === via && p.rider === agent.id)) {
+                    pairs.push({ primary: via, rider: agent.id });
+                }
+            }
+        }
     }
-    const bothAgents = (agents) => agents.includes("gemini-cli") && agents.includes("antigravity");
+    return pairs;
+}
+function resolveAgentRulesSupportForScope(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo")
+        return agent?.agentRulesRepoSupport ?? agent?.agentRulesSupport;
+    if (scope === "workspace") {
+        return (agent?.agentRulesWorkspaceSupport ??
+            agent?.agentRulesRepoSupport ??
+            agent?.agentRulesSupport);
+    }
+    return agent?.agentRulesSupport;
+}
+function checkPairAgentRuleAmbiguities(manifest, primary, rider) {
+    const warnings = [];
     for (const entry of manifest.agentRules ?? []) {
-        if (bothAgents(entry.agents)) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        const primarySupport = resolveAgentRulesSupportForScope(primary, entry.scope);
+        const riderSupport = resolveAgentRulesSupportForScope(rider, entry.scope);
+        if (primarySupport?.status === "supported" &&
+            riderSupport?.status === "supported" &&
+            JSON.stringify(primarySupport.path) === JSON.stringify(riderSupport.path)) {
             warnings.push({
                 kind: "ambiguity",
-                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.`,
+                message: `Both "${primary}" and "${rider}" are listed in agentRules entry "${entry.name}". Both target the same surface — listing both is redundant but harmless; deduplication ensures only one write action is emitted.`,
             });
         }
     }
+    return warnings;
+}
+function checkPairMcpAmbiguities(manifest, primary, rider) {
+    const warnings = [];
+    const primaryMcp = AGENT_REGISTRY_BY_ID[primary]?.mcpSupport;
+    const riderMcp = AGENT_REGISTRY_BY_ID[rider]?.mcpSupport;
+    if (primaryMcp?.status !== "supported" || riderMcp?.status !== "supported")
+        return warnings;
     for (const entry of manifest.mcpServers ?? []) {
-        if (bothAgents(entry.agents)) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        warnings.push({
+            kind: "ambiguity",
+            message: `Both "${primary}" and "${rider}" are listed in mcpServers entry "${entry.name}". "${primary}" writes to a shared MCP surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
+        });
+    }
+    return warnings;
+}
+function checkPairAgentDefinitionAmbiguities(manifest, primary, rider) {
+    const warnings = [];
+    for (const entry of manifest.agentDefinitions ?? []) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        warnings.push({
+            kind: "ambiguity",
+            message: `Both "${primary}" and "${rider}" are listed in agentDefinitions entry "${entry.name}". They write to distinct surfaces — verify that this behavioral divergence is intended.`,
+        });
+    }
+    return warnings;
+}
+function detectAmbiguities(detectedAgents, manifest) {
+    const pairs = findSharedSurfacePairs(detectedAgents);
+    if (pairs.length === 0)
+        return [];
+    const warnings = [];
+    for (const { primary, rider } of pairs) {
+        warnings.push(...checkPairAgentRuleAmbiguities(manifest, primary, rider));
+        warnings.push(...checkPairMcpAmbiguities(manifest, primary, rider));
+        warnings.push(...checkPairAgentDefinitionAmbiguities(manifest, primary, rider));
+    }
+    return warnings;
+}
+function checkAntigravityPathCollisions(manifest) {
+    const warnings = [];
+    const defNames = new Set((manifest.agentDefinitions ?? [])
+        .filter((e) => e.agents.includes("antigravity"))
+        .map((e) => e.name));
+    for (const entry of manifest.mcpServers ?? []) {
+        if (!entry.agents.includes("antigravity"))
+            continue;
+        if (defNames.has(entry.name)) {
             warnings.push({
-                kind: "ambiguity",
-                message: `Both "gemini-cli" and "antigravity" are listed in mcpServers entry "${entry.name}". "gemini-cli" writes to ~/.gemini/settings.json as a shared surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
+                kind: "collision",
+                message: `agentDefinitions entry "${entry.name}" and mcpServers entry "${entry.name}" for agent "antigravity" both resolve to {repo}/.agents/rules/${entry.name}.md — one will silently overwrite the other; use different names or remove one entry`,
             });
         }
     }
@@ -134,7 +226,7 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
     }
     return actions;
 }
-async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
     const actions = [];
     for (const fileEntry of manifest.files ?? []) {
         const targetAgents = fileEntry.agents.filter((agentId) => detectedAgents.includes(agentId));
@@ -152,14 +244,14 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
                 skill: fileEntry.name,
                 agent: agentId,
                 source,
-                target: resolveTargetTemplate(fileEntry.target, home),
+                target: resolveTargetTemplate(fileEntry.target, home, repo, workspace),
                 confidence: agent.provenance.skills,
             });
         }
     }
     return actions;
 }
-function planConfigPatchActions(manifest, detectedAgents, home) {
+function planConfigPatchActions(manifest, detectedAgents, home, repo, workspace) {
     const actions = [];
     for (const configEntry of manifest.configs ?? []) {
         for (const agentId of configEntry.agents) {
@@ -172,7 +264,7 @@ function planConfigPatchActions(manifest, detectedAgents, home) {
                 kind: "config-patch",
                 skill: configEntry.name,
                 agent: agentId,
-                target: resolveTargetTemplate(configEntry.target, home),
+                target: resolveTargetTemplate(configEntry.target, home, repo, workspace),
                 patch: configEntry.patch,
                 confidence: agent.provenance.skills,
             });
@@ -180,7 +272,7 @@ function planConfigPatchActions(manifest, detectedAgents, home) {
     }
     return actions;
 }
-export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
+export async function planDeploy(manifest, sourceDir, detectedAgents, home, repo, workspace) {
     const resolvedSourceDir = path.resolve(sourceDir);
     let realRoot;
     try {
@@ -189,15 +281,17 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     catch {
         realRoot = resolvedSourceDir;
     }
+    const repoDir = repo ?? realRoot;
     const actions = [
         ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...planConfigPatchActions(manifest, detectedAgents, home),
+        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, workspace)),
+        ...planConfigPatchActions(manifest, detectedAgents, home, repoDir, workspace),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, undefined, manifest.agentDefinitions ?? []);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...detectAmbiguities(detectedAgents, manifest),
+        ...checkAntigravityPathCollisions(manifest),
         ...detectCollisions(actions),
         ...adapterResult.warnings,
     ];
@@ -208,44 +302,32 @@ export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     const failed = [];
     const planned = [];
     for (const action of actions) {
-        switch (action.kind) {
-            case "skill-dir": {
-                const result = await deploySkillDir(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "file-write": {
-                const result = await deployFileWrite(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "config-patch": {
-                const result = await deployConfigPatch(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            default: {
-                throw new Error(`Unhandled deploy action kind: ${action}`);
-            }
+        const result = await dispatchDeployAction(action, dryRun, verbose, home, planned, deps);
+        if (result.error === null) {
+            succeeded++;
+        }
+        else {
+            failed.push({ action, error: result.error });
         }
     }
     return { succeeded, failed, planned };
 }
+async function dispatchDeployAction(action, dryRun, verbose, home, planned, deps) {
+    switch (action.kind) {
+        case "skill-dir":
+            return deploySkillDir(action, dryRun, verbose, home, planned, deps);
+        case "file-write":
+            return deployFileWrite(action, dryRun, verbose, home, planned, deps);
+        case "config-patch":
+            return deployConfigPatch(action, dryRun, verbose, home, planned, deps);
+        case "toml-patch":
+            return deployTomlPatch(action, dryRun, verbose, home, planned, deps);
+        case "frontmatter-emit":
+            return deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
+        default:
+            throw new Error(`Unhandled deploy action kind: ${action.kind}`);
+    }
+}
 const defaultSkillDirOps = {
     async createTarget(action) {
         if (action.method === "symlink") {
@@ -483,6 +565,76 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
         return { error: msg };
     }
 }
+async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "patch-toml",
+            kind: "toml-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch: action.config,
+        });
+        return { error: null };
+    }
+    try {
+        const { previousValue } = await (deps.registry
+            ? Promise.resolve({ previousValue: null })
+            : (await import("./adapters/toml.js")).applyTomlMcpPatch(action.target, action.skill, action.config));
+        // Note: To truly support custom deps here we'd need to refactor toml adapter to accept deps.
+        // For now we assume standard adapter for TOML.
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch: action.config,
+            undoPatch: { mcpServers: { [action.skill]: previousValue } },
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-toml: ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "emit-frontmatter",
+            kind: "frontmatter-emit",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            frontmatter: action.frontmatter,
+        });
+        return { error: null };
+    }
+    try {
+        await (await import("./adapters/frontmatter.js")).writeFrontmatterFile(action.target, action.frontmatter, { preserveBody: true });
+        await registerDeployment(home, action.target, {
+            kind: "frontmatter-emit",
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`emit-frontmatter: ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
 async function validateSkillContract(source, skillPath) {
     let stat;
     try {

package/dist/core/init.js

@@ -1,42 +1,81 @@
 import { access, readdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+import { AGENT_REGISTRY, AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { dryRunPrefix, logger } from "../logger.js";
 import { AGENT_IDS, AgentDefinitionEntrySchema, ConfigEntrySchema, FileEntrySchema, McpServerEntrySchema, } from "../schemas/manifest.js";
+import { parseFrontmatterDocument } from "./adapters/frontmatter.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 = [
-    {
-        fileNames: ["claude.md", "claude-instructions.md"],
-        agents: ["claude-code"],
-    },
-    {
-        fileNames: ["agents.md", "agents-instructions.md"],
-        agents: ["codex", "opencode"],
-    },
-    {
-        fileNames: ["gemini.md", "gemini-instructions.md"],
-        agents: ["gemini-cli", "antigravity"],
-    },
-    { fileNames: ["copilot-instructions.md"], agents: ["claude-code"] },
-];
+// Derived from the registry: group agents by the filename of their global
+// agentRulesSupport path. Agents with requiresPrimary (e.g. github-copilot)
+// are excluded because they cannot be deployed independently. The
+// copilot-instructions.md convention mapping is appended explicitly since it
+// is a well-known filename convention, not derivable from a path template.
+const AGENT_RULES_FILE_PATTERNS = (() => {
+    const filenameToAgents = new Map();
+    for (const agent of AGENT_REGISTRY) {
+        const support = agent.agentRulesSupport;
+        if (support?.status !== "supported")
+            continue;
+        // Skip riders that require the primary — they cannot be listed independently
+        if (support.surfaceKind?.kind === "shared-via" &&
+            support.surfaceKind.requiresPrimary)
+            continue;
+        const filename = support.path.posix[support.path.posix.length - 1]?.toLowerCase();
+        if (!filename)
+            continue;
+        const list = filenameToAgents.get(filename) ?? [];
+        list.push(agent.id);
+        filenameToAgents.set(filename, list);
+    }
+    return [
+        ...Array.from(filenameToAgents.entries()).map(([filename, agents]) => ({
+            fileNames: [filename, filename.replace(".md", "-instructions.md")],
+            agents,
+        })),
+        // Convention mapping: copilot-instructions.md → claude-code. Copilot reads
+        // CLAUDE.md natively; this filename is a well-known convention that cannot
+        // be derived from any agent path template.
+        {
+            fileNames: ["copilot-instructions.md"],
+            agents: ["claude-code"],
+        },
+    ];
+})();
 // Conventional subdirectory names to scan one level deep for .md files.
-const AGENT_RULES_SUBDIRS = [
-    "rules",
-    "instructions",
-    ".github",
-    ".agents/rules",
-];
+const AGENT_RULES_SUBDIRS = ["rules", "instructions", ".github"];
 // 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",
-];
+// Derived from the registry: for each agent with a supported agentDefinitions
+// surface, extract the directory prefix from its posix path template.
+const AGENT_DEFINITION_SUBDIRS = (() => {
+    const subdirs = new Set();
+    for (const agent of AGENT_REGISTRY) {
+        const support = agent.agentDefinitionsSupport;
+        if (support?.status !== "supported")
+            continue;
+        const tmpl = support.path.posix;
+        const repoIdx = tmpl.indexOf("{repo}");
+        const nameIdx = tmpl.findIndex((s) => s.includes("{name}"));
+        if (repoIdx === -1 || nameIdx === -1 || nameIdx <= repoIdx)
+            continue;
+        const dirSegs = tmpl.slice(repoIdx + 1, nameIdx);
+        if (dirSegs.length > 0)
+            subdirs.add(dirSegs.join("/"));
+    }
+    return Array.from(subdirs);
+})();
+async function hasAntigravityMcpFrontmatter(absPath) {
+    let raw;
+    try {
+        raw = await readFile(absPath, "utf-8");
+    }
+    catch {
+        return false;
+    }
+    const { attributes } = parseFrontmatterDocument(raw);
+    return (Object.hasOwn(attributes, "mcp-servers") ||
+        Object.hasOwn(attributes, "mcpServers"));
+}
 async function findSkillDirs(baseDir, dir, found) {
     let entries;
     try {
@@ -196,24 +235,53 @@ function deriveAgentDefinitionName(relPath, fileName) {
 }
 /**
  * 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).
+ * Derived from the registry by matching each agent's agentDefinitionsSupport
+ * path prefix. Returns null when the subdir is not recognized.
  */
 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;
+    const matching = [];
+    for (const agent of AGENT_REGISTRY) {
+        const support = agent.agentDefinitionsSupport;
+        if (support?.status !== "supported")
+            continue;
+        const tmpl = support.path.posix;
+        const repoIdx = tmpl.indexOf("{repo}");
+        const nameIdx = tmpl.findIndex((s) => s.includes("{name}"));
+        if (repoIdx === -1 || nameIdx === -1 || nameIdx <= repoIdx)
+            continue;
+        const agentSubdir = tmpl.slice(repoIdx + 1, nameIdx).join("/");
+        if (agentSubdir === subdir)
+            matching.push(agent.id);
     }
+    return matching.length > 0 ? matching : null;
+}
+/**
+ * Returns true when a file in a definition subdir contains MCP-specific
+ * frontmatter and should be excluded from agentDefinitions discovery. Detects
+ * this by checking whether any registered agent uses the same directory as
+ * both its definition surface and its MCP surface (currently: Antigravity's
+ * .agents/rules/).
+ */
+async function isSkippedMcpFile(subdir, absPath, relPath) {
+    const hasMcpSurfaceHere = AGENT_REGISTRY.some((agent) => {
+        const support = agent.mcpSupport;
+        if (support?.status !== "supported")
+            return false;
+        const tmpl = support.path.posix;
+        const repoIdx = tmpl.indexOf("{repo}");
+        const nameIdx = tmpl.findIndex((s) => s.includes("{name}"));
+        if (repoIdx === -1 || nameIdx === -1 || nameIdx <= repoIdx)
+            return false;
+        const prefix = tmpl.slice(repoIdx + 1, nameIdx).join("/");
+        return prefix === subdir;
+    });
+    if (!hasMcpSurfaceHere)
+        return false;
+    const isMcp = await hasAntigravityMcpFrontmatter(absPath);
+    if (isMcp) {
+        logger.warn("init", `Skipping "${relPath}" as agentDefinitions: frontmatter contains "mcp-servers" — file is an MCP surface, not an agent definition`);
+    }
+    return isMcp;
 }
 async function scanDefinitionSubdir(subdir, baseDir, seen, skillDirRelPaths, agentRulesRelPaths, candidates) {
     const suggestedAgents = agentsForDefinitionSubdir(subdir) ?? [];
@@ -237,6 +305,8 @@ async function scanDefinitionSubdir(subdir, baseDir, seen, skillDirRelPaths, age
             isInsideSkillDir(relPath, skillDirRelPaths) ||
             agentRulesRelPaths.has(relPath))
             continue;
+        if (await isSkippedMcpFile(subdir, absPath, relPath))
+            continue;
         const name = deriveAgentDefinitionName(relPath, entry.name);
         if (name === null)
             continue;
@@ -478,7 +548,17 @@ function logVerboseManifest(skills, agentRules, mcpServers, files, configs, agen
 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 agentRulesCapableAgents = agents.filter((id) => {
+        const support = AGENT_REGISTRY_BY_ID[id].agentRulesSupport;
+        if (!support || support.status === "unsupported")
+            return false;
+        // Exclude riders that require the primary — they cannot operate independently
+        if (support.status === "supported" &&
+            support.surfaceKind?.kind === "shared-via" &&
+            support.surfaceKind.requiresPrimary)
+            return false;
+        return true;
+    });
     const manifestPath = path.join(directory, "inception.json");
     if (!dryRun && (await manifestExists(manifestPath)) && !force) {
         logger.error(`Error: ${manifestPath} already exists. Use --force to overwrite.`);

package/dist/core/ownership.d.ts

@@ -1,4 +1,4 @@
-import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, type Registry, type RegistryEntry, type SkillDirRegistryEntry } from "../schemas/registry.ts";
+import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, type FrontmatterEmitRegistryEntry, type Registry, type RegistryEntry, type SkillDirRegistryEntry } from "../schemas/registry.ts";
 import type { AgentId } from "../types.ts";
 export type { RegistryEntry } from "../schemas/registry.ts";
 export interface RegistryPersistence {
@@ -22,7 +22,7 @@ export type VerifyExpected = {
 };
 export declare function registryPath(home: string): string;
 export declare const defaultRegistryPersistence: RegistryPersistence;
-export type RegisterEntry = Omit<SkillDirRegistryEntry, "deployed"> | Omit<FileWriteRegistryEntry, "deployed"> | Omit<ConfigPatchRegistryEntry, "deployed">;
+export type RegisterEntry = Omit<SkillDirRegistryEntry, "deployed"> | Omit<FileWriteRegistryEntry, "deployed"> | Omit<ConfigPatchRegistryEntry, "deployed"> | Omit<FrontmatterEmitRegistryEntry, "deployed">;
 export declare function registerDeployment(home: string, targetPath: string, entry: RegisterEntry, persistence?: RegistryPersistence): Promise<void>;
 export declare function unregisterDeployment(home: string, targetPath: string, persistence?: RegistryPersistence): Promise<void>;
 export declare function lookupDeployment(home: string, targetPath: string, persistence?: RegistryPersistence): Promise<RegistryEntry | null>;

package/dist/core/preflight.d.ts

@@ -3,4 +3,4 @@ export interface PreflightWarning {
     kind: "policy" | "config-authority" | "info" | "precedence" | "budget";
     message: string;
 }
-export declare function runPreflight(options: CliOptions, manifest: Manifest, _home: string, detectedAgents: AgentId[]): Promise<PreflightWarning[]>;
+export declare function runPreflight(options: CliOptions, manifest: Manifest, home: string, detectedAgents: AgentId[]): Promise<PreflightWarning[]>;