mandrel 2.0.0 → 2.2.0

package/.agents/scripts/lib/orchestration/bookkeeping-outbox.js

@@ -1,273 +0,0 @@
-/**
- * bookkeeping-outbox.js — Epic #4476 (M5): buffered GitHub bookkeeping.
- *
- * Delivery bookkeeping — structured-comment upserts (progress, friction,
- * wave-stall, …) and `agent::*` label flips — is human-visible surface that,
- * in an **unattended** (`--yes` / headless) run, no operator is watching in
- * real time. Emitting each one as a live GitHub round-trip mid-run costs an
- * LLM turn per transition for a surface nobody reads until the run finishes.
- *
- * This module lets those non-urgent mutations be **buffered to a local NDJSON
- * outbox** during the run and **reconciled to GitHub once at finalize**.
- * GitHub stays the source of truth *at rest* (post-reconcile); only the
- * per-transition chatter moves off the token stream. The outbox file survives
- * a crash, so crash recovery drains whatever was buffered before the finalize
- * reconcile ran.
- *
- * ## What is NEVER buffered
- * The `agent::blocked` HITL gate (`.agents/instructions.md` §1.J) is the single
- * authoritative runtime pause point. A genuine blocker MUST surface on GitHub
- * **immediately**, not batched to finalize — an operator can only resume a run
- * they can see is blocked. The {@link transitionStateOrBuffer} facade forces
- * `agent::blocked` (and any caller-marked `urgent`) transition through the
- * live path regardless of headless mode.
- *
- * ## Attended runs are unchanged
- * Buffering is gated on the explicit `headless` signal (Story #4427's
- * `--headless`/`--yes` plumbing). An attended run passes `headless: false` and
- * every comment/label posts live exactly as before — byte-for-byte behaviour.
- */
-
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
-import path from 'node:path';
-
-import { runTempDir } from '../config/temp-paths.js';
-import { STATE_LABELS } from './ticketing/reads.js';
-import { upsertStructuredComment } from './ticketing/state.js';
-import { transitionTicketState } from './ticketing/transition.js';
-
-/** Canonical basename for the per-run bookkeeping outbox. */
-const OUTBOX_BASENAME = 'bookkeeping-outbox.ndjson';
-
-/**
- * Resolve the canonical outbox path for a run:
- * `temp/run-<id>/bookkeeping-outbox.ndjson`.
- *
- * Uses `runTempDir` directly; callers may still pass an `epicId`-named
- * variable while the broader file/flag rename remains out of this pass.
- *
- * @param {number} epicId
- * @param {object} [config] Resolved config (tempRoot).
- * @returns {string}
- */
-export function outboxPathFor(epicId, config) {
-  return path.join(runTempDir(epicId, config), OUTBOX_BASENAME);
-}
-
-/**
- * Append one operation record to the outbox, creating the parent dir on
- * demand. Best-effort at the storage layer is the caller's concern; here we
- * let a genuine fs failure propagate so a mis-configured outbox path surfaces
- * loudly in tests.
- *
- * @param {string} outboxPath
- * @param {object} op
- */
-function appendOp(outboxPath, op) {
-  mkdirSync(path.dirname(outboxPath), { recursive: true });
-  appendFileSync(outboxPath, `${JSON.stringify(op)}\n`, 'utf8');
-}
-
-/**
- * Buffer a structured-comment upsert. The op captures everything
- * `upsertStructuredComment` needs at drain time so the reconcile is a pure
- * replay with no re-derivation.
- *
- * @param {{ outboxPath: string, ticketId: number, marker: string,
- *           body: string, attrs?: Record<string, string|number>|null,
- *           ts?: string }} args
- */
-export function enqueueComment({
-  outboxPath,
-  ticketId,
-  marker,
-  body,
-  attrs = null,
-  ts = new Date().toISOString(),
-}) {
-  appendOp(outboxPath, {
-    kind: 'comment',
-    ts,
-    ticketId,
-    marker,
-    body,
-    ...(attrs ? { attrs } : {}),
-  });
-}
-
-/**
- * Buffer an `agent::*` label transition.
- *
- * @param {{ outboxPath: string, ticketId: number, state: string,
- *           ts?: string }} args
- */
-export function enqueueLabel({
-  outboxPath,
-  ticketId,
-  state,
-  ts = new Date().toISOString(),
-}) {
-  appendOp(outboxPath, { kind: 'label', ts, ticketId, state });
-}
-
-/**
- * Parse the outbox into an ordered array of operation records. Malformed
- * lines are skipped (never throw). A missing / empty outbox yields `[]`.
- *
- * @param {string} outboxPath
- * @returns {Array<object>}
- */
-export function readOutbox(outboxPath) {
-  if (!outboxPath || !existsSync(outboxPath)) return [];
-  let raw;
-  try {
-    raw = readFileSync(outboxPath, 'utf8');
-  } catch {
-    return [];
-  }
-  if (!raw) return [];
-  const ops = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line) continue;
-    try {
-      const op = JSON.parse(line);
-      if (op && typeof op === 'object') ops.push(op);
-    } catch {
-      // skip a torn / malformed line — a partial write from a crash is not
-      // fatal to the rest of the batch.
-    }
-  }
-  return ops;
-}
-
-/**
- * Drain the outbox to GitHub in FIFO order and clear it on success. Both sink
- * operations are idempotent (comment upserts are marker-scoped;
- * `transitionTicketState` applies one state via the canonical
- * remove-all-then-add path), so a re-run after a partial drain converges. A
- * per-op failure is recorded and the drain continues — a single bad ticket
- * must not strand the rest of the batch. The outbox file is only truncated
- * when EVERY op succeeded, so a crash mid-drain leaves the un-applied
- * remainder for the next reconcile.
- *
- * @param {{ outboxPath: string,
- *           provider: import('../ITicketingProvider.js').ITicketingProvider,
- *           logger?: { warn?: (m: string) => void } }} args
- * @returns {Promise<{ drained: number, comments: number, labels: number,
- *   errors: Array<{ op: object, error: string }>, cleared: boolean }>}
- */
-export async function reconcileOutbox({ outboxPath, provider, logger }) {
-  const ops = readOutbox(outboxPath);
-  const result = {
-    drained: 0,
-    comments: 0,
-    labels: 0,
-    errors: [],
-    cleared: false,
-  };
-  if (ops.length === 0) {
-    result.cleared = true;
-    return result;
-  }
-
-  for (const op of ops) {
-    try {
-      if (op.kind === 'comment') {
-        await upsertStructuredComment(
-          provider,
-          op.ticketId,
-          op.marker,
-          op.body,
-          op.attrs ?? null,
-        );
-        result.comments += 1;
-        result.drained += 1;
-      } else if (op.kind === 'label') {
-        await transitionTicketState(provider, op.ticketId, op.state);
-        result.labels += 1;
-        result.drained += 1;
-      } else {
-        result.errors.push({ op, error: `unknown op kind "${op.kind}"` });
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      result.errors.push({ op, error: message });
-      logger?.warn?.(
-        `[bookkeeping-outbox] reconcile op failed (${op.kind} #${op.ticketId}): ${message}`,
-      );
-    }
-  }
-
-  // Only truncate when the whole batch landed — otherwise the un-applied
-  // ops must survive for the next reconcile (crash-recovery contract).
-  if (result.errors.length === 0) {
-    try {
-      writeFileSync(outboxPath, '', 'utf8');
-      result.cleared = true;
-    } catch {
-      // A clear failure is non-fatal: the ops all landed, and the idempotent
-      // sinks make a redundant re-drain a no-op.
-    }
-  }
-  return result;
-}
-
-/**
- * Facade: post a structured comment live, OR buffer it to the outbox when the
- * run is headless. Comments are never urgent (the operator reads them at
- * finalize), so headless always buffers when an `outboxPath` is available.
- *
- * @param {{ provider: object, ticketId: number, marker: string, body: string,
- *           attrs?: Record<string, string|number>|null, headless?: boolean,
- *           outboxPath?: string|null }} args
- * @returns {Promise<{ buffered: boolean }>}
- */
-export async function postCommentOrBuffer({
-  provider,
-  ticketId,
-  marker,
-  body,
-  attrs = null,
-  headless = false,
-  outboxPath = null,
-}) {
-  if (headless && outboxPath) {
-    enqueueComment({ outboxPath, ticketId, marker, body, attrs });
-    return { buffered: true };
-  }
-  await upsertStructuredComment(provider, ticketId, marker, body, attrs);
-  return { buffered: false };
-}
-
-/**
- * Facade: flip an `agent::*` state live, OR buffer it when headless — EXCEPT
- * `agent::blocked` (and any caller-marked `urgent` flip), which ALWAYS goes
- * live so the HITL gate surfaces immediately (§1.J).
- *
- * @param {{ provider: object, ticketId: number, state: string,
- *           headless?: boolean, outboxPath?: string|null,
- *           urgent?: boolean }} args
- * @returns {Promise<{ buffered: boolean }>}
- */
-export async function transitionStateOrBuffer({
-  provider,
-  ticketId,
-  state,
-  headless = false,
-  outboxPath = null,
-  urgent = false,
-}) {
-  const mustSurfaceNow = urgent || state === STATE_LABELS.BLOCKED;
-  if (headless && outboxPath && !mustSurfaceNow) {
-    enqueueLabel({ outboxPath, ticketId, state });
-    return { buffered: true };
-  }
-  await transitionTicketState(provider, ticketId, state);
-  return { buffered: false };
-}

package/.agents/scripts/lib/orchestration/error-journal.js

@@ -1,139 +0,0 @@
-/**
- * ErrorJournal — append-only JSONL log of swallowed errors from the
- * orchestration engine's "silent catch" sites.
- *
- * Design notes (see tech spec #382):
- *   - JSONL format: a crashed orchestrator still leaves a valid file up to the
- *     last full line.
- *   - Lazy open: the fd opens on first `record()` call, so runs without any
- *     swallowed errors produce no file.
- *   - Additive: does not replace `logger.warn`. Callers emit both so live
- *     tails stay useful.
- *   - Secret masking: before writing, any string value whose parent key name
- *     or content looks secret-like gets a `::add-mask::<value>` directive
- *     emitted to stdout so any host with mask support redacts accidental
- *     echoes.
- *   - Finalize is idempotent: repeat calls are safe.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-const SECRET_KEY_RE = /token|secret|password|bearer|apikey|api[-_]?key|auth/i;
-const SECRET_VALUE_RE =
-  /\b(gh[pous]_[A-Za-z0-9]{30,}|sk-[A-Za-z0-9]{20,}|xox[bpars]-[A-Za-z0-9-]+|AKIA[0-9A-Z]{16})\b/;
-// Hoisted so the maintainability analyzer (escomplex) doesn't choke on an
-// inline RegExp literal inside .split() — it mis-parses the sequence.
-const NEWLINE_RE = /\r?\n/;
-
-export class ErrorJournal {
-  /**
-   * @param {{ epicId: number, logDir?: string }} opts
-   */
-  constructor({ epicId, logDir = 'temp' } = {}) {
-    if (!Number.isInteger(epicId)) {
-      throw new TypeError('ErrorJournal requires a numeric epicId');
-    }
-    this.epicId = epicId;
-    this.logDir = logDir;
-    this._path = path.join(logDir, `epic-${epicId}-errors.log`);
-    this._fh = null;
-    this._opening = null;
-    this._finalized = false;
-  }
-
-  /** @returns {string} Absolute or relative path to the journal file. */
-  get path() {
-    return this._path;
-  }
-
-  /**
-   * Append one entry to the journal. Emits `::add-mask::` directives for any
-   * secret-looking values before writing.
-   *
-   * @param {{
-   *   module: string,
-   *   op: string,
-   *   error: unknown,
-   *   recovery?: string,
-   * }} entry
-   */
-  async record({ module, op, error, recovery } = {}) {
-    if (this._finalized) return;
-    const payload = {
-      ts: new Date().toISOString(),
-      epicId: this.epicId,
-      module: module ?? null,
-      op: op ?? null,
-      error: serializeError(error),
-      recovery: recovery ?? null,
-    };
-    emitMasksFor(payload);
-    const fh = await this._ensureOpen();
-    await fh.write(`${JSON.stringify(payload)}\n`);
-  }
-
-  /**
-   * Close the underlying file handle. Idempotent: repeat calls are no-ops.
-   * Calls to `record` after finalize silently drop.
-   */
-  async finalize() {
-    if (this._finalized) return;
-    this._finalized = true;
-    const fh = this._fh;
-    this._fh = null;
-    this._opening = null;
-    if (fh) {
-      try {
-        await fh.close();
-      } catch {
-        // idempotent — closing a closed handle is fine
-      }
-    }
-  }
-
-  async _ensureOpen() {
-    if (this._fh) return this._fh;
-    if (!this._opening) {
-      this._opening = (async () => {
-        await fs.mkdir(this.logDir, { recursive: true });
-        this._fh = await fs.open(this._path, 'a');
-        return this._fh;
-      })();
-    }
-    return this._opening;
-  }
-}
-
-function serializeError(err) {
-  if (err == null) return null;
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  if (typeof err === 'string') return { message: err };
-  if (typeof err === 'object') return err;
-  return { message: String(err) };
-}
-
-function emitMasksFor(node, parentKey = null) {
-  if (node == null) return;
-  if (typeof node === 'string') {
-    if (
-      (parentKey && SECRET_KEY_RE.test(parentKey)) ||
-      SECRET_VALUE_RE.test(node)
-    ) {
-      for (const line of node.split(NEWLINE_RE)) {
-        const trimmed = line.trim();
-        if (trimmed) console.log(`::add-mask::${trimmed}`);
-      }
-    }
-    return;
-  }
-  if (Array.isArray(node)) {
-    for (const item of node) emitMasksFor(item, parentKey);
-    return;
-  }
-  if (typeof node === 'object') {
-    for (const [k, v] of Object.entries(node)) emitMasksFor(v, k);
-  }
-}

package/.agents/scripts/lib/orchestration/lifecycle/emit-story-heartbeat.js

@@ -1,155 +0,0 @@
-/**
- * emit-story-heartbeat.js — Story #3057.
- *
- * Programmatic helper that appends a single `story.heartbeat` NDJSON
- * record to the Story lifecycle ledger (`temp/.../lifecycle.ndjson` via
- * `lib/config/temp-paths.js`) during a Story's implementation loop. Story-implementation phases can run for many
- * minutes between dispatch and merge; `story.heartbeat` is the
- * inspectable in-progress signal the host-loop reconciler reads to
- * confirm forward progress.
- *
- * Distinct from:
- *   - `story.dispatch.start` — one per Story per dispatch attempt
- *     (lifecycle-emit-story-dispatch.js).
- *   - `story.merged` — one per Story per close, post-merge.
- *
- * The emit is best-effort: a failure to append (missing schema,
- * unreachable ledger path, validation error) MUST NOT block the phase
- * transition itself. Callers should catch and log via the script's
- * Logger; the heartbeat is observability, not state.
- *
- * Schema contract (story.heartbeat.schema.json):
- *   { event, storyId, epicId, phase, timestamp, operator? }
- *
- * The schema declares `additionalProperties: false`, so this emitter's
- * signature is deliberately narrow: only the schema-allowed fields are
- * accepted. The earlier per-child Task id and progress counters
- * were dropped under Epic #3078's
- * 2-tier hard cutover — they would fail strict validation and have no
- * meaning now that the Story is the leaf execution unit with no child
- * tickets. The optional `operator` field (Story #3480) records the handle
- * holding the assignee-as-lease claim; it is included only when supplied so
- * pre-lease callers continue to emit the unchanged shape.
- */
-
-import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
-
-import { epicLedgerPath } from '../../config/temp-paths.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SCHEMA_PATH = path.resolve(
-  __dirname,
-  '..',
-  '..',
-  '..',
-  '..',
-  'schemas',
-  'lifecycle',
-  'story.heartbeat.schema.json',
-);
-
-const VALID_PHASES = new Set([
-  'init',
-  'implementing',
-  'closing',
-  'blocked',
-  'done',
-]);
-
-let _validator;
-
-function getValidator() {
-  if (_validator) return _validator;
-  const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
-  const ajv = new Ajv2020({ allErrors: true, strict: false });
-  addFormats(ajv);
-  _validator = ajv.compile(schema);
-  return _validator;
-}
-
-/**
- * Append exactly one `story.heartbeat` NDJSON record to the Epic ledger.
- *
- * @param {object} opts
- * @param {number} opts.storyId   Story whose implementation loop is firing.
- * @param {number} opts.epicId    Parent Epic — required for the ledger path.
- * @param {string} [opts.phase='implementing']
- *                                One of init|implementing|closing|blocked|done.
- * @param {string} [opts.timestamp]   ISO-8601 wall clock. Defaults to now().
- * @param {string} [opts.operator]    Optional lease-owner handle (Story #3480).
- *                                    When a non-empty string is supplied it is
- *                                    recorded on the payload so the
- *                                    assignee-as-lease primitive can decide a
- *                                    claim's liveness from the latest heartbeat
- *                                    for a given owner. Omitted when absent so
- *                                    pre-lease callers emit the unchanged shape.
- * @param {object} [opts.config]      Optional resolved config for tempRoot.
- * @param {string} [opts.ledgerPath]  Override for tests.
- * @returns {{ ledgerPath: string, record: object }}
- */
-export function emitStoryHeartbeat(opts) {
-  const {
-    storyId,
-    epicId,
-    phase = 'implementing',
-    timestamp = new Date().toISOString(),
-    operator,
-    config,
-    ledgerPath: ledgerPathOverride,
-  } = opts ?? {};
-
-  if (!Number.isInteger(storyId) || storyId < 1) {
-    throw new Error('emitStoryHeartbeat: storyId must be a positive integer');
-  }
-  if (!Number.isInteger(epicId) || epicId < 1) {
-    throw new Error('emitStoryHeartbeat: epicId must be a positive integer');
-  }
-  if (!VALID_PHASES.has(phase)) {
-    throw new Error(
-      `emitStoryHeartbeat: phase "${phase}" must be one of: ${[...VALID_PHASES].join(', ')}`,
-    );
-  }
-  if (
-    operator !== undefined &&
-    (typeof operator !== 'string' || operator.length === 0)
-  ) {
-    throw new Error(
-      'emitStoryHeartbeat: operator, when supplied, must be a non-empty string',
-    );
-  }
-
-  const payload = {
-    event: 'story.heartbeat',
-    storyId,
-    epicId,
-    phase,
-    timestamp,
-    ...(operator !== undefined ? { operator } : {}),
-  };
-
-  const validator = getValidator();
-  if (!validator(payload)) {
-    const detail = (validator.errors ?? [])
-      .map((e) => `${e.instancePath || '/'} ${e.message}`)
-      .join('; ');
-    throw new Error(
-      `emitStoryHeartbeat: payload failed schema validation: ${detail}`,
-    );
-  }
-
-  const ledgerPath = ledgerPathOverride ?? epicLedgerPath(epicId, config);
-  mkdirSync(path.dirname(ledgerPath), { recursive: true });
-  const record = {
-    kind: 'emitted',
-    ts: timestamp,
-    event: 'story.heartbeat',
-    payload,
-  };
-  appendFileSync(ledgerPath, `${JSON.stringify(record)}\n`, 'utf8');
-  return { ledgerPath, record };
-}

package/.agents/scripts/lib/orchestration/lifecycle/ledger-diff.js

@@ -1,140 +0,0 @@
-/**
- * ledger-diff.js — structural-diff and ordering-assertion helpers over a
- * lifecycle ledger (`temp/epic-<id>/lifecycle.ndjson`) for the
- * repeatability invariants.
- *
- * Relocated from the retired `.agents/scripts/lifecycle-diff.js` CLI
- * (#4482): the assertion helpers are the live surface — they pin the
- * cross-listener ordering contracts in the lifecycle invariant tests —
- * while the CLI wrapper had no workflow, script, or CI consumer.
- *
- * Invariants are derived from Tech Spec #2189 § Repeatability Acceptance
- * Criteria.
- */
-
-/**
- * Parse an NDJSON lifecycle ledger into an array of records. Blank
- * lines tolerated; malformed JSON throws with line number. Duplicated
- * from `trace-logger.js` to keep the diff surface decoupled from the
- * listener surface.
- */
-export function parseLedgerText(text) {
-  const out = [];
-  const lines = String(text || '').split('\n');
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i].trim();
-    if (line.length === 0) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch (_err) {
-      throw new Error(
-        `ledger-diff: malformed JSON in ledger on line ${i + 1}: ${line.slice(0, 80)}`,
-      );
-    }
-  }
-  return out;
-}
-
-/**
- * Project a single record into a comparison key. `ts` and `seqId` are
- * intentionally elided; the rest of the record is included so that the
- * structural shape (event order, payload contents, listener attribution
- * on failed records) is the diff surface.
- *
- * Exported for unit tests that pin the diff contract.
- */
-export function projectRecord(rec) {
-  if (!rec || typeof rec !== 'object') return rec;
-  const { ts: _ts, seqId: _seqId, ...rest } = rec;
-  return rest;
-}
-
-/**
- * Structural diff of two ledger arrays. Returns an array of mismatch
- * descriptors (empty when identical modulo `ts`/`seqId`).
- */
-export function diff(ledgerA, ledgerB) {
-  const a = ledgerA.map(projectRecord);
-  const b = ledgerB.map(projectRecord);
-  const out = [];
-  const max = Math.max(a.length, b.length);
-  for (let i = 0; i < max; i += 1) {
-    const left = a[i];
-    const right = b[i];
-    const leftJson = JSON.stringify(left);
-    const rightJson = JSON.stringify(right);
-    if (leftJson !== rightJson) {
-      out.push({ index: i, left: left ?? null, right: right ?? null });
-    }
-  }
-  return out;
-}
-
-/**
- * Assert: epic.merge.armed must be preceded by epic.merge.ready
- * (same run). Returns `{ ok: true }` or `{ ok: false, reason }`.
- */
-export function assertMergeGateOrdering(records) {
-  let sawReady = false;
-  let sawReadySeq = null;
-  for (const rec of records) {
-    if (rec.kind !== 'emitted') continue;
-    if (rec.event === 'epic.merge.ready') {
-      sawReady = true;
-      sawReadySeq = rec.seqId;
-    } else if (rec.event === 'epic.merge.armed') {
-      if (!sawReady) {
-        return {
-          ok: false,
-          reason: `epic.merge.armed at seqId=${rec.seqId} without preceding epic.merge.ready`,
-        };
-      }
-      if (sawReadySeq != null && rec.seqId <= sawReadySeq) {
-        return {
-          ok: false,
-          reason: `epic.merge.armed seqId=${rec.seqId} must be > epic.merge.ready seqId=${sawReadySeq}`,
-        };
-      }
-    }
-  }
-  return { ok: true };
-}
-
-/**
- * Assert: pr.created must be preceded by either acceptance.reconcile.ok
- * or acceptance.reconcile.waived in the same run. Story #2893 split the
- * waiver path out of `.skipped` so the Finalizer now subscribes to both
- * `.ok` and `.waived`; either is a valid predecessor for pr.created.
- * A reconcile.skipped (empty-spec only after #2893) or reconcile.failed
- * before pr.created remains a violation.
- */
-export function assertReconcileOrdering(records) {
-  let sawReconcileGate = false;
-  let sawReconcileGateSeq = null;
-  let sawReconcileGateEvent = null;
-  for (const rec of records) {
-    if (rec.kind !== 'emitted') continue;
-    if (
-      rec.event === 'acceptance.reconcile.ok' ||
-      rec.event === 'acceptance.reconcile.waived'
-    ) {
-      sawReconcileGate = true;
-      sawReconcileGateSeq = rec.seqId;
-      sawReconcileGateEvent = rec.event;
-    } else if (rec.event === 'pr.created') {
-      if (!sawReconcileGate) {
-        return {
-          ok: false,
-          reason: `pr.created at seqId=${rec.seqId} without preceding acceptance.reconcile.ok or acceptance.reconcile.waived`,
-        };
-      }
-      if (sawReconcileGateSeq != null && rec.seqId <= sawReconcileGateSeq) {
-        return {
-          ok: false,
-          reason: `pr.created seqId=${rec.seqId} must be > ${sawReconcileGateEvent} seqId=${sawReconcileGateSeq}`,
-        };
-      }
-    }
-  }
-  return { ok: true };
-}