superpowers-manager 0.3.0 → 0.4.0

package/dist/commands/prepare.js

@@ -1,39 +1,14 @@
-import { cp, mkdir, rm, stat } from "node:fs/promises";
+import { mkdir, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { atomicReplaceDir } from "../atomic.js";
 import { oneLine } from "../cli-arguments.js";
 import { computeEffectiveSelection } from "../effective-selection.js";
 import { runGit } from "../git.js";
-import { readManifest } from "../hooks.js";
-import { writeProvenance } from "../provenance.js";
 import { SafetyError } from "../safety-error.js";
-import { manifestVersionForRef } from "../upstream-version.js";
 import { fetchExactCommit, gitSafeSource } from "../upstream.js";
 import { BOUNDED_EXECUTABLE, UNBOUNDED_LEGACY, launchFailureMessage, resolveValidator, runValidator, displayPath, } from "../validator.js";
 import { withWorkspace, workspaceRemovalFailure } from "../workspace.js";
 import { replayOutcome } from "./probe.js";
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:64-67::spw_require_upstream_path "$cache/skills`, via spw_require_upstream_path. Order is the shell's;
-// the first miss wins.
-const REQUIRED_UPSTREAM = [
-    { path: "skills", label: "skills/" },
-    { path: "LICENSE", label: "LICENSE" },
-    { path: "README.md", label: "README.md" },
-    { path: "CODE_OF_CONDUCT.md", label: "CODE_OF_CONDUCT.md" },
-];
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:73-77::spw_copy_path_if_present "$cache/skills`. Same names on both sides.
-const COPY_PATHS = [
-    "skills",
-    "assets",
-    "LICENSE",
-    "README.md",
-    "CODE_OF_CONDUCT.md",
-];
-const RESOLUTION_KINDS = [
-    "latest-release",
-    "tag",
-    "ref",
-    "raw-commit",
-];
 // 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
@@ -41,28 +16,10 @@ const RESOLUTION_KINDS = [
 function prepareError(message, cause) {
     return new SafetyError("prepare", message, { cause });
 }
-// `[ -e ]` — follows symlinks, so a dangling link is absent to the shell too.
-// Two call sites, each mirroring a distinct `-e` in the shell: the
-// REQUIRED_UPSTREAM loop
-// (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/common.sh:53-59::spw_require_upstream_path`
-// — e.g. skills/ is a directory, not a regular file) and copyPathIfPresent's
-// guard (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/common.sh:44-51::spw_copy_path_if_present`). The `.git`
-// check below is NOT a third site: it needs `-d` (F1), not `-e`, and uses
-// directoryExists instead.
-async function pathExists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// `[ -f ]` — regular file. `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:42::missing`, :80, and :108 all use -f, and
+// `[ -f ]` — regular file. `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:108::[ -f "$additional_validator` uses -f, and
 // tests/baseline/cli-parity.test.js's "CLI-ENV-MANIFEST-TEMPLATE-01 fallback
-// template bytes and non-file rejection" asserts a DIRECTORY passed as
-// SUPERPOWERS_MANIFEST_TEMPLATE is rejected before any adapter build. A
-// stat-only predicate would accept it.
+// template bytes and non-file rejection" also covers the separately extracted
+// fallback check.
 async function regularFileExists(path) {
     try {
         return (await stat(path)).isFile();
@@ -84,8 +41,8 @@ async function directoryExists(path) {
         return false;
     }
 }
-// mkdir, cp, and rm throw raw ErrnoExceptions. Every prepare-owned call goes
-// through here so the message on the stream is this module's, not Node's.
+// mkdir throws raw ErrnoExceptions. Every command-owned call goes through here
+// so the message on the stream is this module's, not Node's.
 async function owned(message, fn) {
     try {
         return await fn();
@@ -94,50 +51,6 @@ async function owned(message, fn) {
         throw prepareError(message, cause);
     }
 }
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/common.sh:44-51::spw_copy_path_if_present`.
-// `cp -R` copies symlinks AS symlinks;
-// fs.cp's default rewrites relative link targets against the destination,
-// which would change what the adapter's containment checks see.
-async function copyPathIfPresent(source, destination) {
-    if (!(await pathExists(source)))
-        return;
-    await owned(`cannot clear candidate path: ${destination}`, () => rm(destination, { recursive: true, force: true }));
-    await owned(`cannot copy upstream path into candidate: ${source}`, () => cp(source, destination, { recursive: true, verbatimSymlinks: true }));
-}
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:17-24::case "$cache_parent`. Only cache_parent and plugin_root are resolved against
-// the invocation cwd; manifest_template (:14) is not.
-function resolveFromCwd(value, cwd) {
-    return isAbsolute(value) ? value : resolve(cwd, value);
-}
-// readManifest (`src/hooks.ts:113::readManifest`) owns the read and the parse completely: byte
-// read so invalid UTF-8 is rejected rather than replaced, cause dropped, three
-// hand-written messages naming the path, object check included. Its
-// diagnostics are pinned by
-// `tests/unit/hooks.test.js:108::void test("readManifest diagnostics`. This wrapper adds only
-// the `version` type check.
-export async function readUpstreamManifestVersion(path) {
-    const manifest = await readManifest(path);
-    const value = manifest.version;
-    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/provenance.sh:56-62::for part in dotted_key.split`
-    // — absent key and JSON null both yield "".
-    if (value === undefined || value === null)
-        return "";
-    if (typeof value !== "string") {
-        // The shell stringified any other type through Python's print()
-        // (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/provenance.sh:62::print(value`), so `"version": 6` became "6" and flowed into both the
-        // provenance record and --upstream-manifest-version. Fail closed instead.
-        // Spec divergence 7.
-        throw prepareError(`upstream manifest version is not a string: ${path}`);
-    }
-    return value;
-}
-function asResolutionKind(value) {
-    for (const kind of RESOLUTION_KINDS) {
-        if (kind === value)
-            return kind;
-    }
-    throw prepareError(`unknown upstream resolution kind: ${value}`);
-}
 // Each stream's marker goes to that stream's own destination, so a reader of either
 // sees its own truncation and neither is silently short.
 function withTruncationMarker(captured, stream) {
@@ -167,16 +80,38 @@ function disclosureLine(resolution) {
     return `[superpowers-manager: running external validator ${configured}${via} -> ${displayPath(resolution.resolved)}]\n`;
 }
 const NO_VALIDATOR_OUTPUT = { stdout: "", stderr: "" };
+function validStagingLeaf(value) {
+    return (value.length > 0 &&
+        value !== "." &&
+        value !== ".." &&
+        !value.includes("/") &&
+        !value.includes("\\"));
+}
 async function gatherPrepare(ctx) {
     const env = ctx.env;
     // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:16::invocation_root=` — captured before the two case statements below.
     // getcwd(3) returns the physical path, so this matches `pwd -P` without a
     // realpath call.
     const cwd = process.cwd();
-    const cacheParent = resolveFromCwd(env.SUPERPOWERS_CACHE_DIR || join(ctx.root, ".cache", "upstream"), cwd);
-    const pluginRoot = resolveFromCwd(env.SUPERPOWERS_PLUGIN_ROOT || join(ctx.root, "plugins", "superpowers"), cwd);
-    const manifestTemplate = env.SUPERPOWERS_MANIFEST_TEMPLATE ||
-        join(ctx.root, "plugins", "superpowers", ".codex-plugin", "plugin.template.json");
+    const configuredCache = env.SUPERPOWERS_CACHE_DIR || join(ctx.root, ".cache", "upstream");
+    const cacheParent = isAbsolute(configuredCache)
+        ? configuredCache
+        : resolve(cwd, configuredCache);
+    const adapterContext = { root: ctx.root, env };
+    let location;
+    try {
+        location = ctx.adapter.preparationLocation(adapterContext);
+    }
+    catch (cause) {
+        throw prepareError("cannot determine preparation location", cause);
+    }
+    if (!isAbsolute(location.destinationRoot)) {
+        throw prepareError("adapter returned a non-absolute preparation destination");
+    }
+    if (!validStagingLeaf(location.stagingLeaf)) {
+        throw prepareError("adapter returned an invalid preparation staging leaf");
+    }
+    const pluginRoot = location.destinationRoot;
     const additionalValidator = env.SUPERPOWERS_VALIDATOR || "";
     const executableValidator = env.SUPERPOWERS_VALIDATOR_EXECUTABLE || "";
     const cache = join(cacheParent, "superpowers");
@@ -184,17 +119,30 @@ async function gatherPrepare(ctx) {
     await owned(`cannot create directory: ${tmpParent}`, () => mkdir(tmpParent, { recursive: true }));
     let cleanupWarning = null;
     const outcome = await withWorkspace(tmpParent, ".superpowers.prepare.", async (workspace) => {
+        const outcomes = [];
         const failed = (message) => ({
             kind: "failed",
-            outcomes: [],
+            outcomes,
             validator: NO_VALIDATOR_OUTPUT,
             message,
         });
-        const candidate = join(workspace, "superpowers");
+        const candidate = join(workspace, location.stagingLeaf);
         const selection = await computeEffectiveSelection(ctx.root, env);
-        // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:42::missing` — `[ -f ]`.
-        if (!(await regularFileExists(manifestTemplate))) {
-            return failed(`missing fallback manifest template: ${manifestTemplate}`);
+        let prefetch;
+        try {
+            prefetch =
+                await ctx.adapter.validatePreparationBeforeFetch(adapterContext);
+        }
+        catch {
+            return failed(ctx.adapter.presentation.callFailure("prepare", adapterContext)
+                .unexpected);
+        }
+        outcomes.push(prefetch.outcome);
+        if (!prefetch.outcome.ok)
+            return failed(null);
+        if (prefetch.status !== 0) {
+            return failed(ctx.adapter.presentation.callFailure("prepare", adapterContext)
+                .invalidStatus);
         }
         await owned(`cannot create directory: ${cacheParent}`, () => mkdir(cacheParent, { recursive: true }));
         if (selection.selectionMode === "pinned") {
@@ -237,86 +185,31 @@ async function gatherPrepare(ctx) {
         if (checkedOut.status !== 0) {
             return failed(`cannot check out upstream commit: ${selection.desiredCommit}`);
         }
-        for (const required of REQUIRED_UPSTREAM) {
-            // spw_require_upstream_path is `[ -e ]`, not `[ -f ]`: skills/ is a
-            // directory.
-            if (!(await pathExists(join(cache, required.path)))) {
-                return failed(`required upstream path missing: ${required.label}`);
-            }
-        }
-        await owned(`cannot clear candidate root: ${candidate}`, () => rm(candidate, { recursive: true, force: true }));
-        await owned(`cannot create candidate root: ${candidate}`, () => mkdir(join(candidate, ".codex-plugin"), { recursive: true }));
-        for (const name of COPY_PATHS) {
-            await copyPathIfPresent(join(cache, name), join(candidate, name));
-        }
-        const upstreamManifest = join(cache, ".codex-plugin", "plugin.json");
-        let upstreamManifestVersion = "";
-        // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/prepare:80::if [ -f` — `[ -f ]`.
-        if (await regularFileExists(upstreamManifest)) {
-            upstreamManifestVersion =
-                await readUpstreamManifestVersion(upstreamManifest);
-        }
-        await writeProvenance(join(candidate, ".superpowers-upstream.json"), {
-            source: selection.effectiveSource,
-            requested_ref: selection.requestedRef,
-            resolved_ref: selection.resolvedRef,
-            commit: selection.desiredCommit,
-            upstream_manifest_version: upstreamManifestVersion,
-        });
-        const managerVersion = manifestVersionForRef({
-            requestedRef: selection.requestedRef,
-            resolutionKind: asResolutionKind(selection.resolutionKind),
-            resolvedRef: selection.resolvedRef,
-            commit: selection.desiredCommit,
-        });
-        let built;
+        let prepared;
         try {
-            built = await ctx.adapter([
-                "build",
-                "--upstream-root",
-                cache,
-                "--candidate-root",
-                candidate,
-                "--requested-ref",
-                selection.requestedRef,
-                "--resolved-ref",
-                selection.resolvedRef,
-                "--commit",
-                selection.desiredCommit,
-                "--manager-version",
-                managerVersion,
-                "--upstream-manifest-version",
-                upstreamManifestVersion,
-                "--fallback-manifest",
-                manifestTemplate,
-            ], { root: ctx.root, env });
+            prepared = await ctx.adapter.prepareCandidate({
+                upstreamRoot: cache,
+                workspaceRoot: workspace,
+                candidateRoot: candidate,
+                selection,
+            }, adapterContext);
         }
         catch {
-            // ctx.adapter reports CONTROLLED failures by return value
-            // (`src/adapter-result.ts:32-35::export interface AdapterResult`) but still THROWS for a
-            // non-AdapterFailure cause (runAdapter's closing `throw cause`,
-            // src/adapter.ts). That cause is by construction the one failure
-            // src/adapter.ts declined to own, so its text must never reach
-            // ctx.stderr. Caught here rather than in runPrepare's outer catch,
-            // the same treatment
-            // `src/commands/probe.ts:205-228::It does still THROW for a non-AdapterFailure cause`
-            // gives it.
-            return failed("cannot build the generated plugin candidate");
+            return failed(ctx.adapter.presentation.callFailure("prepare", adapterContext)
+                .unexpected);
         }
-        const outcomes = [built.outcome];
-        if (built.status !== 0 || !built.outcome.ok) {
-            return {
-                kind: "failed",
-                outcomes,
-                validator: NO_VALIDATOR_OUTPUT,
-                // replayOutcome emits the adapter's own error and hints; a second
-                // line here would duplicate them. The `ok && status !== 0`
-                // combination cannot arise from successResult/failureResult, so it
-                // gets its own hand-written message rather than a silent replay.
-                message: built.outcome.ok
-                    ? "adapter reported failure without an error outcome"
-                    : null,
-            };
+        outcomes.push(prepared.outcome);
+        if (prepared.status !== 0 || !prepared.outcome.ok) {
+            return failed(prepared.outcome.ok
+                ? ctx.adapter.presentation.callFailure("prepare", adapterContext)
+                    .invalidStatus
+                : null);
+        }
+        if (prepared.outcome.result.root !== candidate) {
+            return failed("adapter returned an unexpected preparation root");
+        }
+        if (prepared.outcome.result.commit !== selection.desiredCommit) {
+            return failed("adapter returned an unexpected preparation commit");
         }
         let validator = NO_VALIDATOR_OUTPUT;
         if (additionalValidator.length > 0) {
@@ -443,7 +336,7 @@ export async function runPrepare(argv, ctx) {
         // 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.js:108::void test("readManifest diagnostics` as carrying no reader vocabulary or
+        // `tests/unit/hooks.test.ts:95::void test("readManifest diagnostics` as carrying no reader vocabulary or
         // errno; and SafetyErrors from gitSafeSource, writeProvenance, and
         // withWorkspace.
         //
@@ -454,7 +347,7 @@ export async function runPrepare(argv, ctx) {
         //      This is the DEFAULT invocation -- plain `prepare`, `track-latest`,
         //      and any non-40-hex SUPERPOWERS_REF -- not an exotic corner. Pinned
         //      by
-        //      `tests/unit/upstream.test.js:460-469::void test("resolveRef reports a query failure for latest`,
+        //      `tests/unit/upstream.test.ts:453-462::void test("resolveRef reports a query failure for latest`,
         //      :471-481, and :483-501.
         //   2. fetchExactCommit splices the same combined stdout+stderr into its
         //      own text on the PINNED path (both of its own splice sites in
@@ -519,7 +412,7 @@ export async function runPrepare(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:503-510::if (cleanupWarning`.
+        // `src/commands/install.ts:395-403::if (cleanupWarning`.
         ctx.stderr.write(`error: ${cleanupWarning}\n`);
         return 1;
     }

package/dist/commands/probe.js

@@ -1,115 +1,7 @@
 import { assertFailureWritable, writeAdapterFailure, } from "../adapter-result.js";
 import { oneLine } from "../cli-arguments.js";
 import { computeEffectiveSelection } from "../effective-selection.js";
-import { generatedCommitOrEmpty } from "../provenance.js";
-import { displaySource } from "../selection.js";
-import { statusForCommits } from "../status.js";
 export const PROBE_USAGE = "error: usage: superpowers-manager probe [--porcelain]\n";
-// One ordered table drives both formats, so the porcelain key order
-// (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:43-59::printf 'requested_ref`) and the human label order (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:61-77::printf 'requested ref`) cannot
-// drift apart. Two parallel lists could each stay self-consistent while
-// disagreeing with one another.
-function fields(f) {
-    return [
-        { key: "requested_ref", label: "requested ref", value: f.requestedRef },
-        { key: "resolved_ref", label: "resolved ref", value: f.resolvedRef },
-        { key: "desired_commit", label: "desired commit", value: f.desiredCommit },
-        {
-            key: "generated_commit",
-            label: "generated plugin commit",
-            value: f.generatedCommit,
-            absent: "not present",
-        },
-        {
-            key: "installed_commit",
-            label: "installed manager commit or fingerprint",
-            value: f.installedCommit,
-            absent: "not detected",
-        },
-        {
-            key: "identity_state",
-            label: "Codex identity state",
-            value: f.identityState,
-        },
-        { key: "status", label: "status", value: f.status },
-        {
-            key: "selection_origin",
-            label: "selection origin",
-            value: f.selectionOrigin,
-        },
-        { key: "selection_mode", label: "selection mode", value: f.selectionMode },
-        {
-            key: "upstream_source_origin",
-            label: "upstream source origin",
-            value: f.upstreamSourceOrigin,
-        },
-        {
-            key: "effective_source",
-            label: "effective source",
-            value: f.effectiveSource,
-        },
-        { key: "saved_mode", label: "saved mode", value: f.savedMode },
-        { key: "saved_source", label: "saved source", value: f.savedSource },
-        {
-            key: "saved_requested_ref",
-            label: "saved requested ref",
-            value: f.savedRequestedRef,
-        },
-        {
-            key: "saved_resolved_ref",
-            label: "saved resolved ref",
-            value: f.savedResolvedRef,
-        },
-        { key: "saved_commit", label: "saved commit", value: f.savedCommit },
-        { key: "update_control", label: "update control", value: f.updateControl },
-    ];
-}
-// Derived from the same fields() table, so the key list a test asserts and
-// the key list formatPorcelain emits cannot be different lists. The facts
-// argument is irrelevant here — fields() is total over ProbeFacts and the
-// keys do not depend on the values.
-const NO_FACTS = {
-    requestedRef: "",
-    resolvedRef: "",
-    desiredCommit: "",
-    generatedCommit: "",
-    installedCommit: "",
-    identityState: "",
-    status: "",
-    selectionOrigin: "",
-    selectionMode: "",
-    upstreamSourceOrigin: "",
-    effectiveSource: "",
-    savedMode: "",
-    savedSource: "",
-    savedRequestedRef: "",
-    savedResolvedRef: "",
-    savedCommit: "",
-    updateControl: "",
-};
-export const PROBE_PORCELAIN_KEYS = fields(NO_FACTS).map((field) => field.key);
-export function formatPorcelain(f) {
-    return fields(f)
-        .map((field) => `${field.key}=${field.value}\n`)
-        .join("");
-}
-export function formatHuman(f) {
-    let text = fields(f)
-        .map((field) => {
-        const shown = field.value.length === 0 && field.absent !== undefined
-            ? field.absent
-            : field.value;
-        return `${field.label}: ${shown}\n`;
-    })
-        .join("");
-    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:78-81::if [ "$SPW_SELECTION_ORIGIN`.
-    if (f.selectionOrigin !== f.upstreamSourceOrigin) {
-        text +=
-            "warning: effective ref and source have mixed origins " +
-                `(ref: ${f.selectionOrigin}, source: ${f.upstreamSourceOrigin})\n`;
-    }
-    return text;
-}
 // Ports scripts/core/validate-adapter-response.py's replay (:235-238) and its
 // error/hint block (:269-272). The shell ran that validator on EVERY adapter
 // response, so adapter messages reached the operator on their declared streams
@@ -156,25 +48,13 @@ export function replayOutcome(outcome, ctx) {
 // adapter module: src/commands/prepare.ts and this module are the two the
 // injected double must observe, because install reaches the adapter through
 // gatherProbe and runPrepare. Spec §4.5.
-async function inspect(view, key, ctx) {
+async function inspect(call, unexpected, invalidStatus) {
     let result;
     try {
-        result = await ctx.adapter(["inspect", "--view", view], {
-            root: ctx.root,
-            env: ctx.env,
-        });
+        result = await call();
     }
     catch {
-        // Deliberately does NOT interpolate the cause. A rethrown non-
-        // AdapterFailure is by construction the one failure src/adapter.ts chose
-        // not to own: free-form text of unknown provenance, which AGENTS.md bars
-        // from this stream. `view` is a bounded token -- one of three literals
-        // this function is ever called with -- so naming the input is safe.
-        return {
-            ok: false,
-            outcome: null,
-            message: `cannot inspect Codex adapter state for view ${view}`,
-        };
+        return { ok: false, result: null, message: unexpected };
     }
     const outcome = result.outcome;
     if (result.status !== 0 || !outcome.ok) {
@@ -183,27 +63,11 @@ async function inspect(view, key, ctx) {
         // rather than falling through to a replay that would print nothing.
         return {
             ok: false,
-            outcome,
-            message: outcome.ok
-                ? `adapter reported a failure status for inspect --view ${view}`
-                : null,
-        };
-    }
-    const value = outcome.result?.[key];
-    // The Python reader printed the empty string for a JSON null
-    // (scripts/core/provenance.sh's spw_json_get), and `fingerprint` is null
-    // whenever no plugin version is active (`src/adapter.ts:820::fingerprint: null`).
-    if (value === null || value === undefined) {
-        return { ok: true, value: "", outcome };
-    }
-    if (typeof value !== "string") {
-        return {
-            ok: false,
-            outcome,
-            message: `adapter returned a non-string ${key} for inspect --view ${view}`,
+            result,
+            message: outcome.ok ? invalidStatus : null,
         };
     }
-    return { ok: true, value, outcome };
+    return { ok: true, result: { status: result.status, outcome } };
 }
 // Runs every step that can throw or fail closed, returning the outcome as
 // data. It performs no writes of its own, so nothing inside runProbe's try can
@@ -223,50 +87,50 @@ async function inspect(view, key, ctx) {
 export async function gatherProbe(ctx) {
     // Order mirrors `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:24-40::spw_compute_effective_selection` exactly.
     const selection = await computeEffectiveSelection(ctx.root, ctx.env);
-    const generatedCommit = await generatedCommitOrEmpty(ctx.root);
     const outcomes = [];
-    const collect = async (view, key) => {
-        const result = await inspect(view, key, ctx);
-        if (result.outcome !== null)
-            outcomes.push(result.outcome);
+    const adapterContext = { root: ctx.root, env: ctx.env };
+    const collect = async (call, unexpected, invalidStatus) => {
+        const result = await inspect(call, unexpected, invalidStatus);
+        if (result.result !== null)
+            outcomes.push(result.result.outcome);
         return result;
     };
-    const fingerprint = await collect("fingerprint", "fingerprint");
-    if (!fingerprint.ok) {
-        return { status: 1, outcomes, message: fingerprint.message };
+    const prepared = await collect(() => ctx.adapter.inspectPrepared(selection, adapterContext), "cannot inspect prepared harness state", "adapter reported a failure status for prepared harness inspection");
+    if (!prepared.ok) {
+        return { status: 1, outcomes, message: prepared.message };
+    }
+    const failure = (site) => ctx.adapter.presentation.callFailure(site, adapterContext);
+    const installedFailure = failure("probe-installed");
+    const installed = await collect(() => ctx.adapter.inspectInstalled(selection, adapterContext), installedFailure.unexpected, installedFailure.invalidStatus);
+    if (!installed.ok) {
+        return { status: 1, outcomes, message: installed.message };
     }
-    const ownership = await collect("ownership", "identity_state");
+    const ownershipFailure = failure("probe-ownership");
+    const ownership = await collect(() => ctx.adapter.inspectOwnership(adapterContext), ownershipFailure.unexpected, ownershipFailure.invalidStatus);
     if (!ownership.ok) {
         return { status: 1, outcomes, message: ownership.message };
     }
-    const updateControl = await collect("update-control", "update_control");
-    if (!updateControl.ok) {
-        return { status: 1, outcomes, message: updateControl.message };
+    const controlFailure = failure("probe-control");
+    const control = await collect(() => ctx.adapter.inspectUpdateControl(adapterContext), controlFailure.unexpected, controlFailure.invalidStatus);
+    if (!control.ok) {
+        return { status: 1, outcomes, message: control.message };
     }
-    const saved = selection.saved;
+    const preparedState = prepared.result.outcome.result;
+    const installedState = installed.result.outcome.result;
     return {
         status: 0,
         outcomes,
         facts: {
-            requestedRef: selection.requestedRef,
-            resolvedRef: selection.resolvedRef,
-            desiredCommit: selection.desiredCommit,
-            generatedCommit,
-            installedCommit: fingerprint.value,
-            identityState: ownership.value,
-            status: statusForCommits(selection.desiredCommit, generatedCommit, fingerprint.value),
-            selectionOrigin: selection.selectionOrigin,
-            selectionMode: selection.selectionMode,
-            upstreamSourceOrigin: selection.upstreamSourceOrigin,
-            effectiveSource: displaySource(selection.effectiveSource),
-            savedMode: saved.saved_mode,
-            // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:26-30::if [ -`: an absent saved source stays empty rather than
-            // being run through displaySource, which would render <redacted-source>.
-            savedSource: saved.saved_source.length > 0 ? displaySource(saved.saved_source) : "",
-            savedRequestedRef: saved.saved_requested_ref,
-            savedResolvedRef: saved.saved_resolved_ref,
-            savedCommit: saved.saved_commit,
-            updateControl: updateControl.value,
+            selection,
+            prepared: preparedState,
+            installed: installedState,
+            ownership: ownership.result.outcome.result,
+            control: control.result.outcome.result,
+            status: preparedState.kind !== "current"
+                ? "needs prepare"
+                : installedState.kind !== "current"
+                    ? "needs install"
+                    : "current",
         },
     };
 }
@@ -319,7 +183,7 @@ export async function runProbe(argv, ctx) {
         //      every unpinned run does: resolveRef's COMMIT_INPUT_RE branch returns
         //      before any runGit call, so a 40-hex requested ref splices nothing.
         //      Pinned by
-        //      `tests/unit/upstream.test.js:460::void test("resolveRef reports a query failure for latest`,
+        //      `tests/unit/upstream.test.ts:453::void test("resolveRef reports a query failure for latest`,
         //      :471, and :483.
         //   2. The
         //      `src/selection-store.ts:120-124::cause.module === "selection") {`
@@ -387,6 +251,7 @@ export async function runProbe(argv, ctx) {
         }
         return 1;
     }
-    ctx.stdout.write(porcelain ? formatPorcelain(outcome.facts) : formatHuman(outcome.facts));
+    const rendered = ctx.adapter.presentation.renderProbe(outcome.facts);
+    ctx.stdout.write(porcelain ? rendered.porcelain : rendered.human);
     return 0;
 }