superpowers-manager 0.9.1 → 0.10.1

package/README.md

@@ -1,6 +1,6 @@
 # Superpowers Manager
 
-Install [`obra/superpowers`](https://github.com/obra/superpowers) directly from upstream for Codex, the Pi coding agent, OpenCode, and Claude Code. 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.
+Install [`obra/superpowers`](https://github.com/obra/superpowers) directly from upstream for Codex, the Pi coding agent, OpenCode, Claude Code, and Hermes 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.
 
@@ -21,7 +21,7 @@ npx superpowers-manager pin v6.1.1
 npx superpowers-manager install --harness codex
 ```
 
-Use `--harness pi` for Pi, `--harness opencode` for OpenCode, or `--harness claude-code` for Claude Code. The pin is shared by all harnesses, 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.
+Use `--harness pi` for Pi, `--harness opencode` for OpenCode, `--harness claude-code` for Claude Code, or `--harness hermes` for Hermes Agent. The pin is shared by all harnesses, 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:
 
@@ -42,7 +42,7 @@ See [version selection](https://github.com/j7an/superpowers-manager/blob/main/do
 
 ## Start with your agent
 
-The four harnesses share upstream selection, while each has independent prepared and installed state. Omitting `--harness` selects Codex.
+The five harnesses share upstream selection, while each has independent prepared and installed state. Omitting `--harness` selects Codex.
 
 ### Codex
 
@@ -97,6 +97,18 @@ Restart Claude Code or run `/reload-plugins` after an install, activating update
 or removal. See the [Claude Code reference](https://github.com/j7an/superpowers-manager/blob/main/docs/claude-code.md)
 for conflicts, hooks, and recovery.
 
+### Hermes Agent
+
+```sh
+npx superpowers-manager install --harness hermes
+npx superpowers-manager probe --harness hermes
+npx superpowers-manager update --harness hermes
+```
+
+Restart Hermes sessions after an install, activating update, or removal. See
+the [Hermes Agent reference](https://github.com/j7an/superpowers-manager/blob/main/docs/hermes.md)
+for plugin layout, compatibility, route switching, and recovery.
+
 To remove a Manager-owned installation, choose one harness explicitly:
 
 ### Uninstall Codex
@@ -123,24 +135,31 @@ npx superpowers-manager uninstall --harness opencode
 npx superpowers-manager uninstall --harness claude-code
 ```
 
+### Uninstall Hermes Agent
+
+```sh
+npx superpowers-manager uninstall --harness hermes
+```
+
 The manager never removes another Superpowers provider. See the [ownership guidance](https://github.com/j7an/superpowers-manager/blob/main/docs/usage.md#provider-ownership) before switching providers.
 
 ## Shared selection and lifecycle
 
-The [selection commands above](#choose-what-you-run) save shared upstream intent. They do not activate Codex, Pi, OpenCode, or Claude Code; run the selected harness's `install` or `update` to apply that choice. `unpin` restores the packaged fallback policy.
+The [selection commands above](#choose-what-you-run) save shared upstream intent. They do not activate Codex, Pi, OpenCode, Claude Code, or Hermes Agent; run the selected harness's `install` or `update` to apply that choice. `unpin` restores the packaged fallback policy.
 
 See [targeted lifecycle commands](https://github.com/j7an/superpowers-manager/blob/main/docs/usage.md#targeted-lifecycle) for preparation, inspection, installation, updates, and removal.
 
-Use `--harness codex`, `--harness pi`, `--harness opencode`, or `--harness claude-code` with each targeted lifecycle command.
+Use `--harness codex`, `--harness pi`, `--harness opencode`, `--harness claude-code`, or `--harness hermes` with each targeted lifecycle command.
 
 ```text
 shared selection -> prepare / inspect / activate Codex
                  -> prepare / inspect / activate Pi
                  -> prepare / inspect / activate OpenCode
                  -> prepare / inspect / activate Claude Code
+                 -> prepare / inspect / activate Hermes Agent
 ```
 
-The [usage reference](https://github.com/j7an/superpowers-manager/blob/main/docs/usage.md) covers version selection, precedence, offline behavior, `prepare`, validators, and every lifecycle command. The harness references cover [Codex registration and hooks](https://github.com/j7an/superpowers-manager/blob/main/docs/codex.md), [Pi snapshots and recovery](https://github.com/j7an/superpowers-manager/blob/main/docs/pi.md), [OpenCode snapshots](https://github.com/j7an/superpowers-manager/blob/main/docs/opencode.md), and [Claude Code marketplace registration](https://github.com/j7an/superpowers-manager/blob/main/docs/claude-code.md).
+The [usage reference](https://github.com/j7an/superpowers-manager/blob/main/docs/usage.md) covers version selection, precedence, offline behavior, `prepare`, validators, and every lifecycle command. The harness references cover [Codex registration and hooks](https://github.com/j7an/superpowers-manager/blob/main/docs/codex.md), [Pi snapshots and recovery](https://github.com/j7an/superpowers-manager/blob/main/docs/pi.md), [OpenCode snapshots](https://github.com/j7an/superpowers-manager/blob/main/docs/opencode.md), [Claude Code marketplace registration](https://github.com/j7an/superpowers-manager/blob/main/docs/claude-code.md), and [Hermes Agent plugin support](https://github.com/j7an/superpowers-manager/blob/main/docs/hermes.md).
 
 ## Requirements and platforms
 
@@ -148,16 +167,16 @@ The installed package requires Node >=24. Native source, tests, and packaging to
 
 <!-- requirements:begin -->
 
-| Command        | git | Codex CLI (default) | Pi CLI (`--harness pi`) | OpenCode CLI (`--harness opencode`) | Claude Code CLI (`--harness claude-code`) |
-| -------------- | --- | ------------------- | ----------------------- | ----------------------------------- | ----------------------------------------- |
-| `pin`          | yes | no                  | no                      | no                                  | no                                        |
-| `track-latest` | no  | no                  | no                      | no                                  | no                                        |
-| `unpin`        | no  | no                  | no                      | no                                  | no                                        |
-| `prepare`      | yes | no                  | no                      | no                                  | no                                        |
-| `probe`        | yes | yes                 | no                      | no                                  | yes                                       |
-| `install`      | yes | yes                 | yes                     | yes                                 | yes                                       |
-| `update`       | yes | yes                 | yes                     | yes                                 | yes                                       |
-| `uninstall`    | no  | yes                 | yes                     | no                                  | yes                                       |
+| Command        | git | Codex CLI (default) | Pi CLI (`--harness pi`) | OpenCode CLI (`--harness opencode`) | Claude Code CLI (`--harness claude-code`) | Hermes Agent CLI (`--harness hermes`) |
+| -------------- | --- | ------------------- | ----------------------- | ----------------------------------- | ----------------------------------------- | ------------------------------------- |
+| `pin`          | yes | no                  | no                      | no                                  | no                                        | no                                    |
+| `track-latest` | no  | no                  | no                      | no                                  | no                                        | no                                    |
+| `unpin`        | no  | no                  | no                      | no                                  | no                                        | no                                    |
+| `prepare`      | yes | no                  | no                      | no                                  | no                                        | no                                    |
+| `probe`        | yes | yes                 | no                      | no                                  | yes                                       | no                                    |
+| `install`      | yes | yes                 | yes                     | yes                                 | yes                                       | yes                                   |
+| `update`       | yes | yes                 | yes                     | yes                                 | yes                                       | yes                                   |
+| `uninstall`    | no  | yes                 | yes                     | no                                  | yes                                       | yes                                   |
 
 <!-- requirements:end -->
 

package/dist/cli-arguments.js

@@ -23,7 +23,8 @@ export function extractHarnessOptions(command, argv) {
             if (value !== "codex" &&
                 value !== "pi" &&
                 value !== "opencode" &&
-                value !== "claude-code")
+                value !== "claude-code" &&
+                value !== "hermes")
                 throw new UsageError(`unknown harness: ${value}`);
             harness = value;
         }

package/dist/cli.js

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { extractHarnessOptions, oneLine, UsageError } from "./cli-arguments.js";
 import { codexHarness } from "./harnesses/codex/harness.js";
 import { claudeCodeHarness } from "./harnesses/claude-code/harness.js";
+import { hermesHarness } from "./harnesses/hermes/harness.js";
 import { piHarness } from "./harnesses/pi/harness.js";
 import { openCodeHarness } from "./harnesses/opencode/harness.js";
 import { createResourceCoordinator } from "./resource-lock.js";
@@ -214,7 +215,7 @@ function usage() {
         "  install --harness opencode [--allow-experimental]",
         "  update --harness opencode [--allow-experimental]",
         "  uninstall --harness opencode",
-        "  --harness=codex, --harness=pi, --harness=opencode, and --harness=claude-code are also accepted after the command.",
+        "  --harness=codex, --harness=pi, --harness=opencode, --harness=claude-code, and --harness=hermes are also accepted after the command.",
         "",
         "Environment overrides (used by in-process commands): SUPERPOWERS_REF,",
         "SUPERPOWERS_UPSTREAM_URL, SUPERPOWERS_CODEX, SUPERPOWERS_CACHE_DIR,",
@@ -222,7 +223,7 @@ function usage() {
         "SUPERPOWERS_PLUGIN_ROOT, SUPERPOWERS_MANIFEST_TEMPLATE,",
         "SUPERPOWERS_VALIDATOR_EXECUTABLE,",
         "SUPERPOWERS_INSTALLED_SEARCH_ROOT, SUPERPOWERS_INSTALL_REFRESH_MODE,",
-        "SUPERPOWERS_OPENCODE, SUPERPOWERS_CLAUDE_CODE, CLAUDE_CONFIG_DIR",
+        "SUPERPOWERS_OPENCODE, SUPERPOWERS_CLAUDE_CODE, CLAUDE_CONFIG_DIR, SUPERPOWERS_HERMES, HERMES_HOME",
         "",
         "SUPERPOWERS_VALIDATOR is removed; unset it and use",
         "SUPERPOWERS_VALIDATOR_EXECUTABLE with an executable validator.",
@@ -252,13 +253,15 @@ async function main() {
         console.error(usage());
         process.exit(2);
     }
-    const status = parsed.options.harness === "claude-code"
-        ? await dispatch(claudeCodeHarness, parsed, root)
-        : parsed.options.harness === "opencode"
-            ? await dispatch(openCodeHarness, parsed, root)
-            : parsed.options.harness === "pi"
-                ? await dispatch(piHarness, parsed, root)
-                : await dispatch(codexHarness, parsed, root);
+    const status = parsed.options.harness === "hermes"
+        ? await dispatch(hermesHarness, parsed, root)
+        : parsed.options.harness === "claude-code"
+            ? await dispatch(claudeCodeHarness, parsed, root)
+            : parsed.options.harness === "opencode"
+                ? await dispatch(openCodeHarness, parsed, root)
+                : parsed.options.harness === "pi"
+                    ? await dispatch(piHarness, parsed, root)
+                    : await dispatch(codexHarness, parsed, root);
     process.exit(status);
 }
 async function dispatch(adapter, parsed, root) {

package/dist/commands/adapter-call.js

@@ -15,17 +15,6 @@ export async function callAdapter(call, failure) {
         };
     return { ok: true, result: { status: result.status, outcome } };
 }
-// Preserve outcomes collected before gathering throws so command catches can
-// replay them before reporting the underlying failure.
-export class GatherFailure extends Error {
-    inner;
-    outcomes;
-    constructor(message, inner, outcomes) {
-        super(message);
-        this.inner = inner;
-        this.outcomes = outcomes;
-    }
-}
 export function writeOutput(output, ctx) {
     for (const line of output.stdout)
         ctx.stdout.write(`${line}\n`);

package/dist/commands/install.js

@@ -1,181 +1,162 @@
 import { tmpdir } from "node:os";
 import { oneLine } from "../cli-arguments.js";
 import { withWorkspaceReporting, } from "../workspace.js";
-import { GatherFailure, invoke, writeOutput } from "./adapter-call.js";
+import { invoke, writeOutput } from "./adapter-call.js";
 import { probeFacts, replayOutcome } from "./probe.js";
 import { runPrepare } from "./prepare.js";
 import { runWithMutation } from "./mutation.js";
 import { activationBlock } from "../harness-compatibility.js";
-// Collect outcomes without writing so output failures cannot be classified as
-// inspection failures. Replay collected outcomes after gathering completes.
-// The callback never throws: invoke() catches every ctx.adapter failure and
-// every predicate here is pure, so a post-success cleanup failure is the only
-// case withWorkspaceReporting's cleanupWarning has to carry.
-async function gatherInstallStages(ctx, selection, artifact) {
+// Collect outcomes into the caller's array without writing, so output failures
+// cannot be classified as inspection failures. The caller replays them after
+// gathering, including when gathering throws; a post-success cleanup failure
+// comes back as withWorkspaceReporting's cleanupWarning instead.
+async function gatherInstallStages(ctx, selection, artifact, outcomes) {
     const parent = ctx.env.TMPDIR ?? tmpdir();
-    const outcomes = [];
-    try {
-        return await withWorkspaceReporting(parent, "superpowers-manager.install.", async (workspace) => {
-            const env = { ...ctx.env, TMPDIR: workspace };
-            const failed = (message) => ({
-                kind: "failed",
-                outcomes,
-                message,
-            });
-            const adapterContext = { root: ctx.root, env };
-            // Stage 1: inspect ownership, re-checked even though gatherProbe just
-            // reported it. Mutation authority requires CURRENT, VALIDATED
-            // evidence -- a probe's answer is neither by the time this runs.
-            const ownershipFailure = ctx.adapter.presentation.callFailure("install-ownership", adapterContext);
-            const ownership = await invoke(() => ctx.adapter.inspectOwnership(adapterContext), ownershipFailure, outcomes);
-            if (!ownership.ok)
-                return failed(ownership.message);
-            const ownershipDecision = ownership.result.outcome.result.installEligibility;
-            if (ownershipDecision.kind === "blocked") {
+    return await withWorkspaceReporting(parent, "superpowers-manager.install.", async (workspace) => {
+        const env = { ...ctx.env, TMPDIR: workspace };
+        const failed = (message) => ({
+            kind: "failed",
+            message,
+        });
+        const adapterContext = { root: ctx.root, env };
+        // Stage 1: inspect ownership, re-checked even though gatherProbe just
+        // reported it. Mutation authority requires CURRENT, VALIDATED
+        // evidence -- a probe's answer is neither by the time this runs.
+        const ownershipFailure = ctx.adapter.presentation.callFailure("install-ownership", adapterContext);
+        const ownership = await invoke(() => ctx.adapter.inspectOwnership(adapterContext), ownershipFailure, outcomes);
+        if (!ownership.ok)
+            return failed(ownership.message);
+        const ownershipDecision = ownership.result.outcome.result.installEligibility;
+        if (ownershipDecision.kind === "blocked") {
+            return {
+                kind: "blocked",
+                output: ownershipDecision.output,
+            };
+        }
+        // Stage 2: inspect update-control, re-checked for the same reason.
+        const controlFailure = ctx.adapter.presentation.callFailure("install-control", adapterContext);
+        const control = await invoke(() => ctx.adapter.inspectUpdateControl(adapterContext), controlFailure, outcomes);
+        if (!control.ok)
+            return failed(control.message);
+        const mutationDecision = control.result.outcome.result.mutationEligibility;
+        if (mutationDecision.kind === "blocked") {
+            return {
+                kind: "blocked",
+                output: mutationDecision.output,
+            };
+        }
+        // Stage 3: the mutation itself. Nothing above may have issued this --
+        // that is the whole point of stages 1 and 2 running first.
+        const activationFailure = activationBlock(artifact.compatibility, ctx.options.allowExperimental);
+        if (activationFailure !== null)
+            return failed(activationFailure);
+        const installFailure = ctx.adapter.presentation.callFailure("install", adapterContext);
+        const install = await invoke(() => ctx.adapter.install(artifact, adapterContext), installFailure, outcomes);
+        if (!install.ok)
+            return failed(install.message);
+        let transaction;
+        try {
+            const candidate = install.result.outcome.result.transaction;
+            if (candidate !== undefined) {
+                if (candidate === null || typeof candidate !== "object")
+                    throw new Error("invalid transaction");
+                const finalize = candidate.finalize.bind(candidate);
+                const rollback = candidate.rollback.bind(candidate);
+                if (typeof finalize !== "function" || typeof rollback !== "function")
+                    throw new Error("invalid transaction");
+                transaction = { finalize, rollback };
+            }
+        }
+        catch {
+            return failed("invalid installation transaction receipt; preserve recovery material for manual resolution");
+        }
+        // Stage 4: inspect fingerprint, to verify the mutation actually took.
+        //
+        // Deliberately NOT short-circuited on `!inspected.ok`, unlike stages
+        // 1-3. `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/install:57::spw_verify_installed_fingerprint` handed the inspect result to
+        // spw_verify_installed_fingerprint whatever it contained, and that
+        // function's first guard, from
+        // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:91-94::spw_inspect_fingerprint`,
+        // is what turns a failed inspection into "error: installed manager
+        // fingerprint inspection failed after install."
+        // renderInstallVerification's failed-inspection arm
+        // (`src/harnesses/codex/presentation.ts:280::if (inspection.status !== 0 || !inspection.outcome.ok) {`)
+        // exists for this result-bearing path. Returning
+        // failed() instead reported the adapter's own generic diagnostic and
+        // dropped the post-install verification claim -- a mutation had
+        // already been issued at stage 3,
+        // so "the install could not be verified" is the contract, not "an
+        // adapter call failed". A ctx.adapter THROW has no result to render.
+        // A pending transaction still rolls back before reporting that failure.
+        const inspectionFailure = ctx.adapter.presentation.callFailure("post-install", adapterContext);
+        const inspected = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
+        const inspection = inspected.result;
+        const verified = inspection !== null &&
+            inspection.status === 0 &&
+            inspection.outcome.ok &&
+            inspection.outcome.result.kind === "current";
+        if (transaction !== undefined) {
+            const operation = verified ? "finalize" : "rollback";
+            const settlement = await invoke(() => (verified ? transaction.finalize() : transaction.rollback()), {
+                unexpected: `installation ${operation} did not complete; preserve recovery material for manual resolution`,
+                invalidStatus: `installation ${operation} returned an invalid result; preserve recovery material for manual resolution`,
+            }, outcomes, (value) => value === null);
+            if (!verified) {
+                const restored = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
+                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 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 : null;
                 return {
-                    kind: "blocked",
-                    outcomes,
-                    output: ownershipDecision.output,
+                    kind: "verified",
+                    status: 1,
+                    stdout: verificationOutput?.stdout ?? [],
+                    stderr: [
+                        ...(verificationOutput?.stderr ?? []),
+                        ...(inspectionMessage === null
+                            ? []
+                            : [`error: ${inspectionMessage}`]),
+                        ...(settlementMessage === null
+                            ? []
+                            : [`error: ${settlementMessage}`]),
+                        restoration,
+                    ],
                 };
             }
-            // Stage 2: inspect update-control, re-checked for the same reason.
-            const controlFailure = ctx.adapter.presentation.callFailure("install-control", adapterContext);
-            const control = await invoke(() => ctx.adapter.inspectUpdateControl(adapterContext), controlFailure, outcomes);
-            if (!control.ok)
-                return failed(control.message);
-            const mutationDecision = control.result.outcome.result.mutationEligibility;
-            if (mutationDecision.kind === "blocked") {
+            if (!settlement.ok) {
+                const actual = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
                 return {
-                    kind: "blocked",
-                    outcomes,
-                    output: mutationDecision.output,
+                    kind: "verified",
+                    status: 1,
+                    stdout: [],
+                    stderr: [
+                        "error: installation was verified, but transaction cleanup did not complete; preserve recovery material for manual resolution",
+                        actual.ok
+                            ? `installed state after failed finalization: ${actual.result.outcome.result.kind}; identity=${actual.result.outcome.result.observedIdentity}`
+                            : "installed state after failed finalization could not be inspected",
+                        ...(settlement.message === null
+                            ? []
+                            : [`error: ${settlement.message}`]),
+                    ],
                 };
             }
-            // Stage 3: the mutation itself. Nothing above may have issued this --
-            // that is the whole point of stages 1 and 2 running first.
-            const activationFailure = activationBlock(artifact.compatibility, ctx.options.allowExperimental);
-            if (activationFailure !== null)
-                return failed(activationFailure);
-            const installFailure = ctx.adapter.presentation.callFailure("install", adapterContext);
-            const install = await invoke(() => ctx.adapter.install(artifact, adapterContext), installFailure, outcomes);
-            if (!install.ok)
-                return failed(install.message);
-            let transaction;
-            try {
-                const candidate = install.result.outcome.result.transaction;
-                if (candidate !== undefined) {
-                    if (candidate === null || typeof candidate !== "object")
-                        throw new Error("invalid transaction");
-                    const finalize = candidate.finalize.bind(candidate);
-                    const rollback = candidate.rollback.bind(candidate);
-                    if (typeof finalize !== "function" ||
-                        typeof rollback !== "function")
-                        throw new Error("invalid transaction");
-                    transaction = { finalize, rollback };
-                }
-            }
-            catch {
-                return failed("invalid installation transaction receipt; preserve recovery material for manual resolution");
-            }
-            // Stage 4: inspect fingerprint, to verify the mutation actually took.
-            //
-            // Deliberately NOT short-circuited on `!inspected.ok`, unlike stages
-            // 1-3. `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/install:57::spw_verify_installed_fingerprint` handed the inspect result to
-            // spw_verify_installed_fingerprint whatever it contained, and that
-            // function's first guard, from
-            // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:91-94::spw_inspect_fingerprint`,
-            // is what turns a failed inspection into "error: installed manager
-            // fingerprint inspection failed after install."
-            // renderInstallVerification's failed-inspection arm
-            // (`src/harnesses/codex/presentation.ts:280::if (inspection.status !== 0 || !inspection.outcome.ok) {`)
-            // exists for this result-bearing path. Returning
-            // failed() instead reported the adapter's own generic diagnostic and
-            // dropped the post-install verification claim -- a mutation had
-            // already been issued at stage 3,
-            // so "the install could not be verified" is the contract, not "an
-            // adapter call failed". A ctx.adapter THROW has no result to render.
-            // A pending transaction still rolls back before reporting that failure.
-            const inspectionFailure = ctx.adapter.presentation.callFailure("post-install", adapterContext);
-            const inspected = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
-            const inspection = inspected.result;
-            const verified = inspection !== null &&
-                inspection.status === 0 &&
-                inspection.outcome.ok &&
-                inspection.outcome.result.kind === "current";
-            if (transaction !== undefined) {
-                const operation = verified ? "finalize" : "rollback";
-                const settlement = await invoke(() => (verified ? transaction.finalize() : transaction.rollback()), {
-                    unexpected: `installation ${operation} did not complete; preserve recovery material for manual resolution`,
-                    invalidStatus: `installation ${operation} returned an invalid result; preserve recovery material for manual resolution`,
-                }, outcomes, (value) => value === null);
-                if (!verified) {
-                    const restored = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
-                    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 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
-                        : null;
-                    return {
-                        kind: "verified",
-                        outcomes,
-                        status: 1,
-                        stdout: verificationOutput?.stdout ?? [],
-                        stderr: [
-                            ...(verificationOutput?.stderr ?? []),
-                            ...(inspectionMessage === null
-                                ? []
-                                : [`error: ${inspectionMessage}`]),
-                            ...(settlementMessage === null
-                                ? []
-                                : [`error: ${settlementMessage}`]),
-                            restoration,
-                        ],
-                    };
-                }
-                if (!settlement.ok) {
-                    const actual = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
-                    return {
-                        kind: "verified",
-                        outcomes,
-                        status: 1,
-                        stdout: [],
-                        stderr: [
-                            "error: installation was verified, but transaction cleanup did not complete; preserve recovery material for manual resolution",
-                            actual.ok
-                                ? `installed state after failed finalization: ${actual.result.outcome.result.kind}; identity=${actual.result.outcome.result.observedIdentity}`
-                                : "installed state after failed finalization could not be inspected",
-                            ...(settlement.message === null
-                                ? []
-                                : [`error: ${settlement.message}`]),
-                        ],
-                    };
-                }
-            }
-            if (inspection === null)
-                return failed(inspected.ok ? null : inspected.message);
-            const output = ctx.adapter.presentation.renderInstallVerification(selection.desiredCommit, install.result, inspection);
-            return {
-                kind: "verified",
-                outcomes,
-                status: verified ? 0 : 1,
-                stdout: output.stdout,
-                stderr: output.stderr,
-            };
-        });
-    }
-    catch (cause) {
-        // Reachable only for mkdtemp failure (nothing collected yet): the
-        // callback never throws, and a post-success cleanup failure comes back
-        // as cleanupWarning.
-        throw new GatherFailure("install gather failed", cause, outcomes);
-    }
+        }
+        if (inspection === null)
+            return failed(inspected.ok ? null : inspected.message);
+        const output = ctx.adapter.presentation.renderInstallVerification(selection.desiredCommit, install.result, inspection);
+        return {
+            kind: "verified",
+            status: verified ? 0 : 1,
+            stdout: output.stdout,
+            stderr: output.stderr,
+        };
+    });
 }
 export async function runInstall(argv, ctx) {
     if (ctx.adapter.presentation.installNotice !== "")
@@ -223,20 +204,21 @@ async function performInstall(ctx) {
         ctx.stderr.write("error: adapter reported a failure status for prepared harness inspection\n");
         return 1;
     }
+    // Owned here, not in gatherInstallStages, so a gather throw still replays
+    // every outcome collected before it.
+    const outcomes = [];
     let stage;
     try {
-        stage = await gatherInstallStages(ctx, facts.selection, prepared.outcome.result);
+        stage = await gatherInstallStages(ctx, facts.selection, prepared.outcome.result, outcomes);
     }
     catch (cause) {
-        const outcomes = cause instanceof GatherFailure ? cause.outcomes : [];
-        for (const outcome of outcomes)
-            replayOutcome(outcome, ctx);
-        const inner = cause instanceof GatherFailure ? cause.inner : cause;
-        ctx.stderr.write(`error: ${oneLine(inner)}\n`);
+        for (const each of outcomes)
+            replayOutcome(each, ctx);
+        ctx.stderr.write(`error: ${oneLine(cause)}\n`);
         return 1;
     }
     const { value: outcome, cleanupWarning } = stage;
-    for (const each of outcome.outcomes)
+    for (const each of outcomes)
         replayOutcome(each, ctx);
     let status;
     if (outcome.kind === "blocked") {

package/dist/commands/prepare.js

@@ -262,7 +262,7 @@ async function performPrepare(ctx, location) {
         // 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:372::if (cleanupWarning`.
+        // `src/commands/install.ts:351::if (cleanupWarning`.
         ctx.stderr.write(`error: ${cleanupWarning}\n`);
         return 1;
     }