@kuznai/inception-engine 0.19.0 → 0.20.0

package/dist/test/helpers/skill-dir-scenarios.js

@@ -0,0 +1,206 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { it } from "node:test";
+import { executeDeploy, planDeploy } from "../../src/core/deploy.js";
+import { lookupDeployment, registerDeployment, } from "../../src/core/ownership.js";
+import { executeRevert, planRevert } from "../../src/core/revert.js";
+import { exists, makeTmpDir } from "./fs.js";
+import { createFailingRegistryPersistence, createSkillSource, testSkillManifest, } from "./skill-dir.js";
+const FIRST_SKILL_MD = "---\nname: test\ndescription: First skill\n---\n# First";
+const SECOND_SKILL_MD = "---\nname: test\ndescription: Second skill\n---\n# Second";
+export function registerSharedSkillDirDeployScenarios(options) {
+    it("first deploy succeeds", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            const source = await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            await options.assertManagedTarget(actions[0]?.target, source, FIRST_SKILL_MD);
+            const entry = await lookupDeployment(home, actions[0]?.target);
+            assert.ok(entry);
+            assert.equal(entry.kind, "skill-dir");
+            assert.equal(entry.method, options.method);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("dry-run reports the planned skill-dir change only", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const { succeeded, failed, planned } = await executeDeploy(actions, true, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.equal(planned.length, 1);
+            assert.equal(planned[0]?.verb, options.method === "symlink" ? "create-symlink" : "copy-dir");
+            assert.ok(!(await exists(actions[0]?.target)));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("refuses to overwrite an unmanaged target", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "user.txt"), "user content");
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error, /not managed by inception-engine/);
+            assert.equal(await readFile(path.join(target, "user.txt"), "utf-8"), "user content");
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("refuses to overwrite a target with a mismatched registry entry", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "SKILL.md"), "other");
+            await registerDeployment(home, target, {
+                kind: "skill-dir",
+                source: "/other/source",
+                skill: "other-skill",
+                agent: "codex",
+                method: options.method,
+            });
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error, /not managed by inception-engine/);
+            assert.equal(await readFile(path.join(target, "SKILL.md"), "utf-8"), "other");
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("managed redeploy succeeds", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            const source = await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            await executeDeploy(actions, false, false, home);
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            await options.assertManagedTarget(actions[0]?.target, source, FIRST_SKILL_MD);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("restores the prior managed target when registry persistence fails", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            const firstSource = await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const firstAction = actions[0];
+            await executeDeploy([firstAction], false, false, home);
+            await writeFile(path.join(firstSource, "SKILL.md"), SECOND_SKILL_MD);
+            const failAction = {
+                ...firstAction,
+            };
+            const { succeeded, failed } = await executeDeploy([failAction], false, false, home, {
+                registry: createFailingRegistryPersistence(),
+            });
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.match(failed[0]?.error, /simulated registry persistence failure/);
+            await options.assertManagedTarget(firstAction.target, firstSource, FIRST_SKILL_MD);
+            assert.ok(!(await exists(`${firstAction.target}.inception-backup`)));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+}
+export function registerSharedSkillDirRevertScenarios(options) {
+    it("reverts a managed skill-dir target", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            await executeDeploy(actions, false, false, home);
+            const revertActions = planRevert(testSkillManifest, ["claude-code"], home);
+            const { succeeded, skipped, failed } = await executeRevert(revertActions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(skipped, 0);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(actions[0]?.target)));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("skips an unmanaged skill-dir target", async () => {
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            const revertActions = planRevert(testSkillManifest, ["claude-code"], home);
+            const target = revertActions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "SKILL.md"), FIRST_SKILL_MD);
+            const { succeeded, skipped, failed } = await executeRevert(revertActions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(skipped, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(target));
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("skips a target whose registry entry belongs to a different skill", async () => {
+        const sourceDir = await makeTmpDir("ie-skill-dir-source");
+        const home = await makeTmpDir("ie-skill-dir-home");
+        try {
+            const source = await createSkillSource(sourceDir, "skills/test-skill", FIRST_SKILL_MD);
+            const revertActions = planRevert(testSkillManifest, ["claude-code"], home);
+            const target = revertActions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "SKILL.md"), FIRST_SKILL_MD);
+            await registerDeployment(home, target, {
+                kind: "skill-dir",
+                source,
+                skill: "different-skill",
+                agent: "codex",
+                method: options.method,
+            });
+            const { succeeded, skipped, failed } = await executeRevert(revertActions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(skipped, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(target));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+}

package/dist/test/helpers/skill-dir.d.ts

@@ -0,0 +1,7 @@
+import type { RegistryPersistence } from "../../src/core/ownership.ts";
+import type { Manifest } from "../../src/types.ts";
+export declare function createSkillSource(baseDir: string, skillPath?: string, skillBody?: string): Promise<string>;
+export declare const testSkillManifest: Manifest;
+export declare function createFailingRegistryPersistence(error?: Error): RegistryPersistence;
+export declare function assertSymlinkTarget(target: string, source: string): Promise<void>;
+export declare function assertCopyTarget(target: string, expectedSkillMd: string): Promise<void>;

package/dist/test/helpers/skill-dir.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, readlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultRegistryPersistence } from "../../src/core/ownership.js";
+import { exists } from "./fs.js";
+export async function createSkillSource(baseDir, skillPath = "skills/test-skill", skillBody = "---\nname: test\ndescription: Test skill\n---\n# Test") {
+    const fullPath = path.join(baseDir, skillPath);
+    await mkdir(fullPath, { recursive: true });
+    await writeFile(path.join(fullPath, "SKILL.md"), skillBody);
+    return fullPath;
+}
+export const testSkillManifest = {
+    skills: [
+        {
+            name: "test-skill",
+            path: "skills/test-skill",
+            agents: ["claude-code"],
+        },
+    ],
+    files: [],
+    configs: [],
+    mcpServers: [],
+    agentRules: [],
+    permissions: [],
+    agentDefinitions: [],
+};
+export function createFailingRegistryPersistence(error = new Error("simulated registry persistence failure")) {
+    return {
+        load(home) {
+            return defaultRegistryPersistence.load(home);
+        },
+        async save() {
+            throw error;
+        },
+    };
+}
+export async function assertSymlinkTarget(target, source) {
+    assert.ok(await exists(target), "expected target to exist");
+    assert.ok((await lstat(target)).isSymbolicLink(), "expected a symlink target");
+    assert.equal(await readlink(target), source);
+}
+export async function assertCopyTarget(target, expectedSkillMd) {
+    assert.ok(await exists(target), "expected target to exist");
+    assert.ok(!(await lstat(target)).isSymbolicLink(), "expected a copied directory");
+    assert.equal(await readFile(path.join(target, "SKILL.md"), "utf-8"), expectedSkillMd);
+}

package/dist/test/os/cross-platform/cross-platform.test.d.ts

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

package/dist/test/os/cross-platform/cross-platform.test.js

@@ -0,0 +1,328 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { AGENT_REGISTRY } from "../../../src/config/agents.js";
+import { getDeployMethod, lookupHomeForUserWith, resolveAgentDetectPathFor, resolveAgentSkillPathFor, } from "../../../src/core/resolve.js";
+import { resolveTargetTemplate } from "../../../src/core/runtime-paths.js";
+import { UserError } from "../../../src/errors.js";
+const HOME = "/home/u";
+const SKILL = "s";
+const posixJoin = path.posix.join;
+const joinLikeRoot = (root, ...segments) => (root.includes("\\") || /^[a-zA-Z]:/.test(root)
+    ? path.win32
+    : path.posix).join(root, ...segments);
+function getAgent(id) {
+    const agent = AGENT_REGISTRY.find((a) => a.id === id);
+    assert.ok(agent, `agent "${id}" not found in AGENT_REGISTRY`);
+    return agent;
+}
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("codex", () => {
+        const agent = getAgent("codex");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".codex", "skills", SKILL));
+    });
+    it("gemini-cli", () => {
+        const agent = getAgent("gemini-cli");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "skills", SKILL));
+    });
+    it("antigravity", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+    it("opencode defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin("/custom/config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode ignores relative XDG_CONFIG_HOME and falls back to home/.config", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — windows", () => {
+    const p = "windows";
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), joinLikeRoot(appdata, "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("opencode falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, "AppData", "Roaming", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("antigravity uses home (same template as posix)", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+    it("opencode detect path defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode detect path uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin("/custom/config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("antigravity has nested detect path", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".gemini", "antigravity"));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — windows", () => {
+    const p = "windows";
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), joinLikeRoot(appdata, "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — getent path (linux)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — getent (linux)", () => {
+    const platform = "linux";
+    const noopRead = readFileSync; // won't be called in success cases
+    it("returns home from valid getent output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, noopRead), "/home/alice");
+    });
+    it("falls through on getent failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("getent: command not found");
+        });
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+    it("falls through when getent returns malformed output (no 6th field)", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "badinput");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — dscl path (darwin)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — dscl (darwin)", () => {
+    const platform = "darwin";
+    it("returns home from valid dscl output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: /Users/alice\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileSync), "/Users/alice");
+    });
+    it("falls through on dscl failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("dscl: record not found");
+        });
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+    it("falls through when dscl returns non-absolute home", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: \n");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — /etc/passwd fallback
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — /etc/passwd fallback", () => {
+    const platform = "linux";
+    const throwExec = ((_cmd, _args, _opts) => {
+        throw new Error("getent absent");
+    });
+    it("finds user among multiple users", () => {
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("bob", platform, throwExec, readFileFn), "/home/bob");
+    });
+    it("ignores lines with wrong username", () => {
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        // looking up "alice", should not return bob's home
+        assert.equal(lookupHomeForUserWith("alice", platform, throwExec, readFileFn), "/home/alice");
+    });
+    it("ignores passwd lines with non-absolute home field", () => {
+        // alice's home field is empty — should fall through to error
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000:::");
+        assert.throws(() => lookupHomeForUserWith("alice", platform, throwExec, readFileFn), (err) => err instanceof UserError && err.code === "RESOLVE_FAILED");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — all methods fail
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — all methods fail", () => {
+    it("throws UserError with code RESOLVE_FAILED", () => {
+        const throwExec = ((_cmd, _args, _opts) => {
+            throw new Error("no exec");
+        });
+        const throwRead = ((_p, _enc) => {
+            throw new Error("no read");
+        });
+        assert.throws(() => lookupHomeForUserWith("alice", "linux", throwExec, throwRead), (err) => {
+            assert.ok(err instanceof UserError);
+            assert.equal(err.code, "RESOLVE_FAILED");
+            assert.match(err.message, /Cannot determine home directory/);
+            return true;
+        });
+    });
+});
+describe("resolveTargetTemplate", () => {
+    it("uses APPDATA for Windows-style target templates", () => {
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = "C:\\Users\\u\\AppData\\Roaming";
+            assert.equal(resolveTargetTemplate("{appdata}\\opencode\\AGENTS.md", "/unused/home"), "C:\\Users\\u\\AppData\\Roaming\\opencode\\AGENTS.md");
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveTargetTemplate("{appdata}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", "AppData", "Roaming")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("uses absolute XDG_CONFIG_HOME and ignores relative values", () => {
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), "/custom/config/opencode/AGENTS.md");
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", ".config")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+describe("getDeployMethod", () => {
+    it("returns a host-appropriate skill-dir deployment method", () => {
+        assert.equal(getDeployMethod(), process.platform === "win32" ? "copy" : "symlink");
+    });
+});

package/dist/test/os/posix/skill-dir.test.d.ts

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

package/dist/test/os/posix/skill-dir.test.js

@@ -0,0 +1,19 @@
+import { describe } from "node:test";
+import { assertSymlinkTarget } from "../../helpers/skill-dir.js";
+import { registerSharedSkillDirDeployScenarios, registerSharedSkillDirRevertScenarios, } from "../../helpers/skill-dir-scenarios.js";
+describe("skill-dir deploy and revert (POSIX)", {
+    skip: process.platform === "win32",
+}, () => {
+    registerSharedSkillDirDeployScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+    registerSharedSkillDirRevertScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+});

package/dist/test/os/windows/revert-integration.test.d.ts

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