superpowers-manager 0.7.3 → 0.9.0

package/dist/harnesses/opencode/native.js

@@ -1,57 +1,36 @@
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, resolve, sep } from "node:path";
+import { dirname, resolve } from "node:path";
 import { mkdir } from "node:fs/promises";
-import { failureResult, } from "../../adapter-result.js";
-import { nativeCommandResult, } from "../../harness-command-result.js";
+import {} from "../../adapter-result.js";
+import { runIsolatedNative, } from "../../harness-command-result.js";
 import { BOUNDED_EXECUTABLE, runValidator as runBoundedCommand, } from "../../validator.js";
-import { withWorkspace } from "../../workspace.js";
 const OPEN_CODE_EXECUTABLE = {
     ...BOUNDED_EXECUTABLE,
     inheritEnvironment: false,
 };
-function selectedExecutable(env, invocationCwd) {
-    const configured = env.SUPERPOWERS_OPENCODE || "opencode";
-    return configured.includes(sep) && !isAbsolute(configured)
-        ? resolve(invocationCwd, configured)
-        : configured;
-}
 export async function runOpenCode(args, paths, ctx, execute = runBoundedCommand) {
-    const operation = "opencode-command";
-    const env = ctx.env ?? {};
-    const executable = selectedExecutable(env, process.cwd());
-    let entered = false;
-    try {
-        return await withWorkspace(env.TMPDIR ?? tmpdir(), "superpowers-manager.opencode.", async (workspace) => {
-            entered = true;
-            const home = resolve(workspace, "home");
-            const data = resolve(workspace, "data");
-            const cache = resolve(workspace, "cache");
-            const state = resolve(workspace, "state");
-            const temporary = resolve(workspace, "tmp");
-            const managed = resolve(workspace, "managed");
-            await Promise.all([home, data, cache, state, temporary, managed].map((path) => mkdir(path)));
-            const result = await execute([executable, ...args], OPEN_CODE_EXECUTABLE, {
-                PATH: env.PATH,
-                HOME: home,
-                XDG_CONFIG_HOME: dirname(paths.configRoot),
-                XDG_DATA_HOME: data,
-                XDG_CACHE_HOME: cache,
-                XDG_STATE_HOME: state,
-                TMPDIR: temporary,
-                OPENCODE_DISABLE_AUTOUPDATE: "1",
-                OPENCODE_DISABLE_MODELS_FETCH: "1",
-                OPENCODE_DISABLE_PROJECT_CONFIG: "1",
-                OPENCODE_PURE: "1",
-                OPENCODE_TEST_MANAGED_CONFIG_DIR: managed,
-                GIT_CONFIG_GLOBAL: "/dev/null",
-                GIT_CONFIG_NOSYSTEM: "1",
-            }, temporary, workspace);
-            return nativeCommandResult("OpenCode", result);
-        });
-    }
-    catch {
-        return failureResult(operation, "workspace-failed", entered
-            ? "cannot complete OpenCode command in its isolated workspace"
-            : "cannot create an isolated OpenCode command workspace", [], []);
-    }
+    return await runIsolatedNative("OpenCode", (ctx.env ?? {}).SUPERPOWERS_OPENCODE || "opencode", ctx, async (executable, workspace, env) => {
+        const home = resolve(workspace, "home");
+        const data = resolve(workspace, "data");
+        const cache = resolve(workspace, "cache");
+        const state = resolve(workspace, "state");
+        const temporary = resolve(workspace, "tmp");
+        const managed = resolve(workspace, "managed");
+        await Promise.all([home, data, cache, state, temporary, managed].map((path) => mkdir(path)));
+        return await execute([executable, ...args], OPEN_CODE_EXECUTABLE, {
+            PATH: env.PATH,
+            HOME: home,
+            XDG_CONFIG_HOME: dirname(paths.configRoot),
+            XDG_DATA_HOME: data,
+            XDG_CACHE_HOME: cache,
+            XDG_STATE_HOME: state,
+            TMPDIR: temporary,
+            OPENCODE_DISABLE_AUTOUPDATE: "1",
+            OPENCODE_DISABLE_MODELS_FETCH: "1",
+            OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+            OPENCODE_PURE: "1",
+            OPENCODE_TEST_MANAGED_CONFIG_DIR: managed,
+            GIT_CONFIG_GLOBAL: "/dev/null",
+            GIT_CONFIG_NOSYSTEM: "1",
+        }, temporary, workspace);
+    });
 }

package/dist/harnesses/opencode/package.js

@@ -1,38 +1,36 @@
 import { join } from "node:path";
-import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
-import { COMMIT_RE, SEMVER_RE } from "../../domain/refs.js";
+import { readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
+import { SEMVER_RE } from "../../domain/refs.js";
+import { assertNoFollowType } from "../../safe-path.js";
 import { validateSource } from "../../selection.js";
-import { SafetyError } from "../../safety-error.js";
-import { isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, snapshotReceiptBinding, } from "../../snapshot-package.js";
+import { createSnapshotReceipts, isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, } from "../../snapshot-package.js";
 const BOOTSTRAP = ".opencode/plugins/superpowers.js";
-// Exact-byte allowlist: every upstream bootstrap change needs re-qualification
-// in the native container before its bytes are added here. Revisit the policy
-// if upstream churn makes that a per-release chore.
-const QUALIFIED_BOOTSTRAPS = [
-    // obra/superpowers v6.0.0-v6.3.0
+const ENTRYPOINT = "index.js";
+// Exact-byte allowlist, matched as a unit: a bootstrap and the V2 entrypoint
+// that shipped with it were qualified together in the native container. Adding
+// either half alone would admit a combination no container ever ran. Every
+// upstream change needs re-qualification before its bytes are added here.
+const QUALIFIED_PROFILES = [
     {
-        size: 5464,
-        sha256: "a5c5e1dbb0abfbd6ec3322b724b9a7b3318bbbb3d83f9a661c56ae0ed0a3adb8",
+        // obra/superpowers v6.0.0-v6.3.0 — no V2 entrypoint shipped
+        bootstrap: {
+            size: 5464,
+            sha256: "a5c5e1dbb0abfbd6ec3322b724b9a7b3318bbbb3d83f9a661c56ae0ed0a3adb8",
+        },
+        entrypoint: null,
     },
-    // obra/superpowers v6.4.1
     {
-        size: 17617,
-        sha256: "c979fe5a9fd6fddc9bc9730b34b25989f9d53939eed7d594c4564f6e47495f26",
+        // obra/superpowers v6.4.1
+        bootstrap: {
+            size: 17617,
+            sha256: "c979fe5a9fd6fddc9bc9730b34b25989f9d53939eed7d594c4564f6e47495f26",
+        },
+        entrypoint: {
+            size: 536,
+            sha256: "f0132fd5339befeb99ba903b1619fd9530969e5b4a1ea8cecf0b0a7f0213a099",
+        },
     },
 ];
-function isReceiptCompatibility(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const compatibility = value;
-    if (typeof compatibility.reason !== "string")
-        return false;
-    if (compatibility.kind === "supported" ||
-        compatibility.kind === "experimental")
-        return typeof compatibility.generation === "string";
-    return ((compatibility.kind === "unknown" ||
-        compatibility.kind === "unsupported") &&
-        compatibility.generation === undefined);
-}
 export async function assessOpenCodeCompatibility(root, selection) {
     try {
         validateSource(selection.effectiveSource);
@@ -45,11 +43,21 @@ export async function assessOpenCodeCompatibility(root, selection) {
             throw new Error("package metadata");
         requireNoSnapshotDependencies(pkg);
         await validateNativeSkill(root);
-        await Promise.any(QUALIFIED_BOOTSTRAPS.map(({ size, sha256 }) => requireSnapshotBootstrap(root, BOOTSTRAP, size, sha256)));
+        const matched = await Promise.any(QUALIFIED_PROFILES.map(async (profile) => {
+            await requireSnapshotBootstrap(root, BOOTSTRAP, profile.bootstrap.size, profile.bootstrap.sha256);
+            if (profile.entrypoint === null)
+                await assertNoFollowType(join(root, ENTRYPOINT), ["missing"]);
+            else
+                await requireSnapshotBootstrap(root, ENTRYPOINT, profile.entrypoint.size, profile.entrypoint.sha256);
+            return profile;
+        }));
+        const generation = matched.entrypoint === null
+            ? "opencode-native-bootstrap-v1"
+            : "opencode-native-bootstrap-v2";
         const official = isOfficialSnapshotSource(selection.effectiveSource);
         return {
             kind: official ? "supported" : "experimental",
-            generation: "opencode-native-bootstrap-v1",
+            generation,
             reason: official
                 ? "qualified upstream-native OpenCode bootstrap"
                 : "qualified OpenCode mechanics from a custom source",
@@ -62,41 +70,11 @@ export async function assessOpenCodeCompatibility(root, selection) {
         };
     }
 }
-export async function readOpenCodeReceipt(root) {
-    const path = join(root, ARTIFACT_RECEIPT);
-    try {
-        const value = await readArtifactObject(root, path);
-        if (value.schema !== 1 ||
-            value.manager !== "superpowers-manager" ||
-            value.harness !== "opencode" ||
-            typeof value.source !== "string" ||
-            typeof value.commit !== "string" ||
-            !COMMIT_RE.test(value.commit) ||
-            typeof value.digest !== "string" ||
-            !ARTIFACT_DIGEST_RE.test(value.digest) ||
-            typeof value.binding !== "string" ||
-            !ARTIFACT_DIGEST_RE.test(value.binding))
-            throw new Error("receipt fields");
-        validateSource(value.source);
-        if (snapshotReceiptBinding(value) !==
-            value.binding)
-            throw new Error("receipt binding");
-        if (!isReceiptCompatibility(value.compatibility))
-            throw new Error("receipt compatibility");
-        return value;
-    }
-    catch (cause) {
-        throw new SafetyError("opencode-package", `invalid OpenCode artifact receipt: ${path}`, { cause });
-    }
-}
-export async function readOpenCodePackageAssessment(root) {
-    const receipt = await readOpenCodeReceipt(root);
-    if ((await digestArtifactTree(root)) !== receipt.digest)
-        throw new SafetyError("opencode-package", `OpenCode artifact digest mismatch: ${root}`);
-    return {
-        receipt,
-        compatibility: await assessOpenCodeCompatibility(root, {
-            effectiveSource: receipt.source,
-        }),
-    };
-}
+const receipts = createSnapshotReceipts({
+    harness: "opencode",
+    label: "OpenCode",
+    strictGeneration: true,
+    assessCompatibility: assessOpenCodeCompatibility,
+});
+export const readOpenCodeReceipt = receipts.readReceipt;
+export const readOpenCodePackageAssessment = receipts.readAssessment;

package/dist/harnesses/opencode/prepare.js

@@ -2,12 +2,6 @@ import { failureResult, successResult, } from "../../adapter-result.js";
 import { createSnapshotPreparation } from "../../snapshot-prepare.js";
 import { assertOpenCodePreparationSeparate, openCodePaths } from "./paths.js";
 import { assessOpenCodeCompatibility, readOpenCodePackageAssessment, } from "./package.js";
-export function openCodePreparationLocation(ctx) {
-    return {
-        destinationRoot: openCodePaths(ctx.env ?? {}, process.cwd()).preparedRoot,
-        stagingLeaf: "superpowers",
-    };
-}
 export async function validateOpenCodePreparationBeforeFetch(ctx) {
     try {
         const paths = openCodePaths(ctx.env ?? {}, process.cwd());
@@ -21,10 +15,11 @@ export async function validateOpenCodePreparationBeforeFetch(ctx) {
 const preparation = createSnapshotPreparation({
     harness: "opencode",
     label: "OpenCode",
-    preparationLocation: openCodePreparationLocation,
+    paths: openCodePaths,
     assessCompatibility: assessOpenCodeCompatibility,
     readAssessment: readOpenCodePackageAssessment,
 });
+export const openCodePreparationLocation = preparation.preparationLocation;
 export const prepareOpenCodeCandidate = preparation.prepareCandidate;
 export const inspectOpenCodePrepared = preparation.inspectPrepared;
 export const readOpenCodePrepared = preparation.readPrepared;

package/dist/harnesses/opencode/presentation.js

@@ -1,5 +1,5 @@
 import { displaySource } from "../../selection.js";
-import { createSnapshotPresentation } from "../../snapshot-presentation.js";
+import { createSnapshotPresentation, probeOutput, } from "../../snapshot-presentation.js";
 import { displayPath } from "../../validator.js";
 const renderProbe = (facts) => {
     const fields = [
@@ -10,6 +10,7 @@ const renderProbe = (facts) => {
         ["prepared_identity", facts.prepared.observedIdentity],
         ["installed_identity", facts.installed.observedIdentity],
         ["installation_state", facts.installed.kind],
+        ["registration_key", facts.ownership.removalInput.registration?.key ?? ""],
         ["resource_state", facts.resourceState ?? "idle"],
         ["ownership", facts.ownership.presentationValue],
         ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],
@@ -18,11 +19,6 @@ const renderProbe = (facts) => {
         ["compatibility_reason", facts.compatibility.reason],
         ["status", facts.status],
     ].map(([key, value]) => [key, displayPath(value)]);
-    return {
-        human: fields
-            .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
-            .join(""),
-        porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
-    };
+    return probeOutput(fields);
 };
 export const openCodePresentation = createSnapshotPresentation("OpenCode", renderProbe, (input) => input.receiptDigest === null && input.registration === null);

package/dist/harnesses/opencode/state.js

@@ -52,6 +52,7 @@ function registrationFor(facts) {
         ? null
         : {
             observation: managed.observation,
+            key: managed.entry.key,
             entryIndex: managed.entry.index,
             spec: managed.entry.spec,
         };

package/dist/harnesses/pi/install.js

@@ -1,20 +1,19 @@
 import { randomBytes } from "node:crypto";
-import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, unlink, } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { cp, mkdir, readdir, rm } from "node:fs/promises";
 import { failureResult, successResult, } from "../../adapter-result.js";
-import { atomicWriteFile, beginDirectoryPublication, } from "../../atomic.js";
+import { beginDirectoryPublication, } from "../../atomic.js";
 import { digestArtifactTree } from "../../artifact-tree.js";
 import { normalizeSnapshotRuntimeVersion } from "../../harness-command-result.js";
 import { runPi } from "./native.js";
 import { readPiPackageAssessment, readPiReceipt, } from "./package.js";
 import { piPaths } from "./paths.js";
-import { readPiSettings, resolveCanonicalPiLocalSource, } from "./settings.js";
+import { readPiSettings } from "./settings.js";
 import { inspectPiControl, inspectPiOwnership, } from "./state.js";
 import { assertNoFollowType, canonicalizeProspectivePath, classifyPathNoFollow, } from "../../safe-path.js";
+import { createJournal, createSnapshotJournal, hasRecovery, identity, journalPath, publicationPaths, requireNoRecovery, } from "../../snapshot-journal.js";
 const DEFAULTS = {
     run: runPi,
     beginPublication: beginDirectoryPublication,
-    readSettings: readPiSettings,
 };
 function fail(code, message) {
     return failureResult("pi-lifecycle", code, message, [], []);
@@ -24,20 +23,6 @@ function accepted(result) {
         throw new Error("Pi operation did not succeed");
     return result.outcome.result;
 }
-function sameIdentity(a, b) {
-    return a.dev === b.dev && a.ino === b.ino;
-}
-async function identity(path) {
-    await assertNoFollowType(path, ["directory"]);
-    return await lstat(path);
-}
-async function requireIdentity(path, expected) {
-    if (!sameIdentity(await identity(path), expected))
-        throw new Error("Pi directory changed");
-}
-function journalPath(p) {
-    return join(p.paths.recoveryRoot, "transaction.json");
-}
 function journalBytes(journal) {
     return Buffer.from(JSON.stringify(journal) + "\n");
 }
@@ -47,38 +32,15 @@ async function validatePaths(paths) {
     await assertNoFollowType(paths.installedRoot, ["directory", "missing"]);
     return await canonicalizeProspectivePath(paths.installedRoot);
 }
-async function requireNoRecovery(paths) {
-    await assertNoFollowType(paths.recoveryRoot, ["missing"]);
-}
-async function syncDirectoryStrict(path) {
-    const directory = await open(path, "r");
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
-}
-async function hasRecovery(paths) {
-    try {
-        return (await classifyPathNoFollow(paths.recoveryRoot)) !== "missing";
-    }
-    catch {
-        return true;
-    }
-}
-async function registration(paths, deps) {
-    const settings = await deps.readSettings(paths.settingsFile, paths.homeDir);
-    const canonicalRoot = await canonicalizeProspectivePath(paths.installedRoot);
-    const matches = [];
-    for (const entry of settings.packages) {
-        if ((await resolveCanonicalPiLocalSource(entry.source, paths.agentDir, paths.homeDir)) === canonicalRoot) {
-            matches.push(entry);
-        }
-    }
-    if (matches.length > 1)
-        throw new Error("duplicate Pi registration");
-    return matches[0] ?? null;
+const { requireIdentity, requireJournal, phase, retireJournal } = createSnapshotJournal({
+    label: "Pi",
+    validatePaths,
+    serialize: journalBytes,
+    readCap: 64 * 1024,
+});
+async function registration(paths) {
+    return (await readPiSettings(paths.settingsFile, paths.homeDir))
+        .managerRegistration;
 }
 function sameRegistration(a, b) {
     return a === null
@@ -115,39 +77,6 @@ async function requireSnapshot(root, expected) {
     if (!sameArtifact(await snapshot(root), expected))
         throw new Error("Pi artifact changed");
 }
-async function requireJournal(p) {
-    if ((await validatePaths(p.paths)) !== p.canonicalRoot ||
-        p.journal.installedRoot !== p.canonicalRoot ||
-        !/^[a-f0-9]{32}$/u.test(p.journal.token))
-        throw new Error("Pi recovery root changed");
-    await requireIdentity(p.paths.recoveryRoot, p.recoveryIdentity);
-    const path = journalPath(p);
-    await assertNoFollowType(path, ["regular-file"]);
-    const stat = await lstat(path);
-    if (!sameIdentity(stat, p.journalIdentity) ||
-        stat.size > 64 * 1024 ||
-        !(await readFile(path)).equals(journalBytes(p.journal)))
-        throw new Error("Pi recovery journal changed");
-    if (p.backup !==
-        join(dirname(p.canonicalRoot), `.${basename(p.canonicalRoot)}.bak.${p.journal.token}`) ||
-        p.stage !==
-            join(dirname(p.canonicalRoot), `.${basename(p.canonicalRoot)}.stage.${p.journal.token}`))
-        throw new Error("Pi recovery paths changed");
-}
-async function phase(p, next, changes = {}) {
-    await requireJournal(p);
-    const journal = { ...p.journal, ...changes, phase: next };
-    const bytes = journalBytes(journal);
-    await atomicWriteFile(journalPath(p), bytes, {
-        validate: async (temporary) => {
-            if (!(await readFile(temporary)).equals(bytes))
-                throw new Error("Pi journal write changed");
-        },
-    });
-    await syncDirectoryStrict(p.paths.recoveryRoot);
-    p.journal = journal;
-    p.journalIdentity = await lstat(journalPath(p));
-}
 async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration, ctx, deps) {
     const canonicalRoot = await validatePaths(paths);
     await mkdir(paths.managerRoot, { recursive: true });
@@ -166,38 +95,20 @@ async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration,
         createdRegistration: null,
         phase: newArtifact === null ? "removing" : "staging",
     };
-    const path = join(paths.recoveryRoot, "transaction.json");
-    const handle = await open(path, "wx", 0o600);
-    try {
-        await handle.writeFile(journalBytes(journal));
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
     // The first journal is durable before either a staging tree or backup exists.
-    await syncDirectoryStrict(paths.recoveryRoot);
+    const journalIdentity = await createJournal(paths.recoveryRoot, journalBytes(journal));
     return {
         paths,
         canonicalRoot,
         recoveryIdentity,
-        backup: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.bak.${token}`),
-        stage: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.stage.${token}`),
+        ...publicationPaths(canonicalRoot, token),
         ctx,
         deps,
         journal,
-        journalIdentity: await lstat(path),
+        journalIdentity,
         settled: false,
     };
 }
-async function retireJournal(p) {
-    await requireJournal(p);
-    if ((await readdir(p.paths.recoveryRoot)).some((name) => name !== "transaction.json"))
-        throw new Error("unknown Pi recovery material");
-    await unlink(journalPath(p));
-    await requireIdentity(p.paths.recoveryRoot, p.recoveryIdentity);
-    await rmdir(p.paths.recoveryRoot);
-}
 async function journalRetirementGuidance(p) {
     try {
         const kind = await classifyPathNoFollow(p.paths.recoveryRoot);
@@ -243,7 +154,7 @@ async function finalizePiPublication(p, publication) {
     let publicationCleanupCompleted = false;
     try {
         await requirePublication(p);
-        const current = await registration(p.paths, p.deps);
+        const current = await registration(p.paths);
         const expectedRegistration = p.journal.priorRegistration ?? p.journal.createdRegistration;
         if (expectedRegistration === null ||
             !sameRegistration(current, expectedRegistration) ||
@@ -273,7 +184,7 @@ async function rollbackPiPublication(p, publication) {
     let retirementStarted = false;
     try {
         await requirePublication(p);
-        const current = await registration(p.paths, p.deps);
+        const current = await registration(p.paths);
         if (p.journal.priorRegistration !== null) {
             if (!sameRegistration(current, p.journal.priorRegistration))
                 throw new Error("prior Pi registration changed");
@@ -288,13 +199,13 @@ async function rollbackPiPublication(p, publication) {
             await p.deps
                 .run(["remove", p.canonicalRoot, "--no-approve"], p.paths, p.ctx)
                 .catch(() => undefined);
-            if ((await registration(p.paths, p.deps)) !== null)
+            if ((await registration(p.paths)) !== null)
                 throw new Error("Pi deregistration unverified");
         }
         await requirePublication(p);
         await publication.rollback();
         await requireSnapshot(p.canonicalRoot, p.journal.oldArtifact);
-        if (!sameRegistration(await registration(p.paths, p.deps), p.journal.priorRegistration))
+        if (!sameRegistration(await registration(p.paths), p.journal.priorRegistration))
             throw new Error("Pi registration restoration unverified");
         await phase(p, "restored");
         retirementStarted = true;
@@ -312,7 +223,7 @@ async function recoverBeforePublication(p) {
         await requireJournal(p);
         await requireSnapshot(p.canonicalRoot, p.journal.oldArtifact);
         await assertNoFollowType(p.backup, ["missing"]);
-        if (!sameRegistration(await registration(p.paths, p.deps), p.journal.priorRegistration))
+        if (!sameRegistration(await registration(p.paths), p.journal.priorRegistration))
             return false;
         if ((await assertNoFollowType(p.stage, ["directory", "missing"])) !==
             "missing") {
@@ -346,13 +257,13 @@ export async function installPi(artifact, ctx, deps = DEFAULTS) {
             throw new Error("Pi prepared artifact changed");
         await requireActivationEligibility(ctx);
         const previous = await snapshot(paths.installedRoot);
-        const priorRegistration = await registration(paths, deps);
+        const priorRegistration = await registration(paths);
         if (previous === null && priorRegistration !== null)
             throw new Error("unowned Pi registration");
         accepted(normalizeSnapshotRuntimeVersion("Pi", await deps.run(["--version"], paths, ctx)));
         // Recheck after the native preflight, before claiming mutation ownership.
         await requireSnapshot(paths.installedRoot, previous);
-        if (!sameRegistration(await registration(paths, deps), priorRegistration))
+        if (!sameRegistration(await registration(paths), priorRegistration))
             throw new Error("Pi registration changed");
         pending = await beginJournal(paths, previous, assessment.receipt, priorRegistration, ctx, deps);
         await mkdir(pending.stage);
@@ -371,20 +282,20 @@ export async function installPi(artifact, ctx, deps = DEFAULTS) {
         await requireIdentity(pending.stage, pending.stageIdentity);
         await requireActivationEligibility(ctx);
         await requireSnapshot(paths.installedRoot, previous);
-        if (!sameRegistration(await registration(paths, deps), priorRegistration))
+        if (!sameRegistration(await registration(paths), priorRegistration))
             throw new Error("Pi registration changed");
         publication = await deps.beginPublication(pending.stage, pending.canonicalRoot, { backupPath: pending.backup });
         pending.publishedIdentity = pending.stageIdentity;
         await phase(pending, "published");
         if (priorRegistration === null) {
             await phase(pending, "registering");
-            if ((await registration(paths, deps)) !== null)
+            if ((await registration(paths)) !== null)
                 throw new Error("Pi registration changed");
             const result = await deps
                 .run(["install", pending.canonicalRoot, "--no-approve"], paths, ctx)
                 .catch(() => fail("native-failed", "Pi native installation failed"));
             // Even an unsuccessful command may have changed settings. Read them first.
-            const registered = await registration(paths, deps);
+            const registered = await registration(paths);
             if (registered === null || registered.resourceState !== "enabled")
                 throw new Error("Pi activation unverified");
             await phase(pending, "registered", {
@@ -393,7 +304,7 @@ export async function installPi(artifact, ctx, deps = DEFAULTS) {
             accepted(result);
         }
         await requirePublication(pending);
-        const registered = await registration(paths, deps);
+        const registered = await registration(paths);
         if (registered === null || registered.resourceState !== "enabled")
             throw new Error("Pi activation unverified");
         await phase(pending, "ready");
@@ -444,7 +355,7 @@ export async function removePi(input, ctx, deps = DEFAULTS) {
             input.receiptDigest !== current.receiptDigest)
             throw new Error("stale Pi removal input");
         const previous = await snapshot(paths.installedRoot);
-        const registered = await registration(paths, deps);
+        const registered = await registration(paths);
         if (previous === null) {
             if (registered !== null)
                 throw new Error("unowned Pi registration");
@@ -453,7 +364,7 @@ export async function removePi(input, ctx, deps = DEFAULTS) {
         if (registered !== null)
             accepted(normalizeSnapshotRuntimeVersion("Pi", await deps.run(["--version"], paths, ctx)));
         await requireSnapshot(paths.installedRoot, previous);
-        if (!sameRegistration(await registration(paths, deps), registered))
+        if (!sameRegistration(await registration(paths), registered))
             throw new Error("Pi registration changed");
         pending = await beginJournal(paths, previous, null, registered, ctx, deps);
         const installedIdentity = await identity(paths.installedRoot);
@@ -461,7 +372,7 @@ export async function removePi(input, ctx, deps = DEFAULTS) {
             const result = await deps
                 .run(["remove", pending.canonicalRoot, "--no-approve"], paths, ctx)
                 .catch(() => fail("native-failed", "Pi native removal failed"));
-            const after = await registration(paths, deps);
+            const after = await registration(paths);
             if (after !== null) {
                 if (sameRegistration(after, registered)) {
                     await requireSnapshot(paths.installedRoot, previous);
@@ -480,7 +391,7 @@ export async function removePi(input, ctx, deps = DEFAULTS) {
         await phase(pending, "deregistered");
         await requireIdentity(paths.installedRoot, installedIdentity);
         await requireSnapshot(paths.installedRoot, previous);
-        if ((await registration(paths, deps)) !== null)
+        if ((await registration(paths)) !== null)
             throw new Error("Pi registration returned");
         await rm(paths.installedRoot, { recursive: true });
         await requireSnapshot(paths.installedRoot, null);

package/dist/harnesses/pi/native.js

@@ -1,37 +1,12 @@
-import { tmpdir } from "node:os";
-import { isAbsolute, resolve, sep } from "node:path";
-import { failureResult, } from "../../adapter-result.js";
-import { nativeCommandResult, } from "../../harness-command-result.js";
+import {} from "../../adapter-result.js";
+import { runIsolatedNative, } from "../../harness-command-result.js";
 import { BOUNDED_EXECUTABLE, runValidator as runBoundedCommand, } from "../../validator.js";
-import { withWorkspace } from "../../workspace.js";
-function selectedExecutable(env, invocationCwd) {
-    const configured = env.SUPERPOWERS_PI || "pi";
-    return configured.includes(sep) && !isAbsolute(configured)
-        ? resolve(invocationCwd, configured)
-        : configured;
-}
 export async function runPi(args, paths, ctx, execute = runBoundedCommand) {
-    const operation = "pi-command";
-    const env = ctx.env ?? {};
-    const invocationCwd = process.cwd();
-    const executable = selectedExecutable(env, invocationCwd);
-    let entered = false;
-    try {
-        return await withWorkspace(env.TMPDIR ?? tmpdir(), "superpowers-manager.pi.", async (workspace) => {
-            entered = true;
-            const result = await execute([executable, ...args], BOUNDED_EXECUTABLE, {
-                ...env,
-                HOME: paths.homeDir,
-                PI_CODING_AGENT_DIR: paths.agentDir,
-                PI_OFFLINE: "1",
-                PI_SKIP_VERSION_CHECK: "1",
-            }, workspace, workspace);
-            return nativeCommandResult("Pi", result);
-        });
-    }
-    catch {
-        return failureResult(operation, "workspace-failed", entered
-            ? "cannot complete Pi command in its isolated workspace"
-            : "cannot create an isolated Pi command workspace", [], []);
-    }
+    return await runIsolatedNative("Pi", (ctx.env ?? {}).SUPERPOWERS_PI || "pi", ctx, async (executable, workspace, env) => await execute([executable, ...args], BOUNDED_EXECUTABLE, {
+        ...env,
+        HOME: paths.homeDir,
+        PI_CODING_AGENT_DIR: paths.agentDir,
+        PI_OFFLINE: "1",
+        PI_SKIP_VERSION_CHECK: "1",
+    }, workspace, workspace));
 }