superpowers-manager 0.5.0 → 0.5.2

package/README.md

@@ -1,9 +1,45 @@
 # Superpowers Manager
 
-Install and explicitly refresh the latest stable [`obra/superpowers`](https://github.com/obra/superpowers) release. Superpowers Manager supports Codex and the Pi coding agent without waiting for a marketplace copy to catch up.
+Install [`obra/superpowers`](https://github.com/obra/superpowers) directly from upstream for Codex and the Pi coding agent. Stay on a known-good release or commit, try a branch, and upgrade when you choose—without waiting for a marketplace copy to catch up.
 
 > Unofficial community integration. Not affiliated with the `obra/superpowers` maintainers.
 
+## Choose what you run
+
+Start with the latest stable release by default, or choose the upstream version that works for you. There is no background updater.
+
+| What you want | How to choose it |
+|---|---|
+| Stay on a known-good version | `pin` a release tag or full 40-character commit SHA |
+| Try an upstream fix before its release | Set `SUPERPOWERS_REF` to a branch or other resolvable ref for that invocation |
+| Return to the latest stable release | Save `track-latest`, then explicitly install or update |
+
+For example, save a release pin and install it for your agent:
+
+```sh
+npx superpowers-manager pin v6.1.1
+npx superpowers-manager install --harness codex
+```
+
+Use `--harness pi` for Pi. The pin is shared by both agents, but each installation changes only when you run its `install` or `update` command. A saved pin keeps subsequent installs and updates on that version unless you change or override the selection.
+
+To try a branch, replace `feature/foo` with an existing upstream branch:
+
+```sh
+SUPERPOWERS_REF=feature/foo npx superpowers-manager install --harness codex
+```
+
+This override applies only to that command and leaves your saved selection unchanged; the installed version remains until you explicitly change it. Branches can move. Persistent `pin` accepts exact version tags (including prereleases) and full commit SHAs.
+
+When you are ready to return to the latest stable release:
+
+```sh
+npx superpowers-manager track-latest
+npx superpowers-manager update --harness codex
+```
+
+See [version selection](https://github.com/j7an/superpowers-manager/blob/main/docs/usage.md#choosing-a-source) for source overrides, precedence, and `unpin`.
+
 ## Start with your agent
 
 The two harnesses share upstream selection, while each has independent prepared and installed state. Omitting `--harness` selects Codex.
@@ -20,7 +56,7 @@ Codex installs the Manager-owned marketplace plugin after preparation and
 validation. Review upstream hook definitions with Codex's `/hooks` flow before
 trusting or running them; updates can change a referenced script or surface a
 new definition. The manager neither creates hooks nor changes Codex trust state.
-See the [Codex reference](https://github.com/j7an/superpowers-manager/blob/main/docs/codex.md).
+See the [Codex reference](https://github.com/j7an/superpowers-manager/blob/main/docs/codex.md#durable-storage-migration-and-recovery) for durable storage, migration, and recovery.
 
 ### Pi
 
@@ -53,7 +89,7 @@ The manager never removes another Superpowers provider. See the [ownership guida
 
 ## Shared selection and lifecycle
 
-Use `pin`, `track-latest`, or `unpin` to save shared upstream intent. They do not activate Codex or Pi; run the selected harness's `install` or `update` to apply that choice. There is no background updater.
+The [selection commands above](#choose-what-you-run) save shared upstream intent. They do not activate Codex or Pi; run the selected harness's `install` or `update` to apply that choice. `unpin` restores the packaged fallback policy.
 
 | Command | Purpose |
 |---|---|
@@ -65,12 +101,6 @@ Use `pin`, `track-latest`, or `unpin` to save shared upstream intent. They do no
 
 Use `--harness codex` or `--harness pi` with each targeted lifecycle command.
 
-```sh
-npx superpowers-manager pin v6.1.1
-npx superpowers-manager track-latest
-npx superpowers-manager unpin
-```
-
 ```text
 shared selection -> prepare / inspect / activate Codex
                  -> prepare / inspect / activate Pi

package/dist/artifact-tree.js

@@ -4,7 +4,8 @@ import { join } from "node:path";
 import { assertExistingContained, assertNoFollowType, assertSymlinkTargetContained, } from "./safe-path.js";
 import { SafetyError } from "./safety-error.js";
 import { parseStrictJson } from "./strict-json.js";
-import { compareByCodePoint, DEFAULT_FS_DEPS, validateSkillFrontmatter, } from "./generated-plugin.js";
+import { compareByCodePoint } from "./python-text.js";
+import { DEFAULT_FS_DEPS, validateSkillFrontmatter, } from "./skill-validation.js";
 export const ARTIFACT_RECEIPT = ".superpowers-manager.json";
 export const ARTIFACT_DIGEST_RE = /^[a-f0-9]{64}$/;
 const DECODER = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });

package/dist/cli.js

@@ -2,8 +2,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { extractHarnessOptions, oneLine, UsageError } from "./cli-arguments.js";
-import { codexHarness } from "./codex-harness.js";
-import { piHarness } from "./pi-harness.js";
+import { codexHarness } from "./harnesses/codex/harness.js";
+import { piHarness } from "./harnesses/pi/harness.js";
 import { createResourceCoordinator } from "./resource-lock.js";
 import { runInstall } from "./commands/install.js";
 import { runPin } from "./commands/pin.js";
@@ -341,7 +341,7 @@ async function dispatch(adapter, parsed) {
     }
     return status;
 }
-export { resolvePackageRoot, isMain, parseArgs, findTool, commandRequirements, commandRequirementsFor, preflight, preflightFor, usage, dispatch, main, };
+export { resolvePackageRoot, isMain, parseArgs, commandRequirements, commandRequirementsFor, preflight, usage, main, };
 if (isMain(import.meta.filename, process.argv[1])) {
     main().catch((cause) => {
         console.error(`error: ${oneLine(cause)}`);

package/dist/commands/install.js

@@ -1,6 +1,6 @@
 // Ports scripts/install. The shell sourced common.sh, provenance.sh,
 // status.sh, lifecycle.sh and adapter.sh; the predicates now live in
-// src/lifecycle.ts, the generated-metadata read lives in src/provenance.ts,
+// src/harnesses/codex/lifecycle.ts, the generated-metadata read lives in src/provenance.ts,
 // and the adapter arrives through ctx.adapter.
 import { tmpdir } from "node:os";
 import { oneLine } from "../cli-arguments.js";
@@ -163,7 +163,7 @@ async function gatherInstallStages(ctx, selection, artifact) {
             // is what turns a failed inspection into "error: installed manager
             // fingerprint inspection failed after install."
             // renderInstallVerification's failed-inspection arm
-            // (`src/codex-presentation.ts:332::if (inspection.status !== 0 || !inspection.outcome.ok) {`)
+            // (`src/harnesses/codex/presentation.ts:329::if (inspection.status !== 0 || !inspection.outcome.ok) {`)
             // exists for this result-bearing path; the lifecycle compatibility
             // export delegates through the same arm. Returning
             // failed() instead reported the adapter's own generic diagnostic and
@@ -190,18 +190,28 @@ async function gatherInstallStages(ctx, selection, artifact) {
                     const restoration = restored.ok
                         ? `installed state after rollback: ${restored.result.outcome.result.kind}; identity=${restored.result.outcome.result.observedIdentity}`
                         : "installed state after rollback could not be inspected";
-                    const message = !settlement.ok
+                    const verificationOutput = inspection === null
+                        ? null
+                        : ctx.adapter.presentation.renderInstallVerification(selection.desiredCommit, install.result, inspection);
+                    const inspectionMessage = verificationOutput === null && !inspected.ok
+                        ? inspected.message
+                        : null;
+                    const settlementMessage = !settlement.ok
                         ? settlement.message
-                        : !inspected.ok
-                            ? inspected.message
-                            : "installation could not be verified";
+                        : null;
                     return {
                         kind: "verified",
                         outcomes,
                         status: 1,
-                        stdout: [],
+                        stdout: verificationOutput?.stdout ?? [],
                         stderr: [
-                            ...(message === null ? [] : [`error: ${message}`]),
+                            ...(verificationOutput?.stderr ?? []),
+                            ...(inspectionMessage === null
+                                ? []
+                                : [`error: ${inspectionMessage}`]),
+                            ...(settlementMessage === null
+                                ? []
+                                : [`error: ${settlementMessage}`]),
                             restoration,
                         ],
                     };

package/dist/commands/prepare.js

@@ -14,7 +14,7 @@ import { runWithMutation } from "./mutation.js";
 // Every message this module writes is hand-written here. The cause is attached
 // for debuggability and never reaches a stream: oneLine (src/cli-arguments.ts)
 // reads .message only. Same arrangement as hookError
-// (`src/hooks.ts:44::function hookError`).
+// (`src/harnesses/codex/hooks.ts:44::function hookError`).
 function prepareError(message, cause) {
     return new SafetyError("prepare", message, { cause });
 }
@@ -341,8 +341,8 @@ async function performPrepare(argv, ctx) {
         // failure (its cause is the shared runner's (src/validator.ts) captured
         // spawn error, which oneLine never reads -- it takes .message only);
         // readManifest's three hookError messages
-        // (`src/hooks.ts:113-138::readManifest`), pinned by
-        // `tests/unit/hooks.test.ts:95::void test("readManifest diagnostics` as carrying no reader vocabulary or
+        // (`src/harnesses/codex/hooks.ts:113-138::readManifest`), pinned by
+        // `tests/unit/harnesses/codex/hooks.test.ts:95::void test("readManifest diagnostics` as carrying no reader vocabulary or
         // errno; and SafetyErrors from gitSafeSource, writeProvenance, and
         // withWorkspace.
         //
@@ -382,7 +382,7 @@ async function performPrepare(argv, ctx) {
         // only, so it bounds how much of that text lands, not what it may
         // contain.
         //
-        // runAdapter's closing `throw cause` (src/adapter.ts) does NOT arrive
+        // runAdapter's closing `throw cause` (src/harnesses/codex/adapter.ts) does NOT arrive
         // here -- the call site catches it and converts it to a hand-written
         // message per AGENTS.md's reader-diagnostics rule.
         //
@@ -418,7 +418,7 @@ async function performPrepare(argv, ctx) {
         // completed before cleanup ran, so it is not being reported as unverified
         // -- but something did still go wrong, and AGENTS.md's fail-closed rule
         // extends to it. Mirrors
-        // `src/commands/install.ts:546-554::if (cleanupWarning`.
+        // `src/commands/install.ts:562-570::if (cleanupWarning`.
         ctx.stderr.write(`error: ${cleanupWarning}\n`);
         return 1;
     }

package/dist/commands/probe.js

@@ -11,7 +11,7 @@ export const PROBE_USAGE = "error: usage: superpowers-manager probe [--porcelain
 // silent diagnostics regression, not a simplification.
 //
 // Interpolating error.message and each hint is the sanctioned form (AGENTS.md):
-// src/adapter.ts has 52 `fail()` sites and none interpolates a caught error's
+// src/harnesses/codex/adapter.ts has 52 `fail()` sites and none interpolates a caught error's
 // message, so the callee owns every failure reachable on this path. Those two
 // writes now live in writeAdapterFailure (src/adapter-result.ts), which
 // validates all three strings before the first of them reaches the stream.
@@ -121,7 +121,7 @@ function validControl(value) {
 // evidence and report it as success.
 //
 // It does still THROW for a non-AdapterFailure cause (runAdapter's closing
-// `throw cause`, src/adapter.ts). That is caught here rather than in runProbe's
+// `throw cause`, src/harnesses/codex/adapter.ts). That is caught here rather than in runProbe's
 // outer catch, because the two need different diagnostics -- see spec §3.3a.
 //
 // Reached through ctx.adapter, not a direct module-level dependency on the
@@ -377,9 +377,9 @@ export async function runProbe(argv, ctx) {
         // which catches every failure and returns "".
         //
         // A non-AdapterFailure re-thrown by runAdapter's closing `throw cause`
-        // (src/adapter.ts) does NOT reach here: inspect() catches it and converts
+        // (src/harnesses/codex/adapter.ts) does NOT reach here: inspect() catches it and converts
         // it to a hand-written message per AGENTS.md's reader-diagnostics rule -- a
-        // rethrown cause is exactly the failure src/adapter.ts declined to own, so
+        // rethrown cause is exactly the failure src/harnesses/codex/adapter.ts declined to own, so
         // its text must never reach this stream. See §3.3a.
         //
         // gatherProbe performs no writes of its own, so this catch cannot also be

package/dist/commands/uninstall.js

@@ -1,5 +1,5 @@
 // Ports scripts/uninstall. The shell sourced common.sh, provenance.sh,
-// lifecycle.sh and adapter.sh; the predicates now live in src/lifecycle.ts
+// lifecycle.sh and adapter.sh; the predicates now live in src/harnesses/codex/lifecycle.ts
 // and the adapter arrives through ctx.adapter.
 import { tmpdir } from "node:os";
 import { oneLine } from "../cli-arguments.js";
@@ -126,7 +126,7 @@ async function gatherUninstall(ctx) {
         // Reachable only for mkdtemp failure, with nothing collected yet: this
         // callback never throws -- every ctx.adapter throw is already caught
         // inside invoke(), and presenceFlag/verifyUninstalledResources/
-        // reportLegacyState are pure (src/lifecycle.ts's header comment) -- so a
+        // reportLegacyState are pure (src/harnesses/codex/lifecycle.ts's header comment) -- so a
         // post-success cleanup failure is handled by onCleanupFailure above and
         // cannot reach here. Wrapping with `outcomes` anyway keeps the class
         // total over its declared contract rather than assuming the callback's
@@ -163,7 +163,7 @@ async function performUninstall(argv, ctx) {
         // blindly.
         //
         // A cause outside ctx.adapter's AdapterFailure guard
-        // (`src/adapter.ts:973-999::async function runCodexOperation(`) does NOT
+        // (`src/harnesses/codex/adapter.ts:1081::async function runCodexOperation<T = JsonValue>(`) does NOT
         // reach here: invoke() catches it inside gatherUninstall and converts it
         // to a hand-written message carried as UninstallOutcome data, exactly as
         // src/commands/probe.ts's inspect() does for the same cause.

package/dist/commands/update.js

@@ -1,5 +1,5 @@
 // Ports scripts/update. The shell sourced common.sh and lifecycle.sh; the
-// predicates now live in src/lifecycle.ts. Unlike install and uninstall,
+// predicates now live in src/harnesses/codex/lifecycle.ts. Unlike install and uninstall,
 // update issues no ctx.adapter call of its own: every adapter interaction
 // this module needs already happens inside gatherProbe, runPrepare or
 // runInstall, each of which owns its own §4.2a-conformant invoke() gate. That

package/dist/domain/refs.js

@@ -3,6 +3,10 @@ const SEMVER_BASE_SOURCE = "(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0-9]*)\\.(?:0|[1-9][0
     "(?:\\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*))?";
 export const SEMVER_BASE_RE = new RegExp(`^${SEMVER_BASE_SOURCE}$`);
 export const TAG_RE = new RegExp(`^v${SEMVER_BASE_SOURCE}$`);
+// The Python's own SEMVER_RE (:15-22). Deliberately not SEMVER_BASE_SOURCE
+// from this module, which omits the `+build` component; widening the shared
+// constant would change TAG_RE and is out of scope.
+export const SEMVER_RE = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 export const COMMIT_RE = /^[0-9a-f]{40}$/;
 export const COMMIT_INPUT_RE = /^[0-9A-Fa-f]{40}$/;
 export function isTagRef(value) {

package/dist/{adapter.js → harnesses/codex/adapter.js}

@@ -4,21 +4,29 @@ import { constants } from "node:fs";
 import { access, copyFile, mkdir, readFile, realpath, stat, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { delimiter, isAbsolute, join } from "node:path";
-import { AdapterMessageLog, failureResult, successResult, } from "./adapter-result.js";
-import { activePluginVersionFromJson, installedListingHas, marketplaceRootFromJson, } from "./codex-json.js";
-import { CODEX_LEGACY_PLUGIN_ID, CODEX_MANAGER_PLUGIN_ID, inspectCodexConflicts, } from "./codex-conflicts.js";
-import { oneLine } from "./cli-arguments.js";
-import { installedCommitFromRoot, installedRootForVersion, pathsEqual, } from "./codex-state.js";
+import { AdapterMessageLog, failureResult, successResult, } from "../../adapter-result.js";
+import { activePluginVersionFromJson, codexInstalledPluginsFromJson, installedListingHas, marketplaceRootFromJson, } from "./json.js";
+import { CODEX_LEGACY_PLUGIN_ID, CODEX_MANAGER_PLUGIN_ID, inspectCodexConflicts, } from "./conflicts.js";
+import { oneLine } from "../../cli-arguments.js";
+import { installedCommitFromRoot, installedRootForVersion, pathsEqual, } from "./state.js";
+import { codexHome } from "./paths.js";
+import { readCodexStoredState } from "./stored-state.js";
 import { validateGeneratedPlugin } from "./generated-plugin.js";
 import { classifyHooks, materializeHooks, readManifest, } from "./hooks.js";
 import { applyManifestOverlay } from "./manifest-overlay.js";
-import { readCodexBuildSource } from "./provenance.js";
-import { isAcceptedSplitValue } from "./validate-generated-plugin-cli.js";
-import { withWorkspace, workspaceRemovalFailure } from "./workspace.js";
+import { readCodexBuildSource } from "../../provenance.js";
+import { isAcceptedSplitValue } from "../../validate-generated-plugin-cli.js";
+import { withWorkspace, workspaceRemovalFailure } from "../../workspace.js";
 const PLUGIN_ID = CODEX_MANAGER_PLUGIN_ID;
 const MARKETPLACE_NAME = "superpowers-manager";
 const LEGACY_PLUGIN_ID = CODEX_LEGACY_PLUGIN_ID;
 const LEGACY_MARKETPLACE_NAME = "superpowers-wrapper";
+export function codexInstallRefreshMode(env) {
+    const refreshMode = env.SUPERPOWERS_INSTALL_REFRESH_MODE || "add-only";
+    return refreshMode === "add-only" || refreshMode === "remove-add"
+        ? refreshMode
+        : null;
+}
 class AdapterFailure extends Error {
     code;
     hints;
@@ -89,12 +97,20 @@ function runCommand(file, args, env) {
         });
     });
 }
-// Exported only so tests/unit/adapter.test.js can assert the env scrub
+// Exported only so tests/unit/harnesses/codex/adapter.test.ts can assert the env scrub
 // directly. No production caller uses this name.
 export { runCommand as runCommandForTest };
 function commandFailed(result) {
     return result.status !== 0;
 }
+async function storedStateAfterListingFailure(env, code, message) {
+    try {
+        return await readCodexStoredState(env, process.cwd());
+    }
+    catch {
+        fail(code, message);
+    }
+}
 // Exported only so its unit test can reach it. No integration test can cover
 // it: on Linux glibc, `execvp`'s ENOEXEC falls back to `/bin/sh`, so the spawn
 // still succeeds, and every other candidate errno is already peeled off by an
@@ -281,7 +297,7 @@ async function runBuild(input, env, log) {
                 // path — three are the frozen CPython wording, and the fourth (the
                 // numeric-overflow diagnostic, which has no CPython oracle wording
                 // to match) now carries the path via its own rewrap in
-                // src/manifest-overlay.ts. Emit as-is, with no added prefix — a
+                // src/harnesses/codex/manifest-overlay.ts. Emit as-is, with no added prefix — a
                 // prefix here would double up the path these messages already
                 // name.
                 log.appendText("stderr", oneLine(cause));
@@ -383,25 +399,27 @@ async function runInstall(packageRoot, env, log) {
         fail("invalid-arguments", `package root not found: ${packageRoot}`);
     }
     const codexBin = env.SUPERPOWERS_CODEX || "codex";
-    const refreshMode = env.SUPERPOWERS_INSTALL_REFRESH_MODE || "add-only";
+    const refreshMode = codexInstallRefreshMode(env);
     await requireCodex(codexBin, env);
-    if (refreshMode !== "add-only" && refreshMode !== "remove-add") {
-        fail("invalid-arguments", `unsupported SUPERPOWERS_INSTALL_REFRESH_MODE: ${refreshMode}`);
+    if (refreshMode === null) {
+        fail("invalid-arguments", `unsupported SUPERPOWERS_INSTALL_REFRESH_MODE: ${env.SUPERPOWERS_INSTALL_REFRESH_MODE}`);
     }
     let entered = false;
     try {
         return await withWorkspace(tmpdir(), "superpowers-manager.adapter-install.", async () => {
             entered = true;
             const marketplaceList = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
-            if (commandFailed(marketplaceList)) {
-                fail("install-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
-            }
             let registeredRoot;
-            try {
-                registeredRoot = marketplaceRootFromJson(marketplaceList.stdout, MARKETPLACE_NAME);
+            if (commandFailed(marketplaceList)) {
+                registeredRoot = (await storedStateAfterListingFailure(env, "install-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`)).managerMarketplaceRoot;
             }
-            catch {
-                fail("install-failed", `cannot parse output of '${codexBin} plugin marketplace list --json'`);
+            else {
+                try {
+                    registeredRoot = marketplaceRootFromJson(marketplaceList.stdout, MARKETPLACE_NAME);
+                }
+                catch {
+                    fail("install-failed", `cannot parse output of '${codexBin} plugin marketplace list --json'`);
+                }
             }
             if (registeredRoot.length === 0) {
                 const added = await mutationCommand(log, codexBin, ["plugin", "marketplace", "add", packageRoot], env);
@@ -543,16 +561,34 @@ async function runInspect(view, context, env, log) {
                 entered = true;
                 const plugins = await listingCommand(log, codexBin, ["plugin", "list", "--json"], env);
                 if (commandFailed(plugins)) {
-                    fail("inspect-failed", `cannot list Codex plugins via '${codexBin} plugin list --json'`);
-                }
-                const marketplaces = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
-                if (commandFailed(marketplaces)) {
-                    fail("inspect-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
+                    const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex plugins via '${codexBin} plugin list --json'`);
+                    const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedListingJson);
+                    const managerPresent = stored.managerPluginPresent ||
+                        stored.managerMarketplaceRoot.length > 0;
+                    const legacyPresent = stored.legacyPluginPresent ||
+                        stored.legacyMarketplaceRoot !== null;
+                    return {
+                        view: "ownership",
+                        resources: {
+                            plugin: stored.managerPluginPresent,
+                            marketplace: true,
+                        },
+                        legacy_resources: {
+                            plugin: stored.legacyPluginPresent,
+                            marketplace: stored.legacyMarketplaceRoot !== null,
+                        },
+                        identity_state: managerPresent
+                            ? legacyPresent
+                                ? "both"
+                                : "manager"
+                            : legacyPresent
+                                ? "legacy"
+                                : "neither",
+                        conflicts: [...conflicts],
+                    };
                 }
                 let managerPlugin;
                 let legacyPlugin;
-                let managerMarketplace;
-                let legacyMarketplace;
                 let conflicts;
                 try {
                     managerPlugin = installedListingHas(plugins.stdout, "installed", "pluginId", PLUGIN_ID);
@@ -562,6 +598,35 @@ async function runInspect(view, context, env, log) {
                 catch {
                     fail("inspect-failed", `cannot parse output of '${codexBin} plugin list --json'`);
                 }
+                const marketplaces = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
+                if (commandFailed(marketplaces)) {
+                    const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
+                    const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedListingJson);
+                    const managerPresent = true;
+                    const legacyPresent = stored.legacyPluginPresent ||
+                        stored.legacyMarketplaceRoot !== null;
+                    return {
+                        view: "ownership",
+                        resources: {
+                            plugin: stored.managerPluginPresent,
+                            marketplace: true,
+                        },
+                        legacy_resources: {
+                            plugin: stored.legacyPluginPresent,
+                            marketplace: stored.legacyMarketplaceRoot !== null,
+                        },
+                        identity_state: managerPresent
+                            ? legacyPresent
+                                ? "both"
+                                : "manager"
+                            : legacyPresent
+                                ? "legacy"
+                                : "neither",
+                        conflicts: [...conflicts],
+                    };
+                }
+                let managerMarketplace;
+                let legacyMarketplace;
                 try {
                     managerMarketplace = installedListingHas(marketplaces.stdout, "marketplaces", "name", MARKETPLACE_NAME);
                     legacyMarketplace = installedListingHas(marketplaces.stdout, "marketplaces", "name", LEGACY_MARKETPLACE_NAME);
@@ -628,6 +693,70 @@ export function codexRemove(input, context) {
 export function codexInspect(view, context) {
     return runCodexOperation("inspect", context, (env, log) => runInspect(view, context, env, log));
 }
+export function codexReadNativeState(context) {
+    return runCodexOperation("native-state", context, async (env, log) => {
+        const codexBin = env.SUPERPOWERS_CODEX || "codex";
+        await requireCodex(codexBin, env);
+        const plugins = await listingCommand(log, codexBin, ["plugin", "list", "--json"], env);
+        if (commandFailed(plugins)) {
+            const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex plugins via '${codexBin} plugin list --json'`);
+            return {
+                marketplaceRoot: stored.managerMarketplaceRoot,
+                pluginPresent: stored.managerPluginPresent,
+                pluginEnabled: stored.managerPluginEnabled,
+                activeVersion: null,
+                activeRoot: null,
+            };
+        }
+        let manager;
+        let activeVersion;
+        try {
+            const managers = codexInstalledPluginsFromJson(plugins.stdout).filter((plugin) => plugin.pluginId === PLUGIN_ID);
+            if (managers.length > 1)
+                fail("inspect-failed", "Codex manager plugin appears more than once");
+            manager = managers[0];
+            activeVersion =
+                manager === undefined
+                    ? ""
+                    : activePluginVersionFromJson(plugins.stdout, PLUGIN_ID);
+        }
+        catch (cause) {
+            if (cause instanceof AdapterFailure)
+                throw cause;
+            fail("inspect-failed", `cannot parse output of '${codexBin} plugin list --json'`);
+        }
+        const marketplaces = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
+        if (commandFailed(marketplaces)) {
+            const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
+            return {
+                marketplaceRoot: stored.managerMarketplaceRoot,
+                pluginPresent: stored.managerPluginPresent,
+                pluginEnabled: stored.managerPluginEnabled,
+                activeVersion: null,
+                activeRoot: null,
+            };
+        }
+        let marketplaceRoot;
+        try {
+            marketplaceRoot = marketplaceRootFromJson(marketplaces.stdout, MARKETPLACE_NAME, true);
+        }
+        catch (cause) {
+            if (cause instanceof AdapterFailure)
+                throw cause;
+            fail("inspect-failed", `cannot parse output of '${codexBin} plugin marketplace list --json'`);
+        }
+        const searchRoot = env.SUPERPOWERS_INSTALLED_SEARCH_ROOT || codexHome(env, process.cwd());
+        return {
+            marketplaceRoot: marketplaceRoot || null,
+            pluginPresent: manager !== undefined,
+            pluginEnabled: manager?.enabled === true,
+            activeVersion: activeVersion || null,
+            activeRoot: activeVersion
+                ? installedRootForVersion(searchRoot, MARKETPLACE_NAME, "superpowers", activeVersion)
+                : null,
+        };
+    });
+}
 export async function runAdapter(argv, context) {
     const rawOperation = argv[0];
     const operation = rawOperation || "adapter";

package/dist/{codex-compatibility.js → harnesses/codex/compatibility.js}

@@ -1,14 +1,14 @@
 import { join } from "node:path";
-import { validateNativeSkill } from "./artifact-tree.js";
-import { classifyPathNoFollow, assertExistingContained } from "./safe-path.js";
+import { validateNativeSkill } from "../../artifact-tree.js";
+import { classifyPathNoFollow, assertExistingContained, } from "../../safe-path.js";
 import { classifyHooks, readManifest } from "./hooks.js";
-import { SEMVER_RE } from "./generated-plugin.js";
-import { validateSource } from "./selection.js";
+import { SEMVER_RE } from "../../domain/refs.js";
+import { validateSource } from "../../selection.js";
 import { writeFile } from "node:fs/promises";
-import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, } from "./artifact-tree.js";
-import { COMMIT_RE } from "./domain/refs.js";
+import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, } from "../../artifact-tree.js";
+import { COMMIT_RE } from "../../domain/refs.js";
 import { validateGeneratedPlugin } from "./generated-plugin.js";
-import { SafetyError } from "./safety-error.js";
+import { SafetyError } from "../../safety-error.js";
 export async function writeCodexAssessment(root, selection, manifestSource) {
     const receipt = {
         schema: 1,

package/dist/{codex-conflicts.js → harnesses/codex/conflicts.js}

@@ -1,6 +1,6 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { codexInstalledPluginsFromJson, } from "./codex-json.js";
+import { codexInstalledPluginsFromJson, } from "./json.js";
 export const CODEX_MANAGER_PLUGIN_ID = "superpowers@superpowers-manager";
 export const CODEX_LEGACY_PLUGIN_ID = "superpowers@superpowers-wrapper";
 const SUPERPOWERS_PLUGIN_PREFIX = "superpowers@";