superpowers-manager 0.8.0 → 0.9.0

package/dist/harnesses/codex/hooks.js

@@ -1,10 +1,10 @@
-import { copyFile, cp, mkdir, readdir, readFile, readlink, stat, symlink, } from "node:fs/promises";
+import { copyFile, cp, mkdir, readdir, readFile, readlink, symlink, } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { assertExistingContained, assertProspectiveContained, classifyPathNoFollow, } from "../../safe-path.js";
+import { assertExistingContained, assertProspectiveContained, classifyPathNoFollow, isDirectory, isFile, } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 import { parseStrictJson } from "../../strict-json.js";
 // Annotated, not `as const`, matching
-// `src/provenance.ts:20::const PROVENANCE_STRICT_PROFILE` and
+// `src/provenance.ts:19::const PROVENANCE_STRICT_PROFILE` and
 // `src/selection-store.ts:15::const SELECTION_JSON_PROFILE`. The annotation
 // rejects a misspelled or unsupported profile field here rather than at the
 // parseStrictJson call.
@@ -14,8 +14,8 @@ const MANIFEST_PROFILE = {
     maxDepth: 256,
 };
 // Private helper, matching
-// `src/selection.ts:42::return new SafetyError("selection"` and
-// `src/upstream.ts:35::function upstreamError`. No new exported error class:
+// `src/selection.ts:35::return new SafetyError("selection"` and
+// `src/upstream.ts:36::function upstreamError`. No new exported error class:
 // SafetyError already carries module and cause.
 function hookError(message, cause) {
     return new SafetyError("hooks", message, { cause });
@@ -37,22 +37,6 @@ async function classifyOwned(path, label) {
         throw ownedPathError(label, path, cause);
     }
 }
-async function isRegularFileFollowing(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function isDirectoryFollowing(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
 async function requireExistingContained(root, path, label) {
     try {
         await assertExistingContained(root, path);
@@ -108,7 +92,7 @@ function isEmptyObject(value) {
 async function checkedFile(root, relativePath) {
     const source = resolve(root, relativePath);
     await requireExistingContained(root, source, "declared hook source");
-    if (!(await isRegularFileFollowing(source))) {
+    if (!(await isFile(source))) {
         throw hookError(`declared hook source is not a regular file: ${source}`);
     }
     return source;
@@ -132,14 +116,14 @@ export async function classifyHooks(manifest, source, upstreamRoot) {
     const hooksRootPresent = (await classifyOwned(hooksRoot, "hook subtree")) !== "missing";
     if (!declared) {
         return {
-            copyHooksSubtree: await isRegularFileFollowing(defaultConfig),
+            copyHooksSubtree: await isFile(defaultConfig),
             declaredPaths: [],
         };
     }
     const hooks = manifest.hooks;
     if (isEmptyArray(hooks)) {
         return {
-            copyHooksSubtree: await isRegularFileFollowing(defaultConfig),
+            copyHooksSubtree: await isFile(defaultConfig),
             declaredPaths: [],
         };
     }
@@ -179,7 +163,7 @@ async function checkedDestination(root, relativePath) {
         return destination;
     }
     await requireExistingContained(root, destination, "declared hook destination");
-    if (!(await isRegularFileFollowing(destination))) {
+    if (!(await isFile(destination))) {
         throw hookError(`declared hook destination is not a regular file: ${destination}`);
     }
     return destination;
@@ -218,7 +202,7 @@ async function validateSubtreeSymlinks(tree, containmentRoot) {
     catch (cause) {
         throw hookError(`hook subtree escapes or is broken: ${tree}`, cause);
     }
-    if (!(await isDirectoryFollowing(tree))) {
+    if (!(await isDirectory(tree))) {
         throw hookError(`hook subtree is not a directory: ${tree}`);
     }
     for (const path of await collectEntries(tree)) {
@@ -252,7 +236,7 @@ async function validateMaterializedDestination(destination, candidateRoot) {
         // re-owned. Discarding it would erase why containment failed.
         throw hookError(message, cause);
     }
-    if (!(await isRegularFileFollowing(destination))) {
+    if (!(await isFile(destination))) {
         throw hookError(message);
     }
 }

package/dist/harnesses/codex/lifecycle.js

@@ -23,120 +23,35 @@ const REPORT_LINES = [
     "Legacy superpowers-wrapper Codex state remains installed.",
     "Run: npx superpowers-wrapper@0.1.1 uninstall",
 ];
-function unknownState(identityState) {
-    return {
-        kind: "unknown",
-        message: `unknown adapter identity state: ${identityState}`,
-    };
-}
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:43-60::spw_require_no_legacy_state`
-export function requireNoLegacyState(identityState) {
-    if (identityState === "neither" || identityState === "manager") {
-        return { kind: "ok" };
-    }
-    if (identityState === "legacy" || identityState === "both") {
-        return { kind: "blocked", lines: BLOCKED_LINES };
-    }
-    return unknownState(identityState);
-}
-// Ported from
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:72-85::spw_report_legacy_state`.
-// Same enumeration, different disposition: this one reports and continues
-// rather than blocking, so its clean arm and its legacy arm are both non-fatal.
-export function reportLegacyState(identityState) {
-    if (identityState === "neither" || identityState === "manager") {
-        return { kind: "ok" };
-    }
-    if (identityState === "legacy" || identityState === "both") {
-        return { kind: "report", lines: REPORT_LINES };
-    }
-    return unknownState(identityState);
-}
-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"],
-                },
-            };
-    }
+function blocked(stderr) {
+    return { kind: "blocked", output: { stdout: [], stderr } };
 }
 export function codexOwnershipInspection(identityState, removalInput, conflicts) {
+    const legacy = identityState === "legacy" || identityState === "both";
     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] },
-        };
-    }
-    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: [] };
+    const installEligibility = legacy
+        ? blocked(BLOCKED_LINES)
+        : conflicts.length > 0
+            ? blocked([
+                "Conflicting unmanaged Superpowers Codex resources require manual resolution:",
+                ...conflicts.map((conflict) => `- ${conflict}`),
+                "Remove or disable each resource manually, then retry.",
+            ])
+            : { kind: "allowed" };
+    const removalVerification = pluginPresent || marketplacePresent
+        ? blocked([
+            pluginPresent
+                ? "error: owned plugin resource is still installed after removal"
+                : "error: owned marketplace resource is still registered after removal",
+        ])
+        : { kind: "allowed" };
     return {
         installEligibility,
         removalInput,
         removalVerification,
-        postRemovalOutput,
+        postRemovalOutput: legacy
+            ? { stdout: REPORT_LINES, stderr: [] }
+            : { stdout: [], stderr: [] },
         presentationValue: identityState,
         presentationConflicts: conflicts,
     };

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

@@ -39,29 +39,11 @@ export function applyManifestOverlay(source, version, path) {
     const entries = parsed.entries.map(([key, value]) => [key, value]);
     setMember(entries, "version", version);
     setMember(entries, "skills", "./skills/");
-    try {
-        return `${emitObject(entries, 0)}\n`;
-    }
-    catch (cause) {
-        throw rewrapNumberOutOfRange(cause, path);
-    }
-}
-// 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 &&
-        cause.message.startsWith(NUMBER_OUT_OF_RANGE_PREFIX)) {
-        const raw = cause.message.slice(NUMBER_OUT_OF_RANGE_PREFIX.length);
-        return new SafetyError("manifest-overlay", `JSON number out of range in ${path}: ${raw}`, { cause });
-    }
-    return cause;
+    return `${emitObject(entries, 0, path)}\n`;
 }
-function emitNumber(raw) {
+function emitNumber(raw, path) {
     if (/[.eE]/.test(raw) && !Number.isFinite(Number(raw))) {
-        throw new SafetyError("manifest-overlay", `JSON number out of range: ${raw}`);
+        throw new SafetyError("manifest-overlay", `JSON number out of range in ${path}: ${raw}`);
     }
     return raw;
 }
@@ -100,7 +82,7 @@ function translate(cause, source, path) {
     const column = (newlines[newlines.length - 1]?.length ?? 0) + 1;
     return new SafetyError("manifest-overlay", `invalid manifest JSON in ${path}: line ${line} column ${column}: ${reason}`, { cause });
 }
-function emit(value, depth) {
+function emit(value, depth, path) {
     if (value === null)
         return "null";
     if (typeof value === "boolean")
@@ -110,21 +92,21 @@ function emit(value, depth) {
     // Order matters: isRawNumber before isRawObject, and both before Array —
     // the branded records are objects too.
     if (isRawNumber(value))
-        return emitNumber(value.source);
+        return emitNumber(value.source, path);
     if (isRawObject(value))
-        return emitObject(value.entries, depth);
+        return emitObject(value.entries, depth, path);
     const inner = "  ".repeat(depth + 1);
     const outer = "  ".repeat(depth);
     if (value.length === 0)
         return "[]";
-    const items = value.map((item) => `${inner}${emit(item, depth + 1)}`);
+    const items = value.map((item) => `${inner}${emit(item, depth + 1, path)}`);
     return `[\n${items.join(",\n")}\n${outer}]`;
 }
-function emitObject(entries, depth) {
+function emitObject(entries, depth, path) {
     if (entries.length === 0)
         return "{}";
     const inner = "  ".repeat(depth + 1);
     const outer = "  ".repeat(depth);
-    const members = entries.map(([key, item]) => `${inner}${escapeNonAscii(JSON.stringify(key))}: ${emit(item, depth + 1)}`);
+    const members = entries.map(([key, item]) => `${inner}${escapeNonAscii(JSON.stringify(key))}: ${emit(item, depth + 1, path)}`);
     return `{\n${members.join(",\n")}\n${outer}}`;
 }

package/dist/harnesses/codex/paths.js

@@ -51,6 +51,35 @@ async function inspectRoot(path, root) {
 export function codexPathFailureDetails(cause) {
     return cause instanceof CodexPathError ? (cause.details ?? null) : null;
 }
+// One mapping from a preparation-separation failure to the refusal an
+// operation reports. Callers differ only in the code for a non-recovery
+// refusal and in the suffix on the recovery message.
+export function codexPathRefusal(cause, paths, preparedRoot, refusedCode, recoverySuffix) {
+    const failure = codexPathFailureDetails(cause);
+    if (failure?.kind === "inspection") {
+        if (failure.root === "recovery") {
+            return {
+                code: "recovery-required",
+                message: `cannot inspect Codex recovery state at ${paths.recoveryRoot}${recoverySuffix}`,
+            };
+        }
+        return {
+            code: refusedCode,
+            message: failure.root === "marketplace"
+                ? `cannot inspect Codex marketplace storage at ${paths.marketplaceRoot}`
+                : `cannot inspect Codex preparation root at ${preparedRoot}`,
+        };
+    }
+    return failure?.kind === "overlap"
+        ? {
+            code: "preparation-overlap",
+            message: `Codex preparation overlaps Codex published or recovery storage: ${preparedRoot}`,
+        }
+        : {
+            code: refusedCode,
+            message: `cannot validate Codex preparation storage separation at ${preparedRoot}`,
+        };
+}
 export async function assertCodexPreparationSeparate(preparedRoot, paths) {
     const recovery = await inspectRoot(paths.recoveryRoot, "recovery");
     const marketplace = await inspectRoot(paths.marketplaceRoot, "marketplace");

package/dist/harnesses/codex/prepare.js

@@ -6,10 +6,10 @@ import { ARTIFACT_RECEIPT } from "../../artifact-tree.js";
 import { assessCodexCompatibility, readCodexAssessment, writeCodexAssessment, } from "./compatibility.js";
 import { readManifest } from "./hooks.js";
 import { readGeneratedCommitLenient, readStrictProvenanceField, writeProvenance, } from "../../provenance.js";
-import { classifyPathNoFollow } from "../../safe-path.js";
+import { classifyPathNoFollow, isFile } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 import { manifestVersionForRef } from "../../upstream-version.js";
-import { assertCodexPreparationSeparate, codexPathFailureDetails, codexPaths, } from "./paths.js";
+import { assertCodexPreparationSeparate, codexPathRefusal, codexPaths, } from "./paths.js";
 import { readCodexRecovery } from "./recovery.js";
 // Order is inherited from the original prepare command; the first miss wins.
 const REQUIRED_UPSTREAM = [
@@ -25,12 +25,6 @@ const COPY_PATHS = [
     "README.md",
     "CODE_OF_CONDUCT.md",
 ];
-const RESOLUTION_KINDS = [
-    "latest-release",
-    "tag",
-    "ref",
-    "raw-commit",
-];
 function unassessedCompatibility() {
     return {
         kind: "unknown",
@@ -55,14 +49,6 @@ async function pathExists(path) {
         return false;
     }
 }
-async function regularFileExists(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
 async function owned(message, fn) {
     try {
         return await fn();
@@ -102,18 +88,8 @@ export async function validateCodexPreparationBeforeFetch(ctx) {
         await assertCodexPreparationSeparate(preparedRoot, paths);
     }
     catch (cause) {
-        const failure = codexPathFailureDetails(cause);
-        if (failure?.kind === "inspection") {
-            if (failure.root === "recovery") {
-                return failureResult("prepare", "recovery-required", `cannot inspect Codex recovery state at ${paths.recoveryRoot}`, [], []);
-            }
-            return failureResult("prepare", "prepare-failed", failure.root === "marketplace"
-                ? `cannot inspect Codex marketplace storage at ${paths.marketplaceRoot}`
-                : `cannot inspect Codex preparation root at ${preparedRoot}`, [], []);
-        }
-        return failureResult("prepare", failure?.kind === "overlap" ? "preparation-overlap" : "prepare-failed", failure?.kind === "overlap"
-            ? `Codex preparation overlaps Codex published or recovery storage: ${preparedRoot}`
-            : `cannot validate Codex preparation storage separation at ${preparedRoot}`, [], []);
+        const refusal = codexPathRefusal(cause, paths, preparedRoot, "prepare-failed", "");
+        return failureResult("prepare", refusal.code, refusal.message, [], []);
     }
     try {
         if ((await readCodexRecovery(paths)) !== null) {
@@ -124,7 +100,7 @@ export async function validateCodexPreparationBeforeFetch(ctx) {
         return failureResult("prepare", "recovery-required", `cannot inspect Codex recovery state at ${paths.recoveryRoot}`, [], []);
     }
     const template = manifestTemplate(ctx);
-    if (!(await regularFileExists(template))) {
+    if (!(await isFile(template))) {
         return failureResult("prepare", "missing-template", `missing fallback manifest template: ${template}`, [], []);
     }
     return successResult("prepare", null, []);
@@ -139,13 +115,6 @@ export async function readUpstreamManifestVersion(path) {
     }
     return value;
 }
-function asResolutionKind(value) {
-    for (const kind of RESOLUTION_KINDS) {
-        if (kind === value)
-            return kind;
-    }
-    throw prepareError(`unknown upstream resolution kind: ${value}`);
-}
 export async function prepareCodexCandidate(input, ctx) {
     let upstreamManifestVersion = "";
     let managerVersion = "";
@@ -161,7 +130,7 @@ export async function prepareCodexCandidate(input, ctx) {
             await copyPathIfPresent(join(input.upstreamRoot, name), join(input.candidateRoot, name));
         }
         const upstreamManifest = join(input.upstreamRoot, ".codex-plugin", "plugin.json");
-        if (await regularFileExists(upstreamManifest)) {
+        if (await isFile(upstreamManifest)) {
             upstreamManifestVersion =
                 await readUpstreamManifestVersion(upstreamManifest);
         }
@@ -174,13 +143,13 @@ export async function prepareCodexCandidate(input, ctx) {
         });
         managerVersion = manifestVersionForRef({
             requestedRef: input.selection.requestedRef,
-            resolutionKind: asResolutionKind(input.selection.resolutionKind),
+            resolutionKind: input.selection.resolutionKind,
             resolvedRef: input.selection.resolvedRef,
             commit: input.selection.desiredCommit,
         });
     }
     catch (cause) {
-        // owned()/asResolutionKind(), readManifest(), and writeProvenance replace
+        // owned(), readManifest(), and writeProvenance replace
         // every subordinate failure with controlled preparation, hook, or
         // provenance text. Re-emitting those owned diagnostics is therefore safe.
         // codexBuild stays below this catch because it deliberately rethrows
@@ -203,13 +172,10 @@ export async function prepareCodexCandidate(input, ctx) {
     if (!built.outcome.ok) {
         return { status: built.status, outcome: built.outcome };
     }
-    if (built.status !== 0) {
-        return failureResult("build", "invalid-status", "adapter reported failure without an error outcome", [], built.outcome.messages);
-    }
     const compatibility = await assessCodexCompatibility(input.upstreamRoot, input.selection);
     if (compatibility.kind === "supported") {
         try {
-            await writeCodexAssessment(input.candidateRoot, input.selection, (await regularFileExists(join(input.upstreamRoot, ".codex-plugin/plugin.json")))
+            await writeCodexAssessment(input.candidateRoot, input.selection, (await isFile(join(input.upstreamRoot, ".codex-plugin/plugin.json")))
                 ? "upstream"
                 : "fallback");
         }

package/dist/harnesses/codex/presentation.js

@@ -90,7 +90,7 @@ function verificationOutput(kind, hint) {
     return { stdout: [], stderr };
 }
 function safeHint(value) {
-    return typeof value === "string" && !hasTerminalControl(value) ? value : "";
+    return hasTerminalControl(value) ? "" : value;
 }
 export function codexInstallReceipt(missingHint, mismatchHint) {
     return {

package/dist/harnesses/codex/publication.js

@@ -3,17 +3,16 @@ import { failureResult, successResult, } from "../../adapter-result.js";
 import { beginDirectoryPublication, } from "../../atomic.js";
 import { digestArtifactTree } from "../../artifact-tree.js";
 import { assertNoFollowType, classifyPathNoFollow } from "../../safe-path.js";
-import { codexInspectControl, codexInspectOwnership, codexInstallRefreshMode, codexRemove, codexReadNativeState, } from "./adapter.js";
+import { codexInspectOwnership, codexInstallRefreshMode, codexRemove, codexReadNativeState, } from "./adapter.js";
 import { readCodexAssessment } from "./compatibility.js";
 import { readCodexMarketplace, stageCodexMarketplace, } from "./marketplace.js";
-import { assertCodexPreparationSeparate, codexPathFailureDetails, codexPaths, } from "./paths.js";
+import { assertCodexPreparationSeparate, codexPathRefusal, codexPaths, } from "./paths.js";
 import { codexPreparationLocation } from "./prepare.js";
 import { beginCodexRecovery, finishCodexRecovery, readCodexRecovery, verifyCodexRecovery, } from "./recovery.js";
 import { hasFilesystemAccessFailure, pathsEqual } from "./state.js";
 const DEFAULTS = {
     readNative: codexReadNativeState,
     inspectOwnership: codexInspectOwnership,
-    inspectControl: codexInspectControl,
     beginPublication: beginDirectoryPublication,
 };
 const REMOVAL_DEFAULTS = {
@@ -30,18 +29,7 @@ function acceptedNative(result) {
     if (result.status !== 0 || !result.outcome.ok) {
         throw new Error("Codex native observation failed");
     }
-    const value = result.outcome.result;
-    if (typeof value.marketplaceRoot !== "string" &&
-        value.marketplaceRoot !== null) {
-        throw new Error("Codex native observation is malformed");
-    }
-    if (typeof value.pluginPresent !== "boolean" ||
-        typeof value.pluginEnabled !== "boolean" ||
-        (typeof value.activeVersion !== "string" && value.activeVersion !== null) ||
-        (typeof value.activeRoot !== "string" && value.activeRoot !== null)) {
-        throw new Error("Codex native observation is malformed");
-    }
-    return value;
+    return result.outcome.result;
 }
 function requireOwnership(result) {
     if (result.status !== 0 || !result.outcome.ok) {
@@ -51,14 +39,6 @@ function requireOwnership(result) {
         throw new Error("Codex ownership blocks publication");
     }
 }
-function requireControl(result) {
-    if (result.status !== 0 || !result.outcome.ok) {
-        throw new Error("Codex inspection failed");
-    }
-    if (result.outcome.result?.mutationEligibility?.kind !== "allowed") {
-        throw new Error("Codex update control blocks publication");
-    }
-}
 function sameNative(left, right) {
     return (left.marketplaceRoot === right.marketplaceRoot &&
         left.pluginPresent === right.pluginPresent &&
@@ -247,9 +227,6 @@ async function requireEligibility(ctx, dependencies, messages) {
     const ownership = await dependencies.inspectOwnership(ctx);
     messages.push(...ownership.outcome.messages);
     requireOwnership(ownership);
-    const control = await dependencies.inspectControl(ctx);
-    messages.push(...control.outcome.messages);
-    requireControl(control);
 }
 async function verifyPrevious(pending, previous) {
     const current = await readCodexMarketplace(pending.paths.marketplaceRoot);
@@ -388,20 +365,8 @@ export async function installCodexMarketplace(artifact, ctx, activate, dependenc
         await assertCodexPreparationSeparate(preparedRoot, paths);
     }
     catch (cause) {
-        const failure = codexPathFailureDetails(cause);
-        if (failure?.kind === "inspection") {
-            if (failure.root === "recovery") {
-                return fail("recovery-required", `cannot inspect Codex recovery state at ${paths.recoveryRoot}; recovery is required before mutation`, messages);
-            }
-            return fail("activation-refused", failure.root === "marketplace"
-                ? `cannot inspect Codex marketplace storage at ${paths.marketplaceRoot}`
-                : `cannot inspect Codex preparation root at ${preparedRoot}`, messages);
-        }
-        return fail(failure?.kind === "overlap"
-            ? "preparation-overlap"
-            : "activation-refused", failure?.kind === "overlap"
-            ? `Codex preparation overlaps Codex published or recovery storage: ${preparedRoot}`
-            : `cannot validate Codex preparation storage separation at ${preparedRoot}`, messages);
+        const refusal = codexPathRefusal(cause, paths, preparedRoot, "activation-refused", "; recovery is required before mutation");
+        return fail(refusal.code, refusal.message, messages);
     }
     let pending;
     let publication;

package/dist/harnesses/codex/state.js

@@ -83,11 +83,6 @@ async function comparablePath(path) {
 export async function pathsEqual(a, b) {
     return (await comparablePath(a)) === (await comparablePath(b));
 }
-function preserveFailure(result) {
-    if (result.outcome.ok)
-        throw new Error("expected adapter failure");
-    return failureResult(result.outcome.operation, result.outcome.error.code, result.outcome.error.message, result.outcome.error.hints, result.outcome.messages);
-}
 function mismatch(reason, messages = [], observedIdentity = "") {
     return successResult("inspect-codex-installed", { kind: "mismatch", observedIdentity }, [
         ...messages,
@@ -116,7 +111,7 @@ export async function inspectCodexInstallation(selection, ctx, readNative = code
     const operation = "inspect-codex-installed";
     const native = await readNative(ctx);
     if (!native.outcome.ok)
-        return preserveFailure(native);
+        return { status: native.status, outcome: native.outcome };
     const messages = native.outcome.messages;
     const paths = codexPaths(ctx.env ?? {}, process.cwd());
     let marketplace;

package/dist/harnesses/codex/stored-state.js

@@ -3,6 +3,7 @@ import { lstat, open, readdir } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
 import { parse, TomlDate } from "smol-toml";
 import { SafetyError } from "../../safety-error.js";
+import { isErrno } from "../../safe-path.js";
 import { codexHome } from "./paths.js";
 const CONFIG_LIMIT = 1024 * 1024;
 const CONFIG_DEPTH_LIMIT = 64;
@@ -15,12 +16,6 @@ const MARKETPLACE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
 function storedError(message, cause) {
     return new SafetyError("codex-stored-state", message, { cause });
 }
-function isErrno(cause, code) {
-    return (cause !== null &&
-        typeof cause === "object" &&
-        "code" in cause &&
-        cause.code === code);
-}
 function table(value, name) {
     if (value === undefined)
         return {};

package/dist/harnesses/opencode/config.js

@@ -286,8 +286,7 @@ async function writeObservedOpenCodeConfig(observation, outputBytes, expected) {
 export async function removeObservedOpenCodeEntry(observation, key, index) {
     const path = observation.document.path;
     try {
-        const originalText = decodeConfig(observation.bytes, path);
-        const original = parseOpenCodeConfig(originalText, path);
+        const original = observation.document;
         const output = removeOpenCodeEntry(original, key, index);
         const outputBytes = Buffer.from(output, "utf8");
         const expected = original.entries.filter((entry) => entry.key !== key || entry.index !== index);
@@ -300,8 +299,7 @@ export async function removeObservedOpenCodeEntry(observation, key, index) {
 export async function addObservedOpenCodeEntry(observation, key, spec) {
     const path = observation.document.path;
     try {
-        const originalText = decodeConfig(observation.bytes, path);
-        const original = parseOpenCodeConfig(originalText, path);
+        const original = observation.document;
         const output = addOpenCodeEntry(original, key, spec);
         const outputBytes = Buffer.from(output, "utf8");
         const expected = parseOpenCodeConfig(output, path).entries;

package/dist/harnesses/opencode/discovery.js

@@ -163,11 +163,7 @@ async function inspectPluginEntry(observation, entry, state, allowManaged = true
         const canonical = await canonicalizeProspectivePath(local);
         if (canonical === state.installedRoot) {
             if (allowManaged)
-                state.managedEntries.push({
-                    observation,
-                    entry,
-                    canonicalRoot: canonical,
-                });
+                state.managedEntries.push({ observation, entry });
             else
                 addBlocked(state, `${OPEN_CODE_UNOWNED_MANAGER_INPUT}: ${observation.document.path}`);
             return;