@agent-delivery-harness/cli 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+delivery-harness
+Copyright the delivery-harness authors
+
+This product includes software developed by the delivery-harness authors
+(https://github.com/kwam1na/agent-delivery-harness).

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@agent-delivery-harness/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Delivery harness CLI: prepare, review-context, submit-evidence, gate, record, verify, check",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@agent-delivery-harness/kernel": "0.1.0"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "LICENSE",
+    "NOTICE"
+  ]
+}

package/src/boundary.ts

@@ -0,0 +1,326 @@
+/**
+ * The one boundary every CLI command runs behind.
+ *
+ * WHY ONE BOUNDARY. Seven commands, one place that loads config, wires the repo,
+ * classifies exit codes, and renders failures. A command never touches
+ * `process`, never prints a stack, never chooses an exit code of its own: it
+ * returns a typed result and the boundary maps it. That is what keeps the three
+ * exit semantics — policy block, usage error, interruption — identical across
+ * commands, and what keeps every operator-facing byte flowing through the one
+ * neutralizing renderer.
+ *
+ * EXIT CODES.
+ *   0    the command completed and its check passed
+ *   1    a policy block (a typed blocker, a gate that did not admit, a failed
+ *        verification) OR an unexpected internal error (rendered as a redacted
+ *        `internal_error` blocker — never reported as a policy decision, but
+ *        still a non-zero failure)
+ *   2    a usage error (unknown command, missing or malformed arguments)
+ *   130  interruption (SIGINT) — the shell convention 128 + SIGINT(2)
+ *
+ * REPO COHERENCE. Capture and the evidence store must address the same
+ * repository — the recorder's coherence requirement. Both are wired here, from one
+ * `rootDir`, with the store's own `workspaceId` handed to the capture — so a
+ * captured candidate can never disagree with the store about which workspace it
+ * belongs to. Admission still guards `workspace_incoherent`; this makes the
+ * disagreement unconstructible in the first place.
+ */
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  BlockedError,
+  classifyExecutionContext,
+  createArtifactsPort,
+  createBlocker,
+  createCandidateCapture,
+  createInternalErrorBlocker,
+  evaluateCandidateActivation,
+  renderBlockers,
+  resolveRecordStorage,
+  validateHarnessConfig,
+  withDeliverableIdentity,
+  type ArtifactsPort,
+  type Blocker,
+  type CaptureCandidate,
+  type CapturedCandidate,
+  type EnvSnapshot,
+  type ExecutionContext,
+  type HarnessConfig,
+  type LiveProviderResult,
+  type NonEmptyTuple,
+  type ReviewActivationProjection,
+  type WaiverPrompt,
+} from "@agent-delivery-harness/kernel";
+
+// ── Exit codes ───────────────────────────────────────────────────────────────
+
+export const EXIT_OK = 0;
+export const EXIT_POLICY = 1;
+export const EXIT_USAGE = 2;
+export const EXIT_INTERRUPTED = 130;
+
+/**
+ * Thrown when the operator interrupts the process (SIGINT), typically at an
+ * interactive prompt. The boundary maps it to exit 130 — distinct from a policy
+ * block, because an interrupted run reached no verdict.
+ */
+export class CliInterruption extends Error {
+  constructor(message = "Interrupted.") {
+    super(message);
+    this.name = "CliInterruption";
+  }
+}
+
+// ── Command contract ─────────────────────────────────────────────────────────
+
+/**
+ * What a command returns. `ok` is a pass; `blocked` is a policy failure carrying
+ * the typed blockers to render; `usage` is an argument or invocation error.
+ */
+export type CommandResult =
+  | { readonly kind: "ok"; readonly summary?: string }
+  | { readonly kind: "blocked"; readonly blockers: readonly Blocker[] }
+  | { readonly kind: "usage"; readonly message: string };
+
+/** The repository wiring shared by every command in one invocation. */
+export interface RepoWiring {
+  readonly rootDir: string;
+  readonly workspaceId: string;
+  readonly captureCandidate: CaptureCandidate;
+  readonly projectActivation: (candidate: CapturedCandidate) => Promise<ReviewActivationProjection>;
+  /** Storage options threaded to every kernel call so all share one namespace. */
+  readonly storageOptions: { readonly storageNamespace: string };
+}
+
+/** Everything a command may reach, none of it the ambient process. */
+export interface CommandContext {
+  readonly rootDir: string;
+  readonly config: HarnessConfig;
+  readonly env: EnvSnapshot;
+  readonly stdinIsTTY: boolean;
+  readonly stdoutIsTTY: boolean;
+  /** Positional and flag arguments after the command name. */
+  readonly args: readonly string[];
+  /**
+   * Wires capture and the store from this repo, memoized. Lazy so `--help`
+   * wires nothing and so a command owns how it renders a store that will not
+   * resolve. Rejects with a `BlockedError` the boundary maps to exit 1.
+   */
+  wire(): Promise<RepoWiring>;
+  readonly artifacts: ArtifactsPort;
+  /** Present only when the run can ask a human; the boundary gates it on a TTY. */
+  readonly promptForWaiver?: WaiverPrompt;
+  readonly liveResults?: readonly LiveProviderResult[];
+  /** Emits one line of operator-facing output to stdout. */
+  readonly write: (text: string) => void;
+  /** Classifies the execution context from this invocation's env + TTY. */
+  classifyContext(): ExecutionContext;
+}
+
+export interface CommandDescriptor {
+  readonly name: string;
+  /** The blocker `source.id` this command stamps on failures it raises itself. */
+  readonly sourceId: string;
+  readonly summary: string;
+  run(context: CommandContext): Promise<CommandResult>;
+}
+
+// ── Runtime the boundary is driven with ──────────────────────────────────────
+
+export interface CliRuntime {
+  readonly cwd: string;
+  readonly env: EnvSnapshot;
+  readonly stdinIsTTY: boolean;
+  readonly stdoutIsTTY: boolean;
+  readonly stdout: (text: string) => void;
+  readonly stderr: (text: string) => void;
+  /** Loads the consumer config. Defaults to importing `harness.config.ts`. */
+  readonly loadConfig?: (rootDir: string) => Promise<HarnessConfig>;
+  /** The interactive waiver prompt. Only ever offered under a TTY. */
+  readonly promptForWaiver?: WaiverPrompt;
+  /** The filesystem port. Defaults to one rooted in the system temp directory. */
+  readonly artifacts?: ArtifactsPort;
+  readonly liveResults?: readonly LiveProviderResult[];
+}
+
+// ── Blocker helpers ──────────────────────────────────────────────────────────
+
+const COMMAND_SOURCE = { kind: "command", id: "delivery-harness.cli" } as const;
+
+export function commandBlocker(input: {
+  readonly code: string;
+  readonly sourceId: string;
+  readonly summary: string;
+  readonly details?: string;
+  readonly remediations: NonEmptyTuple<Parameters<typeof createBlocker>[0]["remediations"][number]>;
+}): Blocker {
+  return createBlocker({
+    code: input.code,
+    source: { kind: "command", id: input.sourceId },
+    summary: input.summary,
+    ...(input.details === undefined ? {} : { details: input.details }),
+    remediations: input.remediations,
+  });
+}
+
+// ── Config loading ───────────────────────────────────────────────────────────
+
+/**
+ * The default config loader: import `harness.config.ts` from the repo root and
+ * take its default export, which `defineHarnessConfig` has already validated. A
+ * config that fails to load — absent, unparseable, or invalid — becomes one
+ * typed blocker rather than an unhandled throw.
+ */
+export async function importHarnessConfig(rootDir: string): Promise<HarnessConfig> {
+  const configPath = path.join(rootDir, "harness.config.ts");
+  let loaded: unknown;
+  try {
+    const module = (await import(pathToFileURL(configPath).href)) as { default?: unknown };
+    loaded = module.default;
+  } catch (error) {
+    throw new BlockedError([
+      commandBlocker({
+        code: "config_unloadable",
+        sourceId: "delivery-harness.cli.config",
+        summary: "The harness configuration could not be loaded.",
+        details: `${configPath}: ${error instanceof Error ? error.message : String(error)}`,
+        remediations: [
+          {
+            id: "create-harness-config",
+            kind: "manual_action",
+            summary: "Provide a valid harness.config.ts at the repository root.",
+          },
+        ],
+      }),
+    ]);
+  }
+  const validation = validateHarnessConfig(loaded);
+  if (!validation.ok) {
+    throw new BlockedError(validation.blockers);
+  }
+  return validation.config;
+}
+
+// ── Repo wiring (coherence lives here) ───────────────────────────────────────
+
+/**
+ * Wires capture and the evidence store from one `rootDir`. The store's
+ * `workspaceId` is what the capture stamps onto the candidate, so the two can
+ * never disagree — the coherence the admission adapter guards is guaranteed at
+ * the source here.
+ */
+export async function wireRepo(rootDir: string, config: HarnessConfig): Promise<RepoWiring> {
+  const storageOptions = { storageNamespace: config.storageNamespace };
+  const storage = await resolveRecordStorage(rootDir, storageOptions);
+  const captureCandidate = createCandidateCapture({
+    rootDir,
+    config,
+    workspaceId: storage.workspaceId,
+    computeIdentity: withDeliverableIdentity(),
+  });
+  const projectActivation = (candidate: CapturedCandidate): Promise<ReviewActivationProjection> =>
+    evaluateCandidateActivation({ rootDir, candidate, config });
+  return { rootDir, workspaceId: storage.workspaceId, captureCandidate, projectActivation, storageOptions };
+}
+
+// ── The boundary ─────────────────────────────────────────────────────────────
+
+const USAGE = (commands: readonly CommandDescriptor[]): string =>
+  [
+    "Usage: delivery-harness <command> [options]",
+    "",
+    "Commands:",
+    ...commands.map((command) => `  ${command.name.padEnd(16)}${command.summary}`),
+  ].join("\n");
+
+/**
+ * Runs one CLI invocation to an exit code. Total: it maps every command result
+ * and every throw to one of the four codes, and renders every failure through
+ * the neutralizing blocker renderer. Never throws.
+ */
+export async function runCliBoundary(
+  argv: readonly string[],
+  commands: readonly CommandDescriptor[],
+  runtime: CliRuntime,
+): Promise<number> {
+  const [commandName, ...args] = argv;
+
+  if (commandName === undefined || commandName === "--help" || commandName === "-h" || commandName === "help") {
+    runtime.stdout(`${USAGE(commands)}\n`);
+    return commandName === undefined ? EXIT_USAGE : EXIT_OK;
+  }
+
+  const descriptor = commands.find((command) => command.name === commandName);
+  if (descriptor === undefined) {
+    runtime.stderr(`Unknown command: ${commandName}\n\n${USAGE(commands)}\n`);
+    return EXIT_USAGE;
+  }
+
+  const loadConfig = runtime.loadConfig ?? importHarnessConfig;
+  const artifacts = runtime.artifacts ?? createArtifactsPort();
+
+  try {
+    const config = await loadConfig(runtime.cwd);
+
+    let wiringPromise: Promise<RepoWiring> | undefined;
+    const wire = (): Promise<RepoWiring> => {
+      wiringPromise ??= wireRepo(runtime.cwd, config);
+      return wiringPromise;
+    };
+
+    const context: CommandContext = {
+      rootDir: runtime.cwd,
+      config,
+      env: runtime.env,
+      stdinIsTTY: runtime.stdinIsTTY,
+      stdoutIsTTY: runtime.stdoutIsTTY,
+      args,
+      wire,
+      artifacts,
+      // The waiver prompt is offered only under a real TTY. A non-interactive
+      // invocation never prompts — it blocks — no matter what the run wired.
+      ...(runtime.stdinIsTTY && runtime.stdoutIsTTY && runtime.promptForWaiver !== undefined
+        ? { promptForWaiver: runtime.promptForWaiver }
+        : {}),
+      ...(runtime.liveResults === undefined ? {} : { liveResults: runtime.liveResults }),
+      write: (text) => runtime.stdout(`${text}\n`),
+      classifyContext: () =>
+        classifyExecutionContext({
+          config,
+          env: runtime.env,
+          stdinIsTTY: runtime.stdinIsTTY,
+          stdoutIsTTY: runtime.stdoutIsTTY,
+        }),
+    };
+
+    const result = await descriptor.run(context);
+    if (result.kind === "ok") {
+      if (result.summary !== undefined && result.summary !== "") runtime.stdout(`${result.summary}\n`);
+      return EXIT_OK;
+    }
+    if (result.kind === "usage") {
+      runtime.stderr(`${result.message}\n`);
+      return EXIT_USAGE;
+    }
+    runtime.stderr(`${renderBlockers(result.blockers)}\n`);
+    return EXIT_POLICY;
+  } catch (error) {
+    if (error instanceof CliInterruption) {
+      runtime.stderr(`${error.message}\n`);
+      return EXIT_INTERRUPTED;
+    }
+    if (error instanceof BlockedError) {
+      runtime.stderr(`${renderBlockers(error.blockers)}\n`);
+      return EXIT_POLICY;
+    }
+    const blocker = createInternalErrorBlocker({
+      source: { kind: "command", id: descriptor.sourceId },
+      error,
+      reproduce: ["delivery-harness", descriptor.name],
+    });
+    runtime.stderr(`${renderBlockers([blocker])}\n`);
+    return EXIT_POLICY;
+  }
+}
+
+export { COMMAND_SOURCE };

package/src/commands/check.ts

@@ -0,0 +1,45 @@
+/**
+ * `check` — confirm the config loads and the evidence store is usable.
+ *
+ * A preflight the operator runs before anything else. Config validity is proven
+ * by the boundary having loaded it at all; this command additionally resolves the
+ * git-private store *and proves it can be written to*, because a store that
+ * resolves but cannot be written is exactly the failure the operator wants to
+ * learn about here rather than halfway through a submission. The probe is
+ * written through the fs port and removed again, so the check leaves nothing
+ * behind. An unresolvable or unwritable store is a typed block, never a crash.
+ */
+import path from "node:path";
+import { resolveRecordStorage, BlockedError } from "@agent-delivery-harness/kernel";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+/** Named so an interrupted run leaves something obviously disposable. */
+const PROBE_FILE = ".delivery-harness-write-probe";
+
+export const checkCommand: CommandDescriptor = {
+  name: "check",
+  sourceId: "delivery-harness.cli.check",
+  summary: "Confirm the config loads and the evidence store is usable.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    try {
+      const storage = await resolveRecordStorage(context.rootDir, { storageNamespace: context.config.storageNamespace });
+      const probe = path.join(storage.storageDir, PROBE_FILE);
+      await context.artifacts.writeTextFile(probe, "probe\n", { mode: 0o600 });
+      await context.artifacts.removeFile(probe);
+      return {
+        kind: "ok",
+        summary: [
+          `ok: gate ${context.config.gateId}`,
+          `  ${context.config.obligations.length} obligation(s), ${context.config.providers.length} provider(s)`,
+          `  store ${storage.storageDir} (writable)`,
+          `  delivery record path ${context.config.deliveryRecordPath} (base movement: ${context.config.deliveryRecordVerification.baseMovement})`,
+        ].join("\n"),
+      };
+    } catch (error) {
+      if (error instanceof BlockedError) {
+        return { kind: "blocked", blockers: [...error.blockers] };
+      }
+      throw error;
+    }
+  },
+};

package/src/commands/gate.ts

@@ -0,0 +1,46 @@
+/**
+ * `gate` — evaluate the delivery gate and, under a TTY, offer a scoped waiver.
+ *
+ * The command classifies the execution context from this invocation's env and
+ * TTY, then runs the admission adapter. The waiver prompt is the one piece of
+ * interactive I/O the CLI owns: it is handed to admission only when the boundary
+ * saw a real TTY (the boundary already gated `context.promptForWaiver` on that),
+ * so a non-interactive run can never be prompted — it blocks. Admission itself
+ * only ever offers a waiver to a `human` context, all-or-nothing over waivable
+ * findings; the CLI adds no waiver logic of its own.
+ */
+import { runAdmission } from "@agent-delivery-harness/kernel";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+export const gateCommand: CommandDescriptor = {
+  name: "gate",
+  sourceId: "delivery-harness.cli.gate",
+  summary: "Evaluate the delivery gate for the current candidate.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const wiring = await context.wire();
+    const result = await runAdmission(
+      {
+        rootDir: context.rootDir,
+        config: context.config,
+        context: context.classifyContext(),
+        ...(context.liveResults === undefined ? {} : { liveResults: context.liveResults }),
+      },
+      {
+        captureCandidate: wiring.captureCandidate,
+        projectActivation: wiring.projectActivation,
+        ...(context.promptForWaiver === undefined ? {} : { promptForWaiver: context.promptForWaiver }),
+        ...wiring.storageOptions,
+      },
+    );
+
+    if (result.admitted) {
+      const waiverNote =
+        result.waiver === "accepted"
+          ? ` (waived: ${result.waivedObligationIds.join(", ")})`
+          : "";
+      const kinds = (result.decision?.resolutions ?? []).map((resolution) => `${resolution.obligationId}=${resolution.kind}`);
+      return { kind: "ok", summary: `admitted${waiverNote}: ${kinds.join(", ")}` };
+    }
+    return { kind: "blocked", blockers: [...result.blockers] };
+  },
+};

package/src/commands/prepare.ts

@@ -0,0 +1,31 @@
+/**
+ * `prepare` — capture the candidate and publish its preparation receipt.
+ *
+ * The receipt is the ordering mechanism: no receipt, no review context, no
+ * admission. Capturing an unprepared tree (dirty or with untracked files) is a
+ * typed block, not a silent skip.
+ */
+import { publishPreparationReceipt } from "@agent-delivery-harness/kernel";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+export const prepareCommand: CommandDescriptor = {
+  name: "prepare",
+  sourceId: "delivery-harness.cli.prepare",
+  summary: "Capture the candidate and publish its preparation receipt.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const wiring = await context.wire();
+    const capture = await wiring.captureCandidate();
+    if (!capture.ok) {
+      return { kind: "blocked", blockers: [...capture.blockers] };
+    }
+    const published = await publishPreparationReceipt(
+      context.rootDir,
+      { config: context.config, candidate: capture.candidate },
+      wiring.storageOptions,
+    );
+    return {
+      kind: "ok",
+      summary: `prepared ${context.config.gateId}: tree ${capture.candidate.treeSha} (${capture.candidate.mode}); receipt ${published.path}`,
+    };
+  },
+};

package/src/commands/record.ts

@@ -0,0 +1,96 @@
+/**
+ * `record` — promote an admitted gate into the tracked delivery record.
+ *
+ * The record is the one artifact that crosses out of the git-private workspace
+ * into the tracked tree. The command runs the gate, refuses unless it admitted,
+ * and refuses again if the deliverable identity moved between the gate and the
+ * write — a record must describe the candidate it attests, so a re-capture
+ * adjacent to the write is what makes "record after an edit" a refusal rather
+ * than a lie. The record object and its bytes are produced by the kernel
+ * (`delivery-record.ts`, produce-only); the single write goes through the fs
+ * port, and the candidate-keyed path keeps parallel branches from colliding
+ * while staying exactly recomputable by the Action.
+ */
+import {
+  buildDeliveryRecord,
+  deliveryRecordBytes,
+  deliveryRecordPathFor,
+  discoverRecords,
+  runAdmission,
+  type EvidenceRecord,
+} from "@agent-delivery-harness/kernel";
+import path from "node:path";
+import { commandBlocker } from "../boundary.ts";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+export const recordCommand: CommandDescriptor = {
+  name: "record",
+  sourceId: "delivery-harness.cli.record",
+  summary: "Write the tracked delivery record for an admitted gate.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const wiring = await context.wire();
+
+    // The gate is run without a prompt: `record` is not the waiver surface. If a
+    // waiver is needed, the operator runs `gate` first; here a non-admitting gate
+    // is simply a refusal.
+    const admission = await runAdmission(
+      { rootDir: context.rootDir, config: context.config, context: context.classifyContext() },
+      { captureCandidate: wiring.captureCandidate, projectActivation: wiring.projectActivation, ...wiring.storageOptions },
+    );
+    if (!admission.admitted || admission.decision === undefined) {
+      return { kind: "blocked", blockers: [...admission.blockers] };
+    }
+    const decision = admission.decision;
+
+    // Refuse when the gate result no longer describes the current deliverable
+    // identity: a re-capture adjacent to the write.
+    const recheck = await wiring.captureCandidate();
+    if (!recheck.ok) {
+      return { kind: "blocked", blockers: [...recheck.blockers] };
+    }
+    if (recheck.candidate.deliverable.digest !== decision.candidate.deliverable.digest) {
+      return {
+        kind: "blocked",
+        blockers: [
+          commandBlocker({
+            code: "record_identity_changed",
+            sourceId: "delivery-harness.cli.record",
+            summary: "The deliverable identity changed after the gate; nothing was recorded.",
+            details: `gate ${decision.candidate.deliverable.digest} but current ${recheck.candidate.deliverable.digest}`,
+            remediations: [
+              {
+                id: "reprepare-and-record",
+                kind: "command",
+                command: ["delivery-harness", "prepare"],
+                summary: "Re-prepare the candidate and re-run the gate before recording.",
+              },
+            ],
+          }),
+        ],
+      };
+    }
+
+    // Gather the evidence records backing the decision so each evidence claim can
+    // be stamped with its manifest digest.
+    const evidenceRecords: EvidenceRecord[] = [];
+    for (const obligation of context.config.obligations) {
+      const discovery = await discoverRecords(context.rootDir, {
+        gateId: context.config.gateId,
+        obligationId: obligation.id,
+        ...wiring.storageOptions,
+      });
+      evidenceRecords.push(...discovery.records);
+    }
+
+    const built = buildDeliveryRecord({ config: context.config, decision, evidenceRecords });
+    if (!built.ok) {
+      return { kind: "blocked", blockers: [...built.blockers] };
+    }
+
+    const relativePath = deliveryRecordPathFor(context.config, decision.candidate.deliverable.digest);
+    const absolutePath = path.join(context.rootDir, relativePath);
+    await context.artifacts.writeTextFile(absolutePath, deliveryRecordBytes(built.record));
+
+    return { kind: "ok", summary: `recorded ${relativePath}` };
+  },
+};

package/src/commands/review-context.ts

@@ -0,0 +1,66 @@
+/**
+ * `review-context` — the reviewable-change context for a prepared candidate.
+ *
+ * Requires a current receipt. A missing receipt blocks and names `prepare`; a
+ * stale one blocks with its own distinct class. Only once the receipt is current
+ * does the command report what a provider should review and submit evidence for.
+ */
+import { evaluatePreparationReceipt } from "@agent-delivery-harness/kernel";
+import { commandBlocker } from "../boundary.ts";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+export const reviewContextCommand: CommandDescriptor = {
+  name: "review-context",
+  sourceId: "delivery-harness.cli.review-context",
+  summary: "Show the reviewable-change context for the prepared candidate.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const wiring = await context.wire();
+    const capture = await wiring.captureCandidate();
+    if (!capture.ok) {
+      return { kind: "blocked", blockers: [...capture.blockers] };
+    }
+
+    const evaluation = await evaluatePreparationReceipt(
+      context.rootDir,
+      { config: context.config, candidate: capture.candidate },
+      wiring.storageOptions,
+    );
+    if (!evaluation.prepared) {
+      // The kernel's receipt blockers already name the failure class; when the
+      // receipt is absent, point the operator at the command that creates it.
+      const blockers = [...evaluation.blockers];
+      if (evaluation.failure === "missing") {
+        blockers.push(
+          commandBlocker({
+            code: "review_context_requires_receipt",
+            sourceId: "delivery-harness.cli.review-context",
+            summary: "Review context is unavailable until the candidate is prepared.",
+            remediations: [
+              {
+                id: "run-prepare",
+                kind: "command",
+                command: ["delivery-harness", "prepare"],
+                summary: "Publish a preparation receipt for the current candidate.",
+              },
+            ],
+          }),
+        );
+      }
+      return { kind: "blocked", blockers };
+    }
+
+    const projection = await wiring.projectActivation(capture.candidate);
+    const active = projection.relevantLineCount >= context.config.activationThreshold || projection.hasRelevantBinaryChange;
+    return {
+      kind: "ok",
+      summary: [
+        `review context for ${context.config.gateId}:`,
+        `  candidate tree ${capture.candidate.treeSha} (${capture.candidate.mode})`,
+        `  relevant lines ${projection.relevantLineCount} across ${projection.changedEntryCount} changed entr${projection.changedEntryCount === 1 ? "y" : "ies"}`,
+        `  activation ${active ? "active" : "inactive"} (threshold ${context.config.activationThreshold})`,
+        ...(projection.sensitivePathIds.length > 0 ? [`  sensitive: ${projection.sensitivePathIds.join(", ")}`] : []),
+        `  submit evidence with: delivery-harness submit-evidence --manifest <path>`,
+      ].join("\n"),
+    };
+  },
+};

package/src/commands/submit-evidence.ts

@@ -0,0 +1,48 @@
+/**
+ * `submit-evidence` — validate a provider manifest and publish per-claim records.
+ *
+ * A thin caller over the recorder: the SUB rules, the run-root containment and
+ * artifact digest checks, and the record writes all live in the kernel. The
+ * command's only jobs are to find the manifest path in argv and to map the three
+ * submission outcomes onto exit codes. Rejections and blocks both surface their
+ * typed blockers; an acceptance reports the digest and the records it wrote.
+ */
+import { submitManifest } from "@agent-delivery-harness/kernel";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+function manifestPathFrom(args: readonly string[]): string | undefined {
+  const flagIndex = args.indexOf("--manifest");
+  if (flagIndex !== -1) return args[flagIndex + 1];
+  // A lone positional is accepted too, but never a flag mistaken for a path.
+  const positional = args.find((argument) => !argument.startsWith("-"));
+  return positional;
+}
+
+export const submitEvidenceCommand: CommandDescriptor = {
+  name: "submit-evidence",
+  sourceId: "delivery-harness.cli.submit-evidence",
+  summary: "Validate a provider manifest and publish its evidence records.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const manifestPath = manifestPathFrom(context.args);
+    if (manifestPath === undefined || manifestPath === "") {
+      return { kind: "usage", message: "submit-evidence requires --manifest <path>." };
+    }
+
+    const wiring = await context.wire();
+    const outcome = await submitManifest(
+      { rootDir: context.rootDir, manifestPath, config: context.config },
+      { captureCandidate: wiring.captureCandidate, artifacts: context.artifacts, ...wiring.storageOptions },
+    );
+
+    if (outcome.status === "accepted") {
+      const lines = outcome.records.map(
+        (record) => `  ${record.obligationId}: ${record.status} ${record.recordId}`,
+      );
+      return {
+        kind: "ok",
+        summary: [`accepted (manifestDigest ${outcome.manifestDigest}):`, ...lines].join("\n"),
+      };
+    }
+    return { kind: "blocked", blockers: [...outcome.blockers] };
+  },
+};

package/src/commands/verify.ts

@@ -0,0 +1,83 @@
+/**
+ * `verify` — recompute the deliverable identity and check the tracked record.
+ *
+ * The command captures the current candidate, derives the candidate-keyed record
+ * path from the recomputed deliverable identity (the same exact lookup the
+ * Action performs from the PR head), reads and parses the record, and hands it to
+ * the pure `verifyDeliveryRecord` core. A missing record names the command that
+ * writes it; a failed check surfaces the named drift class. When the base-movement
+ * policy is `allow`, a passing check that relaxed base drift names the relaxation.
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { deliveryRecordPathFor, parseDeliveryRecord, verifyDeliveryRecord } from "@agent-delivery-harness/kernel";
+import { commandBlocker } from "../boundary.ts";
+import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+
+export const verifyCommand: CommandDescriptor = {
+  name: "verify",
+  sourceId: "delivery-harness.cli.verify",
+  summary: "Verify the tracked delivery record against the current candidate.",
+  async run(context: CommandContext): Promise<CommandResult> {
+    const wiring = await context.wire();
+    const capture = await wiring.captureCandidate();
+    if (!capture.ok) {
+      return { kind: "blocked", blockers: [...capture.blockers] };
+    }
+    const identity = {
+      deliverableDigest: capture.candidate.deliverable.digest,
+      identityToken: capture.candidate.deliverable.identity,
+    };
+    const base = {
+      ref: capture.candidate.base.ref,
+      tipSha: capture.candidate.base.tipSha,
+      mergeBaseSha: capture.candidate.base.mergeBaseSha,
+    };
+
+    const relativePath = deliveryRecordPathFor(context.config, identity.deliverableDigest);
+    const absolutePath = path.join(context.rootDir, relativePath);
+
+    let text: string;
+    try {
+      text = await readFile(absolutePath, "utf8");
+    } catch {
+      return {
+        kind: "blocked",
+        blockers: [
+          commandBlocker({
+            code: "delivery_record_missing",
+            sourceId: "delivery-harness.cli.verify",
+            summary: "No delivery record describes the current candidate.",
+            details: `expected ${relativePath}`,
+            remediations: [
+              {
+                id: "run-record",
+                kind: "command",
+                command: ["delivery-harness", "record"],
+                summary: "Record the admitted gate for this candidate.",
+              },
+            ],
+          }),
+        ],
+      };
+    }
+
+    const parsed = parseDeliveryRecord(text);
+    if (!parsed.ok) {
+      return { kind: "blocked", blockers: [...parsed.blockers] };
+    }
+
+    const check = verifyDeliveryRecord(context.config, parsed.record, identity, base);
+    if (!check.ok) {
+      return { kind: "blocked", blockers: [...check.blockers] };
+    }
+
+    const relaxation = check.baseMovementRelaxed
+      ? ` (base movement relaxed by policy: ${check.relaxedDriftClasses.join(", ")})`
+      : "";
+    return {
+      kind: "ok",
+      summary: `verified ${relativePath}${relaxation}; attestation: ${check.attestationLabel}`,
+    };
+  },
+};

package/src/index.ts

@@ -0,0 +1,68 @@
+/**
+ * Delivery harness CLI: the seven-command operator surface.
+ *
+ * THE COMMAND REGISTRY. `COMMANDS` is the single source of truth for which
+ * commands exist. Every command module under `commands/` must appear here, and
+ * `scripts/check-cli-inventory.ts` enforces that against the filesystem: a
+ * command file that is not registered is a finding, and an empty registry fails
+ * the sensor outright (a CLI that offers nothing is not a CLI). Registration is
+ * the mechanism; the sensor is only the alarm.
+ *
+ * The boundary, the exit codes, the config loader, and the repo wiring all live
+ * in `boundary.ts`; each command is a thin, testable unit behind it.
+ */
+import { checkCommand } from "./commands/check.ts";
+import { gateCommand } from "./commands/gate.ts";
+import { prepareCommand } from "./commands/prepare.ts";
+import { recordCommand } from "./commands/record.ts";
+import { reviewContextCommand } from "./commands/review-context.ts";
+import { submitEvidenceCommand } from "./commands/submit-evidence.ts";
+import { verifyCommand } from "./commands/verify.ts";
+import { runCliBoundary, type CliRuntime, type CommandDescriptor } from "./boundary.ts";
+
+export const PACKAGE_NAME = "@agent-delivery-harness/cli";
+
+/**
+ * The command registry. The order here is the order `--help` lists them, and it
+ * follows the loop an operator walks: prepare, review, submit, gate, record,
+ * verify — with `check` last as the standalone preflight.
+ */
+export const COMMANDS: readonly CommandDescriptor[] = [
+  prepareCommand,
+  reviewContextCommand,
+  submitEvidenceCommand,
+  gateCommand,
+  recordCommand,
+  verifyCommand,
+  checkCommand,
+];
+
+export {
+  EXIT_INTERRUPTED,
+  EXIT_OK,
+  EXIT_POLICY,
+  EXIT_USAGE,
+  CliInterruption,
+  runCliBoundary,
+  wireRepo,
+  importHarnessConfig,
+  commandBlocker,
+  type CliRuntime,
+  type CommandContext,
+  type CommandDescriptor,
+  type CommandResult,
+  type RepoWiring,
+} from "./boundary.ts";
+
+export { prepareCommand } from "./commands/prepare.ts";
+export { reviewContextCommand } from "./commands/review-context.ts";
+export { submitEvidenceCommand } from "./commands/submit-evidence.ts";
+export { gateCommand } from "./commands/gate.ts";
+export { recordCommand } from "./commands/record.ts";
+export { verifyCommand } from "./commands/verify.ts";
+export { checkCommand } from "./commands/check.ts";
+
+/** Runs the CLI against a runtime and returns the process exit code. */
+export function runCli(argv: readonly string[], runtime: CliRuntime): Promise<number> {
+  return runCliBoundary(argv, COMMANDS, runtime);
+}

package/src/main.ts

@@ -0,0 +1,148 @@
+/**
+ * The executable entry point: builds a {@link CliRuntime} from the ambient
+ * process and runs the CLI.
+ *
+ * This is the one CLI module that reads `process`, `stdin`/`stdout` TTY flags,
+ * and installs a SIGINT handler — all inside functions, never at import time.
+ * The interactive waiver prompt lives here because it is the boundary's I/O: it
+ * prints every obligation one "yes" would cover, reads a single line, and turns
+ * a Ctrl-C into the typed {@link CliInterruption} the boundary maps to exit 130.
+ */
+import { realpathSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { CliInterruption, EXIT_POLICY, runCli, type CliRuntime } from "./index.ts";
+import type { WaiverPrompt } from "@agent-delivery-harness/kernel";
+
+/**
+ * Reads a yes/no answer after naming every obligation the waiver would cover.
+ * A SIGINT during the read rejects with {@link CliInterruption} rather than
+ * tearing the process down, so the boundary can report exit 130.
+ */
+/**
+ * EVERY PATH OUT OF THIS PROMPT SETTLES.
+ *
+ * A readline question has three exits, not one. The callback fires on a
+ * submitted line; `SIGINT` fires on Ctrl-C; and `close` fires on Ctrl-D — stdin
+ * reaching EOF with no line ever submitted. Waiting only on the callback leaves
+ * the EOF path hanging forever: the returned promise never settles, the awaiting
+ * gate never returns, the event loop drains with nothing left to do, and Node
+ * exits 0. A gate that admitted nothing then reports success, which is the worst
+ * failure this program has — a wrongful pass at the merge gate.
+ *
+ * So `close` resolves, and it resolves *false*: the prompt is `[y/N]`, its
+ * default is decline, and a caller who never said yes has not said yes. The
+ * settle guard makes the three exits mutually exclusive, because `close` also
+ * fires immediately after the other two — without it, an interrupted prompt
+ * would reject and then resolve, and a settled promise silently ignoring its
+ * second settlement is exactly how this class of bug hides.
+ */
+export function createWaiverPrompt(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): WaiverPrompt {
+  return (_decision, obligationIds) =>
+    new Promise<boolean>((resolve, reject) => {
+      const rl = createInterface({ input, output });
+      let settled = false;
+      const settle = (action: () => void): void => {
+        if (settled) return;
+        settled = true;
+        action();
+      };
+
+      rl.on("SIGINT", () => {
+        settle(() => {
+          rl.close();
+          reject(new CliInterruption("Waiver prompt interrupted."));
+        });
+      });
+      // Ctrl-D, a closed pipe, or any other end of input.
+      rl.on("close", () => {
+        settle(() => resolve(false));
+      });
+
+      output.write(`Waiving covers ${obligationIds.length} obligation(s): ${obligationIds.join(", ")}.\n`);
+      rl.question("Waive all of them? [y/N] ", (answer) => {
+        settle(() => {
+          rl.close();
+          resolve(/^\s*y(es)?\s*$/i.test(answer));
+        });
+      });
+    });
+}
+
+export const readlineWaiverPrompt: WaiverPrompt = (decision, obligationIds) =>
+  createWaiverPrompt(process.stdin, process.stderr)(decision, obligationIds);
+
+/** The spelling the filesystem can vouch for: the realpath where it can answer, the spelling itself where it cannot. */
+function canonicalEntryPath(entryPath: string): string {
+  try {
+    return realpathSync(entryPath);
+  } catch {
+    return entryPath;
+  }
+}
+
+/**
+ * Whether this module is the entry the process was started with.
+ *
+ * argv and `import.meta.url` may spell the same file differently: argv is the
+ * caller's spelling, and Node builds the module URL from the realpath by
+ * default but from the caller's spelling under `--preserve-symlinks-main`. So
+ * each side is canonicalized independently and the canonical forms compared:
+ * a symlinked spelling matches its realpath whenever the link can be read
+ * (`/tmp` → `/private/tmp` on macOS, a wrapper script's stored path, a pnpm
+ * workspace link), and equal spellings still match when neither side resolves.
+ *
+ * What is NOT claimed: a symlink the filesystem cannot resolve cannot be seen
+ * through, and the failing-exit-code floor below sits inside this guard, so an
+ * under-match exits 0 in silence — the CLI reporting success having verified
+ * nothing. The floor cannot be hoisted above the guard: that would stamp a
+ * failing exit code on every process that merely *imports* this module. And a
+ * non-`file:` module href (a bundled or single-executable build) never
+ * matches — such a build must invoke `main` explicitly.
+ */
+export function invokedDirectly(argvEntry: string | undefined, moduleHref: string): boolean {
+  if (argvEntry === undefined) return false;
+  let modulePath: string;
+  try {
+    modulePath = fileURLToPath(moduleHref);
+  } catch {
+    return false;
+  }
+  return canonicalEntryPath(argvEntry) === canonicalEntryPath(modulePath);
+}
+
+export function defaultRuntime(): CliRuntime {
+  return {
+    cwd: process.cwd(),
+    env: process.env,
+    stdinIsTTY: process.stdin.isTTY === true,
+    stdoutIsTTY: process.stdout.isTTY === true,
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+    promptForWaiver: readlineWaiverPrompt,
+  };
+}
+
+export async function main(argv: readonly string[]): Promise<number> {
+  return runCli(argv, defaultRuntime());
+}
+
+if (invokedDirectly(process.argv[1], import.meta.url)) {
+  // FAIL CLOSED BEFORE ANYTHING RUNS.
+  //
+  // The exit code starts at a failure and is overwritten only by a real verdict.
+  // Node's default is 0, so *any* way of leaving without settling — a promise
+  // that never resolves, an event loop that drains early, a path nobody has
+  // thought of yet — reports success from a gate that decided nothing. Setting
+  // it first inverts that default: the only way to exit 0 is for the boundary to
+  // have returned 0.
+  process.exitCode = EXIT_POLICY;
+  main(process.argv.slice(2))
+    .then((code) => {
+      process.exitCode = code;
+    })
+    .catch((error: unknown) => {
+      process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+      process.exitCode = EXIT_POLICY;
+    });
+}