superpowers-manager 0.8.0 → 0.9.1

package/dist/harnesses/pi/state.js

@@ -6,7 +6,7 @@ import { observeSnapshot, sameSnapshotSource, } from "../../snapshot-package.js"
 import { readPiPackageAssessment, readPiReceipt, } from "./package.js";
 import { piPaths } from "./paths.js";
 import { readPiSettings, resolveCanonicalPiLocalSource, resolvePiLocalSource, } from "./settings.js";
-import { classifyPathNoFollow } from "../../safe-path.js";
+import { canonicalizeProspectivePath, classifyPathNoFollow, } from "../../safe-path.js";
 // Verified remote spellings only: Pi 0.85.1 accepts http:// as Git. Unprefixed
 // github: and git+ forms stay local; git:-wrapped aliases and explicit transports
 // normalize only an exact GitHub authority and repository path (native source
@@ -102,19 +102,12 @@ function isKnownUpstreamPiSource(raw) {
 }
 async function observeSettings(paths) {
     const settings = await readPiSettings(paths.settingsFile, paths.homeDir);
-    const installedRoot = await resolveCanonicalPiLocalSource(paths.installedRoot, paths.agentDir, paths.homeDir);
-    let registration = null;
-    for (const entry of settings.packages) {
-        if ((await resolveCanonicalPiLocalSource(entry.source, paths.agentDir, paths.homeDir)) === installedRoot) {
-            registration = entry;
-        }
-    }
-    return { settings, registration };
+    return { settings, registration: settings.managerRegistration };
 }
 async function isNamedLocalSuperpowers(entry, paths, canonicalInstalledRoot) {
     const root = resolvePiLocalSource(entry.source, paths.agentDir, paths.homeDir);
     if (root === null ||
-        (await resolveCanonicalPiLocalSource(entry.source, paths.agentDir, paths.homeDir)) === canonicalInstalledRoot)
+        (await canonicalizeProspectivePath(root)) === canonicalInstalledRoot)
         return false;
     const rootKind = await classifyPathNoFollow(root);
     if (rootKind !== "directory" && rootKind !== "symlink")

package/dist/provenance.js

@@ -1,7 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import { COMMIT_INPUT_RE } from "./domain/refs.js";
-import { escapePythonJsonString } from "./python-json.js";
+import { escapeNonAscii } from "./python-json-format.js";
 import { SafetyError } from "./safety-error.js";
 import { parseStrictJson, } from "./strict-json.js";
 const PROVENANCE_STRICT_PROFILE = {
@@ -57,21 +56,6 @@ export async function readGeneratedCommitLenient(path) {
         return "";
     }
 }
-// Ported from
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:28-31::spw_generated_metadata_path(`.
-// The path the generated tree's provenance lives at, relative to a package
-// root.
-export function generatedMetadataPath(root) {
-    return join(root, "plugins", "superpowers", ".superpowers-upstream.json");
-}
-// Ported from
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/lifecycle.sh:33-37::spw_generated_commit_or_empty`.
-// Lenient by design: a missing or malformed generated provenance file yields
-// "", which the typed prepared-state flow reports as "needs prepare".
-// Aborting here would deny the operator the remediation path.
-export async function generatedCommitOrEmpty(root) {
-    return readGeneratedCommitLenient(generatedMetadataPath(root));
-}
 export async function readCodexBuildSource(path) {
     try {
         const parsed = parseStrictJson(await readFile(path), PROVENANCE_CODEX_SOURCE_PROFILE);
@@ -96,8 +80,8 @@ const PROVENANCE_KEYS = [
     "upstream_manifest_version",
 ];
 export function serializeProvenance(record) {
-    const lines = PROVENANCE_KEYS.map((key) => `  "${key}": "${escapePythonJsonString(record[key])}"`);
-    return `{\n${lines.join(",\n")}\n}\n`;
+    const ordered = Object.fromEntries(PROVENANCE_KEYS.map((key) => [key, record[key]]));
+    return `${escapeNonAscii(JSON.stringify(ordered, null, 2))}\n`;
 }
 export async function writeProvenance(path, record) {
     try {

package/dist/resource-lock.js

@@ -2,13 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, realpath, rmdir, unlink, writeFile, } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { canonicalizeProspectivePath } from "./safe-path.js";
+import { canonicalizeProspectivePath, isErrno } from "./safe-path.js";
 import { SafetyError } from "./safety-error.js";
-function errnoIs(cause, code) {
-    return (cause instanceof Error &&
-        "code" in cause &&
-        cause.code === code);
-}
 async function nearestExistingDirectory(path) {
     let cursor = path;
     for (;;) {
@@ -16,7 +11,7 @@ async function nearestExistingDirectory(path) {
             return await realpath(cursor);
         }
         catch (cause) {
-            if (!errnoIs(cause, "ENOENT"))
+            if (!isErrno(cause, "ENOENT"))
                 throw cause;
             const parent = dirname(cursor);
             if (parent === cursor)
@@ -55,7 +50,7 @@ async function resourceLock(resource) {
             return { resource: canonical, lockPath: candidate };
         }
         catch (cause) {
-            if (!errnoIs(cause, "ENOENT")) {
+            if (!isErrno(cause, "ENOENT")) {
                 throw new SafetyError("resource-lock", `cannot inspect resource lock: ${canonical}`, { cause });
             }
         }
@@ -71,7 +66,7 @@ async function assertNoCompetingResourceLock(lock, held) {
             await lstat(candidate);
         }
         catch (cause) {
-            if (errnoIs(cause, "ENOENT"))
+            if (isErrno(cause, "ENOENT"))
                 continue;
             throw new SafetyError("resource-lock", `cannot inspect resource lock: ${lock.resource}`, { cause });
         }
@@ -177,12 +172,12 @@ class FilesystemResourceCoordinator {
                 }
             }
             catch (cause) {
-                if (errnoIs(cause, "ENOENT")) {
+                if (isErrno(cause, "ENOENT")) {
                     try {
                         await lstat(lock.lockPath);
                     }
                     catch (again) {
-                        if (errnoIs(again, "ENOENT"))
+                        if (isErrno(again, "ENOENT"))
                             return observation(this.#held.has(lock.lockPath) ? "uninspectable" : "idle");
                     }
                 }
@@ -206,7 +201,7 @@ class FilesystemResourceCoordinator {
                 const existing = this.#held.get(lock.lockPath);
                 if (existing !== undefined) {
                     existing.count += 1;
-                    acquired.push({ held: existing });
+                    acquired.push(existing);
                     continue;
                 }
                 const token = randomUUID();
@@ -214,7 +209,7 @@ class FilesystemResourceCoordinator {
                     await mkdir(lock.lockPath);
                 }
                 catch (cause) {
-                    if (errnoIs(cause, "EEXIST")) {
+                    if (isErrno(cause, "EEXIST")) {
                         throw new SafetyError("resource-lock", `resource is busy: ${lock.resource}`, { cause });
                     }
                     throw new SafetyError("resource-lock", `cannot acquire resource lock: ${lock.resource}`, { cause });
@@ -231,7 +226,7 @@ class FilesystemResourceCoordinator {
                     throw new SafetyError("resource-lock", `cannot record resource lock ownership: ${lock.resource}`, { cause });
                 }
                 this.#held.set(lock.lockPath, held);
-                acquired.push({ held });
+                acquired.push(held);
             }
             // A missing ancestor can appear between placement discovery and mkdir,
             // leaving concurrently acquired markers at different depths. Checking
@@ -247,9 +242,9 @@ class FilesystemResourceCoordinator {
         }
         let firstReleaseFailure = null;
         for (const entry of acquired.reverse()) {
-            const released = await releaseOwned(entry.held);
+            const released = await releaseOwned(entry);
             if (!released.keepHeld) {
-                this.#held.delete(entry.held.lockPath);
+                this.#held.delete(entry.lockPath);
             }
             firstReleaseFailure ??= released.failure;
         }

package/dist/safe-path.js

@@ -1,4 +1,4 @@
-import { lstat, readlink, realpath } from "node:fs/promises";
+import { lstat, readlink, realpath, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, sep, } from "node:path";
 import { SafetyError } from "./safety-error.js";
 export function isErrno(value, code) {
@@ -6,6 +6,33 @@ export function isErrno(value, code) {
         "code" in value &&
         value.code === code);
 }
+// Follow symlinks, like `[ -d ]` / `[ -f ]`: a regular file, a broken
+// symlink, or an unreadable path is not a directory (and vice versa), so any
+// stat failure answers false.
+export async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `ENOENT`/`ENOTDIR` mean *missing*; every other error rejects. This is the
+ * only place the absence set is defined.
+ */
+export function isAbsenceError(cause) {
+    const code = cause?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
 export function isContained(root, candidate) {
     const suffix = relative(root, candidate);
     return (suffix === "" ||

package/dist/selection.js

@@ -1,6 +1,6 @@
 import { isIP } from "node:net";
-import { COMMIT_RE, TAG_RE, normalizeCommitInput } from "./domain/refs.js";
-import { escapePythonJsonString } from "./python-json.js";
+import { COMMIT_RE, TAG_RE } from "./domain/refs.js";
+import { escapeNonAscii } from "./python-json-format.js";
 import { SafetyError } from "./safety-error.js";
 export function selectionError(message, cause) {
     return new SafetyError("selection", message, { cause });
@@ -179,22 +179,18 @@ export function normalizeSaved(record) {
         saved_commit: record.mode === "pinned" ? record.commit : "",
     };
 }
-export function normalizePinnedArguments(arguments_) {
-    const requestedRef = normalizeCommitInput(arguments_.requestedRef) ?? arguments_.requestedRef;
-    const resolvedRef = normalizeCommitInput(arguments_.resolvedRef) ?? arguments_.resolvedRef;
-    const commit = arguments_.commit.toLowerCase();
-    return {
-        schema_version: 1,
-        mode: "pinned",
-        source: arguments_.source,
-        requested_ref: requestedRef,
-        resolved_ref: resolvedRef,
-        commit,
-    };
-}
 export function serializeRecord(record) {
-    if (record.mode === "track-latest") {
-        return `{\n  "schema_version": 1,\n  "mode": "track-latest",\n  "source": "${escapePythonJsonString(record.source)}"\n}\n`;
-    }
-    return `{\n  "schema_version": 1,\n  "mode": "pinned",\n  "source": "${escapePythonJsonString(record.source)}",\n  "requested_ref": "${escapePythonJsonString(record.requested_ref)}",\n  "resolved_ref": "${escapePythonJsonString(record.resolved_ref)}",\n  "commit": "${escapePythonJsonString(record.commit)}"\n}\n`;
+    // Keys are listed here, not taken from the caller's object, so the bytes do
+    // not depend on how the record was built.
+    const ordered = record.mode === "track-latest"
+        ? { schema_version: 1, mode: record.mode, source: record.source }
+        : {
+            schema_version: 1,
+            mode: record.mode,
+            source: record.source,
+            requested_ref: record.requested_ref,
+            resolved_ref: record.resolved_ref,
+            commit: record.commit,
+        };
+    return `${escapeNonAscii(JSON.stringify(ordered, null, 2))}\n`;
 }

package/dist/snapshot-journal.js

@@ -0,0 +1,101 @@
+import { lstat, open, readdir, readFile, rmdir, unlink, } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { atomicWriteFile } from "./atomic.js";
+import { assertNoFollowType, classifyPathNoFollow } from "./safe-path.js";
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+export async function identity(path) {
+    await assertNoFollowType(path, ["directory"]);
+    return await lstat(path);
+}
+export function journalPath(pending) {
+    return join(pending.paths.recoveryRoot, "transaction.json");
+}
+export async function requireNoRecovery(paths) {
+    await assertNoFollowType(paths.recoveryRoot, ["missing"]);
+}
+export async function hasRecovery(paths) {
+    try {
+        return (await classifyPathNoFollow(paths.recoveryRoot)) !== "missing";
+    }
+    catch {
+        return true;
+    }
+}
+async function syncDirectoryStrict(path) {
+    const directory = await open(path, "r");
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+export function publicationPaths(canonicalRoot, token) {
+    return {
+        backup: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.bak.${token}`),
+        stage: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.stage.${token}`),
+    };
+}
+// The first journal is durable before either a staging tree or backup exists.
+export async function createJournal(recoveryRoot, bytes) {
+    const path = join(recoveryRoot, "transaction.json");
+    const handle = await open(path, "wx", 0o600);
+    try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await syncDirectoryStrict(recoveryRoot);
+    return await lstat(path);
+}
+export function createSnapshotJournal(rules) {
+    const { label } = rules;
+    async function requireIdentity(path, expected) {
+        if (!sameIdentity(await identity(path), expected))
+            throw new Error(`${label} directory changed`);
+    }
+    async function requireJournal(pending) {
+        if ((await rules.validatePaths(pending.paths)) !== pending.canonicalRoot ||
+            pending.journal.installedRoot !== pending.canonicalRoot ||
+            !/^[a-f0-9]{32}$/u.test(pending.journal.token))
+            throw new Error(`${label} recovery root changed`);
+        await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
+        const path = journalPath(pending);
+        await assertNoFollowType(path, ["regular-file"]);
+        const observed = await lstat(path);
+        if (!sameIdentity(observed, pending.journalIdentity) ||
+            observed.size > rules.readCap ||
+            !(await readFile(path)).equals(rules.serialize(pending.journal)))
+            throw new Error(`${label} recovery journal changed`);
+        const expected = publicationPaths(pending.canonicalRoot, pending.journal.token);
+        if (pending.backup !== expected.backup || pending.stage !== expected.stage)
+            throw new Error(`${label} recovery paths changed`);
+    }
+    async function phase(pending, next, changes = {}) {
+        await requireJournal(pending);
+        const journal = { ...pending.journal, ...changes, phase: next };
+        const bytes = rules.serialize(journal);
+        await atomicWriteFile(journalPath(pending), bytes, {
+            validate: async (temporary) => {
+                if (!(await readFile(temporary)).equals(bytes))
+                    throw new Error(`${label} journal write changed`);
+            },
+        });
+        await syncDirectoryStrict(pending.paths.recoveryRoot);
+        pending.journal = journal;
+        pending.journalIdentity = await lstat(journalPath(pending));
+    }
+    async function retireJournal(pending) {
+        await requireJournal(pending);
+        if ((await readdir(pending.paths.recoveryRoot)).some((name) => name !== "transaction.json"))
+            throw new Error(`unknown ${label} recovery material`);
+        await unlink(journalPath(pending));
+        await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
+        await rmdir(pending.paths.recoveryRoot);
+    }
+    return { requireIdentity, requireJournal, phase, retireJournal };
+}

package/dist/snapshot-package.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { lstat } from "node:fs/promises";
 import { join } from "node:path";
-import { addArtifactHashField, digestArtifactTree, readArtifactFile, } from "./artifact-tree.js";
+import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, addArtifactHashField, digestArtifactTree, readArtifactFile, readArtifactObject, } from "./artifact-tree.js";
+import { COMMIT_RE } from "./domain/refs.js";
 import { classifyPathNoFollow } from "./safe-path.js";
+import { SafetyError } from "./safety-error.js";
 import { validateSource } from "./selection.js";
 const OFFICIAL_SOURCES = new Set([
     "https://github.com/obra/superpowers",
@@ -76,3 +78,62 @@ export async function requireSnapshotBootstrap(root, relativePath, expectedSize,
         createHash("sha256").update(bytes).digest("hex") !== expectedDigest)
         throw new Error("bootstrap implementation");
 }
+// strictGeneration=false admits a generation on unknown/unsupported
+// compatibility. Only Pi passes false: its readers keep that recorded policy
+// (tests/unit/harnesses/pi/package.test.ts, "receipt readers retain their
+// distinct unsupported-generation policy").
+function isReceiptCompatibility(value, strictGeneration) {
+    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") &&
+        (!strictGeneration || compatibility.generation === undefined));
+}
+export function createSnapshotReceipts(rules) {
+    const module = `${rules.harness}-package`;
+    async function readReceipt(root) {
+        const path = join(root, ARTIFACT_RECEIPT);
+        try {
+            const value = await readArtifactObject(root, path);
+            if (value.schema !== 1 ||
+                value.manager !== "superpowers-manager" ||
+                value.harness !== rules.harness ||
+                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, rules.strictGeneration))
+                throw new Error("receipt compatibility");
+            return value;
+        }
+        catch (cause) {
+            throw new SafetyError(module, `invalid ${rules.label} artifact receipt: ${path}`, { cause });
+        }
+    }
+    async function readAssessment(root) {
+        const receipt = await readReceipt(root);
+        if ((await digestArtifactTree(root)) !== receipt.digest)
+            throw new SafetyError(module, `${rules.label} artifact digest mismatch: ${root}`);
+        return {
+            receipt,
+            compatibility: await rules.assessCompatibility(root, {
+                effectiveSource: receipt.source,
+            }),
+        };
+    }
+    return { readReceipt, readAssessment };
+}

package/dist/snapshot-prepare.js

@@ -6,6 +6,10 @@ import { materializeGitTree } from "./git-tree.js";
 import { classifyPathNoFollow } from "./safe-path.js";
 import { sameSnapshotSource, snapshotReceiptBinding, } from "./snapshot-package.js";
 export function createSnapshotPreparation(b) {
+    const preparationLocation = (ctx) => ({
+        destinationRoot: b.paths(ctx.env ?? {}, process.cwd()).preparedRoot,
+        stagingLeaf: "superpowers",
+    });
     const artifactFrom = (root, a) => ({
         root,
         commit: a.receipt.commit,
@@ -13,6 +17,7 @@ export function createSnapshotPreparation(b) {
         compatibility: a.compatibility,
     });
     return {
+        preparationLocation,
         async prepareCandidate(input) {
             try {
                 await materializeGitTree(input.upstreamRoot, input.selection.desiredCommit, input.candidateRoot);
@@ -20,6 +25,8 @@ export function createSnapshotPreparation(b) {
                 if (compatibility.kind === "unsupported" ||
                     compatibility.kind === "unknown")
                     return failureResult("prepare", "unsupported", compatibility.reason, [], []);
+                if (b.rewrite !== undefined)
+                    await b.rewrite(input.candidateRoot, input.selection);
                 const digest = await digestArtifactTree(input.candidateRoot);
                 const identity = {
                     schema: 1,
@@ -42,7 +49,7 @@ export function createSnapshotPreparation(b) {
             }
         },
         async inspectPrepared(selection, ctx) {
-            const root = b.preparationLocation(ctx).destinationRoot;
+            const root = preparationLocation(ctx).destinationRoot;
             const unknown = {
                 kind: "unknown",
                 reason: `${b.label} prepared compatibility evidence is missing`,
@@ -83,7 +90,7 @@ export function createSnapshotPreparation(b) {
             }
         },
         async readPrepared(ctx) {
-            const root = b.preparationLocation(ctx).destinationRoot;
+            const root = preparationLocation(ctx).destinationRoot;
             try {
                 const assessment = await b.readAssessment(root);
                 if (assessment.compatibility.kind !== "supported" &&

package/dist/snapshot-presentation.js

@@ -42,3 +42,12 @@ export function createSnapshotPresentation(label, renderProbe, wasAbsent) {
         },
     };
 }
+// Each harness chooses its fields and applies its own escaping before calling.
+export function probeOutput(fields) {
+    return {
+        human: fields
+            .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
+            .join(""),
+        porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
+    };
+}

package/dist/upstream.js

@@ -1,8 +1,9 @@
-import { readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { COMMIT_INPUT_RE, compareStable, parseStableTag, } from "./domain/refs.js";
 import { runGit } from "./git.js";
 import { SafetyError } from "./safety-error.js";
+import { isDirectory } from "./safe-path.js";
 import { displaySource } from "./selection.js";
 import { withWorkspace } from "./workspace.js";
 const UNAVAILABLE_OBJECT_RE = /not our ref|unadvertised object|couldn't find remote ref/;
@@ -35,16 +36,6 @@ function failed(result) {
 function combined(result) {
     return `${result.stdout}${result.stderr}`.replace(/\n+$/, "");
 }
-// Mirrors `[ -d "$repository/.git" ]`: a regular file, a broken symlink, or
-// an unreadable path is *not* a directory, so the cache is re-initialized.
-async function isDirectory(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
 export function parseLsRemote(output) {
     const entries = [];
     for (const line of output.split("\n")) {
@@ -251,3 +242,8 @@ export async function fetchExactCommit(source, commit, repository, workspacePare
         }
     });
 }
+// An explicit relative SUPERPOWERS_CACHE_DIR resolves against the
+// invocation's working directory.
+export function upstreamCacheRoot(root, env) {
+    return resolve(env.SUPERPOWERS_CACHE_DIR || join(root, ".cache", "upstream"), "superpowers");
+}

package/dist/validator.js

@@ -198,14 +198,21 @@ export async function resolveValidator(configured) {
     // runs whatever PATH selects -- the same divergence that makes realpath unsafe
     // here.
     const pathLike = configured.includes(sep);
+    if (!pathLike) {
+        return {
+            configured,
+            resolved: null,
+            isSymlink: false,
+            isDirectory: false,
+            exists: false,
+        };
+    }
     let isSymlink = false;
-    if (pathLike) {
-        try {
-            isSymlink = (await lstat(configured)).isSymbolicLink();
-        }
-        catch {
-            /* spawn reports the real reason */
-        }
+    try {
+        isSymlink = (await lstat(configured)).isSymbolicLink();
+    }
+    catch {
+        /* spawn reports the real reason */
     }
     // Resolve ONLY when the configured value contains a path separator -- which is
     // exactly when spawn bypasses PATH and the two agree about the target. For a
@@ -214,25 +221,21 @@ export async function resolveValidator(configured) {
     // interpreter and spawn("node") ran another. Resolving a bare name would let the
     // manager confidently disclose a file it is not about to run.
     let resolved = null;
-    if (configured.includes(sep)) {
-        try {
-            resolved = await realpath(configured);
-        }
-        catch {
-            /* unresolvable; stays null and is never claimed */
-        }
+    try {
+        resolved = await realpath(configured);
+    }
+    catch {
+        /* unresolvable; stays null and is never claimed */
     }
     let isDirectory = false;
     let exists = false;
-    if (pathLike) {
-        try {
-            const s = await stat(configured);
-            isDirectory = s.isDirectory();
-            exists = true;
-        }
-        catch {
-            /* spawn reports the real reason */
-        }
+    try {
+        const s = await stat(configured);
+        isDirectory = s.isDirectory();
+        exists = true;
+    }
+    catch {
+        /* spawn reports the real reason */
     }
     return { configured, resolved, isSymlink, isDirectory, exists };
 }