superpowers-manager 0.6.0 → 0.7.0

package/dist/commands/uninstall.js

@@ -1,72 +1,21 @@
-// Ports scripts/uninstall. The shell sourced common.sh, provenance.sh,
-// lifecycle.sh and adapter.sh; the predicates now live in src/harnesses/codex/lifecycle.ts
-// and the adapter arrives through ctx.adapter.
 import { tmpdir } from "node:os";
 import { oneLine } from "../cli-arguments.js";
 import { withWorkspace, workspaceRemovalFailure } from "../workspace.js";
+import { GatherFailure, callAdapter, } from "./adapter-call.js";
 import { runWithMutation } from "./mutation.js";
 import { replayOutcome } from "./probe.js";
 async function invoke(call, failure, outcomes) {
-    let result;
-    try {
-        result = await call();
-    }
-    catch {
-        return { ok: false, message: failure.unexpected };
-    }
-    outcomes.push(result.outcome);
-    const outcome = result.outcome;
-    if (result.status !== 0 || !outcome.ok) {
-        return {
-            ok: false,
-            message: outcome.ok ? failure.invalidStatus : null,
-        };
-    }
-    return {
-        ok: true,
-        result: { status: result.status, outcome },
-    };
-}
-// withWorkspace throws for mkdtemp failure before the callback ever runs
-// ("cannot create workspace",
-// `src/workspace.ts:120::throw new SafetyError("workspace", "cannot create workspace"`).
-// A bare re-throw would silently drop every outcome collected before that
-// point -- a narrow
-// DIAG-ADAPTER-01 regression the shell never had, since it replayed each
-// adapter response as it went rather than batching replay to the end. This
-// carries the outcomes collected so far alongside the original cause, so
-// runUninstall's catch can still replay them before reporting the cause.
-//
-// The post-success cleanup failure no longer reaches here: onCleanupFailure
-// below suppresses withWorkspace's throw for that case and records the
-// warning as data, so the computed UninstallOutcome survives it. The
-// outcome-carrying is still load-bearing for mkdtemp, and the shape stays
-// identical to src/commands/install.ts's GatherFailure.
-class GatherFailure extends Error {
-    inner;
-    outcomes;
-    constructor(inner, outcomes) {
-        super("uninstall gather failed");
-        this.inner = inner;
-        this.outcomes = outcomes;
-    }
+    const result = await callAdapter(call, failure);
+    if (result.result !== null)
+        outcomes.push(result.result.outcome);
+    return result;
 }
-// Every step that can throw or fail closed, returning the outcome as data and
-// performing NO writes. Same shape as gatherProbe
-// (`src/commands/probe.ts::readonly facts: ProbeSnapshot<R>;`) and for the same
-// reason: a write inside this try could raise EPIPE, be caught here, and be
-// relabelled as a domain failure.
+// Collect outcomes without writing so output failures cannot be classified as
+// inspection failures. Replay collected outcomes after gathering completes.
 async function gatherUninstall(ctx) {
-    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/uninstall:20-21::TMPDIR=` exported TMPDIR="$uninstall_workspace" so every
-    // child confined its temporary files to the tree the workspace trap
-    // removed. The AdapterContext passed to ctx.adapter below does the same.
     const parent = ctx.env.TMPDIR ?? tmpdir();
-    // Declared OUTSIDE the withWorkspace callback (rather than inside, as an
-    // earlier draft had it) so the catch below -- which wraps the ENTIRE
-    // withWorkspace call, not just the callback -- can still see whatever was
-    // collected before a workspace throw. Both `mkdtemp` failure (nothing
-    // collected yet) and a post-success cleanup failure (everything the
-    // callback collected) reach this same array.
+    // Kept outside the workspace callback so a workspace failure preserves every
+    // outcome collected before it.
     const outcomes = [];
     let cleanupWarning = null;
     try {
@@ -90,9 +39,8 @@ async function gatherUninstall(ctx) {
             const removed = await invoke(() => ctx.adapter.remove(removalInput, adapterContext), removeFailure, outcomes);
             if (!removed.ok)
                 return failed(removed.message);
-            // Stage 3: inspect ownership AGAIN. This overwrites the first
-            // inspection (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/uninstall:29-30::spw_verify_uninstalled_resources`), so everything below reads the
-            // POST-uninstall state, not the pre-uninstall one read above.
+            // Stage 3: inspect ownership again. Everything below reads this
+            // post-removal state, not the inspection before removal.
             const afterFailure = ctx.adapter.presentation.callFailure("post-remove", adapterContext);
             const after = await invoke(() => ctx.adapter.inspectOwnership(adapterContext), afterFailure, outcomes);
             if (!after.ok)
@@ -131,7 +79,7 @@ async function gatherUninstall(ctx) {
         // cannot reach here. Wrapping with `outcomes` anyway keeps the class
         // total over its declared contract rather than assuming the callback's
         // purity at the throw site.
-        throw new GatherFailure(cause, outcomes);
+        throw new GatherFailure("uninstall gather failed", cause, outcomes);
     }
 }
 export async function runUninstall(argv, ctx) {
@@ -147,30 +95,8 @@ async function performUninstall(argv, ctx) {
         run = await gatherUninstall(ctx);
     }
     catch (cause) {
-        // gatherUninstall throws exactly one shape: GatherFailure, wrapping
-        // withWorkspace's "cannot create workspace" SafetyError
-        // (`src/workspace.ts:120::throw new SafetyError("workspace", "cannot create workspace"`),
-        // alongside whatever outcomes were collected before that throw -- none,
-        // for that cause. Replaying first, before
-        // reporting the cause, keeps the arm honest for any outcome-bearing
-        // throw the class is declared to carry (DIAG-ADAPTER-01). The
-        // post-success cleanup failure no longer arrives here: gatherUninstall's
-        // onCleanupFailure records it as `cleanupWarning` and the computed
-        // outcome survives, which is what `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/uninstall:34-35::complete` did. The
-        // `instanceof` guard is defensive rather than load-bearing --
-        // gatherUninstall's own catch is the only thing that can throw here, and
-        // it always wraps -- but this catch does not assume that invariant
-        // blindly.
-        //
-        // A cause outside ctx.adapter's AdapterFailure guard
-        // (`src/harnesses/codex/adapter.ts:829::async function runCodexOperation<T = JsonValue>(`) does NOT
-        // reach here: invoke() catches it inside gatherUninstall and converts it
-        // to a hand-written message carried as UninstallOutcome data, exactly as
-        // src/commands/probe.ts's inspect() does for the same cause.
-        //
-        // gatherUninstall performs no writes of its own, so this catch cannot
-        // also be reached by an EPIPE from uninstall's own output -- every write
-        // below runs only after this try/catch has resolved.
+        // Replay collected outcomes before reporting a gather failure. The
+        // cleanup reporter retains post-success cleanup failures as data.
         const outcomes = cause instanceof GatherFailure ? cause.outcomes : [];
         for (const outcome of outcomes)
             replayOutcome(outcome, ctx);
@@ -179,9 +105,7 @@ async function performUninstall(argv, ctx) {
         return 1;
     }
     const { outcome, cleanupWarning } = run;
-    // Replay first, on both paths: the shell validator replayed every
-    // response's messages whether or not that response was a failure
-    // (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/validate-adapter-response.py:268::replay(messages)`).
+    // Replay before reporting a command-level result on either path.
     for (const each of outcome.outcomes)
         replayOutcome(each, ctx);
     let status;

package/dist/commands/update.js

@@ -1,21 +1,10 @@
-// Ports scripts/update. The shell sourced common.sh and lifecycle.sh; the
-// predicates now live in src/harnesses/codex/lifecycle.ts. Unlike install and uninstall,
-// update issues no ctx.adapter call of its own: every adapter interaction
-// this module needs already happens inside gatherProbe, runPrepare or
-// runInstall, each of which owns its own §4.2a-conformant invoke() gate. That
-// is also why update opens no temporary workspace of its own -- there is no
-// mutation here for one to protect.
+// Update delegates adapter calls to probe, prepare, and install. Those
+// mutating commands own their workspaces, so update opens none itself.
 import { oneLine } from "../cli-arguments.js";
+import { runInstall, writeOutput } from "./install.js";
 import { gatherProbe, replayOutcome } from "./probe.js";
-import { runInstall } from "./install.js";
 import { runPrepare } from "./prepare.js";
 import { runWithMutation } from "./mutation.js";
-function writeOutput(output, ctx) {
-    for (const line of output.stdout)
-        ctx.stdout.write(`${line}\n`);
-    for (const line of output.stderr)
-        ctx.stderr.write(`${line}\n`);
-}
 export async function runUpdate(argv, ctx) {
     return await runWithMutation("update", ctx, async (scoped) => performUpdate(argv, scoped));
 }
@@ -28,17 +17,8 @@ async function performUpdate(argv, ctx) {
         probe = await gatherProbe(ctx);
     }
     catch (cause) {
-        // gatherProbe performs no writes of its own (src/commands/probe.ts), so
-        // this catch cannot also be reached by an EPIPE from update's own
-        // output -- update writes nothing before this call resolves, unlike
-        // install's NOTE line.
-        //
-        // This is a THIRD consumer of gatherProbe's throw channel --
-        // `src/commands/probe.ts:469-527::THREE exceptions, all inherited and none a regression:`'s
-        // runProbe catch is the first and src/commands/install.ts's runInstall catch
-        // is the second. Because all three wrap the identical function, runProbe's
-        // long comment there enumerates exactly what can reach this stream too; not
-        // repeated here.
+        // Gathering does not write, so this catch cannot misclassify an output
+        // failure. oneLine() bounds any inherited diagnostic to one line.
         ctx.stderr.write(`error: ${oneLine(cause)}\n`);
         return 1;
     }

package/dist/effective-selection.js

@@ -43,10 +43,9 @@ export async function loadSavedSelection(env) {
 export const UPSTREAM_URL_DEFAULT = "https://github.com/obra/superpowers";
 // Ports the env > saved > package-default precedence ladder from
 // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/selection.sh:88-162::spw_compute_effective_selection`.
-// validateSource runs before any ref resolution -- pinned by
-// tests/unit/effective-selection.test.js's "source validation precedes ref
-// resolution": a credential-bearing source must fail before Git is ever
-// invoked.
+// validateSource runs before any ref resolution. A credential-bearing source
+// must fail before Git is invoked; the resolver-log check lives in
+// `tests/baseline/selection-location.test.ts::SEL-PRECEDENCE-VALIDATE-01 invalid saved state stops resolution`.
 export async function computeEffectiveSelection(root, env) {
     const saved = await loadSavedSelection(env);
     let upstreamSourceOrigin;
@@ -63,8 +62,7 @@ export async function computeEffectiveSelection(root, env) {
         upstreamSourceOrigin = "package-default";
         effectiveSource = UPSTREAM_URL_DEFAULT;
     }
-    // Before any Git access. Pinned by tests/unit/effective-selection.test.js's
-    // "source validation precedes ref resolution".
+    // Before any Git access; the selection-location test above checks the log.
     validateSource(effectiveSource);
     let selectionOrigin;
     let selectionMode;

package/dist/git-tree.js

@@ -0,0 +1,85 @@
+import { execFile } from "node:child_process";
+import { chmod, mkdir, symlink, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+import { ARTIFACT_RECEIPT } from "./artifact-tree.js";
+import { COMMIT_RE } from "./domain/refs.js";
+import { assertNoFollowType, assertSymlinkTargetContained, } from "./safe-path.js";
+import { SafetyError } from "./safety-error.js";
+const exec = promisify(execFile);
+const DECODER = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+async function gitBytes(repository, args) {
+    try {
+        return (await exec("git", ["--no-replace-objects", "-C", repository, ...args], {
+            encoding: null,
+            maxBuffer: 256 * 1024 * 1024,
+        })).stdout;
+    }
+    catch (cause) {
+        throw new SafetyError("git-tree", `cannot read Git tree objects from repository: ${repository}`, { cause });
+    }
+}
+export async function materializeGitTree(repository, commit, destination) {
+    try {
+        if (!COMMIT_RE.test(commit))
+            throw new Error("commit");
+        if (!(await gitBytes(repository, ["cat-file", "-t", commit])).equals(Buffer.from("commit\n")))
+            throw new Error("not a commit");
+        await assertNoFollowType(destination, ["missing"]);
+        const bytes = await gitBytes(repository, [
+            "ls-tree",
+            "-rz",
+            "--full-tree",
+            commit,
+        ]);
+        const entries = [];
+        let offset = 0;
+        while (offset < bytes.length) {
+            const end = bytes.indexOf(0, offset);
+            if (end < 0)
+                throw new Error("tree framing");
+            const record = DECODER.decode(bytes.subarray(offset, end));
+            offset = end + 1;
+            const match = /^(100644|100755|120000) blob ([a-f0-9]{40})\t([\s\S]+)$/.exec(record);
+            if (!match)
+                throw new Error("tree entry");
+            const path = match[3];
+            if (path
+                .split("/")
+                .some((part) => !part ||
+                part === "." ||
+                part === ".." ||
+                part.toLowerCase() === ".git") ||
+                isAbsolute(path) ||
+                path.includes("\\") ||
+                path.split("/")[0] === ARTIFACT_RECEIPT)
+                throw new Error("tree path");
+            entries.push({ mode: match[1], oid: match[2], path });
+        }
+        await mkdir(destination, { recursive: true });
+        for (const entry of entries)
+            await mkdir(dirname(join(destination, entry.path)), { recursive: true });
+        for (const entry of entries.filter((entry) => entry.mode !== "120000")) {
+            const path = join(destination, entry.path), mode = entry.mode === "100755" ? 0o755 : 0o644;
+            await writeFile(path, await gitBytes(repository, ["cat-file", "blob", entry.oid]), { flag: "wx", mode });
+            await chmod(path, mode);
+        }
+        for (const entry of entries.filter((entry) => entry.mode === "120000")) {
+            const target = DECODER.decode(await gitBytes(repository, ["cat-file", "blob", entry.oid]));
+            const path = join(destination, entry.path), suffix = relative(resolve(destination), resolve(dirname(path), target));
+            if (!target ||
+                target.includes("\0") ||
+                isAbsolute(target) ||
+                suffix === ".." ||
+                suffix.startsWith("../") ||
+                isAbsolute(suffix))
+                throw new Error("link escape");
+            await symlink(target, path);
+        }
+        for (const entry of entries.filter((entry) => entry.mode === "120000"))
+            await assertSymlinkTargetContained(destination, join(destination, entry.path));
+    }
+    catch (cause) {
+        throw new SafetyError("git-tree", `cannot materialize Git tree from ${repository} into ${destination}`, { cause });
+    }
+}

package/dist/harness-command-result.js

@@ -0,0 +1,47 @@
+import { AdapterMessageLog, failureResult, successResult, } from "./adapter-result.js";
+import { SEMVER_RE } from "./domain/refs.js";
+function appendCaptured(log, label, channel, captured) {
+    log.appendBytes(channel, Buffer.from(captured.text));
+    if (captured.droppedBytes > 0)
+        log.appendText(channel, `${label} ${channel} omitted ${captured.droppedBytes} bytes at the capture limit`);
+}
+export function nativeCommandResult(label, result) {
+    const operation = `${label.toLowerCase()}-command`;
+    if (result.kind === "launchFailed") {
+        const errno = /^[A-Z][A-Z0-9_]*$/u.test(result.errno)
+            ? result.errno
+            : "UNKNOWN";
+        return failureResult(operation, "launch-failed", `cannot launch configured ${label} executable (${errno})`, [], []);
+    }
+    const log = new AdapterMessageLog();
+    if (result.kind === "timedOut") {
+        appendCaptured(log, label, "stdout", result.stdout);
+        appendCaptured(log, label, "stderr", result.stderr);
+        return failureResult(operation, "timeout", `${label} command timed out after ${result.afterMs} ms`, [], log.snapshot());
+    }
+    if (result.code !== 0) {
+        appendCaptured(log, label, "stdout", result.stdout);
+        appendCaptured(log, label, "stderr", result.stderr);
+        return failureResult(operation, "nonzero-exit", result.code === null
+            ? `${label} command exited without a status`
+            : `${label} command exited with status ${result.code}`, [], log.snapshot());
+    }
+    if (result.stdout.droppedBytes > 0 || result.stderr.droppedBytes > 0) {
+        appendCaptured(log, label, "stdout", result.stdout);
+        appendCaptured(log, label, "stderr", result.stderr);
+        return failureResult(operation, "output-limit", `${label} command output exceeded the capture limit`, [], log.snapshot());
+    }
+    appendCaptured(log, label, "stderr", result.stderr);
+    return successResult(operation, { stdout: result.stdout.text }, log.snapshot());
+}
+export function normalizeSnapshotRuntimeVersion(label, result) {
+    if (!result.outcome.ok)
+        return { status: result.status, outcome: result.outcome };
+    const operation = `${label.toLowerCase()}-runtime`;
+    if (result.status !== 0)
+        return failureResult(operation, "invalid-status", `${label} runtime inspection returned a nonzero status`, [], result.outcome.messages);
+    const version = result.outcome.result.stdout.trim();
+    if (!SEMVER_RE.test(version))
+        return failureResult(operation, "invalid-version", `${label} runtime inspection returned an invalid version response`, [], result.outcome.messages);
+    return successResult(operation, version, result.outcome.messages);
+}

package/dist/harnesses/codex/adapter.js

@@ -14,8 +14,7 @@ import { validateGeneratedPlugin } from "./generated-plugin.js";
 import { classifyHooks, materializeHooks, readManifest, } from "./hooks.js";
 import { applyManifestOverlay } from "./manifest-overlay.js";
 import { readCodexBuildSource } from "../../provenance.js";
-import { isAcceptedSplitValue } from "../../validate-generated-plugin-cli.js";
-import { codexControlInspection, codexOwnershipInspection, } from "./lifecycle.js";
+import { codexOwnershipInspection } from "./lifecycle.js";
 import { codexInstallReceipt } from "./presentation.js";
 const PLUGIN_ID = CODEX_MANAGER_PLUGIN_ID;
 const MARKETPLACE_NAME = "superpowers-manager";
@@ -282,39 +281,6 @@ async function runBuild(input, env, log) {
     catch {
         fail("invalid-provenance", "candidate provenance is missing or invalid");
     }
-    // The seven values the validator CLI would receive in split form:
-    // --plugin-root, --requested-ref, --resolved-ref, --commit,
-    // --manifest-version, --manifest-source, --upstream-manifest-version.
-    // The eighth, --source, is passed attached, where argparse accepts any
-    // dash-leading value, so it is deliberately absent here. Each value is
-    // paired with the ADAPTER-facing flag name to report: --manager-version
-    // (the CLI calls it --manifest-version) and --plugin-root /
-    // --manifest-source (derived, not user-supplied) deliberately differ
-    // from the validator CLI's own names, since the operator can only act
-    // on the adapter's surface.
-    const splitValues = [
-        { value: candidateRoot, name: "--plugin-root" },
-        { value: input.requestedRef, name: "--requested-ref" },
-        { value: input.resolvedRef, name: "--resolved-ref" },
-        { value: input.commit, name: "--commit" },
-        { value: input.managerVersion, name: "--manager-version" },
-        { value: manifestSource, name: "--manifest-source" },
-        {
-            value: input.upstreamManifestVersion,
-            name: "--upstream-manifest-version",
-        },
-    ];
-    const firstRejected = splitValues.find(({ value }) => !isAcceptedSplitValue(value));
-    if (firstRejected !== undefined) {
-        // Declared exception to message-record parity: argparse wrote usage
-        // records here; this guard precedes the call and writes a
-        // differently-worded record naming the rejected flag instead. The
-        // failure code and message are unchanged.
-        const text = "Generated plugin validation failed:\n" +
-            `- validator argument \`${firstRejected.name}\` has a dash-leading value the argument parser rejects\n`;
-        log.appendBytes("stderr", Buffer.from(text, "utf8"));
-        fail("generated-plugin-validation-failed", "built-in generated plugin validation failed");
-    }
     let errors;
     try {
         errors = await validateGeneratedPlugin({
@@ -447,16 +413,17 @@ async function runOwnership(context, env, log) {
     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.installedListingJson);
+        const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedPlugins);
         return ownershipFromResources(stored.managerPluginPresent, true, stored.legacyPluginPresent || stored.legacyMarketplaceRoot !== null, conflicts);
     }
     let managerPlugin;
     let legacyPlugin;
     let conflicts;
     try {
-        managerPlugin = installedListingHas(plugins.stdout, "installed", "pluginId", PLUGIN_ID);
-        legacyPlugin = installedListingHas(plugins.stdout, "installed", "pluginId", LEGACY_PLUGIN_ID);
-        conflicts = await inspectCodexConflicts({ root: context.root, env }, plugins.stdout.toString("utf8"));
+        const installed = codexInstalledPluginsFromJson(plugins.stdout);
+        managerPlugin = installed.some((plugin) => plugin.pluginId === PLUGIN_ID);
+        legacyPlugin = installed.some((plugin) => plugin.pluginId === LEGACY_PLUGIN_ID);
+        conflicts = await inspectCodexConflicts({ root: context.root, env }, installed);
     }
     catch {
         fail("inspect-failed", `cannot parse output of '${codexBin} plugin list --json'`);
@@ -464,7 +431,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.installedListingJson);
+        const conflicts = await inspectCodexConflicts({ root: context.root, env }, stored.installedPlugins);
         return ownershipFromResources(stored.managerPluginPresent, true, stored.legacyPluginPresent || stored.legacyMarketplaceRoot !== null, conflicts);
     }
     let managerMarketplace;
@@ -505,7 +472,11 @@ export function codexInspectOwnership(context) {
     return runCodexOperation("inspect", context, (env, log) => runOwnership(context, env, log));
 }
 export function codexInspectControl(context) {
-    return runCodexOperation("inspect", context, async () => codexControlInspection("managed"));
+    return runCodexOperation("inspect", context, async () => ({
+        probeEligibility: { kind: "allowed" },
+        mutationEligibility: { kind: "allowed" },
+        presentationValue: "managed",
+    }));
 }
 export function codexReadNativeState(context) {
     return runCodexOperation("native-state", context, async (env, log) => {

package/dist/harnesses/codex/conflicts.js

@@ -1,6 +1,5 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { codexInstalledPluginsFromJson, } from "./json.js";
 export const CODEX_MANAGER_PLUGIN_ID = "superpowers@superpowers-manager";
 export const CODEX_LEGACY_PLUGIN_ID = "superpowers@superpowers-wrapper";
 const SUPERPOWERS_PLUGIN_PREFIX = "superpowers@";
@@ -85,9 +84,9 @@ async function nativeRouteConflict(ctx) {
     }
     return NATIVE_ROUTE_CONFLICT;
 }
-export async function inspectCodexConflicts(ctx, installedListing) {
+export async function inspectCodexConflicts(ctx, installedPlugins) {
     const conflicts = new Set();
-    for (const plugin of codexInstalledPluginsFromJson(installedListing)) {
+    for (const plugin of installedPlugins) {
         const conflict = unmanagedPluginConflict(plugin);
         if (conflict.length > 0)
             conflicts.add(conflict);

package/dist/harnesses/codex/hooks.js

@@ -5,7 +5,7 @@ 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/selection-store.ts:19::const SELECTION_JSON_PROFILE`. The annotation
+// `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.
 const MANIFEST_PROFILE = {

package/dist/harnesses/codex/json.js

@@ -1,4 +1,5 @@
 import { SafetyError } from "../../safety-error.js";
+import { hasTerminalControl } from "../../adapter-result.js";
 import { parseStrictJson, } from "../../strict-json.js";
 const ACCEPT_CONSTANTS = {
     duplicateKeys: "last-wins",
@@ -45,17 +46,6 @@ function checkedItems(raw, profile, arrayKey, field) {
         return candidate;
     });
 }
-function hasTerminalControl(value) {
-    for (const character of value) {
-        const code = character.codePointAt(0);
-        if (code < 0x20 ||
-            (code >= 0x7f && code <= 0x9f) ||
-            (code >= 0xd800 && code <= 0xdfff)) {
-            return true;
-        }
-    }
-    return false;
-}
 export function installedListingHas(raw, arrayKey, field, value) {
     return checkedItems(raw, ACCEPT_CONSTANTS, arrayKey, field).some((item) => item[field] === value);
 }

package/dist/harnesses/codex/lifecycle.js

@@ -52,24 +52,6 @@ export function reportLegacyState(identityState) {
     }
     return unknownState(identityState);
 }
-// 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
-// at the call site and neither is special.
-export function requireManagedUpdateControl(value) {
-    if (value === "managed")
-        return { ok: true };
-    if (value === "unsupported") {
-        return {
-            ok: false,
-            message: "adapter cannot guarantee manager-controlled updates",
-        };
-    }
-    return {
-        ok: false,
-        message: `unknown adapter update-control capability: ${value}`,
-    };
-}
 function installDecision(legacy) {
     switch (legacy.kind) {
         case "ok":
@@ -159,33 +141,3 @@ export function codexOwnershipInspection(identityState, removalInput, conflicts)
         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

@@ -74,7 +74,7 @@ function setMember(entries, key, value) {
 }
 /**
  * Map strict-json's diagnostics onto the CPython wording the callers assert.
- * Repository policy at `AGENTS.md:92::most diagnostics are asserted as`
+ * Repository policy at `AGENTS.md:89::most diagnostics are asserted as`
  * freezes most of these diagnostics as complete-string contracts.
  */
 function translate(cause, source, path) {

package/dist/harnesses/codex/paths.js

@@ -1,5 +1,5 @@
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { assertNoFollowType, canonicalizeProspectivePath, } from "../../safe-path.js";
+import { join, resolve } from "node:path";
+import { assertNoFollowType, canonicalizeProspectivePath, isContained, } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 export function codexHome(env, cwd) {
     const configured = env.CODEX_HOME;
@@ -26,15 +26,18 @@ export function codexPaths(env, cwd) {
     };
 }
 function overlaps(a, b) {
-    const inside = (root, leaf) => {
-        const suffix = relative(root, leaf);
-        return (suffix === "" ||
-            (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`)));
-    };
-    return inside(a, b) || inside(b, a);
+    return isContained(a, b) || isContained(b, a);
+}
+class CodexPathError extends SafetyError {
+    constructor(message, details, cause) {
+        super("codex-paths", message, {
+            details,
+            ...(cause === undefined ? {} : { cause }),
+        });
+    }
 }
 function separationError() {
-    return new SafetyError("codex-paths", "preparation overlaps Codex published or recovery storage", { details: { kind: "overlap" } });
+    return new CodexPathError("preparation overlaps Codex published or recovery storage", { kind: "overlap" });
 }
 async function inspectRoot(path, root) {
     try {
@@ -42,29 +45,11 @@ async function inspectRoot(path, root) {
         return await canonicalizeProspectivePath(path);
     }
     catch (cause) {
-        throw new SafetyError("codex-paths", `cannot inspect ${root} root: ${path}`, { cause, details: { kind: "inspection", root, path } });
+        throw new CodexPathError(`cannot inspect ${root} root: ${path}`, { kind: "inspection", root, path }, cause);
     }
 }
 export function codexPathFailureDetails(cause) {
-    if (!(cause instanceof SafetyError) || cause.module !== "codex-paths") {
-        return null;
-    }
-    const details = cause.details;
-    if (details === null || typeof details !== "object" || !("kind" in details)) {
-        return null;
-    }
-    if (details.kind === "overlap")
-        return { kind: "overlap" };
-    if (details.kind !== "inspection" ||
-        !("root" in details) ||
-        !("path" in details) ||
-        (details.root !== "preparation" &&
-            details.root !== "marketplace" &&
-            details.root !== "recovery") ||
-        typeof details.path !== "string") {
-        return null;
-    }
-    return { kind: "inspection", root: details.root, path: details.path };
+    return cause instanceof CodexPathError ? (cause.details ?? null) : null;
 }
 export async function assertCodexPreparationSeparate(preparedRoot, paths) {
     const recovery = await inspectRoot(paths.recoveryRoot, "recovery");