superpowers-manager 0.7.3 → 0.9.0

package/dist/harnesses/opencode/config.js

@@ -2,7 +2,7 @@ import { Buffer } from "node:buffer";
 import { constants } from "node:fs";
 import { chmod, open } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
-import { applyEdits, createScanner, findNodeAtLocation, getNodeValue, parseTree, } from "jsonc-parser";
+import { applyEdits, createScanner, findNodeAtLocation, getNodeValue, modify, parseTree, } from "jsonc-parser";
 import * as jsoncParserRuntime from "jsonc-parser";
 import { atomicWriteFile } from "../../atomic.js";
 import { SafetyError } from "../../safety-error.js";
@@ -14,6 +14,7 @@ const UTF8_DECODER = new TextDecoder("utf-8", {
     ignoreBOM: true,
 });
 const SYNTAX_KIND = jsoncParserRuntime.SyntaxKind;
+const CONFIG_KEYS = ["plugin", "plugins"];
 async function readBoundedConfigBytes(handle) {
     const budget = Buffer.allocUnsafe(MAX_CONFIG_BYTES + 1);
     let length = 0;
@@ -37,6 +38,9 @@ function cannotRead(path, cause) {
 function cannotRemove(path, cause) {
     return new SafetyError("opencode-config", `cannot remove owned OpenCode registration: ${path}`, cause === undefined ? {} : { cause });
 }
+function cannotRegister(path, cause) {
+    return new SafetyError("opencode-config", `cannot register owned OpenCode registration: ${path}`, cause === undefined ? {} : { cause });
+}
 function propertyParts(property) {
     const [key, value] = property.children ?? [];
     if (property.type !== "property" ||
@@ -67,28 +71,31 @@ function validateTree(node, depth) {
         validateTree(child, depth + 1);
 }
 function configEntries(root) {
-    const plugin = findNodeAtLocation(root, ["plugin"]);
-    if (plugin === undefined)
-        return [];
-    if (plugin.type !== "array")
-        throw new Error("plugin must be an array");
-    return (plugin.children ?? []).map((entry, index) => {
-        if (entry.type === "string" && typeof entry.value === "string") {
-            return { index, spec: entry.value, options: null };
-        }
-        const tuple = entry.children ?? [];
-        if (entry.type !== "array" ||
-            tuple.length !== 2 ||
-            tuple[0]?.type !== "string" ||
-            typeof tuple[0].value !== "string" ||
-            tuple[1]?.type !== "object") {
-            throw new Error("unsupported plugin entry");
-        }
-        return {
-            index,
-            spec: tuple[0].value,
-            options: structuredClone(getNodeValue(tuple[1])),
-        };
+    return CONFIG_KEYS.flatMap((key) => {
+        const array = findNodeAtLocation(root, [key]);
+        if (array === undefined)
+            return [];
+        if (array.type !== "array")
+            throw new Error(`${key} must be an array`);
+        return (array.children ?? []).map((entry, index) => {
+            if (entry.type === "string" && typeof entry.value === "string") {
+                return { key, index, spec: entry.value, options: null };
+            }
+            const tuple = entry.children ?? [];
+            if (entry.type !== "array" ||
+                tuple.length !== 2 ||
+                tuple[0]?.type !== "string" ||
+                typeof tuple[0].value !== "string" ||
+                tuple[1]?.type !== "object") {
+                throw new Error("unsupported plugin entry");
+            }
+            return {
+                key,
+                index,
+                spec: tuple[0].value,
+                options: structuredClone(getNodeValue(tuple[1])),
+            };
+        });
     });
 }
 export function parseOpenCodeConfig(text, path) {
@@ -112,12 +119,13 @@ export function parseOpenCodeConfig(text, path) {
 }
 function sameEntries(left, right) {
     return (left.length === right.length &&
-        left.every((entry, index) => entry.spec === right[index]?.spec &&
+        left.every((entry, index) => entry.key === right[index]?.key &&
+            entry.spec === right[index]?.spec &&
             isDeepStrictEqual(entry.options, right[index]?.options)));
 }
-export function removeOpenCodeEntry(document, index) {
+export function removeOpenCodeEntry(document, key, index) {
     try {
-        const array = findNodeAtLocation(document.root, ["plugin"]);
+        const array = findNodeAtLocation(document.root, [key]);
         const elements = array?.children ?? [];
         const element = elements[index];
         if (array?.type !== "array" ||
@@ -159,7 +167,7 @@ export function removeOpenCodeEntry(document, index) {
         }
         const output = applyEdits(document.text, edits);
         const after = parseOpenCodeConfig(output, document.path);
-        const expected = document.entries.filter((entry) => entry.index !== index);
+        const expected = document.entries.filter((entry) => entry.key !== key || entry.index !== index);
         if (!sameEntries(after.entries, expected)) {
             throw new Error("removal changed surviving registrations");
         }
@@ -169,6 +177,37 @@ export function removeOpenCodeEntry(document, index) {
         throw cannotRemove(document.path, cause);
     }
 }
+export function addOpenCodeEntry(document, key, spec) {
+    try {
+        if (spec.trim().length === 0)
+            throw new Error("empty registration spec");
+        const array = findNodeAtLocation(document.root, [key]);
+        if (array !== undefined && array.type !== "array") {
+            throw new Error(`${key} must be an array`);
+        }
+        const position = array?.children?.length ?? 0;
+        const edits = modify(document.text, [key, position], spec, {
+            isArrayInsertion: true,
+        });
+        const output = applyEdits(document.text, edits);
+        const after = parseOpenCodeConfig(output, document.path);
+        const expected = [
+            ...document.entries,
+            { key, index: position, spec, options: null },
+        ].sort((left, right) => left.key === right.key
+            ? left.index - right.index
+            : left.key < right.key
+                ? -1
+                : 1);
+        if (!sameEntries(after.entries, expected)) {
+            throw new Error("registration changed surviving registrations");
+        }
+        return output;
+    }
+    catch (cause) {
+        throw cannotRegister(document.path, cause);
+    }
+}
 async function readConfigBytes(path) {
     let handle;
     try {
@@ -223,34 +262,50 @@ export async function readOpenCodeConfig(path) {
 function sameObservedState(left, right) {
     return (left.dev === right.dev && left.ino === right.ino && left.mode === right.mode);
 }
-export async function removeObservedOpenCodeEntry(observation, index) {
+async function writeObservedOpenCodeConfig(observation, outputBytes, expected) {
+    const path = observation.document.path;
+    await atomicWriteFile(path, outputBytes, {
+        validate: async (temporary) => {
+            await chmod(temporary, observation.identity.mode & 0o7777);
+            const current = await readConfigBytes(path);
+            if (current === null ||
+                !sameObservedState(current.identity, observation.identity) ||
+                !current.bytes.equals(observation.bytes)) {
+                throw new Error("OpenCode configuration changed concurrently");
+            }
+        },
+    });
+    const after = await readOpenCodeConfig(path);
+    if (after === null ||
+        !after.bytes.equals(outputBytes) ||
+        after.identity.mode !== observation.identity.mode ||
+        !sameEntries(after.document.entries, expected)) {
+        throw new Error("published OpenCode configuration could not be verified");
+    }
+}
+export async function removeObservedOpenCodeEntry(observation, key, index) {
     const path = observation.document.path;
     try {
-        const originalText = decodeConfig(observation.bytes, path);
-        const original = parseOpenCodeConfig(originalText, path);
-        const output = removeOpenCodeEntry(original, index);
+        const original = observation.document;
+        const output = removeOpenCodeEntry(original, key, index);
         const outputBytes = Buffer.from(output, "utf8");
-        const expected = original.entries.filter((entry) => entry.index !== index);
-        await atomicWriteFile(path, outputBytes, {
-            validate: async (temporary) => {
-                await chmod(temporary, observation.identity.mode & 0o7777);
-                const current = await readConfigBytes(path);
-                if (current === null ||
-                    !sameObservedState(current.identity, observation.identity) ||
-                    !current.bytes.equals(observation.bytes)) {
-                    throw new Error("OpenCode configuration changed concurrently");
-                }
-            },
-        });
-        const after = await readOpenCodeConfig(path);
-        if (after === null ||
-            !after.bytes.equals(outputBytes) ||
-            after.identity.mode !== observation.identity.mode ||
-            !sameEntries(after.document.entries, expected)) {
-            throw new Error("published OpenCode configuration could not be verified");
-        }
+        const expected = original.entries.filter((entry) => entry.key !== key || entry.index !== index);
+        await writeObservedOpenCodeConfig(observation, outputBytes, expected);
     }
     catch (cause) {
         throw cannotRemove(path, cause);
     }
 }
+export async function addObservedOpenCodeEntry(observation, key, spec) {
+    const path = observation.document.path;
+    try {
+        const original = observation.document;
+        const output = addOpenCodeEntry(original, key, spec);
+        const outputBytes = Buffer.from(output, "utf8");
+        const expected = parseOpenCodeConfig(output, path).entries;
+        await writeObservedOpenCodeConfig(observation, outputBytes, expected);
+    }
+    catch (cause) {
+        throw cannotRegister(path, cause);
+    }
+}

package/dist/harnesses/opencode/discovery.js

@@ -151,11 +151,11 @@ function isKnownPluginFile(path) {
 }
 async function inspectPluginEntry(observation, entry, state, allowManaged = true, active = true) {
     if (entry.spec.trim().length === 0) {
-        addBlocked(state, `${observation.document.path} plugin[${entry.index}]`);
+        addBlocked(state, `${observation.document.path} ${entry.key}[${entry.index}]`);
         return;
     }
     if (containsSubstitution(entry.spec)) {
-        addBlocked(state, `${observation.document.path} plugin[${entry.index}]`);
+        addBlocked(state, `${observation.document.path} ${entry.key}[${entry.index}]`);
         return;
     }
     const local = localPluginPath(entry.spec, observation.document.path, state);
@@ -163,11 +163,7 @@ async function inspectPluginEntry(observation, entry, state, allowManaged = true
         const canonical = await canonicalizeProspectivePath(local);
         if (canonical === state.installedRoot) {
             if (allowManaged)
-                state.managedEntries.push({
-                    observation,
-                    entry,
-                    canonicalRoot: canonical,
-                });
+                state.managedEntries.push({ observation, entry });
             else
                 addBlocked(state, `${OPEN_CODE_UNOWNED_MANAGER_INPUT}: ${observation.document.path}`);
             return;
@@ -175,14 +171,14 @@ async function inspectPluginEntry(observation, entry, state, allowManaged = true
     }
     if (!active)
         return;
-    if (inspectUpstreamSpec(entry.spec, `${observation.document.path} plugin[${entry.index}]`, state))
+    if (inspectUpstreamSpec(entry.spec, `${observation.document.path} ${entry.key}[${entry.index}]`, state))
         return;
     if (local === null)
         return;
     const kind = await classifyPathNoFollow(local);
     if (kind === "missing") {
         if (/^superpowers(?:\.(?:js|ts))?$/u.test(basename(local)))
-            addBlocked(state, `${observation.document.path} plugin[${entry.index}]`);
+            addBlocked(state, `${observation.document.path} ${entry.key}[${entry.index}]`);
         return;
     }
     if (isKnownPluginFile(local)) {
@@ -190,7 +186,7 @@ async function inspectPluginEntry(observation, entry, state, allowManaged = true
         return;
     }
     if (kind !== "directory" && kind !== "symlink") {
-        addBlocked(state, `${observation.document.path} plugin[${entry.index}]`);
+        addBlocked(state, `${observation.document.path} ${entry.key}[${entry.index}]`);
         return;
     }
     try {
@@ -200,7 +196,7 @@ async function inspectPluginEntry(observation, entry, state, allowManaged = true
     }
     catch {
         if (basename(local) === "superpowers")
-            addBlocked(state, `${observation.document.path} plugin[${entry.index}]`);
+            addBlocked(state, `${observation.document.path} ${entry.key}[${entry.index}]`);
     }
 }
 async function inspectSkillFile(path, label, state, requireKnownIdentity = false) {
@@ -268,7 +264,7 @@ async function inspectDocument(observation, state) {
     await inspectConfigFields(effective.root, source, state);
     const active = !truthy(state.env.OPENCODE_PURE);
     for (const entry of effective.entries) {
-        const original = observation.document.entries[entry.index];
+        const original = observation.document.entries.find((candidate) => candidate.key === entry.key && candidate.index === entry.index);
         const stable = original !== undefined && original.spec === entry.spec;
         await inspectPluginEntry(observation, stable ? original : entry, state, stable && isNativeWriterOrigin(observation, state), active);
     }
@@ -565,8 +561,8 @@ export async function inspectOpenCodeDiscovery(paths, env, cwd) {
                 for (const entry of inline.entries) {
                     if (entry.spec.trim().length === 0 ||
                         containsSubstitution(entry.spec))
-                        addBlocked(state, `OPENCODE_CONFIG_CONTENT plugin[${entry.index}]`);
-                    else if (inspectUpstreamSpec(entry.spec, `OPENCODE_CONFIG_CONTENT plugin[${entry.index}]`, state)) {
+                        addBlocked(state, `OPENCODE_CONFIG_CONTENT ${entry.key}[${entry.index}]`);
+                    else if (inspectUpstreamSpec(entry.spec, `OPENCODE_CONFIG_CONTENT ${entry.key}[${entry.index}]`, state)) {
                         continue;
                     }
                     else {
@@ -575,7 +571,7 @@ export async function inspectOpenCodeDiscovery(paths, env, cwd) {
                             const canonical = await canonicalizeProspectivePath(local);
                             addBlocked(state, canonical === state.installedRoot
                                 ? `${OPEN_CODE_UNOWNED_MANAGER_INPUT}: OPENCODE_CONFIG_CONTENT`
-                                : `OPENCODE_CONFIG_CONTENT plugin[${entry.index}]`);
+                                : `OPENCODE_CONFIG_CONTENT ${entry.key}[${entry.index}]`);
                         }
                     }
                 }

package/dist/harnesses/opencode/install.js

@@ -1,12 +1,12 @@
 import { createHash, randomBytes } from "node:crypto";
-import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, unlink, } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { cp, mkdir, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
 import { findNodeAtLocation } from "jsonc-parser";
 import { failureResult, successResult, } from "../../adapter-result.js";
 import { digestArtifactTree } from "../../artifact-tree.js";
 import { atomicWriteFile, beginDirectoryPublication, } from "../../atomic.js";
 import { assertNoFollowType, canonicalizeProspectivePath, classifyPathNoFollow, } from "../../safe-path.js";
-import { removeObservedOpenCodeEntry } from "./config.js";
+import { addObservedOpenCodeEntry, removeObservedOpenCodeEntry, } from "./config.js";
 import { inspectOpenCodeDiscovery, OPEN_CODE_PURE_MODE_INPUT, } from "./discovery.js";
 import { normalizeSnapshotRuntimeVersion } from "../../harness-command-result.js";
 import { runOpenCode } from "./native.js";
@@ -14,10 +14,13 @@ import { readOpenCodePackageAssessment, readOpenCodeReceipt, } from "./package.j
 import { assertOpenCodePreparationSeparate, openCodePaths, } from "./paths.js";
 import { inspectOpenCodeControl, inspectOpenCodeOwnership, } from "./state.js";
 import { displayPath } from "../../validator.js";
+import { createJournal, createSnapshotJournal, hasRecovery, identity, journalPath, publicationPaths, requireNoRecovery, } from "../../snapshot-journal.js";
 const DEFAULTS = {
     run: runOpenCode,
     beginPublication: beginDirectoryPublication,
 };
+// V1 prints a bare semver ("1.18.31"); V2 prints "opencode v2.0.10".
+const OPEN_CODE_VERSION_PREFIX = /^opencode\s+v/i;
 // The journal can contain data from two independently bounded 1 MiB receipts
 // plus one bounded 1 MiB config. Six bytes of JSON output per input byte covers
 // control escaping; counting the registration spec independently brings that
@@ -33,20 +36,6 @@ function accepted(result) {
         throw new Error("OpenCode operation did not succeed");
     return result.outcome.result;
 }
-function sameIdentity(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-async function identity(path) {
-    await assertNoFollowType(path, ["directory"]);
-    return await lstat(path);
-}
-async function requireIdentity(path, expected) {
-    if (!sameIdentity(await identity(path), expected))
-        throw new Error("OpenCode directory changed");
-}
-function journalPath(pending) {
-    return join(pending.paths.recoveryRoot, "transaction.json");
-}
 function journalBytes(journal) {
     const bytes = Buffer.from(`${JSON.stringify(journal)}\n`);
     if (bytes.length > MAX_JOURNAL_BYTES)
@@ -55,31 +44,14 @@ function journalBytes(journal) {
 }
 async function validatePaths(paths) {
     await assertOpenCodePreparationSeparate(paths);
-    await assertNoFollowType(paths.configRoot, ["directory", "missing"]);
-    await assertNoFollowType(paths.managerRoot, ["directory", "missing"]);
-    await assertNoFollowType(paths.installedRoot, ["directory", "missing"]);
     return await canonicalizeProspectivePath(paths.installedRoot);
 }
-async function requireNoRecovery(paths) {
-    await assertNoFollowType(paths.recoveryRoot, ["missing"]);
-}
-async function hasRecovery(paths) {
-    try {
-        return (await classifyPathNoFollow(paths.recoveryRoot)) !== "missing";
-    }
-    catch {
-        return true;
-    }
-}
-async function syncDirectoryStrict(path) {
-    const directory = await open(path, "r");
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
-}
+const { requireIdentity, requireJournal, phase, retireJournal } = createSnapshotJournal({
+    label: "OpenCode",
+    validatePaths,
+    serialize: journalBytes,
+    readCap: MAX_JOURNAL_BYTES,
+});
 function artifactSame(left, right) {
     return left === null
         ? right === null
@@ -122,13 +94,14 @@ function registrationRecord(registration) {
         return null;
     const observation = registration.observation;
     const node = findNodeAtLocation(observation.document.root, [
-        "plugin",
+        registration.entry.key,
         registration.entry.index,
     ]);
     if (node === undefined)
         throw new Error("OpenCode registration syntax changed");
     return {
         configPath: observation.document.path,
+        configKey: registration.entry.key,
         entryIndex: registration.entry.index,
         spec: registration.entry.spec,
         optionsDigest: createHash("sha256")
@@ -148,6 +121,7 @@ function sameRegistration(registration, expected) {
         ? registration === undefined
         : registration !== undefined &&
             registration.observation.document.path === expected.configPath &&
+            registration.entry.key === expected.configKey &&
             registration.entry.spec === expected.spec &&
             createHash("sha256")
                 .update(JSON.stringify(registration.entry.options))
@@ -157,6 +131,7 @@ function registrationInputSame(input, current) {
     return input === null
         ? current === null
         : current !== null &&
+            input.key === current.key &&
             input.entryIndex === current.entryIndex &&
             input.spec === current.spec &&
             input.observation.document.path === current.observation.document.path &&
@@ -195,39 +170,6 @@ async function requireActivationEligibility(ctx) {
         control.mutationEligibility.kind !== "allowed")
         throw new Error("OpenCode ownership or control blocked");
 }
-async function requireJournal(pending) {
-    if ((await validatePaths(pending.paths)) !== pending.canonicalRoot ||
-        pending.journal.installedRoot !== pending.canonicalRoot ||
-        !/^[a-f0-9]{32}$/u.test(pending.journal.token))
-        throw new Error("OpenCode recovery root changed");
-    await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
-    const path = journalPath(pending);
-    await assertNoFollowType(path, ["regular-file"]);
-    const observed = await lstat(path);
-    if (!sameIdentity(observed, pending.journalIdentity) ||
-        observed.size > MAX_JOURNAL_BYTES ||
-        !(await readFile(path)).equals(journalBytes(pending.journal)))
-        throw new Error("OpenCode recovery journal changed");
-    if (pending.backup !==
-        join(dirname(pending.canonicalRoot), `.${basename(pending.canonicalRoot)}.bak.${pending.journal.token}`) ||
-        pending.stage !==
-            join(dirname(pending.canonicalRoot), `.${basename(pending.canonicalRoot)}.stage.${pending.journal.token}`))
-        throw new Error("OpenCode recovery paths changed");
-}
-async function phase(pending, next, changes = {}) {
-    await requireJournal(pending);
-    const journal = { ...pending.journal, ...changes, phase: next };
-    const bytes = journalBytes(journal);
-    await atomicWriteFile(journalPath(pending), bytes, {
-        validate: async (temporary) => {
-            if (!(await readFile(temporary)).equals(bytes))
-                throw new Error("OpenCode journal write changed");
-        },
-    });
-    await syncDirectoryStrict(pending.paths.recoveryRoot);
-    pending.journal = journal;
-    pending.journalIdentity = await lstat(journalPath(pending));
-}
 async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration, ctx) {
     const canonicalRoot = await validatePaths(paths);
     await requireNoRecovery(paths);
@@ -248,36 +190,18 @@ async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration,
     await mkdir(paths.managerRoot, { recursive: true });
     await mkdir(paths.recoveryRoot, { mode: 0o700 });
     const recoveryIdentity = await identity(paths.recoveryRoot);
-    const path = join(paths.recoveryRoot, "transaction.json");
-    const handle = await open(path, "wx", 0o600);
-    try {
-        await handle.writeFile(bytes);
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await syncDirectoryStrict(paths.recoveryRoot);
+    const journalIdentity = await createJournal(paths.recoveryRoot, bytes);
     return {
         paths,
         canonicalRoot,
         recoveryIdentity,
-        backup: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.bak.${token}`),
-        stage: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.stage.${token}`),
+        ...publicationPaths(canonicalRoot, token),
         ctx,
         journal,
-        journalIdentity: await lstat(path),
+        journalIdentity,
         settled: false,
     };
 }
-async function retireJournal(pending) {
-    await requireJournal(pending);
-    if ((await readdir(pending.paths.recoveryRoot)).some((name) => name !== "transaction.json"))
-        throw new Error("unknown OpenCode recovery material");
-    await unlink(journalPath(pending));
-    await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
-    await rmdir(pending.paths.recoveryRoot);
-}
 async function recoveryGuidance(pending) {
     try {
         const kind = await classifyPathNoFollow(pending.paths.recoveryRoot);
@@ -348,7 +272,7 @@ async function rollbackOpenCodePublication(pending, publication) {
             const current = observed.managedEntries[0];
             if (current === undefined)
                 throw new Error("OpenCode created registration missing");
-            await removeObservedOpenCodeEntry(current.observation, current.entry.index);
+            await removeObservedOpenCodeEntry(current.observation, current.entry.key, current.entry.index);
             observed = await discovery(pending.paths, pending.ctx);
             requireNoOwnedActivation(observed);
         }
@@ -416,7 +340,13 @@ export async function installOpenCode(artifact, ctx, deps = DEFAULTS) {
         let priorRegistration = registrationRecord(observed.managedEntries[0]);
         if (previous === null && priorRegistration !== null)
             throw new Error("unowned OpenCode registration");
-        accepted(normalizeSnapshotRuntimeVersion("OpenCode", await deps.run(["--version"], paths, ctx)));
+        const runtimeVersion = accepted(normalizeSnapshotRuntimeVersion("OpenCode", await deps.run(["--version"], paths, ctx), OPEN_CODE_VERSION_PREFIX));
+        const major = Number.parseInt(runtimeVersion, 10);
+        if (major !== 1 && major !== 2)
+            return fail("unsupported-runtime", `unsupported OpenCode major version ${major}`);
+        if (major === 2 &&
+            assessment.compatibility.generation !== "opencode-native-bootstrap-v2")
+            return fail("unsupported-artifact", "the selected upstream ref does not support OpenCode 2; select a ref that ships the V2 entrypoint");
         await requireSnapshot(paths.installedRoot, previous);
         observed = await requireStableActivationRegistration(paths, ctx, priorRegistration);
         priorRegistration = registrationRecord(observed.managedEntries[0]);
@@ -443,16 +373,40 @@ export async function installOpenCode(artifact, ctx, deps = DEFAULTS) {
         if (priorRegistration === null) {
             await phase(pending, "registering");
             observed = await requireStableActivationRegistration(paths, ctx, null);
-            const native = await deps
-                .run(["plugin", pending.canonicalRoot, "--global"], paths, ctx)
-                .catch(() => fail("native-failed", "OpenCode native installation failed"));
+            let native = null;
+            if (major === 1) {
+                native = await deps
+                    .run(["plugin", pending.canonicalRoot, "--global"], paths, ctx)
+                    .catch(() => fail("native-failed", "OpenCode native installation failed"));
+            }
+            else {
+                const jsonc = join(paths.configRoot, "opencode.jsonc");
+                const json = join(paths.configRoot, "opencode.json");
+                let target = observed.documents.find((document) => document.document.path === jsonc) ??
+                    observed.documents.find((document) => document.document.path === json);
+                if (target === undefined) {
+                    await atomicWriteFile(json, Buffer.from("{}\n"), {
+                        validate: async () => {
+                            await assertNoFollowType(paths.configRoot, ["directory"]);
+                            await assertNoFollowType(jsonc, ["missing"]);
+                            await assertNoFollowType(json, ["missing"]);
+                        },
+                    });
+                    observed = await requireStableActivationRegistration(paths, ctx, null);
+                    target = observed.documents.find((document) => document.document.path === json);
+                }
+                if (target === undefined)
+                    throw new Error("no OpenCode configuration to register in");
+                await addObservedOpenCodeEntry(target, "plugins", pending.canonicalRoot);
+            }
             observed = await discovery(paths, ctx);
             requireSafeActivationDiscovery(observed);
             const created = registrationRecord(observed.managedEntries[0]);
             if (created === null || created.spec !== pending.canonicalRoot)
                 throw new Error("OpenCode activation unverified");
             await phase(pending, "registered", { createdRegistration: created });
-            accepted(native);
+            if (native !== null)
+                accepted(native);
         }
         await requirePublication(pending);
         observed = await discovery(paths, ctx);
@@ -524,6 +478,7 @@ export async function removeOpenCode(input, ctx, deps = DEFAULTS) {
                 ? null
                 : {
                     observation: registered.observation,
+                    key: registered.entry.key,
                     entryIndex: registered.entry.index,
                     spec: registered.entry.spec,
                 }))
@@ -546,7 +501,7 @@ export async function removeOpenCode(input, ctx, deps = DEFAULTS) {
         if (!sameRegistration(observed.managedEntries[0], pending.journal.priorRegistration))
             throw new Error("OpenCode registration changed");
         if (registered !== undefined) {
-            await removeObservedOpenCodeEntry(registered.observation, registered.entry.index);
+            await removeObservedOpenCodeEntry(registered.observation, registered.entry.key, registered.entry.index);
             observed = await discovery(paths, ctx);
             requireNoOwnedActivation(observed);
             deregistered = true;