superpowers-manager 0.3.0 → 0.4.0

package/README.md

@@ -16,16 +16,21 @@ npx superpowers-manager probe
 npx superpowers-manager update
 ```
 
-Use the official marketplace for the simplest native Codex installation. Use
-Superpowers Manager when you want immediate stable-upstream freshness after a
-user-triggered install/update, per-invocation release or commit selection,
-recorded upstream provenance, diagnostics, upstream-owned Codex hook handling,
-and explicit install/update/probe/uninstall lifecycle control.
+Use Superpowers Manager to follow the latest stable Superpowers release directly
+from upstream and apply updates with one command. By default, `install` and
+`update` resolve the highest stable `vX.Y.Z` tag when invoked; saved pins and
+invocation overrides take precedence. `probe` reports whether your installation
+matches that selection without changing Codex state. Updates are user-triggered.
 
-| Choose | Best fit |
-|---|---|
-| Official marketplace | Simplest Codex-native installation and marketplace-managed cadence |
-| `superpowers-manager` | Direct stable-upstream freshness when invoked, exact ref selection, provenance, diagnostics, and lifecycle control |
+| Choose | Version source | Best fit |
+|---|---|---|
+| `superpowers-manager` | Latest stable upstream tag by default, or your saved/overridden selection | Follow upstream stable with drift reporting and verified updates |
+| Direct upstream repository | The configured Git ref, or the repository's default branch | Use Codex's native Git marketplace support |
+| `superpowers@openai-curated` | The copy distributed in the curated marketplace | Use the curated integration and its refresh policy |
+
+See [Comparing installation routes](#comparing-installation-routes) for commands
+and update behavior. Use one provider at a time; see
+[Provider ownership](#provider-ownership) before switching.
 
 ### Moving from `superpowers-wrapper`
 
@@ -39,10 +44,11 @@ It never removes the legacy provider automatically.
 
 ## Requirements and platforms
 
-Superpowers Manager requires Node 24+, and Codex is the only supported
+The installed Superpowers Manager package requires Node >=24. Native source,
+tests, and packaging tooling require Node >=24.12.0. Codex is the only supported
 integration today. Every other requirement is per command, enforced by
 preflight before any dispatch. This table is checked against production by
-`tests/bin/readme-requirements.test.js`; edit it when a command's requirements
+`tests/bin/readme-requirements.test.ts`; edit it when a command's requirements
 change, in the same pull request.
 
 <!-- requirements:begin -->
@@ -73,6 +79,78 @@ of a saved exact pin can reuse its recorded identity without upstream access.
 Updates remain user-triggered; the manager does not run automatic or background
 updates.
 
+## Comparing installation routes
+
+### Getting the latest stable release
+
+The manager selects the highest stable upstream `vX.Y.Z` tag when its effective
+policy is `latest-release`. It does not require the curated marketplace to
+publish that release first. Saved pins and environment overrides can select a
+different version or source; see [Choosing the upstream version](#choosing-the-upstream-version).
+
+The direct repository route uses the Git ref you configure. Adding the repository
+without `--ref` uses its default branch, which is not a latest-stable release
+policy. The curated route uses the
+[copy in `openai/plugins`](https://github.com/openai/plugins/tree/main/plugins/superpowers).
+Refreshing that snapshot does not independently resolve the latest stable tag
+from `obra/superpowers`; curated may match upstream or lag behind it.
+
+The native CLI examples below were checked against Codex `0.153.3`. Upstream's
+[marketplace manifest](https://github.com/obra/superpowers/blob/main/.agents/plugins/marketplace.json)
+names its marketplace `superpowers-dev`.
+
+### First install
+
+These are alternative routes; do not run both to install duplicate providers.
+
+| Step | Superpowers Manager | Direct upstream repository |
+|---|---|---|
+| 1 | `npx superpowers-manager install` | `codex plugin marketplace add https://github.com/obra/superpowers` |
+| 2 | — | `codex plugin add superpowers@superpowers-dev` |
+
+The manager follows upstream stable by default. For a specific release on the
+direct route, choose its tag and add `--ref TAG` to the marketplace-add command.
+
+### Staying current
+
+| Action | Superpowers Manager | Direct upstream repository |
+|---|---|---|
+| Explicit update | `npx superpowers-manager update` | `codex plugin marketplace upgrade superpowers-dev` |
+| Optional inspection | `npx superpowers-manager probe` | `codex plugin list` |
+
+The manager probes first, skips prepare/install when current and update control
+is valid, and verifies the resulting installed state after a refresh. `probe`
+reports requested and resolved refs, desired/generated/installed commits, and
+status. With a saved pin, "current" means matching that pin, not necessarily
+matching the latest upstream release. See [Lifecycle commands](#lifecycle-commands).
+
+Native marketplace upgrade follows its configured ref. In the checked Codex
+version, it can skip unchanged snapshots and refreshes installed plugins when
+the marketplace changes; a second `plugin add` is not required for that refresh.
+Codex also has an automatic refresh path for configured Git marketplaces.
+See the [native upgrade implementation](https://github.com/openai/codex/blob/rust-v0.153.3/codex-rs/core-plugins/src/manager.rs).
+`plugin list` shows installed versions; comparing them with upstream stable is
+separate inspection work, not a prerequisite for running an update.
+
+### Changing the selected version
+
+Replace `TAG` below with the exact release tag you want. For an already registered
+direct marketplace, remove/add is a CLI route to changing its ref:
+
+| Step | Superpowers Manager | Direct upstream repository |
+|---|---|---|
+| 1 | `npx superpowers-manager pin TAG` | `codex plugin marketplace remove superpowers-dev` |
+| 2 | `npx superpowers-manager update` | `codex plugin marketplace add https://github.com/obra/superpowers --ref TAG` |
+| 3 | — | `codex plugin add superpowers@superpowers-dev` |
+
+The manager's `pin` saves verified intent without changing Codex state; `update`
+applies it. To resume following stable releases, run
+`npx superpowers-manager track-latest`, then `npx superpowers-manager update`.
+The native sequence changes marketplace configuration immediately. In the checked
+CLI, `marketplace upgrade` has no `--ref` option, and adding the same marketplace
+name with a different ref is rejected. This sequence does not imply that editing
+native configuration is impossible.
+
 ## What it does
 
 - Resolves an upstream ref, defaulting to the latest stable `vX.Y.Z` release
@@ -111,6 +189,8 @@ eliminates latent hook-policy drift.
 - The in-process TypeScript runtime under `src/` owns lifecycle dispatch,
   status, and adapter-result handling;
   see the [in-process adapter result contract](https://github.com/j7an/superpowers-manager/blob/main/docs/adapter-result-contract.md).
+- Developers extending that runtime should start with the
+  [internal harness interface](https://github.com/j7an/superpowers-manager/blob/main/docs/harness-interface.md).
 - `src/adapter.ts` owns build, inspection, reconciliation, and Codex mutation.
 - Codex is the only supported adapter today; no public harness selector ships
   yet.
@@ -306,46 +386,175 @@ updates the official provider or any other provider automatically.
   SUPERPOWERS_INSTALL_REFRESH_MODE=remove-add npx superpowers-manager update
   ```
 
+## pnpm updates
+
+A weekly Monday workflow (06:00 UTC), also available through manual dispatch,
+opens or refreshes a dedicated pull request updating only `package.json`'s
+`packageManager` pin. It selects a newer, non-deprecated stable pnpm release
+within the pinned major after five days. If the current pin is deprecated,
+the shared updater bypasses that waiting period and discloses it in the PR.
+Major upgrades remain a manual decision; the lockfile is not updated by this
+workflow.
+
+The caller forwards only `RELEASE_BOT_PRIVATE_KEY` and uses
+`vars.RELEASE_BOT_APP_ID` for App-authored PRs that can trigger CI. Keep both
+configured. After adopting the caller, verify a manual run's App authentication
+and inspect any resulting PR before treating live integration as validated.
+
 ## Tests
 
+Install once, run the static gate before submission, and choose the package
+script that matches the scope you are iterating on:
+
+```sh
+pnpm install --frozen-lockfile
+pnpm run check:static
+pnpm test
+pnpm run test:unit
+pnpm run test:integration
+pnpm run test:harness:codex
+pnpm run test:acceptance
+```
+
+The package scripts above are alternative iteration selectors; do not run every
+row sequentially as a substitute for acceptance. `pnpm test` runs all shared
+suites once, while the unit and integration scripts select one shared group.
+`test:harness:codex` runs only the isolated Docker Codex probe. Complete
+acceptance is `pnpm run check:static` followed by `pnpm run test:acceptance`
+with explicit evidence for the package's minimum Node runtime.
+
+To compare shared-suite scheduling while iterating, use:
+
+```sh
+sh tests/run.sh --concurrency 1
+sh tests/run.sh --concurrency 2
+```
+
+Every normally completed shared run emits both `run-node-suites: complete
+status=<status>` and `tests/run.sh: complete failed=<count>`. Either sentinel
+may report failure; if either is absent, the run was interrupted and is
+incomplete.
+
+Use a Homebrew-managed local pnpm by command name; do not use Corepack.
+`check:static` checks formatting, lints, and typechecks production and tests without
+emitting JavaScript. Run the maintained CLI directly with `node src/cli.ts`.
+Tests and their subprocesses execute TypeScript against `src/` with no checkout
+build. Future production coverage covers `src/`, including `src/cli.ts`; emitted
+distribution files, tests, and packaging tools are outside that source scope.
+No coverage collection is enabled by this migration.
+
+On macOS, reuse an existing exact package-minimum Node executable when one is
+already available:
+
+```sh
+export SPW_PACKAGE_NODE=/absolute/path/to/node-v24.0.0
+export SPW_PACKAGE_NODE_VERSION=24.0.0
+test "$("$SPW_PACKAGE_NODE" -p 'process.versions.node')" = "$SPW_PACKAGE_NODE_VERSION"
+```
+
+Otherwise, run this prerequisite setup from the worktree while a supported
+native Node remains on `PATH`. It downloads an official Node archive into a
+new temporary directory and verifies the selected checksum before extraction:
+
+```sh
+spw_runtime_dir=$(mktemp -d)
+SPW_PACKAGE_NODE_VERSION=$(node -p 'const e=require("./package.json").engines.node; const m=/^>=(\d+)$/.exec(e); if(!m) throw Error("unsupported engines.node"); `${m[1]}.0.0`')
+case "$(uname -m)" in
+  arm64) spw_node_arch=arm64 ;;
+  x86_64) spw_node_arch=x64 ;;
+  *) echo "unsupported macOS architecture" >&2; exit 1 ;;
+esac
+spw_node_archive="node-v${SPW_PACKAGE_NODE_VERSION}-darwin-${spw_node_arch}.tar.gz"
+(
+  set -eu
+  cd "$spw_runtime_dir"
+  curl --fail --location --remote-name "https://nodejs.org/dist/v${SPW_PACKAGE_NODE_VERSION}/${spw_node_archive}"
+  curl --fail --location --remote-name "https://nodejs.org/dist/v${SPW_PACKAGE_NODE_VERSION}/SHASUMS256.txt"
+  rg -F "  ${spw_node_archive}" SHASUMS256.txt > selected-sha256.txt
+  test "$(wc -l < selected-sha256.txt)" -eq 1
+  read -r spw_node_sha spw_selected_archive < selected-sha256.txt
+  test "$spw_selected_archive" = "$spw_node_archive"
+  shasum -a 256 -c selected-sha256.txt
+  tar -xzf "$spw_node_archive"
+) || exit 1
+SPW_PACKAGE_NODE="$spw_runtime_dir/node-v${SPW_PACKAGE_NODE_VERSION}-darwin-${spw_node_arch}/bin/node"
+export SPW_PACKAGE_NODE SPW_PACKAGE_NODE_VERSION
+```
+
+The native runtime on `PATH` remains unchanged. With the package runtime
+variables exported, complete acceptance is:
+
 ```sh
 pnpm install --frozen-lockfile
-pnpm run build
-sh tests/run.sh                          # Layers 1-3: host-side hermetic checks while iterating
-sh tests/container.sh                    # Layers 1-4: blocking Docker acceptance command
-sh tests/manual/codex-behavior-probe.sh  # optional native-only compatibility residue
+pnpm run check:static
+pnpm run test:acceptance
+```
+
+After the checks, remove only the temporary directory created by this
+invocation and clear its variables:
+
+```sh
+rm -rf -- "$spw_runtime_dir"
+unset SPW_PACKAGE_NODE SPW_PACKAGE_NODE_VERSION spw_node_arch spw_node_archive spw_runtime_dir
+```
+
+Linux CI provisions the exact package runtime with `actions/setup-node`.
+Downloads happen only during prerequisite setup, never inside the hermetic test
+cases.
+
+Packaging compiles only production source into fresh external temporary staging:
+
+```sh
+node tests/tools/pack.ts --out-dir /absolute/existing/temporary/output
 ```
 
-`pnpm run build` deletes `dist/` before compiling, so every build is a clean
-rebuild and stale artifacts of deleted or renamed modules cannot survive.
+Allocate the existing output directory outside the checkout before running this
+command. It returns npm-compatible JSON for one validated tarball and removes its
+own staging. Bare checkout `npm pack` always fails with this command's guidance,
+even if stale `dist/` exists. Maintained or manager-generated JavaScript must not
+remain in the checkout; dependencies and generated upstream plugin content have
+separate ownership. This developer command does not authorize publication; follow
+`RELEASING.md` for the protected release procedure.
 
 Layers 1-3 stay offline and hermetic: they use a fake local upstream repo plus
 host-side fixtures, and they perform no mutation of the developer's or runner's
 real Codex state.
 
-Layer 4 is the Docker acceptance path. It is the required completion command
-because the isolated-container Codex probe graduated from a temporary
-nonblocking spike to a blocking acceptance gate. `sh tests/container.sh` runs
-the inner `sh tests/run.sh` suite and then the real Codex offline probe inside
-an isolated container home with networking disabled. That container run may
-mutate the throwaway container-local Codex state, but it still performs no
-mutation of the developer's or runner's real Codex state.
+Layer 4 is the Docker acceptance path. `pnpm run test:harness:codex` runs the
+real Codex offline probe inside an isolated container home with networking
+disabled. `pnpm run test:acceptance` composes one host-side shared run with that
+probe. The container may mutate its throwaway container-local Codex state, but
+it performs no mutation of the developer's or runner's real Codex state.
+
+Release validation deliberately retains the combined shared-plus-Codex path at
+both native endpoints:
+
+```sh
+SPW_NATIVE_NODE_VERSION=24.12.0 sh tests/container.sh
+SPW_NATIVE_NODE_VERSION=24 sh tests/container.sh
+```
 
 The container probe uses Codex's `hooks/list` only as compatibility evidence
 for the tested Codex build. It is not a stable Superpowers Manager API.
 
-The manual probe is opt-in and covers native-only compatibility residue such as
+`sh tests/manual/codex-behavior-probe.sh` remains opt-in and covers native-only compatibility residue such as
 path/cache and version-precedence behavior against an intentionally real local
-Codex install. It is not part of acceptance. GitHub Actions runs both the
-toolchain check and the blocking container acceptance command on pull requests
-and pushes to `main`.
+Codex install. It is not part of acceptance. GitHub Actions runs two focused
+`toolchain` entries and one blocking Codex integration job on pull requests
+and pushes to `main`. The Node 24.12.0 toolchain entry checks native source
+loading, the suite runner/assertion preload, and package-producer success and
+failure. The latest-24 toolchain entry alone runs `pnpm run check:static` and
+the full shared suite with package-minimum evidence. The independent `test` job
+runs only the Codex offline probe on latest Node 24.x. Release acceptance still
+runs the combined shared and Codex paths at both native endpoints, and the
+installed npm executable is tested with Node 24.0.0. These runtime selectors
+are separate from the Homebrew-managed local commands above.
 
 ## Repository layout
 
 ```
 .agents/plugins/marketplace.json          # local marketplace definition (tracked)
 .github/                                  # CI, security, dependency, and release workflows (tracked)
-bin/superpowers-manager.js                # public thin loader for dist/cli.js
 config/upstream-ref                       # packaged upstream fallback policy (tracked)
 docs/                                     # adapter result contract and baseline evidence (tracked)
 package.json pnpm-lock.yaml tsconfig.json # package contract and locked toolchain (tracked)
@@ -353,12 +562,12 @@ plugins/superpowers/
   .codex-plugin/plugin.template.json      # fallback manifest template (tracked)
   generated plugin tree                   # prepared from upstream (gitignored)
 src/                                      # in-process TypeScript runtime (tracked)
-  cli.ts                                  # CLI parsing, preflight, and command dispatch
+  cli.ts                                  # sole maintained CLI entry, parsing, preflight, dispatch
   commands/                               # lifecycle and selection command handlers
   adapter.ts                              # Codex integration
 tests/                                    # hermetic suite and manual Codex probe (tracked)
   migration-inventory/                     # frozen historical evidence
-dist/                                     # generated ESM build tree (gitignored)
+  tools/pack.ts                           # external staging and validated package emission
 ```
 
 Everything under `plugins/superpowers/` except the fallback manifest template is

package/dist/adapter.js

@@ -197,11 +197,8 @@ async function fileExists(path) {
         return false;
     }
 }
-async function runBuild(argv, root, env, log) {
-    const flags = parseFlags(argv, BUILD_FLAGS);
-    const upstreamRoot = flags["--upstream-root"];
-    const candidateRoot = flags["--candidate-root"];
-    const fallbackManifest = flags["--fallback-manifest"];
+async function runBuild(input, env, log) {
+    const { upstreamRoot, candidateRoot, fallbackManifest } = input;
     if (!isAbsolute(upstreamRoot)) {
         fail("invalid-arguments", "--upstream-root must be an absolute path");
     }
@@ -276,7 +273,7 @@ async function runBuild(argv, root, env, log) {
             }
             let overlaid;
             try {
-                overlaid = applyManifestOverlay(source, flags["--manager-version"], candidateManifest);
+                overlaid = applyManifestOverlay(source, input.managerVersion, candidateManifest);
             }
             catch (cause) {
                 // applyManifestOverlay's own messages already name the manifest
@@ -321,13 +318,13 @@ async function runBuild(argv, root, env, log) {
             // on the adapter's surface.
             const splitValues = [
                 { value: candidateRoot, name: "--plugin-root" },
-                { value: flags["--requested-ref"], name: "--requested-ref" },
-                { value: flags["--resolved-ref"], name: "--resolved-ref" },
-                { value: flags["--commit"], name: "--commit" },
-                { value: flags["--manager-version"], name: "--manager-version" },
+                { value: input.requestedRef, name: "--requested-ref" },
+                { value: input.resolvedRef, name: "--resolved-ref" },
+                { value: input.commit, name: "--commit" },
+                { value: input.managerVersion, name: "--manager-version" },
                 { value: manifestSource, name: "--manifest-source" },
                 {
-                    value: flags["--upstream-manifest-version"],
+                    value: input.upstreamManifestVersion,
                     name: "--upstream-manifest-version",
                 },
             ];
@@ -347,12 +344,12 @@ async function runBuild(argv, root, env, log) {
                 errors = await validateGeneratedPlugin({
                     pluginRoot: candidateRoot,
                     source: upstreamSource,
-                    requestedRef: flags["--requested-ref"],
-                    resolvedRef: flags["--resolved-ref"],
-                    commit: flags["--commit"],
-                    manifestVersion: flags["--manager-version"],
+                    requestedRef: input.requestedRef,
+                    resolvedRef: input.resolvedRef,
+                    commit: input.commit,
+                    manifestVersion: input.managerVersion,
                     manifestSource,
-                    upstreamManifestVersion: flags["--upstream-manifest-version"],
+                    upstreamManifestVersion: input.upstreamManifestVersion,
                 });
             }
             catch {
@@ -377,9 +374,7 @@ async function runBuild(argv, root, env, log) {
         throw cause;
     }
 }
-async function runInstall(argv, env, log) {
-    const flags = parseFlags(argv, ["--package-root"]);
-    const packageRoot = flags["--package-root"];
+async function runInstall(packageRoot, env, log) {
     if (!isAbsolute(packageRoot)) {
         fail("invalid-arguments", "--package-root must be an absolute path");
     }
@@ -453,23 +448,15 @@ async function runInstall(argv, env, log) {
         throw cause;
     }
 }
-async function runUninstall(argv, env, log) {
-    const flags = parseFlags(argv, ["--plugin-present", "--marketplace-present"]);
-    const pluginPresent = flags["--plugin-present"];
-    const marketplacePresent = flags["--marketplace-present"];
-    if (pluginPresent !== "true" && pluginPresent !== "false") {
-        fail("invalid-arguments", "--plugin-present must be true or false");
-    }
-    if (marketplacePresent !== "true" && marketplacePresent !== "false") {
-        fail("invalid-arguments", "--marketplace-present must be true or false");
-    }
+async function runUninstall(input, env, log) {
+    const { pluginPresent, marketplacePresent } = input;
     const codexBin = env.SUPERPOWERS_CODEX || "codex";
     await requireCodex(codexBin, env);
     let entered = false;
     try {
         return await withWorkspace(tmpdir(), "superpowers-manager.adapter-uninstall.", async () => {
             entered = true;
-            if (pluginPresent === "true") {
+            if (pluginPresent) {
                 const result = await mutationCommand(log, codexBin, ["plugin", "remove", PLUGIN_ID], env);
                 if (commandFailed(result)) {
                     fail("uninstall-failed", `codex plugin remove failed for ${PLUGIN_ID}`);
@@ -479,7 +466,7 @@ async function runUninstall(argv, env, log) {
             else {
                 log.appendText("stdout", "plugin not installed; skipping");
             }
-            if (marketplacePresent === "true") {
+            if (marketplacePresent) {
                 const result = await mutationCommand(log, codexBin, ["plugin", "marketplace", "remove", MARKETPLACE_NAME], env);
                 if (commandFailed(result)) {
                     fail("uninstall-failed", `codex plugin marketplace remove failed for ${MARKETPLACE_NAME}`);
@@ -499,9 +486,7 @@ async function runUninstall(argv, env, log) {
         throw cause;
     }
 }
-async function runInspect(argv, env, log) {
-    const flags = parseFlags(argv, ["--view"]);
-    const view = flags["--view"];
+async function runInspect(view, env, log) {
     if (view === "update-control") {
         return { view: "update-control", update_control: "managed" };
     }
@@ -610,39 +595,95 @@ async function runInspect(argv, env, log) {
             throw cause;
         }
     }
-    fail("invalid-arguments", `unsupported inspect view: ${view}`);
+    const unsupportedView = view;
+    fail("invalid-arguments", `unsupported inspect view: ${unsupportedView}`);
+}
+async function runCodexOperation(operation, context, execute) {
+    const env = { ...process.env, ...context.env };
+    const log = new AdapterMessageLog();
+    try {
+        const result = await execute(env, log);
+        return successResult(operation, result, log.snapshot());
+    }
+    catch (cause) {
+        if (cause instanceof AdapterFailure) {
+            return failureResult(operation, cause.code, cause.message, cause.hints, log.snapshot());
+        }
+        throw cause;
+    }
+}
+export function codexBuild(input, context) {
+    return runCodexOperation("build", context, (env, log) => runBuild(input, env, log));
+}
+export function codexInstall(packageRoot, context) {
+    return runCodexOperation("install", context, (env, log) => runInstall(packageRoot, env, log));
+}
+export function codexRemove(input, context) {
+    return runCodexOperation("uninstall", context, (env, log) => runUninstall(input, env, log));
+}
+export function codexInspect(view, context) {
+    return runCodexOperation("inspect", context, (env, log) => runInspect(view, env, log));
 }
 export async function runAdapter(argv, context) {
     const rawOperation = argv[0];
     const operation = rawOperation || "adapter";
     const args = argv.slice(1);
-    const env = { ...process.env, ...context.env };
-    const log = new AdapterMessageLog();
     try {
-        let result;
         if (rawOperation === undefined || rawOperation.length === 0) {
             fail("invalid-arguments", "missing adapter operation");
         }
         else if (operation === "build") {
-            result = await runBuild(args, context.root, env, log);
+            const flags = parseFlags(args, BUILD_FLAGS);
+            return codexBuild({
+                upstreamRoot: flags["--upstream-root"],
+                candidateRoot: flags["--candidate-root"],
+                requestedRef: flags["--requested-ref"],
+                resolvedRef: flags["--resolved-ref"],
+                commit: flags["--commit"],
+                managerVersion: flags["--manager-version"],
+                upstreamManifestVersion: flags["--upstream-manifest-version"],
+                fallbackManifest: flags["--fallback-manifest"],
+            }, context);
         }
         else if (operation === "install") {
-            result = await runInstall(args, env, log);
+            const flags = parseFlags(args, ["--package-root"]);
+            return codexInstall(flags["--package-root"], context);
         }
         else if (operation === "uninstall") {
-            result = await runUninstall(args, env, log);
+            const flags = parseFlags(args, [
+                "--plugin-present",
+                "--marketplace-present",
+            ]);
+            const pluginPresent = flags["--plugin-present"];
+            const marketplacePresent = flags["--marketplace-present"];
+            if (pluginPresent !== "true" && pluginPresent !== "false") {
+                fail("invalid-arguments", "--plugin-present must be true or false");
+            }
+            if (marketplacePresent !== "true" && marketplacePresent !== "false") {
+                fail("invalid-arguments", "--marketplace-present must be true or false");
+            }
+            return codexRemove({
+                pluginPresent: pluginPresent === "true",
+                marketplacePresent: marketplacePresent === "true",
+            }, context);
         }
         else if (operation === "inspect") {
-            result = await runInspect(args, env, log);
+            const flags = parseFlags(args, ["--view"]);
+            const view = flags["--view"];
+            if (view !== "ownership" &&
+                view !== "update-control" &&
+                view !== "fingerprint") {
+                fail("invalid-arguments", `unsupported inspect view: ${view}`);
+            }
+            return codexInspect(view, context);
         }
         else {
             fail("unsupported-operation", `unsupported adapter operation: ${operation}`);
         }
-        return successResult(operation, result, log.snapshot());
     }
     catch (cause) {
         if (cause instanceof AdapterFailure) {
-            return failureResult(operation, cause.code, cause.message, cause.hints, log.snapshot());
+            return failureResult(operation, cause.code, cause.message, cause.hints, []);
         }
         throw cause;
     }