@telora/daemon 0.22.245 → 0.22.290

package/dist/verify/engine/verification-deps.d.ts

@@ -0,0 +1,466 @@
+/**
+ * The verification engine's injectable dependency surface.
+ *
+ * Separate from `verification-engine.ts` (which holds the dispatch + tick logic)
+ * because this is a CONTRACT, not behavior: every seam the engine reaches
+ * reality through -- pending-verification reads, the injection flip, target
+ * reconciliation, escalation filing, drift emission, the three strategies, cwd
+ * and commit-set resolution, the security gate, and the three feedback re-entry
+ * paths -- is declared here, and every test that drives the engine constructs
+ * one of these. EVERY member is REQUIRED: the engine and its helpers read each
+ * one without a fallback, so which implementation runs is decided by whoever
+ * builds the context, never by a consumer's default. Production builds it once,
+ * in the composition root (composition/verification-context.ts
+ * buildVerificationDeps); a test builds it with testing/fixtures/verification-deps.ts
+ * makeVerificationDeps (inert stubs) plus the members it exercises, so a test
+ * that omits a collaborator gets a stub it chose, never a real implementation.
+ *
+ * Type-only module: no runtime imports, so it adds no edge to the module graph
+ * that `import-x/no-cycle` has to reason about.
+ *
+ * History: docs/daemon/history-verify.md (verify/engine/verification-deps.ts).
+ *
+ * @module verification-deps
+ */
+import type { CommitGateSubject } from '../gate-config/commit-gate-configured.js';
+import type { StrategyResult } from '../deterministic-gate/verification-deterministic.js';
+import type { runDeterministicStrategy } from '../deterministic-gate/verification-deterministic.js';
+import type { CommitVerdictGate, CommitVerdictReader, CommitVerdictRecorder } from '../gate-verdicts/commit-verdict-record.js';
+import type { NoVerdictStore } from '../gate-verdicts/no-verdict-record.js';
+import type { CarriedVerdict } from '../gate-verdicts/no-own-delta-verdict.js';
+import type { AncestorLister } from '../gate-verdicts/judged-ancestor.js';
+import type { CommitVerdictPullRegistry } from '../run-selection/commit-verdict-pull.js';
+import type { InstallProbeTickDeps } from '../install-probe/install-probe-tick.js';
+import type { RecordedTargetsPersist } from '../effect-reconciliation/recorded-targets.js';
+import type { VerifyCheckout } from '../deterministic-gate/verification-checkout.js';
+import type { WorktreeProvisioningStatus } from '../../worktree/worktree-package-provisioning.js';
+import type { getPendingVerifications, PendingVerification, VerificationOutcome } from '../../queries/verification/verification.js';
+import type { NodeWriteback } from '../../reality/reality-writeback.js';
+import type { JudgedTarget, ReconcileTargetsResult, TargetRestatement, TargetShortfall } from '../effect-reconciliation/verify-restatement.js';
+import type { VerifyEvidence } from '../effect-reconciliation/verify-reconciliation.js';
+import type { FileEscalationInput } from '../../nexus/file-escalation.js';
+import type { EvidenceUnavailableDetail, GateVerdictSummary } from '../../queries/delivery-gate-state/delivery-gate-state.js';
+import type { DeliveryGateRecord } from '../../queries/deliveries/deliveries.js';
+import type { JudgeWorkspace } from '../effect-reconciliation/judge-workspace.js';
+import type { ModelUnavailableDetail } from '../../queries/delivery-gate-state/verify-own-holds.js';
+import type { AppliedVerificationConfig, DefaultVerificationResolver, VerificationConfigScope } from '../gate-config/verification-config.js';
+import type { JudgedCommitManifest, JudgedCommitRead } from '../run-selection/verification-default-on.js';
+import type { OwedReworkRetry } from '../outcome-routing/verification-rework-issue.js';
+import type { getActiveFocuses } from '../../queries/focuses/focus-discovery.js';
+import type { getFocusDeliveries } from '../../queries/focuses/focuses.js';
+import type { AiInspectionInputs } from '../inspection-strategies/ai-inspection-context.js';
+import type { InspectionResult } from '../inspection-strategies/ai-inspection-runner.js';
+import type { SecurityFindingGateDeps } from '../../security/security-finding-gate.js';
+import type { FailureClassification } from '../attribution/verification-baseline.js';
+import type { GateSegment } from '../deterministic-gate/verification-gate-stages.js';
+import type { ShortfallRulingsReader } from '../shortfalls/shortfall-rulings.js';
+import type { UnresolvedEvidenceRef } from '../shortfalls/ruling-evidence-resolution.js';
+import type { EvidenceRef } from '../../drift/artifact-ref-shape.js';
+/**
+ * Run the gate stages that never ran after a pre-existing red (a parsed run's
+ * continuation segments) at the commit `head` judged, returning that run's result.
+ */
+export type StageContinuationRunner = (v: PendingVerification, segments: readonly GateSegment[], head: StrategyResult) => Promise<StrategyResult>;
+export interface DriftProposalCreatePayload {
+    focusId: string | null;
+    productId: string | null;
+    injectionNodeId: string;
+    observation: {
+        nodeId: string | null;
+        kind: 'update_statement' | 'add_node' | 'retire_node' | 'change_node_type' | 'flip_ude_to_de';
+        observed: string;
+        suggestedCorrection: string;
+    };
+}
+export interface VerificationDeps {
+    getPendingVerifications: typeof getPendingVerifications;
+    /**
+     * Record the outcome. `judgedSha` is the commit the run judged (null when it
+     * judged none): a pass keeps a judged commit stamped for that very sha
+     * (verify/outcome-routing/verification-history-reset.ts).
+     */
+    recordOutcome: (deliveryId: string, outcome: VerificationOutcome, judgedSha?: string | null) => Promise<void>;
+    /**
+     * Retire the injection + promote its FRT overlay. `evidence` (when supplied)
+     * is stamped onto the injection node before the flip so a verification-retired
+     * injection cites the files/tests it was verified on -- never evidence=null.
+     * `withheldNodeIds` are targets that must not flip with it: shortfall nodes an
+     * operator EXCUSED (verify/shortfalls/shortfall-rulings.ts).
+     */
+    verifyInjection: (injectionNodeId: string, restatements?: TargetRestatement[], evidence?: string, withheldNodeIds?: readonly string[]) => Promise<void>;
+    /**
+     * Read the operator shortfall rulings recorded on a delivery
+     * (queries/verification/shortfall-rulings.ts). Applied to a judgement's shortfalls before
+     * they route, and read by the default-on scan to re-judge a park a ruling
+     * released (verify/shortfalls/shortfall-rulings.ts). Production reads the product-api.
+     */
+    readShortfallRulings: ShortfallRulingsReader;
+    /**
+     * Resolve a review met's evidence references at the judged commit, by
+     * existence only (verify/shortfalls/ruling-evidence-resolution.ts): the references that
+     * did NOT resolve; a review met whose evidence does not resolve is not honored
+     * (verify judges those nodes itself). Production reads the product repo with git.
+     */
+    resolveRulingEvidence: (v: PendingVerification, refs: readonly EvidenceRef[], sha: string) => Promise<UnresolvedEvidenceRef[]>;
+    /**
+     * The verdict the commit-verdict RELEASE pass would read for a held commit
+     * (verify/gate-verdicts/own-gate-verdict.ts readGateVerdictState over the
+     * production gate seams): the delivery's own gate, its per-commit record and its
+     * explicit outcome. The commit-verdict pull declines a parked delivery only when
+     * this reads 'passed' -- the one state in which the release replays with no run
+     * (verify/run-selection/commit-verdict-pull.ts).
+     */
+    readHeldCommitVerdictState: (subject: CommitGateSubject, sha: string) => Promise<'unconfigured' | 'passed' | 'failed' | 'pending'>;
+    /**
+     * Read the delivery's execution_status + gate_state as the last writer left
+     * them (queries/deliveries/deliveries.ts getDeliveryGateRecord). The pass path reads the
+     * standing SHORTFALL PARK through it before the reconciliation, so a parked
+     * delivery whose commit set and rulings are unchanged is re-held from the
+     * record instead of costing another model call
+     * (verify/shortfalls/parked-shortfall-reuse.ts). A null record reads no park, and
+     * the dispatch judges. Production reads the delivery row.
+     */
+    readDeliveryGateRecord: (deliveryId: string) => Promise<DeliveryGateRecord | null>;
+    /**
+     * The identities of the delivery's OWN Telora-Delivery-trailered commits at the
+     * commit a dispatch judged (verify/shortfalls/delivery-commit-set.ts); null when git could
+     * not answer. The SAME resolution the shortfall routing fingerprints the park
+     * with (composition/verification-context.ts resolveJudgedDeliveryCommitSet), so the
+     * park's recorded set and the set read here are comparable by construction.
+     * A null set is unknown, and a park is then never reused.
+     */
+    resolveDeliveryCommitSet: (v: PendingVerification, judgedSha: string | null) => Promise<string[] | null> | string[] | null;
+    /**
+     * Reconcile the declared desired effect against the achieved outcome (authored
+     * from the supplied EVIDENCE -- diff/tests/inspection, NOT the UDE problem text)
+     * for each UDE the injection targets, classifying match / legitimate_divergence
+     * / shortfall. match / legitimate_divergence come back in `restatements` for the
+     * engine to carry INTO the verify call; shortfalls come back in `shortfalls` so
+     * the engine can hold the gate and escalate. The edge applies the supplied prose
+     * + classification; it never runs the LLM.
+     */
+    authorTargetRestatements: (injectionNodeId: string, focusId: string | null, evidence: VerifyEvidence, 
+    /**
+     * True when the resolved diff range does not cover the delivery's recorded
+     * commit set (half-blind). Treated the same as an empty bundle: the gate
+     * declines to render a verdict and returns the instrument-fault signal.
+     */
+    evidenceIncomplete: boolean, 
+    /**
+     * The delivery being verified. Lets the reconciliation narrow to the targets
+     * the focus's ARM COVERED: a target added to the in-flight injection after
+     * arming produces no shortfall, no hold and no re-work issue, and is
+     * reported as recorded instead. Omitted => every target is judged, as before.
+     */
+    deliveryId?: string | null, 
+    /**
+     * Target nodes an active ruling honours at the judged commit
+     * (verify/shortfalls/pre-judge-rulings.ts): not sent to the judge.
+     */
+    ruledNodeIds?: ReadonlySet<string>) => Promise<ReconcileTargetsResult>;
+    /**
+     * The targets a verify judge would judge for the injection, with no model call
+     * (production: verify/effect-reconciliation/verify-restatement.ts
+     * listJudgedTargets). ai_inspection is not called when every one is ruled
+     * (verify/shortfalls/pre-judge-rulings.ts everyTargetPreRuled). A throw is an
+     * unknown: the inspection runs.
+     */
+    listJudgedTargets: (injectionNodeId: string, focusId: string | null, deliveryId: string) => Promise<JudgedTarget[]>;
+    /**
+     * File a human escalation when an injection's achieved outcome falls SHORT of
+     * its declared desired effect. Reality is asymmetric: we never soften the
+     * declared DE to match a lesser achievement -- we hold the gate and hand the
+     * gap to the intent owner.
+     */
+    fileEscalation: (input: FileEscalationInput) => Promise<void>;
+    /** Org scope for filed escalations. */
+    organizationId: string;
+    /** Persist a single drift proposal observed during ai_inspection. */
+    emitDriftProposal: (payload: DriftProposalCreatePayload) => Promise<void>;
+    /**
+     * Surface INWARD drift proposals (TEL-4): for each target the verify path
+     * stamped `legitimate_divergence`, create one `update_statement` drift
+     * proposal flagged `inward:true` so a confident-but-wrong tree claim is
+     * corrected by drift rather than frozen. Best-effort + non-fatal: a failure
+     * here must not undo the verify flip that already landed. Production binds
+     * emitInwardDriftProposals (reality/injection-writeback.ts).
+     */
+    emitInwardDrift: (injectionNodeId: string, writebacks: readonly NodeWriteback[], realityTreeId?: string) => Promise<void>;
+    runDeterministic: typeof runDeterministicStrategy;
+    runAiInspection: (inputs: AiInspectionInputs) => Promise<InspectionResult>;
+    resolveAiInspectionInputs: (v: PendingVerification) => Promise<AiInspectionInputs | null>;
+    /**
+     * The changed files and diff stat read at a pinned range, so the inspection's
+     * question describes the commit it judges (production:
+     * verify/inspection-strategies/ai-inspection-context.ts readPinnedChange).
+     */
+    readPinnedChange: (repoPath: string, range: string) => Pick<AiInspectionInputs, 'changedFiles' | 'diffStat'>;
+    resolveCwd: (productId: string | null) => string;
+    integrationBranch: string;
+    /**
+     * Security workflow verify-closed gate. Consulted before
+     * `verifyInjection` so a security-linked injection cannot be retired
+     * unless the linked finding has flipped to 'resolved'. On failure the
+     * gate escalates the finding (status='escalated', reason='verify_gate_failed')
+     * and the engine demotes the verification outcome to 'failed'.
+     */
+    securityFindingGate: SecurityFindingGateDeps;
+    /**
+     * Resolve the default-on deterministic verification config (env > file >
+     * default). When it yields `enabled: false` (no command configured) the
+     * default-on scan arms only from judged commits. `setAsideRepoManifest`
+     * reads the repoPath manifest as absent (the tick sets a malformed one aside).
+     */
+    resolveDefaultVerification: DefaultVerificationResolver;
+    /** Enumerate active focuses for a product (default-on candidate discovery). */
+    getActiveFocuses: typeof getActiveFocuses;
+    /** Fetch a focus's deliveries (default-on candidate discovery). */
+    getFocusDeliveries: typeof getFocusDeliveries;
+    /** Failed-run feedback (gate_state + live inject). */
+    deliverFailureFeedback: (v: PendingVerification, result: StrategyResult) => Promise<void>;
+    /**
+     * Shortfall-origin re-work re-entry: route the delivery verify -> verify_failed
+     * through the single-writer reconciler (carrying the declared-vs-achieved gap in
+     * gate_state under the shortfall guard) so it re-enters bounded re-work instead
+     * of a human inbox, and live-inject the gap into a running coding team.
+     * Distinct from deliverFailureFeedback so a shortfall hold never reports under
+     * the deterministic guard. Production routes it through routeShortfallOutcome.
+     * `judgedSha` is the commit the run behind this verdict judged (null when it
+     * judged none), and `runVerdict` the verdict that run rendered for it
+     * (rework-judgment.ts runVerdictOf; null when it rendered none): the re-work
+     * shows it and persists it beside the judged commit, so a resume reads the
+     * delivery's own verdict without a record read. `shortfalls` are those no
+     * operator ruling cleared, and `rulingsFingerprint` the fingerprint of the
+     * rulings applied (null when unread) -- recorded on a park it re-holds
+     * (verify/shortfalls/shortfall-park.ts classifyShortfallPark).
+     */
+    deliverShortfallFeedback: (v: PendingVerification, shortfalls: readonly TargetShortfall[], judgedSha?: string | null, runVerdict?: GateVerdictSummary | null, rulingsFingerprint?: string | null) => Promise<void>;
+    /**
+     * Instrument-fault re-work re-entry: the verify path was handed no evidence it
+     * could judge the work against (an empty bundle). Routes the delivery
+     * verify -> verify_failed through the single-writer reconciler (carrying the
+     * instrument-fault context in gate_state under the evidence-unavailable guard)
+     * so it re-enters the EXISTING bounded verify_failed re-work cycle, and
+     * live-injects the fault into a running coding team. Files NO escalation --
+     * "fix the diff range / confirm the merge" names no act only a human can
+     * perform, so an empty bundle never reaches a human inbox
+     * (verify_gate_unclearable, from the iteration cap, is the sole residue).
+     * Production binds requeueEvidenceUnavailableAsRework.
+     * `judgedSha` and `runVerdict` as for deliverShortfallFeedback.
+     */
+    requeueEvidenceUnavailableAsRework: (v: PendingVerification, fault: Omit<EvidenceUnavailableDetail, 'heldAt'>, judgedSha?: string | null, runVerdict?: GateVerdictSummary | null) => Promise<void>;
+    /**
+     * The reconciliation could not RUN (backends/claude/one-shot-model.ts ModelUnavailable):
+     * the model was not reached, so nothing was judged. Records the awaited hold
+     * on the delivery at its own status -- no transition, no iteration, no
+     * shortfall, no repeat signature -- so a later tick re-judges the same commit
+     * (verify/outcome-routing/verification-model-unavailable-hold.ts).
+     */
+    holdForModelUnavailable: (v: PendingVerification, detail: ModelUnavailableDetail) => Promise<void>;
+    /**
+     * cwd for the HEAD run and the diff read -- the focus worktree, else the
+     * product repo (production: verify/attribution/verification-baseline.ts
+     * buildResolveVerificationCwd over resolveCwd).
+     */
+    resolveVerificationCwd: (v: PendingVerification) => string;
+    /**
+     * The focus worktree a deterministic verify judges (its HEAD is checked out
+     * detached for the run), and where the green-ancestor base is walked
+     * (verify/deterministic-gate/verification-boundary-env.ts); null when the focus
+     * has none. Production reads the registered focus worktree.
+     */
+    resolveFocusWorktreePath: (v: PendingVerification) => string | null;
+    /**
+     * The judge's workspace: a detached checkout of `sha` (null: `repoPath`'s HEAD now) made from `repoPath`, and
+     * its citation resolution (production: verify/effect-reconciliation/judge-workspace.ts
+     * createJudgeWorkspace). null when no checkout can be made -- the judge is then
+     * not called.
+     */
+    createJudgeWorkspace: (repoPath: string, key: string, sha: string | null, range: string) => JudgeWorkspace | null;
+    /**
+     * The HEAD sha of the directory an in-place deterministic run executes in, or
+     * null when it cannot be read -- named on the gate-run registry for the
+     * heartbeat's focus activity record (production: resolveHeadSha,
+     * verify/attribution/verification-baseline.ts).
+     */
+    resolveHeadShaAt: (cwd: string) => string | null;
+    /** Detached-checkout factory for a deterministic run (production: createVerifyCheckout). */
+    createVerifyCheckout: (focusWorktreePath: string, checkoutKey: string) => VerifyCheckout | null;
+    /**
+     * Whether the focus worktree's nested package installs are current; not ready
+     * -> the run reports checkoutUnavailable. Production binds
+     * readWorktreeProvisioning (worktree/worktree-package-provisioning.ts).
+     */
+    readWorktreeProvisioning: (focusWorktreePath: string) => WorktreeProvisioningStatus;
+    /**
+     * Re-resolve a DEFAULT-ON candidate's command + timeout from the code a run
+     * executes in (`runPath`, the detached checkout), with the product repoPath
+     * manifest as a recorded fallback. Throws on a malformed manifest in that code.
+     * Never consulted for explicit-method rows or in-place runs. Production binds
+     * the real resolver over process.env (verify/deterministic-gate/verification-checkout.ts
+     * buildRunVerificationConfigResolver).
+     */
+    resolveRunVerificationConfig: (v: PendingVerification, runPath: string) => AppliedVerificationConfig;
+    /**
+     * Focus worktree HEAD sha: the default-on HEAD re-verify guard, the explicit
+     * re-arm, the commit a verdict is keyed by, and the green-ancestor walk. null
+     * (unreadable) never suppresses a run.
+     */
+    resolveFocusHeadSha: (focusId: string) => string | null;
+    /**
+     * Ancestors of a tip, newest first, excluding the tip: the green-ancestor walk
+     * that bounds the gate's diff (verify/gate-verdicts/judged-ancestor.ts). Production
+     * reads them with git (listAncestorsWithGit).
+     */
+    listAncestors: AncestorLister;
+    /**
+     * The in-process run registries a held-verdict pull reads and releases
+     * (verify/run-selection/commit-verdict-pull.ts withCommitVerdictPull).
+     */
+    commitVerdictPull: CommitVerdictPullRegistry;
+    /** The clean-environment install probe's IO (verify/install-probe/install-probe-tick.ts runInstallProbeTick). */
+    installProbe: InstallProbeTickDeps;
+    /**
+     * The telora.verify.json a focus's judged commit ships (default-on arming, and
+     * the gate a default-on verdict is keyed by). Production reads it with git
+     * (verify/run-selection/verification-default-on.ts buildJudgedCommitManifestReader).
+     */
+    readJudgedCommitManifest: (focusId: string) => JudgedCommitRead | null;
+    /**
+     * The gate a default-on verdict is keyed by at the judged commit a read names
+     * (verify/gate-config/judged-commit-gate.ts judgedCommitGate); production binds
+     * process.env and the real repoPath manifest reader.
+     */
+    judgedCommitGate: (source: VerificationConfigScope, read: JudgedCommitManifest) => CommitVerdictGate | null;
+    /**
+     * Retry a rework-Bug filing a failure left owed at the failed HEAD, for each
+     * verify delivery the default-on scan reads
+     * (verify/outcome-routing/verification-rework-issue.ts).
+     */
+    retryOwedReworkIssue: OwedReworkRetry;
+    /**
+     * Count of commits the delivery branch is ahead of the integration base.
+     * Used by the evidence-integrity guard to tell a broken diff MEASUREMENT
+     * (commits present but diff empty -> hold) from genuine inaction (no commits
+     * -> a real shortfall). Production resolves it in the focus worktree.
+     */
+    resolveCommitsAhead: (v: PendingVerification) => number;
+    /**
+     * Resolve the delivery's RECORDED constituent commit shas (focus_merges.commit_shas)
+     * for the merge_commit_sha the row carries -- the durable attribution written at
+     * merge time. The verify diff resolver prefers this over live branch topology so a
+     * fast-forwarded or rebased merge-back is judged against the delivery's real commit
+     * set, not a truncated trailing-commit range. Returns [] when no record exists (the
+     * resolver then falls through to topology).
+     */
+    resolveRecordedCommitShas: (v: PendingVerification) => Promise<string[]>;
+    /**
+     * Resolve the delivery's RECORDED pre-merge boundary (focus_merges.pre_merge_ref)
+     * for the merge_commit_sha the row carries. The verify diff resolver uses
+     * `<preMergeRef>...<mergeCommitSha>` as a FAST-FORWARD-safe range when the
+     * merge-back produced no merge commit -- an INDEPENDENT source from
+     * resolveRecordedCommitShas (a scalar that survives an empty commit_shas array).
+     * Returns null when no boundary was recorded (the resolver then falls through to
+     * its remaining sources).
+     */
+    resolveRecordedPreMergeRef: (v: PendingVerification) => Promise<string | null>;
+    /**
+     * The delivery's own commits in the batch whose pre-merge boundary
+     * resolveRecordedPreMergeRef hands -- the commits that boundary bounds. The
+     * verify boundary env counts these (not the whole-history set) so the
+     * selector's range guard compares one batch with its own boundary. Returns []
+     * when the batch holds none or is unrecorded.
+     */
+    resolveRecordedBoundaryCommitShas: (v: PendingVerification) => Promise<string[]>;
+    /**
+     * Detect a TOTAL ATTRIBUTION FAILURE: the recorded merge batch carries ZERO
+     * parseable Telora-Delivery trailers on a focus with MORE THAN ONE delivery.
+     * Such a batch is un-partitionable AND cannot be the genuine single-delivery
+     * legacy case, so returning the whole set as this delivery's evidence would
+     * judge it against the combined sibling diff (a confident verdict on the wrong
+     * evidence). Returns the batch/deliveries sizes when it IS such a failure, or
+     * null otherwise (partitionable batch, single-delivery focus, or no record).
+     * The engine forces the evidence-unavailable non-verdict path on non-null.
+     */
+    resolveAttributionFailure: (v: PendingVerification) => Promise<{
+        batch: number;
+        deliveries: number;
+    } | null>;
+    /**
+     * Detect an INSTRUMENT-READ fault: the durable record could not be READ at all
+     * (the focus_merge_list API was unreachable), as distinct from an honest empty
+     * record. Returns the seam that could not be determined + the underlying reason
+     * when the read was UNDETERMINED, or null when the record was read successfully
+     * (whether it held evidence or was confirmed empty). The engine uses this, on
+     * the fully-blind evidence-unavailable path, to report the blindness as a
+     * READ fault naming the seam rather than "there is nothing here".
+     */
+    resolveEvidenceInstrumentFault: (v: PendingVerification) => Promise<{
+        seam: string;
+        reason: string;
+    } | null>;
+    /** Baseline-diff attribution; null => no baseline resolvable (gate all). */
+    attributeFailures: (v: PendingVerification, result: StrategyResult) => Promise<FailureClassification | null>;
+    /**
+     * Continue a gate after a red the focus base shares: run the stages that never
+     * ran, at the judged commit, so they are judged before any pass. Production
+     * binds a fixed-commit run pinned to the HEAD run's verifiedSha
+     * (verify/attribution/verification-attribution.ts buildDefaultStageContinuation).
+     */
+    runStageContinuation: StageContinuationRunner;
+    /**
+     * Record the verdict a deterministic run rendered for its judged commit
+     * (verify/gate-verdicts/commit-verdict-record.ts). Production writes the durable
+     * per-commit record.
+     */
+    recordCommitVerdict: CommitVerdictRecorder;
+    /**
+     * Read the verdict recorded for a focus commit under a gate, so a deterministic
+     * delivery -- default-on, or an explicit row under its own gate -- judged on an
+     * already-judged commit takes it instead of running the gate again
+     * (verify/engine/verification-commit-sharing.ts). Production reads the durable
+     * per-commit record.
+     */
+    readCommitVerdict: CommitVerdictReader;
+    /**
+     * The per-commit record of gate runs that rendered NO verdict
+     * (verify/gate-verdicts/no-verdict-record.ts): written by the judge step, read at dispatch so
+     * no candidate re-runs such a commit inside its backoff. Production uses the
+     * durable store.
+     */
+    noVerdicts: NoVerdictStore;
+    /**
+     * The verdict a focus commit that adds nothing of the focus's own carries from
+     * its newest judged ancestor (verify/gate-verdicts/no-own-delta-verdict.ts), read when no
+     * verdict is recorded for the commit itself: taken in place of a run that would
+     * judge the integration tip for the focus. null: nothing is carried, and the
+     * commit runs.
+     */
+    resolveCarriedVerdict: (productId: string, focusId: string, head: string, gate: CommitVerdictGate) => Promise<CarriedVerdict | null>;
+    /**
+     * Record an explicit-method run's verdict, under the gate it applied, on its
+     * delivery's gate_state, where a daemon restart keeps it
+     * (verify/gate-verdicts/explicit-gate-outcome.ts). Called for an explicit row that routes,
+     * after recordOutcome, with the run id its selection named (undefined when none
+     * did). Production writes the durable record.
+     */
+    persistExplicitGateOutcome: (deliveryId: string, result: StrategyResult, gateKey: string, runId: string | undefined) => Promise<unknown>;
+    /**
+     * Record on the delivery's gate_state the targets its verify run did NOT judge,
+     * because the focus's arm did not cover them (verify/effect-reconciliation/recorded-targets.ts).
+     * Called last, once the run's other gate_state writers have settled, with the
+     * set the reconciliation reported -- empty to remove a standing record.
+     * Production writes the durable record.
+     */
+    persistRecordedTargets: RecordedTargetsPersist;
+    /**
+     * Name `runId` the explicit-method delivery's current run, voiding every verdict
+     * an older run recorded (verify/gate-verdicts/explicit-run-ledger.ts), and durably remove that
+     * verdict from its gate_state, before the run can start
+     * (verify/gate-verdicts/explicit-gate-outcome.ts). Resolves false when either did not land, or
+     * when the delivery is not found or stopped cycling (done, cancelled), and the tick
+     * then neither starts that run nor routes a verdict. Production does both.
+     */
+    invalidateExplicitGateOutcome: (deliveryId: string, runId: string) => Promise<boolean>;
+}
+//# sourceMappingURL=verification-deps.d.ts.map

package/dist/verify/engine/verification-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-deps.d.ts","sourceRoot":"","sources":["../../../src/verify/engine/verification-deps.ts"],"names":[],"mappings":"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"}

package/dist/verify/engine/verification-deps.js

@@ -0,0 +1,5 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: 30 tests -- run: npm run gen:pinned-by -- --list packages/daemon/src/verify/engine/verification-deps.ts
+// PINNED-BY-END
+export {};
+//# sourceMappingURL=verification-deps.js.map

package/dist/verify/engine/verification-deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-deps.js","sourceRoot":"","sources":["../../../src/verify/engine/verification-deps.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,qHAAqH;AACrH,gBAAgB"}

package/dist/verify/engine/verification-engine.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Pluggable verification engine -- Differential Focus Spec.
+ *
+ * Each delivery is the materialization of an injection. When the delivery
+ * reaches the 'verify' execution status, this engine selects a strategy
+ * based on the delivery's verification_method and runs it. On a 'passed'
+ * outcome the injection is retired (its FRT statement promotes to CRT)
+ * via the existing reality_tree_verify_injection compound op.
+ *
+ * A delivery carrying an explicit method runs that method. A delivery with none
+ * runs the default-on deterministic gate (verification-default-on.ts) when its
+ * product resolves a command; with neither it does not block, and focus-level AI
+ * review is the verify->done authority. Humans observe via the focus debug tab,
+ * never via a gate.
+ *
+ * Methods:
+ *   deterministic   -- run a shell command (tests, lint, types). Pass = exit 0.
+ *   behavioral      -- runtime telemetry observation (scaffold; needs drift
+ *                      detection to provide signal).
+ *   ai_inspection   -- AI reads code/state and decides (scaffold; needs an
+ *                      AI inspection driver that walks the reality tree in
+ *                      conversation via `telora_reality_tree_*` MCP calls).
+ *
+ * History: docs/daemon/history-verify.md (verify/engine/verification-engine.ts).
+ *
+ * @module verification-engine
+ */
+import { type StrategyResult } from '../deterministic-gate/verification-deterministic.js';
+import { type PendingVerification } from '../../queries/verification/verification.js';
+import type { DaemonConfig } from '../../types/index.js';
+import { type JudgeOptions } from './verification-commit-sharing.js';
+import type { VerificationDeps } from './verification-deps.js';
+/**
+ * Run verification for a single delivery.
+ *
+ * Ordering invariants:
+ *   1. Judge: run the strategy -- or, given `opts.reused`, take the verdict
+ *      already recorded for the commit the delivery is judged on.
+ *   2. On verdict 'passed' with an injection node: the gates that can still
+ *      demote the pass to 'failed' run (security finding, reconciliation
+ *      shortfall, blind evidence); a pass that survives them stamps the
+ *      injection (verifyInjection runs the reality_tree_verify_injection
+ *      compound op). The stamp is a POST-VERDICT side effect: its failure never
+ *      demotes the rendered verdict -- it is logged, surfaced separately, and
+ *      retried alone on later ticks (verify/effect-reconciliation/injection-stamp.ts), so a passed
+ *      HEAD is never re-run because a stamp failed.
+ *   3. Record the outcome (demoted only by the gates in 2, never by the stamp).
+ *   4. Emit any drift_observations the runner attached, regardless of
+ *      verdict. Each becomes a crt_drift_proposal in 'proposed' status.
+ *
+ * Drift emission is best-effort: a single failure logs and continues so
+ * one bad observation does not prevent the rest from being persisted.
+ */
+export declare function runVerificationForDelivery(v: PendingVerification, deps: VerificationDeps, opts?: JudgeOptions): Promise<StrategyResult>;
+/** A tick's telemetry counts. */
+type TickCounts = {
+    checked: number;
+    passed: number;
+    failed: number;
+    pending: number;
+    escalated: number;
+};
+/**
+ * One tick: fetch pending verifications across products, dispatch each.
+ * Returns counts for telemetry. `deps` is required: production passes the
+ * context the composition root built (composition/verification-context.ts).
+ */
+export declare function runVerificationTick(config: DaemonConfig, deps: VerificationDeps): Promise<TickCounts>;
+export {};
+//# sourceMappingURL=verification-engine.d.ts.map

package/dist/verify/engine/verification-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-engine.d.ts","sourceRoot":"","sources":["../../../src/verify/engine/verification-engine.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAmC,KAAK,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAE3H,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,4CAA4C,CAAC;AAQpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EAA8G,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AA+BjL,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA8H/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,0BAA0B,CAC9C,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,gBAAgB,EACtB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,cAAc,CAAC,CAuUzB;AA4DD,iCAAiC;AACjC,KAAK,UAAU,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAwE1G;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,UAAU,CAAC,CAyFrB"}