superpowers-manager 0.2.0 → 0.4.0

package/dist/codex-presentation.js

@@ -0,0 +1,259 @@
+import { normalizeCodexInstall, normalizeCodexInstalled, } from "./codex-harness.js";
+import { displaySource } from "./selection.js";
+// One ordered table drives both formats, preserving the public human and
+// porcelain field order exposed through the harness presentation.
+export 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 },
+    ];
+}
+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("");
+    if (f.selectionOrigin !== f.upstreamSourceOrigin) {
+        text +=
+            "warning: effective ref and source have mixed origins " +
+                `(ref: ${f.selectionOrigin}, source: ${f.upstreamSourceOrigin})\n`;
+    }
+    return text;
+}
+function verificationOutput(kind, hint) {
+    const stderr = [
+        kind === "mismatch"
+            ? "error: installed manager fingerprint does not match the prepared plugin after install."
+            : "error: installed manager fingerprint is not detectable after install.",
+    ];
+    if (hint.length > 0)
+        stderr.push(`hint: ${hint}`);
+    return { stdout: [], stderr };
+}
+export function codexInstallReceipt(missingHint, mismatchHint) {
+    return {
+        missingVerificationOutput: verificationOutput("missing", missingHint),
+        mismatchVerificationOutput: verificationOutput("mismatch", mismatchHint),
+    };
+}
+// Compatibility export target for src/lifecycle.ts. Delegate to the production
+// normalizers and renderer so the retained verdict cannot drift from commands.
+export function verifyInstalledFingerprint(desiredCommit, installResult, inspectResult) {
+    const receipt = normalizeCodexInstall(installResult);
+    const inspection = normalizeCodexInstalled(inspectResult, desiredCommit);
+    const output = codexPresentation.renderInstallVerification(desiredCommit, receipt, inspection);
+    const ok = inspection.status === 0 &&
+        inspection.outcome.ok &&
+        inspection.outcome.result.kind === "current";
+    return { ok, stdout: output.stdout, stderr: output.stderr };
+}
+function probeFacts(facts) {
+    const selection = facts.selection;
+    const saved = selection.saved;
+    return {
+        requestedRef: selection.requestedRef,
+        resolvedRef: selection.resolvedRef,
+        desiredCommit: selection.desiredCommit,
+        generatedCommit: facts.prepared.observedIdentity,
+        installedCommit: facts.installed.observedIdentity,
+        identityState: facts.ownership.presentationValue,
+        status: facts.status,
+        selectionOrigin: selection.selectionOrigin,
+        selectionMode: selection.selectionMode,
+        upstreamSourceOrigin: selection.upstreamSourceOrigin,
+        effectiveSource: displaySource(selection.effectiveSource),
+        savedMode: saved.saved_mode,
+        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: facts.control.presentationValue,
+    };
+}
+function invocationFailure(argv) {
+    return {
+        unexpected: `cannot invoke Codex adapter for ${argv}`,
+        invalidStatus: `adapter reported a failure status for ${argv}`,
+    };
+}
+function callFailure(site, ctx, removalInput) {
+    switch (site) {
+        case "prepare":
+            return {
+                unexpected: "cannot build the generated plugin candidate",
+                invalidStatus: "adapter reported failure without an error outcome",
+            };
+        case "probe-installed":
+            return {
+                unexpected: "cannot inspect Codex adapter state for view fingerprint",
+                invalidStatus: "adapter reported a failure status for inspect --view fingerprint",
+            };
+        case "probe-ownership":
+            return {
+                unexpected: "cannot inspect Codex adapter state for view ownership",
+                invalidStatus: "adapter reported a failure status for inspect --view ownership",
+            };
+        case "probe-control":
+            return {
+                unexpected: "cannot inspect Codex adapter state for view update-control",
+                invalidStatus: "adapter reported a failure status for inspect --view update-control",
+            };
+        case "install-ownership":
+        case "remove-ownership":
+        case "post-remove":
+            return invocationFailure("inspect --view ownership");
+        case "install-control":
+            return invocationFailure("inspect --view update-control");
+        case "install":
+            return invocationFailure(`install --package-root ${ctx.root}`);
+        case "post-install":
+            return {
+                unexpected: "cannot invoke Codex adapter for inspect --view fingerprint",
+                invalidStatus: "installed manager fingerprint inspection failed after install.",
+            };
+        case "remove": {
+            const input = removalInput ?? {
+                pluginPresent: false,
+                marketplacePresent: false,
+            };
+            return invocationFailure(`uninstall --plugin-present ${String(input.pluginPresent)}` +
+                ` --marketplace-present ${String(input.marketplacePresent)}`);
+        }
+    }
+}
+export const codexPresentation = {
+    installNotice: "Note: remove or disable conflicting Superpowers providers yourself before" +
+        " relying on manager skills.",
+    currentNotice: "manager is current",
+    renderProbe(snapshot) {
+        const facts = probeFacts(snapshot);
+        return { human: formatHuman(facts), porcelain: formatPorcelain(facts) };
+    },
+    renderInstallVerification(desiredCommit, receipt, inspection) {
+        if (inspection.status !== 0 || !inspection.outcome.ok) {
+            const malformed = !inspection.outcome.ok &&
+                inspection.outcome.error.code === "malformed-result";
+            return {
+                stdout: [],
+                stderr: [
+                    malformed
+                        ? "error: cannot parse installed manager fingerprint inspection result after install."
+                        : "error: installed manager fingerprint inspection failed after install.",
+                ],
+            };
+        }
+        const observed = inspection.outcome.result.observedIdentity;
+        const stdout = [
+            `desired_commit=${desiredCommit}`,
+            `installed_commit=${observed}`,
+        ];
+        if (inspection.outcome.result.kind === "current") {
+            return { stdout: [...stdout, "manager updated"], stderr: [] };
+        }
+        if (receipt.status !== 0 || !receipt.outcome.ok) {
+            return {
+                stdout,
+                stderr: [
+                    inspection.outcome.result.kind === "absent"
+                        ? "error: installed manager fingerprint is not detectable after install."
+                        : "error: installed manager fingerprint does not match the prepared plugin after install.",
+                ],
+            };
+        }
+        const output = inspection.outcome.result.kind === "absent"
+            ? receipt.outcome.result.missingVerificationOutput
+            : receipt.outcome.result.mismatchVerificationOutput;
+        return { stdout, stderr: output.stderr };
+    },
+    renderRemovalCompletion(ownership) {
+        return {
+            stdout: [
+                ...ownership.postRemovalOutput.stdout,
+                "uninstall complete",
+                "note: local generated artifacts under plugins/superpowers/ and " +
+                    ".cache/upstream/ were left in place; remove them manually or " +
+                    "regenerate with npx superpowers-manager prepare.",
+            ],
+            stderr: ownership.postRemovalOutput.stderr,
+        };
+    },
+    callFailure,
+};

package/dist/codex-state.js

@@ -0,0 +1,78 @@
+import { readFile, realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { COMMIT_INPUT_RE } from "./domain/refs.js";
+import { SafetyError } from "./safety-error.js";
+import { parseStrictJson, } from "./strict-json.js";
+const INSTALLED_PROFILE = {
+    duplicateKeys: "last-wins",
+    nonStandardConstants: "reject",
+    maxDepth: 256,
+};
+function fail(message, cause) {
+    throw new SafetyError("codex-state", message, { cause });
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+async function jsonStringField(path, key) {
+    let parsed;
+    try {
+        parsed = parseStrictJson(await readFile(path), INSTALLED_PROFILE);
+    }
+    catch (cause) {
+        fail(`cannot read installed Codex JSON ${path}`, cause);
+    }
+    const record = object(parsed);
+    if (record === undefined)
+        fail(`invalid installed Codex JSON ${path}`);
+    const value = record[key];
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value !== "string")
+        fail(`invalid installed Codex JSON ${path}`);
+    return value;
+}
+export function installedRootForVersion(searchRoot, marketplace, plugin, version) {
+    return join(searchRoot, "plugins", "cache", marketplace, plugin, version);
+}
+export async function codexMetadataCommit(path) {
+    const commit = await jsonStringField(path, "commit");
+    if (!COMMIT_INPUT_RE.test(commit) && !/^[0-9a-fA-F]{7}$/.test(commit)) {
+        fail(`invalid installed Codex commit in ${path}`);
+    }
+    return commit;
+}
+export async function manifestShortSha(path) {
+    const version = await jsonStringField(path, "version");
+    if (!version.includes("+manager."))
+        return "";
+    const short = version.slice(version.lastIndexOf(".") + 1);
+    return /^[0-9a-fA-F]{7}$/.test(short) ? short : "";
+}
+export async function installedCommitFromRoot(activeRoot) {
+    try {
+        return await codexMetadataCommit(join(activeRoot, ".superpowers-upstream.json"));
+    }
+    catch {
+        // The shell predecessor deliberately fell back to the generated manifest.
+    }
+    try {
+        return await manifestShortSha(join(activeRoot, ".codex-plugin", "plugin.json"));
+    }
+    catch {
+        return "";
+    }
+}
+async function comparablePath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+export async function pathsEqual(a, b) {
+    return (await comparablePath(a)) === (await comparablePath(b));
+}

package/dist/commands/context.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/install.js

@@ -0,0 +1,291 @@
+// Ports scripts/install. The shell sourced common.sh, provenance.sh,
+// status.sh, lifecycle.sh and adapter.sh; the predicates now live in
+// src/lifecycle.ts, the generated-metadata read lives in src/provenance.ts,
+// and the adapter arrives through ctx.adapter.
+import { tmpdir } from "node:os";
+import { oneLine } from "../cli-arguments.js";
+import { withWorkspace, workspaceRemovalFailure } from "../workspace.js";
+import { gatherProbe, replayOutcome } from "./probe.js";
+import { runPrepare } from "./prepare.js";
+function writeOutput(output, ctx) {
+    for (const line of output.stdout)
+        ctx.stdout.write(`${line}\n`);
+    for (const line of output.stderr)
+        ctx.stderr.write(`${line}\n`);
+}
+async function invoke(call, failure, outcomes) {
+    let result;
+    try {
+        result = await call();
+    }
+    catch {
+        return { ok: false, message: failure.unexpected, result: null };
+    }
+    outcomes.push(result.outcome);
+    const outcome = result.outcome;
+    if (result.status !== 0 || !outcome.ok) {
+        return {
+            ok: false,
+            message: outcome.ok ? failure.invalidStatus : null,
+            result,
+        };
+    }
+    return {
+        ok: true,
+        result: { status: result.status, outcome },
+    };
+}
+// withWorkspace can throw AFTER its callback has already returned a fully
+// computed StageOutcome: a post-success cleanup failure discards that return
+// value entirely and rejects instead, UNLESS an `onCleanupFailure` reporter is
+// supplied -- which gatherInstallStages below does, precisely so this class
+// stays reserved for mkdtemp failure (nothing collected yet) and the
+// callback's own throw (never reachable here; see gatherInstallStages).
+// Carries the outcomes collected so far so runInstall's catch can still
+// replay them instead of discarding them with a bare re-throw. Same shape as
+// src/commands/uninstall.ts's GatherFailure, duplicated for the same reason
+// invoke() is: no shared dependency between the two modules.
+class GatherFailure extends Error {
+    inner;
+    outcomes;
+    constructor(inner, outcomes) {
+        super("install gather failed");
+        this.inner = inner;
+        this.outcomes = outcomes;
+    }
+}
+// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/install:44-58::TMPDIR=`, wrapped in the temporary workspace scripts/install
+// created via spw_make_workspace + spw_install_workspace_trap. Performs no
+// writes of its own -- same EPIPE-avoidance shape as gatherProbe and
+// src/commands/uninstall.ts's gatherUninstall.
+async function gatherInstallStages(ctx, selection, artifact) {
+    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/install:38::tmp_parent=` -- ${TMPDIR:-/tmp}. Matches
+    // src/commands/uninstall.ts's gatherUninstall.
+    const parent = ctx.env.TMPDIR ?? tmpdir();
+    const outcomes = [];
+    let cleanupWarning = null;
+    try {
+        const outcome = await withWorkspace(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 {
+                    kind: "blocked",
+                    outcomes,
+                    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",
+                    outcomes,
+                    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 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);
+            // 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/codex-presentation.ts:306::if (inspection.status !== 0 || !inspection.outcome.ok) {`)
+            // exists for this result-bearing path; the lifecycle compatibility
+            // export delegates through the same arm. Returning
+            // failed() instead reported the adapter's own generic diagnostic and
+            // 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 is the one case with no
+            // result to verify against, and keeps the short-circuit.
+            const inspectionFailure = ctx.adapter.presentation.callFailure("post-install", adapterContext);
+            const inspected = await invoke(() => ctx.adapter.inspectInstalled(selection, adapterContext), inspectionFailure, outcomes);
+            if (!inspected.ok && inspected.result === null) {
+                return failed(inspected.message);
+            }
+            const inspection = inspected.result;
+            if (inspection === null)
+                return failed(null);
+            const output = ctx.adapter.presentation.renderInstallVerification(selection.desiredCommit, install.result, inspection);
+            const verified = inspection.status === 0 &&
+                inspection.outcome.ok &&
+                inspection.outcome.result.kind === "current";
+            return {
+                kind: "verified",
+                outcomes,
+                status: verified ? 0 : 1,
+                stdout: output.stdout,
+                stderr: output.stderr,
+            };
+        }, {
+            // Suppresses withWorkspace's throw on a POST-SUCCESS cleanup failure,
+            // so the StageOutcome the callback already computed still comes back
+            // as `outcome` below instead of being discarded. `report` runs
+            // synchronously, as the option requires (src/workspace.ts).
+            onCleanupFailure: (path) => {
+                cleanupWarning = workspaceRemovalFailure(path);
+            },
+        });
+        return { outcome, cleanupWarning };
+    }
+    catch (cause) {
+        // Reachable only for mkdtemp failure (nothing collected yet) -- the
+        // callback above never throws, so a post-success cleanup failure is
+        // already handled by onCleanupFailure and cannot reach here.
+        throw new GatherFailure(cause, outcomes);
+    }
+}
+export async function runInstall(argv, ctx) {
+    // scripts/install never reads "$@", so extra arguments are silently
+    // ignored -- the same asymmetry runPrepare and runUninstall document.
+    void argv;
+    ctx.stdout.write(`${ctx.adapter.presentation.installNotice}\n`);
+    let probe;
+    try {
+        probe = await gatherProbe(ctx);
+    }
+    catch (cause) {
+        // gatherProbe performs no writes of its own (src/commands/probe.ts), so
+        // this catch cannot also be reached by an EPIPE from install's own
+        // output: the NOTE line above already left the try, and everything below
+        // runs only after this try/catch has resolved.
+        //
+        // This is a SECOND consumer of gatherProbe's throw channel --
+        // `src/commands/probe.ts:251-309::THREE exceptions, all inherited and none a regression:`'s
+        // runProbe catch is the first. Because both consumers wrap the identical
+        // function, its long comment there enumerates exactly what can reach THIS
+        // stream too, including the three foreign-text exceptions at :251-296:
+        //   1. :251-262 -- resolveRef splices git's own combined stdout+stderr
+        //      into its text. Reached on probe's DEFAULT path, which that comment
+        //      defines as every invocation NOT resolving a saved pin: a 40-hex
+        //      ref returns a "raw-commit" resolution at
+        //      `src/upstream.ts:162-164::return { kind: "raw-commit"`
+        //      before any git call, so it reaches no splice at all.
+        //   2. :263-280 -- src/selection-store.ts's read path interpolates the
+        //      caught error's own message, so Node errno prose can appear.
+        //      AGENTS.md grandfathers that module's wording.
+        //   3. :281-296 -- a SPAWN-level git failure, a different channel from
+        //      exception 1's exit-status one: on the non-ENOENT arm of
+        //      `src/git.ts:47-52::if (typeof failure.code === "string") {`, runGit
+        //      rejects with "cannot run git: " followed by the Node spawn error's
+        //      own message.
+        // Not repeated in full here; read it there.
+        ctx.stderr.write(`error: ${oneLine(cause)}\n`);
+        return 1;
+    }
+    // Replay first, on both paths, before any decision -- clause 1.
+    for (const outcome of probe.outcomes)
+        replayOutcome(outcome, ctx);
+    if (probe.status === 1) {
+        if (probe.message !== null) {
+            ctx.stderr.write(`error: ${probe.message}\n`);
+        }
+        return 1;
+    }
+    const facts = probe.facts;
+    if (facts.ownership.installEligibility.kind === "blocked") {
+        writeOutput(facts.ownership.installEligibility.output, ctx);
+        return 1;
+    }
+    switch (facts.status) {
+        case "needs prepare": {
+            const prepareStatus = await runPrepare([], ctx);
+            if (prepareStatus !== 0)
+                return prepareStatus;
+            break;
+        }
+        case "needs install":
+            break;
+        case "current":
+            break;
+    }
+    let prepared;
+    try {
+        prepared = await ctx.adapter.readPrepared({ root: ctx.root, env: ctx.env });
+    }
+    catch {
+        ctx.stderr.write("error: cannot read prepared harness state\n");
+        return 1;
+    }
+    replayOutcome(prepared.outcome, ctx);
+    if (!prepared.outcome.ok)
+        return 1;
+    if (prepared.status !== 0) {
+        ctx.stderr.write("error: adapter reported a failure status for prepared harness inspection\n");
+        return 1;
+    }
+    let stage;
+    try {
+        stage = await gatherInstallStages(ctx, facts.selection, prepared.outcome.result);
+    }
+    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`);
+        return 1;
+    }
+    const { outcome, cleanupWarning } = stage;
+    for (const each of outcome.outcomes)
+        replayOutcome(each, ctx);
+    let status;
+    if (outcome.kind === "blocked") {
+        writeOutput(outcome.output, ctx);
+        status = 1;
+    }
+    else if (outcome.kind === "failed") {
+        if (outcome.message !== null) {
+            ctx.stderr.write(`error: ${outcome.message}\n`);
+        }
+        status = 1;
+    }
+    else {
+        // :99-100 printed both lines BEFORE deciding, on every path that got this
+        // far; the verified outcome already carries both renderer arrays, so they
+        // are written in order regardless of its status.
+        for (const line of outcome.stdout)
+            ctx.stdout.write(`${line}\n`);
+        for (const line of outcome.stderr)
+            ctx.stderr.write(`${line}\n`);
+        status = outcome.status;
+    }
+    if (cleanupWarning !== null) {
+        // A leaked workspace is reported even when the domain outcome above was
+        // itself a success: the fingerprint verification that produced that
+        // success already completed against the adapter 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.
+        ctx.stderr.write(`error: ${cleanupWarning}\n`);
+        return 1;
+    }
+    return status;
+}