@kuznai/inception-engine 0.19.0 → 0.20.0

package/dist/{core → src/core}/revert.js

@@ -3,6 +3,7 @@ import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
 import { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, } from "./adapters/index.js";
 import { revertTomlMcpPatch } from "./adapters/toml.js";
+import { applyUndoPatch } from "./merge-patch.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
@@ -112,24 +113,6 @@ async function readJsonConfig(filePath) {
     }
     return parsed;
 }
-function isPlainObject(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function applyUndoPatch(current, undoPatch) {
-    const restored = { ...current };
-    for (const [key, originalValue] of Object.entries(undoPatch)) {
-        if (originalValue === null) {
-            delete restored[key];
-        }
-        else if (isPlainObject(originalValue) && isPlainObject(restored[key])) {
-            restored[key] = applyUndoPatch(restored[key], originalValue);
-        }
-        else {
-            restored[key] = originalValue;
-        }
-    }
-    return restored;
-}
 function lstatOutcome(err) {
     if (err.code === "ENOENT") {
         return { outcome: "skip" };
@@ -157,14 +140,7 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
                 result = await revertTomlPatch(action, dryRun, verbose, home, planned, deps);
                 break;
             case "frontmatter-emit":
-                // Frontmatter-emit files are fully managed by inception — revert
-                // deletes the file, same as a file-write revert.
-                result = await revertFileWrite({
-                    kind: "file-write",
-                    skill: action.skill,
-                    agent: action.agent,
-                    target: action.target,
-                }, dryRun, verbose, home, planned, deps);
+                result = await revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
                 break;
             default: {
                 throw new Error(`Unhandled revert action kind: ${action.kind}`);
@@ -179,6 +155,90 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
         planned,
     };
 }
+function isManagedFrontmatterEntry(entry, action) {
+    return (entry !== null &&
+        entry.kind === "frontmatter-emit" &&
+        entry.skill === action.skill &&
+        entry.agent === action.agent);
+}
+async function loadManagedFrontmatterEntry(action, home, deps) {
+    const entry = await lookupDeployment(home, action.target, deps.registry);
+    return isManagedFrontmatterEntry(entry, action) ? entry : null;
+}
+function planFrontmatterRevert(action, frontmatterEntry, planned) {
+    planned.push({
+        verb: "unapply-patch",
+        kind: "frontmatter-emit",
+        skill: action.skill,
+        agent: action.agent,
+        target: action.target,
+        patch: frontmatterEntry.undoPatch,
+    });
+    return { outcome: "ok" };
+}
+async function applyFrontmatterRevert(action, frontmatterEntry) {
+    const frontmatterAdapter = await import("./adapters/frontmatter.js");
+    const current = await frontmatterAdapter.readFrontmatterDocumentFile(action.target);
+    const restoredFrontmatter = applyUndoPatch(current.attributes, frontmatterEntry.undoPatch ?? {});
+    const shouldDeleteFile = frontmatterEntry.created === true &&
+        !frontmatterEntry.hadFrontmatter &&
+        Object.keys(restoredFrontmatter).length === 0 &&
+        current.body.trim() === "";
+    if (shouldDeleteFile) {
+        await unlink(action.target);
+        return { shouldDeleteFile };
+    }
+    const restoredContent = frontmatterAdapter.buildMarkdownDocument(restoredFrontmatter, current.body, { hasFrontmatter: frontmatterEntry.hadFrontmatter ?? false });
+    await writeFile(action.target, restoredContent, "utf-8");
+    return { shouldDeleteFile };
+}
+async function revertFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await lstat(action.target);
+    }
+    catch (err) {
+        const result = lstatOutcome(err);
+        if (result.outcome === "skip") {
+            logger.skip(label, "(not found, skipping)");
+            return result;
+        }
+        logger.fail(label, result.error);
+        return result;
+    }
+    const frontmatterEntry = await loadManagedFrontmatterEntry(action, home, deps);
+    if (!frontmatterEntry) {
+        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
+        return { outcome: "skip" };
+    }
+    if (!frontmatterEntry.undoPatch) {
+        return revertFileWrite({
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        }, dryRun, verbose, home, planned, deps);
+    }
+    if (dryRun) {
+        return planFrontmatterRevert(action, frontmatterEntry, planned);
+    }
+    try {
+        const { shouldDeleteFile } = await applyFrontmatterRevert(action, frontmatterEntry);
+        await unregisterDeployment(home, action.target, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(shouldDeleteFile
+                ? `removed: ${action.target}`
+                : `unapplied frontmatter patch from: ${action.target}`);
+        }
+        return { outcome: "ok" };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { outcome: "fail", error: msg };
+    }
+}
 async function executeRevertAction(action, dryRun, verbose, home, planned, deps) {
     const label = `${action.skill} -> ${action.agent}`;
     try {

package/dist/{core → src/core}/validation.js

@@ -135,6 +135,23 @@ function validateCodexPermissions(config, entryName) {
         throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "codex" must define "approval_policy" as one of: ${CODEX_APPROVAL_POLICY_VALUES.join(", ")}`);
     }
 }
+function validateOpenCodePermissions(config, entryName) {
+    rejectUnknownKeys(config, ["permissions"], entryName, "opencode");
+    const perms = config.permissions;
+    if (perms === undefined)
+        return;
+    if (typeof perms !== "object" || perms === null || Array.isArray(perms)) {
+        throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "opencode" must define "permissions" as an object`);
+    }
+    const permsObj = perms;
+    for (const key of ["allow", "ask", "deny"]) {
+        const val = permsObj[key];
+        if (val !== undefined &&
+            (!Array.isArray(val) || val.some((item) => typeof item !== "string"))) {
+            throw new UserError("DEPLOY_FAILED", `permissions entry "${entryName}" for agent "opencode" must define "permissions.${key}" as an array of strings when present`);
+        }
+    }
+}
 export function validatePermissionsConfigShape(config, entryName, agentId) {
     if (agentId === "claude-code") {
         validateClaudeCodePermissions(config, entryName);
@@ -142,6 +159,9 @@ export function validatePermissionsConfigShape(config, entryName, agentId) {
     else if (agentId === "codex") {
         validateCodexPermissions(config, entryName);
     }
+    else if (agentId === "opencode") {
+        validateOpenCodePermissions(config, entryName);
+    }
 }
 export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
     const extension = path.extname(manifestPath).toLowerCase();

package/dist/{schemas → src/schemas}/manifest.d.ts

@@ -59,6 +59,11 @@ export declare const McpServerEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        repo: "repo";
+        workspace: "workspace";
+    }>>;
 }, z.core.$strip>;
 export declare const AgentRuleEntrySchema: z.ZodObject<{
     name: z.ZodString;
@@ -100,6 +105,11 @@ export declare const AgentDefinitionEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     path: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        repo: "repo";
+        workspace: "workspace";
+    }>>;
 }, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
@@ -151,6 +161,11 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            global: "global";
+            repo: "repo";
+            workspace: "workspace";
+        }>>;
     }, z.core.$strip>>>;
     agentRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -192,6 +207,11 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
         path: z.ZodString;
+        scope: z.ZodDefault<z.ZodEnum<{
+            global: "global";
+            repo: "repo";
+            workspace: "workspace";
+        }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;

package/dist/{schemas → src/schemas}/manifest.js

@@ -83,6 +83,12 @@ export const McpServerEntrySchema = z.object({
     // Raw server descriptor passed verbatim to each agent adapter.
     // Adapters are responsible for validating the shape they need.
     config: z.record(z.string(), z.unknown()),
+    // Deployment scope: "global" (default) targets the agent's user-level MCP
+    // config file. "repo" and "workspace" target repo- or workspace-relative
+    // config files for agents that support them (e.g. GitHub Copilot's
+    // .vscode/mcp.json). For agents without scope-specific surfaces the
+    // adapter falls back to the global surface or emits a warning.
+    scope: z.enum(["global", "repo", "workspace"]).default("global"),
 });
 export const AgentRuleEntrySchema = z.object({
     name: nameField,
@@ -103,6 +109,7 @@ export const PermissionsEntrySchema = z.object({
     // Raw permission config payload validated per agent by the permissions adapter.
     // For claude-code: { permissions: { allow?: string[], deny?: string[] } }
     // For codex: { approval_policy?: "auto" | "manual" | "suggest" | "on-failure" }
+    // For opencode: { permissions: { allow?: string[], ask?: string[], deny?: string[] } }
     config: z.record(z.string(), z.unknown()),
 });
 export const AgentDefinitionEntrySchema = z.object({
@@ -112,6 +119,10 @@ export const AgentDefinitionEntrySchema = z.object({
     // Must be a .md or .markdown file. Structural requirements (e.g. YAML
     // frontmatter) are validated per agent requirements by the adapter.
     path: sourcePathField,
+    // Deployment scope: "global" targets the agent's home-directory definition
+    // directory (if supported), "repo" targets the project-root definition directory
+    // within the deployed repository (default).
+    scope: z.enum(["global", "repo", "workspace"]).default("repo"),
 });
 export const ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {

package/dist/{schemas → src/schemas}/registry.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 declare const SkillDirRegistryEntrySchema: z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"skill-dir">;
     source: z.ZodString;
     skill: z.ZodString;
@@ -18,6 +20,8 @@ declare const SkillDirRegistryEntrySchema: z.ZodObject<{
     deployed: z.ZodString;
 }, z.core.$strip>;
 declare const FileWriteRegistryEntrySchema: z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"file-write">;
     source: z.ZodString;
     skill: z.ZodString;
@@ -32,6 +36,8 @@ declare const FileWriteRegistryEntrySchema: z.ZodObject<{
     deployed: z.ZodString;
 }, z.core.$strip>;
 declare const ConfigPatchRegistryEntrySchema: z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"config-patch">;
     patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -47,7 +53,13 @@ declare const ConfigPatchRegistryEntrySchema: z.ZodObject<{
     deployed: z.ZodString;
 }, z.core.$strip>;
 declare const FrontmatterEmitRegistryEntrySchema: z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"frontmatter-emit">;
+    patch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    undoPatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created: z.ZodOptional<z.ZodBoolean>;
+    hadFrontmatter: z.ZodOptional<z.ZodBoolean>;
     skill: z.ZodString;
     agent: z.ZodEnum<{
         "claude-code": "claude-code";
@@ -60,6 +72,8 @@ declare const FrontmatterEmitRegistryEntrySchema: z.ZodObject<{
     deployed: z.ZodString;
 }, z.core.$strip>;
 export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"skill-dir">;
     source: z.ZodString;
     skill: z.ZodString;
@@ -77,6 +91,8 @@ export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>>;
     deployed: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"file-write">;
     source: z.ZodString;
     skill: z.ZodString;
@@ -90,6 +106,8 @@ export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     deployed: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"config-patch">;
     patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -104,7 +122,13 @@ export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     deployed: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
+    surfaceId: z.ZodOptional<z.ZodString>;
+    migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kind: z.ZodLiteral<"frontmatter-emit">;
+    patch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    undoPatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created: z.ZodOptional<z.ZodBoolean>;
+    hadFrontmatter: z.ZodOptional<z.ZodBoolean>;
     skill: z.ZodString;
     agent: z.ZodEnum<{
         "claude-code": "claude-code";
@@ -119,6 +143,8 @@ export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export declare const RegistrySchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     deployments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        surfaceId: z.ZodOptional<z.ZodString>;
+        migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
         kind: z.ZodLiteral<"skill-dir">;
         source: z.ZodString;
         skill: z.ZodString;
@@ -136,6 +162,8 @@ export declare const RegistrySchema: z.ZodObject<{
         }>>;
         deployed: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        surfaceId: z.ZodOptional<z.ZodString>;
+        migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
         kind: z.ZodLiteral<"file-write">;
         source: z.ZodString;
         skill: z.ZodString;
@@ -149,6 +177,8 @@ export declare const RegistrySchema: z.ZodObject<{
         }>;
         deployed: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        surfaceId: z.ZodOptional<z.ZodString>;
+        migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
         kind: z.ZodLiteral<"config-patch">;
         patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -163,7 +193,13 @@ export declare const RegistrySchema: z.ZodObject<{
         }>;
         deployed: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        surfaceId: z.ZodOptional<z.ZodString>;
+        migratedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
         kind: z.ZodLiteral<"frontmatter-emit">;
+        patch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        undoPatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        created: z.ZodOptional<z.ZodBoolean>;
+        hadFrontmatter: z.ZodOptional<z.ZodBoolean>;
         skill: z.ZodString;
         agent: z.ZodEnum<{
             "claude-code": "claude-code";

package/dist/{schemas → src/schemas}/registry.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { AgentIdSchema } from "./manifest.js";
-const SkillDirRegistryEntrySchema = z.object({
+const RegistryOwnershipMetadataSchema = z.object({
+    surfaceId: z.string().optional(),
+    migratedFrom: z.array(z.string()).optional(),
+});
+const SkillDirRegistryEntrySchema = RegistryOwnershipMetadataSchema.extend({
     kind: z.literal("skill-dir"),
     source: z.string(),
     skill: z.string(),
@@ -8,14 +12,14 @@ const SkillDirRegistryEntrySchema = z.object({
     method: z.enum(["symlink", "copy"]).optional(),
     deployed: z.string(),
 });
-const FileWriteRegistryEntrySchema = z.object({
+const FileWriteRegistryEntrySchema = RegistryOwnershipMetadataSchema.extend({
     kind: z.literal("file-write"),
     source: z.string(),
     skill: z.string(),
     agent: AgentIdSchema,
     deployed: z.string(),
 });
-const ConfigPatchRegistryEntrySchema = z.object({
+const ConfigPatchRegistryEntrySchema = RegistryOwnershipMetadataSchema.extend({
     kind: z.literal("config-patch"),
     patch: z.record(z.string(), z.unknown()),
     undoPatch: z.record(z.string(), z.unknown()),
@@ -23,8 +27,12 @@ const ConfigPatchRegistryEntrySchema = z.object({
     agent: AgentIdSchema,
     deployed: z.string(),
 });
-const FrontmatterEmitRegistryEntrySchema = z.object({
+const FrontmatterEmitRegistryEntrySchema = RegistryOwnershipMetadataSchema.extend({
     kind: z.literal("frontmatter-emit"),
+    patch: z.record(z.string(), z.unknown()).optional(),
+    undoPatch: z.record(z.string(), z.unknown()).optional(),
+    created: z.boolean().optional(),
+    hadFrontmatter: z.boolean().optional(),
     skill: z.string(),
     agent: AgentIdSchema,
     deployed: z.string(),

package/dist/{types.d.ts → src/types.d.ts}

@@ -5,6 +5,7 @@ export interface AgentPaths {
     windows: string[];
 }
 export type Confidence = "documented" | "implementation-only" | "provisional";
+export type CapabilityKind = "skills" | "mcpServers" | "agentRules" | "permissions" | "agentDefinitions";
 export interface SupportedAgentSurface {
     status: "supported";
     /**
@@ -90,12 +91,23 @@ export interface AgentConfig {
     detectBinary: string | null;
     provenance: AgentProvenance;
     mcpSupport?: AgentSurfaceSupport;
+    mcpRepoSupport?: AgentSurfaceSupport;
+    mcpWorkspaceSupport?: AgentSurfaceSupport;
     agentRulesSupport?: AgentSurfaceSupport;
     agentRulesRepoSupport?: AgentSurfaceSupport;
     agentRulesWorkspaceSupport?: AgentSurfaceSupport;
     permissionsSupport?: AgentSurfaceSupport;
     agentDefinitionsSupport?: AgentSurfaceSupport;
+    agentDefinitionsRepoSupport?: AgentSurfaceSupport;
+    agentDefinitionsWorkspaceSupport?: AgentSurfaceSupport;
+    agentDefinitionsTomlSupport?: AgentSurfaceSupport;
+    agentDefinitionsTomlRepoSupport?: AgentSurfaceSupport;
     policyNote?: string;
+    /**
+     * A list of documented surfaces that are currently not safe to support directly.
+     * Preflight will emit warnings for these if the agent is targeted.
+     */
+    unsupportedSurfaces?: AgentSurfaceSupport[];
     /**
      * When true, instruction files deployed to this agent must include valid
      * YAML frontmatter. Drives validateInstructionFileRequirements without
@@ -127,6 +139,7 @@ export interface FileWriteDeployAction {
     source: string;
     target: string;
     confidence?: Confidence;
+    migratedFrom?: string[];
 }
 export interface ConfigPatchDeployAction {
     kind: "config-patch";

package/dist/test/helpers/fs.d.ts

@@ -0,0 +1,2 @@
+export declare function exists(p: string): Promise<boolean>;
+export declare function makeTmpDir(prefix?: string): Promise<string>;

package/dist/test/helpers/fs.js

@@ -0,0 +1,17 @@
+import { access, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function makeTmpDir(prefix = "ie-test-dir") {
+    const dir = path.join(os.tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}

package/dist/test/helpers/path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Normalize path separators to forward slashes for cross-platform path assertions.
+ * Use this instead of hard-coding POSIX separators in expected strings.
+ */
+export declare function normalizeSlashes(value: string): string;
+/**
+ * Assert that a path ends with the given POSIX-style suffix, normalizing separators.
+ * Use instead of: assert.ok(normalizeSlashes(p).endsWith("some/suffix"))
+ */
+export declare function assertPathEndsWith(actual: string, suffix: string, msg?: string): void;

package/dist/test/helpers/path.js

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+/**
+ * Normalize path separators to forward slashes for cross-platform path assertions.
+ * Use this instead of hard-coding POSIX separators in expected strings.
+ */
+export function normalizeSlashes(value) {
+    return value.replaceAll("\\", "/");
+}
+/**
+ * Assert that a path ends with the given POSIX-style suffix, normalizing separators.
+ * Use instead of: assert.ok(normalizeSlashes(p).endsWith("some/suffix"))
+ */
+export function assertPathEndsWith(actual, suffix, msg) {
+    assert.ok(normalizeSlashes(actual).endsWith(suffix), msg ?? `Expected path "${actual}" to end with "${suffix}"`);
+}

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

@@ -0,0 +1,7 @@
+interface SkillDirScenarioOptions {
+    method: "symlink" | "copy";
+    assertManagedTarget(target: string, source: string, expectedSkillMd: string): Promise<void>;
+}
+export declare function registerSharedSkillDirDeployScenarios(options: SkillDirScenarioOptions): void;
+export declare function registerSharedSkillDirRevertScenarios(options: SkillDirScenarioOptions): void;
+export {};