dw-sdlc 0.20.0 → 0.21.1

package/dist/recap-next.js

@@ -1,7 +1,8 @@
 // The candidates for the session after this one, as `dw-sdlc recap` reads them: the open issues an agent may
 // start, from one GraphQL request that also asks which issues the branch's pull request closes.
-import { isObject, parseObject } from "./json-text.js";
-import { CannotRun, gh, said } from "./pr/read.js";
+import { CannotRun } from "./cannot-run.js";
+import { gh, said } from "./pr/read.js";
+import { child, childOrNull, integer, nodes, ReplyError, rootOf, string } from "./pr/reply.js";
 /** The label that marks an issue as ready for an agent to start. */
 export const READY_LABEL = "ready-for-agent";
 /** How many open issues the one read holds, oldest first, and how many issues the pull request closes. */
@@ -16,46 +17,33 @@ const QUERY = `query Backlog($owner: String!, $name: String!, $number: Int!, $cl
   }
 }`;
 const REMEDY = "check gh auth status and the network, then call again";
-function malformed(field) {
-    return new CannotRun(`the backlog reply does not parse: ${field}`, "gh answered a shape dw-sdlc does not read; report it with the output of gh --version");
-}
-function nodesOf(value, field) {
-    if (!isObject(value) || !Array.isArray(value.nodes)) {
-        throw malformed(field);
-    }
-    return value.nodes;
-}
-function numberOf(value, field) {
-    if (!isObject(value) || typeof value.number !== "number") {
-        throw malformed(field);
-    }
-    return value.number;
-}
+const UNREAD_SHAPE = "gh answered a shape dw-sdlc does not read; report it with the output of gh --version";
 /** An issue node as a candidate, or null when it has an assignee or an open blocker. */
 function candidateOf(node) {
-    if (!isObject(node) || typeof node.title !== "string" || typeof node.url !== "string") {
-        throw malformed("issues.nodes");
-    }
-    const { assignees, issueDependenciesSummary: dependencies, parent } = node;
-    if (!isObject(assignees) || typeof assignees.totalCount !== "number") {
-        throw malformed("issues.nodes.assignees");
-    }
-    if (!isObject(dependencies) || typeof dependencies.blockedBy !== "number") {
-        throw malformed("issues.nodes.issueDependenciesSummary");
-    }
-    if (assignees.totalCount > 0 || dependencies.blockedBy > 0) {
+    const title = string(node, "title");
+    const url = string(node, "url");
+    const assignees = integer(child(node, "assignees"), "totalCount");
+    const blockedBy = integer(child(node, "issueDependenciesSummary"), "blockedBy");
+    if (assignees > 0 || blockedBy > 0) {
         return null;
     }
-    const number = numberOf(node, "issues.nodes.number");
-    return { number, title: node.title, url: node.url, parent: parent === null ? null : numberOf(parent, "parent") };
+    const parent = childOrNull(node, "parent");
+    return { number: integer(node, "number"), title, url, parent: parent === null ? null : integer(parent, "number") };
 }
-function repositoryOf(stdout) {
-    const data = parseObject(stdout)?.data;
-    const repository = isObject(data) ? data.repository : undefined;
-    if (!isObject(repository)) {
-        throw malformed("data.repository");
-    }
-    return repository;
+/**
+ * The candidates the backlog `reply` holds, the sub-issues of an issue the pull request closes first, each
+ * part in issue order. The issues it closes are read only when the query asked for them, `closing`.
+ */
+function candidatesIn(reply, closing) {
+    const repository = child(child(rootOf(reply, "the backlog reply"), "data"), "repository");
+    const closed = closing ? nodes(child(repository, "pullRequest"), "closingIssuesReferences") : [];
+    const closes = new Set(closed.map((node) => integer(node, "number")));
+    const candidates = nodes(repository, "issues")
+        .map(candidateOf)
+        .filter((candidate) => candidate !== null && !closes.has(candidate.number))
+        .toSorted((one, other) => one.number - other.number);
+    const underClosed = (candidate) => candidate.parent !== null && closes.has(candidate.parent);
+    return [...candidates.filter(underClosed), ...candidates.filter((candidate) => !underClosed(candidate))];
 }
 /**
  * The open issues labelled ready-for-agent with no assignee and no open blocker, read from `repo`, or from the
@@ -81,16 +69,15 @@ function nextCandidates(pr) {
     if (reply.status !== 0) {
         throw new CannotRun(`gh could not read the backlog: ${said(reply.stderr)}`, REMEDY);
     }
-    const repository = repositoryOf(reply.stdout);
-    const closes = new Set(pr === null
-        ? []
-        : nodesOf(isObject(repository.pullRequest) ? repository.pullRequest.closingIssuesReferences : undefined, "pullRequest").map((node) => numberOf(node, "closingIssuesReferences.nodes")));
-    const candidates = nodesOf(repository.issues, "issues")
-        .map(candidateOf)
-        .filter((candidate) => candidate !== null && !closes.has(candidate.number))
-        .toSorted((one, other) => one.number - other.number);
-    const underClosed = (candidate) => candidate.parent !== null && closes.has(candidate.parent);
-    return [...candidates.filter(underClosed), ...candidates.filter((candidate) => !underClosed(candidate))];
+    try {
+        return candidatesIn(reply.stdout, pr !== null);
+    }
+    catch (error) {
+        if (error instanceof ReplyError) {
+            throw new CannotRun(`the backlog reply does not parse: ${error.message}`, UNREAD_SHAPE);
+        }
+        throw error;
+    }
 }
 export function readNext(pr) {
     try {

package/dist/recap-primitives.js

@@ -3,8 +3,8 @@
 // the default branch and a repository with no catalogue roll up to none.
 import { resolveConfig } from "./agentic-config.js";
 import { catalogueFile } from "./checks/primitives.js";
+import { asked } from "./git.js";
 import { primitivesDiff } from "./primitives-diff.js";
-import { asked } from "./working-tree.js";
 /** `defaultOf` names the default branch and is asked only once the repository has a catalogue and `branch` is no base. */
 export function rollup(root, branch, defaultOf) {
     const { guardrails, gate } = resolveConfig(root).config;

package/dist/references-key.d.ts

@@ -15,7 +15,6 @@ export type KeyProblem = {
     path: string;
     message: string;
 };
-export declare function isObject(value: unknown): value is Record<string, unknown>;
 /** The References `value` declares, or the first problem in it, named by its path under the key. */
 export declare function parseReferences(value: unknown): {
     references: Reference[];

package/dist/references-key.js

@@ -3,6 +3,8 @@
 // and `test/references-key.test.ts` runs one case list through both. The first problem stops the parse.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { messageOf } from "./cannot-run.js";
+import { isObject } from "./json-text.js";
 /** The committed file the References are read from; no local layer adds to it. */
 export const REFERENCES_FILE = ".ai/references.json";
 /** The committed agentic config: a `references` key in it is refused, so the file stays the one list. */
@@ -30,9 +32,6 @@ function kind(value) {
     }
     return typeof value === "object" ? "an object" : `a ${typeof value}`;
 }
-export function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function nonEmpty(value, path) {
     if (typeof value !== "string") {
         throw new KeyError(path, `must be a string, not ${kind(value)}`);
@@ -153,7 +152,7 @@ function readObject(path, name) {
         value = JSON.parse(readFileSync(path, "utf8"));
     }
     catch (error) {
-        return { problem: `${name}: not JSON: ${error instanceof Error ? error.message : String(error)}` };
+        return { problem: `${name}: not JSON: ${messageOf(error)}` };
     }
     return isObject(value) ? { value } : { problem: `${name}: not a JSON object` };
 }

package/dist/run-command.d.ts

@@ -17,7 +17,10 @@ export type Ran = {
     tail: string[] | null;
 };
 export declare const TAIL_LINES = 50;
-/** Runs `body` with SIGINT and SIGTERM held, so a signal stops the command running and the Gate reports it. */
+/**
+ * Runs `body` with SIGINT and SIGTERM held, so a signal stops the command running and the Gate
+ * reports it, and SIGHUP passed on to the command.
+ */
 export declare function holdingSignals<T>(body: () => Promise<T>): Promise<T>;
 /** The signal that stopped the run, once one has: one the Gate got or one that ended a command. */
 export declare function stoppedBy(): NodeJS.Signals | undefined;

package/dist/run-command.js

@@ -1,39 +1,58 @@
-// How the Gate runs one command, a Step or a `gate.checks.run` script: through `sh -c` from the
-// repository root, stdin closed, its output captured or passed through, and what it answered; and
-// how SIGINT and SIGTERM stop the command running and every command after it.
+// How the Gate runs one command, a Step or a `gate.checks.run` script: `sh -c` from the repository
+// root in a process group of its own, stdin closed, output captured or passed through; and how SIGINT
+// and SIGTERM stop it, every process it started and every command after it.
 import { spawn } from "node:child_process";
 import { closeSync, fstatSync, mkdtempSync, openSync, readSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { signalGroup } from "./exec.js";
 export const TAIL_LINES = 50;
 /** What the shell answers for a command it cannot find, and for one it cannot execute. */
 const NOT_RUNNABLE = { 127: "was not found", 126: "could not be executed" };
 const STOPPING = ["SIGINT", "SIGTERM"];
-/** The command running, which a signal the Gate gets is passed on to. */
+/** The process group the running command leads, which a signal the Gate gets is passed on to. */
 let running;
 /** The first SIGINT or SIGTERM the Gate got; no command starts after it. */
 let received;
 /**
- * The SIGINT or SIGTERM that ended a command; no command starts after it either. Ctrl-C reaches the
- * command and the Gate together, and the command's exit can be seen before the Gate's own signal.
+ * The SIGINT or SIGTERM that ended a command; no command starts after it either. A signal sent to
+ * the command and the Gate together can show in the command's exit before the Gate's own handler runs.
  */
 let commandEndedBy;
 function release() {
     for (const signal of STOPPING) {
         process.off(signal, stop);
     }
+    process.off("SIGHUP", hangUp);
+}
+/** Sends `signal` to every process of the running command's group. */
+function signalCommand(signal) {
+    if (running !== undefined) {
+        signalGroup(running, signal);
+    }
 }
 function stop(signal) {
     if (received !== undefined) {
-        // A second signal ends the Gate at once, as it would with no handler: the command ignored the first.
+        // A second signal ends the Gate at once, as it would with no handler, and kills the command, which
+        // ignored the first.
+        signalCommand("SIGKILL");
         release();
         process.kill(process.pid, signal);
         return;
     }
     received = signal;
-    running?.kill(signal);
+    signalCommand(signal);
+}
+/** A hangup ends the Gate as with no handler, passed on first: a terminal's hangup misses the command's session. */
+function hangUp() {
+    signalCommand("SIGHUP");
+    release();
+    process.kill(process.pid, "SIGHUP");
 }
-/** Runs `body` with SIGINT and SIGTERM held, so a signal stops the command running and the Gate reports it. */
+/**
+ * Runs `body` with SIGINT and SIGTERM held, so a signal stops the command running and the Gate
+ * reports it, and SIGHUP passed on to the command.
+ */
 export async function holdingSignals(body) {
     running = undefined;
     received = undefined;
@@ -42,6 +61,7 @@ export async function holdingSignals(body) {
     for (const signal of STOPPING) {
         process.on(signal, stop);
     }
+    process.on("SIGHUP", hangUp);
     try {
         return await body();
     }
@@ -104,8 +124,9 @@ function run(command, root, stdio) {
             running = undefined;
             resolve({ ...answered, seconds: (performance.now() - started) / 1000 });
         };
-        const child = spawn(command, { shell: true, cwd: root, stdio });
-        running = child;
+        // A session of its own makes the command lead a process group, which every process it starts joins.
+        const child = spawn(command, { shell: true, cwd: root, stdio, detached: true });
+        running = child.pid;
         // A signal that cannot be delivered is an error too; only a child with no pid never started.
         child.on("error", (error) => {
             if (child.pid === undefined) {

package/dist/setup-gate.d.ts

@@ -1,11 +1,5 @@
 import type { NodePackageManager } from "./agentic-config.ts";
-/** A file's text after the setup and what writing it does, or why the setup leaves the file alone. */
-export type Change = {
-    text: string;
-    detail?: string;
-} | {
-    refusal: string;
-};
+import type { Change } from "./setup-writer.ts";
 /**
  * package.json with the package pinned exactly as a devDependency, in name order, where neither list
  * names it. A new dependency needs the owner's yes, so without `add` the file is refused.

package/dist/setup-rules.js

@@ -1,7 +1,7 @@
 // The permission rules the setup writes: the lease exception and the irreversible set for the user
 // file, and a repository's deny backstop for a machine without jq.
 import { DEFAULT_GUARDRAILS, matchesEnvGlob, resolveConfig } from "./agentic-config.js";
-import { exec } from "./exec.js";
+import { asked } from "./git.js";
 /** The auto-mode exception that lets a lease push through the classifier's default force-push block. */
 export const LEASE_RULE = "Force push with --force-with-lease or --force-if-includes to a branch that is not master, main or production: allowed. The guardrails plugin's hook refuses a bare --force, -f or +refspec and any force to a protected branch, so the lease form is the safe one and needs no prompt.";
 /** The irreversible set for the user file; `git stash clear` also in the rtk form a permission rule sees once rtk rewrites it. */
@@ -56,10 +56,6 @@ const GH_DENY = ["gh repo delete", "gh repo delete *"];
  */
 export const RETIRED_DENY = ["Bash(git branch -D *)", "Bash(rtk git branch -D *)"];
 const ENV_NAME = /^\.env(\..+)?$|^\.envrc$/;
-function git(root, args) {
-    const result = exec("git", ["-C", root, ...args]);
-    return result.status === 0 ? result.stdout.trim() : undefined;
-}
 function listedIn(globs, file) {
     return globs.some((glob) => matchesEnvGlob(glob, file));
 }
@@ -67,7 +63,7 @@ function isEnvName(file) {
     return ENV_NAME.test(file.slice(file.lastIndexOf("/") + 1));
 }
 function gitFiles(root, ...flags) {
-    const listed = git(root, ["-c", "core.quotePath=false", "ls-files", ...flags, "--exclude-standard"]) ?? "";
+    const listed = asked(root, ["-c", "core.quotePath=false", "ls-files", ...flags, "--exclude-standard"]) ?? "";
     return listed.split("\n").filter((file) => file !== "");
 }
 /**

package/dist/setup-writer.d.ts

@@ -0,0 +1,32 @@
+/** `by hand` is an edit the setup names and leaves to the user; `skipped` is a file it has no reason to write. */
+export type Outcome = "wrote" | "unchanged" | "skipped" | "refused" | "by hand";
+export type Step = {
+    file: string;
+    outcome: Outcome;
+    detail?: string;
+};
+/** A file's text after the step and what writing it does, or why the step leaves the file alone. */
+export type Change = {
+    text: string;
+    detail?: string | undefined;
+} | {
+    refusal: string;
+};
+export declare class Writer {
+    readonly steps: Step[];
+    private readonly dryRun;
+    constructor(dryRun: boolean);
+    private record;
+    /**
+     * The file at `path`, recorded under `label`, as `change` leaves it, or as it leaves the text the file
+     * holds now: written when the text differs, unchanged when it does not, else refused.
+     */
+    apply(label: string, path: string, change: Change | ((current: string | undefined) => Change)): void;
+    /** The file at `path`, made by `make` when nothing sits there, a dangling symlink included; never replaced. */
+    create(label: string, path: string, make: (path: string) => void): void;
+    refuse(label: string, detail: string): void;
+    skip(label: string, detail: string): void;
+    byHand(label: string, detail: string): void;
+}
+/** One line a step: what it did, or would do under `dryRun`, the file, and why where it says. */
+export declare function stepLines(steps: Step[], dryRun: boolean): string[];

package/dist/setup-writer.js

@@ -0,0 +1,60 @@
+// How `dw-sdlc setup` and `dw-sdlc references setup` write a file: only when its text would change,
+// nothing under --dry-run, and one line a file saying what the step did or would do.
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+export class Writer {
+    steps = [];
+    dryRun;
+    constructor(dryRun) {
+        this.dryRun = dryRun;
+    }
+    record(file, outcome, detail) {
+        this.steps.push(detail === undefined ? { file, outcome } : { file, outcome, detail });
+    }
+    /**
+     * The file at `path`, recorded under `label`, as `change` leaves it, or as it leaves the text the file
+     * holds now: written when the text differs, unchanged when it does not, else refused.
+     */
+    apply(label, path, change) {
+        const current = existsSync(path) ? readFileSync(path, "utf8") : undefined;
+        const next = typeof change === "function" ? change(current) : change;
+        if ("refusal" in next) {
+            this.record(label, "refused", next.refusal);
+            return;
+        }
+        if (next.text === current) {
+            this.record(label, "unchanged", undefined);
+            return;
+        }
+        if (!this.dryRun) {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, next.text);
+        }
+        this.record(label, "wrote", next.detail);
+    }
+    /** The file at `path`, made by `make` when nothing sits there, a dangling symlink included; never replaced. */
+    create(label, path, make) {
+        const absent = lstatSync(path, { throwIfNoEntry: false }) === undefined;
+        if (absent && !this.dryRun) {
+            mkdirSync(dirname(path), { recursive: true });
+            make(path);
+        }
+        this.record(label, absent ? "wrote" : "unchanged", undefined);
+    }
+    refuse(label, detail) {
+        this.record(label, "refused", detail);
+    }
+    skip(label, detail) {
+        this.record(label, "skipped", detail);
+    }
+    byHand(label, detail) {
+        this.record(label, "by hand", detail);
+    }
+}
+/** One line a step: what it did, or would do under `dryRun`, the file, and why where it says. */
+export function stepLines(steps, dryRun) {
+    return steps.map(({ file, outcome, detail }) => {
+        const verb = outcome === "wrote" && dryRun ? "would write" : outcome;
+        return `${verb.padEnd(11)} ${file}${detail === undefined ? "" : ` — ${detail}`}`;
+    });
+}

package/dist/shell-line.d.ts

@@ -0,0 +1,2 @@
+/** The words as one POSIX shell command line, each word that needs it single-quoted. */
+export declare function shellLine(words: string[]): string;

package/dist/shell-line.js

@@ -0,0 +1,5 @@
+// A command as the line a dev pastes into a POSIX shell: what an answer hands the dev to run.
+/** The words as one POSIX shell command line, each word that needs it single-quoted. */
+export function shellLine(words) {
+    return words.map((word) => (/^[\w./:=@%+,-]+$/.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`)).join(" ");
+}

package/dist/sweep-removal.d.ts

@@ -0,0 +1,31 @@
+import type { StaleLock } from "./worktree-lock.ts";
+export type Item = {
+    kind: "branch" | "worktree" | "lock" | "terminal";
+    name: string;
+    reason: string;
+};
+export type Kept = Item & {
+    command: string | null;
+    dev: boolean;
+};
+/**
+ * An item to remove: `at` the commit it was judged at, a worktree's HEAD or a branch's tip; a worktree's
+ * `holds` branch, `stale` lock, `workerLock` its Worker's program holds; a terminal's `stop`, `tree`.
+ */
+export type Planned = Item & {
+    at?: string;
+    holds?: string;
+    stale?: StaleLock;
+    stop?: boolean;
+    tree?: string;
+    workerLock?: {
+        pid: number;
+    };
+};
+export type Judged = {
+    base: string;
+    removed: Planned[];
+    kept: Kept[];
+};
+/** Removes each item judged to go, in order; a worktree that stays keeps the branch it holds as well. */
+export declare function apply({ base, removed, kept }: Judged, root: string): Judged;

package/dist/sweep-removal.js

@@ -0,0 +1,133 @@
+// How a Sweep carries out what it judged: each item it plans to remove, removed in order, and the one git or
+// hc refuses, or that outlives its time limit, kept with why. docs/adr/0015 sets the bounds: it never forces.
+import { SLOW_LIMIT_MS, TimedOut } from "./exec.js";
+import { git } from "./git.js";
+import { byHand, lockAfterStop, takeDown } from "./sweep-terminals.js";
+import { forcedDelete, forcedRemoval, tipOf, unlockCommand, whyUnclean, worktreesOf } from "./sweep-trees.js";
+/** Why the worktree `item` stays after all, read again just before it goes: what changed since it was judged. */
+function whyChanged(root, item) {
+    const now = worktreesOf(root).find(({ path }) => path === item.name);
+    if (now === undefined) {
+        return { reason: "git no longer lists it", command: null };
+    }
+    if (now.head !== item.at) {
+        return { reason: `its HEAD moved to ${now.head.slice(0, 9)} since the Sweep judged it`, command: null };
+    }
+    if (now.branch !== item.holds) {
+        const on = now.branch === undefined ? "a detached HEAD" : `${now.branch} checked out`;
+        return { reason: `it has ${on} since the Sweep judged it`, command: null };
+    }
+    if (now.lock !== item.stale?.held) {
+        return { reason: "its lock changed since the Sweep judged it", command: null };
+    }
+    return whyUnclean(item.name, item.stale !== undefined);
+}
+/** The command that removes `item` by hand, for one the Sweep did not remove. */
+function byHandOf(item) {
+    if (item.kind === "terminal") {
+        return byHand(item);
+    }
+    return item.kind === "worktree" ? forcedRemoval(item.name, item.stale !== undefined) : forcedDelete(item.name);
+}
+/** Stops, if it asks, and removes the terminal of `item`; why it stays, in hc's words, or undefined once it is gone. */
+function removeTerminalOf(item, unstopped) {
+    const failed = takeDown(item);
+    if (failed === undefined) {
+        return undefined;
+    }
+    if (item.tree !== undefined) {
+        unstopped.set(item.tree, `its Worker's terminal ${item.name} stays: ${failed}`);
+    }
+    return { reason: failed, command: byHandOf(item) };
+}
+/** Removes the worktree of `item` once it still passes, its stale lock lifted just before; why it stays, or undefined. */
+function removeTree(root, item, unstopped) {
+    const unstoppable = unstopped.get(item.name);
+    if (unstoppable !== undefined) {
+        return { reason: unstoppable, command: null };
+    }
+    if (item.workerLock !== undefined) {
+        const now = lockAfterStop(root, item.name);
+        if (now.state === "stays") {
+            return { reason: `its Worker's terminal was stopped, but ${now.reason}`, command: now.command };
+        }
+        if (now.state === "stale") {
+            item.stale = now;
+        }
+        delete item.workerLock;
+    }
+    const changed = whyChanged(root, item);
+    if (changed !== null) {
+        return changed;
+    }
+    if (item.stale !== undefined) {
+        const lifted = git(root, ["worktree", "unlock", "--", item.name]);
+        if ("error" in lifted) {
+            return { reason: lifted.error, command: unlockCommand(item.name) };
+        }
+    }
+    let result;
+    try {
+        result = git(root, ["worktree", "remove", "--", item.name], { limitMs: SLOW_LIMIT_MS });
+    }
+    catch (error) {
+        if (!(error instanceof TimedOut)) {
+            throw error;
+        }
+        result = { error: error.message, said: error.message };
+    }
+    if (!("error" in result)) {
+        return undefined;
+    }
+    const relocked = item.stale === undefined ? undefined : git(root, ["worktree", "lock", "--reason", item.stale.held, "--", item.name]);
+    const lost = relocked !== undefined && "error" in relocked ? `; its lock could not be put back: ${relocked.error}` : "";
+    return { reason: `${result.error}${lost}`, command: byHandOf(item) };
+}
+/** Deletes the branch of `item` while it still points at the commit judged Landed; why it stays, or undefined. */
+function removeBranch(root, item, heldBy) {
+    const path = heldBy.get(item.name);
+    if (path !== undefined) {
+        return { reason: `checked out in the worktree at ${path}`, command: null };
+    }
+    // Read just before the delete: git branch -D, the delete the guard lets an agent make, takes no expected tip.
+    const now = tipOf(root, item.name);
+    if (now !== undefined && now !== item.at) {
+        return { reason: `it moved to ${now.slice(0, 9)} since the Sweep judged it`, command: null };
+    }
+    const result = git(root, ["branch", "-D", "--", item.name]);
+    return "error" in result ? { reason: result.error, command: byHandOf(item) } : undefined;
+}
+/** Removes `item`; why it stays, in git's or hc's words or as the time limit it hit, or undefined once it is gone. */
+function removal(root, item, heldBy, unstopped) {
+    try {
+        if (item.kind === "terminal") {
+            return removeTerminalOf(item, unstopped);
+        }
+        return item.kind === "worktree" ? removeTree(root, item, unstopped) : removeBranch(root, item, heldBy);
+    }
+    catch (error) {
+        if (error instanceof TimedOut) {
+            return { reason: error.message, command: byHandOf(item) };
+        }
+        throw error;
+    }
+}
+/** Removes each item judged to go, in order; a worktree that stays keeps the branch it holds as well. */
+export function apply({ base, removed, kept }, root) {
+    const gone = [];
+    const refused = [];
+    const heldBy = new Map();
+    const unstopped = new Map();
+    for (const item of removed) {
+        const why = removal(root, item, heldBy, unstopped);
+        if (why === undefined) {
+            gone.push(item);
+            continue;
+        }
+        if (item.kind === "worktree" && item.holds !== undefined) {
+            heldBy.set(item.holds, item.name);
+        }
+        refused.push({ kind: item.kind, name: item.name, ...why, dev: true });
+    }
+    return { base, removed: gone, kept: [...kept, ...refused] };
+}

package/dist/sweep-terminals.d.ts

@@ -56,7 +56,7 @@ export declare function whyHeld(holders: Holder[]): {
 /** The terminals of the Workers done in a worktree that goes, to stop and remove with it. */
 export declare function stopsOf(holders: Holder[], tree: string): TerminalPlan[];
 /** Stops, if `item` asks, and removes its terminal; the words of the `hc` that refused, or undefined when it is gone. */
-export declare function removeTerminal(item: {
+export declare function takeDown(item: {
     name: string;
     stop?: boolean;
 }): string | undefined;