dw-sdlc 0.20.0 → 0.21.1

package/dist/worker/herdr.js

@@ -1,66 +1,126 @@
-// What the `worker` commands share: `hc` and `herdr-app` as child processes, the Lead a command acts for,
-// and the Workers herdr lists for it.
-import { exec, TimedOut } from "../exec.js";
+// herdr's CLI, `hc`, run from this one place, each reply parsed once into a typed value: a read that fails
+// stops the command through `CannotRun` with hc's words, an action answers its refusal. Beside it:
+// `herdr-app`, the Lead a command acts for, and the Workers herdr lists for it.
+import { CannotRun } from "../cannot-run.js";
+import { need, whyFailed } from "../exec.js";
 import { isObject, parseObject } from "../json-text.js";
-/** What stops a `worker` command before it acts: exit 2, the problem and, when there is one, its remedy. */
-export class Refusal extends Error {
-    remedy;
-    constructor(message, remedy) {
-        super(message);
-        this.remedy = remedy;
-    }
+const REMEDIES = {
+    missing: "install herdr, or run the command in a terminal herdr started",
+    stalled: "check herdr is responding, then call again"
+};
+/** The remedy for a reply in a shape this module does not read. */
+const SHAPE = "check hc --version";
+/** hc's exit when it has no such terminal. */
+const NO_TERMINAL = 3;
+/** `hc send`'s exit when the target sits on a permission or a question. */
+const BLOCKED = 9;
+/** `hc kill`'s exit when the terminal finished before the stop. */
+const FINISHED = 11;
+/** `hc args`; one not on PATH, or past its limit, stops the command. */
+function hc(args) {
+    return need("hc", args, REMEDIES);
 }
-/** The first line of a tool's output that says anything, or the exit it ended with. */
-export function said(called) {
-    const line = `${called.stderr}\n${called.stdout}`.split("\n").find((text) => text.trim() !== "");
-    return line?.trim() ?? `exited ${called.status}`;
+/** `herdr-app args`, the window's CLI; one not on PATH, or past its limit, stops the command. */
+export function herdrApp(args) {
+    return need("herdr-app", args, REMEDIES);
 }
-/** `tool args` as a child process; past its limit it stops the command as any failed call does. */
-function reach(tool, args) {
-    try {
-        return exec(tool, args);
+/** The JSON object `hc <args>` prints, or why it printed none; `shown` names the call, as `hc get t3`. */
+function answer(args, shown) {
+    const called = hc(args);
+    if (called.status !== 0) {
+        return { status: called.status, problem: `${shown} failed: ${whyFailed(called)}` };
     }
-    catch (error) {
-        if (error instanceof TimedOut) {
-            throw new Refusal(error.message, "check herdr is responding, then call again");
-        }
-        throw error;
+    const object = parseObject(called.stdout);
+    return object === undefined
+        ? { status: 0, problem: `${shown} answered something that is no JSON object`, remedy: SHAPE }
+        : { object };
+}
+/** The object `answered` holds; a call that answered none stops the command. */
+function objectOf(answered) {
+    if ("object" in answered) {
+        return answered.object;
     }
+    throw new CannotRun(answered.problem, answered.remedy);
 }
-/** `tool args` as a child process; a tool that is not on PATH stops the command. */
-export function call(tool, args) {
-    const result = reach(tool, args);
-    if (result.error !== undefined) {
-        if ("code" in result.error && result.error.code === "ENOENT") {
-            throw new Refusal(`${tool} is not on PATH`, "install herdr, or run the command in a terminal herdr started");
-        }
-        throw result.error;
+/** A string that says something, else undefined. */
+function word(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function listedOf(entry) {
+    const address = isObject(entry) ? word(entry.address) : undefined;
+    if (!isObject(entry) || address === undefined || typeof entry.state !== "string" || typeof entry.cwd !== "string") {
+        throw new CannotRun("hc ls answered a terminal without an address, state or folder", SHAPE);
     }
-    return { status: result.status ?? 1, stdout: result.stdout, stderr: result.stderr };
+    return {
+        address,
+        name: word(entry.name) ?? address,
+        parent: word(entry.parent),
+        state: entry.state,
+        status: word(entry.status),
+        folder: entry.cwd,
+        place: word(entry.where)
+    };
 }
-/** The JSON object `hc <args>` prints; a failing call or a reply that is no object stops the command. */
-export function hcObject(args) {
-    const called = call("hc", args);
-    if (called.status !== 0) {
-        throw new Refusal(`hc ${args[0] ?? ""} failed: ${said(called)}`);
+function readingOf({ state, status, labels, first_message: first, foreground }) {
+    const program = isObject(foreground) ? foreground : {};
+    return {
+        state: word(state),
+        status: isObject(status) ? word(status.state) : undefined,
+        space: isObject(labels) ? word(labels["herdr.space"]) : undefined,
+        firstMessage: isObject(first) && typeof first.sent === "boolean" ? { sent: first.sent, reason: word(first.reason) } : undefined,
+        folder: word(program.cwd),
+        pid: typeof program.pid === "number" ? program.pid : undefined
+    };
+}
+/** The terminals `hc ls` lists: the live ones, every one with `all`, only those labelled `label` when given. */
+export function listTerminals(filter = {}) {
+    const all = filter.all === true ? ["--all"] : [];
+    const label = filter.label === undefined ? [] : ["--label", filter.label];
+    const { terminals } = objectOf(answer(["ls", "--json", ...all, ...label], "hc ls"));
+    if (!Array.isArray(terminals)) {
+        throw new CannotRun("hc ls answered no list of terminals", SHAPE);
     }
-    const parsed = parseObject(called.stdout);
-    if (parsed === undefined) {
-        throw new Refusal(`hc ${args[0] ?? ""} answered something that is no JSON object`, "check hc --version");
+    return terminals.map(listedOf);
+}
+/** What `hc get` reports of the terminal at `address`, or `gone`, in hc's words, when herdr has no such terminal. */
+export function readTerminal(address) {
+    const answered = answer(["get", address, "--json"], `hc get ${address}`);
+    if ("status" in answered && answered.status === NO_TERMINAL) {
+        return { gone: answered.problem };
     }
-    return parsed;
+    return readingOf(objectOf(answered));
 }
-/** What an error says, whatever was thrown. */
-export function describe(error) {
-    return error instanceof Error ? error.message : String(error);
+/** Runs `argv` in a terminal of its own in the background, outliving its caller; the address hc gives it. */
+export function startTerminal({ name, labels, cwd, argv }) {
+    const label = Object.entries(labels).flatMap(([key, value]) => ["--label", `${key}=${value}`]);
+    const args = ["run", "--bg", "--json", "--name", name, ...label, "--outlive-parent", "--cwd", cwd, "--", ...argv];
+    const address = word(objectOf(answer(args, "hc run")).address);
+    if (address === undefined) {
+        throw new CannotRun("hc run answered no address for the terminal it started", "check hc ls before starting it again");
+    }
+    return address;
+}
+/** Stops the terminal at `address`: hc's words when it refuses, undefined once it is stopped or had finished. */
+export function stopTerminal(address) {
+    const called = hc(["kill", address]);
+    return called.status === 0 || called.status === FINISHED
+        ? undefined
+        : `hc kill ${address} failed: ${whyFailed(called)}`;
+}
+/** Removes the terminal at `address`: hc's words when it refuses, undefined once it is gone. */
+export function removeTerminal(address) {
+    const called = hc(["rm", address]);
+    return called.status === 0 || called.status === NO_TERMINAL
+        ? undefined
+        : `hc rm ${address} failed: ${whyFailed(called)}`;
 }
-/** Reports a `Refusal` of `command` on stderr and answers exit 2; any other error is a bug and goes on up. */
-export function refuse(command, error) {
-    if (!(error instanceof Refusal)) {
-        throw error;
+/** Types `message` into the terminal at `address`: `sent`, `blocked` while it sits on a dialog, else hc's words. */
+export function sendTo(address, message) {
+    const called = hc(["send", address, message]);
+    if (called.status === 0) {
+        return "sent";
     }
-    process.stderr.write(`dw-sdlc ${command}: ${error.message}${error.remedy === undefined ? "" : ` — ${error.remedy}`}\n`);
-    return 2;
+    return called.status === BLOCKED ? "blocked" : { refused: `hc send failed: ${whyFailed(called)}` };
 }
 /** The option `flag` as a whole number from `min`, `fallback` when the command line leaves it out. */
 export function wholeNumber(flag, value, fallback, min) {
@@ -73,7 +133,7 @@ export function wholeNumber(flag, value, fallback, min) {
 export function lead() {
     const id = process.env.HC_TERMINAL_ID;
     if (id === undefined || id === "") {
-        throw new Refusal("outside herdr: $HC_TERMINAL_ID is not set", "run it in a terminal herdr started, where the Lead has an address");
+        throw new CannotRun("outside herdr: $HC_TERMINAL_ID is not set", "run it in a terminal herdr started, where the Lead has an address");
     }
     return id;
 }
@@ -82,41 +142,30 @@ export function isLive(worker) {
     return worker.state === "live";
 }
 /**
- * The Workers with the folder each live one works in, its worktree, which `hc get` reports as
- * `foreground.cwd` and `hc ls` leaves out. A Worker herdr cannot tell it for keeps its launch folder.
+ * The Workers with the folder each live one works in, its worktree, which `hc get` reports and `hc ls`
+ * leaves out. A Worker herdr cannot tell it for keeps its launch folder.
  */
 export function workingFolders(workers) {
     return workers.map((worker) => {
         if (!isLive(worker)) {
             return worker;
         }
-        const got = call("hc", ["get", worker.address, "--json"]);
-        const foreground = got.status === 0 ? parseObject(got.stdout)?.foreground : undefined;
-        const cwd = isObject(foreground) ? foreground.cwd : undefined;
-        return typeof cwd === "string" && cwd !== "" ? { ...worker, folder: cwd } : worker;
+        const answered = answer(["get", worker.address, "--json"], `hc get ${worker.address}`);
+        const folder = "object" in answered ? readingOf(answered.object).folder : undefined;
+        return folder === undefined ? worker : { ...worker, folder };
     });
 }
-function word(value) {
-    return typeof value === "string" ? value : undefined;
-}
-/** The Workers `lead` started, in the order herdr lists them; `all` adds the finished ones. */
+/** The Workers `leadId` started, in the order herdr lists them; `all` adds the finished ones. */
 export function workersOf(leadId, all) {
-    const listing = hcObject(["ls", "--json", ...(all ? ["--all"] : []), "--label", "role=worker"]);
-    const { terminals } = listing;
-    if (!Array.isArray(terminals)) {
-        throw new Refusal("hc ls answered no list of terminals", "check hc --version");
-    }
-    return terminals.flatMap((entry) => {
-        if (!isObject(entry) || entry.parent !== leadId) {
-            return [];
-        }
-        const { address, state, cwd } = entry;
-        if (typeof address !== "string" || typeof state !== "string" || typeof cwd !== "string") {
-            throw new Refusal("hc ls answered a terminal without an address, state or folder", "check hc --version");
-        }
-        const status = state === "finished" ? "finished" : (word(entry.status) ?? "unknown");
-        return [{ name: word(entry.name) ?? address, address, state, status, folder: cwd }];
-    });
+    return listTerminals({ all, label: "role=worker" })
+        .filter(({ parent }) => parent === leadId)
+        .map(({ name, address, state, status, folder }) => ({
+        name,
+        address,
+        state,
+        status: state === "finished" ? "finished" : (status ?? "unknown"),
+        folder
+    }));
 }
 /** A table of rows, every column but the last padded to its widest cell and two spaces apart. */
 export function table(rows) {

package/dist/worker/launch.js

@@ -1,8 +1,8 @@
 // What `worker start` and `lead start` share: a session started in a herdr terminal of its own beside the
 // caller, its tab named, and the terminal read back until the session shows it took its first message.
 import { setTimeout as sleep } from "node:timers/promises";
-import { isObject } from "../json-text.js";
-import { describe, hcObject, Refusal } from "./herdr.js";
+import { CannotRun } from "../cannot-run.js";
+import { readTerminal, startTerminal } from "./herdr.js";
 import { nameTab } from "./tabs.js";
 /** hc names a terminal with 1-32 of a-z, 0-9, - and _. */
 export const NAME = /^[a-z0-9][a-z0-9_-]{0,31}$/;
@@ -12,42 +12,43 @@ export const TAB_WAIT = 10;
 const WORKING = new Set(["working", "blocked", "done"]);
 /** How long the read-back waits between two reads of the terminal. */
 const POLL_MS = 1000;
-/** The status a session reports, if it has reported one. */
-function reportedStatus(terminal) {
-    const { status } = terminal;
-    return isObject(status) && typeof status.state === "string" ? status.state : undefined;
-}
 /** Why the session, called `who`, can no longer take its first message, or undefined while it still may. */
-function failure(terminal, who) {
-    const { first_message: first, state } = terminal;
-    if (isObject(first) && first.sent === false) {
-        return typeof first.reason === "string" ? first.reason : "herdr gave no reason";
+function failure({ firstMessage, state, status }, who) {
+    if (firstMessage?.sent === false) {
+        return firstMessage.reason ?? "herdr gave no reason";
     }
     if (state !== "live") {
         return "the terminal has finished";
     }
-    return reportedStatus(terminal) === "error" ? `the ${who} reports its status as error` : undefined;
+    return status === "error" ? `the ${who} reports its status as error` : undefined;
+}
+/** The terminal at `address` as `hc get` reports it, or why it could not be read. */
+function readBack(address) {
+    try {
+        const reading = readTerminal(address);
+        return "gone" in reading ? { unread: reading.gone } : reading;
+    }
+    catch (error) {
+        if (error instanceof CannotRun) {
+            return { unread: error.message };
+        }
+        throw error;
+    }
 }
 /** Reads the terminal until the session shows work, for up to `wait` seconds; why it did not, or undefined once it did. */
 async function delivery(address, wait, who) {
     const deadline = Date.now() + wait * 1000;
     for (;;) {
-        let terminal;
-        try {
-            terminal = hcObject(["get", address, "--json"]);
-        }
-        catch (error) {
-            if (!(error instanceof Refusal)) {
-                throw error;
-            }
-            // The session is running by now, so a failed read is a message not confirmed, never a start that did not happen.
-            return `the terminal could not be read back: ${describe(error)}`;
+        const reading = readBack(address);
+        // The session is running by now, so a failed read is a message not confirmed, never a start that did not happen.
+        if ("unread" in reading) {
+            return `the terminal could not be read back: ${reading.unread}`;
         }
-        const failed = failure(terminal, who);
+        const failed = failure(reading, who);
         if (failed !== undefined) {
             return failed;
         }
-        if (WORKING.has(reportedStatus(terminal) ?? "")) {
+        if (WORKING.has(reading.status ?? "")) {
             return undefined;
         }
         if (Date.now() >= deadline) {
@@ -58,33 +59,19 @@ async function delivery(address, wait, who) {
 }
 /** The id of the herdr space the terminal `id` sits in, if it sits in one. */
 export function spaceOf(id) {
-    const { labels } = hcObject(["get", id, "--json"]);
-    const space = isObject(labels) ? labels["herdr.space"] : undefined;
-    return typeof space === "string" ? space : undefined;
+    const reading = readTerminal(id);
+    if ("gone" in reading) {
+        throw new CannotRun(reading.gone);
+    }
+    return reading.space;
 }
 /**
  * Runs `hc run` once for `launch`, outliving its caller, then names the tab and reads the terminal back side
  * by side. It never sends the first message again; `reason` says why the session did not take it.
  */
 export async function launch(command, { name, role, space, cwd, argv, wait }) {
-    const { address } = hcObject([
-        "run",
-        "--bg",
-        "--json",
-        "--name",
-        name,
-        "--label",
-        `role=${role}`,
-        ...(space === undefined ? [] : ["--label", `herdr.space=${space}`]),
-        "--outlive-parent",
-        "--cwd",
-        cwd,
-        "--",
-        ...argv
-    ]);
-    if (typeof address !== "string") {
-        throw new Refusal("hc run answered no address for the terminal it started", "check hc ls before starting it again");
-    }
+    const labels = { role, ...(space === undefined ? {} : { "herdr.space": space }) };
+    const address = startTerminal({ name, labels, cwd, argv });
     // Side by side, so the wait for the tab overlaps the wait for the session to start.
     const naming = space === undefined ? Promise.resolve("none") : nameTab(address, name, Math.min(TAB_WAIT, wait));
     const [named, reason] = await Promise.all([naming, delivery(address, wait, role === "lead" ? "Lead" : "Worker")]);

package/dist/worker/origin.d.ts

@@ -1,6 +1,6 @@
 /**
  * Fetches origin's default branch, or every branch of origin when no default is known, into the remote-tracking
- * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws a `Refusal` when the
+ * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws `CannotRun` when the
  * fetch fails, since a Worker started on a stale base is the fault this prevents.
  */
 export declare function freshenOrigin(root: string, baseBranch: string): void;

package/dist/worker/origin.js

@@ -1,10 +1,9 @@
 // Brings the clone's view of origin's default branch up to date before a Worker starts: Claude Code's
 // `--worktree` branches from the cached `origin/<default>` and fetches it only when the clone has gone a
 // day without a fetch, so a Worker could otherwise begin from a ref that is hours or days behind.
-import { exec, SLOW_LIMIT_MS, TimedOut } from "../exec.js";
-import { repositoryFreeEnv } from "../git-env.js";
-import { asked } from "../working-tree.js";
-import { Refusal } from "./herdr.js";
+import { CannotRun } from "../cannot-run.js";
+import { SLOW_LIMIT_MS, TimedOut } from "../exec.js";
+import { asked, git } from "../git.js";
 const REMOTE_HEAD = "refs/remotes/origin/HEAD";
 const PREFIX = "refs/remotes/origin/";
 /** The branch to fetch: the one origin/HEAD names, else `baseBranch` of the config; undefined when neither names one. */
@@ -17,7 +16,7 @@ function defaultBranch(root, baseBranch) {
 }
 /**
  * Fetches origin's default branch, or every branch of origin when no default is known, into the remote-tracking
- * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws a `Refusal` when the
+ * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws `CannotRun` when the
  * fetch fails, since a Worker started on a stale base is the fault this prevents.
  */
 export function freshenOrigin(root, baseBranch) {
@@ -25,19 +24,18 @@ export function freshenOrigin(root, baseBranch) {
         return;
     }
     const branch = defaultBranch(root, baseBranch);
-    const args = ["-C", root, "fetch", "--quiet", "origin", ...(branch === undefined ? [] : [branch])];
+    const args = ["fetch", "--quiet", "origin", ...(branch === undefined ? [] : [branch])];
     const fetched = `git fetch origin${branch === undefined ? "" : ` ${branch}`}`;
-    const stale = (why) => new Refusal(`${fetched} failed, so the Worker would begin from a stale base: ${why}`, "check the network and the access to origin; when origin/HEAD names a branch the remote no longer has, " +
+    const stale = (why) => new CannotRun(`${fetched} failed, so the Worker would begin from a stale base: ${why}`, "check the network and the access to origin; when origin/HEAD names a branch the remote no longer has, " +
         "run `git remote set-head origin --auto`; then start the Worker again");
     let result;
     try {
-        result = exec("git", args, { env: repositoryFreeEnv(), limitMs: SLOW_LIMIT_MS });
+        result = git(root, args, { limitMs: SLOW_LIMIT_MS });
     }
     catch (error) {
         throw error instanceof TimedOut ? stale(error.message) : error;
     }
-    if (result.status !== 0) {
-        const said = result.stderr.split("\n").find((line) => line.trim() !== "");
-        throw stale(said?.trim() ?? `exited ${result.status ?? "on a signal"}`);
+    if ("error" in result) {
+        throw stale(result.said);
     }
 }

package/dist/worker/tabs.js

@@ -1,17 +1,19 @@
 // The tab of a Worker's terminal in the herdr window: `hc run` with a `herdr.space` label opens one that herdr
 // numbers, and `herdr-app` names it.
 import { setTimeout as sleep } from "node:timers/promises";
+import { CannotRun } from "../cannot-run.js";
+import { whyFailed } from "../exec.js";
 import { isObject, parseObject } from "../json-text.js";
-import { call, Refusal, said } from "./herdr.js";
+import { herdrApp } from "./herdr.js";
 /** The tabs `herdr-app ls` shows, each with the addresses of its terminals. */
 function tabsOf() {
-    const listed = call("herdr-app", ["ls"]);
+    const listed = herdrApp(["ls"]);
     if (listed.status !== 0) {
-        throw new Refusal(`herdr-app ls failed: ${said(listed)}`);
+        throw new CannotRun(`herdr-app ls failed: ${whyFailed(listed)}`);
     }
     const parsed = parseObject(listed.stdout);
     if (parsed === undefined) {
-        throw new Refusal("herdr-app ls answered no JSON object");
+        throw new CannotRun("herdr-app ls answered no JSON object");
     }
     const spaces = Array.isArray(parsed.spaces) ? parsed.spaces : [];
     return spaces
@@ -47,14 +49,16 @@ export async function nameTab(address, name, boundSeconds) {
         if (tab === undefined) {
             return { kept: `the tab of ${address} is not in herdr-app ls within ${boundSeconds} s, so it keeps herdr's name` };
         }
-        const renamed = call("herdr-app", ["do", "tab.rename", "--id", tab.id, "--name", name]);
+        const renamed = herdrApp(["do", "tab.rename", "--id", tab.id, "--name", name]);
         if (renamed.status !== 0) {
-            return { kept: `herdr-app could not rename the tab of ${address}: ${errorOf(renamed.stdout) ?? said(renamed)}` };
+            return {
+                kept: `herdr-app could not rename the tab of ${address}: ${errorOf(renamed.stdout) ?? whyFailed(renamed)}`
+            };
         }
         return "renamed";
     }
     catch (error) {
-        if (error instanceof Refusal) {
+        if (error instanceof CannotRun) {
             return { kept: `the tab of ${address} keeps herdr's name: ${error.message}` };
         }
         throw error;

package/dist/working-tree.d.ts

@@ -1,11 +1,3 @@
-/** `git <args>` in the repository at `root`, on `index` when given. */
-export declare function git(root: string, args: string[], index?: string): {
-    out: string;
-} | {
-    error: string;
-};
-/** `git <args>` at `root`, or undefined when it exits non-zero as a question answered no. */
-export declare function asked(root: string, args: string[]): string | undefined;
 /** The tree of the checkout at `root` and its git dir, or why it has none. */
 export declare function workingTree(root: string): {
     tree: string;

package/dist/working-tree.js

@@ -3,25 +3,8 @@
 import { copyFileSync, existsSync, mkdtempSync, rmSync, statSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { exec } from "./exec.js";
-import { repositoryFreeEnv } from "./git-env.js";
-/** `git <args>` in the repository at `root`, on `index` when given. */
-export function git(root, args, index) {
-    const env = repositoryFreeEnv();
-    const result = exec("git", ["-C", root, ...args], {
-        env: index === undefined ? env : { ...env, GIT_INDEX_FILE: index }
-    });
-    if (result.status === 0) {
-        return { out: result.stdout.trim() };
-    }
-    const reason = result.error?.message ?? result.stderr.split("\n").find((line) => line.trim() !== "");
-    return { error: `git ${args[0] ?? ""}: ${reason?.trim() ?? `exited ${result.status ?? "on a signal"}`}` };
-}
-/** `git <args>` at `root`, or undefined when it exits non-zero as a question answered no. */
-export function asked(root, args) {
-    const result = git(root, args);
-    return "out" in result ? result.out : undefined;
-}
+import { messageOf } from "./cannot-run.js";
+import { git } from "./git.js";
 /**
  * The tree `git write-tree` hashes from a copy of the index after `git add -A` on it: the copy keeps the
  * stat cache, so only what changed is read again; identical content survives a commit, an amend or a
@@ -39,8 +22,9 @@ function treeOf(root, gitDir) {
             copyFileSync(real, index);
             utimesSync(index, atime, mtime);
         }
-        const added = git(root, ["add", "-A"], index);
-        return "error" in added ? added : git(root, ["write-tree"], index);
+        const scratchIndex = { env: { GIT_INDEX_FILE: index } };
+        const added = git(root, ["add", "-A"], scratchIndex);
+        return "error" in added ? added : git(root, ["write-tree"], scratchIndex);
     }
     finally {
         rmSync(scratch, { recursive: true, force: true });
@@ -57,6 +41,6 @@ export function workingTree(root) {
         return "error" in tree ? tree : { tree: tree.out, gitDir: gitDir.out };
     }
     catch (error) {
-        return { error: error instanceof Error ? error.message : String(error) };
+        return { error: messageOf(error) };
     }
 }

package/dist/worktree-lock.js

@@ -2,7 +2,7 @@
 // `claude session <name> (pid <N> start <time>)`, <time> as `ps -o lstart` writes it in UTC. Such a lock is
 // stale once no process N runs or N started at another time. Any other reason is the dev's to lift.
 import { exec } from "./exec.js";
-import { shellLine } from "./pr/decide.js";
+import { shellLine } from "./shell-line.js";
 const CLAUDE_LOCK = /^claude session .* \(pid (?<pid>\d{1,10}) start (?<start>.+)\)$/;
 const MAX_PID = 2 ** 31 - 1;
 const squeezed = (text) => text.trim().replace(/\s+/g, " ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-sdlc",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "The Gate and the agentic config behind the sdlc Claude Code plugin: a bin with the Gate and its Checks, the setup, the doctor, the Sync of References, the Ship script that drives a pull request to merged, the Sweep, and Lead and Worker sessions in herdr; the resolver of a repository's .ai/agentic.config.json layers and its JSON Schema.",
   "license": "MIT",
   "repository": {

package/dist/git-env.d.ts

@@ -1,2 +0,0 @@
-/** This process's environment without the variables that tie git to one repository, as git lists them. */
-export declare function repositoryFreeEnv(): NodeJS.ProcessEnv;

package/dist/git-env.js

@@ -1,10 +0,0 @@
-// The environment a git command runs under to find its repository from its own directory, as a git
-// hook's GIT_DIR or GIT_INDEX_FILE would otherwise aim it at the hook's repository.
-import { exec } from "./exec.js";
-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)));
-}