superpowers-manager 0.7.2 → 0.8.0

package/dist/harness-command-result.js

@@ -34,13 +34,14 @@ export function nativeCommandResult(label, result) {
     appendCaptured(log, label, "stderr", result.stderr);
     return successResult(operation, { stdout: result.stdout.text }, log.snapshot());
 }
-export function normalizeSnapshotRuntimeVersion(label, result) {
+export function normalizeSnapshotRuntimeVersion(label, result, strip) {
     if (!result.outcome.ok)
         return { status: result.status, outcome: result.outcome };
     const operation = `${label.toLowerCase()}-runtime`;
     if (result.status !== 0)
         return failureResult(operation, "invalid-status", `${label} runtime inspection returned a nonzero status`, [], result.outcome.messages);
-    const version = result.outcome.result.stdout.trim();
+    const reported = result.outcome.result.stdout.trim();
+    const version = strip === undefined ? reported : reported.replace(strip, "");
     if (!SEMVER_RE.test(version))
         return failureResult(operation, "invalid-version", `${label} runtime inspection returned an invalid version response`, [], result.outcome.messages);
     return successResult(operation, version, result.outcome.messages);

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,52 @@ 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 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 originalText = decodeConfig(observation.bytes, path);
+        const original = parseOpenCodeConfig(originalText, path);
+        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);
@@ -175,14 +175,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 +190,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 +200,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 +268,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 +565,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 +575,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

@@ -6,7 +6,7 @@ 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";
@@ -18,6 +18,8 @@ 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
@@ -122,13 +124,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 +151,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 +161,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 &&
@@ -348,7 +353,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 +421,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 +454,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 +559,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 +582,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;

package/dist/harnesses/opencode/package.js

@@ -1,12 +1,37 @@
 import { join } from "node:path";
 import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
 import { COMMIT_RE, SEMVER_RE } from "../../domain/refs.js";
+import { assertNoFollowType } from "../../safe-path.js";
 import { validateSource } from "../../selection.js";
 import { SafetyError } from "../../safety-error.js";
 import { isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, snapshotReceiptBinding, } from "../../snapshot-package.js";
 const BOOTSTRAP = ".opencode/plugins/superpowers.js";
-const BOOTSTRAP_SIZE = 5464;
-const BOOTSTRAP_SHA256 = "a5c5e1dbb0abfbd6ec3322b724b9a7b3318bbbb3d83f9a661c56ae0ed0a3adb8";
+const ENTRYPOINT = "index.js";
+// Exact-byte allowlist, matched as a unit: a bootstrap and the V2 entrypoint
+// that shipped with it were qualified together in the native container. Adding
+// either half alone would admit a combination no container ever ran. Every
+// upstream change needs re-qualification before its bytes are added here.
+const QUALIFIED_PROFILES = [
+    {
+        // obra/superpowers v6.0.0-v6.3.0 — no V2 entrypoint shipped
+        bootstrap: {
+            size: 5464,
+            sha256: "a5c5e1dbb0abfbd6ec3322b724b9a7b3318bbbb3d83f9a661c56ae0ed0a3adb8",
+        },
+        entrypoint: null,
+    },
+    {
+        // obra/superpowers v6.4.1
+        bootstrap: {
+            size: 17617,
+            sha256: "c979fe5a9fd6fddc9bc9730b34b25989f9d53939eed7d594c4564f6e47495f26",
+        },
+        entrypoint: {
+            size: 536,
+            sha256: "f0132fd5339befeb99ba903b1619fd9530969e5b4a1ea8cecf0b0a7f0213a099",
+        },
+    },
+];
 function isReceiptCompatibility(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -32,11 +57,21 @@ export async function assessOpenCodeCompatibility(root, selection) {
             throw new Error("package metadata");
         requireNoSnapshotDependencies(pkg);
         await validateNativeSkill(root);
-        await requireSnapshotBootstrap(root, BOOTSTRAP, BOOTSTRAP_SIZE, BOOTSTRAP_SHA256);
+        const matched = await Promise.any(QUALIFIED_PROFILES.map(async (profile) => {
+            await requireSnapshotBootstrap(root, BOOTSTRAP, profile.bootstrap.size, profile.bootstrap.sha256);
+            if (profile.entrypoint === null)
+                await assertNoFollowType(join(root, ENTRYPOINT), ["missing"]);
+            else
+                await requireSnapshotBootstrap(root, ENTRYPOINT, profile.entrypoint.size, profile.entrypoint.sha256);
+            return profile;
+        }));
+        const generation = matched.entrypoint === null
+            ? "opencode-native-bootstrap-v1"
+            : "opencode-native-bootstrap-v2";
         const official = isOfficialSnapshotSource(selection.effectiveSource);
         return {
             kind: official ? "supported" : "experimental",
-            generation: "opencode-native-bootstrap-v1",
+            generation,
             reason: official
                 ? "qualified upstream-native OpenCode bootstrap"
                 : "qualified OpenCode mechanics from a custom source",

package/dist/harnesses/opencode/presentation.js

@@ -10,6 +10,7 @@ const renderProbe = (facts) => {
         ["prepared_identity", facts.prepared.observedIdentity],
         ["installed_identity", facts.installed.observedIdentity],
         ["installation_state", facts.installed.kind],
+        ["registration_key", facts.ownership.removalInput.registration?.key ?? ""],
         ["resource_state", facts.resourceState ?? "idle"],
         ["ownership", facts.ownership.presentationValue],
         ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],

package/dist/harnesses/opencode/state.js

@@ -52,6 +52,7 @@ function registrationFor(facts) {
         ? null
         : {
             observation: managed.observation,
+            key: managed.entry.key,
             entryIndex: managed.entry.index,
             spec: managed.entry.spec,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superpowers-manager",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Install obra/superpowers directly from upstream for Codex, Pi, and OpenCode. Stay on a known-good release or commit, try a branch, and upgrade when you choose.",
   "keywords": [
     "superpowers",