superpowers-manager 0.5.2 → 0.6.0

package/dist/harnesses/codex/compatibility.js

@@ -61,24 +61,9 @@ export async function readCodexAssessment(root) {
         });
         if (errors.length)
             throw new Error("generated resources");
-        const selection = {
+        const compatibility = await assessCodexCompatibility(root, {
             effectiveSource: receipt.source,
-            desiredCommit: receipt.commit,
-            requestedRef: provenance.requested_ref,
-            resolvedRef: provenance.resolved_ref,
-            resolutionKind: "raw-commit",
-            selectionOrigin: "package-default",
-            selectionMode: "default",
-            upstreamSourceOrigin: "package-default",
-            saved: {
-                saved_mode: "none",
-                saved_source: "",
-                saved_requested_ref: "",
-                saved_resolved_ref: "",
-                saved_commit: "",
-            },
-        };
-        const compatibility = await assessCodexCompatibility(root, selection);
+        });
         return {
             root,
             commit: receipt.commit,

package/dist/harnesses/codex/harness.js

@@ -1,9 +1,7 @@
-import { failureResult, hasTerminalControl, successResult, } from "../../adapter-result.js";
-import { codexInspect, codexInstall, } from "./adapter.js";
+import { failureResult, successResult, } from "../../adapter-result.js";
+import { codexInspectControl, codexInspectOwnership, codexInstall, } from "./adapter.js";
 import { codexPreparationLocation, inspectCodexPrepared, prepareCodexCandidate, readCodexPrepared, validateCodexPreparationBeforeFetch, } from "./prepare.js";
-import { codexInstallReceipt, codexPresentation } from "./presentation.js";
-import { reportLegacyState, requireManagedUpdateControl, requireNoLegacyState, verifyUninstalledResources, } from "./lifecycle.js";
-import { commitMatches } from "../../status.js";
+import { codexPresentation } from "./presentation.js";
 import { codexHome, codexPaths } from "./paths.js";
 import { installCodexMarketplace, removeCodexMarketplace, } from "./publication.js";
 import { readCodexRecovery } from "./recovery.js";
@@ -14,257 +12,11 @@ function preserveFailure(result) {
     }
     return { status: result.status, outcome: result.outcome };
 }
-function malformed(result, message) {
-    return failureResult(result.outcome.operation, "malformed-result", message, [], result.outcome.messages);
-}
-function invalidStatus(result, message) {
+export function rejectSuccessfulNonzeroStatus(result, message) {
+    if (!result.outcome.ok || result.status === 0)
+        return result;
     return failureResult(result.outcome.operation, "invalid-status", message, [], result.outcome.messages);
 }
-function resultRecord(result) {
-    const value = result.outcome.ok ? result.outcome.result : null;
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : null;
-}
-function stringField(result, key) {
-    const raw = result[key];
-    if (raw === null || raw === undefined)
-        return { ok: true, value: "" };
-    if (typeof raw === "string")
-        return { ok: true, value: raw };
-    return { ok: false };
-}
-function resourceFlag(result, key) {
-    const resources = result.resources;
-    const bag = typeof resources === "object" &&
-        resources !== null &&
-        !Array.isArray(resources)
-        ? resources
-        : {};
-    const value = bag[key];
-    return typeof value === "boolean" ? value : null;
-}
-function conflictDescriptions(result) {
-    const raw = result.conflicts;
-    if (raw === null || raw === undefined)
-        return [];
-    if (!Array.isArray(raw))
-        return null;
-    const descriptions = [];
-    for (const item of raw) {
-        if (typeof item !== "string" ||
-            item.length === 0 ||
-            hasTerminalControl(item)) {
-            return null;
-        }
-        descriptions.push(item);
-    }
-    return descriptions;
-}
-function installDecision(legacy) {
-    switch (legacy.kind) {
-        case "ok":
-            return { kind: "allowed" };
-        case "blocked":
-            return {
-                kind: "blocked",
-                output: { stdout: [], stderr: legacy.lines },
-            };
-        case "unknown":
-            return {
-                kind: "blocked",
-                output: { stdout: [], stderr: [`error: ${legacy.message}`] },
-            };
-        case "report":
-            return {
-                kind: "blocked",
-                output: {
-                    stdout: [],
-                    stderr: ["error: unexpected legacy report during installation"],
-                },
-            };
-    }
-}
-export function normalizeCodexOwnership(result) {
-    if (!result.outcome.ok)
-        return preserveFailure(result);
-    if (result.status !== 0) {
-        return invalidStatus(result, "adapter reported a failure status for inspect --view ownership");
-    }
-    const record = resultRecord(result);
-    if (record === null) {
-        return malformed(result, "adapter returned a non-object result for inspect --view ownership");
-    }
-    const pluginPresent = resourceFlag(record, "plugin");
-    if (pluginPresent === null) {
-        return malformed(result, "expected a Boolean adapter result at resources.plugin");
-    }
-    const marketplacePresent = resourceFlag(record, "marketplace");
-    if (marketplacePresent === null) {
-        return malformed(result, "expected a Boolean adapter result at resources.marketplace");
-    }
-    const identity = stringField(record, "identity_state");
-    if (!identity.ok) {
-        return malformed(result, "adapter returned a non-string identity_state for inspect --view ownership");
-    }
-    const identityState = identity.value;
-    const conflicts = conflictDescriptions(record);
-    if (conflicts === null) {
-        return malformed(result, "expected an array of strings at conflicts");
-    }
-    const legacyEligibility = identityState.length === 0
-        ? {
-            kind: "blocked",
-            output: {
-                stdout: [],
-                stderr: ["error: probe did not report adapter identity state"],
-            },
-        }
-        : installDecision(requireNoLegacyState(identityState));
-    const installEligibility = legacyEligibility.kind === "blocked" || conflicts.length === 0
-        ? legacyEligibility
-        : {
-            kind: "blocked",
-            output: {
-                stdout: [],
-                stderr: [
-                    "Conflicting unmanaged Superpowers Codex resources require manual resolution:",
-                    ...conflicts.map((conflict) => `- ${conflict}`),
-                    "Remove or disable each resource manually, then retry.",
-                ],
-            },
-        };
-    const verification = verifyUninstalledResources(result);
-    const legacyReport = reportLegacyState(identityState);
-    let removalVerification;
-    if (!verification.ok) {
-        removalVerification = {
-            kind: "blocked",
-            output: { stdout: [], stderr: [`error: ${verification.message}`] },
-        };
-    }
-    else if (legacyReport.kind === "unknown") {
-        removalVerification = {
-            kind: "blocked",
-            output: { stdout: [], stderr: [`error: ${legacyReport.message}`] },
-        };
-    }
-    else if (legacyReport.kind === "blocked") {
-        removalVerification = {
-            kind: "blocked",
-            output: {
-                stdout: [],
-                stderr: ["error: unexpected legacy block after removal"],
-            },
-        };
-    }
-    else {
-        removalVerification = { kind: "allowed" };
-    }
-    const postRemovalOutput = legacyReport.kind === "report"
-        ? { stdout: legacyReport.lines, stderr: [] }
-        : { stdout: [], stderr: [] };
-    return successResult(result.outcome.operation, {
-        installEligibility,
-        removalInput: { pluginPresent, marketplacePresent },
-        removalVerification,
-        postRemovalOutput,
-        presentationValue: identityState,
-        presentationConflicts: conflicts,
-    }, result.outcome.messages);
-}
-export function normalizeCodexControl(result) {
-    if (!result.outcome.ok)
-        return preserveFailure(result);
-    if (result.status !== 0) {
-        return invalidStatus(result, "adapter reported a failure status for inspect --view update-control");
-    }
-    const record = resultRecord(result);
-    if (record === null) {
-        return malformed(result, "adapter returned a non-object result for inspect --view update-control");
-    }
-    const control = stringField(record, "update_control");
-    if (!control.ok) {
-        return malformed(result, "adapter returned a non-string update_control for inspect --view update-control");
-    }
-    const updateControl = control.value;
-    const probeEligibility = updateControl.length === 0
-        ? {
-            kind: "blocked",
-            output: {
-                stdout: [],
-                stderr: [
-                    "error: probe did not report adapter update-control capability",
-                ],
-            },
-        }
-        : { kind: "allowed" };
-    const managed = requireManagedUpdateControl(updateControl);
-    const mutationEligibility = probeEligibility.kind === "blocked"
-        ? probeEligibility
-        : managed.ok
-            ? { kind: "allowed" }
-            : {
-                kind: "blocked",
-                output: {
-                    stdout: [],
-                    stderr: [`error: ${managed.message}`],
-                },
-            };
-    return successResult(result.outcome.operation, { probeEligibility, mutationEligibility, presentationValue: updateControl }, result.outcome.messages);
-}
-export function normalizeCodexInstalled(result, desiredCommit) {
-    if (!result.outcome.ok)
-        return preserveFailure(result);
-    if (result.status !== 0) {
-        return invalidStatus(result, "adapter reported a failure status for inspect --view fingerprint");
-    }
-    const record = resultRecord(result);
-    if (record === null) {
-        return malformed(result, "adapter returned a non-object result for inspect --view fingerprint");
-    }
-    const fingerprint = stringField(record, "fingerprint");
-    if (!fingerprint.ok) {
-        return malformed(result, "adapter returned a non-string fingerprint for inspect --view fingerprint");
-    }
-    const observedIdentity = fingerprint.value;
-    const installed = observedIdentity.length === 0
-        ? { kind: "absent", observedIdentity: "" }
-        : commitMatches(desiredCommit, observedIdentity)
-            ? { kind: "current", observedIdentity }
-            : { kind: "mismatch", observedIdentity };
-    return successResult(result.outcome.operation, installed, result.outcome.messages);
-}
-function safeHint(value) {
-    return typeof value === "string" && !hasTerminalControl(value) ? value : "";
-}
-export function normalizeCodexInstall(result) {
-    if (!result.outcome.ok)
-        return preserveFailure(result);
-    if (result.status !== 0) {
-        return invalidStatus(result, "adapter reported a failure status for install");
-    }
-    const record = resultRecord(result);
-    if (record === null) {
-        return malformed(result, "adapter returned a non-object result for install");
-    }
-    const hints = record.verification_hints;
-    const bag = typeof hints === "object" && hints !== null && !Array.isArray(hints)
-        ? hints
-        : {};
-    return successResult(result.outcome.operation, codexInstallReceipt(safeHint(bag.missing), safeHint(bag.mismatch)), result.outcome.messages);
-}
-// The canonical payload normalizer has no context parameter. Keep the native
-// call's defensive success/nonzero-status guard beside the concrete adapter,
-// where the exact legacy diagnostic can still name ctx.root.
-export function normalizeCodexInstallForContext(result, ctx) {
-    if (!result.outcome.ok)
-        return preserveFailure(result);
-    if (result.status !== 0) {
-        return invalidStatus(result, codexPresentation.callFailure("install", ctx).invalidStatus);
-    }
-    return normalizeCodexInstall(result);
-}
 function requirements(command, env) {
     if (command !== "probe" &&
         command !== "install" &&
@@ -286,9 +38,9 @@ async function mutationRoots(ctx) {
     return [codexHome(ctx.env ?? {}, process.cwd())];
 }
 async function inspectCodexUpdateControl(ctx) {
-    const normalized = normalizeCodexControl(await codexInspect("update-control", ctx));
-    if (!normalized.outcome.ok)
-        return normalized;
+    const result = rejectSuccessfulNonzeroStatus(await codexInspectControl(ctx), "adapter reported a failure status for inspect --view update-control");
+    if (!result.outcome.ok)
+        return result;
     const paths = codexPaths(ctx.env ?? {}, process.cwd());
     let diagnostic = null;
     try {
@@ -300,17 +52,17 @@ async function inspectCodexUpdateControl(ctx) {
         diagnostic = `cannot inspect Codex recovery state at ${paths.recoveryRoot}`;
     }
     if (diagnostic === null)
-        return normalized;
+        return result;
     const decision = {
         kind: "blocked",
         output: { stdout: [], stderr: [`error: ${diagnostic}`] },
     };
-    return successResult(normalized.outcome.operation, {
+    return successResult(result.outcome.operation, {
         probeEligibility: decision,
         mutationEligibility: decision,
         presentationValue: diagnostic,
         recoveryState: "required",
-    }, normalized.outcome.messages);
+    }, result.outcome.messages);
 }
 export const codexHarness = {
     preparationLocation: codexPreparationLocation,
@@ -319,16 +71,19 @@ export const codexHarness = {
     prepareCandidate: prepareCodexCandidate,
     inspectPrepared: inspectCodexPrepared,
     readPrepared: readCodexPrepared,
-    inspectOwnership: async (ctx) => normalizeCodexOwnership(await codexInspect("ownership", ctx)),
+    inspectOwnership: codexInspectOwnership,
     inspectUpdateControl: inspectCodexUpdateControl,
     inspectInstalled: inspectCodexInstallation,
-    install: async (artifact, ctx) => installCodexMarketplace(artifact, ctx, async (root, context) => normalizeCodexInstallForContext(await codexInstall(root, context), context)),
+    install: async (artifact, ctx) => installCodexMarketplace(artifact, ctx, async (root, context) => {
+        const result = await codexInstall(root, context);
+        return rejectSuccessfulNonzeroStatus(result, codexPresentation.callFailure("install", context).invalidStatus);
+    }),
     remove: async (input, ctx) => {
         const result = await removeCodexMarketplace(input, ctx);
         if (!result.outcome.ok)
             return preserveFailure(result);
         if (result.status !== 0) {
-            return invalidStatus(result, codexPresentation.callFailure("remove", ctx, input).invalidStatus);
+            return rejectSuccessfulNonzeroStatus(result, codexPresentation.callFailure("remove", ctx, input).invalidStatus);
         }
         return successResult(result.outcome.operation, null, result.outcome.messages);
     },

package/dist/harnesses/codex/lifecycle.js

@@ -52,7 +52,6 @@ export function reportLegacyState(identityState) {
     }
     return unknownState(identityState);
 }
-export { verifyInstalledFingerprint } from "./presentation.js";
 // Ported from
 // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:62-70::spw_require_managed_update_control`.
 // Both refusals reached spw_die in the shell, so both carry the `error: ` prefix
@@ -71,65 +70,122 @@ export function requireManagedUpdateControl(value) {
         message: `unknown adapter update-control capability: ${value}`,
     };
 }
-function readResult(adapterResult) {
-    if (adapterResult.status !== 0)
-        return { kind: "call-failed" };
-    const outcome = adapterResult.outcome;
-    if (!outcome.ok)
-        return { kind: "call-failed" };
-    const value = outcome.result;
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return { kind: "unusable" };
-    }
-    return { kind: "object", value: value };
-}
-// Ported from
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:126-141::spw_verify_uninstalled_resources`,
-// with the Boolean coercion of
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/adapter.sh:58-73::spw_adapter_result_boolean`
-// folded in: a non-Boolean is a hard failure, never a falsy "absent".
-export function verifyUninstalledResources(inspectResult) {
-    const read = readResult(inspectResult);
-    if (read.kind !== "object") {
-        return {
-            ok: false,
-            message: "cannot read the adapter ownership inspection after removal",
-        };
-    }
-    const inspected = read.value;
-    // A missing or non-object `resources` falls THROUGH to the Boolean check
-    // rather than getting its own message.
-    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/adapter.sh:70::expected`
-    // emits "expected Boolean adapter result at resources.plugin" for input {} —
-    // the input tests/unit/harnesses/codex/lifecycle.test.ts's "a non-object resources falls
-    // through to the Boolean message" exercises — so a distinct "not an object"
-    // message here would be a port-only divergence. Parity, not divergence. Spec
-    // §6.2.3 item 3.
-    const resources = inspected.resources;
-    const bag = typeof resources === "object" &&
-        resources !== null &&
-        !Array.isArray(resources)
-        ? resources
-        : {};
-    for (const key of ["plugin", "marketplace"]) {
-        if (typeof bag[key] !== "boolean") {
+function installDecision(legacy) {
+    switch (legacy.kind) {
+        case "ok":
+            return { kind: "allowed" };
+        case "blocked":
             return {
-                ok: false,
-                message: `expected a Boolean adapter result at resources.${key}`,
+                kind: "blocked",
+                output: { stdout: [], stderr: legacy.lines },
             };
+        case "unknown":
+            return {
+                kind: "blocked",
+                output: { stdout: [], stderr: [`error: ${legacy.message}`] },
+            };
+        case "report":
+            return {
+                kind: "blocked",
+                output: {
+                    stdout: [],
+                    stderr: ["error: unexpected legacy report during installation"],
+                },
+            };
+    }
+}
+export function codexOwnershipInspection(identityState, removalInput, conflicts) {
+    const { pluginPresent, marketplacePresent } = removalInput;
+    const legacyEligibility = identityState.length === 0
+        ? {
+            kind: "blocked",
+            output: {
+                stdout: [],
+                stderr: ["error: probe did not report adapter identity state"],
+            },
         }
+        : installDecision(requireNoLegacyState(identityState));
+    const installEligibility = legacyEligibility.kind === "blocked" || conflicts.length === 0
+        ? legacyEligibility
+        : {
+            kind: "blocked",
+            output: {
+                stdout: [],
+                stderr: [
+                    "Conflicting unmanaged Superpowers Codex resources require manual resolution:",
+                    ...conflicts.map((conflict) => `- ${conflict}`),
+                    "Remove or disable each resource manually, then retry.",
+                ],
+            },
+        };
+    const legacyReport = reportLegacyState(identityState);
+    let removalVerification;
+    if (pluginPresent || marketplacePresent) {
+        const message = pluginPresent
+            ? "owned plugin resource is still installed after removal"
+            : "owned marketplace resource is still registered after removal";
+        removalVerification = {
+            kind: "blocked",
+            output: { stdout: [], stderr: ["error: " + message] },
+        };
     }
-    if (bag.plugin === true) {
-        return {
-            ok: false,
-            message: "owned plugin resource is still installed after removal",
+    else if (legacyReport.kind === "unknown") {
+        removalVerification = {
+            kind: "blocked",
+            output: { stdout: [], stderr: [`error: ${legacyReport.message}`] },
         };
     }
-    if (bag.marketplace === true) {
-        return {
-            ok: false,
-            message: "owned marketplace resource is still registered after removal",
+    else if (legacyReport.kind === "blocked") {
+        removalVerification = {
+            kind: "blocked",
+            output: {
+                stdout: [],
+                stderr: ["error: unexpected legacy block after removal"],
+            },
         };
     }
-    return { ok: true };
+    else {
+        removalVerification = { kind: "allowed" };
+    }
+    const postRemovalOutput = legacyReport.kind === "report"
+        ? { stdout: legacyReport.lines, stderr: [] }
+        : { stdout: [], stderr: [] };
+    return {
+        installEligibility,
+        removalInput,
+        removalVerification,
+        postRemovalOutput,
+        presentationValue: identityState,
+        presentationConflicts: conflicts,
+    };
+}
+export function codexControlInspection(updateControl) {
+    const probeEligibility = updateControl.length === 0
+        ? {
+            kind: "blocked",
+            output: {
+                stdout: [],
+                stderr: [
+                    "error: probe did not report adapter update-control capability",
+                ],
+            },
+        }
+        : { kind: "allowed" };
+    const managed = requireManagedUpdateControl(updateControl);
+    const mutationEligibility = probeEligibility.kind === "blocked"
+        ? probeEligibility
+        : managed.ok
+            ? { kind: "allowed" }
+            : {
+                kind: "blocked",
+                output: {
+                    stdout: [],
+                    stderr: [`error: ${managed.message}`],
+                },
+            };
+    return {
+        probeEligibility,
+        mutationEligibility,
+        presentationValue: updateControl,
+    };
 }

package/dist/harnesses/codex/manifest-overlay.js

@@ -1,4 +1,4 @@
-import { escapeNonAscii, formatPythonNumber, } from "../../python-json-format.js";
+import { escapeNonAscii } from "../../python-json-format.js";
 import { SafetyError } from "../../safety-error.js";
 import { isRawNumber, isRawObject, parseStrictJsonPreservingNumbers, } from "../../strict-json.js";
 const OVERLAY_PROFILE = {
@@ -9,14 +9,17 @@ const OVERLAY_PROFILE = {
 /**
  * Apply the manager's manifest overlay to a Codex plugin manifest.
  *
- * Byte-for-byte equivalent to the CPython implementation this replaces:
- * `json.dump(data, f, indent=2, allow_nan=False)` plus a trailing newline.
- * The byte-parity evidence lives in
- * `tests/baseline/harnesses/codex/manifest-overlay-parity.test.ts` (tracked as
- * `MANIFEST-READER-OVERLAY-01` in `docs/baseline/traceability.md`) against
- * the fixtures under `tests/fixtures/baseline/overlay-parity/`. Known,
- * deliberate divergences from strict byte parity are recorded in
+ * Preserves validated JSON numeric source tokens while applying the manager's
+ * manifest fields, with a trailing newline. The baseline contract lives in
+ * `tests/baseline/harnesses/codex/manifest-overlay-parity.test.ts` against the
+ * fixtures under `tests/fixtures/baseline/overlay-parity/`. The 5,000-digit
+ * integer widening is recorded in
  * `tests/fixtures/baseline/overlay-parity/divergent/README.md`.
+ *
+ * Decimal and exponent tokens are range-checked before emission. The strict
+ * parser rejects non-standard constants before they reach the emitter. Object
+ * member order, string escaping, and unknown fields remain part of this
+ * overlay contract.
  */
 export function applyManifestOverlay(source, version, path) {
     let parsed;
@@ -43,14 +46,10 @@ export function applyManifestOverlay(source, version, path) {
         throw rewrapNumberOutOfRange(cause, path);
     }
 }
-// formatPythonNumber (src/python-json-format.ts) has no notion of a manifest
-// path — it is a general CPython-`json.dump`-equivalent number formatter,
-// exercised on its own in tests/unit/python-json-format.test.js — so it
-// throws a bare `JSON number out of range: ${raw}`. That left the operator
-// with no indication of which manifest produced the diagnostic, unlike every
-// other overlay failure. This rewrap adds the path without touching
-// formatPythonNumber's own contract, and is scoped to exactly this message so
-// it cannot swallow or reword any other overlay throw.
+// emitNumber has no manifest path, so it throws a bare
+// `JSON number out of range: ${raw}`. This rewrap adds the path without
+// touching the local emitter's own contract, and is scoped to exactly this
+// message so it cannot swallow or reword any other overlay throw.
 const NUMBER_OUT_OF_RANGE_PREFIX = "JSON number out of range: ";
 function rewrapNumberOutOfRange(cause, path) {
     if (cause instanceof SafetyError &&
@@ -60,6 +59,12 @@ function rewrapNumberOutOfRange(cause, path) {
     }
     return cause;
 }
+function emitNumber(raw) {
+    if (/[.eE]/.test(raw) && !Number.isFinite(Number(raw))) {
+        throw new SafetyError("manifest-overlay", `JSON number out of range: ${raw}`);
+    }
+    return raw;
+}
 function setMember(entries, key, value) {
     const index = entries.findIndex(([existing]) => existing === key);
     if (index === -1)
@@ -105,7 +110,7 @@ function emit(value, depth) {
     // Order matters: isRawNumber before isRawObject, and both before Array —
     // the branded records are objects too.
     if (isRawNumber(value))
-        return formatPythonNumber(value.source);
+        return emitNumber(value.source);
     if (isRawObject(value))
         return emitObject(value.entries, depth);
     const inner = "  ".repeat(depth + 1);

package/dist/harnesses/codex/presentation.js

@@ -1,5 +1,5 @@
-import { normalizeCodexInstall, normalizeCodexInstalled } from "./harness.js";
 import { displaySource } from "../../selection.js";
+import { hasTerminalControl } from "../../adapter-result.js";
 // One ordered table drives both formats, preserving the public human and
 // porcelain field order exposed through the harness presentation.
 function fields(f) {
@@ -110,23 +110,15 @@ function verificationOutput(kind, hint) {
         stderr.push(`hint: ${hint}`);
     return { stdout: [], stderr };
 }
+function safeHint(value) {
+    return typeof value === "string" && !hasTerminalControl(value) ? value : "";
+}
 export function codexInstallReceipt(missingHint, mismatchHint) {
     return {
-        missingVerificationOutput: verificationOutput("missing", missingHint),
-        mismatchVerificationOutput: verificationOutput("mismatch", mismatchHint),
+        missingVerificationOutput: verificationOutput("missing", safeHint(missingHint)),
+        mismatchVerificationOutput: verificationOutput("mismatch", safeHint(mismatchHint)),
     };
 }
-// Compatibility export target for src/harnesses/codex/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;