@telora/daemon 0.22.239 → 0.22.289

package/dist/queries/delivery-gate-state.d.ts

@@ -1,570 +0,0 @@
-/**
- * The shape of `org_nodes.gate_state` on a delivery row, plus the per-origin
- * detail records that hang off it.
- *
- * Split out of `queries/deliveries.ts` (which holds the API calls) because these
- * are the vocabulary of the verify gate, not of any one query: the verification
- * engine, the feedback/re-work path, the operator- and external-hold gates, and
- * the stall detectors all read and write them. Keeping them here lets those
- * modules depend on the gate's vocabulary without pulling in the query layer.
- *
- * The one rule that shapes every type below: each way the gate can hold a
- * delivery gets its OWN key. A shell-command failure (`verification`), a
- * declared-vs-achieved gap (`shortfallReconciliation`), an unvouchable evidence
- * bundle (`evidenceUnavailable`), an operator hold, and an external dependency
- * are distinct facts about distinct things, and a reader must be able to tell
- * "the gate was blind" from "the work fell short" without inspecting fields.
- *
- * Re-exported from `queries/deliveries.ts`, so both import paths resolve.
- *
- * @module queries/delivery-gate-state
- */
-import { type ShortfallPark } from './shortfall-park-record.js';
-import type { MisattributedCommitsRecord } from './misattributed-commits-record.js';
-import type { RecordedTargetsRecord } from './recorded-targets-record.js';
-import type { VerificationParseFailure } from '../verify/verification-failure-parser.js';
-import type { ModelUnavailableDetail } from './verify-own-holds.js';
-export type { ShortfallPark } from './shortfall-park-record.js';
-export type { MisattributedCommitsRecord } from './misattributed-commits-record.js';
-import type { ExternalHoldState, CommitVerdictHoldState, AdvanceHoldDetail } from './delivery-gate-holds.js';
-export type { ExternalHoldState, HeldReviewExit, CommitVerdictHoldState, AdvanceHoldDetail } from './delivery-gate-holds.js';
-/**
- * Detail attached to gate_state when a daemon-side deterministic verification
- * run fails. Carries the failing-test names (parsed from the run output) and a
- * pointer to the persistent full-log file so the feedback loop -- dashboard
- * "Waiting on", live-session inject, and the requeue/respawn prompt -- can
- * surface WHAT failed and WHERE to read it, without a cold re-run.
- */
-export interface VerificationFailureDetail {
-    /**
-     * Failing-test ids that GATE this delivery. When baseline-diff attribution ran,
-     * these are the NEW failures the focus introduced; otherwise all parsed failures.
-     */
-    failingTests: string[];
-    /**
-     * Failing tests that pre-exist on the focus base -- recorded, non-blocking
-     * (they do not gate the focus). Absent when attribution did not run.
-     */
-    preExisting?: string[];
-    /** Absolute path to the persistent full-log file, or null when none was written. */
-    logPath: string | null;
-    /** Process exit code of the failed run, or null. */
-    exitCode: number | null;
-    /** ISO timestamp of the failing run. */
-    failedAt: string;
-    /**
-     * Stable signature of WHAT failed (verify/failure-signature.ts): the failing
-     * stage plus a hash of its normalized failure detail, with volatile detail
-     * (timestamps, durations, line/over-by counts, tmp paths, pids, shas) removed.
-     * Two rejections failing the same way share it; one failing a different gate --
-     * or the same gate on a different defect -- does not. null when no signature
-     * could be derived (empty / unparseable log). Absent on a gate_state written
-     * before signatures existed.
-     */
-    failureSignature?: string | null;
-    /**
-     * Bounded run-length record over consecutive deterministic rejections. The
-     * verify_gate_unclearable detector (verify/verify-gate-stall.ts) reads it to
-     * tell a delivery failing identically from one converging through successive
-     * gates. Absent on a gate_state written before signatures existed.
-     */
-    signatureRun?: VerificationSignatureRun;
-    /**
-     * The commit this rejection judged, when the gate command itself failed there
-     * (a non-zero exit, not a timeout) in a detached checkout of the focus HEAD
-     * (judgedFailedSha). Carried forward as `verificationHistory.failedAtSha`, so
-     * default-on selection (verify/verification-default-on.ts) never re-verifies
-     * that unchanged commit: not across the verify_failed round trip, not across a
-     * daemon restart. A verify pass resets it. Absent for an in-place run, a
-     * timeout, or a gate_state written before it existed.
-     */
-    failedAtSha?: string;
-    /** The gate's verdict for the judged commit, as the re-work and respawn messages show it. */
-    gateVerdict?: GateVerdictSummary;
-    /** The run exited non-zero but its log parsed to zero failing-test ids (verify/verification-failure-parser.ts). */
-    parseFailure?: VerificationParseFailure;
-}
-/**
- * The deterministic gate's recorded verdict for the commit a delivery was judged
- * on (verify/commit-verdict-record.ts), in the form a team is shown it. Each
- * re-work detail persists it so a respawned or woken team reads what the gate
- * proved on that commit instead of replaying the gate by hand. Rendered only by
- * prompt-sections/gate-verdict-section.ts. Not history: it rides with the
- * verdict it describes and is dropped with it.
- */
-export interface GateVerdictSummary {
-    outcome: 'passed' | 'failed';
-    /** The judged commit (full sha). */
-    sha: string;
-    /** The stage charged to the delivery on a failure; absent when the log named none (unattributed). */
-    failedStage?: string;
-    /** Stage reds that fail the same way on the focus base -- recorded, not blocking. */
-    preExistingStages?: string[];
-}
-/**
- * The failure-signature run-length record on a deterministic rejection. Bounded
- * by construction: the current and previous signature plus a count, never a
- * history. gate_state is its SOLE carrier: the rejection stamps it here, and
- * every writer that later clears or replaces the gate carries it forward under
- * `verificationHistory` (carryVerificationHistory) so the NEXT rejection can
- * compare against it.
- */
-export interface VerificationSignatureRun {
-    /** This rejection's failure signature; null when underivable. */
-    signature: string | null;
-    /** The previous deterministic rejection's signature; null when none was known. */
-    previousSignature: string | null;
-    /**
-     * Consecutive rejections carrying `signature` (>= 1). 0 when `signature` is
-     * null -- an unknown signature never counts as a repeat.
-     */
-    consecutive: number;
-}
-/**
- * Detail attached to gate_state when the verify-shortfall RECONCILIATION (not a
- * deterministic shell run) holds the flip: the achieved outcome fell short of
- * the declared desired effect for one or more targeted nodes. Distinct from
- * VerificationFailureDetail on purpose -- a shortfall hold has no exitCode /
- * failingTests (the deterministic check may well have passed), it has a
- * declared-vs-achieved gap. Keeping it under its own key prevents a reader from
- * seeing a passed:false deterministic_verification whose exitCode is 0.
- */
-export interface ShortfallReconciliationDetail {
-    /** ISO timestamp of the reconciliation that held the gate. */
-    heldAt: string;
-    /** The per-target declared/achieved/reason gaps that withheld the flip. */
-    shortfalls: Array<{
-        nodeId: string;
-        declared: string;
-        achieved: string;
-        reason: string;
-        /** The diff evidence grounding the shortfall, when the judge cited one. */
-        diffCitation?: string;
-    }>;
-    /**
-     * Cross-iteration repetition state (verify/shortfall-repeat.ts). Carries a
-     * stable signature of this shortfall set plus how many CONSECUTIVE iterations
-     * it has stood UNCHANGED. Persisted so the next iteration can tell a genuine
-     * (changing) shortfall from an unclearable (identical) one -- the former routes
-     * as ordinary re-work, the latter is diagnosed as a defective CLAIM. Absent on
-     * a shortfall written before this discriminator existed.
-     */
-    repeat?: ShortfallRepeatRecord;
-    /**
-     * True when the repeat count reached the unclearable threshold: the shortfall
-     * reproduced identically enough times that it is a defect in the tree CLAIM,
-     * not team re-work. Set on the terminal hold that escalates the tree node and
-     * STOPS re-queuing; absent/false while the shortfall is still routing as re-work.
-     */
-    unclearableClaim?: boolean;
-    /** The recorded gate verdict for the commit the shortfall's run judged (usually a pass: the gap is not a failing check). */
-    gateVerdict?: GateVerdictSummary;
-    /** Unattributed commits touching the delivery's files; absent when there are none. */
-    misattributed?: MisattributedCommitsRecord;
-}
-/**
- * The cross-iteration shortfall repeat record (verify/shortfall-repeat.ts): a
- * stable signature of the shortfall set plus how many CONSECUTIVE iterations it
- * has stood unchanged -- and, when it could be read, the fingerprint of the
- * delivery-trailered commit set it was judged on (verify/shortfall-park.ts).
- * Absent on a legacy record or an unreadable set.
- */
-export interface ShortfallRepeatRecord {
-    signature: string;
-    count: number;
-    commitSet?: string;
-}
-/**
- * Verification HISTORY carried across a gate_state clear or replacement.
- *
- * The two repetition discriminators -- the failure-signature run
- * (verify_gate_unclearable) and the shortfall repeat (unclearable claim) -- count
- * CONSECUTIVE rejections, so each rejection must see the previous one's record.
- * Between two rejections the delivery walks verify_failed -> queued -> coding ->
- * verify, and a guard-pass advance clears the gate. A clear that dropped the
- * records would restart both counts at 1 every cycle and leave their thresholds
- * unreachable. So a clearing writer drops the VERDICT and keeps this history
- * (carryVerificationHistory); only a verify pass resets it
- * (clearVerificationHistory), and a delivery that reaches done or cancelled
- * stops cycling.
- *
- * History is not a verdict and not a hold. It rides in its own key beside an
- * EMPTY `blocking` array, so no reader of `blocking` takes it for a live block.
- */
-export interface VerificationHistory {
-    /** The latest deterministic rejection's failure-signature run. */
-    signatureRun?: VerificationSignatureRun;
-    /** The latest shortfall rejection's repeat record. */
-    shortfallRepeat?: ShortfallRepeatRecord;
-    /** The commit the latest deterministic rejection's command failed on (VerificationFailureDetail.failedAtSha). */
-    failedAtSha?: string;
-    /**
-     * The commit the latest re-work judged this delivery on. Each re-work writer
-     * (deterministic failure, shortfall, evidence-unavailable, and the review
-     * exit's verify_failed route for review-filed work) REPLACES it
-     * (stampJudgedCommit), so it never names an older commit than the latest
-     * judgment. A resumed team is shown the recorded verdict for THIS sha, never
-     * the worktree HEAD's (verify/gate-verdict-source.ts). A verify pass resets it
-     * with the rest of the history -- unless it names the very commit that pass
-     * judged (verify/verification-history-reset.ts).
-     */
-    judgedCommit?: JudgedCommit;
-    /**
-     * The verdict the delivery's latest EXPLICIT-METHOD run rendered
-     * (verify/explicit-gate-outcome.ts). Such a run may write no per-commit
-     * verdict record (an in-place run judges no commit; an ai_inspection writes
-     * none), and its terminal row leaves daemon_get_pending_verifications, so after
-     * a daemon restart this is the only place its verdict -- and the fact that the
-     * delivery is gated by its own run -- survives. Removed before the next explicit
-     * run starts, so a restart mid-run or a failed write after it reads no verdict,
-     * then set to that run's verdict, or left removed by a run that rendered none
-     * (stampExplicitGateOutcome).
-     * OWNED by those writers: every other gate_state write -- a verify pass's
-     * history reset included -- sends the value the row holds in its serialized
-     * write turn, never one its own earlier read carried
-     * (queries/delivery-write-discipline.ts).
-     */
-    explicitOutcome?: ExplicitGateOutcome;
-    /** The standing shortfall park (queries/shortfall-park-record.ts); only ever carried, dropped by a verify pass. */
-    shortfallPark?: ShortfallPark;
-}
-/** A commit a verify run judged, and when the re-work that carries it was written. */
-export interface JudgedCommit {
-    /** The judged commit (StrategyResult.verifiedSha). */
-    sha: string;
-    /** ISO timestamp of the re-work write; orders judgments across a focus's deliveries. */
-    judgedAt: string;
-    /**
-     * The delivery's OWN gate verdict for exactly this sha, persisted beside it by
-     * the re-work writer: a verification re-work's run verdict
-     * (verify/rework-judgment.ts), or a review-filed route's own-gate read
-     * (completion/review-exit-verdict-gate.ts). The resume shows it first; only a
-     * stamp without one is resolved at resume time, under the delivery's own gate
-     * (spawn/prompt-assembly.ts), never by a gate-less record read. Absent when the
-     * run rendered no verdict or no own-gate source held one.
-     */
-    gateVerdict?: GateVerdictSummary;
-}
-/** The verdict an explicit-method run rendered, and the commit it applies to. */
-export interface ExplicitGateOutcome {
-    outcome: 'passed' | 'failed';
-    /** The commit the run judged (StrategyResult.verifiedSha); null when it judged none, which applies to any commit. */
-    sha: string | null;
-    /**
-     * The gate the run rendered it under (verify/commit-verdict-record.ts
-     * explicitGateKeyOf: its method + the config it applied). It governs the
-     * delivery only while the row names that same gate; a record without one
-     * governs no named gate.
-     */
-    gateKey?: string;
-    /** ISO timestamp the verdict was recorded. */
-    recordedAt: string;
-    /** The run that rendered it: a verdict only while that run is the delivery's current one (verify/explicit-run-ledger.ts). */
-    runId?: string;
-}
-/**
- * Detail attached to gate_state when the verify path could NOT vouch for the
- * evidence it was handed -- an INSTRUMENT FAULT, not a verdict about the work.
- * Two flavours, both BLIND:
- *   - EMPTY   : no diff / changed-files / inspection finding at all.
- *   - INCOMPLETE (half-blind): a non-empty bundle whose resolved diff range does
- *     NOT cover the delivery's recorded commit set, so a verdict would judge the
- *     work against only part of it. `coverage` is populated in this case.
- * Distinct from VerificationFailureDetail (a shell command failed) and from
- * ShortfallReconciliationDetail (the work fell short of intent): here the
- * reconciliation cannot see the whole delivery, so it must not render any
- * verdict. The delivery is held in `verify` (never routed to verify_failed, so
- * no iteration is consumed) and a first-occurrence escalation names the fault.
- */
-export interface EvidenceUnavailableDetail {
-    /** ISO timestamp the instrument-fault hold was recorded. */
-    heldAt: string;
-    /** Unattributed commits (incl. daemon captures of unknown delivery) in the focus's batches; absent when none. */
-    misattributed?: MisattributedCommitsRecord;
-    /** Which evidence slots were empty (named, so the hold describes the fault, not the work). */
-    missing: string[];
-    /**
-     * Commits the delivery branch is ahead of the integration base. 0 => the
-     * branch already merged / did no work; > 0 => a broken diff MEASUREMENT
-     * (commits present but the diff resolved empty). Carried for operator triage.
-     */
-    commitsAhead: number;
-    /**
-     * Populated for a HALF-BLIND (incomplete) hold: the resolved range covered
-     * only `covered` of the delivery's `recorded` commits. Absent for a plain
-     * empty-bundle hold, so the empty case is byte-unchanged.
-     */
-    coverage?: {
-        /** How many commits the durable record (focus_merges.commit_shas) names. */
-        recorded: number;
-        /** How many of those the resolved diff range actually covered. */
-        covered: number;
-    };
-    /**
-     * Populated for a TOTAL ATTRIBUTION FAILURE hold: the merged batch carried
-     * `parsed` (=0) parseable Telora-Delivery trailers across `batch` commits on a
-     * focus of `deliveries` deliveries (> 1), so it cannot be partitioned and each
-     * delivery would otherwise be judged against the COMBINED sibling diff. Distinct
-     * from an under-covering range (`coverage`, half-blind): here the range covers
-     * the batch exactly, but the batch is the wrong -- unattributable -- evidence.
-     * Absent for empty-bundle and half-blind holds.
-     */
-    attribution?: {
-        /** How many commits the merged batch contains. */
-        batch: number;
-        /** How many carried a parseable trailer (0, by definition of this hold). */
-        parsed: number;
-        /** How many deliveries share the focus (> 1, else this is a genuine legacy batch). */
-        deliveries: number;
-    };
-    /**
-     * Populated for a FULLY-BLIND (empty-source) hold: the four evidence sources
-     * the diff resolver consults, each with the reason it yielded nothing (e.g.
-     * "no recorded commit set", "recorded sha refused as non-merge", "zero commits
-     * ahead", "no merge commit found"). Absent for half-blind (`coverage`) and
-     * attribution-failure (`attribution`) holds, where a source WAS resolved. This
-     * is what makes a second fast-forward blinding diagnosable from the daemon log
-     * alone -- without the database access the 2026-08-15 investigation lacked.
-     */
-    sourceDiagnostics?: Array<{
-        source: string;
-        reason: string;
-    }>;
-    /**
-     * Populated when the gate went blind because the durable record could not be
-     * READ (the focus_merge_list API was unreachable), as distinct from a record
-     * that was read and confirmed EMPTY. Names the seam that could not be
-     * determined + the underlying reason, so an INSTRUMENT fault is never reported
-     * as an absent-evidence fault. Absent when every evidence lookup ran
-     * successfully (the blindness was an honest absence, not a read failure).
-     */
-    instrumentUndetermined?: {
-        seam: string;
-        reason: string;
-    };
-    /**
-     * Populated for a DETERMINISTIC instrument fault: the deterministic verify RUN
-     * itself could not yield an attributable verdict --
-     *   'blind_zero_parse' -- it exited non-zero but parsed zero failing-test ids
-     *                         (a type-check crash, missing deps, or a run that died
-     *                         before any test executed), OR
-     *   'timeout'          -- it was killed by the deterministic timeout before it
-     *                         completed.
-     * Distinct from the diff-evidence faults above: here the SHELL RUN is the blind
-     * instrument, not the diff resolver. Absent for every diff-evidence hold, so
-     * those cases stay byte-unchanged.
-     */
-    deterministicFault?: {
-        kind: 'blind_zero_parse' | 'timeout';
-        exitCode: number | null;
-        /**
-         * For a 'timeout': the timeout the run was killed at, and the layer it was
-         * read from (env var, daemon.json, a manifest path, the typed default, or the
-         * delivery's own config). Absent when the run recorded no applied config --
-         * never invented -- and always absent for 'blind_zero_parse'.
-         */
-        timeoutMs?: number;
-        timeoutSource?: string;
-    };
-    /** The recorded gate verdict for the commit the blind run judged; absent when none was recorded (a blind run records none). */
-    gateVerdict?: GateVerdictSummary;
-}
-/**
- * Shape written into product_deliveries.gate_state when guard evaluation
- * blocks a stage transition. Its verdict is cleared when guards pass. The row
- * goes null unless verification history must carry forward
- * (carryVerificationHistory).
- *
- * `verification` is populated when the block is a daemon-side deterministic
- * verification failure (Harness-Owned Delivery Verification), carrying the
- * failing tests + log path for the feedback loop; absent for guard-only gates.
- *
- * `shortfallReconciliation` is populated when the block is a verify-shortfall
- * reconciliation hold (declared-vs-achieved gap), NOT a deterministic run; the
- * two are mutually exclusive origins and never share the deterministic guard.
- */
-export interface DeliveryGateState {
-    blocking: Array<{
-        guardName: string;
-        passed: boolean;
-    }>;
-    warnings: Array<{
-        guardName: string;
-        passed: boolean;
-    }>;
-    evaluatedAt: string;
-    verification?: VerificationFailureDetail;
-    shortfallReconciliation?: ShortfallReconciliationDetail;
-    /**
-     * Populated when the verify path was handed no evidence it could judge the
-     * work against (an instrument fault). Kept under its own key -- never
-     * conflated with `verification` (a shell failure) or `shortfallReconciliation`
-     * (a work shortfall) -- so a reader can tell "the gate was blind" from "the
-     * work fell short". The blocking guard is `verify_evidence_unavailable`.
-     */
-    evidenceUnavailable?: EvidenceUnavailableDetail;
-    /** The verify reconciliation could not RUN (queries/verify-own-holds.ts); hand-mirrored in src/types/delivery.ts. */
-    modelUnavailable?: ModelUnavailableDetail;
-    /**
-     * Undisposed shortfall drift proposal ids holding this delivery in verify.
-     *
-     * Kept OUT of `blocking` on purpose: that array is guard-verdict data
-     * (guardName + passed), and a shortfall hold is not a guard. Synthesizing a
-     * fake guardName to smuggle the ids through would make `blocking` lie about
-     * what a guard is. `formatGateBlockers` is the single place that merges the
-     * two for display.
-     *
-     * Absent for guard-only gates. Written by the review-exit shortfall hold and
-     * cleared, like the rest of gate_state, when the delivery finally routes.
-     */
-    shortfallProposalIds?: string[];
-    /**
-     * The open operator-blocked escalation (disposition needs_operator /
-     * external_wait, any kind) holding this delivery in verify. Written by the
-     * operator-hold gate (operator-hold.ts) so the board can name what the
-     * delivery is waiting on without a second escalation being filed; cleared,
-     * like the rest of gate_state, when the delivery finally routes. When the hold
-     * read itself failed (fail-closed), escalationId is null and readFailed is
-     * true -- the delivery is still held, just without a specific escalation to
-     * name. Like shortfallProposalIds, kept OUT of `blocking` (a hold is not a
-     * guard verdict).
-     *
-     * An OBSERVATION hold (a machine-lane agent_resolvable filing whose detector
-     * proposed needs_operator / external_wait; see queries/holds.ts) carries
-     * `observation: true` and the `proposedDisposition`, beside the row's own
-     * `disposition` (agent_resolvable). The card then reads "held on an open
-     * observation (proposed needs_operator)", and the wedge watchdog does not count
-     * it as human provenance. Hand-mirrored in src/types/delivery.ts.
-     */
-    operatorHold?: {
-        escalationId: string | null;
-        escalationKind: string | null;
-        disposition: string | null;
-        readFailed?: boolean;
-        observation?: boolean;
-        proposedDisposition?: string;
-    };
-    /**
-     * An irreducibly-external dependency holding this delivery in verify, carried
-     * as durable STATE rather than an agent_escalations row (external-hold.ts).
-     * The blocking condition and what would clear it live here, attached to the
-     * delivery they block; the hold clears by re-evaluating that condition (a
-     * re-read of reality), not by a human resolving an inbox item. Kept OUT of
-     * `blocking` for the same reason as operatorHold/shortfallProposalIds: a hold
-     * is not a guard verdict. Cleared, like the rest of gate_state, when the
-     * delivery finally routes.
-     */
-    externalHold?: ExternalHoldState;
-    /**
-     * A review that would have moved this delivery to done, held because no
-     * PASSING deterministic gate verdict exists yet for the commit it judges (the
-     * focus worktree HEAD). Written by the review exit's commit-verdict gate
-     * (completion/review-exit-verdict-gate.ts); read by the release poll pass
-     * (completion/commit-verdict-release.ts), which replays the held review exit
-     * once the verdict lands, and by the review park (spawn/review-hold-park.ts),
-     * so no billed review respawns while the gate runs. Kept OUT of `blocking` for
-     * the same reason as operatorHold: a hold is not a guard verdict. Cleared, like
-     * the rest of gate_state, when the delivery routes. Hand-mirrored in
-     * src/types/delivery.ts.
-     */
-    commitVerdictHold?: CommitVerdictHoldState;
-    /**
-     * A finished delivery's coding -> verify advance, held by the daemon's own
-     * precheck (focus/advance-hold.ts): the focus worktree -- shared by every
-     * delivery of the focus -- has uncommitted paths, or a verify command is
-     * running in it. Paired with a `blocking` entry of the same guard name (the
-     * `verify_evidence_unavailable` shape), so the Waiting-on line and a team
-     * reading the delivery both see it. The daemon clears it on the tick the
-     * advance lands and when the delivery re-opens. Hand-mirrored in
-     * src/types/delivery.ts.
-     */
-    advanceHold?: AdvanceHoldDetail;
-    /**
-     * The targets the latest verify run did NOT judge, because the focus's arm did
-     * not cover them (queries/recorded-targets-record.ts, written by
-     * verify/recorded-targets.ts). A RECORD, not a hold: its own key, so
-     * "recorded, waiting for the next arm" never reads as "held".
-     */
-    recordedTargets?: RecordedTargetsRecord;
-    /**
-     * Verification history carried across a clear or replacement of this gate
-     * (see VerificationHistory). Never a live block: a clear that carries history
-     * writes it beside an EMPTY `blocking` array.
-     */
-    verificationHistory?: VerificationHistory;
-}
-/** Validate a signature run read from JSON (gate_state); null when malformed. Pure. */
-export declare function parseSignatureRun(raw: unknown): VerificationSignatureRun | null;
-/** Validate a shortfall repeat record read from JSON; null when malformed. Pure. */
-export declare function parseShortfallRepeat(raw: unknown): ShortfallRepeatRecord | null;
-/**
- * The commit a verification run's command FAILED on, or null. Only a verdict
- * about a tree counts: a non-zero exit at a known judged sha. A timeout (a kill,
- * not a verdict), an unknown exit, or an in-place run with no judged sha is null.
- * Pure; the one rule both the durable record and the in-memory guard apply.
- */
-export declare function judgedFailedSha(result: {
-    exitCode?: number | null;
-    timedOut?: boolean;
-    verifiedSha?: string;
-}): string | null;
-/**
- * The verification history a delivery's gate_state carries, whether live (the
- * gate IS a rejection: `verification.signatureRun`,
- * `shortfallReconciliation.repeat`) or carried (`verificationHistory`). A live
- * record wins over the carried copy of the same kind. `judgedCommit`,
- * `shortfallPark` and `explicitOutcome` are only ever carried (their writers stamp them there). Returns `{}` for null,
- * malformed, or history-free gate_state. Defensive over the loosely typed JSONB.
- * Pure.
- */
-export declare function readVerificationHistory(gateState: unknown): VerificationHistory;
-/**
- * `gateState` with its judged commit REPLACED: set to `sha` (judged at
- * `judgedAt`) when the run judged a commit, removed when it judged none, so a
- * re-work never leaves an older judgment standing for a newer run. `gateVerdict`
- * is persisted beside the sha only when it is a verdict for that same sha. The
- * rest of the history is untouched; an emptied history key is dropped. Pure.
- */
-export declare function stampJudgedCommit(gateState: DeliveryGateState, sha: string | null | undefined, judgedAt: string, gateVerdict?: GateVerdictSummary | null): DeliveryGateState;
-/**
- * `gateState` with its explicit-method verdict REPLACED: set to `outcome` when
- * the run rendered one, removed when it rendered none
- * (verify/explicit-gate-outcome.ts). Every other key and the rest of the history
- * are untouched; an emptied history key is dropped, and a gate left holding
- * nothing is null. A verdict stamped on a null gate_state rides beside an EMPTY
- * `blocking` array, like carried history. Pure.
- */
-export declare function stampExplicitGateOutcome(gateState: unknown, outcome: ExplicitGateOutcome | null): DeliveryGateState | null;
-/**
- * The ONE carry-forward rule for every writer that clears or replaces a
- * delivery's gate_state between two verify runs. The verdict changes; the
- * verification history (VerificationHistory) survives.
- *
- *   - `next` null (a guard-pass clear): returns null when `prior` carries no
- *     history, which is byte-identical to the old clear. Otherwise returns
- *     `{ blocking: [], warnings: [], evaluatedAt, verificationHistory }`. The
- *     `blocking` array is EMPTY, so carried history is never read as a live
- *     block (verify/verify-gate-stall.ts hasLiveBlockingGuard). `evaluatedAt`
- *     is the prior's, so carrying an already-carried gate is a fixpoint.
- *   - `next` a verdict or hold: returns `next` plus any prior history of a kind
- *     `next` does not record live (a rejection's own fresh record supersedes
- *     the prior one).
- *
- * Pure and idempotent: `now` is consulted only when `prior` has no
- * `evaluatedAt` to reuse.
- */
-export declare function carryVerificationHistory(prior: unknown, next?: null, now?: () => string): DeliveryGateState | null;
-export declare function carryVerificationHistory(prior: unknown, next: DeliveryGateState, now?: () => string): DeliveryGateState;
-export declare function carryVerificationHistory(prior: unknown, next: DeliveryGateState | null, now?: () => string): DeliveryGateState | null;
-/**
- * A gate_state with its verification history RESET, which is what a verify PASS
- * leaves. Drops the carried copy (a standing shortfall park with it) and the
- * live run/repeat records so the next rejection starts a fresh count. Returns null when what remains is an empty
- * clear (no guard verdict, no warning, no hold), so a history-only gate goes
- * back to null. Every other key (holds, a live verdict's detail) is preserved.
- * Pure.
- */
-export declare function clearVerificationHistory(gateState: DeliveryGateState | null): DeliveryGateState | null;
-/** Whether a gate_state is an empty clear: no guard verdict, no warning, no other key. Pure. */
-export declare function isEmptyClear(gate: DeliveryGateState): boolean;
-//# sourceMappingURL=delivery-gate-state.d.ts.map

package/dist/queries/delivery-gate-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delivery-gate-state.d.ts","sourceRoot":"","sources":["../../src/queries/delivery-gate-state.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACpF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,YAAY,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,YAAY,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,KAAK,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7G,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7H;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,oFAAoF;IACpF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,wBAAwB,CAAC;IACxC;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6FAA6F;IAC7F,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,mHAAmH;IACnH,YAAY,CAAC,EAAE,wBAAwB,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,qGAAqG;IACrG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,iEAAiE;IACjE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,kFAAkF;IAClF,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,6BAA6B;IAC5C,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,UAAU,EAAE,KAAK,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,2EAA2E;QAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;IACH;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,4HAA4H;IAC5H,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,sFAAsF;IACtF,aAAa,CAAC,EAAE,0BAA0B,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,YAAY,CAAC,EAAE,wBAAwB,CAAC;IACxC,sDAAsD;IACtD,eAAe,CAAC,EAAE,qBAAqB,CAAC;IACxC,iHAAiH;IACjH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,mHAAmH;IACnH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,sFAAsF;AACtF,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,GAAG,EAAE,MAAM,CAAC;IACZ,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED,iFAAiF;AACjF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,qHAAqH;IACrH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,6HAA6H;IAC7H,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,yBAAyB;IACxC,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,iHAAiH;IACjH,aAAa,CAAC,EAAE,0BAA0B,CAAC;IAC3C,8FAA8F;IAC9F,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE;QACT,4EAA4E;QAC5E,QAAQ,EAAE,MAAM,CAAC;QACjB,kEAAkE;QAClE,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE;QACZ,kDAAkD;QAClD,KAAK,EAAE,MAAM,CAAC;QACd,4EAA4E;QAC5E,MAAM,EAAE,MAAM,CAAC;QACf,sFAAsF;QACtF,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9D;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,EAAE;QACnB,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAAC;QACrC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB;;;;;WAKG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,+HAA+H;IAC/H,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACxD,QAAQ,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,uBAAuB,CAAC,EAAE,6BAA6B,CAAC;IACxD;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,yBAAyB,CAAC;IAChD,qHAAqH;IACrH,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;IAC1C;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE;QACb,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC;IACF;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;IAC3C;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAC;IACxC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C;AAYD,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,wBAAwB,GAAG,IAAI,CAU/E;AAED,oFAAoF;AACpF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,qBAAqB,GAAG,IAAI,CAK/E;AAOD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAG7H;AAqDD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,OAAO,GAAG,mBAAmB,CAkB/E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,iBAAiB,EAC5B,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,kBAAkB,GAAG,IAAI,GACtC,iBAAiB,CAOnB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAY1H;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,MAAM,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAC;AACpH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,MAAM,MAAM,GAAG,iBAAiB,CAAC;AACzH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,GAAG,IAAI,EAC9B,GAAG,CAAC,EAAE,MAAM,MAAM,GACjB,iBAAiB,GAAG,IAAI,CAAC;AA6B5B;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAgBtG;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAI7D"}