@kisev/skills-opencode 2.4.1 → 3.0.0

package/dist/doctor.js

@@ -328,7 +328,6 @@ function reconcileProjection(plan) {
         "current",
         "renamed",
         "retired",
-        "archive-pending",
         "modified_managed",
         "user_owned",
         "unknown",

package/dist/index.d.ts

@@ -49,74 +49,6 @@ declare const plugin: (input: PluginInput) => Promise<{
                 decision?: any;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
-        capabilities: {
-            description: string;
-            args: {};
-            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        doctor: {
-            description: string;
-            args: {
-                scope: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>>;
-            };
-            execute(args: {
-                scope: "global" | "project";
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        agent_profiles: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    list: "list";
-                    model_set: "model_set";
-                    critic_add: "critic_add";
-                    critic_remove: "critic_remove";
-                }>;
-                phase: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    preview: "preview";
-                    apply: "apply";
-                }>>;
-                scope: import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>;
-                name: import("zod").ZodOptional<import("zod").ZodString>;
-                model: import("zod").ZodOptional<import("zod").ZodString>;
-                variant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
-            };
-            execute(args: {
-                action: "list" | "model_set" | "critic_add" | "critic_remove";
-                scope: "global" | "project";
-                phase?: "preview" | "apply" | undefined;
-                name?: string | undefined;
-                model?: string | undefined;
-                variant?: string | null | undefined;
-                confirmation_digest?: string | undefined;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        reconcile: {
-            description: string;
-            args: {
-                phase: import("zod").ZodEnum<{
-                    preview: "preview";
-                    apply: "apply";
-                }>;
-                scope: import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>;
-                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
-            };
-            execute(args: {
-                phase: "preview" | "apply";
-                scope: "global" | "project";
-                confirmation_digest?: string | undefined;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
     };
     "tool.execute.before": (input: {
         tool: string;
@@ -173,74 +105,6 @@ export declare const server: (input: PluginInput) => Promise<{
                 decision?: any;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
         };
-        capabilities: {
-            description: string;
-            args: {};
-            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        doctor: {
-            description: string;
-            args: {
-                scope: import("zod").ZodDefault<import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>>;
-            };
-            execute(args: {
-                scope: "global" | "project";
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        agent_profiles: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    list: "list";
-                    model_set: "model_set";
-                    critic_add: "critic_add";
-                    critic_remove: "critic_remove";
-                }>;
-                phase: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    preview: "preview";
-                    apply: "apply";
-                }>>;
-                scope: import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>;
-                name: import("zod").ZodOptional<import("zod").ZodString>;
-                model: import("zod").ZodOptional<import("zod").ZodString>;
-                variant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
-            };
-            execute(args: {
-                action: "list" | "model_set" | "critic_add" | "critic_remove";
-                scope: "global" | "project";
-                phase?: "preview" | "apply" | undefined;
-                name?: string | undefined;
-                model?: string | undefined;
-                variant?: string | null | undefined;
-                confirmation_digest?: string | undefined;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
-        reconcile: {
-            description: string;
-            args: {
-                phase: import("zod").ZodEnum<{
-                    preview: "preview";
-                    apply: "apply";
-                }>;
-                scope: import("zod").ZodEnum<{
-                    global: "global";
-                    project: "project";
-                }>;
-                confirmation_digest: import("zod").ZodOptional<import("zod").ZodString>;
-            };
-            execute(args: {
-                phase: "preview" | "apply";
-                scope: "global" | "project";
-                confirmation_digest?: string | undefined;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-        };
     };
     "tool.execute.before": (input: {
         tool: string;

package/dist/index.js

@@ -3,10 +3,6 @@ import { CATEGORIES, RoutingGate, } from "./routing.js";
 import rulesInjector from "./plugins/rules-injector.js";
 import rtk from "./plugins/rtk.js";
 import zedBell from "./plugins/zed-bell.js";
-import { applyAgentProfileChange, listAgentProfiles, previewAgentProfileChange, } from "./agent-profiles.js";
-import { applyReconcile, previewReconcile } from "./reconcile.js";
-import { collectDoctorFacts } from "./doctor.js";
-import { CATALOG } from "./catalog.js";
 import { digest } from "./lifecycle.js";
 export { rulesInjector, rtk, zedBell };
 const plugin = (async (input) => {
@@ -91,98 +87,8 @@ const plugin = (async (input) => {
             return JSON.stringify({ decision, receipt, status: "routed" });
         },
     });
-    const capabilities = tool({
-        description: "Show the bundled OpenCode capability catalog without installing or changing anything.",
-        args: {},
-        async execute() {
-            return JSON.stringify({ schema_version: 1, status: "ok", ...CATALOG });
-        },
-    });
-    const doctor = tool({
-        description: "Read package health and opt-in defaults without installing or repairing anything.",
-        args: { scope: tool.schema.enum(["global", "project"]).default("project") },
-        async execute(args, context) {
-            const host = input.client
-                ? {
-                    config: async () => (await input.client.config.get({ query: { directory: context.directory } })).data,
-                    lsp: async () => (await input.client.lsp.status({ query: { directory: context.directory } })).data,
-                }
-                : undefined;
-            return JSON.stringify(await collectDoctorFacts(args.scope ?? "project", context.directory, undefined, host));
-        },
-    });
-    const agentProfiles = tool({
-        description: "List, preview, or apply package-owned OpenCode agent profile configuration without editing opencode.json.",
-        args: {
-            action: tool.schema.enum(["list", "model_set", "critic_add", "critic_remove"]),
-            phase: tool.schema.enum(["preview", "apply"]).optional(),
-            scope: tool.schema.enum(["global", "project"]),
-            name: tool.schema.string().optional(),
-            model: tool.schema.string().optional(),
-            variant: tool.schema.string().nullable().optional(),
-            confirmation_digest: tool.schema.string().optional(),
-        },
-        async execute(args) {
-            const cwd = input.directory ?? process.cwd();
-            if (args.action === "list") {
-                if (args.phase ||
-                    args.name ||
-                    args.model ||
-                    args.variant !== undefined ||
-                    args.confirmation_digest)
-                    throw new Error("agent_profiles list accepts only scope");
-                return JSON.stringify({
-                    status: "ok",
-                    inventory: await listAgentProfiles(args.scope, cwd),
-                });
-            }
-            if (!args.phase)
-                throw new Error("agent_profiles mutation requires preview or apply phase");
-            const action = {
-                model_set: "model-set",
-                critic_add: "critic-add",
-                critic_remove: "critic-remove",
-            }[args.action];
-            const request = {
-                action,
-                ...(args.name ? { name: args.name } : {}),
-                ...(args.model ? { model: args.model } : {}),
-                ...(args.variant !== undefined ? { variant: args.variant } : {}),
-            };
-            if (args.phase === "preview")
-                return JSON.stringify({
-                    status: "ok",
-                    applied: false,
-                    requires_restart: false,
-                    plan: await previewAgentProfileChange(request, args.scope, cwd),
-                });
-            if (!args.confirmation_digest)
-                throw new Error("agent_profiles apply requires confirmation_digest");
-            return JSON.stringify(await applyAgentProfileChange(request, args.scope, args.confirmation_digest, cwd));
-        },
-    });
-    const reconcile = tool({
-        description: "Preview or apply scope-isolated removal of retired public assets without touching unknown sources or runtime state.",
-        args: {
-            phase: tool.schema.enum(["preview", "apply"]),
-            scope: tool.schema.enum(["global", "project"]),
-            confirmation_digest: tool.schema.string().optional(),
-        },
-        async execute(args) {
-            const cwd = input.directory ?? process.cwd();
-            if (args.phase === "preview")
-                return JSON.stringify({
-                    status: "ok",
-                    applied: false,
-                    plan: await previewReconcile(args.scope, cwd),
-                });
-            if (!args.confirmation_digest)
-                throw new Error("reconcile apply requires confirmation_digest");
-            return JSON.stringify(await applyReconcile(args.scope, args.confirmation_digest, cwd));
-        },
-    });
     return {
-        tool: { route, capabilities, doctor, agent_profiles: agentProfiles, reconcile },
+        tool: { route },
         "tool.execute.before": async (input, output) => {
             if (input.tool !== "task")
                 return;

package/dist/installer.d.ts

@@ -45,7 +45,6 @@ export type ArchiveCandidate = {
     kind: "command" | "agent" | "plugin" | "state";
 };
 export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
-export declare const PACKAGE_COMMANDS: string[];
 export declare const SKILL_COMMANDS: string[];
 export declare function defaultSelection(): InstallerSelection;
 export declare function normalizeSelection(value?: Partial<InstallerSelection>): InstallerSelection;

package/dist/installer.js

@@ -20,18 +20,17 @@ function retiredAssetPaths() {
     ]);
 }
 export const SELECTABLE_PLUGINS = [...CATALOG.plugins];
-export const PACKAGE_COMMANDS = [...CATALOG.package_commands];
 export const SKILL_COMMANDS = [...CATALOG.skills];
 export function defaultSelection() {
     return {
-        commands: [...SKILL_COMMANDS, ...PACKAGE_COMMANDS].sort(),
+        commands: [...SKILL_COMMANDS].sort(),
         agents: [...FIXED_AGENT_ROLES],
         plugins: [],
         core_activation: true,
     };
 }
 export function normalizeSelection(value = {}) {
-    const allCommands = new Set([...SKILL_COMMANDS, ...PACKAGE_COMMANDS]);
+    const allCommands = new Set(SKILL_COMMANDS);
     const commands = [...new Set(value.commands ?? defaultSelection().commands)].sort();
     const agents = [...new Set(value.agents ?? FIXED_AGENT_ROLES)];
     const plugins = [...new Set(value.plugins ?? [])];
@@ -45,8 +44,7 @@ export function normalizeSelection(value = {}) {
         commands,
         agents: agents.sort(),
         plugins: plugins.sort(),
-        core_activation: Boolean(value.core_activation ??
-            (commands.some((name) => PACKAGE_COMMANDS.includes(name)) || agents.length)),
+        core_activation: Boolean(value.core_activation ?? agents.length),
     };
 }
 export class InstallerError extends LifecycleError {
@@ -214,15 +212,20 @@ export async function archiveMutations(candidates, scope, cwd, home, sourceVersi
     }
     const known = new Set(entries.map((entry) => `${String(entry.original_path)}:${String(entry.digest)}`));
     const mutations = [];
+    const queuedObjects = new Set();
     const now = new Date(0).toISOString();
     for (const candidate of candidates) {
         const digestValue = sha256(candidate.content);
         const key = `${candidate.path}:${digestValue}`;
-        if (known.has(key))
-            continue;
         const objectPath = `objects/${digestValue}`;
         const object = await readRegular(destination(root, objectPath));
-        if (!object) {
+        if (known.has(key)) {
+            if ((!object && !queuedObjects.has(digestValue)) ||
+                (object && sha256(object) !== digestValue))
+                throw new InstallerError("invalid_archive", `Archive index references an invalid object: ${digestValue}`);
+            continue;
+        }
+        if (!object && !queuedObjects.has(digestValue)) {
             mutations.push({
                 root,
                 path: objectPath,
@@ -231,8 +234,9 @@ export async function archiveMutations(candidates, scope, cwd, home, sourceVersi
                 mode: candidate.record.mode,
                 expected: { absent: true },
             });
+            queuedObjects.add(digestValue);
         }
-        else if (sha256(object) !== digestValue) {
+        else if (object && sha256(object) !== digestValue) {
             throw new InstallerError("archive_collision", `Archive object collision: ${digestValue}`);
         }
         entries.push({
@@ -605,7 +609,7 @@ export async function preview(action, scope, cwd = process.cwd(), home = homedir
     const root = deploymentRoot(scope, cwd, home);
     try {
         return await withLifecycleLock(stateRoot, async () => {
-            if (await recoverTransaction(root, stateRoot))
+            if (await recoverTransaction(root, stateRoot, [archiveRoot(scope, cwd, home)]))
                 throw new InstallerError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
             const built = await build(action, scope, cwd, home, selection);
             const receipt = await saveReceipt(stateRoot, `installer:${action}`, scope, root, { plan_digest: built.plan.digest }, Date.now(), built.plan.digest);
@@ -632,7 +636,7 @@ export async function apply(action, scope, confirmationDigest, cwd = process.cwd
     const root = deploymentRoot(scope, cwd, home);
     try {
         return await withLifecycleLock(stateRoot, async () => {
-            if (await recoverTransaction(root, stateRoot))
+            if (await recoverTransaction(root, stateRoot, [archiveRoot(scope, cwd, home)]))
                 throw new InstallerError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
             const receipt = (await consumeReceipt(stateRoot, {
                 digest: confirmationDigest,

package/dist/lifecycle.d.ts

@@ -20,6 +20,18 @@ export type FileMutation = {
     root?: string;
     operation: "remove";
     expected: FileExpectation;
+} | {
+    path: string;
+    root?: string;
+    operation: "external-write";
+    content: Buffer;
+    mode: number;
+    expected: FileExpectation;
+} | {
+    path: string;
+    root?: string;
+    operation: "external-remove";
+    expected: FileExpectation;
 };
 export type SupersededPlan = {
     kind: string;
@@ -56,10 +68,11 @@ export declare function consumeReceipt(stateRoot: string, expected: {
 }, now?: number): Promise<unknown>;
 /** Invalidate an active receipt when a preview is blocked before a replacement exists. */
 export declare function supersedeReceipt(stateRoot: string, now?: number): Promise<void>;
-export declare function recoverTransaction(root: string, stateRoot: string): Promise<boolean>;
+export declare function recoverTransaction(root: string, stateRoot: string, allowedRoots?: readonly string[]): Promise<boolean>;
 export type TransactionOptions = {
     beforePublish?: (index: number) => void;
     afterPublish?: (published: number) => "continue" | "fail" | "interrupt";
+    applyExternal?: () => Promise<void>;
     validateFinal?: () => Promise<void>;
 };
 export declare function applyTransaction(root: string, stateRoot: string, mutations: readonly FileMutation[], options?: TransactionOptions): Promise<void>;

package/dist/lifecycle.js

@@ -105,8 +105,17 @@ async function ensureDirectory(path, mode) {
                 throw new LifecycleError("unsafe_path", `Unsafe directory: ${current}`);
             continue;
         }
-        await mkdir(current, { mode });
-        created.push(current);
+        try {
+            await mkdir(current, { mode });
+            created.push(current);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const raced = await lstat(current);
+            if (!raced.isDirectory() || raced.isSymbolicLink())
+                throw new LifecycleError("unsafe_path", `Unsafe directory: ${current}`);
+        }
     }
     return created;
 }
@@ -155,7 +164,8 @@ export function archiveRoot(scope, cwd = process.cwd(), home = homedir()) {
     const base = process.env.XDG_DATA_HOME && home === homedir()
         ? resolve(process.env.XDG_DATA_HOME)
         : resolve(home, ".local", "share");
-    return join(base, "opencode", "skills-opencode", "archive", scope);
+    const suffix = scope === "global" ? "global" : join("project", sha256(resolve(cwd)));
+    return join(base, "opencode", "skills-opencode", "archive", suffix);
 }
 async function processAlive(pid) {
     if (!Number.isSafeInteger(pid) || pid <= 0)
@@ -476,11 +486,17 @@ async function restore(root, journal) {
         const currentMode = current ? (await lstat(target)).mode & 0o777 : undefined;
         const beforeHash = item.content === null ? undefined : sha256(Buffer.from(item.content, "base64"));
         const beforeMode = item.mode ?? undefined;
-        const intendedHash = operation.operation === "write" && operation.content
+        const intendedHash = (operation.operation === "write" || operation.operation === "external-write") &&
+            operation.content
             ? sha256(Buffer.from(operation.content, "base64"))
             : undefined;
-        const intendedMode = operation.operation === "write" ? operation.mode : undefined;
-        const touched = index < journal.published || index === journal.applying;
+        const intendedMode = operation.operation === "write" || operation.operation === "external-write"
+            ? operation.mode
+            : undefined;
+        const external = operation.operation === "external-write" || operation.operation === "external-remove";
+        const touched = external
+            ? journal.external_started === true
+            : index < journal.published || index === journal.applying;
         if (!touched) {
             if (currentHash !== beforeHash || currentMode !== beforeMode)
                 conflicts.push(item.path);
@@ -521,7 +537,7 @@ async function restore(root, journal) {
     if (conflicts.length)
         throw new LifecycleError("recovery_conflict", `Transaction targets changed outside the lifecycle lock: ${conflicts.join(", ")}`);
 }
-function parseJournal(raw, expectedRoot) {
+function parseJournal(raw, expectedRoot, allowedRoots) {
     let value;
     try {
         value = JSON.parse(raw.toString("utf8"));
@@ -530,6 +546,7 @@ function parseJournal(raw, expectedRoot) {
         throw new LifecycleError("invalid_journal", "Transaction journal is not valid JSON");
     }
     const journal = value;
+    const roots = new Set([expectedRoot, ...allowedRoots].map((value) => resolve(value)));
     if (journal.schema_version !== 1 ||
         journal.root !== expectedRoot ||
         !Array.isArray(journal.operations) ||
@@ -540,6 +557,7 @@ function parseJournal(raw, expectedRoot) {
         !Number.isSafeInteger(journal.published) ||
         journal.published < 0 ||
         journal.published > journal.operations.length ||
+        (journal.external_started !== undefined && typeof journal.external_started !== "boolean") ||
         (journal.applying !== null &&
             (typeof journal.applying !== "number" ||
                 !Number.isSafeInteger(journal.applying) ||
@@ -550,8 +568,8 @@ function parseJournal(raw, expectedRoot) {
     }
     for (const item of journal.snapshots) {
         assertSafeRelative(item.path);
-        if (item.root !== undefined && !isAbsolute(item.root))
-            throw new LifecycleError("invalid_journal", "Transaction snapshot root must be absolute");
+        if (item.root !== undefined && (!isAbsolute(item.root) || !roots.has(resolve(item.root))))
+            throw new LifecycleError("invalid_journal", "Transaction snapshot root is not allowed");
     }
     for (const item of journal.snapshots) {
         if ((item.content !== null &&
@@ -564,11 +582,14 @@ function parseJournal(raw, expectedRoot) {
     }
     for (const item of journal.operations) {
         assertSafeRelative(item.path);
-        if (item.root !== undefined && !isAbsolute(item.root))
-            throw new LifecycleError("invalid_journal", "Transaction operation root must be absolute");
-        if (item.operation !== "write" && item.operation !== "remove")
+        if (item.root !== undefined && (!isAbsolute(item.root) || !roots.has(resolve(item.root))))
+            throw new LifecycleError("invalid_journal", "Transaction operation root is not allowed");
+        if (item.operation !== "write" &&
+            item.operation !== "remove" &&
+            item.operation !== "external-write" &&
+            item.operation !== "external-remove")
             throw new LifecycleError("invalid_journal", "Transaction journal contains an invalid operation");
-        if (item.operation === "write" &&
+        if ((item.operation === "write" || item.operation === "external-write") &&
             (typeof item.content !== "string" ||
                 !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(item.content) ||
                 typeof item.mode !== "number" ||
@@ -577,10 +598,17 @@ function parseJournal(raw, expectedRoot) {
                 item.mode > 0o777))
             throw new LifecycleError("invalid_journal", "Transaction journal contains invalid write content");
     }
+    for (let index = 0; index < journal.operations.length; index += 1) {
+        const operation = journal.operations[index];
+        const snapshot = journal.snapshots[index];
+        if (operation.path !== snapshot.path ||
+            resolve(operation.root ?? expectedRoot) !== resolve(snapshot.root ?? expectedRoot))
+            throw new LifecycleError("invalid_journal", "Transaction journal operation and snapshot targets differ");
+    }
     if (!journal.created_directories.every((item) => item &&
         typeof item.path === "string" &&
         (inside(resolve(expectedRoot), resolve(item.path)) ||
-            (journal.operations ?? []).some((operation) => operation.root && inside(resolve(operation.root), resolve(item.path)))) &&
+            [...roots].some((root) => inside(root, resolve(item.path)))) &&
         Number.isSafeInteger(item.device) &&
         item.device >= 0 &&
         Number.isSafeInteger(item.inode) &&
@@ -592,11 +620,11 @@ function parseJournal(raw, expectedRoot) {
         snapshots: journal.snapshots.map((item) => ({ ...item, root: item.root ?? expectedRoot })),
     };
 }
-export async function recoverTransaction(root, stateRoot) {
+export async function recoverTransaction(root, stateRoot, allowedRoots = []) {
     const raw = await readRegular(journalPath(stateRoot));
     if (!raw)
         return false;
-    const journal = parseJournal(raw, resolve(root));
+    const journal = parseJournal(raw, resolve(root), allowedRoots);
     await restore(root, journal);
     await unlink(journalPath(stateRoot));
     return true;
@@ -640,20 +668,24 @@ async function ensureTransactionDirectories(root, mutation, stateRoot, journal)
 export async function applyTransaction(root, stateRoot, mutations, options = {}) {
     if (await readRegular(journalPath(stateRoot)))
         throw new LifecycleError("recovery_required", "An interrupted transaction must be recovered before apply");
+    const ordered = [
+        ...mutations.filter((mutation) => mutation.operation !== "external-write" && mutation.operation !== "external-remove"),
+        ...mutations.filter((mutation) => mutation.operation === "external-write" || mutation.operation === "external-remove"),
+    ];
     const unique = new Set();
-    for (const mutation of mutations) {
+    for (const mutation of ordered) {
         assertSafeRelative(mutation.path);
-        const key = `${mutationRoot(root, mutation)}:${mutation.path}`;
+        const key = destination(mutationRoot(root, mutation), mutation.path);
         if (unique.has(key))
             throw new LifecycleError("invalid_plan", `Duplicate transaction target: ${mutation.path}`);
         unique.add(key);
         await validateExpectation(root, mutation);
     }
-    const snapshots = await Promise.all(mutations.map((mutation) => snapshot(root, mutation)));
+    const snapshots = await Promise.all(ordered.map((mutation) => snapshot(root, mutation)));
     const journal = {
         schema_version: 1,
         root: resolve(root),
-        operations: mutations.map((mutation) => mutation.operation === "write"
+        operations: ordered.map((mutation) => mutation.operation === "write" || mutation.operation === "external-write"
             ? {
                 path: mutation.path,
                 ...(mutation.root ? { root: resolve(mutation.root) } : {}),
@@ -672,10 +704,13 @@ export async function applyTransaction(root, stateRoot, mutations, options = {})
         created_directories: [],
         published: 0,
         applying: null,
+        external_started: false,
     };
     await writeJournal(stateRoot, journal);
     try {
-        for (const mutation of mutations) {
+        const native = ordered.filter((mutation) => mutation.operation !== "external-write" && mutation.operation !== "external-remove");
+        const external = ordered.slice(native.length);
+        for (const mutation of native) {
             journal.applying = journal.published;
             await writeJournal(stateRoot, journal);
             options.beforePublish?.(journal.published);
@@ -696,11 +731,19 @@ export async function applyTransaction(root, stateRoot, mutations, options = {})
             if (injected === "fail")
                 throw new LifecycleError("test_failure", "Injected transaction failure");
         }
-        for (const mutation of mutations) {
+        if (external.length) {
+            for (const mutation of external)
+                await validateExpectation(root, mutation);
+            journal.external_started = true;
+            await writeJournal(stateRoot, journal);
+            await options.applyExternal?.();
+        }
+        for (const mutation of ordered) {
             const target = destination(mutationRoot(root, mutation), mutation.path);
             const current = await readRegular(target);
-            if ((mutation.operation === "remove" && current) ||
-                (mutation.operation === "write" &&
+            if (((mutation.operation === "remove" || mutation.operation === "external-remove") &&
+                current) ||
+                ((mutation.operation === "write" || mutation.operation === "external-write") &&
                     (!current ||
                         !current.equals(mutation.content) ||
                         ((await stat(target)).mode & 0o777) !== mutation.mode))) {