@kuznai/inception-engine 0.8.0 → 0.10.1

package/dist/core/deploy.js

@@ -4,12 +4,15 @@ import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
+import { compileAdapterActions } from "./adapters/index.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
+import { resolveTargetTemplate } from "./runtime-paths.js";
+import { sourceAccessError, validateSourceFile, validateSourcePath, } from "./validation.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-async function readJsonConfig(filePath) {
+async function readJsonConfigFile(filePath) {
     let rawContent;
     try {
         rawContent = await readFile(filePath, "utf-8");
@@ -35,7 +38,13 @@ async function readJsonConfig(filePath) {
 function computeUndoPatch(original, patch) {
     const undoPatch = {};
     for (const key of Object.keys(patch)) {
-        undoPatch[key] = key in original ? original[key] : null;
+        const patchVal = patch[key];
+        if (isPlainObject(patchVal) && isPlainObject(original[key])) {
+            undoPatch[key] = computeUndoPatch(original[key], patchVal);
+        }
+        else {
+            undoPatch[key] = key in original ? original[key] : null;
+        }
     }
     return undoPatch;
 }
@@ -45,42 +54,15 @@ function applyMergePatch(original, patch) {
         if (value === null) {
             delete patched[key];
         }
+        else if (isPlainObject(value) && isPlainObject(patched[key])) {
+            patched[key] = applyMergePatch(patched[key], value);
+        }
         else {
             patched[key] = value;
         }
     }
     return patched;
 }
-function sourceAccessError(err, sourcePath) {
-    const code = err.code;
-    if (code === "ENOENT")
-        return `Source not found: ${sourcePath}`;
-    if (code === "EACCES" || code === "EPERM")
-        return `Permission denied accessing source: ${sourcePath}`;
-    const detail = err instanceof Error ? err.message : String(err);
-    return `Failed to access source ${sourcePath}: ${detail}`;
-}
-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);
-}
-async function validateSourceFile(sourcePath, manifestPath) {
-    let stat;
-    try {
-        stat = await lstat(sourcePath);
-    }
-    catch (err) {
-        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, manifestPath));
-    }
-    if (!stat.isFile()) {
-        throw new UserError("DEPLOY_FAILED", `Source is not a file: ${manifestPath}`);
-    }
-}
 function detectCollisions(actions) {
     const seen = new Map();
     const warnings = [];
@@ -113,12 +95,13 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
     const method = getDeployMethod();
     const actions = [];
     for (const skill of manifest.skills) {
+        const targetAgents = skill.agents.filter((agentId) => detectedAgents.includes(agentId));
+        if (targetAgents.length === 0)
+            continue;
         const source = path.resolve(sourceDir, skill.path);
         await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
         await validateSkillContract(source, skill.path);
-        for (const agentId of skill.agents) {
-            if (!detectedAgents.includes(agentId))
-                continue;
+        for (const agentId of targetAgents) {
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
@@ -138,12 +121,13 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
 async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
     const actions = [];
     for (const fileEntry of manifest.files ?? []) {
+        const targetAgents = fileEntry.agents.filter((agentId) => detectedAgents.includes(agentId));
+        if (targetAgents.length === 0)
+            continue;
         const source = path.resolve(sourceDir, fileEntry.path);
         await validateSourcePath(source, fileEntry.path, resolvedSourceDir, realRoot);
         await validateSourceFile(source, fileEntry.path);
-        for (const agentId of fileEntry.agents) {
-            if (!detectedAgents.includes(agentId))
-                continue;
+        for (const agentId of targetAgents) {
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
@@ -194,20 +178,23 @@ 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);
+    actions.push(...adapterResult.actions);
     const warnings = [
         ...detectAmbiguities(detectedAgents),
         ...detectCollisions(actions),
+        ...adapterResult.warnings,
     ];
     return { actions, warnings };
 }
-export async function executeDeploy(actions, dryRun, verbose, home) {
+export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     let succeeded = 0;
     const failed = [];
     const planned = [];
     for (const action of actions) {
         switch (action.kind) {
             case "skill-dir": {
-                const result = await deploySkillDir(action, dryRun, verbose, home, planned);
+                const result = await deploySkillDir(action, dryRun, verbose, home, planned, deps);
                 if (result.error === null) {
                     succeeded++;
                 }
@@ -217,7 +204,7 @@ export async function executeDeploy(actions, dryRun, verbose, home) {
                 break;
             }
             case "file-write": {
-                const result = await deployFileWrite(action, dryRun, verbose, home, planned);
+                const result = await deployFileWrite(action, dryRun, verbose, home, planned, deps);
                 if (result.error === null) {
                     succeeded++;
                 }
@@ -227,7 +214,7 @@ export async function executeDeploy(actions, dryRun, verbose, home) {
                 break;
             }
             case "config-patch": {
-                const result = await deployConfigPatch(action, dryRun, verbose, home, planned);
+                const result = await deployConfigPatch(action, dryRun, verbose, home, planned, deps);
                 if (result.error === null) {
                     succeeded++;
                 }
@@ -243,7 +230,114 @@ export async function executeDeploy(actions, dryRun, verbose, home) {
     }
     return { succeeded, failed, planned };
 }
-async function deploySkillDir(action, dryRun, verbose, home, planned) {
+const defaultSkillDirOps = {
+    async createTarget(action) {
+        if (action.method === "symlink") {
+            await symlink(action.source, action.target, "dir");
+        }
+        else {
+            await cp(action.source, action.target, { recursive: true });
+        }
+    },
+    async removeTarget(targetPath) {
+        const stat = await lstat(targetPath);
+        if (stat.isSymbolicLink()) {
+            await unlink(targetPath);
+        }
+        else {
+            await rm(targetPath, { recursive: true });
+        }
+    },
+};
+const defaultDeployFileOps = {
+    copyFile,
+    rename,
+    rm,
+    writeFile,
+};
+async function removeFileSystemTarget(targetPath) {
+    const stat = await lstat(targetPath);
+    if (stat.isDirectory() && !stat.isSymbolicLink()) {
+        await rm(targetPath, { recursive: true });
+    }
+    else {
+        await unlink(targetPath);
+    }
+}
+async function backupManagedFileWriteTarget(action, home, deps) {
+    try {
+        await lstat(action.target);
+    }
+    catch {
+        return null;
+    }
+    const isOwned = await verifyDeployment(home, action.target, {
+        kind: "file-write",
+        source: action.source,
+        skill: action.skill,
+        agent: action.agent,
+    }, deps.registry);
+    if (!isOwned) {
+        throw new Error(`Target "${action.target}" exists but is not managed by inception-engine — refusing to overwrite`);
+    }
+    const backupPath = `${action.target}.inception-backup`;
+    await (deps.fileOps ?? defaultDeployFileOps).rm(backupPath, {
+        recursive: true,
+        force: true,
+    });
+    await (deps.fileOps ?? defaultDeployFileOps).rename(action.target, backupPath);
+    return backupPath;
+}
+function createAtomicTempPath(targetPath) {
+    return `${targetPath}.inception-tmp-${process.pid}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
+}
+async function replaceFileAtomically(targetPath, deps, stageTempFile, prepareBackup, commit) {
+    const fileOps = deps.fileOps ?? defaultDeployFileOps;
+    const tempPath = createAtomicTempPath(targetPath);
+    let backupPath = null;
+    let replacedTarget = false;
+    try {
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await stageTempFile(tempPath, fileOps);
+        backupPath = await prepareBackup();
+        await fileOps.rename(tempPath, targetPath);
+        replacedTarget = true;
+        await commit();
+    }
+    catch (writeErr) {
+        if (replacedTarget) {
+            try {
+                await removeFileSystemTarget(targetPath);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        else {
+            try {
+                await fileOps.rm(tempPath, { recursive: true, force: true });
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        if (backupPath) {
+            try {
+                await fileOps.rename(backupPath, targetPath);
+            }
+            catch {
+                /* best-effort rollback */
+            }
+        }
+        throw writeErr;
+    }
+    if (backupPath) {
+        await fileOps.rm(backupPath, { recursive: true, force: true });
+    }
+}
+async function deploySkillDir(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     try {
         await access(action.source);
@@ -267,7 +361,7 @@ async function deploySkillDir(action, dryRun, verbose, home, planned) {
         return { error: null };
     }
     try {
-        await executeDeployAction(action, verbose, home);
+        await executeDeployAction(action, verbose, home, deps);
         return { error: null };
     }
     catch (err) {
@@ -276,7 +370,7 @@ async function deploySkillDir(action, dryRun, verbose, home, planned) {
         return { error: msg };
     }
 }
-async function deployFileWrite(action, dryRun, verbose, home, planned) {
+async function deployFileWrite(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     try {
         await access(action.source);
@@ -298,32 +392,12 @@ async function deployFileWrite(action, dryRun, verbose, home, planned) {
         return { error: null };
     }
     try {
-        // Check if target exists — only allow overwrite if we own it
-        try {
-            await lstat(action.target);
-            const isOwned = await verifyDeployment(home, action.target, {
-                kind: "file-write",
-                source: action.source,
-                skill: action.skill,
-                agent: action.agent,
-            });
-            if (!isOwned) {
-                throw new Error(`Target "${action.target}" exists but is not managed by inception-engine — refusing to overwrite`);
-            }
-        }
-        catch (err) {
-            if (err instanceof Error && err.message.includes("refusing to overwrite"))
-                throw err;
-            // ENOENT — target doesn't exist, fine to create
-        }
-        await mkdir(path.dirname(action.target), { recursive: true });
-        await copyFile(action.source, action.target);
-        await registerDeployment(home, action.target, {
+        await replaceFileAtomically(action.target, deps, (tempPath, fileOps) => fileOps.copyFile(action.source, tempPath), () => backupManagedFileWriteTarget(action, home, deps), () => registerDeployment(home, action.target, {
             kind: "file-write",
             source: action.source,
             skill: action.skill,
             agent: action.agent,
-        });
+        }, deps.registry));
         logger.ok(label);
         if (verbose) {
             logger.detail(`write-file: ${action.source} -> ${action.target}`);
@@ -336,7 +410,7 @@ async function deployFileWrite(action, dryRun, verbose, home, planned) {
         return { error: msg };
     }
 }
-async function deployConfigPatch(action, dryRun, verbose, home, planned) {
+async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     if (!isPlainObject(action.patch)) {
         const msg = `Config patch for skill "${action.skill}" must be a plain object`;
@@ -357,23 +431,30 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned) {
     }
     try {
         // Guard against double-patching by a different skill/agent
-        const existingEntry = await lookupDeployment(home, action.target);
+        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
         if (existingEntry &&
             (existingEntry.skill !== action.skill ||
                 existingEntry.agent !== action.agent)) {
             throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
         }
-        const original = await readJsonConfig(action.target);
+        const original = await readJsonConfigFile(action.target);
         const undoPatch = computeUndoPatch(original, patch);
         const patched = applyMergePatch(original, patch);
-        await writeFile(action.target, `${JSON.stringify(patched, null, 2)}\n`, "utf-8");
-        await registerDeployment(home, action.target, {
+        await replaceFileAtomically(action.target, deps, (tempPath, fileOps) => fileOps.writeFile(tempPath, `${JSON.stringify(patched, null, 2)}\n`, "utf-8"), async () => {
+            const backupPath = `${action.target}.inception-backup`;
+            await (deps.fileOps ?? defaultDeployFileOps).rm(backupPath, {
+                recursive: true,
+                force: true,
+            });
+            await (deps.fileOps ?? defaultDeployFileOps).rename(action.target, backupPath);
+            return backupPath;
+        }, () => registerDeployment(home, action.target, {
             kind: "config-patch",
             patch,
             undoPatch,
             skill: action.skill,
             agent: action.agent,
-        });
+        }, deps.registry));
         logger.ok(label);
         if (verbose) {
             logger.detail(`patch-config: applied ${Object.keys(patch).length} key(s) to ${action.target}`);
@@ -386,23 +467,6 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned) {
         return { error: msg };
     }
 }
-async function validateSourcePath(source, skillPath, resolvedSourceDir, realRoot) {
-    if (!source.startsWith(resolvedSourceDir + path.sep)) {
-        throw new UserError("DEPLOY_FAILED", `Skill path "${skillPath}" resolves outside the repository root: ${source}`);
-    }
-    try {
-        const realSource = await realpath(source);
-        if (realSource !== realRoot &&
-            !realSource.startsWith(realRoot + path.sep)) {
-            throw new UserError("DEPLOY_FAILED", `Skill path "${skillPath}" resolves outside the repository root via symlink: ${source} -> ${realSource}`);
-        }
-    }
-    catch (err) {
-        if (err instanceof UserError)
-            throw err;
-        // Source doesn't exist yet — will be caught during execute
-    }
-}
 async function validateSkillContract(source, skillPath) {
     let stat;
     try {
@@ -453,38 +517,35 @@ async function assertTargetAbsent(targetPath) {
         // ENOENT is expected — target should not exist after backup
     }
 }
-async function createDeployTarget(action, home) {
-    if (action.method === "symlink") {
-        await symlink(action.source, action.target, "dir");
-    }
-    else {
-        await cp(action.source, action.target, { recursive: true });
-    }
+async function createDeployTarget(action, home, deps) {
+    await (deps.skillDirOps ?? defaultSkillDirOps).createTarget(action);
     await registerDeployment(home, action.target, {
         kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
         method: action.method,
-    });
+    }, deps.registry);
 }
-async function executeDeployAction(action, verbose, home) {
+async function executeDeployAction(action, verbose, home, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     const backupPath = await backupExisting(action.target, verbose, home, {
         kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
-    });
+    }, deps);
     await mkdir(path.dirname(action.target), { recursive: true });
     try {
         await assertTargetAbsent(action.target);
-        await createDeployTarget(action, home);
+        await createDeployTarget(action, home, deps);
     }
     catch (createErr) {
         if (backupPath) {
             try {
-                await removeTarget(action.target).catch(() => {
+                await (deps.skillDirOps ?? defaultSkillDirOps)
+                    .removeTarget(action.target)
+                    .catch(() => {
                     /* best-effort cleanup */
                 });
                 await rename(backupPath, action.target);
@@ -496,14 +557,14 @@ async function executeDeployAction(action, verbose, home) {
         throw createErr;
     }
     if (backupPath) {
-        await removeTarget(backupPath);
+        await (deps.skillDirOps ?? defaultSkillDirOps).removeTarget(backupPath);
     }
     logger.ok(label);
     if (verbose) {
         logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
     }
 }
-async function backupExisting(targetPath, verbose, home, expected) {
+async function backupExisting(targetPath, verbose, home, expected, deps) {
     try {
         await lstat(targetPath);
     }
@@ -515,7 +576,7 @@ async function backupExisting(targetPath, verbose, home, expected) {
         source: expected.source,
         skill: expected.skill,
         agent: expected.agent,
-    }))) {
+    }, deps.registry))) {
         throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine — refusing to overwrite`);
     }
     const backupPath = `${targetPath}.inception-backup`;
@@ -531,12 +592,3 @@ async function backupExisting(targetPath, verbose, home, expected) {
     await rename(targetPath, backupPath);
     return backupPath;
 }
-async function removeTarget(targetPath) {
-    const stat = await lstat(targetPath);
-    if (stat.isSymbolicLink()) {
-        await unlink(targetPath);
-    }
-    else {
-        await rm(targetPath, { recursive: true });
-    }
-}

package/dist/core/ownership.d.ts

@@ -1,6 +1,10 @@
-import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, type RegistryEntry, type SkillDirRegistryEntry } from "../schemas/registry.ts";
+import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, 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 {
+    load(home: string): Promise<Registry>;
+    save(home: string, registry: Registry): Promise<void>;
+}
 export type VerifyExpected = {
     kind: "skill-dir";
     source: string;
@@ -17,8 +21,9 @@ export type VerifyExpected = {
     agent: AgentId;
 };
 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 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>;
+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>;
+export declare function verifyDeployment(home: string, targetPath: string, expected: VerifyExpected, persistence?: RegistryPersistence): Promise<RegistryEntry | null>;

package/dist/core/ownership.js

@@ -24,6 +24,10 @@ async function saveRegistry(home, registry) {
     await writeFile(filePath, `${JSON.stringify(registry, null, 2)}\n`);
     await setFilePermissions(filePath);
 }
+export const defaultRegistryPersistence = {
+    load: loadRegistry,
+    save: saveRegistry,
+};
 /**
  * Ensure the file is not world-writable regardless of umask.
  * On Windows, the OS inherits ACLs from the parent directory — no-op is correct.
@@ -36,27 +40,27 @@ async function setFilePermissions(filePath) {
 function emptyRegistry() {
     return { version: 1, deployments: {} };
 }
-export async function registerDeployment(home, targetPath, entry) {
-    const registry = await loadRegistry(home);
+export async function registerDeployment(home, targetPath, entry, persistence = defaultRegistryPersistence) {
+    const registry = await persistence.load(home);
     registry.deployments[targetPath] = {
         ...entry,
         deployed: new Date().toISOString(),
     };
-    await saveRegistry(home, registry);
+    await persistence.save(home, registry);
 }
-export async function unregisterDeployment(home, targetPath) {
-    const registry = await loadRegistry(home);
+export async function unregisterDeployment(home, targetPath, persistence = defaultRegistryPersistence) {
+    const registry = await persistence.load(home);
     if (!(targetPath in registry.deployments))
         return;
     delete registry.deployments[targetPath];
-    await saveRegistry(home, registry);
+    await persistence.save(home, registry);
 }
-export async function lookupDeployment(home, targetPath) {
-    const registry = await loadRegistry(home);
+export async function lookupDeployment(home, targetPath, persistence = defaultRegistryPersistence) {
+    const registry = await persistence.load(home);
     return registry.deployments[targetPath] ?? null;
 }
-export async function verifyDeployment(home, targetPath, expected) {
-    const entry = await lookupDeployment(home, targetPath);
+export async function verifyDeployment(home, targetPath, expected, persistence = defaultRegistryPersistence) {
+    const entry = await lookupDeployment(home, targetPath, persistence);
     if (!entry)
         return null;
     if (entry.kind !== expected.kind)

package/dist/core/resolve.d.ts

@@ -9,3 +9,4 @@ export declare function resolveAgentSkillPathFor(agent: AgentConfig, skillName:
 export declare function resolveAgentDetectPathFor(agent: AgentConfig, home: string, platform: "posix" | "windows"): string;
 export declare function resolveAgentSkillPath(agent: AgentConfig, skillName: string, home: string): string;
 export declare function resolveAgentDetectPath(agent: AgentConfig, home: string): string;
+export declare function resolvePlaceholders(segments: string[], skillName: string, home: string): string;

package/dist/core/resolve.js

@@ -1,8 +1,8 @@
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import os from "node:os";
-import path from "node:path";
 import { UserError } from "../errors.js";
+import { getPathApi, resolveRuntimePaths } from "./runtime-paths.js";
 export function resolveHome() {
     if (process.platform === "win32") {
         return os.homedir();
@@ -96,14 +96,13 @@ export function resolveAgentSkillPath(agent, skillName, home) {
 export function resolveAgentDetectPath(agent, home) {
     return resolveAgentDetectPathFor(agent, home, getPlatformKey());
 }
-function resolvePlaceholders(segments, skillName, 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");
+export function resolvePlaceholders(segments, skillName, home) {
+    const { appdata, xdgConfig } = resolveRuntimePaths(home);
     const resolved = segments.map((seg) => seg
         .replace("{home}", home)
         .replace("{name}", skillName)
         .replace("{appdata}", appdata)
         .replace("{xdg_config}", xdgConfig));
-    return path.join(...resolved);
+    const root = resolved.find((segment) => segment.length > 0) ?? home;
+    return getPathApi(root).join(...resolved);
 }

package/dist/core/revert.d.ts

@@ -1,7 +1,8 @@
 import type { AgentId, Manifest, PlannedChange, RevertAction } from "../types.ts";
+import { type RegistryPersistence } from "./ownership.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<{
+export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean, home: string, deps?: RevertDependencies): Promise<{
     succeeded: number;
     skipped: number;
     failed: Array<{
@@ -10,3 +11,7 @@ export declare function executeRevert(actions: RevertAction[], dryRun: boolean,
     }>;
     planned: PlannedChange[];
 }>;
+interface RevertDependencies {
+    registry?: RegistryPersistence;
+}
+export {};