dw-sdlc 0.21.0 → 0.21.1

package/dist/commands/worker-report.js

@@ -2,8 +2,8 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
-import { parseArgs } from "node:util";
-import { call, describe, lead, refuse, Refusal, said, wholeNumber } from "../worker/herdr.js";
+import { CannotRun, messageOf, readArgs, usageError } from "../cannot-run.js";
+import { lead, sendTo, wholeNumber } from "../worker/herdr.js";
 export const summary = "deliver a Recap to the Lead, retrying while it is blocked";
 const USAGE = `Usage: dw-sdlc worker report --to <lead> --recap <file> [--attempts <n>] [--interval <seconds>]
 
@@ -18,47 +18,40 @@ it at once with exit 1.
 Needs a terminal herdr started ($HC_TERMINAL_ID) and hc on PATH.
 
 Exit 0 delivered, 1 not delivered, 2 when it cannot run.`;
-/** `hc send` exits with this when the target is blocked on a permission or a question. */
-const BLOCKED = 9;
 const DEFAULT_ATTEMPTS = 30;
 const DEFAULT_INTERVAL = 60;
 /** The longest Recap that goes as itself, in characters; a longer one goes as a path. */
 const SHORT = 300;
 function parseCli(argv) {
-    try {
-        const { values } = parseArgs({
-            args: argv,
-            options: {
-                help: { type: "boolean", short: "h" },
-                to: { type: "string" },
-                recap: { type: "string" },
-                attempts: { type: "string" },
-                interval: { type: "string" }
-            }
-        });
-        if (values.help === true) {
-            return "help";
-        }
-        const { to, recap } = values;
-        if (to === undefined || to === "") {
-            return { error: "name the Lead's terminal: --to <lead>" };
-        }
-        if (recap === undefined) {
-            return { error: "name the Recap file: --recap <file>" };
-        }
-        const attempts = wholeNumber("--attempts", values.attempts, DEFAULT_ATTEMPTS, 1);
-        const interval = wholeNumber("--interval", values.interval, DEFAULT_INTERVAL, 0);
-        if (typeof attempts === "object") {
-            return attempts;
+    const { values } = readArgs({
+        args: argv,
+        options: {
+            help: { type: "boolean", short: "h" },
+            to: { type: "string" },
+            recap: { type: "string" },
+            attempts: { type: "string" },
+            interval: { type: "string" }
         }
-        if (typeof interval === "object") {
-            return interval;
-        }
-        return { to, recap, attempts, interval };
+    }, USAGE);
+    if (values.help === true) {
+        return { help: true };
     }
-    catch (error) {
-        return { error: describe(error) };
+    const { to, recap } = values;
+    if (to === undefined || to === "") {
+        throw usageError("name the Lead's terminal: --to <lead>", USAGE);
+    }
+    if (recap === undefined) {
+        throw usageError("name the Recap file: --recap <file>", USAGE);
     }
+    const attempts = wholeNumber("--attempts", values.attempts, DEFAULT_ATTEMPTS, 1);
+    const interval = wholeNumber("--interval", values.interval, DEFAULT_INTERVAL, 0);
+    if (typeof attempts === "object") {
+        throw usageError(attempts.error, USAGE);
+    }
+    if (typeof interval === "object") {
+        throw usageError(interval.error, USAGE);
+    }
+    return { help: false, to, recap, attempts, interval };
 }
 /** What to send for the Recap in `file`: the Recap itself when it is one short line, else the file's path. */
 function messageFor(file) {
@@ -68,10 +61,10 @@ function messageFor(file) {
         text = readFileSync(path, "utf8").trim();
     }
     catch (error) {
-        throw new Refusal(`cannot read the Recap ${file}: ${describe(error)}`);
+        throw new CannotRun(`cannot read the Recap ${file}: ${messageOf(error)}`);
     }
     if (text === "") {
-        throw new Refusal(`the Recap ${file} is empty`);
+        throw new CannotRun(`the Recap ${file} is empty`);
     }
     return { message: text.includes("\n") || text.length > SHORT ? path : text, path };
 }
@@ -79,13 +72,13 @@ async function report({ to, recap, attempts, interval }) {
     lead();
     const { message, path } = messageFor(recap);
     for (let attempt = 1; attempt <= attempts; attempt += 1) {
-        const sent = call("hc", ["send", to, message]);
-        if (sent.status === 0) {
+        const sent = sendTo(to, message);
+        if (sent === "sent") {
             process.stdout.write(`reported to ${to}\n`);
             return 0;
         }
-        if (sent.status !== BLOCKED) {
-            process.stderr.write(`dw-sdlc worker report: hc send failed: ${said(sent)} — the Recap stays at ${path}\n`);
+        if (sent !== "blocked") {
+            process.stderr.write(`dw-sdlc worker report: ${sent.refused} — the Recap stays at ${path}\n`);
             return 1;
         }
         if (attempt === attempts) {
@@ -100,18 +93,9 @@ async function report({ to, recap, attempts, interval }) {
 }
 export async function run(argv) {
     const cli = parseCli(argv);
-    if (cli === "help") {
+    if (cli.help) {
         process.stdout.write(`${USAGE}\n`);
         return 0;
     }
-    if ("error" in cli) {
-        process.stderr.write(`dw-sdlc worker report: ${cli.error}\n\n${USAGE}\n`);
-        return 2;
-    }
-    try {
-        return await report(cli);
-    }
-    catch (error) {
-        return refuse("worker report", error);
-    }
+    return report(cli);
 }

package/dist/commands/worker-start.js

@@ -2,9 +2,9 @@
 // and effort the config names, and reads back whether the Worker took it.
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { parseArgs } from "node:util";
 import { mainCheckout, repositoryRoot, resolveConfig, WORKER_EFFORTS } from "../agentic-config.js";
-import { describe, isLive, lead, refuse, Refusal, wholeNumber, workersOf } from "../worker/herdr.js";
+import { CannotRun, messageOf, readArgs, usageError } from "../cannot-run.js";
+import { isLive, lead, wholeNumber, workersOf } from "../worker/herdr.js";
 import { launch, NAME, spaceOf, TAB_WAIT, undelivered } from "../worker/launch.js";
 import { freshenOrigin } from "../worker/origin.js";
 export const summary = "start a Worker on a Brief in a herdr terminal";
@@ -38,49 +38,44 @@ Exit 0 started and delivered, 1 started but not delivered, 2 when it cannot run,
 const DEFAULT_MAX_WORKERS = 3;
 const DEFAULT_WAIT = 30;
 function parseCli(argv) {
-    try {
-        const { values } = parseArgs({
-            args: argv,
-            options: {
-                help: { type: "boolean", short: "h" },
-                json: { type: "boolean" },
-                brief: { type: "string" },
-                name: { type: "string" },
-                model: { type: "string" },
-                effort: { type: "string" },
-                "max-workers": { type: "string" },
-                wait: { type: "string" }
-            }
-        });
-        if (values.help === true) {
-            return "help";
-        }
-        const { brief, name, model, effort } = values;
-        if (brief === undefined) {
-            return { error: "name the Brief file: --brief <file>" };
-        }
-        if (name === undefined || !NAME.test(name)) {
-            return { error: `--name takes 1-32 of a-z, 0-9, - and _, not ${JSON.stringify(name ?? "")}` };
-        }
-        if (model !== undefined && (model.trim() === "" || model.startsWith("-"))) {
-            return { error: `--model takes a model name, not ${JSON.stringify(model)}` };
-        }
-        if (effort !== undefined && !WORKER_EFFORTS.includes(effort)) {
-            return { error: `--effort takes one of ${WORKER_EFFORTS.join(", ")}, not ${JSON.stringify(effort)}` };
+    const { values } = readArgs({
+        args: argv,
+        options: {
+            help: { type: "boolean", short: "h" },
+            json: { type: "boolean" },
+            brief: { type: "string" },
+            name: { type: "string" },
+            model: { type: "string" },
+            effort: { type: "string" },
+            "max-workers": { type: "string" },
+            wait: { type: "string" }
         }
-        const max = wholeNumber("--max-workers", values["max-workers"], DEFAULT_MAX_WORKERS, 1);
-        const wait = wholeNumber("--wait", values.wait, DEFAULT_WAIT, 0);
-        if (typeof max === "object") {
-            return max;
-        }
-        if (typeof wait === "object") {
-            return wait;
-        }
-        return { brief, name, model, effort, max, wait, json: values.json === true };
+    }, USAGE);
+    if (values.help === true) {
+        return { help: true };
     }
-    catch (error) {
-        return { error: describe(error) };
+    const { brief, name, model, effort } = values;
+    if (brief === undefined) {
+        throw usageError("name the Brief file: --brief <file>", USAGE);
+    }
+    if (name === undefined || !NAME.test(name)) {
+        throw usageError(`--name takes 1-32 of a-z, 0-9, - and _, not ${JSON.stringify(name ?? "")}`, USAGE);
     }
+    if (model !== undefined && (model.trim() === "" || model.startsWith("-"))) {
+        throw usageError(`--model takes a model name, not ${JSON.stringify(model)}`, USAGE);
+    }
+    if (effort !== undefined && !WORKER_EFFORTS.includes(effort)) {
+        throw usageError(`--effort takes one of ${WORKER_EFFORTS.join(", ")}, not ${JSON.stringify(effort)}`, USAGE);
+    }
+    const max = wholeNumber("--max-workers", values["max-workers"], DEFAULT_MAX_WORKERS, 1);
+    const wait = wholeNumber("--wait", values.wait, DEFAULT_WAIT, 0);
+    if (typeof max === "object") {
+        throw usageError(max.error, USAGE);
+    }
+    if (typeof wait === "object") {
+        throw usageError(wait.error, USAGE);
+    }
+    return { help: false, brief, name, model, effort, max, wait, json: values.json === true };
 }
 /** The Brief's text; a file that is missing or holds only whitespace stops the command. */
 function readBrief(file) {
@@ -89,10 +84,10 @@ function readBrief(file) {
         text = readFileSync(resolve(file), "utf8");
     }
     catch (error) {
-        throw new Refusal(`cannot read the Brief ${file}: ${describe(error)}`);
+        throw new CannotRun(`cannot read the Brief ${file}: ${messageOf(error)}`);
     }
     if (text.trim() === "") {
-        throw new Refusal(`the Brief ${file} is empty`);
+        throw new CannotRun(`the Brief ${file} is empty`);
     }
     return text;
 }
@@ -105,13 +100,13 @@ async function start(cli) {
     const { baseBranch, worker } = resolveConfig(checkout).config;
     const command = worker.command.split(/\s+/).filter(Boolean);
     if (command.length === 0) {
-        throw new Refusal("worker.command holds no command", "set it in .ai/agentic.config.local.json, or remove the key");
+        throw new CannotRun("worker.command holds no command", "set it in .ai/agentic.config.local.json, or remove the key");
     }
     const model = cli.model ?? worker.model;
     const effort = cli.effort ?? worker.effort;
     const live = workersOf(leadId, false).filter(isLive);
     if (live.length >= cli.max) {
-        throw new Refusal(`${leadId} already has ${live.length} live Workers (the limit is ${cli.max})`, `carry one through first, or raise the limit with --max-workers ${live.length + 1}`);
+        throw new CannotRun(`${leadId} already has ${live.length} live Workers (the limit is ${cli.max})`, `carry one through first, or raise the limit with --max-workers ${live.length + 1}`);
     }
     // Before hc run, so a failed fetch starts no terminal.
     freshenOrigin(root, baseBranch);
@@ -139,18 +134,9 @@ async function start(cli) {
 }
 export async function run(argv) {
     const cli = parseCli(argv);
-    if (cli === "help") {
+    if (cli.help) {
         process.stdout.write(`${USAGE}\n`);
         return 0;
     }
-    if ("error" in cli) {
-        process.stderr.write(`dw-sdlc worker start: ${cli.error}\n\n${USAGE}\n`);
-        return 2;
-    }
-    try {
-        return await start(cli);
-    }
-    catch (error) {
-        return refuse("worker start", error);
-    }
+    return start(cli);
 }

package/dist/drift.js

@@ -1,8 +1,9 @@
 // Drift: a file a Step creates, changes or deletes while the Gate runs. Before and after each Step the
 // Gate records the tree of every file git tracks or would track, never against HEAD, so an ignored
 // file never drifts and an edit made before the run sits in both records.
+import { git } from "./git.js";
 import { stoppedBy } from "./run-command.js";
-import { git, workingTree } from "./working-tree.js";
+import { workingTree } from "./working-tree.js";
 const REMEDIES = {
     drift: "commit the change, or make the Step only read",
     cannotWatch: 'run the Gate in a git checkout, or set gate.drift to "allow"'

package/dist/exec.d.ts

@@ -10,5 +10,25 @@ export type ExecOptions = {
 /** A tool that outlived its limit and was stopped; the message names it. */
 export declare class TimedOut extends Error {
 }
+/** Sends `signal` to every process of the group `pid` leads; nothing when the group is gone. */
+export declare function signalGroup(pid: number, signal: NodeJS.Signals): void;
 /** `tool args` as a child process; a tool's own exit, or its absence, is the caller's. Throws `TimedOut` at the limit. */
 export declare function exec(tool: string, args: string[], options?: ExecOptions): SpawnSyncReturns<string>;
+/** What a tool the command needs answered: its exit status, 1 for a signal, and both streams. */
+export type Called = {
+    status: number;
+    stdout: string;
+    stderr: string;
+};
+/** The first line of a tool's output that says anything, trimmed; undefined where none does. */
+export declare function firstLine(text: string): string | undefined;
+/** Why a call failed, in the tool's words: its first line, stderr before stdout, else the exit it ended with. */
+export declare function whyFailed({ status, stdout, stderr }: Called): string;
+/**
+ * `tool args` for a command that cannot go on without the tool: one not on PATH stops the command with
+ * `missing`, one past its limit with `stalled`. Its own exit is the caller's.
+ */
+export declare function need(tool: string, args: string[], remedies: {
+    missing: string;
+    stalled: string;
+}): Called;

package/dist/exec.js

@@ -2,6 +2,7 @@
 // every child it started; no terminal, so no prompt, ssh's included; Ctrl-C stops the package, not the
 // tool. A Step of the Gate runs through `run-command.ts`, as long as it takes.
 import { spawnSync } from "node:child_process";
+import { CannotRun } from "./cannot-run.js";
 const LIMIT_MS = 120_000;
 /** For what the network or a repository's size can stretch: a clone, a fetch, a scan of its history. */
 export const SLOW_LIMIT_MS = 600_000;
@@ -19,14 +20,14 @@ function limitOf(asked) {
 function shown(tool, args) {
     return [tool, ...args].join(" ").replaceAll(/\s+/g, " ").trim().slice(0, SHOWN);
 }
-/** Every process left in the group the tool led; the tool itself is stopped and reaped by now. */
-function stopGroup(pid) {
+/** Sends `signal` to every process of the group `pid` leads; nothing when the group is gone. */
+export function signalGroup(pid, signal) {
     // A pid of 0 would make the kill reach this process's own group.
     if (pid <= 0) {
         return;
     }
     try {
-        process.kill(-pid, "SIGKILL");
+        process.kill(-pid, signal);
     }
     catch (error) {
         // ESRCH: no process is left in the group.
@@ -51,8 +52,40 @@ export function exec(tool, args, options = {}) {
     };
     const result = spawnSync(tool, args, spawnOptions);
     if (result.error !== undefined && "code" in result.error && result.error.code === "ETIMEDOUT") {
-        stopGroup(result.pid);
+        // Every process left in the group the tool led; the tool itself is stopped and reaped by now.
+        signalGroup(result.pid, "SIGKILL");
         throw new TimedOut(`${shown(tool, args)} did not answer within ${limitMs / 1000} s`);
     }
     return result;
 }
+/** The first line of a tool's output that says anything, trimmed; undefined where none does. */
+export function firstLine(text) {
+    return text
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line !== "");
+}
+/** Why a call failed, in the tool's words: its first line, stderr before stdout, else the exit it ended with. */
+export function whyFailed({ status, stdout, stderr }) {
+    return firstLine(`${stderr}\n${stdout}`) ?? `exited ${status}`;
+}
+/**
+ * `tool args` for a command that cannot go on without the tool: one not on PATH stops the command with
+ * `missing`, one past its limit with `stalled`. Its own exit is the caller's.
+ */
+export function need(tool, args, remedies) {
+    let result;
+    try {
+        result = exec(tool, args);
+    }
+    catch (error) {
+        throw error instanceof TimedOut ? new CannotRun(error.message, remedies.stalled) : error;
+    }
+    if (result.error !== undefined) {
+        if ("code" in result.error && result.error.code === "ENOENT") {
+            throw new CannotRun(`${tool} is not on PATH`, remedies.missing);
+        }
+        throw result.error;
+    }
+    return { status: result.status ?? 1, stdout: result.stdout, stderr: result.stderr };
+}

package/dist/gate-cache.js

@@ -3,6 +3,7 @@
 import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { messageOf } from "./cannot-run.js";
 import { packageVersion } from "./package-version.js";
 import { workingTree } from "./working-tree.js";
 const STAMP_FILE = "dw-sdlc-gate.green";
@@ -17,7 +18,7 @@ export function fingerprint(root, gate) {
         return { key: `${found.tree} ${judge.digest("hex")}`, stampFile: join(found.gitDir, STAMP_FILE) };
     }
     catch (error) {
-        return { error: error instanceof Error ? error.message : String(error) };
+        return { error: messageOf(error) };
     }
 }
 /** Whether the last green run of this checkout was stamped with this fingerprint. */

package/dist/git.d.ts

@@ -0,0 +1,32 @@
+export type GitOptions = {
+    /** Text on git's stdin. */
+    input?: string;
+    /** The time limit, for what a repository's size or the network stretches: a fetch, a scan of history. */
+    limitMs?: number;
+    /** Variables over the cleared environment, as a scratch GIT_INDEX_FILE. */
+    env?: Record<string, string>;
+    /** stdout as git wrote it, for NUL-separated or patch output; trimmed otherwise. */
+    raw?: boolean;
+    /** Every line git wrote on stderr, joined, where one line of a report must hold all it said. */
+    whole?: boolean;
+};
+/** What git answered: its stdout on exit 0; else `said`, what went wrong, and `error`, it after `git <first argument>:`. */
+export type GitAnswer = {
+    out: string;
+} | {
+    error: string;
+    said: string;
+};
+/** This process's environment without the variables that tie git to one repository, as git lists them. */
+export declare function repositoryFreeEnv(): NodeJS.ProcessEnv;
+/** `git -C <dir> <args>`; past its limit it throws `TimedOut`, as `exec` does. */
+export declare function git(dir: string, args: string[], options?: GitOptions): GitAnswer;
+/** What `git -C <dir> <args>` prints, or undefined when it exits non-zero, as a question answered no. */
+export declare function asked(dir: string, args: string[], options?: GitOptions): string | undefined;
+/** What `git -C <dir> <args>` prints; a failure stops the command, naming git's problem. */
+export declare function must(dir: string, args: string[]): string;
+/** The git dir of the checkout at `dir` and the common one its worktrees share, absolute; undefined outside one. */
+export declare function gitDirs(dir: string): {
+    gitDir: string;
+    commonDir: string;
+} | undefined;

package/dist/git.js

@@ -0,0 +1,60 @@
+// The package's git commands, through `exec.ts`: from the directory each names, without the variables that tie
+// git to one repository, so a hook's GIT_DIR never aims one at the hook's repository; failures in git's words.
+// Two run outside it: the doctor's `git config --global`, which reads no repository, and landed.ts's pipeline.
+import { CannotRun } from "./cannot-run.js";
+import { exec, firstLine } from "./exec.js";
+const REMEDY = "check the repository with git status";
+let repositoryVars;
+/** This process's environment without the variables that tie git to one repository, as git lists them. */
+export function repositoryFreeEnv() {
+    repositoryVars ??= new Set((exec("git", ["rev-parse", "--local-env-vars"]).stdout ?? "").split("\n").filter(Boolean));
+    const vars = repositoryVars;
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !vars.has(name)));
+}
+/** What git said went wrong: its first line on stderr, or with `whole` every line; else how it ended. */
+function saidOf(result, whole) {
+    if (result.error !== undefined) {
+        return result.error.message;
+    }
+    const words = whole
+        ? result.stderr
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line !== "")
+            .join(" ")
+        : firstLine(result.stderr);
+    return words === undefined || words === "" ? `exited ${result.status ?? "on a signal"}` : words;
+}
+/** `git -C <dir> <args>`; past its limit it throws `TimedOut`, as `exec` does. */
+export function git(dir, args, options = {}) {
+    const { input, limitMs } = options;
+    const result = exec("git", ["-C", dir, ...args], {
+        env: { ...repositoryFreeEnv(), ...options.env },
+        ...(input === undefined ? {} : { input }),
+        ...(limitMs === undefined ? {} : { limitMs })
+    });
+    if (result.status === 0) {
+        return { out: options.raw === true ? result.stdout : result.stdout.trim() };
+    }
+    const said = saidOf(result, options.whole === true);
+    return { error: `git ${args[0] ?? ""}: ${said}`, said };
+}
+/** What `git -C <dir> <args>` prints, or undefined when it exits non-zero, as a question answered no. */
+export function asked(dir, args, options = {}) {
+    const answer = git(dir, args, options);
+    return "out" in answer ? answer.out : undefined;
+}
+/** What `git -C <dir> <args>` prints; a failure stops the command, naming git's problem. */
+export function must(dir, args) {
+    const answer = git(dir, args);
+    if ("error" in answer) {
+        throw new CannotRun(answer.error, REMEDY);
+    }
+    return answer.out;
+}
+/** The git dir of the checkout at `dir` and the common one its worktrees share, absolute; undefined outside one. */
+export function gitDirs(dir) {
+    const answer = asked(dir, ["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
+    const [gitDir, commonDir] = answer === undefined ? [] : answer.split("\n");
+    return gitDir === undefined || commonDir === undefined ? undefined : { gitDir, commonDir };
+}

package/dist/json-schema.js

@@ -1,12 +1,10 @@
 // The subset of JSON Schema draft 2020-12 the shipped schemas use, validated without a dependency: Node
 // has no validator built in, and a config file does not justify pulling one in. A keyword outside the
 // subset throws instead of passing silently, so a schema never promises more than this file enforces.
+import { isObject } from "./json-text.js";
 export class SchemaError extends Error {
 }
 const ANNOTATIONS = new Set(["$schema", "$id", "$comment", "title", "description", "default", "examples"]);
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function show(value) {
     return value === undefined ? "undefined" : JSON.stringify(value);
 }

package/dist/landed.js

@@ -2,33 +2,22 @@
 // (plugins/sdlc/hooks/lib-git.sh) judges it. The guard keeps its own bash version; docs/adr/0015 says why there
 // are two, and the shared table of scenarios, plugins/sdlc/test/landed-scenarios.ts, holds them to one meaning.
 import { exec, SLOW_LIMIT_MS } from "./exec.js";
-import { repositoryFreeEnv } from "./git-env.js";
+import { asked, repositoryFreeEnv } from "./git.js";
 /** The base commits read, newest first: a branch that forked further back is kept rather than read for seconds. */
 const SCAN = 5000;
 /** Only local objects: a partial clone's missing blob is no reason to ask its remote. */
-function localEnv() {
-    return { ...repositoryFreeEnv(), GIT_NO_LAZY_FETCH: "1" };
-}
-function git(root, args, input, limitMs) {
-    const result = exec("git", ["-C", root, ...args], {
-        env: localEnv(),
-        ...(input === undefined ? {} : { input }),
-        ...(limitMs === undefined ? {} : { limitMs })
-    });
-    return { status: result.status ?? 1, stdout: result.stdout ?? "" };
-}
-/** What `git <args>` prints, or undefined when it exits non-zero. */
-function answer(root, args, input, limitMs) {
-    const ran = git(root, args, input, limitMs);
-    return ran.status === 0 ? ran.stdout.trim() : undefined;
+const LOCAL_ONLY = { GIT_NO_LAZY_FETCH: "1" };
+/** What `git <args>` prints over local objects only, or undefined when it exits non-zero. */
+function answer(root, args, options = {}) {
+    return asked(root, args, { ...options, env: LOCAL_ONLY });
 }
 /** The patch-id of the whole diff from `from` to `to`; undefined for an empty diff or one git could not finish. */
 function patchIdOf(root, from, to) {
-    const diff = git(root, ["diff-tree", "-p", "--binary", "--no-renames", from, to]);
-    if (diff.status !== 0) {
+    const diff = answer(root, ["diff-tree", "-p", "--binary", "--no-renames", from, to], { raw: true });
+    if (diff === undefined) {
         return undefined;
     }
-    const id = answer(root, ["patch-id", "--verbatim"], diff.stdout)?.split(" ")[0];
+    const id = answer(root, ["patch-id", "--verbatim"], { input: diff })?.split(" ")[0];
     return id === undefined || id === "" ? undefined : id;
 }
 /** Whether a base commit in `range`, merges aside, has `patch` for the patch-id of its diff. */
@@ -44,7 +33,7 @@ function baseHoldsPatch(root, range, patch) {
         ].join(" | ")
     ].join("; ");
     const result = exec("bash", ["-c", pipeline, "bash", root, String(SCAN), range], {
-        env: localEnv(),
+        env: { ...repositoryFreeEnv(), ...LOCAL_ONLY },
         limitMs: SLOW_LIMIT_MS
     });
     if (result.status !== 0) {
@@ -66,7 +55,7 @@ export function isLanded(root, baseRef, branch) {
  * its tree or the verbatim patch-id of its whole diff, as a squash merge leaves them.
  */
 export function isCommitLanded(root, baseRef, tip) {
-    if (git(root, ["merge-base", "--is-ancestor", tip, baseRef]).status === 0) {
+    if (answer(root, ["merge-base", "--is-ancestor", tip, baseRef]) !== undefined) {
         return true;
     }
     const fork = answer(root, ["merge-base", tip, baseRef]);
@@ -75,7 +64,7 @@ export function isCommitLanded(root, baseRef, tip) {
         return false;
     }
     const range = `${fork}..${baseRef}`;
-    const trees = answer(root, ["log", "--format=%T", `--max-count=${SCAN}`, range], undefined, SLOW_LIMIT_MS) ?? "";
+    const trees = answer(root, ["log", "--format=%T", `--max-count=${SCAN}`, range], { limitMs: SLOW_LIMIT_MS }) ?? "";
     if (trees.split("\n").includes(tree)) {
         return true;
     }

package/dist/paused-operation.d.ts

@@ -0,0 +1,2 @@
+/** The operation paused in the checkout whose git directory is `gitDir`, if any. */
+export declare function pausedIn(gitDir: string): string | undefined;

package/dist/paused-operation.js

@@ -0,0 +1,17 @@
+// The operation git left paused in a checkout, read from the record git resumes it from.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** Git's own record of each paused operation, in the git directory a linked worktree keeps apart. */
+const PAUSES = [
+    { record: "rebase-merge", name: "rebase" },
+    { record: "rebase-apply", name: "rebase or am" },
+    { record: "MERGE_HEAD", name: "merge" },
+    { record: "CHERRY_PICK_HEAD", name: "cherry-pick" },
+    { record: "REVERT_HEAD", name: "revert" },
+    { record: "sequencer", name: "cherry-pick or revert" },
+    { record: "BISECT_LOG", name: "bisect" }
+];
+/** The operation paused in the checkout whose git directory is `gitDir`, if any. */
+export function pausedIn(gitDir) {
+    return PAUSES.find(({ record }) => existsSync(join(gitDir, record)))?.name;
+}

package/dist/pins.js

@@ -3,6 +3,7 @@
 // ref without `{name}` reads neither file, so a broken manifest fails only the References that name one.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { messageOf } from "./cannot-run.js";
 /** A pin that names one version: `x.y.z`, a pre-release tag allowed. */
 export const EXACT_VERSION = /^\d+\.\d+\.\d+(?:-[\w.]+)?$/;
 /** The two ways a pin names the default catalog: by its name, or by pnpm's shorthand. */
@@ -65,7 +66,7 @@ export function readPins(root) {
         return parsePins(readFileSync(manifest, "utf8"), catalog);
     }
     catch (error) {
-        throw new Error(`package.json: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        throw new Error(`package.json: ${messageOf(error)}`, { cause: error });
     }
 }
 /** `ref` with each `{name}` replaced by the exact version `pins` holds for package `name`. */