dw-sdlc 0.14.0 → 0.15.0

package/dist/agentic-config.js

@@ -1,9 +1,9 @@
 // Reads what a repository declares for an agent: the committed config, the machine's local layer over it,
 // and what the repository implies; an invalid layer is dropped whole. The sdlc plugin's
 // `hooks/config.jq` is the same merge for the guards; this file is the reference, and the tests run both.
-import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { exec } from "./exec.js";
 import { validate } from "./json-schema.js";
 export const COMMITTED_FILE = ".ai/agentic.config.json";
 export const LOCAL_FILE = ".ai/agentic.config.local.json";
@@ -143,7 +143,7 @@ function readLayer(checkouts, file) {
 }
 /** The top level of the repository holding `dir`, or undefined outside one. */
 export function findRepository(dir) {
-    const toplevel = spawnSync("git", ["-C", dir, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    const toplevel = exec("git", ["-C", dir, "rev-parse", "--show-toplevel"]);
     return toplevel.status === 0 ? toplevel.stdout.trim() : undefined;
 }
 /** The top level of the repository holding `dir`, or `dir` itself outside one. */
@@ -156,7 +156,7 @@ export function repositoryRoot(dir) {
  */
 export function mainCheckout(root) {
     const args = ["-C", root, "rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"];
-    const result = spawnSync("git", args, { encoding: "utf8" });
+    const result = exec("git", args);
     if (result.status !== 0) {
         return undefined;
     }

package/dist/checks/file-size-ratchet.js

@@ -1,8 +1,8 @@
 // `file-size-ratchet`: each file of code within the line limit of its group or, listed in the baseline,
 // within the count recorded there. A refresh only tightens the baseline: it lowers and drops, and adds no file.
-import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, matchesGlob } from "node:path";
+import { exec } from "../exec.js";
 import { CannotRun } from "./check.js";
 import { matching, treeFiles } from "./tree.js";
 const BASELINE = ".ai/file-size-ratchet.baseline.json";
@@ -58,7 +58,7 @@ function keyLines(text, path) {
 function readBaseline(root) {
     const path = join(root, BASELINE);
     if (!existsSync(path)) {
-        const committed = spawnSync("git", ["-C", root, "cat-file", "-e", `HEAD:${BASELINE}`]).status === 0;
+        const committed = exec("git", ["-C", root, "cat-file", "-e", `HEAD:${BASELINE}`]).status === 0;
         return { state: "missing", committed };
     }
     const text = readFileSync(path, "utf8");

package/dist/checks/tree.js

@@ -1,13 +1,13 @@
 // The files of a repository as git sees them, the directories above them, and the ones a Check's globs
 // pick out of them: what the Checks that judge many files read, so a file git ignores is never judged.
-import { spawnSync } from "node:child_process";
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { join, matchesGlob, posix, relative } from "node:path";
+import { exec } from "../exec.js";
 import { CannotRun } from "./check.js";
 /** Every file under `pathspecs`, the whole tree when there are none, that git tracks or would track and that is on disk; sorted. */
 export function treeFiles(root, pathspecs = []) {
     const args = ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...pathspecs];
-    const listed = spawnSync("git", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    const listed = exec("git", args);
     if (listed.status !== 0) {
         const under = pathspecs.length === 0 ? "" : ` under ${pathspecs.join(", ")}`;
         const message = `cannot list the files${under}: not a git repository`;

package/dist/cli.js

@@ -55,5 +55,12 @@ async function main(argv) {
     return command.run(argv.slice(words));
 }
 if (import.meta.main) {
-    process.exitCode = await main(process.argv.slice(2));
+    try {
+        process.exitCode = await main(process.argv.slice(2));
+    }
+    catch (error) {
+        // What no command answered for stopped it before a verdict: exit 1 would read as one.
+        process.stderr.write(`dw-sdlc: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 2;
+    }
 }

package/dist/commands/doctor.js

@@ -1,13 +1,13 @@
 // `dw-sdlc doctor`: one PASS / WARN / FAIL line per machine check the sdlc plugin relies on, for the
 // repository holding --root and the user's home; it installs nothing. FAIL is a guard that does not guard
 // (no jq, plugin absent or disabled, an invalid config), WARN a layer missing, loose or out of step, INFO one that does not apply.
-import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { findRepository, resolveConfig } from "../agentic-config.js";
-import { checkPackage, checkPlugin, checkSessions, parseJson, runningPluginRoot, versionBefore } from "../doctor-plugins.js";
+import { checkPackage, checkPlugin, checkSessions, parseJson, runningPluginRoot, sessionsEnabled, versionBefore } from "../doctor-plugins.js";
+import { exec, TimedOut } from "../exec.js";
 import { isObject } from "../json-text.js";
 /** Claude Code's config dir: `$CLAUDE_CONFIG_DIR` when set, the way Claude Code reads it, else `~/.claude`. */
 export function claudeConfigDir(env, home) {
@@ -16,18 +16,30 @@ export function claudeConfigDir(env, home) {
 /** rtk find passes -exec through verbatim from this release; before it, `rtk find … -exec` exits 1. */
 export const RTK_FIND_EXEC_FIXED = "0.46.0";
 export const PNPM_MINIMUM_RELEASE_AGE = 10080;
+/** A probe past its limit answers as a tool that could not run, so its check reports it and the rest still run. */
+function probed(tool, args, cwd) {
+    try {
+        return exec(tool, args, cwd === undefined ? {} : { cwd });
+    }
+    catch (error) {
+        if (error instanceof TimedOut) {
+            return undefined;
+        }
+        throw error;
+    }
+}
 export const realProbe = {
     run(command, args, cwd) {
-        const result = spawnSync(command, args, { cwd, encoding: "utf8" });
-        return { status: result.status ?? 127, stdout: result.stdout ?? "" };
+        const result = probed(command, args, cwd);
+        return { status: result?.status ?? 127, stdout: result?.stdout ?? "" };
     },
     read(path) {
         return existsSync(path) ? readFileSync(path, "utf8") : undefined;
     },
     shell(script) {
         const shell = process.env.SHELL ?? "/bin/sh";
-        const result = spawnSync(shell, ["-l", "-c", script], { encoding: "utf8" });
-        return (result.stdout ?? "").trim().split("\n")[0] ?? "";
+        const result = probed(shell, ["-l", "-c", script]);
+        return (result?.stdout ?? "").trim().split("\n")[0] ?? "";
     }
 };
 function checkJq(probe) {
@@ -121,11 +133,18 @@ function checkRtk(probe, home, claude) {
         detail: `rtk ${version} behind the plugin's rewrite hook; exclude_commands: ${excludes.join(", ") || "none"}`
     };
 }
-/** herdr's `hc` in the agent's shell, which a Lead starts its Workers through; a machine may go without it. */
+/**
+ * herdr's `hc` in the agent's shell, which a Lead starts its Workers through. Its absence warns only where
+ * `sdlc-sessions` is enabled: a machine with only the guards has no reason to install herdr.
+ */
 function checkHc(probe) {
     const hc = probe.shell("command -v hc");
     if (hc === "") {
-        return { name: "hc", level: "INFO", detail: "no hc on PATH, so no /sdlc-delegate: install herdr to run Workers" };
+        return {
+            name: "hc",
+            level: sessionsEnabled(probe) ? "WARN" : "INFO",
+            detail: "no hc on PATH, so no /sdlc-delegate: install herdr to run Workers"
+        };
     }
     return { name: "hc", level: "PASS", detail: `${hc}, so a Lead can start Workers` };
 }

package/dist/commands/references-setup.js

@@ -1,10 +1,10 @@
 // `dw-sdlc references setup` sets a repository up to declare References: the files its USAGE names,
 // each written only when it would change. A list gains the entries it lacks at its end; the one removal
 // is a `references` key moving out of the agentic config. A file it cannot read as expected is refused.
-import { spawnSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseArgs } from "node:util";
+import { exec } from "../exec.js";
 import { parseObject, removeKey, render } from "../json-text.js";
 import { CONFIG, REFERENCES_FILE, leftoverKey, leftoverProblem, parseReferences, readFile } from "../references-key.js";
 import { renderBlock, withBlock } from "../router-block.js";
@@ -159,7 +159,7 @@ function source(root) {
 }
 /** The repository `dir` sits in, or `dir` itself outside one. */
 function toplevel(dir) {
-    const result = spawnSync("git", ["-C", dir, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    const result = exec("git", ["-C", dir, "rev-parse", "--show-toplevel"]);
     return result.status === 0 ? result.stdout.trim() : dir;
 }
 function setup(root, dryRun) {

package/dist/commands/references-sync.js

@@ -1,11 +1,11 @@
 // `dw-sdlc references sync`, the Sync: every Reference `.ai/references.json` declares brought to its ref
 // under references/<dir>, each clone shallow, blobless, detached and sparse where its entry says. An
 // entry that fails fails alone, and a repository that declares no References gets no output at all.
-import { spawnSync } from "node:child_process";
 import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { parseArgs } from "node:util";
+import { exec, SLOW_LIMIT_MS } from "../exec.js";
 import { repositoryFreeEnv } from "../git-env.js";
 import { readPins, resolveRef } from "../pins.js";
 import { REFERENCES_FILE, readReferences } from "../references-key.js";
@@ -135,10 +135,9 @@ async function lock(root, seconds) {
     }
 }
 function git(args, cwd) {
-    // Each call finds its repository from `cwd`. A missing credential fails the fetch instead of waiting
-    // on a prompt nobody sees.
-    const env = { ...repositoryFreeEnv(), GIT_TERMINAL_PROMPT: "0" };
-    const result = spawnSync("git", args, { cwd, encoding: "utf8", env });
+    // Each call finds its repository from `cwd`.
+    const env = repositoryFreeEnv();
+    const result = exec("git", args, { ...(cwd === undefined ? {} : { cwd }), env, limitMs: SLOW_LIMIT_MS });
     // git's error on one line, so each Reference stays one line of the report.
     const err = (result.stderr ?? "")
         .split("\n")

package/dist/commands/setup.js

@@ -1,13 +1,13 @@
 // `dw-sdlc setup` sets a repository and this machine up for the sdlc plugin: the files its USAGE names,
 // each written only when its content would change, so a run is safe to repeat. Existing content is
 // merged, never replaced: other keys stay, and a file that is not a JSON object is refused.
-import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 import { COMMIT_CONVENTIONS, COMMITTED_FILE, DEFAULT_GUARDRAILS, LOCAL_FILE, SCHEMA_FILE, STRICTNESS, inferConfig, repositoryRoot, resolveConfig, schemaId, validateDocument } from "../agentic-config.js";
+import { exec } from "../exec.js";
 import { isObject, parseObject, render } from "../json-text.js";
 import { withGate, withPackage } from "../setup-gate.js";
 import { GLOBAL_DENY, LEASE_RULE, RETIRED_DENY, repositoryDeny } from "../setup-rules.js";
@@ -54,7 +54,7 @@ const PACKAGE_LINK = "dw-sdlc";
 const RETIRED_PLUGINS = ["guardrails", "references"].map((name) => `${name}@${MARKETPLACE}`);
 /** A read-only git command, the one thing the setup runs in the repository. */
 function git(root, args) {
-    const result = spawnSync("git", ["-C", root, ...args], { encoding: "utf8" });
+    const result = exec("git", ["-C", root, ...args]);
     return result.status === 0 ? result.stdout.trim() : undefined;
 }
 /** The committed layer when it is valid; an absent or invalid one sets nothing, as the resolver drops it. */

package/dist/commands/sweep.js

@@ -1,9 +1,9 @@
 // `dw-sdlc sweep`: removes each linked worktree whose whole set passes and each Landed local branch.
 // docs/adr/0015 sets its bounds: it runs from the main checkout, never forces and never writes to a remote.
-import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { findRepository, mainCheckout, resolveConfig } from "../agentic-config.js";
+import { exec, SLOW_LIMIT_MS } from "../exec.js";
 import { repositoryFreeEnv } from "../git-env.js";
 import { isCommitLanded, isLanded } from "../landed.js";
 import { shellLine } from "../pr/decide.js";
@@ -60,8 +60,10 @@ function fetchOrigin(root) {
     if (asked(root, ["remote", "get-url", "origin"]) === undefined) {
         return;
     }
-    const env = { ...repositoryFreeEnv(), GIT_TERMINAL_PROMPT: "0" };
-    const result = spawnSync("git", ["-C", root, "fetch", "--quiet", "origin"], { encoding: "utf8", env, stdio: "pipe" });
+    const result = exec("git", ["-C", root, "fetch", "--quiet", "origin"], {
+        env: repositoryFreeEnv(),
+        limitMs: SLOW_LIMIT_MS
+    });
     if (result.status !== 0) {
         const said = result.stderr.split("\n").find((line) => line.trim() !== "");
         throw new CannotRun(`git fetch origin failed: ${said?.trim() ?? `exited ${result.status}`}`, "check the network, then call again");

package/dist/doctor-plugins.d.ts

@@ -6,6 +6,8 @@ export declare function runningPluginRoot(probe: Probe, claude: string, plugin?:
 export declare function checkPlugin(probe: Probe, claude: string): Check;
 /** Whether the plugin's hooks and skills run the dw-sdlc the repository pins, the one its Gate runs. */
 export declare function checkPackage(probe: Probe, claude: string, root: string | undefined): Check;
+/** Whether `sdlc-sessions` is installed and enabled here, so `/sdlc-delegate` is one the dev can start. */
+export declare function sessionsEnabled(probe: Probe): boolean;
 /**
  * `sdlc-sessions`, which a machine may go without, so it never fails. Its copy of the package against
  * the sdlc plugin's copy: the `package` line holds that one to the repository's pin.

package/dist/doctor-plugins.js

@@ -131,6 +131,10 @@ export function checkPackage(probe, claude, root) {
     }
     return { name, level: "PASS", detail: `${PACKAGE} ${linked} in the plugin and in the repository` };
 }
+/** Whether `sdlc-sessions` is installed and enabled here, so `/sdlc-delegate` is one the dev can start. */
+export function sessionsEnabled(probe) {
+    return listedPlugins(probe)?.find((item) => item.id === SESSIONS_ID)?.enabled === true;
+}
 /**
  * `sdlc-sessions`, which a machine may go without, so it never fails. Its copy of the package against
  * the sdlc plugin's copy: the `package` line holds that one to the repository's pin.
@@ -140,7 +144,9 @@ export function checkSessions(probe, claude) {
     const list = listedPlugins(probe);
     const entry = list?.find((item) => item.id === SESSIONS_ID);
     if (entry === undefined) {
-        const detail = list === undefined ? "claude plugin list did not answer" : `no ${SESSIONS_ID}, so no /sdlc-recap`;
+        const detail = list === undefined
+            ? "claude plugin list did not answer"
+            : `no ${SESSIONS_ID}, so no /sdlc-recap, /sdlc-brief or /sdlc-delegate. claude plugin install ${SESSIONS_ID} --scope user`;
         return { name, level: "INFO", detail };
     }
     const version = typeof entry.version === "string" ? entry.version : "?";

package/dist/exec.d.ts

@@ -0,0 +1,14 @@
+import { type SpawnSyncReturns } from "node:child_process";
+/** For what the network or a repository's size can stretch: a clone, a fetch, a scan of its history. */
+export declare const SLOW_LIMIT_MS = 600000;
+export type ExecOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string;
+    limitMs?: number;
+};
+/** A tool that outlived its limit and was stopped; the message names it. */
+export declare class TimedOut extends Error {
+}
+/** `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>;

package/dist/exec.js

@@ -0,0 +1,39 @@
+// Every short-lived child process the package runs: stopped at a time limit, so a tool that hangs cannot
+// hang the command, and with git's prompts off, since nobody would see one. A Step of the Gate runs
+// through `run-command.ts` instead, and takes as long as it takes.
+import { spawnSync } from "node:child_process";
+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;
+/** A Step that writes thousands of files makes a diff-tree past the default of 1 MiB. */
+const MAX_BUFFER = 64 * 1024 * 1024;
+const SHOWN = 80;
+/** A tool that outlived its limit and was stopped; the message names it. */
+export class TimedOut extends Error {
+}
+/** DW_SDLC_LIMIT_MS, which a test sets to reach a limit quickly, else the limit the call asks for. */
+function limitOf(asked) {
+    const given = Number(process.env.DW_SDLC_LIMIT_MS);
+    return given > 0 ? given : asked;
+}
+function shown(tool, args) {
+    return [tool, ...args].join(" ").replaceAll(/\s+/g, " ").trim().slice(0, SHOWN);
+}
+/** `tool args` as a child process; a tool's own exit, or its absence, is the caller's. Throws `TimedOut` at the limit. */
+export function exec(tool, args, options = {}) {
+    const { cwd, env = process.env, input } = options;
+    const limitMs = limitOf(options.limitMs ?? LIMIT_MS);
+    const result = spawnSync(tool, args, {
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(input === undefined ? {} : { input }),
+        encoding: "utf8",
+        env: { ...env, GIT_TERMINAL_PROMPT: "0" },
+        killSignal: "SIGKILL",
+        maxBuffer: MAX_BUFFER,
+        timeout: limitMs
+    });
+    if (result.error !== undefined && "code" in result.error && result.error.code === "ETIMEDOUT") {
+        throw new TimedOut(`${shown(tool, args)} did not answer within ${limitMs / 1000} s`);
+    }
+    return result;
+}

package/dist/git-env.js

@@ -1,10 +1,10 @@
 // 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 { spawnSync } from "node:child_process";
+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((spawnSync("git", ["rev-parse", "--local-env-vars"], { encoding: "utf8" }).stdout ?? "").split("\n").filter(Boolean));
+    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)));
 }

package/dist/landed.js

@@ -1,7 +1,7 @@
 // Whether a local branch is Landed: its work is on the base, as the guard's `guard_landed`
 // (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 { spawnSync } from "node:child_process";
+import { exec, SLOW_LIMIT_MS } from "./exec.js";
 import { repositoryFreeEnv } from "./git-env.js";
 /** The base commits read, newest first: a branch that forked further back is kept rather than read for seconds. */
 const SCAN = 5000;
@@ -9,18 +9,17 @@ const SCAN = 5000;
 function localEnv() {
     return { ...repositoryFreeEnv(), GIT_NO_LAZY_FETCH: "1" };
 }
-function git(root, args, input) {
-    const result = spawnSync("git", ["-C", root, ...args], {
-        encoding: "utf8",
+function git(root, args, input, limitMs) {
+    const result = exec("git", ["-C", root, ...args], {
         env: localEnv(),
-        input,
-        maxBuffer: 64 * 1024 * 1024
+        ...(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) {
-    const ran = git(root, args, input);
+function answer(root, args, input, limitMs) {
+    const ran = git(root, args, input, limitMs);
     return ran.status === 0 ? ran.stdout.trim() : undefined;
 }
 /** The patch-id of the whole diff from `from` to `to`; undefined for an empty diff or one git could not finish. */
@@ -44,10 +43,9 @@ function baseHoldsPatch(root, range, patch) {
             "git patch-id --verbatim"
         ].join(" | ")
     ].join("; ");
-    const result = spawnSync("bash", ["-c", pipeline, "bash", root, String(SCAN), range], {
-        encoding: "utf8",
+    const result = exec("bash", ["-c", pipeline, "bash", root, String(SCAN), range], {
         env: localEnv(),
-        maxBuffer: 64 * 1024 * 1024
+        limitMs: SLOW_LIMIT_MS
     });
     if (result.status !== 0) {
         return false;
@@ -77,7 +75,7 @@ export function isCommitLanded(root, baseRef, tip) {
         return false;
     }
     const range = `${fork}..${baseRef}`;
-    const trees = answer(root, ["log", "--format=%T", `--max-count=${SCAN}`, range]) ?? "";
+    const trees = answer(root, ["log", "--format=%T", `--max-count=${SCAN}`, range], undefined, SLOW_LIMIT_MS) ?? "";
     if (trees.split("\n").includes(tree)) {
         return true;
     }

package/dist/pr/decide.d.ts

@@ -3,7 +3,7 @@ import { type PrState, REVIEW } from "./state.ts";
 export { REVIEW };
 export type Status = "act" | "wait" | "park" | "done";
 export type Actor = "script" | "agent" | "dev";
-export type Action = "done" | "stop" | "wait" | "fix-conflicts" | "update-branch" | "fix-ci" | "address-review" | "review" | "review-limit" | "mark-reviewed" | "unverified" | "ci-stuck" | "awaiting-reply" | "mark-ready" | "awaiting-author" | "awaiting-approval" | "ready-to-merge" | "merge";
+export type Action = "done" | "stop" | "wait" | "fix-conflicts" | "update-branch" | "fix-ci" | "address-review" | "review" | "review-limit" | "mark-reviewed" | "unverified" | "ci-stuck" | "awaiting-reply" | "awaiting-review" | "mark-ready" | "awaiting-author" | "awaiting-approval" | "partial-read" | "ready-to-merge" | "merge";
 /** The Actions the script performs itself, each one gh command. */
 export type ScriptAction = "update-branch" | "mark-ready" | "mark-reviewed" | "merge";
 /**

package/dist/pr/decide.js

@@ -46,6 +46,20 @@ function failure({ name, link, log }) {
 function threads(pr, lastByViewer) {
     return pr.unresolvedThreads.filter((thread) => thread.lastByViewer === lastByViewer);
 }
+/**
+ * Whether the decision is changes requested and every reviewer asking for them has been answered by a
+ * push. One review still unanswered, or none in the reply to judge, keeps the agent's turn.
+ */
+function reviewAnswered({ reviewDecision, changeRequests }) {
+    return (reviewDecision === "CHANGES_REQUESTED" &&
+        changeRequests.length > 0 &&
+        changeRequests.every(({ answered }) => answered));
+}
+/** The names, `a`, `a and b` or `a, b and c`. */
+function namesOf(names) {
+    const last = names.at(-1);
+    return names.length < 2 ? names.join("") : `${names.slice(0, -1).join(", ")} and ${last}`;
+}
 function listed({ id, path, line, author, body }) {
     return { id, path, line, author, body };
 }
@@ -200,7 +214,7 @@ const ROWS = [
         })
     },
     {
-        when: (pr) => pr.reviewDecision === "CHANGES_REQUESTED",
+        when: (pr) => pr.reviewDecision === "CHANGES_REQUESTED" && !reviewAnswered(pr),
         answer: () => ({ status: "act", action: "address-review", actor: "agent", reason: "changes requested" })
     },
     {
@@ -273,6 +287,17 @@ const ROWS = [
             details: { threads: threads(pr, true).map(listed) }
         })
     },
+    {
+        // After awaiting-reply, so the pull request's own Review and CI run first and the reviewer gets a
+        // verified fix. Only the reviewer can act: their review stands until they review again or dismiss it.
+        when: reviewAnswered,
+        answer: (pr) => ({
+            status: "park",
+            action: "awaiting-review",
+            actor: "dev",
+            reason: `changes requested by ${namesOf(pr.changeRequests.map(({ reviewer }) => reviewer))}, answered by a push: the next review is the reviewer's`
+        })
+    },
     {
         when: (pr) => pr.draft && pr.viewerDidAuthor,
         answer: () => ({ status: "act", action: "mark-ready", actor: "script", reason: "still a draft" })
@@ -295,6 +320,17 @@ const ROWS = [
             reason: "an approving review is required"
         })
     },
+    {
+        // A failure or an open thread past what the read holds shows in no row above.
+        when: (pr) => pr.cutOff.length > 0,
+        answer: (pr, _, policy) => ({
+            status: "park",
+            action: "partial-read",
+            actor: "dev",
+            reason: `the read holds only ${pr.cutOff.join(" and ")}: the merge is the dev's`,
+            command: devCommand(pr, "merge", policy)
+        })
+    },
     {
         when: (pr) => !pr.viewerDidAuthor,
         answer: (pr, _, policy) => readyToMerge(pr, policy, "another author's pull request: the merge is the dev's"),

package/dist/pr/read.js

@@ -1,7 +1,7 @@
 // The read the pr commands and recap make: gh as a child process, its auth, the pull request a command names,
 // its state from one GraphQL request with the compares that tell whether its head carries an earlier Review
 // and that size its changes, and beside them the default branch and the clock the decision reads.
-import { spawnSync } from "node:child_process";
+import { exec, TimedOut } from "../exec.js";
 import { behindOf, changedOf, changesOf, compareArgs, sameChanges } from "./delta.js";
 import { awaitsReview, parseDefaultBranch, parsePr, parseView, QUERY, ReplyError } from "./state.js";
 /** What stops a pr command or recap before it answers: exit 2, the problem and its remedy on one line. */
@@ -42,8 +42,20 @@ function authProblem(stderr) {
     const marked = stderr.split("\n").find((line) => line.trimStart().startsWith("X "));
     return marked === undefined ? firstLine(stderr) : marked.trim().slice(2);
 }
+/** `gh args` as a child process; past its limit it stops the command as any other failed read does. */
+function reachGh(args) {
+    try {
+        return exec("gh", args);
+    }
+    catch (error) {
+        if (error instanceof TimedOut) {
+            throw new CannotRun(error.message, REMEDIES.read);
+        }
+        throw error;
+    }
+}
 export function gh(args) {
-    const result = spawnSync("gh", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    const result = reachGh(args);
     if (result.error !== undefined) {
         if ("code" in result.error && result.error.code === "ENOENT") {
             throw new CannotRun("gh is not on PATH", REMEDIES.missing);

package/dist/pr/state.d.ts

@@ -10,7 +10,7 @@ export declare const MARK_STATE = "failure";
 export declare const READ_MARK = "read, findings open";
 /** How the description of the success the dev's `--accept` posts reads: the head, taken with its Findings open. */
 export declare const ACCEPTED = "accepted by the dev, findings open";
-export declare const QUERY = "query($owner: String!, $name: String!, $number: Int!) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $number) {\n      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName baseRefName baseRefOid\n      baseRef { target { oid } } viewerDidAuthor mergeCommit { oid }\n      reviewThreads(first: 100) { nodes { id isResolved isOutdated path line\n        comments(first: 1) { nodes { author { login } body } }\n        latest: comments(last: 1) { nodes { viewerDidAuthor } } } }\n      commits(last: 1) { nodes { commit { committedDate statusCheckRollup {\n        contexts(first: 50) { nodes {\n          ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }\n          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }\n      history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: \"dw-sdlc/review\") { state description } } } } }\n    }\n  }\n}";
+export declare const QUERY = "query($owner: String!, $name: String!, $number: Int!) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $number) {\n      url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName baseRefName baseRefOid\n      baseRef { target { oid } } viewerDidAuthor mergeCommit { oid }\n      latestReviews(first: 100) { nodes { state author { login } commit { oid } } }\n      reviewThreads(first: 100) { pageInfo { hasNextPage } nodes { id isResolved isOutdated path line\n        comments(first: 1) { nodes { author { login } body } }\n        latest: comments(last: 1) { nodes { viewerDidAuthor } } } }\n      commits(last: 1) { nodes { commit { committedDate statusCheckRollup {\n        contexts(first: 50) { pageInfo { hasNextPage } nodes {\n          ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }\n          ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }\n      history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: \"dw-sdlc/review\") { state description } } } } }\n    }\n  }\n}";
 export type Bucket = "pass" | "fail" | "pending" | "skipping";
 export type CiCheck = {
     name: string;
@@ -33,6 +33,11 @@ export type Thread = {
 declare const STATES: readonly ["OPEN", "CLOSED", "MERGED"];
 declare const MERGEABLE: readonly ["MERGEABLE", "CONFLICTING", "UNKNOWN"];
 declare const REVIEW_DECISIONS: readonly ["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"];
+/** A reviewer whose latest review requests changes, and whether a push has answered it. */
+export type ChangeRequest = {
+    reviewer: string;
+    answered: boolean;
+};
 export type PrState = {
     url: string;
     repo: string;
@@ -57,6 +62,10 @@ export type PrState = {
     checks: CiCheck[];
     /** The threads neither resolved nor outdated. */
     unresolvedThreads: Thread[];
+    /** Each reviewer's latest review that requests changes, in the order GitHub lists them. */
+    changeRequests: ChangeRequest[];
+    /** What the read holds of each list with more after it, as `the first 50 checks`; empty when it holds all. */
+    cutOff: string[];
     /** The oids of the pull request's last 100 commits, oldest first, the head last. */
     commits: string[];
     /**

package/dist/pr/state.js

@@ -12,16 +12,20 @@ export const MARK_STATE = "failure";
 export const READ_MARK = "read, findings open";
 /** How the description of the success the dev's `--accept` posts reads: the head, taken with its Findings open. */
 export const ACCEPTED = "accepted by the dev, findings open";
+/** How many checks and review threads the one read holds; each list's `pageInfo` says when more follow. */
+const CHECKS_READ = 50;
+const THREADS_READ = 100;
 export const QUERY = `query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) {
     pullRequest(number: $number) {
       url number state isDraft mergeable mergeStateStatus reviewDecision headRefOid headRefName baseRefName baseRefOid
       baseRef { target { oid } } viewerDidAuthor mergeCommit { oid }
-      reviewThreads(first: 100) { nodes { id isResolved isOutdated path line
+      latestReviews(first: 100) { nodes { state author { login } commit { oid } } }
+      reviewThreads(first: ${THREADS_READ}) { pageInfo { hasNextPage } nodes { id isResolved isOutdated path line
         comments(first: 1) { nodes { author { login } body } }
         latest: comments(last: 1) { nodes { viewerDidAuthor } } } }
       commits(last: 1) { nodes { commit { committedDate statusCheckRollup {
-        contexts(first: 50) { nodes {
+        contexts(first: ${CHECKS_READ}) { pageInfo { hasNextPage } nodes {
           ... on CheckRun { name status conclusion detailsUrl startedAt isRequired(pullRequestNumber: $number) }
           ... on StatusContext { context state targetUrl createdAt isRequired(pullRequestNumber: $number) } } } } } } }
       history: commits(last: 100) { nodes { commit { oid parents { totalCount } status { context(name: "${REVIEW}") { state description } } } } }
@@ -131,6 +135,10 @@ function nodes(node, key) {
     }
     return value.map((item, index) => object(item, `${at}[${index}]`));
 }
+/** Whether a connection has more nodes after the ones the reply holds. */
+function hasMore(node, key) {
+    return boolean(child(child(node, key), "pageInfo"), "hasNextPage");
+}
 /** The first object of a connection's `nodes`; an empty connection does not parse. */
 function firstNode(node, key) {
     const [first] = nodes(node, key);
@@ -246,6 +254,27 @@ function lastReadOf(history, head) {
     }
     return { commit: last.oid, clean: last.read === "clean", mergesOnly: mergesOnlyAfter(index) };
 }
+/**
+ * Whether a non-merge commit follows `commit` in the history, oldest first, as `lastReadOf` judges a read
+ * mark. A commit outside the history, after a force-push or past the last 100, is not answered.
+ */
+function answeredAfter(history, commit) {
+    const index = history.findIndex(({ oid }) => oid === commit);
+    return index >= 0 && history.slice(index + 1).some(({ merge }) => !merge);
+}
+/** The reviewers whose latest review requests changes, each judged against the history. */
+function changeRequestsOf(pr, history) {
+    return nodes(pr, "latestReviews")
+        .filter((review) => string(review, "state") === "CHANGES_REQUESTED")
+        .map((review) => {
+        const author = childOrNull(review, "author");
+        const commit = childOrNull(review, "commit");
+        return {
+            reviewer: author === null ? "ghost" : string(author, "login"),
+            answered: answeredAfter(history, commit === null ? null : string(commit, "oid"))
+        };
+    });
+}
 function readMarksOf(history) {
     const success = history.findLastIndex(({ posted }) => posted === "clean" || posted === "off");
     const count = history.slice(success + 1).filter(({ posted }) => posted === "findings").length;
@@ -293,6 +322,11 @@ export function parsePr(reply, repo) {
         unresolvedThreads: nodes(pr, "reviewThreads")
             .filter((thread) => !boolean(thread, "isResolved") && !boolean(thread, "isOutdated"))
             .map(threadOf),
+        changeRequests: changeRequestsOf(pr, history),
+        cutOff: [
+            ...(rollup !== null && hasMore(rollup, "contexts") ? [`the first ${CHECKS_READ} checks`] : []),
+            ...(hasMore(pr, "reviewThreads") ? [`the first ${THREADS_READ} threads`] : [])
+        ],
         commits: history.map(({ oid }) => oid),
         lastRead: lastReadOf(history, head),
         marks: readMarksOf(history)

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 { spawnSync } from "node:child_process";
 import { DEFAULT_GUARDRAILS, matchesEnvGlob, resolveConfig } from "./agentic-config.js";
+import { exec } from "./exec.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. */
@@ -57,7 +57,7 @@ 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 = spawnSync("git", ["-C", root, ...args], { encoding: "utf8" });
+    const result = exec("git", ["-C", root, ...args]);
     return result.status === 0 ? result.stdout.trim() : undefined;
 }
 function listedIn(globs, file) {

package/dist/sweep-trees.js

@@ -1,8 +1,8 @@
 // What a Sweep reads of a repository's linked worktrees: where each lies, what it has checked out, its lock,
 // the files that hold it and the operation paused in it.
-import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { exec } from "./exec.js";
 import { repositoryFreeEnv } from "./git-env.js";
 import { CannotRun } from "./pr/read.js";
 import { asked, git } from "./working-tree.js";
@@ -41,7 +41,7 @@ export function worktreesOf(root) {
 /** The files `git status` lists in the worktree at `path`, ignored ones aside, or why it cannot be read. */
 export function dirtyFiles(path) {
     const args = ["-C", path, "status", "--porcelain=v1", "-z", "--untracked-files=all"];
-    const result = spawnSync("git", args, { encoding: "utf8", env: repositoryFreeEnv(), maxBuffer: 64 * 1024 * 1024 });
+    const result = exec("git", args, { env: repositoryFreeEnv() });
     if (result.status !== 0) {
         const said = result.stderr.split("\n").find((line) => line.trim() !== "");
         return { error: `git status: ${said?.trim() ?? `exited ${result.status ?? "on a signal"}`}` };

package/dist/worker/herdr.js

@@ -1,6 +1,6 @@
 // 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 { spawnSync } from "node:child_process";
+import { exec, TimedOut } 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 {
@@ -15,9 +15,21 @@ export function said(called) {
     const line = `${called.stderr}\n${called.stdout}`.split("\n").find((text) => text.trim() !== "");
     return line?.trim() ?? `exited ${called.status}`;
 }
+/** `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);
+    }
+    catch (error) {
+        if (error instanceof TimedOut) {
+            throw new Refusal(error.message, "check herdr is responding, then call again");
+        }
+        throw error;
+    }
+}
 /** `tool args` as a child process; a tool that is not on PATH stops the command. */
 export function call(tool, args) {
-    const result = spawnSync(tool, args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    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");

package/dist/working-tree.js

@@ -1,18 +1,15 @@
 // A checkout's working tree as git would commit it: the tree of every file git tracks or would track,
 // hashed on a copy of the index. The Gate's cache fingerprints it and the watch for Drift records it.
-import { spawnSync } from "node:child_process";
 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 = spawnSync("git", ["-C", root, ...args], {
-        encoding: "utf8",
-        env: index === undefined ? env : { ...env, GIT_INDEX_FILE: index },
-        // A Step that writes thousands of files makes a diff-tree past the default 1 MiB.
-        maxBuffer: 64 * 1024 * 1024
+    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() };

package/dist/worktree-lock.js

@@ -1,7 +1,7 @@
 // What a worktree's lock means to a Sweep. Claude Code locks the worktree of a session with the reason
 // `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 { spawnSync } from "node:child_process";
+import { exec } from "./exec.js";
 import { shellLine } from "./pr/decide.js";
 const CLAUDE_LOCK = /^claude session .* \(pid (?<pid>\d{1,10}) start (?<start>.+)\)$/;
 const MAX_PID = 2 ** 31 - 1;
@@ -22,7 +22,7 @@ function runningOf(pid) {
     const starts = [{ TZ: "UTC" }, {}]
         .map((zone) => {
         const env = { ...process.env, LC_ALL: "C", ...zone };
-        const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env });
+        const result = exec("ps", ["-o", "lstart=", "-p", String(pid)], { env });
         return result.status === 0 ? squeezed(result.stdout) : "";
     })
         .filter((start) => start !== "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-sdlc",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "The Gate and the agentic config of a repository: the dw-sdlc bin with the Gate, the setup, the doctor, the config check, the Sync and setup of References, and the Ship script that drives a pull request to merged; the resolver of the config's layers, its JSON Schema and the validator that reads it.",
   "license": "MIT",
   "repository": {