superpowers-manager 0.7.3 → 0.9.0

package/dist/harnesses/claude-code/prepare.js

@@ -0,0 +1,117 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { applyEdits, modify } from "jsonc-parser";
+import { failureResult, successResult, } from "../../adapter-result.js";
+import { readArtifactFile, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
+import { SEMVER_RE } from "../../domain/refs.js";
+import { classifyPathNoFollow } from "../../safe-path.js";
+import { SafetyError } from "../../safety-error.js";
+import { validateSource } from "../../selection.js";
+import { createSnapshotReceipts, } from "../../snapshot-package.js";
+import { createSnapshotPreparation } from "../../snapshot-prepare.js";
+import { manifestVersionForRef } from "../../upstream-version.js";
+import { assertClaudeCodeStorageSafe, claudeCodePaths } from "./paths.js";
+const CLAUDE_CODE_MANIFEST = ".claude-plugin/plugin.json";
+const GENERATION = "claude-code-native-plugin-v1";
+async function assessClaudeCodeCompatibility(root, selection) {
+    try {
+        validateSource(selection.effectiveSource);
+        const manifest = await readArtifactObject(root, join(root, CLAUDE_CODE_MANIFEST));
+        if (manifest.name !== "superpowers" ||
+            typeof manifest.version !== "string" ||
+            !SEMVER_RE.test(manifest.version))
+            throw new Error("manifest");
+        await validateNativeSkill(root);
+        const hooks = join(root, "hooks", "hooks.json");
+        if ((await classifyPathNoFollow(hooks)) !== "missing")
+            await readArtifactObject(root, hooks);
+        return {
+            kind: "supported",
+            generation: GENERATION,
+            reason: "native Claude Code plugin",
+        };
+    }
+    catch {
+        return {
+            kind: "unsupported",
+            reason: `Claude Code package does not provide a native Claude Code plugin: ${root}`,
+        };
+    }
+}
+// The ref-aware manifest version for this selection. Two selections of the
+// same commit (for example a tag and the raw SHA) yield different versions.
+export function expectedClaudeCodeVersion(selection) {
+    return manifestVersionForRef({
+        requestedRef: selection.requestedRef,
+        resolutionKind: selection.resolutionKind,
+        resolvedRef: selection.resolvedRef,
+        commit: selection.desiredCommit,
+    });
+}
+// A targeted edit of the one value: every other upstream byte, including
+// formatting and unknown fields, is preserved.
+async function rewriteClaudeCodeVersion(root, selection) {
+    const version = expectedClaudeCodeVersion(selection);
+    const path = join(root, CLAUDE_CODE_MANIFEST);
+    await readArtifactObject(root, path);
+    const text = (await readArtifactFile(root, path)).toString("utf8");
+    await writeFile(path, applyEdits(text, modify(text, ["version"], version, {})));
+}
+const receipts = createSnapshotReceipts({
+    harness: "claude-code",
+    label: "Claude Code",
+    strictGeneration: true,
+    assessCompatibility: assessClaudeCodeCompatibility,
+});
+export const readClaudeCodeReceipt = receipts.readReceipt;
+export const readClaudeCodePackageAssessment = receipts.readAssessment;
+export async function readClaudeCodeManifestVersion(root) {
+    const manifest = await readArtifactObject(root, join(root, CLAUDE_CODE_MANIFEST));
+    if (typeof manifest.version !== "string")
+        throw new SafetyError("claude-code-package", `Claude Code manifest has no version: ${root}`);
+    return manifest.version;
+}
+export async function validateClaudeCodePreparationBeforeFetch(ctx) {
+    try {
+        await assertClaudeCodeStorageSafe(claudeCodePaths(ctx.env ?? {}, process.cwd()));
+        return successResult("prepare", null, []);
+    }
+    catch {
+        return failureResult("prepare", "invalid-package", "cannot validate Claude Code artifact storage", [], []);
+    }
+}
+const preparation = createSnapshotPreparation({
+    harness: "claude-code",
+    label: "Claude Code",
+    paths: claudeCodePaths,
+    assessCompatibility: assessClaudeCodeCompatibility,
+    readAssessment: readClaudeCodePackageAssessment,
+    rewrite: rewriteClaudeCodeVersion,
+});
+export const claudeCodePreparationLocation = preparation.preparationLocation;
+export const prepareClaudeCodeCandidate = preparation.prepareCandidate;
+// The shared check compares only commit and source, so a same-commit ref
+// change would otherwise leave a prepared tree carrying the old version.
+export async function inspectClaudeCodePrepared(selection, ctx) {
+    const result = await preparation.inspectPrepared(selection, ctx);
+    if (!result.outcome.ok || result.outcome.result.kind !== "current")
+        return result;
+    const root = result.outcome.result.artifact.root;
+    try {
+        if ((await readClaudeCodeManifestVersion(root)) ===
+            expectedClaudeCodeVersion(selection))
+            return result;
+    }
+    catch {
+        return failureResult("inspect-prepared", "invalid-package", `cannot inspect Claude Code prepared artifact: ${root}`, [], []);
+    }
+    return successResult("inspect-prepared", {
+        kind: "needs-prepare",
+        observedIdentity: result.outcome.result.observedIdentity,
+        compatibility: {
+            kind: "unknown",
+            reason: "Claude Code prepared version does not match the selection",
+        },
+    }, []);
+}
+export const readClaudeCodePrepared = preparation.readPrepared;

package/dist/harnesses/claude-code/presentation.js

@@ -0,0 +1,25 @@
+import { displaySource } from "../../selection.js";
+import { createSnapshotPresentation, probeOutput, } from "../../snapshot-presentation.js";
+import { displayPath } from "../../validator.js";
+const renderProbe = (facts) => {
+    const fields = [
+        ["harness", "claude-code"],
+        ["desired_commit", facts.selection.desiredCommit],
+        ["upstream_source_origin", facts.selection.upstreamSourceOrigin],
+        ["effective_source", displaySource(facts.selection.effectiveSource)],
+        ["prepared_identity", facts.prepared.observedIdentity],
+        ["installed_identity", facts.installed.observedIdentity],
+        ["installation_state", facts.installed.kind],
+        ["resource_state", facts.resourceState ?? "idle"],
+        ["ownership", facts.ownership.presentationValue],
+        ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],
+        ["update_control", facts.control.presentationValue],
+        ["compatibility", facts.compatibility.kind],
+        ["compatibility_reason", facts.compatibility.reason],
+        ["status", facts.status],
+    ].map(([key, value]) => [key, displayPath(value)]);
+    return probeOutput(fields);
+};
+export const claudeCodePresentation = createSnapshotPresentation("Claude Code", renderProbe, (input) => input.registration === "absent" &&
+    !input.pluginInstalled &&
+    !input.published);

package/dist/harnesses/claude-code/state.js

@@ -0,0 +1,253 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { readArtifactFile } from "../../artifact-tree.js";
+import { inspectionFailure, successResult, } from "../../adapter-result.js";
+import { canonicalizeProspectivePath, classifyPathNoFollow, } from "../../safe-path.js";
+import { observeSnapshot, sameSnapshotSource, } from "../../snapshot-package.js";
+import { displayPath } from "../../validator.js";
+import { readClaudeCodeState, runClaude, } from "./native.js";
+import { assertClaudeCodeStorageSafe, claudeCodePaths, } from "./paths.js";
+import { expectedClaudeCodeVersion, readClaudeCodeManifestVersion, readClaudeCodePackageAssessment, readClaudeCodeReceipt, } from "./prepare.js";
+export const CLAUDE_CODE_MARKETPLACE = "superpowers-manager";
+export const CLAUDE_CODE_PLUGIN_ID = "superpowers@superpowers-manager";
+export const CLAUDE_CODE_MARKETPLACE_BYTES = Buffer.from(JSON.stringify({
+    name: CLAUDE_CODE_MARKETPLACE,
+    owner: { name: CLAUDE_CODE_MARKETPLACE },
+    plugins: [{ name: "superpowers", source: "./plugins/superpowers" }],
+}) + "\n");
+const SYNCED_ID = "superpowers@synced";
+const DISPLAYABLE_ID = /^superpowers@[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/;
+function blocked(...stderr) {
+    return {
+        kind: "blocked",
+        output: { stdout: [], stderr: stderr.map((line) => displayPath(line)) },
+    };
+}
+function pathsFor(ctx) {
+    return claudeCodePaths(ctx.env ?? {}, process.cwd());
+}
+export async function marketplaceRegistration(native, paths) {
+    const entries = native.marketplaces.filter((entry) => entry.name === CLAUDE_CODE_MARKETPLACE);
+    if (entries.length === 0)
+        return "absent";
+    if (entries.length > 1)
+        throw new Error("ambiguous Claude Code marketplace");
+    const entry = entries[0];
+    if (entry.source !== "directory" || entry.path === null)
+        return "foreign";
+    return (await canonicalizeProspectivePath(entry.path)) ===
+        (await canonicalizeProspectivePath(paths.marketplaceRoot))
+        ? "owned"
+        : "foreign";
+}
+export function managerPlugin(native) {
+    const entries = native.plugins.filter((plugin) => plugin.id === CLAUDE_CODE_PLUGIN_ID && plugin.scope === "user");
+    if (entries.length > 1)
+        throw new Error("ambiguous Claude Code plugin");
+    return entries[0];
+}
+// An unregistered directory is removable only when every entry is part of
+// the Manager's marketplace layout. Empty known directories are safe crash
+// residue; a present snapshot must have a valid Manager receipt and digest.
+export async function inspectClaudeCodeMarketplaceStorage(paths) {
+    const rootKind = await classifyPathNoFollow(paths.marketplaceRoot);
+    if (rootKind === "missing")
+        return "absent";
+    if (rootKind !== "directory")
+        return "unverified";
+    try {
+        await assertClaudeCodeStorageSafe(paths);
+        // Probe must present recovery before judging a crash leftover's contents.
+        // Mutation paths still refuse these siblings before any native call.
+        if ((await leftoverPublicationMaterial(paths)).length > 0)
+            return "recovery";
+        const known = (entries, allowed) => entries.every((entry) => allowed.includes(entry));
+        if (!known(await readdir(paths.marketplaceRoot), [
+            ".claude-plugin",
+            "plugins",
+        ]))
+            return "unverified";
+        const metadataRoot = join(paths.marketplaceRoot, ".claude-plugin");
+        if ((await classifyPathNoFollow(metadataRoot)) !== "missing") {
+            if (!known(await readdir(metadataRoot), ["marketplace.json"]))
+                return "unverified";
+        }
+        const manifestKind = await classifyPathNoFollow(paths.marketplaceManifest);
+        if (manifestKind !== "missing") {
+            if (manifestKind !== "regular-file" ||
+                !(await readArtifactFile(paths.marketplaceRoot, paths.marketplaceManifest, CLAUDE_CODE_MARKETPLACE_BYTES.length)).equals(CLAUDE_CODE_MARKETPLACE_BYTES))
+                return "unverified";
+        }
+        if ((await classifyPathNoFollow(paths.pluginsRoot)) !== "missing") {
+            if (!known(await readdir(paths.pluginsRoot), ["superpowers"]))
+                return "unverified";
+            if ((await classifyPathNoFollow(paths.pluginRoot)) !== "missing") {
+                const snapshot = await observeSnapshot(paths.pluginRoot, readClaudeCodeReceipt);
+                if (snapshot.kind !== "owned")
+                    return "unverified";
+            }
+        }
+        return "owned";
+    }
+    catch {
+        return "unverified";
+    }
+}
+// A synced copy is reported as not loaded whenever another origin provides the
+// same name, so it never duplicates the Manager plugin.
+function conflicts(native) {
+    return native.plugins
+        .filter((plugin) => plugin.enabled &&
+        plugin.id.startsWith("superpowers@") &&
+        plugin.id !== CLAUDE_CODE_PLUGIN_ID &&
+        plugin.id !== SYNCED_ID)
+        .map((plugin) => DISPLAYABLE_ID.test(plugin.id)
+        ? plugin.id
+        : "a Claude Code plugin with a non-displayable Superpowers identity");
+}
+async function observeFacts(ctx, run) {
+    const paths = pathsFor(ctx);
+    await assertClaudeCodeStorageSafe(paths);
+    const native = await readClaudeCodeState(ctx, run);
+    const [registration, snapshot, marketplaceKind] = await Promise.all([
+        marketplaceRegistration(native, paths),
+        observeSnapshot(paths.pluginRoot, readClaudeCodeReceipt),
+        classifyPathNoFollow(paths.marketplaceRoot),
+    ]);
+    if (registration === "absent" &&
+        marketplaceKind !== "missing" &&
+        (await inspectClaudeCodeMarketplaceStorage(paths)) === "unverified")
+        throw new Error("unverified Claude Code marketplace storage");
+    return {
+        paths,
+        registration,
+        marketplaceSource: native.marketplaces.find((entry) => entry.name === CLAUDE_CODE_MARKETPLACE),
+        plugin: managerPlugin(native),
+        conflicts: conflicts(native),
+        snapshot,
+        published: marketplaceKind !== "missing",
+    };
+}
+function installDecision(facts) {
+    if (facts.registration === "foreign")
+        return blocked(`error: a Claude Code marketplace named ${CLAUDE_CODE_MARKETPLACE} is registered from another source; remove it manually, then retry:`, `  source: ${facts.marketplaceSource?.source ?? "unknown"}; path: ${facts.marketplaceSource?.path ?? "unknown"}`, `  claude plugin marketplace remove ${CLAUDE_CODE_MARKETPLACE}`);
+    if (facts.conflicts.length > 0)
+        return blocked("error: another Superpowers Claude Code plugin is enabled; disable it manually, then retry:", ...facts.conflicts.map((id) => DISPLAYABLE_ID.test(id) ? `  claude plugin disable ${id}` : `  ${id}`));
+    return { kind: "allowed" };
+}
+export async function inspectClaudeCodeOwnership(ctx, run = runClaude) {
+    const operation = "inspect-claude-code-ownership";
+    try {
+        const facts = await observeFacts(ctx, run);
+        if (facts.snapshot.kind === "unverified")
+            throw new Error("unverified Manager snapshot");
+        const removalVerification = facts.registration === "owned" || facts.plugin !== undefined
+            ? blocked("error: Claude Code still lists the Manager marketplace or plugin after removal")
+            : facts.published
+                ? blocked(`error: the Manager-owned Claude Code marketplace is still present at ${facts.paths.marketplaceRoot}`)
+                : { kind: "allowed" };
+        const presentationValue = facts.registration === "foreign"
+            ? "foreign marketplace registration"
+            : facts.snapshot.kind === "owned"
+                ? facts.registration === "owned"
+                    ? `managed ${facts.snapshot.digest}`
+                    : `managed snapshot ${facts.snapshot.digest}`
+                : facts.registration === "owned"
+                    ? "managed registration without a snapshot"
+                    : "absent";
+        return successResult(operation, {
+            installEligibility: installDecision(facts),
+            removalInput: {
+                registration: facts.registration,
+                pluginInstalled: facts.plugin !== undefined,
+                published: facts.published,
+            },
+            removalVerification,
+            postRemovalOutput: { stdout: [], stderr: [] },
+            presentationValue,
+            presentationConflicts: facts.conflicts,
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "Claude Code ownership");
+    }
+}
+export async function inspectClaudeCodeInstalled(selection, ctx, run = runClaude) {
+    const operation = "inspect-claude-code-installed";
+    let facts;
+    try {
+        facts = await observeFacts(ctx, run);
+    }
+    catch {
+        return inspectionFailure(operation, "Claude Code installed state");
+    }
+    const mismatch = (observedIdentity) => successResult(operation, { kind: "mismatch", observedIdentity }, []);
+    if (facts.snapshot.kind === "absent")
+        return facts.registration === "absent" &&
+            facts.plugin === undefined &&
+            !facts.published
+            ? successResult(operation, { kind: "absent", observedIdentity: "" }, [])
+            : mismatch("registered without an installed snapshot");
+    if (facts.snapshot.kind === "unverified")
+        return mismatch("unverified installed snapshot");
+    const observed = facts.snapshot.digest;
+    const plugin = facts.plugin;
+    if (facts.registration !== "owned" ||
+        plugin === undefined ||
+        !plugin.enabled ||
+        plugin.errorCount > 0 ||
+        facts.conflicts.length > 0)
+        return mismatch(observed);
+    try {
+        const prepared = await readClaudeCodePackageAssessment(facts.paths.preparedRoot);
+        if (prepared.compatibility.kind !== "supported" ||
+            prepared.receipt.commit !== selection.desiredCommit ||
+            !sameSnapshotSource(prepared.receipt.source, selection.effectiveSource) ||
+            facts.snapshot.receipt.commit !== prepared.receipt.commit ||
+            facts.snapshot.digest !== prepared.receipt.digest ||
+            plugin.version !== expectedClaudeCodeVersion(selection) ||
+            (await readClaudeCodeManifestVersion(facts.paths.pluginRoot)) !==
+                expectedClaudeCodeVersion(selection))
+            return mismatch(observed);
+    }
+    catch {
+        return mismatch(observed);
+    }
+    return successResult(operation, { kind: "current", observedIdentity: observed }, []);
+}
+// Filesystem-only: any `.superpowers.*` sibling is a publication backup or a
+// staging directory left by an interrupted install.
+export async function leftoverPublicationMaterial(paths) {
+    if ((await classifyPathNoFollow(paths.pluginsRoot)) === "missing")
+        return [];
+    return (await readdir(paths.pluginsRoot))
+        .filter((name) => name.startsWith(".superpowers."))
+        .sort()
+        .map((name) => join(paths.pluginsRoot, name));
+}
+export async function inspectClaudeCodeControl(ctx) {
+    const operation = "inspect-claude-code-control";
+    try {
+        const paths = pathsFor(ctx);
+        await assertClaudeCodeStorageSafe(paths);
+        const leftovers = await leftoverPublicationMaterial(paths);
+        if (leftovers.length === 0)
+            return successResult(operation, {
+                probeEligibility: { kind: "allowed" },
+                mutationEligibility: { kind: "allowed" },
+                presentationValue: "clear",
+            }, []);
+        // Shared probe requires both decisions blocked whenever recovery is
+        // required (`src/commands/probe.ts::function coherentControl`).
+        const decision = blocked("error: Claude Code recovery required; inspect and remove leftover publication material manually:", ...leftovers.map((path) => `  ${path}`));
+        return successResult(operation, {
+            probeEligibility: decision,
+            mutationEligibility: decision,
+            presentationValue: `recovery required at ${leftovers.join(", ")}`,
+            recoveryState: "required",
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "Claude Code update control");
+    }
+}

package/dist/harnesses/codex/adapter.js

@@ -2,8 +2,8 @@ import { Buffer } from "node:buffer";
 import { execFile } from "node:child_process";
 import { constants } from "node:fs";
 import { access, copyFile, mkdir, readFile, realpath, stat, writeFile, } from "node:fs/promises";
-import { delimiter, isAbsolute, join } from "node:path";
-import { AdapterMessageLog, failureResult, hasTerminalControl, successResult, } from "../../adapter-result.js";
+import { delimiter, join } from "node:path";
+import { AdapterMessageLog, failureResult, successResult, } from "../../adapter-result.js";
 import { activePluginVersionFromJson, codexInstalledPluginsFromJson, installedListingHas, marketplaceRootFromJson, } from "./json.js";
 import { CODEX_LEGACY_PLUGIN_ID, CODEX_MANAGER_PLUGIN_ID, inspectCodexConflicts, } from "./conflicts.js";
 import { oneLine } from "../../cli-arguments.js";
@@ -16,6 +16,7 @@ import { applyManifestOverlay } from "./manifest-overlay.js";
 import { readCodexBuildSource } from "../../provenance.js";
 import { codexOwnershipInspection } from "./lifecycle.js";
 import { codexInstallReceipt } from "./presentation.js";
+import { isFile } from "../../safe-path.js";
 const PLUGIN_ID = CODEX_MANAGER_PLUGIN_ID;
 const MARKETPLACE_NAME = "superpowers-manager";
 const LEGACY_PLUGIN_ID = CODEX_LEGACY_PLUGIN_ID;
@@ -110,7 +111,7 @@ export function mapCodexLaunchFailure(cause, codexBin) {
         signal: null,
         stdout: Buffer.alloc(0),
         // Trailing newline matches how a real process writes stderr;
-        // `src/adapter-result.ts:133::appendBytes` splits on newlines and terminates the
+        // `src/adapter-result.ts:132::appendBytes` splits on newlines and terminates the
         // final chunk at end-of-buffer either way.
         stderr: Buffer.from(`cannot launch Codex command ${codexBin}${detail}\n`, "utf8"),
     };
@@ -160,42 +161,14 @@ async function requireCodex(codexBin, env) {
         fail("command-not-found", `required Codex command not found: ${codexBin}`);
     }
 }
-async function directoryExists(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function fileExists(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
 async function runBuild(input, env, log) {
     const { upstreamRoot, candidateRoot, fallbackManifest } = input;
-    if (!isAbsolute(upstreamRoot)) {
-        fail("invalid-arguments", "--upstream-root must be an absolute path");
-    }
-    if (!isAbsolute(candidateRoot)) {
-        fail("invalid-arguments", "--candidate-root must be an absolute path");
-    }
-    if (!(await directoryExists(upstreamRoot))) {
-        fail("invalid-arguments", `upstream root not found: ${upstreamRoot}`);
-    }
-    if (!(await directoryExists(candidateRoot))) {
-        fail("invalid-arguments", `candidate root not found: ${candidateRoot}`);
-    }
-    if (!(await fileExists(fallbackManifest))) {
+    if (!(await isFile(fallbackManifest))) {
         fail("invalid-arguments", `fallback manifest not found: ${fallbackManifest}`);
     }
     const candidateManifest = join(candidateRoot, ".codex-plugin/plugin.json");
     const upstreamManifest = join(upstreamRoot, ".codex-plugin/plugin.json");
-    const manifestSource = (await fileExists(upstreamManifest))
+    const manifestSource = (await isFile(upstreamManifest))
         ? "upstream"
         : "fallback";
     try {
@@ -254,8 +227,8 @@ async function runBuild(input, env, log) {
         // applyManifestOverlay's own messages already name the manifest
         // path — three are the frozen CPython wording, and the fourth (the
         // numeric-overflow diagnostic, which has no CPython oracle wording
-        // to match) now carries the path via its own rewrap in
-        // src/harnesses/codex/manifest-overlay.ts. Emit as-is, with no added prefix — a
+        // to match) carries the path from src/harnesses/codex/manifest-overlay.ts's
+        // emitter. Emit as-is, with no added prefix — a
         // prefix here would double up the path these messages already
         // name.
         log.appendText("stderr", oneLine(cause));
@@ -309,12 +282,6 @@ async function runBuild(input, env, log) {
     return {};
 }
 async function runInstall(packageRoot, env, log) {
-    if (!isAbsolute(packageRoot)) {
-        fail("invalid-arguments", "--package-root must be an absolute path");
-    }
-    if (!(await directoryExists(packageRoot))) {
-        fail("invalid-arguments", `package root not found: ${packageRoot}`);
-    }
     const codexBin = env.SUPERPOWERS_CODEX || "codex";
     const refreshMode = codexInstallRefreshMode(env);
     await requireCodex(codexBin, env);
@@ -392,11 +359,6 @@ async function runUninstall(input, env, log) {
     return {};
 }
 function ownershipFromResources(pluginPresent, marketplacePresent, legacyPresent, conflicts) {
-    if (conflicts.some((item) => typeof item !== "string" ||
-        item.length === 0 ||
-        hasTerminalControl(item))) {
-        fail("malformed-result", "expected an array of strings at conflicts");
-    }
     const managerPresent = pluginPresent || marketplacePresent;
     const identityState = managerPresent
         ? legacyPresent
@@ -407,14 +369,27 @@ function ownershipFromResources(pluginPresent, marketplacePresent, legacyPresent
             : "neither";
     return codexOwnershipInspection(identityState, { pluginPresent, marketplacePresent }, conflicts);
 }
+async function ownershipAfterListingFailure(context, env, message) {
+    const stored = await storedStateAfterListingFailure(env, "inspect-failed", message);
+    const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedPlugins);
+    return ownershipFromResources(stored.managerPluginPresent, true, stored.legacyPluginPresent || stored.legacyMarketplaceRoot !== null, conflicts);
+}
+async function nativeAfterListingFailure(env, message) {
+    const stored = await storedStateAfterListingFailure(env, "inspect-failed", message);
+    return {
+        marketplaceRoot: stored.managerMarketplaceRoot,
+        pluginPresent: stored.managerPluginPresent,
+        pluginEnabled: stored.managerPluginEnabled,
+        activeVersion: null,
+        activeRoot: null,
+    };
+}
 async function runOwnership(context, env, log) {
     const codexBin = env.SUPERPOWERS_CODEX || "codex";
     await requireCodex(codexBin, env);
     const plugins = await listingCommand(log, codexBin, ["plugin", "list", "--json"], env);
     if (commandFailed(plugins)) {
-        const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex plugins via '${codexBin} plugin list --json'`);
-        const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedPlugins);
-        return ownershipFromResources(stored.managerPluginPresent, true, stored.legacyPluginPresent || stored.legacyMarketplaceRoot !== null, conflicts);
+        return await ownershipAfterListingFailure(context, env, `cannot list Codex plugins via '${codexBin} plugin list --json'`);
     }
     let managerPlugin;
     let legacyPlugin;
@@ -430,9 +405,7 @@ async function runOwnership(context, env, log) {
     }
     const marketplaces = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
     if (commandFailed(marketplaces)) {
-        const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
-        const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedPlugins);
-        return ownershipFromResources(stored.managerPluginPresent, true, stored.legacyPluginPresent || stored.legacyMarketplaceRoot !== null, conflicts);
+        return await ownershipAfterListingFailure(context, env, `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
     }
     let managerMarketplace;
     let legacyMarketplace;
@@ -484,14 +457,7 @@ export function codexReadNativeState(context) {
         await requireCodex(codexBin, env);
         const plugins = await listingCommand(log, codexBin, ["plugin", "list", "--json"], env);
         if (commandFailed(plugins)) {
-            const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex plugins via '${codexBin} plugin list --json'`);
-            return {
-                marketplaceRoot: stored.managerMarketplaceRoot,
-                pluginPresent: stored.managerPluginPresent,
-                pluginEnabled: stored.managerPluginEnabled,
-                activeVersion: null,
-                activeRoot: null,
-            };
+            return await nativeAfterListingFailure(env, `cannot list Codex plugins via '${codexBin} plugin list --json'`);
         }
         let manager;
         let activeVersion;
@@ -512,14 +478,7 @@ export function codexReadNativeState(context) {
         }
         const marketplaces = await listingCommand(log, codexBin, ["plugin", "marketplace", "list", "--json"], env);
         if (commandFailed(marketplaces)) {
-            const stored = await storedStateAfterListingFailure(env, "inspect-failed", `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
-            return {
-                marketplaceRoot: stored.managerMarketplaceRoot,
-                pluginPresent: stored.managerPluginPresent,
-                pluginEnabled: stored.managerPluginEnabled,
-                activeVersion: null,
-                activeRoot: null,
-            };
+            return await nativeAfterListingFailure(env, `cannot list Codex marketplaces via '${codexBin} plugin marketplace list --json'`);
         }
         let marketplaceRoot;
         try {

package/dist/harnesses/codex/conflicts.js

@@ -1,17 +1,12 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { isAbsenceError } from "../../safe-path.js";
 export const CODEX_MANAGER_PLUGIN_ID = "superpowers@superpowers-manager";
 export const CODEX_LEGACY_PLUGIN_ID = "superpowers@superpowers-wrapper";
 const SUPERPOWERS_PLUGIN_PREFIX = "superpowers@";
 const DISPLAYABLE_PLUGIN_ID = /^superpowers@[A-Za-z0-9][A-Za-z0-9._-]*/;
 const NATIVE_ROUTE = ".agents/skills/superpowers";
 const NATIVE_ROUTE_CONFLICT = `native Codex skills route ~/${NATIVE_ROUTE} has indeterminate activity`;
-function isMissingPath(cause) {
-    if (cause === null || typeof cause !== "object" || !("code" in cause)) {
-        return false;
-    }
-    return cause.code === "ENOENT" || cause.code === "ENOTDIR";
-}
 function isUnmanagedPluginId(pluginId) {
     if (pluginId === CODEX_MANAGER_PLUGIN_ID ||
         pluginId === CODEX_LEGACY_PLUGIN_ID) {
@@ -53,14 +48,14 @@ async function nativeRouteConflict(ctx) {
         routeIsSymlink = (await lstat(route)).isSymbolicLink();
     }
     catch (cause) {
-        return isMissingPath(cause) ? "" : NATIVE_ROUTE_CONFLICT;
+        return isAbsenceError(cause) ? "" : NATIVE_ROUTE_CONFLICT;
     }
     if (!routeIsSymlink) {
         try {
             await lstat(asset);
         }
         catch (cause) {
-            return isMissingPath(cause) ? "" : NATIVE_ROUTE_CONFLICT;
+            return isAbsenceError(cause) ? "" : NATIVE_ROUTE_CONFLICT;
         }
     }
     try {

package/dist/harnesses/codex/generated-plugin.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { posix } from "node:path";
 import { COMMIT_RE, SEMVER_RE } from "../../domain/refs.js";
 import { compareByCodePoint, pythonStrip } from "../../python-text.js";
+import { isAbsenceError } from "../../safe-path.js";
 import { DEFAULT_FS_DEPS, validateSkillFrontmatter, } from "../../skill-validation.js";
 import { parseStrictJson } from "../../strict-json.js";
 const MANIFEST_JSON_PROFILE = {
@@ -18,14 +19,6 @@ class InspectionFailure extends Error {
 /** Any error from a directory enumeration, absence-like included. */
 class EnumerationFailure extends Error {
 }
-/**
- * `ENOENT`/`ENOTDIR` mean *missing*; every other error rejects. This is the
- * only place the absence set is defined.
- */
-function isAbsenceError(cause) {
-    const code = cause?.code;
-    return code === "ENOENT" || code === "ENOTDIR";
-}
 const STRICT_DECODER = new TextDecoder("utf-8", {
     fatal: true,
     ignoreBOM: true,
@@ -447,9 +440,9 @@ async function validateHookSubtree(pluginRoot, hooksRoot, errors, deps) {
             isLink = (await inspectLink(path, deps)) === "symlink";
         }
         catch {
-            // The `src/harnesses/codex/generated-plugin.ts:583::isLink =` probe reaches the first catch bounded by `src/harnesses/codex/generated-plugin.ts:592::let rawTarget`; the `src/harnesses/codex/generated-plugin.ts:594::rawTarget = decodePathBytes` readlink reaches the same site text.
-            // The three probes sharing the *subtree* string are `src/harnesses/codex/generated-plugin.ts:627::resolvedDirectory =`, `src/harnesses/codex/generated-plugin.ts:637::children =`, and
-            // `src/harnesses/codex/generated-plugin.ts:646::deps, true)) === "directory"`, not this one.
+            // The `src/harnesses/codex/generated-plugin.ts:575::isLink =` probe reaches the first catch bounded by `src/harnesses/codex/generated-plugin.ts:584::let rawTarget`; the `src/harnesses/codex/generated-plugin.ts:586::rawTarget = decodePathBytes` readlink reaches the same site text.
+            // The three probes sharing the *subtree* string are `src/harnesses/codex/generated-plugin.ts:619::resolvedDirectory =`, `src/harnesses/codex/generated-plugin.ts:629::children =`, and
+            // `src/harnesses/codex/generated-plugin.ts:638::deps, true)) === "directory"`, not this one.
             errors.push(`generated hook symlink could not be inspected: ${path}`);
             return false;
         }