@kuznai/inception-engine 0.24.0 → 0.25.1

package/dist/src/core/revert.js

@@ -1,12 +1,14 @@
-import { lstat, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import { lstat, readFile, rm, unlink } from "node:fs/promises";
 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 * as frontmatterAdapter from "./adapters/frontmatter.js";
 import { compileAgentDefinitionReverts, compileAgentRuleReverts, compileExecutionConfigReverts, compileHookReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
+import { writeFileAtomic } from "./atomic-write.js";
 import { applyUndoPatch } from "./merge-patch.js";
-import { lookupDeployment, registryDirPath, unregisterDeployment, } from "./ownership.js";
+import { defaultRegistryPersistence, lookupDeployment, RunRegistry, registryDirPath, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
 function buildSkillDirReverts(manifest, home, agentFilter) {
@@ -111,11 +113,11 @@ async function readJsonConfig(filePath) {
     try {
         parsed = JSON.parse(rawContent);
     }
-    catch {
-        throw new Error(`Config file is not valid JSON: ${filePath}`);
+    catch (err) {
+        throw new UserError("DEPLOY_FAILED", `Config file is not valid JSON: ${filePath}`, { cause: err });
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error(`Config file is not a JSON object: ${filePath}`);
+        throw new UserError("DEPLOY_FAILED", `Config file is not a JSON object: ${filePath}`);
     }
     return parsed;
 }
@@ -174,27 +176,48 @@ async function preflightManagedSkillDirRevert(action, label, home, deps) {
     }
     return null;
 }
-export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
+export async function executeRevert(actions, dryRun, verbose, home, deps = {}, signal) {
     const failed = [];
     const planned = [];
     const counts = { succeeded: 0, skipped: 0 };
+    const runRegistry = new RunRegistry(deps.registry ?? defaultRegistryPersistence);
+    const depsWithRegistry = {
+        ...deps,
+        registry: runRegistry,
+    };
+    if (!dryRun) {
+        try {
+            await runRegistry.preflight(home);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                succeeded: 0,
+                skipped: 0,
+                failed: actions.map((action) => ({ action, error: message })),
+                planned,
+            };
+        }
+    }
     for (const action of actions) {
+        if (signal?.aborted)
+            break;
         let result;
         switch (action.kind) {
             case "skill-dir":
-                result = await executeRevertAction(action, dryRun, verbose, home, planned, deps);
+                result = await executeRevertAction(action, dryRun, verbose, home, planned, depsWithRegistry);
                 break;
             case "file-write":
-                result = await revertFileWrite(action, dryRun, verbose, home, planned, deps);
+                result = await revertFileWrite(action, dryRun, verbose, home, planned, depsWithRegistry);
                 break;
             case "config-patch":
-                result = await revertConfigPatch(action, dryRun, verbose, home, planned, deps);
+                result = await revertConfigPatch(action, dryRun, verbose, home, planned, depsWithRegistry);
                 break;
             case "toml-patch":
-                result = await revertTomlPatch(action, dryRun, verbose, home, planned, deps);
+                result = await revertTomlPatch(action, dryRun, verbose, home, planned, depsWithRegistry);
                 break;
             case "frontmatter-emit":
-                result = await revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
+                result = await revertFrontmatterEmit(action, dryRun, verbose, home, planned, depsWithRegistry);
                 break;
             default: {
                 throw new Error(`Unhandled revert action kind: ${action.kind}`);
@@ -202,6 +225,9 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
         }
         recordOutcome(result, action, counts, failed);
     }
+    if (!dryRun) {
+        await runRegistry.flush(home);
+    }
     return {
         succeeded: counts.succeeded,
         skipped: counts.skipped,
@@ -242,7 +268,7 @@ async function applyFrontmatterRevert(action, frontmatterEntry) {
         return { shouldDeleteFile };
     }
     const restoredContent = frontmatterAdapter.buildMarkdownDocument(restoredFrontmatter, current.body, { hasFrontmatter: frontmatterEntry.hadFrontmatter ?? false });
-    await writeFile(action.target, restoredContent, "utf-8");
+    await writeFileAtomic(action.target, restoredContent);
     return { shouldDeleteFile };
 }
 async function revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
@@ -445,7 +471,7 @@ async function revertConfigPatch(action, dryRun, verbose, home, planned, deps) {
     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 writeFileAtomic(action.target, `${JSON.stringify(restored, null, 2)}\n`);
         await unregisterDeployment(home, action.target, deps.registry);
         logger.ok(label);
         if (verbose) {

package/dist/src/core/runtime-paths.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { UserError } from "../errors.js";
 const TARGET_TEMPLATE_RE = /^\{(home|appdata|local_appdata|xdg_config|repo|workspace)\}(?<suffix>(?:[\\/].*)?)$/;
 export function getPathApi(root) {
     if (root.includes("\\") || /^[a-zA-Z]:/.test(root)) {
@@ -39,13 +40,13 @@ export function resolveRuntimePaths(home) {
 function resolveVfsPlaceholder(root, template, suffix, repo, workspace) {
     const rootPath = root === "repo" ? repo : (workspace ?? repo);
     if (!rootPath) {
-        throw new Error(`Target template uses {${root}} but no ${root} directory was provided: ${template}`);
+        throw new UserError("RESOLVE_FAILED", `Target template uses {${root}} but no ${root} directory was provided: ${template}`);
     }
     const segments = suffix.split(/[\\/]+/).filter(Boolean);
     const rootPathApi = getPathApi(rootPath);
     const resolved = segments.length === 0 ? rootPath : rootPathApi.join(rootPath, ...segments);
     if (!isSameOrDescendantPath(resolved, rootPath)) {
-        throw new Error(`Target template resolves outside its placeholder root: ${template}`);
+        throw new UserError("RESOLVE_FAILED", `Target template resolves outside its placeholder root: ${template}`);
     }
     return suffix === "" ? rootPath : `${rootPath}${suffix}`;
 }
@@ -53,7 +54,7 @@ export function resolveTargetTemplate(template, home, repo, workspace) {
     const { appdata, localAppdata, xdgConfig } = resolveRuntimePaths(home);
     const match = TARGET_TEMPLATE_RE.exec(template);
     if (!match) {
-        throw new Error(`Invalid target template: ${template}`);
+        throw new UserError("RESOLVE_FAILED", `Invalid target template: ${template}`);
     }
     const root = match[1];
     const suffix = match.groups?.suffix ?? "";
@@ -71,7 +72,7 @@ export function resolveTargetTemplate(template, home, repo, workspace) {
     const pathApi = getPathApi(base);
     const resolved = segments.length === 0 ? base : pathApi.join(base, ...segments);
     if (!isSameOrDescendantPath(resolved, base)) {
-        throw new Error(`Target template resolves outside its placeholder root: ${template}`);
+        throw new UserError("RESOLVE_FAILED", `Target template resolves outside its placeholder root: ${template}`);
     }
     return suffix === "" ? base : `${base}${suffix}`;
 }

package/dist/src/core/validation.js

@@ -60,7 +60,9 @@ export async function validateSourceFile(sourcePath, manifestPath) {
         stat = await lstat(sourcePath);
     }
     catch (err) {
-        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, manifestPath));
+        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, manifestPath), {
+            cause: err,
+        });
     }
     if (!stat.isFile()) {
         throw new UserError("DEPLOY_FAILED", `Source is not a file: ${manifestPath}`);
@@ -233,7 +235,7 @@ export async function validateSkillDefinitionFile(sourcePath, manifestPath) {
         raw = await readFile(sourcePath, "utf-8");
     }
     catch (err) {
-        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, `${manifestPath}/SKILL.md`));
+        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, `${manifestPath}/SKILL.md`), { cause: err });
     }
     const lines = raw.split(/\r?\n/);
     if (lines[0]?.trim() !== "---") {

package/dist/src/index.js

@@ -66,7 +66,7 @@ function parseCLI(argv) {
         });
     }
     catch (err) {
-        throw new UserError("INVALID_ARGS", err.message);
+        throw new UserError("INVALID_ARGS", err.message, { cause: err });
     }
     const { values, positionals } = parsed;
     if (values.help) {
@@ -128,16 +128,17 @@ async function main() {
             dryRun: options.dryRun,
             force: options.force,
             verbose: options.verbose,
+            signal: controller.signal,
         });
     }
     const manifest = await loadManifest(options.directory);
     const home = resolveHome();
     if (options.command === "deploy") {
-        return runDeploy(options, manifest, home);
+        return runDeploy(options, manifest, home, controller.signal);
     }
-    return runRevert(options, manifest, home);
+    return runRevert(options, manifest, home, controller.signal);
 }
-async function runDeploy(options, manifest, home) {
+async function runDeploy(options, manifest, home, signal) {
     let detectedAgents;
     if (options.agents) {
         detectedAgents = options.agents;
@@ -156,12 +157,12 @@ async function runDeploy(options, manifest, home) {
             logger.info(`Detected agents: ${detectedAgents.join(", ")}`);
         }
     }
-    const preflightWarnings = await runPreflight(options, manifest, home, detectedAgents);
+    const preflightWarnings = await runPreflight(options, manifest, home, detectedAgents, signal);
     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);
+    const { actions, warnings: planWarnings } = await planDeploy(manifest, options.directory, detectedAgents, home, undefined, undefined, signal);
     for (const w of planWarnings) {
         logger.warn("plan", w.message);
     }
@@ -170,7 +171,7 @@ async function runDeploy(options, manifest, home) {
         return 0;
     }
     logger.info(`${dryRunPrefix(options.dryRun)}Deploying ${actions.length} action(s):`);
-    const { succeeded, failed, planned } = await executeDeploy(actions, options.dryRun, options.verbose, home);
+    const { succeeded, failed, planned } = await executeDeploy(actions, options.dryRun, options.verbose, home, {}, signal);
     if (options.dryRun) {
         logger.info("");
         logger.info(formatDryRunPlan(planned));
@@ -185,7 +186,7 @@ async function runDeploy(options, manifest, home) {
     logger.info(`${succeeded} action(s) deployed`);
     return 0;
 }
-async function runRevert(options, manifest, home) {
+async function runRevert(options, manifest, home, signal) {
     const actions = options.agents
         ? planRevert(manifest, options.agents, home)
         : planRevertAll(manifest, home);
@@ -194,7 +195,7 @@ async function runRevert(options, manifest, home) {
         return 0;
     }
     logger.info(`${dryRunPrefix(options.dryRun)}Reverting ${actions.length} action(s):`);
-    const { succeeded, skipped, failed, planned } = await executeRevert(actions, options.dryRun, options.verbose, home);
+    const { succeeded, skipped, failed, planned } = await executeRevert(actions, options.dryRun, options.verbose, home, {}, signal);
     if (options.dryRun) {
         logger.info("");
         logger.info(formatDryRunPlan(planned));
@@ -223,22 +224,51 @@ const USER_ERROR_EXIT = {
     RESOLVE_FAILED: 1,
 };
 const debugMode = process.argv.includes("--debug");
+// Root cancellation controller. Signal handlers abort this when the user
+// interrupts the process so long-running loops can stop cooperatively.
+const controller = new AbortController();
+// Track whether a shutdown signal arrived while an operation was running.
+// When set, we preserve the signal exit code rather than overwriting it
+// with the operation result (which may be 0 if the operation completed
+// before the signal was processed).
+let shutdownSignal = null;
+function handleSignal(sig) {
+    if (shutdownSignal !== null)
+        return;
+    shutdownSignal = sig;
+    process.stderr.write(`\nReceived ${sig}, finishing current operation...\n`);
+    // Standard Unix convention: 128 + signal number (SIGINT=2, SIGTERM=15)
+    process.exitCode = sig === "SIGINT" ? 130 : 143;
+    controller.abort();
+}
+process.on("SIGINT", () => handleSignal("SIGINT"));
+process.on("SIGTERM", () => handleSignal("SIGTERM"));
 try {
-    process.exit(await main());
+    const code = await main();
+    if (shutdownSignal === null) {
+        process.exitCode = code;
+    }
 }
 catch (err) {
     if (err instanceof UserError) {
         logger.error(`Error: ${err.message}`);
+        if (err.cause instanceof Error && err.cause.message) {
+            logger.error(`Caused by: ${err.cause.message}`);
+        }
         if (debugMode) {
             logger.errorRaw(err);
         }
-        process.exit(USER_ERROR_EXIT[err.code]);
+        if (shutdownSignal === null) {
+            process.exitCode = USER_ERROR_EXIT[err.code];
+        }
     }
     else {
         logger.error("Unexpected error. Run with --debug for details.");
         if (debugMode) {
             logger.errorRaw(err);
         }
-        process.exit(1);
+        if (shutdownSignal === null) {
+            process.exitCode = 1;
+        }
     }
 }

package/dist/test/os/posix/deploy.test.js

@@ -6,7 +6,7 @@ import { executeDeploy, planDeploy } from "../../../src/core/deploy.js";
 import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
 import { UserError } from "../../../src/errors.js";
 import { exists, makeTmpDir } from "../../helpers/fs.js";
-import { createSkillSource, testSkillManifest, } from "../../helpers/skill-dir.js";
+import { createFailingRegistryPersistence, createSkillSource, testSkillManifest, } from "../../helpers/skill-dir.js";
 describe("executeDeploy (POSIX)", {
     skip: process.platform === "win32",
 }, () => {
@@ -289,7 +289,6 @@ describe("atomic redeploy behavior (POSIX)", {
     it("restores the backup when registry write fails", async () => {
         const sourceDir = await makeTmpDir();
         const home = await makeTmpDir();
-        const registryFile = path.join(home, ".inception-engine", "registry.json");
         try {
             await createSkillSource(sourceDir, "skills/test-skill");
             const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
@@ -298,8 +297,11 @@ describe("atomic redeploy behavior (POSIX)", {
             const { succeeded: firstSucceeded } = await executeDeploy(actions, false, false, home);
             assert.equal(firstSucceeded, 1);
             const originalLink = await readlink(target);
-            await chmod(registryFile, 0o444);
-            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            // Use a mock registry that always fails on save. Using chmod on the
+            // registry file is not reliable because writeFileAtomic uses rename(),
+            // which only requires directory write permission (not file permission),
+            // and would also silently succeed when running as root.
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home, { registry: createFailingRegistryPersistence() });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
             assert.ok(!(await exists(backupPath)));
@@ -308,12 +310,6 @@ describe("atomic redeploy behavior (POSIX)", {
             assert.equal(await readlink(target), originalLink);
         }
         finally {
-            try {
-                await chmod(registryFile, 0o644);
-            }
-            catch {
-                // best effort
-            }
             await rm(sourceDir, { recursive: true, force: true });
             await rm(home, { recursive: true, force: true });
         }

package/dist/test/os/windows/deploy.test.js

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import { chmod, mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { describe, it } from "node:test";
 import { executeDeploy, planDeploy } from "../../../src/core/deploy.js";
-import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
+import { defaultRegistryPersistence, lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
 import { UserError } from "../../../src/errors.js";
 import { exists, makeTmpDir } from "../../helpers/fs.js";
 import { createSkillSource, testSkillManifest, } from "../../helpers/skill-dir.js";
@@ -215,9 +215,16 @@ describe("atomic redeploy behavior (Windows)", {
             const backupPath = `${target}.inception-backup`;
             const { succeeded: firstSucceeded } = await executeDeploy(actions, false, false, home);
             assert.equal(firstSucceeded, 1);
-            const registryFile = path.join(home, ".inception-engine", "registry.json");
-            await chmod(registryFile, 0o444);
-            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            // Simulate an unwritable registry via a failing RegistryPersistence
+            // instead of relying on chmod, which is not enforced for admin processes
+            // on Windows (e.g. GitHub Actions windows-latest runners).
+            const failingRegistry = {
+                load: (h) => defaultRegistryPersistence.load(h),
+                save: async () => {
+                    throw Object.assign(new Error("EACCES: permission denied, open 'registry.json'"), { code: "EACCES" });
+                },
+            };
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home, { registry: failingRegistry });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
             assert.ok(!(await exists(backupPath)));
@@ -225,12 +232,6 @@ describe("atomic redeploy behavior (Windows)", {
             assert.ok(await exists(path.join(target, "SKILL.md")));
         }
         finally {
-            try {
-                await chmod(path.join(home, ".inception-engine", "registry.json"), 0o666);
-            }
-            catch {
-                // best effort
-            }
             await rm(sourceDir, { recursive: true, force: true });
             await rm(home, { recursive: true, force: true });
         }

package/dist/test/unit/atomic-write.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/atomic-write.test.js

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { writeFileAtomic } from "../../src/core/atomic-write.js";
+import { exists, makeTmpDir } from "../helpers/fs.js";
+describe("writeFileAtomic", () => {
+    it("creates a file with the correct content", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const target = path.join(dir, "output.txt");
+            await writeFileAtomic(target, "hello world");
+            const content = await readFile(target, "utf-8");
+            assert.equal(content, "hello world");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("overwrites an existing file", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const target = path.join(dir, "output.txt");
+            await writeFile(target, "old content", "utf-8");
+            await writeFileAtomic(target, "new content");
+            const content = await readFile(target, "utf-8");
+            assert.equal(content, "new content");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("creates parent directory if it does not exist", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const target = path.join(dir, "nested", "deep", "output.txt");
+            await writeFileAtomic(target, "nested content");
+            const content = await readFile(target, "utf-8");
+            assert.equal(content, "nested content");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("leaves no orphan temp file after successful write", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const target = path.join(dir, "output.txt");
+            await writeFileAtomic(target, "content");
+            // Ensure no .inception-tmp-* files remain
+            const { readdir } = await import("node:fs/promises");
+            const entries = await readdir(dir);
+            const temps = entries.filter((e) => e.includes(".inception-tmp-"));
+            assert.equal(temps.length, 0, `Unexpected temp files: ${temps.join(", ")}`);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("does not leave a partial file at the target when the target dir is read-only", async () => {
+        // Skip on Windows where chmod semantics differ
+        if (process.platform === "win32")
+            return;
+        const dir = await makeTmpDir();
+        try {
+            const { chmod } = await import("node:fs/promises");
+            const subdir = path.join(dir, "readonly");
+            const { mkdir } = await import("node:fs/promises");
+            await mkdir(subdir, { recursive: true });
+            await chmod(subdir, 0o555); // remove write permission
+            const target = path.join(subdir, "output.txt");
+            await assert.rejects(() => writeFileAtomic(target, "content"));
+            // Target should not exist after failure
+            assert.equal(await exists(target), false);
+        }
+        finally {
+            const { chmod } = await import("node:fs/promises");
+            await chmod(path.join(dir, "readonly"), 0o755).catch((_e) => {
+                /* best-effort restore */
+            });
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("respects custom encoding option", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const target = path.join(dir, "output.txt");
+            await writeFileAtomic(target, "utf8 content", { encoding: "utf-8" });
+            const content = await readFile(target, "utf-8");
+            assert.equal(content, "utf8 content");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/unit/deploy.test.js

@@ -1287,7 +1287,7 @@ describe("executeDeploy — file-write", () => {
             await rm(home, { recursive: true, force: true });
         }
     });
-    it("rolls back a newly written file when registry persistence fails", async () => {
+    it("aborts deploy without writing any files when registry is not writable", async () => {
         const sourceDir = await makeTmpDir();
         const home = await makeTmpDir();
         try {
@@ -1309,10 +1309,13 @@ describe("executeDeploy — file-write", () => {
                     throw new Error("registry unavailable");
                 },
             };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home, { registry: failingRegistry });
+            const { succeeded, failed } = await executeDeploy([action], false, false, home, {
+                registry: failingRegistry,
+            });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
-            assert.ok(!(await exists(targetFile)), "target file should be rolled back");
+            assert.match(failed[0]?.error ?? "", /registry unavailable/);
+            assert.ok(!(await exists(targetFile)), "target file should not be written");
             assert.ok(!(await exists(`${targetFile}.inception-backup`)));
         }
         finally {
@@ -1320,7 +1323,7 @@ describe("executeDeploy — file-write", () => {
             await rm(home, { recursive: true, force: true });
         }
     });
-    it("restores the previous managed file when registry persistence fails during overwrite", async () => {
+    it("aborts deploy without touching managed files when registry is not writable", async () => {
         const sourceDir = await makeTmpDir();
         const home = await makeTmpDir();
         try {
@@ -1328,23 +1331,19 @@ describe("executeDeploy — file-write", () => {
             const targetFile = path.join(home, "managed.txt");
             await writeFile(sourceFile, "new content");
             await writeFile(targetFile, "old content");
-            let loadCount = 0;
             const failingRegistry = {
                 async load() {
-                    loadCount += 1;
                     return {
                         version: 1,
-                        deployments: loadCount === 1
-                            ? {
-                                [targetFile]: {
-                                    kind: "file-write",
-                                    source: sourceFile,
-                                    skill: "test-skill",
-                                    agent: "claude-code",
-                                    deployed: new Date().toISOString(),
-                                },
-                            }
-                            : {},
+                        deployments: {
+                            [targetFile]: {
+                                kind: "file-write",
+                                source: sourceFile,
+                                skill: "test-skill",
+                                agent: "claude-code",
+                                deployed: new Date().toISOString(),
+                            },
+                        },
                     };
                 },
                 async save() {
@@ -1358,9 +1357,12 @@ describe("executeDeploy — file-write", () => {
                 source: sourceFile,
                 target: targetFile,
             };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home, { registry: failingRegistry });
+            const { succeeded, failed } = await executeDeploy([action], false, false, home, {
+                registry: failingRegistry,
+            });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error ?? "", /registry unavailable/);
             assert.equal(await readFile(targetFile, "utf-8"), "old content");
             assert.ok(!(await exists(`${targetFile}.inception-backup`)));
         }
@@ -1718,7 +1720,7 @@ describe("executeDeploy — config-patch", () => {
             await rm(home, { recursive: true, force: true });
         }
     });
-    it("restores the original config when registry persistence fails after patching", async () => {
+    it("aborts deploy without patching config when registry is not writable", async () => {
         const home = await makeTmpDir();
         try {
             const configFile = path.join(home, "config.json");
@@ -1738,9 +1740,12 @@ describe("executeDeploy — config-patch", () => {
                     throw new Error("registry unavailable");
                 },
             };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home, { registry: failingRegistry });
+            const { succeeded, failed } = await executeDeploy([action], false, false, home, {
+                registry: failingRegistry,
+            });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error ?? "", /registry unavailable/);
             assert.deepEqual(JSON.parse(await readFile(configFile, "utf-8")), {
                 a: 1,
                 b: 2,
@@ -1889,7 +1894,7 @@ describe("executeDeploy — frontmatter-emit", () => {
             await rm(home, { recursive: true, force: true });
         }
     });
-    it("restores the original markdown file when registry persistence fails", async () => {
+    it("aborts deploy without touching the markdown file when registry is not writable", async () => {
         const home = await makeTmpDir();
         try {
             const targetFile = path.join(home, ".agents", "rules", "my-mcp.md");
@@ -1911,9 +1916,12 @@ describe("executeDeploy — frontmatter-emit", () => {
                     throw new Error("registry unavailable");
                 },
             };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home, { registry: failingRegistry });
+            const { succeeded, failed } = await executeDeploy([action], false, false, home, {
+                registry: failingRegistry,
+            });
             assert.equal(succeeded, 0);
             assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error ?? "", /registry unavailable/);
             assert.equal(await readFile(targetFile, "utf-8"), original);
             assert.ok(!(await exists(`${targetFile}.inception-backup`)));
         }

package/dist/test/unit/formatters.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
-import { stripVTControlCharacters } from "node:util";
 import { describe, it } from "node:test";
+import { stripVTControlCharacters } from "node:util";
 import { formatDryRunPlan } from "../../src/formatters.js";
 function stripAnsi(value) {
     return stripVTControlCharacters(value);

package/dist/test/unit/init-fixture.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { describe, it } from "node:test";
 import { runInit } from "../../src/core/init.js";