superpowers-manager 0.6.0 → 0.7.0

package/dist/harnesses/opencode/package.js

@@ -0,0 +1,89 @@
+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 { validateSource } from "../../selection.js";
+import { SafetyError } from "../../safety-error.js";
+import { isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, snapshotReceiptBinding, } from "../../snapshot-package.js";
+const BOOTSTRAP = ".opencode/plugins/superpowers.js";
+const BOOTSTRAP_SIZE = 5464;
+const BOOTSTRAP_SHA256 = "a5c5e1dbb0abfbd6ec3322b724b9a7b3318bbbb3d83f9a661c56ae0ed0a3adb8";
+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);
+        const pkg = await readArtifactObject(root, join(root, "package.json"));
+        if (pkg.name !== "superpowers" ||
+            pkg.type !== "module" ||
+            pkg.main !== BOOTSTRAP ||
+            typeof pkg.version !== "string" ||
+            !SEMVER_RE.test(pkg.version))
+            throw new Error("package metadata");
+        requireNoSnapshotDependencies(pkg);
+        await validateNativeSkill(root);
+        await requireSnapshotBootstrap(root, BOOTSTRAP, BOOTSTRAP_SIZE, BOOTSTRAP_SHA256);
+        const official = isOfficialSnapshotSource(selection.effectiveSource);
+        return {
+            kind: official ? "supported" : "experimental",
+            generation: "opencode-native-bootstrap-v1",
+            reason: official
+                ? "qualified upstream-native OpenCode bootstrap"
+                : "qualified OpenCode mechanics from a custom source",
+        };
+    }
+    catch {
+        return {
+            kind: "unsupported",
+            reason: `OpenCode package does not match the qualified native bootstrap profile: ${root}`,
+        };
+    }
+}
+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,
+        }),
+    };
+}

package/dist/harnesses/opencode/paths.js

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { assertNoFollowType, canonicalizeProspectivePath, isContained, } from "../../safe-path.js";
+function overlaps(left, right) {
+    return isContained(left, right) || isContained(right, left);
+}
+export async function assertOpenCodePreparationSeparate(paths) {
+    await assertNoFollowType(paths.configRoot, ["directory", "missing"]);
+    await assertNoFollowType(paths.managerRoot, ["directory", "missing"]);
+    const roots = [paths.preparedRoot, paths.installedRoot, paths.recoveryRoot];
+    const canonical = await Promise.all(roots.map(async (root) => {
+        await assertNoFollowType(root, ["directory", "missing"]);
+        return await canonicalizeProspectivePath(root);
+    }));
+    if (overlaps(canonical[0], canonical[1]) ||
+        overlaps(canonical[0], canonical[2]) ||
+        overlaps(canonical[1], canonical[2]))
+        throw new Error("storage roots overlap");
+}
+export function openCodePaths(env, cwd) {
+    const home = env.HOME && env.HOME.length > 0 ? env.HOME : homedir();
+    const homeDir = resolve(cwd, home);
+    const configured = env.XDG_CONFIG_HOME;
+    if (configured !== undefined &&
+        configured.length > 0 &&
+        !isAbsolute(configured))
+        throw new Error("XDG_CONFIG_HOME must be absolute");
+    const configRoot = join(configured && configured.length > 0 ? configured : join(homeDir, ".config"), "opencode");
+    const managerRoot = join(configRoot, "superpowers-manager");
+    return {
+        homeDir,
+        configRoot,
+        managerRoot,
+        preparedRoot: join(managerRoot, "prepared"),
+        installedRoot: join(managerRoot, "installed"),
+        recoveryRoot: join(managerRoot, "recovery"),
+    };
+}

package/dist/harnesses/opencode/prepare.js

@@ -0,0 +1,30 @@
+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());
+        await assertOpenCodePreparationSeparate(paths);
+        return successResult("prepare", null, []);
+    }
+    catch {
+        return failureResult("prepare", "invalid-package", "cannot validate OpenCode artifact storage", [], []);
+    }
+}
+const preparation = createSnapshotPreparation({
+    harness: "opencode",
+    label: "OpenCode",
+    preparationLocation: openCodePreparationLocation,
+    assessCompatibility: assessOpenCodeCompatibility,
+    readAssessment: readOpenCodePackageAssessment,
+});
+export const prepareOpenCodeCandidate = preparation.prepareCandidate;
+export const inspectOpenCodePrepared = preparation.inspectPrepared;
+export const readOpenCodePrepared = preparation.readPrepared;

package/dist/harnesses/opencode/presentation.js

@@ -0,0 +1,28 @@
+import { displaySource } from "../../selection.js";
+import { createSnapshotPresentation } from "../../snapshot-presentation.js";
+import { displayPath } from "../../validator.js";
+const renderProbe = (facts) => {
+    const fields = [
+        ["harness", "opencode"],
+        ["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 {
+        human: fields
+            .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
+            .join(""),
+        porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
+    };
+};
+export const openCodePresentation = createSnapshotPresentation("OpenCode", renderProbe, (input) => input.receiptDigest === null && input.registration === null);

package/dist/harnesses/opencode/state.js

@@ -0,0 +1,174 @@
+import { inspectionFailure, successResult, } from "../../adapter-result.js";
+import { displayPath } from "../../validator.js";
+import { observeSnapshot, sameSnapshotSource, } from "../../snapshot-package.js";
+import { classifyPathNoFollow } from "../../safe-path.js";
+import { inspectOpenCodeDiscovery, } from "./discovery.js";
+import { assessOpenCodeCompatibility, readOpenCodePackageAssessment, readOpenCodeReceipt, } from "./package.js";
+import { openCodePaths } from "./paths.js";
+function blocked(...stderr) {
+    return {
+        kind: "blocked",
+        output: { stdout: [], stderr: stderr.map((line) => displayPath(line)) },
+    };
+}
+function pathsFor(ctx) {
+    return openCodePaths(ctx.env ?? {}, process.cwd());
+}
+async function observeFacts(ctx) {
+    const paths = pathsFor(ctx);
+    const [discovery, snapshot, recoveryKind] = await Promise.all([
+        inspectOpenCodeDiscovery(paths, ctx.env ?? {}, process.cwd()),
+        observeSnapshot(paths.installedRoot, readOpenCodeReceipt),
+        classifyPathNoFollow(paths.recoveryRoot),
+    ]);
+    return {
+        paths,
+        discovery,
+        snapshot,
+        recovery: recoveryKind === "missing" ? "absent" : "required",
+    };
+}
+function assertInspectableFacts(facts) {
+    if (facts.discovery.managedEntries.length > 1)
+        throw new Error("ambiguous Manager registration");
+    if (facts.snapshot.kind === "unverified")
+        throw new Error("unverified Manager snapshot");
+    if (facts.discovery.managedEntries.length === 1 &&
+        facts.snapshot.kind === "absent")
+        throw new Error("unverified Manager registration");
+}
+function mutationDecision(facts) {
+    if (facts.recovery === "required")
+        return blocked(`error: OpenCode recovery required; preserve material at ${facts.paths.recoveryRoot}`);
+    if (facts.discovery.blockedInputs.length > 0)
+        return blocked("OpenCode configuration activity could not be established read-only:", ...facts.discovery.blockedInputs.map((input) => `- ${input}`));
+    if (facts.discovery.conflicts.length > 0)
+        return blocked("Conflicting unmanaged Superpowers OpenCode resources require manual resolution:", ...facts.discovery.conflicts.map((conflict) => `- ${conflict}`), "Remove or disable each resource manually, then retry.");
+    return { kind: "allowed" };
+}
+function registrationFor(facts) {
+    const managed = facts.discovery.managedEntries[0];
+    return managed === undefined
+        ? null
+        : {
+            observation: managed.observation,
+            entryIndex: managed.entry.index,
+            spec: managed.entry.spec,
+        };
+}
+export async function inspectOpenCodeOwnership(ctx) {
+    const operation = "inspect-opencode-ownership";
+    try {
+        const facts = await observeFacts(ctx);
+        assertInspectableFacts(facts);
+        const registration = registrationFor(facts);
+        const removalVerification = registration !== null
+            ? blocked("error: the Manager OpenCode registration is still present after removal")
+            : facts.snapshot.kind === "owned"
+                ? blocked("error: the Manager-owned OpenCode snapshot is still present after removal")
+                : facts.discovery.registrationUncertain
+                    ? blocked("error: unresolved OpenCode configuration remains after removal", ...facts.discovery.blockedInputs.map((input) => `- ${input}`))
+                    : { kind: "allowed" };
+        const conflicts = [
+            ...facts.discovery.conflicts,
+            ...facts.discovery.blockedInputs.map((input) => `${input} is unresolved`),
+        ];
+        const presentationValue = facts.snapshot.kind === "owned"
+            ? registration === null
+                ? `managed snapshot ${facts.snapshot.digest}`
+                : `managed ${facts.snapshot.digest}`
+            : facts.discovery.registrationUncertain
+                ? "unresolved configuration"
+                : "absent";
+        return successResult(operation, {
+            installEligibility: mutationDecision(facts),
+            removalInput: {
+                installedRoot: facts.paths.installedRoot,
+                registration,
+                receiptDigest: facts.snapshot.kind === "owned"
+                    ? facts.snapshot.receipt.digest
+                    : null,
+            },
+            removalVerification,
+            postRemovalOutput: { stdout: [], stderr: [] },
+            presentationValue,
+            presentationConflicts: conflicts,
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "OpenCode ownership");
+    }
+}
+function mismatch(operation, observedIdentity) {
+    return successResult(operation, { kind: "mismatch", observedIdentity }, []);
+}
+export async function inspectOpenCodeInstalled(selection, ctx) {
+    const operation = "inspect-opencode-installed";
+    let facts;
+    try {
+        facts = await observeFacts(ctx);
+    }
+    catch {
+        return inspectionFailure(operation, "OpenCode installed state");
+    }
+    if (facts.snapshot.kind === "absent") {
+        if (facts.discovery.managedEntries.length > 0)
+            return mismatch(operation, "registered without an installed snapshot");
+        return facts.discovery.registrationUncertain
+            ? mismatch(operation, "unresolved OpenCode configuration")
+            : successResult(operation, { kind: "absent", observedIdentity: "" }, []);
+    }
+    if (facts.snapshot.kind === "unverified")
+        return mismatch(operation, "unverified installed snapshot");
+    const observed = facts.snapshot.digest;
+    if (facts.discovery.managedEntries.length > 1)
+        return inspectionFailure(operation, "OpenCode installed state");
+    if (facts.discovery.managedEntries.length !== 1 ||
+        facts.discovery.conflicts.length > 0 ||
+        facts.discovery.blockedInputs.length > 0)
+        return mismatch(operation, observed);
+    try {
+        const prepared = await readOpenCodePackageAssessment(facts.paths.preparedRoot);
+        const installedProfile = await assessOpenCodeCompatibility(facts.paths.installedRoot, { effectiveSource: facts.snapshot.receipt.source });
+        if ((prepared.compatibility.kind !== "supported" &&
+            prepared.compatibility.kind !== "experimental") ||
+            (installedProfile.kind !== "supported" &&
+                installedProfile.kind !== "experimental") ||
+            prepared.receipt.commit !== selection.desiredCommit ||
+            !sameSnapshotSource(prepared.receipt.source, selection.effectiveSource) ||
+            facts.snapshot.receipt.commit !== prepared.receipt.commit ||
+            !sameSnapshotSource(facts.snapshot.receipt.source, prepared.receipt.source) ||
+            facts.snapshot.digest !== prepared.receipt.digest)
+            return mismatch(operation, observed);
+    }
+    catch {
+        return mismatch(operation, observed);
+    }
+    return successResult(operation, { kind: "current", observedIdentity: observed }, []);
+}
+export async function inspectOpenCodeControl(ctx) {
+    const operation = "inspect-opencode-control";
+    try {
+        const facts = await observeFacts(ctx);
+        assertInspectableFacts(facts);
+        const mutationEligibility = mutationDecision(facts);
+        return successResult(operation, {
+            probeEligibility: { kind: "allowed" },
+            mutationEligibility,
+            presentationValue: facts.recovery === "required"
+                ? `recovery required at ${facts.paths.recoveryRoot}`
+                : facts.discovery.managedEntries.length === 1
+                    ? "managed local registration"
+                    : facts.discovery.conflicts.length > 0 ||
+                        facts.discovery.blockedInputs.length > 0
+                        ? "unmanaged or unresolved configuration"
+                        : "unregistered",
+            ...(facts.recovery === "required"
+                ? { recoveryState: "required" }
+                : {}),
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "OpenCode update control");
+    }
+}

package/dist/harnesses/pi/compatibility.js

@@ -1,25 +1,12 @@
-import { createHash } from "node:crypto";
-import { lstat } from "node:fs/promises";
 import { join } from "node:path";
-import { readArtifactFile, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
+import { readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
 import { SEMVER_RE } from "../../domain/refs.js";
 import { validateSource } from "../../selection.js";
-const OFFICIAL_SOURCES = new Set([
-    "https://github.com/obra/superpowers",
-    "https://github.com/obra/superpowers.git",
-    "ssh://git@github.com/obra/superpowers.git",
-    "git@github.com:obra/superpowers.git",
-]);
-export function samePiSource(left, right) {
-    validateSource(left);
-    validateSource(right);
-    return (left === right ||
-        (OFFICIAL_SOURCES.has(left) && OFFICIAL_SOURCES.has(right)));
-}
+import { isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, } from "../../snapshot-package.js";
 export async function assessPiCompatibility(root, selection) {
     try {
         validateSource(selection.effectiveSource);
-        const official = OFFICIAL_SOURCES.has(selection.effectiveSource);
+        const official = isOfficialSnapshotSource(selection.effectiveSource);
         const pkg = await readArtifactObject(root, join(root, "package.json"));
         if (pkg.name !== "superpowers" ||
             pkg.type !== "module" ||
@@ -34,28 +21,9 @@ export async function assessPiCompatibility(root, selection) {
             JSON.stringify(pi.extensions) !== '["./.pi/extensions/superpowers.ts"]' ||
             JSON.stringify(pi.skills) !== '["./skills"]')
             throw new Error("resource declaration");
-        for (const key of [
-            "dependencies",
-            "optionalDependencies",
-            "peerDependencies",
-            "bundleDependencies",
-            "bundledDependencies",
-        ]) {
-            const value = pkg[key];
-            if (value !== undefined &&
-                (value === null ||
-                    typeof value !== "object" ||
-                    Object.keys(value).length !== 0))
-                throw new Error("runtime dependencies");
-        }
+        requireNoSnapshotDependencies(pkg);
         await validateNativeSkill(root);
-        const bootstrap = join(root, ".pi/extensions/superpowers.ts");
-        const bytes = await readArtifactFile(root, bootstrap, 4283);
-        if ((await lstat(bootstrap)).mode & 0o111 ||
-            bytes.length !== 4283 ||
-            createHash("sha256").update(bytes).digest("hex") !==
-                "39c27000c047f8a1399a76e032e4cd239d7bdb0be168a121f46a2ac719deaae0")
-            throw new Error("bootstrap implementation");
+        await requireSnapshotBootstrap(root, ".pi/extensions/superpowers.ts", 4283, "39c27000c047f8a1399a76e032e4cd239d7bdb0be168a121f46a2ac719deaae0");
         return {
             kind: official ? "supported" : "experimental",
             generation: "pi-native-bootstrap-v1",

package/dist/harnesses/pi/install.js

@@ -3,8 +3,10 @@ import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, unlink, } from "n
 import { basename, dirname, join } from "node:path";
 import { failureResult, successResult, } from "../../adapter-result.js";
 import { atomicWriteFile, beginDirectoryPublication, } from "../../atomic.js";
-import { normalizePiRuntimeVersion, runPi } from "./native.js";
-import { digestPiTree, readPiPackageAssessment, readPiReceipt, } from "./package.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 { inspectPiControl, inspectPiOwnership, } from "./state.js";
@@ -89,7 +91,7 @@ async function snapshot(root) {
     if ((await assertNoFollowType(root, ["directory", "missing"])) === "missing")
         return null;
     const receipt = await readPiReceipt(root);
-    if (receipt.digest !== (await digestPiTree(root)))
+    if (receipt.digest !== (await digestArtifactTree(root)))
         throw new Error("Pi snapshot changed");
     return receipt;
 }
@@ -347,7 +349,7 @@ export async function installPi(artifact, ctx, deps = DEFAULTS) {
         const priorRegistration = await registration(paths, deps);
         if (previous === null && priorRegistration !== null)
             throw new Error("unowned Pi registration");
-        accepted(normalizePiRuntimeVersion(await deps.run(["--version"], paths, ctx)));
+        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))
@@ -449,7 +451,7 @@ export async function removePi(input, ctx, deps = DEFAULTS) {
             return successResult("remove-pi", null, []);
         }
         if (registered !== null)
-            accepted(normalizePiRuntimeVersion(await deps.run(["--version"], paths, ctx)));
+            accepted(normalizeSnapshotRuntimeVersion("Pi", await deps.run(["--version"], paths, ctx)));
         await requireSnapshot(paths.installedRoot, previous);
         if (!sameRegistration(await registration(paths, deps), registered))
             throw new Error("Pi registration changed");

package/dist/harnesses/pi/native.js

@@ -1,7 +1,7 @@
 import { tmpdir } from "node:os";
 import { isAbsolute, resolve, sep } from "node:path";
-import { AdapterMessageLog, failureResult, successResult, } from "../../adapter-result.js";
-import { SEMVER_RE } from "../../domain/refs.js";
+import { failureResult, } from "../../adapter-result.js";
+import { nativeCommandResult, } from "../../harness-command-result.js";
 import { BOUNDED_EXECUTABLE, runValidator as runBoundedCommand, } from "../../validator.js";
 import { withWorkspace } from "../../workspace.js";
 function selectedExecutable(env, invocationCwd) {
@@ -10,12 +10,6 @@ function selectedExecutable(env, invocationCwd) {
         ? resolve(invocationCwd, configured)
         : configured;
 }
-function appendCaptured(log, channel, captured) {
-    log.appendBytes(channel, Buffer.from(captured.text));
-    if (captured.droppedBytes > 0) {
-        log.appendText(channel, `Pi ${channel} omitted ${captured.droppedBytes} bytes at the capture limit`);
-    }
-}
 export async function runPi(args, paths, ctx, execute = runBoundedCommand) {
     const operation = "pi-command";
     const env = ctx.env ?? {};
@@ -32,32 +26,7 @@ export async function runPi(args, paths, ctx, execute = runBoundedCommand) {
                 PI_OFFLINE: "1",
                 PI_SKIP_VERSION_CHECK: "1",
             }, workspace, workspace);
-            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 Pi executable (${errno})`, [], []);
-            }
-            const log = new AdapterMessageLog();
-            if (result.kind === "timedOut") {
-                appendCaptured(log, "stdout", result.stdout);
-                appendCaptured(log, "stderr", result.stderr);
-                return failureResult(operation, "timeout", `Pi command timed out after ${result.afterMs} ms`, [], log.snapshot());
-            }
-            if (result.code !== 0) {
-                appendCaptured(log, "stdout", result.stdout);
-                appendCaptured(log, "stderr", result.stderr);
-                return failureResult(operation, "nonzero-exit", result.code === null
-                    ? "Pi command exited without a status"
-                    : `Pi command exited with status ${result.code}`, [], log.snapshot());
-            }
-            if (result.stdout.droppedBytes > 0 || result.stderr.droppedBytes > 0) {
-                appendCaptured(log, "stdout", result.stdout);
-                appendCaptured(log, "stderr", result.stderr);
-                return failureResult(operation, "output-limit", "Pi command output exceeded the capture limit", [], log.snapshot());
-            }
-            appendCaptured(log, "stderr", result.stderr);
-            return successResult(operation, { stdout: result.stdout.text }, log.snapshot());
+            return nativeCommandResult("Pi", result);
         });
     }
     catch {
@@ -66,16 +35,3 @@ export async function runPi(args, paths, ctx, execute = runBoundedCommand) {
             : "cannot create an isolated Pi command workspace", [], []);
     }
 }
-export function normalizePiRuntimeVersion(result) {
-    if (!result.outcome.ok) {
-        return { status: result.status, outcome: result.outcome };
-    }
-    if (result.status !== 0) {
-        return failureResult("pi-runtime", "invalid-status", "Pi runtime inspection returned a nonzero status", [], result.outcome.messages);
-    }
-    const version = result.outcome.result.stdout.trim();
-    if (!SEMVER_RE.test(version)) {
-        return failureResult("pi-runtime", "invalid-version", "Pi runtime inspection returned an invalid version response", [], result.outcome.messages);
-    }
-    return successResult("pi-runtime", version, result.outcome.messages);
-}