@tech-leads-club/harness-toolkit 0.16.6 → 0.16.7

package/docs/concepts.md

@@ -150,6 +150,11 @@ step. The tree id covers uncommitted and untracked files, so a verdict recorded
 push of that commit, and any edit after it does not. Linked worktrees share one record with their main checkout. A
 gate that rewrites files while it runs is not recorded, because its verdict describes a tree that no longer exists.
 
+The `stop` grind follows the same rule. It reuses a verdict recorded for the current tree by this session or by
+`tlc harness verify`, and otherwise runs the gate inline within a 90-second budget, ending the whole process tree if
+it overruns. A suite that does not fit is handed back: the turn continues with an instruction to run `tlc harness
+verify`, and the overrun is remembered as an estimate — never as a verdict — so the next stop does not start it again.
+
 ## pause / resume
 
 `tlc harness pause` is the circuit breaker: every hook steps aside and answers at once, reading no policy and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tech-leads-club/harness-toolkit",
-  "version": "0.16.6",
+  "version": "0.16.7",
   "type": "module",
   "description": "Multi-provider agent steering: gates, follow-up, handoff, policy",
   "keywords": [

package/src/core/core.facade.ts

@@ -56,7 +56,12 @@ import { filesFromOutput } from "./gate/gate.findings.ts";
 import { cachedVerdict, computeInputsHash, isCacheHit } from "./gate/gate.inputs.ts";
 import { describeHolder, GATE_LOCK_WAIT_MS, GateLockTimeoutError, withGateLock } from "./gate/gate.lock.ts";
 import { gapsFromArtifact } from "./gate/gate.service.ts";
-import { findShipVerdict, lastShipVerdictFor, recordShipVerdict } from "./gate/gate.verdicts.ts";
+import {
+  findShipVerdict,
+  lastShipVerdictFor,
+  recordShipVerdict,
+  VERIFY_SOURCE,
+} from "./gate/gate.verdicts.ts";
 import {
   clearStuckSignals,
   handoffInjectable,
@@ -321,6 +326,7 @@ export const coreFacade = {
     findShipVerdict,
     lastShipVerdictFor,
     recordShipVerdict,
+    VERIFY_SOURCE,
   },
   stagnation: {
     computeFingerprint,

package/src/core/gate/gate.verdicts.ts

@@ -7,6 +7,7 @@ import { trimOutputTail } from "./gate.artifact.ts";
 
 const SHIP_VERDICT_SCHEMA = "harness.ship-verdicts.v1";
 export const SHIP_VERDICT_LIMIT = 50;
+export const VERIFY_SOURCE = "verify";
 
 export type ShipVerdict = {
   gate: string;
@@ -17,6 +18,8 @@ export type ShipVerdict = {
   durationMs: number;
   outputTail: string;
   at: string;
+  timedOut?: boolean;
+  source?: string;
 };
 
 type ShipVerdictFile = { schema: string; verdicts: ShipVerdict[] };
@@ -47,9 +50,15 @@ export function findShipVerdict(
   gate: string,
   command: string[],
   tree: string,
+  sources?: readonly string[],
 ): ShipVerdict | null {
   const matches = readShipVerdicts(root).filter(
-    (verdict) => verdict.gate === gate && verdict.tree === tree && sameCommand(verdict.command, command),
+    (verdict) =>
+      verdict.timedOut !== true &&
+      (sources === undefined || (verdict.source !== undefined && sources.includes(verdict.source))) &&
+      verdict.gate === gate &&
+      verdict.tree === tree &&
+      sameCommand(verdict.command, command),
   );
   return matches.at(-1) ?? null;
 }
@@ -69,11 +78,13 @@ export async function recordShipVerdict(
     gate: input.gate,
     command: input.command,
     tree: input.tree,
-    passed: input.exitCode === 0,
+    passed: input.exitCode === 0 && input.timedOut !== true,
     exitCode: input.exitCode,
     durationMs: input.durationMs,
     outputTail: trimOutputTail(input.output),
     at: input.at ?? new Date().toISOString(),
+    ...(input.timedOut === true ? { timedOut: true } : {}),
+    ...(input.source !== undefined ? { source: input.source } : {}),
   };
   const path = shipVerdictsPath(root);
   await updateJsonAtomic<ShipVerdictFile>(
@@ -84,6 +95,7 @@ export async function recordShipVerdict(
           !(
             existing.gate === verdict.gate &&
             existing.tree === verdict.tree &&
+            existing.source === verdict.source &&
             sameCommand(existing.command, verdict.command)
           ),
       );

package/src/entrypoints/ship-gate.ts

@@ -66,6 +66,24 @@ function formatDuration(ms: number): string {
   return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
 }
 
+function requiredShipGates(
+  policy: HandlerContext["policy"],
+  scope: { codeTargets: string[]; testTargets: string[] },
+): Array<{ gate: string; command: string[] }> {
+  const required: Array<{ gate: string; command: string[] }> = [];
+  const changedCode = scope.codeTargets.length > 0;
+  if (policy.grind.enabled && policy.grind.lintCommand && changedCode) {
+    required.push({ gate: "lint", command: policy.grind.lintCommand });
+  }
+  if (policy.grind.enabled && policy.grind.testCommand && (changedCode || scope.testTargets.length > 0)) {
+    required.push({ gate: "test", command: policy.grind.testCommand });
+  }
+  if (policy.docs.command && policy.docs.command.length > 0 && policy.docs.severity === "deny") {
+    required.push({ gate: "docs", command: policy.docs.command });
+  }
+  return required;
+}
+
 function verdictRefusal(
   root: string,
   tree: string,
@@ -137,20 +155,7 @@ export async function shipGateVerdict(event: HarnessEvent, ctx: HandlerContext):
     };
   }
 
-  const required: Array<{ gate: string; command: string[] }> = [];
-  if (policy.grind.enabled && policy.grind.lintCommand && scope.codeTargets.length > 0) {
-    required.push({ gate: "lint", command: policy.grind.lintCommand });
-  }
-  if (
-    policy.grind.enabled &&
-    policy.grind.testCommand &&
-    (scope.testTargets.length > 0 || scope.codeTargets.length > 0)
-  ) {
-    required.push({ gate: "test", command: policy.grind.testCommand });
-  }
-  if (policy.docs.command && policy.docs.command.length > 0 && policy.docs.severity === "deny") {
-    required.push({ gate: "docs", command: policy.docs.command });
-  }
+  const required = requiredShipGates(policy, scope);
   if (required.length > 0) {
     const tree = await workingTreeId(shaRoot);
     if (tree !== null) {

package/src/entrypoints/stop.ts

@@ -135,7 +135,8 @@ function recordGateDeferred(args: {
  */
 export type GateRun =
   | { kind: "ran"; artifact: LastGateArtifact; reused: boolean }
-  | { kind: "deferred"; holder: string };
+  | { kind: "deferred"; holder: string }
+  | { kind: "slow"; estimateMs: number; budgetMs: number };
 
 /**
  * hazard: `GATE_LOCK_WAIT_MS` is 120 000 and the Stop hook is registered with `timeoutSeconds: 120`, so waiting
@@ -144,6 +145,15 @@ export type GateRun =
  */
 export const STOP_LOCK_WAIT_MS = 10_000;
 
+export const STOP_GATE_BUDGET_MS = 90_000;
+
+const TIMED_OUT_HEADROOM = 1.25;
+
+export function stopGateBudgetMs(env: NodeJS.ProcessEnv = process.env): number {
+  const declared = Number(env.TLC_TEST_STOP_GATE_BUDGET_MS);
+  return Number.isFinite(declared) && declared > 0 ? declared : STOP_GATE_BUDGET_MS;
+}
+
 /**
  * why: a test that proves the wait has to wait, and a suite that pays ten seconds for it pays that on every gate
  * run in every environment. This is the only seam and it is read here, so the production default is a constant
@@ -192,19 +202,7 @@ async function creditPendingLessons(args: {
  * ([/decisions/ad-116.md](/decisions/ad-116.md)) can ask the identical question `stop` asks — same lock, same
  * content-hash cache, same observability. A second implementation is the drift AD-071 already named once.
  */
-export async function runLockedGate(args: {
-  root: string;
-  shaRoot: string;
-  provider: string;
-  session: string;
-  gate: "lint" | "test" | "docs";
-  command: string[];
-  argvFiles: string[];
-  recordFiles: string[];
-  sessionKey: string;
-  policy: Policy;
-  pendingCredit: PendingLessonCredit | undefined;
-}): Promise<GateRun> {
+export async function runLockedGate(args: LockedGateArgs): Promise<GateRun> {
   const command = [...args.command, ...args.argvFiles];
   // why: `args.recordFiles`/`args.argvFiles` are the turn's changed files, resolved against `shaRoot` — the
   // same split AD-129 already applied to diffing. Hashing or running against `args.root` instead reads a
@@ -218,39 +216,30 @@ export async function runLockedGate(args: {
   );
 
   let artifact: LastGateArtifact;
+  let reused = cached !== null;
+  const tree = cached === null ? await workingTreeId(args.shaRoot) : null;
+  const recorded = recordedVerdictFor(args, tree);
   if (cached !== null) {
     artifact = cached;
+  } else if (recorded !== null) {
+    reused = true;
+    artifact = writeArtifact(args, command, inputs, {
+      exitCode: recorded.exitCode,
+      durationMs: recorded.durationMs,
+      output: recorded.outputTail,
+    });
   } else {
+    const slow = overBudget(args);
+    if (slow !== null) {
+      return slow;
+    }
+    let ran: LastGateArtifact | { timedOutAfterMs: number };
     try {
-      artifact = await coreFacade.gate.withGateLock(
+      ran = await coreFacade.gate.withGateLock(
         args.root,
         args.provider,
         args.session,
-        async () => {
-          const treeBefore = await workingTreeId(args.shaRoot);
-          const result = await runCommand(args.shaRoot, args.command, args.argvFiles);
-          if (treeBefore !== null && (await workingTreeId(args.shaRoot)) === treeBefore) {
-            await coreFacade.gate.recordShipVerdict(args.root, {
-              gate: args.gate,
-              command: args.command,
-              tree: treeBefore,
-              exitCode: result.exitCode,
-              durationMs: result.durationMs,
-              output: result.output,
-            });
-          }
-          return coreFacade.gate.writeLastGate({
-            root: args.root,
-            sessionKey: args.sessionKey,
-            gate: args.gate,
-            exitCode: result.exitCode,
-            command,
-            files: args.recordFiles,
-            durationMs: result.durationMs,
-            output: result.output,
-            ...(inputs.complete ? { inputsHash: inputs.hash } : {}),
-          });
-        },
+        () => runAndRecord(args, command, inputs, tree),
         { waitMs: stopLockWaitMs() },
       );
     } catch (error) {
@@ -263,10 +252,14 @@ export async function runLockedGate(args: {
       recordGateDeferred({ ...args, holder });
       return { kind: "deferred", holder };
     }
+    if ("timedOutAfterMs" in ran) {
+      return { kind: "slow", estimateMs: ran.timedOutAfterMs, budgetMs: ran.timedOutAfterMs };
+    }
+    artifact = ran;
   }
 
   // invariant: recorded outside the lock. A measurement must not widen the window in which one gate blocks another.
-  recordGateOutcome({ ...args, artifact, reused: cached !== null });
+  recordGateOutcome({ ...args, artifact, reused });
   await observeGateForRules({ ...args, gate: args.gate, passed: artifact.passed });
   await creditPendingLessons({
     root: args.root,
@@ -276,7 +269,97 @@ export async function runLockedGate(args: {
     sessionKey: args.sessionKey,
     passed: artifact.passed,
   });
-  return { kind: "ran", artifact, reused: cached !== null };
+  return { kind: "ran", artifact, reused };
+}
+
+type LockedGateArgs = {
+  root: string;
+  shaRoot: string;
+  provider: string;
+  session: string;
+  gate: "lint" | "test" | "docs";
+  command: string[];
+  argvFiles: string[];
+  recordFiles: string[];
+  sessionKey: string;
+  policy: Policy;
+  pendingCredit: PendingLessonCredit | undefined;
+  deadline?: number;
+};
+
+type GateInputs = ReturnType<typeof coreFacade.gate.computeInputsHash>;
+
+function recordedVerdictFor(args: LockedGateArgs, tree: string | null) {
+  if (tree === null) {
+    return null;
+  }
+  return coreFacade.gate.findShipVerdict(args.root, args.gate, args.command, tree, [
+    args.sessionKey,
+    coreFacade.gate.VERIFY_SOURCE,
+  ]);
+}
+
+function writeArtifact(
+  args: LockedGateArgs,
+  command: string[],
+  inputs: GateInputs,
+  result: { exitCode: number; durationMs: number; output: string },
+): LastGateArtifact {
+  return coreFacade.gate.writeLastGate({
+    root: args.root,
+    sessionKey: args.sessionKey,
+    gate: args.gate,
+    exitCode: result.exitCode,
+    command,
+    files: args.recordFiles,
+    durationMs: result.durationMs,
+    output: result.output,
+    ...(inputs.complete ? { inputsHash: inputs.hash } : {}),
+  });
+}
+
+function overBudget(args: LockedGateArgs): GateRun | null {
+  if (args.deadline === undefined) {
+    return null;
+  }
+  const last = coreFacade.gate.lastShipVerdictFor(args.root, args.gate, args.command);
+  const needed = last?.timedOut === true ? last.durationMs * TIMED_OUT_HEADROOM : last?.durationMs;
+  const budgetMs = args.deadline - Date.now();
+  if (budgetMs > 0 && (needed === undefined || needed < budgetMs)) {
+    return null;
+  }
+  return { kind: "slow", estimateMs: last?.durationMs ?? 0, budgetMs: Math.max(0, budgetMs) };
+}
+
+async function runAndRecord(
+  args: LockedGateArgs,
+  command: string[],
+  inputs: GateInputs,
+  tree: string | null,
+): Promise<LastGateArtifact | { timedOutAfterMs: number }> {
+  const timeoutMs = args.deadline !== undefined ? Math.max(1, args.deadline - Date.now()) : undefined;
+  const result = await runCommand(
+    args.shaRoot,
+    args.command,
+    args.argvFiles,
+    timeoutMs !== undefined ? { timeoutMs } : {},
+  );
+  if (tree !== null && (await workingTreeId(args.shaRoot)) === tree) {
+    await coreFacade.gate.recordShipVerdict(args.root, {
+      gate: args.gate,
+      command: args.command,
+      tree,
+      exitCode: result.exitCode,
+      durationMs: result.durationMs,
+      output: result.output,
+      source: args.sessionKey,
+      ...(result.timedOut ? { timedOut: true } : {}),
+    });
+  }
+  if (result.timedOut) {
+    return { timedOutAfterMs: result.durationMs };
+  }
+  return writeArtifact(args, command, inputs, result);
 }
 
 async function failGate(args: {
@@ -514,6 +597,8 @@ export const stopHandler: Handler = async (event: HarnessEvent, ctx: HandlerCont
    * says so once at the end instead of three times ([/decisions/ad-073.md](/decisions/ad-073.md)).
    */
   const deferred: string[] = [];
+  const slow: Array<{ gate: string; estimateMs: number }> = [];
+  const gateDeadline = ctx.now.getTime() + stopGateBudgetMs();
   const rawChangedFiles = await listChangedRepoFiles(shaRoot, turnBase);
   const otherSessionFiles = await coreFacade.presence.filesClaimedByOtherLiveSessions(
     root,
@@ -620,9 +705,12 @@ export const stopHandler: Handler = async (event: HarnessEvent, ctx: HandlerCont
         ? codeTargets
         : [],
       recordFiles: codeTargets,
+      deadline: gateDeadline,
     });
     if (run.kind === "deferred") {
       deferred.push(run.holder);
+    } else if (run.kind === "slow") {
+      slow.push({ gate: "lint", estimateMs: run.estimateMs });
     } else if (!run.artifact.passed) {
       return failGate({
         root,
@@ -658,9 +746,12 @@ export const stopHandler: Handler = async (event: HarnessEvent, ctx: HandlerCont
           ? testTargets
           : [],
         recordFiles,
+        deadline: gateDeadline,
       });
       if (run.kind === "deferred") {
         deferred.push(run.holder);
+      } else if (run.kind === "slow") {
+        slow.push({ gate: "test", estimateMs: run.estimateMs });
       } else if (!run.artifact.passed) {
         return failGate({
           root,
@@ -817,9 +908,12 @@ export const stopHandler: Handler = async (event: HarnessEvent, ctx: HandlerCont
       command: policy.docs.command,
       argvFiles: [],
       recordFiles: changedFiles,
+      deadline: gateDeadline,
     });
     if (run.kind === "deferred") {
       deferred.push(run.holder);
+    } else if (run.kind === "slow") {
+      slow.push({ gate: "docs", estimateMs: run.estimateMs });
     } else if (!run.artifact.passed) {
       if (policy.docs.severity === "deny") {
         return failGate({
@@ -992,6 +1086,24 @@ export const stopHandler: Handler = async (event: HarnessEvent, ctx: HandlerCont
    * `{"decision":"block"}`, so telling the turn would mean blocking it — the defect being fixed. `gate.outcome` is
    * a `why` kind, so `tlc harness why` answers it after the fact.
    */
+  if (slow.length > 0) {
+    const names = slow.map(({ gate }) => gate).join(" + ");
+    const longest = Math.max(...slow.map(({ estimateMs }) => estimateMs));
+    await coreFacade.handoff.patchHandoff(root, provider, sessionKey, {
+      slice: {
+        last_gate_result: "skipped",
+        next_action: "Run `tlc harness verify` and let it finish before ending the turn.",
+      },
+    });
+    return {
+      kind: "continue",
+      text: [
+        `BLOCKED: the ${names} gate needs longer than a stop hook may run, so this turn's changes are not verified yet.`,
+        `TRIED: ${longest > 0 ? `the last run took ${Math.round(longest / 1000)}s` : "it did not finish"}; the stop hook gives its gates ${Math.round(stopGateBudgetMs() / 1000)}s.`,
+        "NEED: run `tlc harness verify` in the shell and let it finish — give it a timeout long enough for the whole suite, or run it in the background and wait — then end the turn. Its verdict is reused here and at push.",
+      ].join("\n"),
+    };
+  }
   const holders = [...new Set(deferred)];
   await coreFacade.handoff.patchHandoff(root, provider, sessionKey, {
     slice: {

package/src/platform/git.ts

@@ -103,9 +103,7 @@ export async function workingTreeId(dir: string): Promise<string | null> {
     } else if ((await git(["read-tree", "--empty"])).exitCode !== 0) {
       return null;
     }
-    if ((await git(["add", "-A"])).exitCode !== 0) {
-      return null;
-    }
+    await git(["add", "-A", "--ignore-errors"]);
     const tree = await git(["write-tree"]);
     const id = tree.stdout.trim();
     return tree.exitCode === 0 && id.length > 0 ? id : null;

package/src/platform/process.ts

@@ -52,16 +52,18 @@ export async function runProcess(args: {
   input?: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
-}): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+}): Promise<{ exitCode: number; stdout: string; stderr: string; timedOut?: boolean }> {
   const [file, ...argv] = args.command;
   if (file === undefined) {
     return { exitCode: 0, stdout: "", stderr: "" };
   }
+  const ownGroup = args.timeoutMs !== undefined && process.platform !== "win32";
   return await new Promise((resolve, reject) => {
     const child = spawn(file, argv, {
       cwd: args.cwd,
       stdio: ["pipe", "pipe", "pipe"] as const,
       env: args.env ?? process.env,
+      detached: ownGroup,
     });
     let stdout = "";
     let stderr = "";
@@ -71,6 +73,12 @@ export async function runProcess(args: {
         ? undefined
         : setTimeout(() => {
             timedOut = true;
+            try {
+              if (ownGroup && child.pid !== undefined) {
+                process.kill(-child.pid, "SIGKILL");
+                return;
+              }
+            } catch {}
             child.kill("SIGKILL");
           }, args.timeoutMs);
 
@@ -87,7 +95,12 @@ export async function runProcess(args: {
     child.on("close", (code) => {
       if (timer) clearTimeout(timer);
       if (timedOut) {
-        resolve({ exitCode: TIMEOUT_EXIT_CODE, stdout, stderr: `${stderr}\n(process timed out)` });
+        resolve({
+          exitCode: TIMEOUT_EXIT_CODE,
+          stdout,
+          stderr: `${stderr}\n(process timed out)`,
+          timedOut: true,
+        });
         return;
       }
       resolve({ exitCode: code ?? 1, stdout, stderr });
@@ -99,7 +112,7 @@ export async function runProcess(args: {
   });
 }
 
-export type CommandResult = { exitCode: number; output: string; durationMs: number };
+export type CommandResult = { exitCode: number; output: string; durationMs: number; timedOut?: boolean };
 
 export const NO_OUTPUT_CAPTURED = "(no output captured)";
 
@@ -114,7 +127,7 @@ export async function runCommand(
   projectDir: string,
   command: string[],
   extraArgs: string[] = [],
-  options: { env?: NodeJS.ProcessEnv } = {},
+  options: { env?: NodeJS.ProcessEnv; timeoutMs?: number } = {},
 ): Promise<CommandResult> {
   if (command.length === 0) {
     return { exitCode: 0, output: "", durationMs: 0 };
@@ -124,6 +137,7 @@ export async function runCommand(
     command: [...command, ...extraArgs],
     cwd: projectDir,
     env: options.env ? { ...process.env, ...options.env } : process.env,
+    ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
   });
   const combined = (result.stdout + result.stderr).trim();
   const output = combined.length === 0 ? NO_OUTPUT_CAPTURED : combined;
@@ -131,5 +145,6 @@ export async function runCommand(
     exitCode: result.exitCode,
     output,
     durationMs: Date.now() - started,
+    ...(result.timedOut ? { timedOut: true } : {}),
   };
 }

package/tools/verify.ts

@@ -15,6 +15,7 @@ export type VerifyOutcome = {
   durationMs: number;
   recorded: boolean;
   treeChanged: boolean;
+  unidentified: boolean;
 };
 
 export function gatesToVerify(policy: ReturnType<typeof coreFacade.policy.loadPolicy>): VerifyGate[] {
@@ -74,8 +75,9 @@ export async function verify(args: {
     log(`▸ ${gate}: ${command.join(" ")}`);
     const result = await runStreaming(command, gitRoot, args.echo ?? true);
     tree = await workingTreeId(gitRoot);
-    const treeChanged = before === null || tree !== before;
-    if (!treeChanged && before !== null) {
+    const unidentified = before === null || tree === null;
+    const treeChanged = !unidentified && tree !== before;
+    if (!unidentified && !treeChanged && before !== null) {
       await coreFacade.gate.recordShipVerdict(args.root, {
         gate,
         command,
@@ -83,6 +85,7 @@ export async function verify(args: {
         exitCode: result.exitCode,
         durationMs: result.durationMs,
         output: result.output,
+        source: coreFacade.gate.VERIFY_SOURCE,
       });
     }
     outcomes.push({
@@ -90,8 +93,9 @@ export async function verify(args: {
       command,
       exitCode: result.exitCode,
       durationMs: result.durationMs,
-      recorded: !treeChanged,
+      recorded: !unidentified && !treeChanged,
       treeChanged,
+      unidentified,
     });
     log(
       `${result.exitCode === 0 ? "✔" : "✖"} ${gate} — exit ${result.exitCode} in ${Math.round(result.durationMs / 1000)}s`,
@@ -126,10 +130,15 @@ export async function main(argv: string[]): Promise<void> {
   });
   const failed = outcomes.find((outcome) => outcome.exitCode !== 0);
   const changed = outcomes.find((outcome) => outcome.treeChanged);
+  const unidentified = outcomes.find((outcome) => outcome.unidentified);
   if (json) {
     emitJson({ tree, outcomes });
   } else if (failed) {
     console.log(`verify: ${failed.gate} failed — fix it and run \`tlc harness verify\` again`);
+  } else if (unidentified) {
+    console.log(
+      "verify: git could not identify the working tree, so no verdict was recorded — run `git status` to see what it cannot read",
+    );
   } else if (changed) {
     console.log(
       `verify: ${changed.gate} changed files while it ran, so its result describes a tree that no longer exists — review the changes and run \`tlc harness verify\` again`,
@@ -137,7 +146,7 @@ export async function main(argv: string[]): Promise<void> {
   } else {
     console.log(`verify: all gates passed for tree ${tree?.slice(0, 12)} — commit, push and PR may proceed`);
   }
-  process.exit(failed || changed ? 1 : 0);
+  process.exit(failed || changed || unidentified ? 1 : 0);
 }
 
 if (import.meta.main) {