@agent-delivery-harness/cli 0.2.0 → 0.7.3

package/src/commands/save-context.ts

@@ -0,0 +1,51 @@
+import { buildRunEvent } from "../run-surface.ts";
+import { installedRelease, ordinaryEventWriter, policyDigest, recoveryBlocker, recoveryRun, rejectionDetails } from "../ordinary-context.ts";
+import type { CommandDescriptor } from "../boundary.ts";
+
+const USAGE = "Usage: delivery-harness save-context --json '{\"contract\":{\"objective\":\"...\",\"acceptanceCriteria\":[\"...\"],\"finishLine\":\"merge-ready\"},\"stage\":\"work\"}'";
+
+export const saveContextCommand: CommandDescriptor = {
+  name: "save-context", sourceId: "delivery-harness.cli.save-context",
+  summary: "Save a bounded delivery contract and stage observation in the current run.",
+  usage: USAGE,
+  async run(context) {
+    if (context.args.length !== 2 || context.args[0] !== "--json") return { kind: "usage", message: USAGE };
+    let input: { contract?: unknown; stage?: unknown };
+    try {
+      const value: unknown = JSON.parse(context.args[1]!);
+      if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some(key => key !== "contract" && key !== "stage")) throw new Error();
+      input = value;
+    } catch { return { kind: "usage", message: "Context must be a JSON object with only contract and stage." }; }
+    const run = await recoveryRun(context.rootDir);
+    if (!run.ok) return { kind: "blocked", blockers: [run.blocker] };
+    const wiring = await context.wire();
+    const capture = await wiring.captureCandidate();
+    if (!capture.ok) return { kind: "blocked", blockers: capture.blockers };
+    let release;
+    try { release = await installedRelease(context.rootDir); }
+    catch { return { kind: "blocked", blockers: [recoveryBlocker("resume_release_unreadable", "The installed workflow release identity cannot be read; restore a valid installation before saving context.")] }; }
+    const candidate = capture.candidate;
+    // An omitted member is absent, never present-and-undefined: the contract
+    // reports it as a missing member, and the v2 retry key stays derivable.
+    const payload = { spec: "ordinary-run-context/1",
+      ...(input.contract === undefined ? {} : { contract: input.contract }),
+      ...(input.stage === undefined ? {} : { stage: input.stage }),
+      candidateTreeSha: candidate.treeSha,
+      candidateBinding: { deliverableDigest: candidate.deliverable.digest, identity: candidate.deliverable.identity,
+        baseRef: candidate.base.ref, baseTipSha: candidate.base.tipSha, mergeBaseSha: candidate.base.mergeBaseSha, workspaceId: candidate.workspaceId },
+      policyDigest: policyDigest(context), release };
+    // The run's own writer version, never this command's: a v2 journal admits
+    // no v1 event, and a v2 event needs the retry key the writer derives.
+    const writer = ordinaryEventWriter(run.version, "context.saved", payload);
+    const appended = await run.surface.store.append(
+      run.runId,
+      buildRunEvent({ runId: run.runId, commonDir: run.surface.commonDir, kind: "context.saved", role: "executor", payload, ...writer }),
+      // An exact retry of one save is one observation, at its first instant.
+      { reuseExistingTimestamp: true },
+    );
+    if (!appended.ok) return { kind: "blocked", blockers: [recoveryBlocker("resume_context_invalid",
+      "Context was refused by the bounded run-event contract; inspect contract, stage, and secret-free inputs.",
+      `run ${run.runId}: ${rejectionDetails(appended.rejections)}`)] };
+    return { kind: "ok", summary: `saved ordinary context for ${run.runId}; stage is an observation, not evidence` };
+  },
+};

package/src/commands/submit-evidence.ts

@@ -9,21 +9,60 @@
  */
 import { submitManifest } from "@agent-delivery-harness/kernel";
 import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+import { oneLine } from "../run-surface.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;
+function manifestPathsFrom(args: readonly string[]): string[] | undefined {
+  const paths: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--manifest") {
+      const value = args[++index];
+      if (value === undefined || value === "") return undefined;
+      paths.push(value);
+    } else if (!token.startsWith("-")) paths.push(token);
+  }
+  return paths;
+}
+
+/**
+ * The one flag this command has, and everything else that looks like a flag.
+ * `--manifest`'s VALUE is skipped rather than scanned, so a path that happens
+ * to begin with a hyphen is still that flag's value and not an unknown flag —
+ * rejecting legitimate arguments generically is the failure mode this guard
+ * has to avoid while it closes the silently-ignored one.
+ */
+function unknownFlagIn(args: readonly string[]): string | undefined {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--manifest") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) return token;
+  }
+  return undefined;
 }
 
 export const submitEvidenceCommand: CommandDescriptor = {
   name: "submit-evidence",
   sourceId: "delivery-harness.cli.submit-evidence",
   summary: "Validate a provider manifest and publish its evidence records.",
+  usage: "Usage: delivery-harness submit-evidence --manifest <path>",
   async run(context: CommandContext): Promise<CommandResult> {
-    const manifestPath = manifestPathFrom(context.args);
+    // An unrecognized flag is refused before the manifest is looked for, so a
+    // mistyped flag can never be ignored into a positional read of the argv.
+    const unknown = unknownFlagIn(context.args);
+    if (unknown !== undefined) {
+      return { kind: "usage", message: `Unknown flag ${oneLine(unknown, 64)}.\n${submitEvidenceCommand.usage}` };
+    }
+    const paths = manifestPathsFrom(context.args);
+    if (paths === undefined) {
+      return { kind: "usage", message: "submit-evidence requires --manifest <path>." };
+    }
+    if (paths.length > 1) {
+      return { kind: "usage", message: `submit-evidence requires one manifest path; received ${paths.map(value => oneLine(value, 256)).join(", ")}.` };
+    }
+    const manifestPath = paths[0];
     if (manifestPath === undefined || manifestPath === "") {
       return { kind: "usage", message: "submit-evidence requires --manifest <path>." };
     }

package/src/commands/verify.ts

@@ -37,12 +37,15 @@ import {
   parseDeliveryRecord,
   runGitCommand,
   verifyDeliveryRecord,
+  capturePortableVerificationInputs,
+  collectLiveProviderResults,
   type CandidateTreeEntry,
   type RunJournalRow,
 } from "@agent-delivery-harness/kernel";
 import { commandBlocker } from "../boundary.ts";
 import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
-import { oneLine, resolveRunJournalRow, runJournalRows } from "../run-surface.ts";
+import { RUN_JOURNAL_ADMISSION_ROW, oneLine, resolveRunJournalRow, resolveRunSpan, runJournalRows } from "../run-surface.ts";
+import { durationLabel } from "../run-projection.ts";
 
 const USAGE = "Usage: delivery-harness verify [--require-run-journal] [--mandated-lens <id>]...";
 
@@ -96,11 +99,61 @@ function parseArgs(args: readonly string[]): ArgParse {
 function runJournalBlocker(row: RunJournalRow) {
   const missing = row.missing.length === 0 ? "(none)" : row.missing.join(", ");
   const violations = row.violations === undefined || row.violations.length === 0 ? "(none)" : row.violations.join(", ");
+  // The same per-violation reasons the row prints. A refusal that named only
+  // the identifiers would make the operator run the command again with the
+  // flag dropped just to read why.
+  //
+  // EVERYTHING THE REMEDIATION NAMES COMES FIRST, BECAUSE A DETAIL IS CUT FROM
+  // THE END. A blocker's detail reaches a terminal through `renderBlockers`,
+  // which bounds it at 600 characters, so a journal with several warnings
+  // pushes whatever is last off the end. Two things must never be the
+  // casualty: the line saying none of this blocks admission, because a
+  // truncated list of violated constraints with no such line reads as a
+  // verdict; and the `missing:` list, because the remediation tells the
+  // operator to emit the run events this delivery did not journal and that
+  // list is the only place this refusal says which ones. So the identifiers,
+  // the missing list and the admission sentence all precede the per-warning
+  // reasons, which are the right thing to lose to the cap — the row on stdout,
+  // which is written line by line and is not bounded this way, always carries
+  // all of them. Inside a warning's own segment the `(a consequence of …)`
+  // clause goes before the reason for the same arithmetic: the reason is the
+  // long part, so a clause written after it is the first thing the cap
+  // destroys. With the clause after the reason it vanished from the
+  // reproduction shape once the run id reached 36 characters, and `runId` is
+  // accepted up to 128; with it before, it survives at every run id length
+  // through 128, as do the missing list and the admission sentence. Two
+  // warnings that restate one fact, printed as peers with nothing saying so,
+  // are the exact misreading this row exists to prevent.
+  //
+  // Do not read the 120 as making the whole detail fit. It never does on a
+  // journal with more than one warning: the reproduction's two render 733
+  // characters at this bound (753 at 130, 813 at 160, and 1045 at 400 and at
+  // every larger bound — the longer of its two reasons is 315 characters, so
+  // nothing above that is binding) against a 600-character cut, and the later
+  // warnings' reasons are lost at every one of them — that is what the
+  // unbounded stdout row is for.
+  //
+  // What 120 buys is narrower than it looks, and the narrowness is the point,
+  // because two earlier rounds of this delivery each shipped a confident and
+  // wrong statement about this budget. Measured on the reproduction's two
+  // warnings at the run id this store actually mints (`run-` + 16 hex = 20
+  // characters), the second warning's identifier begins inside the cut — as
+  // `round-not-bou…`, 13 of its 25 characters — and at 121 and above it does
+  // not. That is the whole of it. The margin is one character: at a 21-
+  // character run id, which `isLegalRunId` admits up to 128, it is already
+  // gone, and a journal carrying a third warning loses the later segments
+  // whatever the bound is. What a larger bound costs is a later warning's own
+  // SEGMENT, never its name: the `violations:` list and any `(a consequence
+  // of …)` clause naming it are ahead of the cut and survive regardless.
+  const why = (row.explanations ?? []).map(
+    (explanation) =>
+      `; ${oneLine(explanation.violation, 64)}${explanation.consequenceOf === undefined ? "" : ` (a consequence of ${oneLine(explanation.consequenceOf, 64)})`}: ${oneLine(explanation.because, 120)}`,
+  ).join("");
   return commandBlocker({
     code: "run_journal_incomplete",
     sourceId: "delivery-harness.cli.verify",
     summary: "The run journal for this candidate is not complete, and --require-run-journal was given.",
-    details: `status ${row.status}${row.runId === undefined ? "" : ` (run ${oneLine(row.runId, 128)})`}; missing: ${missing}; violations: ${violations}`,
+    details: `status ${row.status}${row.runId === undefined ? "" : ` (run ${oneLine(row.runId, 128)})`}; violations: ${violations}; missing: ${missing}; ${RUN_JOURNAL_ADMISSION_ROW}${why}`,
     remediations: [
       {
         id: "emit-the-missing-run-events",
@@ -111,11 +164,81 @@ function runJournalBlocker(row: RunJournalRow) {
   });
 }
 
+/**
+ * The record's own span, checked against the journal that binds its candidate.
+ *
+ * WHAT IS CHECKED, AND WHY THOSE TWO THINGS. `startedAt` must EQUAL the
+ * journal's first instant: a journal is append-only, so its first event never
+ * moves and a record that disagrees about when the delivery began is describing
+ * some other run. `endedAt` must lie inside the journal's span, because the
+ * journal keeps growing after the record is written — `verify`, `pr.opened` and
+ * `run.ended` all land later — so equality there would fail on every honest
+ * record, while an `endedAt` after the journal's last instant or before its
+ * first could not have been read off it at all.
+ *
+ * WHY A MISS IS NOT A REFUSAL. A journal is self-attested observability that
+ * anything the owner executes can append to, and this command runs in CI over
+ * checkouts that carry no run store whatever. So the refusal is available only
+ * where a journal BINDS this record's candidate — never on whichever run is
+ * current in the checkout someone verified from, and never as a demand that a
+ * journal exist. Where none binds it the span is reported unchecked, which is
+ * what `verify` could honestly say before this member existed too.
+ */
+async function runSpanRows(
+  rootDir: string,
+  record: { readonly runSpan?: { readonly startedAt: string; readonly endedAt: string }; readonly candidateBinding: { readonly treeSha: string } },
+): Promise<{ readonly rows: readonly string[]; readonly blocker?: ReturnType<typeof commandBlocker> }> {
+  const span = record.runSpan;
+  if (span === undefined) return { rows: [] };
+  const spent = (Date.parse(span.endedAt) - Date.parse(span.startedAt)) / 1000;
+  const recorded = `recorded run span: ${span.startedAt} to ${span.endedAt} (${durationLabel(spent)})`;
+  // `preferStartedAt` is what keeps a SECOND run in the same worktree — the one
+  // this verify is itself running under, say — from refusing a record whose own
+  // run reports exactly this span. A refusal stands only where no journal
+  // binding this candidate starts where the record says it did.
+  const journal = await resolveRunSpan({
+    cwd: rootDir,
+    treeSha: record.candidateBinding.treeSha,
+    preferStartedAt: span.startedAt,
+  });
+  if (journal === undefined) {
+    return { rows: [`${recorded}; unchecked: no run journal in this repository binds this candidate`] };
+  }
+  const disagreement =
+    span.startedAt !== journal.startedAt
+      ? `the record starts at ${span.startedAt} but run ${oneLine(journal.runId, 128)} starts at ${journal.startedAt}`
+      : span.endedAt > journal.endedAt
+        ? `the record ends at ${span.endedAt}, after the last instant run ${oneLine(journal.runId, 128)} reached (${journal.endedAt})`
+        : undefined;
+  if (disagreement === undefined) {
+    return { rows: [`${recorded}; checked against run ${oneLine(journal.runId, 128)}`] };
+  }
+  return {
+    rows: [],
+    blocker: commandBlocker({
+      code: "record_run_span_mismatch",
+      sourceId: "delivery-harness.cli.verify",
+      summary: "The delivery record's run span disagrees with the run journal that binds its candidate.",
+      details: disagreement,
+      remediations: [
+        {
+          id: "re-record-the-span",
+          kind: "command",
+          command: ["delivery-harness", "record"],
+          summary: "Re-record this candidate so its span is the one its own run journal reports.",
+        },
+      ],
+    }),
+  };
+}
+
 export const verifyCommand: CommandDescriptor = {
   name: "verify",
   sourceId: "delivery-harness.cli.verify",
   summary: "Verify the tracked delivery record against the current candidate.",
+  usage: USAGE,
   async run(context: CommandContext): Promise<CommandResult> {
+    const observedAt = `${new Date().toISOString().slice(0, 19)}Z`;
     // Arguments first: a malformed invocation is a usage error and captures
     // nothing, exactly as `emit` and `submit-evidence` order it.
     const parsedArgs = parseArgs(context.args);
@@ -196,19 +319,29 @@ export const verifyCommand: CommandDescriptor = {
       }
     }
 
-    // The row is resolved from the RECORD'S tree sha, not the recomputed
-    // identity: the identity digest excludes the review-neutral paths, and what
-    // a review round and a `pr.opened` bind is the raw tree the record carries.
+    const inputs = await capturePortableVerificationInputs(context.rootDir, context.config, capture.candidate, parsed.record);
+    const live = await collectLiveProviderResults({rootDir:context.rootDir,config:context.config,candidate:capture.candidate,
+      projection:inputs.projection,evidenceContext:inputs.evidenceContext,env:context.env,...(context.signal===undefined?{}:{signal:context.signal})});
+    // Verify the portable record before letting any retained projection widen
+    // the observational tree coordinates. Corrupt or invented projection bytes
+    // therefore fail as record evidence and never influence journal matching.
+    const verified = verifyDeliveryRecord(context.config, parsed.record, identity, base,
+      { candidateTreePaths, ...inputs, observedAt, liveResults:live.liveResults, executionContext: context.classifyContext() });
+    if (!verified.ok) {
+      return { kind: "blocked", blockers: [...live.blockers, ...verified.blockers] };
+    }
+
+    // The record tree remains the primary coordinate. A product-validated
+    // review-neutral projection may additionally name the earlier raw tree the
+    // reviewers actually read; the journal stays observational either way.
     const runJournal = await resolveRunJournalRow({
       cwd: context.rootDir,
       treeSha: parsed.record.candidateBinding.treeSha,
+      reviewedCandidateTreeShas: verified.reviewedCandidateTreeShas,
       ...(parsedArgs.args.mandatedLensIds.length === 0 ? {} : { mandatedLensIds: parsedArgs.args.mandatedLensIds }),
     });
-
-    const check = verifyDeliveryRecord(context.config, parsed.record, identity, base, { candidateTreePaths, runJournal });
-    if (!check.ok) {
-      return { kind: "blocked", blockers: [...check.blockers] };
-    }
+    const check = verifyDeliveryRecord(context.config, parsed.record, identity, base,
+      { candidateTreePaths, runJournal, ...inputs, observedAt, liveResults:live.liveResults, executionContext: context.classifyContext() });
 
     // The opt-in is judged AFTER the record's own verification, so a delivery
     // whose record is bad is never told its journal is the problem.
@@ -216,13 +349,26 @@ export const verifyCommand: CommandDescriptor = {
       return { kind: "blocked", blockers: [runJournalBlocker(runJournal)] };
     }
 
+    // Judged in the same place and for the same reason: a record that fails its
+    // own verification is never told its span is the problem.
+    const span = await runSpanRows(context.rootDir, parsed.record);
+    if (span.blocker !== undefined) return { kind: "blocked", blockers: [span.blocker] };
+
     const relaxation = check.baseMovementRelaxed
       ? ` (base movement relaxed by policy: ${check.relaxedDriftClasses.join(", ")})`
       : "";
+    const exemption = check.hostedChecks.exemption;
+    const hostedCheckRow = exemption === undefined ? [] : [
+      `hosted checks: exempted for ${oneLine(exemption.scope.repositoryId, 128)} at ${oneLine(exemption.scope.baseRef, 256)}; granted by ${oneLine(exemption.grantedBy, 256)}; until ${exemption.until}; reason: ${oneLine(exemption.reason, 512)}`,
+    ];
     return {
       kind: "ok",
       summary: [
         `verified ${relativePath}${relaxation}; attestation: ${check.attestationLabel}`,
+        `recorded base: ${oneLine(parsed.record.candidateBinding.baseRef, 256)} at ${parsed.record.candidateBinding.baseTipSha}`,
+        `observed base: ${oneLine(base.ref, 256)} at ${base.tipSha}`,
+        ...span.rows,
+        ...hostedCheckRow,
         ...runJournalRows(runJournal),
       ].join("\n"),
     };

package/src/declared-checks.ts

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { captureCheckBindings, captureCheckOutputSnapshots, digestCanonical, classifyCandidateDrift, computeCheckWiringFingerprint, createBlocker, createExecPort, sha256Hex, submitManifest, type Blocker, type CandidateBinding, type ProviderRegistration } from "@agent-delivery-harness/kernel";
+import type { CommandContext } from "./boundary.ts";
+
+/** Runs one declared argv check and submits its product-constructed terminal evidence. */
+export async function runDeclaredCheck(context: CommandContext, provider: ProviderRegistration, obligationIds: readonly string[], before: CandidateBinding): Promise<readonly Blocker[]> {
+  const check = provider.check!;
+  const wiring = await context.wire();
+  const fail = (code: string, summary: string, details?: string): readonly Blocker[] => [createBlocker({ code, source: { kind: "command", id: "delivery-harness.cli.gate" }, summary,
+    ...(details === undefined ? {} : { details }), remediations: [{ id: "repair-declared-check", kind: "manual_action", summary: "Fix the declared check or its inputs, prepare the stable candidate and run gate again." }] })];
+  const start = await wiring.captureCandidate();
+  if (!start.ok) return start.blockers;
+  if (classifyCandidateDrift(before, start.candidate).length) return fail("check_candidate_changed", "The candidate changed after review admission and before the check started.");
+  const fingerprint = await computeCheckWiringFingerprint(context.rootDir, context.config, wiring.storageOptions);
+  context.write(`checking ${provider.id}`);
+  const result = await createExecPort().run({ command: check.command[0], args: check.command.slice(1), cwd: context.rootDir,
+    env: Object.fromEntries(Object.entries(context.env).filter((entry): entry is [string, string] => entry[1] !== undefined)),
+    timeoutMs: check.timeoutMs, maxBuffer: 1024 * 1024, ...(context.signal === undefined ? {} : { signal: context.signal }) });
+  if (result.code !== 0 || context.signal?.aborted) return fail("check_command_failed", `Declared check ${provider.id} did not complete successfully.`, `exit ${result.code}${result.errorCode === undefined ? "" : ` (${result.errorCode})`}\n${`${result.stdout}\n${result.stderr}`.slice(-4000)}`);
+  const captured = await wiring.captureCandidate();
+  if (!captured.ok) return captured.blockers;
+  if (classifyCandidateDrift(before, captured.candidate).length || start.candidate.headSha !== captured.candidate.headSha || fingerprint !== await computeCheckWiringFingerprint(context.rootDir, context.config, wiring.storageOptions)) return fail("check_candidate_changed", "The candidate, base or wiring changed while the check ran.");
+  const binding = (await captureCheckBindings(context.rootDir, context.config, captured.candidate, wiring.storageOptions))[provider.id];
+  if (binding === undefined) return fail("check_output_missing", `Declared check ${provider.id} has a missing, unreadable, oversized or escaped output.`);
+  const runId = randomUUID(), finalPassId = "pass-1";
+  const allocation = await context.artifacts.allocateRunRoot({ providerId: provider.id, runId });
+  if (!allocation.ok) return fail("check_artifact_unavailable", "Cannot allocate the declared check evidence root.");
+  const snapshots = await captureCheckOutputSnapshots(context.rootDir, check.outputs ?? []);
+  if (snapshots === undefined || digestCanonical(snapshots.map(({ path, sha256 }) => ({ path, sha256 }))) !== binding.outputsDigest) return fail("check_output_missing", "Declared outputs changed before evidence retention.");
+  const outputArtifacts: { path: string; sha256: string; role: string }[] = [];
+  for (const [index, output] of snapshots.entries()) {
+    const contents = JSON.stringify({ path: output.path, base64: output.base64 });
+    const artifactPath = `check-output-${index}.json`;
+    await context.artifacts.writeTextFile(path.join(allocation.runRoot.path, artifactPath), contents);
+    outputArtifacts.push({ path: artifactPath, sha256: sha256Hex(contents), role: "check-output" });
+  }
+  const payload = { verdict: "green", exitCode: 0, binding };
+  const terminal = JSON.stringify({ providerId: provider.id, runId, finalPassId, ...payload });
+  await context.artifacts.writeTextFile(path.join(allocation.runRoot.path, "check-result.json"), terminal);
+  const candidate = captured.candidate;
+  const manifest = { spec: "delivery-evidence/1", provider: { id: provider.id, runId, finalPassId },
+    candidate: { vcs: "git", treeSha: candidate.treeSha, headSha: candidate.headSha, deliverable: candidate.deliverable, base: candidate.base, workspaceId: candidate.workspaceId },
+    runHistory: [{ preparedTreeSha: candidate.treeSha, evaluatedInPassId: finalPassId }], artifacts: [{ path: "check-result.json", sha256: sha256Hex(terminal), role: "check-result" }, ...outputArtifacts],
+    attestation: { level: "self", signatures: [] }, recordedAt: new Date().toISOString(), claims: obligationIds.map(obligation => ({ obligation, payloadSpec: "checks.passed/1", payload })) };
+  const manifestPath = path.join(allocation.runRoot.path, "manifest.json");
+  await context.artifacts.writeTextFile(manifestPath, JSON.stringify(manifest));
+  const outcome = await submitManifest({ rootDir: context.rootDir, config: context.config, manifestPath }, { captureCandidate: wiring.captureCandidate, artifacts: context.artifacts, ...wiring.storageOptions });
+  return outcome.status === "accepted" ? [] : outcome.blockers;
+}

package/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * Delivery harness CLI: the eleven-command operator surface.
+ * Delivery harness CLI: the fifteen-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
@@ -12,6 +12,7 @@
  * in `boundary.ts`; each command is a thin, testable unit behind it.
  */
 import { checkCommand } from "./commands/check.ts";
+import { admitCommand } from "./commands/admit.ts";
 import { emitCommand } from "./commands/emit.ts";
 import { gateCommand } from "./commands/gate.ts";
 import { maintainCommand } from "./commands/maintain.ts";
@@ -19,12 +20,16 @@ import { managedCommand } from "./commands/managed.ts";
 import { prepareCommand } from "./commands/prepare.ts";
 import { recordCommand } from "./commands/record.ts";
 import { reviewContextCommand } from "./commands/review-context.ts";
+import { emitReviewEvidenceCommand } from "./commands/emit-review-evidence.ts";
 import { runsCommand } from "./commands/runs.ts";
 import { submitEvidenceCommand } from "./commands/submit-evidence.ts";
 import { verifyCommand } from "./commands/verify.ts";
+import { saveContextCommand } from "./commands/save-context.ts";
+import { resumeCommand } from "./commands/resume.ts";
 import { runCliBoundary, type AnyCommandDescriptor, type CliRuntime } from "./boundary.ts";
 
 export const PACKAGE_NAME = "@agent-delivery-harness/cli";
+export { buildRunExport, parseRunExport, type DeliveryRunExport, type RunExportParseResult } from "./run-export.ts";
 
 /**
  * The command registry. The order here is the order `--help` lists them, and it
@@ -38,8 +43,10 @@ export const PACKAGE_NAME = "@agent-delivery-harness/cli";
  * write the run store rather than anything a delivery decision depends on.
  */
 export const COMMANDS: readonly AnyCommandDescriptor[] = [
+  admitCommand,
   prepareCommand,
   reviewContextCommand,
+  emitReviewEvidenceCommand,
   submitEvidenceCommand,
   gateCommand,
   recordCommand,
@@ -49,6 +56,8 @@ export const COMMANDS: readonly AnyCommandDescriptor[] = [
   maintainCommand,
   emitCommand,
   runsCommand,
+  saveContextCommand,
+  resumeCommand,
 ];
 
 export {
@@ -74,7 +83,9 @@ export {
 } from "./boundary.ts";
 
 export { prepareCommand } from "./commands/prepare.ts";
+export { admitCommand } from "./commands/admit.ts";
 export { reviewContextCommand } from "./commands/review-context.ts";
+export { emitReviewEvidenceCommand } from "./commands/emit-review-evidence.ts";
 export { submitEvidenceCommand } from "./commands/submit-evidence.ts";
 export { gateCommand } from "./commands/gate.ts";
 export { recordCommand } from "./commands/record.ts";
@@ -84,8 +95,13 @@ export { managedCommand } from "./commands/managed.ts";
 export { maintainCommand } from "./commands/maintain.ts";
 export { emitCommand } from "./commands/emit.ts";
 export { runsCommand } from "./commands/runs.ts";
+export { saveContextCommand } from "./commands/save-context.ts";
+export { resumeCommand } from "./commands/resume.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);
 }
+
+export { readScopedCheckObservations, type ScopedCheckObservations } from "./scoped-observations.ts";
+export { readScopedCheckDiagnostics, type ScopedCheckDiagnostics, type ScopedAttemptDiagnostic, type RecordedScopedAttemptDiagnostic, type ScopedDiagnosticPhase, type ScopedDiagnosticFailureCode, type ScopedDiagnosticExecutionCode, type ScopedDiagnosticCommand, type ScopedDependencyDiagnostic } from "./scoped-diagnostics.ts";