@telora/daemon 0.22.239 → 0.22.289

package/dist/verify/effect-reconciliation/verify-restatement.js

@@ -0,0 +1,330 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: 24 tests -- run: npm run gen:pinned-by -- --list packages/daemon/src/verify/effect-reconciliation/verify-restatement.ts
+// PINNED-BY-END
+/**
+ * Verify-time desired-effect reconciliation.
+ *
+ * When the verification engine produces a 'passed' verdict for an injection,
+ * it reconciles the DECLARED desired effect (the UDE's preserved frt_statement,
+ * authored at target time) against the ACHIEVED desired effect re-derived from
+ * the delivery's CITED worktree EVIDENCE (diff, test output, inspection finding)
+ * -- NOT from the targeted UDE's problem text. Each targeted UDE gets a
+ * classification:
+ *
+ *   - match                 -- the achieved outcome realizes the declared intent.
+ *   - legitimate_divergence -- a valid but different outcome (carries a reason).
+ *   - shortfall             -- the achieved outcome falls short of the intent.
+ *
+ * match / legitimate_divergence are carried INTO the verify call as the UDE's
+ * new base statement (+ classification + reason). The edge applies the supplied
+ * prose; it never runs the LLM.
+ *
+ * ASYMMETRY: a shortfall is NEVER carried into verify and NEVER softens the
+ * declared DE. The caller short-circuits the flip and escalates to a human --
+ * reality is moved toward intent, never the reverse. Shortfalls are returned
+ * here so the caller can hold the gate and file the escalation.
+ *
+ * Reuses the de-restatement CLI plumbing via verify-reconciliation (no new
+ * client or secret wiring).
+ *
+ * @module verify-restatement
+ */
+import { isModelUnavailable } from '../../backends/claude/one-shot-model.js';
+import { judgedQuestionFingerprint } from './judge-question.js';
+import { heldTargetsOrAll, } from '../../queries/focuses/arm-covered-targets.js';
+import { judgeEvidenceIsEmpty, } from './verify-reconciliation.js';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'verify-restatement' });
+/**
+ * Reconcile the achieved outcome against the declared desired effect for each
+ * UDE the injection targets.
+ *
+ * For each targeted UDE:
+ *   - The DECLARED desired effect is the UDE's preserved `frtStatement` (intent
+ *     of record). When absent, there is no declared intent to fall short of, so
+ *     the achieved DE authored from evidence is treated as a match.
+ *   - The ACHIEVED desired effect is authored from the supplied `evidence`
+ *     (diff/tests/inspection), NOT from the UDE problem text.
+ *   - The judgment classifies match / legitimate_divergence / shortfall.
+ *
+ * match / legitimate_divergence -> `restatements` (carried into verify).
+ * shortfall                     -> `shortfalls` (caller holds gate + escalates).
+ *
+ * Best-effort per target: a reconciliation FAILURE (model error / parse error)
+ * is treated as a SHORTFALL -- we cannot prove the achieved outcome realizes the
+ * declared intent, so we do not flip it and we surface it to a human. (This is
+ * the asymmetric-safe default: never flip what you could not reconcile.)
+ *
+ * SCOPE BOUNDARY (intentional): this reconciles ONLY the UDEs the injection
+ * DIRECTLY targets (its `targets` edges). Downstream consequences that resolve
+ * by causal PROPAGATION at verify are NOT reconciled here -- they have no
+ * declared DE to measure against, and their forward prose is authored by the
+ * injection-conditioned draft-assist loop (cascade-restatement.ts), not from raw
+ * code evidence. Verify flips their node_type but leaves verify_classification
+ * null; display falls back to the draft-assist frt_statement. See the matching
+ * note in graph-verification.ts (verifyInjectionImpl, Step 6).
+ *
+ * Returns empty result when focusId is null or the injection is not in the
+ * focus's active tree(s).
+ *
+ * `deliveryId` (6th argument): supplied => the reconciliation is narrowed to
+ * the targets the focus's ARM COVERED (see narrowToArmCoverage); omitted =>
+ * every target is judged, as before. Optional so a caller with no delivery in
+ * hand behaves exactly as it did.
+ */
+/**
+ * Which targets the focus's arm covers, resolved ONCE per reconciliation.
+ *
+ * Hoisted out of `authorTargetRestatements` so that function stays within its
+ * recorded size floor, and because the answer is a property of the DELIVERY and
+ * its focus -- not of any one tree the reconciliation happens to walk.
+ *
+ * `null` means JUDGE EVERYTHING: no delivery id was supplied, the read failed,
+ * or the arm could not be reasoned about. The gate never narrows what it judges
+ * on a question it could not answer.
+ */
+async function resolveArmCoverageForDelivery(deliveryId, deps) {
+    if (!deliveryId)
+        return null;
+    return await deps.readArmCoveredTargets(deliveryId);
+}
+/**
+ * Narrow an injection's targets to the ones the arm COVERED, recording the rest
+ * on `result`, and return the held set.
+ *
+ * A target added to an in-flight injection after the human armed -- serving no
+ * effect the arm covers -- is not owed work: it produces no shortfall, no hold
+ * and no re-work issue, and waits for the next arm. It is recorded rather than
+ * dropped, so what was set aside is visible on the delivery's record instead of
+ * merely absent from it.
+ *
+ * The caller applies this BEFORE the evidence-blindness check, deliberately: a
+ * set-aside target must not make the bundle look unjudgeable either. With every
+ * target recorded there is nothing left to judge, so the evidence question does
+ * not arise and the caller flips exactly as it would with no targets at all.
+ *
+ * Mutates `result` rather than returning a pair because the recorded set
+ * accumulates across trees, and threading an accumulator through the walk buys
+ * nothing over the one write.
+ */
+function narrowToArmCoverage(injectionNodeId, edges, coverage, result) {
+    const targets = edges
+        .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionNodeId)
+        .map((e) => e.toNodeId);
+    const { held, recorded, unclassified } = heldTargetsOrAll(targets, coverage);
+    if (recorded.length > 0) {
+        result.recordedTargetNodeIds = [...(result.recordedTargetNodeIds ?? []), ...recorded];
+    }
+    if (unclassified.length > 0) {
+        // The split was stale: the edge answered about a tree that did not yet
+        // carry these targets. They are judged (heldTargetsOrAll already put them
+        // in `held`); this line is so the race is visible rather than inferred
+        // from a target that is judged while the answer never mentioned it.
+        log.warn(`[verify] Arm coverage did not classify ${unclassified.length} target(s) the ` +
+            `reconciler resolved (${unclassified.join(', ')}) -- the split predates them. ` +
+            `Judging them, as a gate must when its own answer is stale.`);
+    }
+    return new Set(held);
+}
+/**
+ * The shortfall a reconciliation THROW leaves on one target -- or no shortfall at
+ * all: a judge that could not RUN (ModelUnavailable) judged nothing, not this
+ * target and not the targets after it, so the typed unavailability is rethrown
+ * whole and the engine holds the delivery as awaited. The 2026-09-23 park was
+ * three identical "de-restatement exited 1" rounds signed here. Any other throw
+ * is a reconciliation that ran but rendered nothing usable: asymmetric-safe, a
+ * shortfall -- we never flip an injection whose achievement we could not verify.
+ */
+function unjudgedTargetShortfall(err, nodeId, declaredStatement, question) {
+    if (isModelUnavailable(err)) {
+        recordSentQuestion(err, question);
+        throw err;
+    }
+    return {
+        nodeId,
+        declaredStatement,
+        achievedStatement: '(reconciliation failed)',
+        reason: `Reconciliation failed: ${err.message}`,
+    };
+}
+/**
+ * A target an active ruling honours (`ruledNodeIds`, verify/shortfalls/pre-judge-rulings.ts)
+ * with a declared future to honour: it is NOT sent to the judge. It is handed on
+ * as an unjudged shortfall carrying its declared statement, which the ruling pass
+ * that follows clears -- by the shared rule and the shared read -- into the same
+ * honoured record, fingerprint and `match` on the declared statement it would
+ * have produced after a model call. A target with no declared future is judged
+ * as before: there is nothing for a ruling to honour.
+ */
+function preRuledTarget(target, ruledNodeIds) {
+    const declared = target?.frtStatement?.trim() ?? '';
+    if (!target || declared === '' || !ruledNodeIds?.has(target.id.toLowerCase()))
+        return null;
+    const reason = 'Not sent to the judge: an active ruling honours this target at the judged commit.';
+    return { nodeId: target.id, declaredStatement: declared, achievedStatement: '(not judged: ruled)', reason };
+}
+/** The question each reconciliation that could not run was SENT, keyed by its thrown ModelUnavailable. */
+const sentQuestions = new WeakMap();
+/** Record the question a reconciliation that threw `err` was sent (sentQuestionOf reads it). */
+export function recordSentQuestion(err, question) {
+    sentQuestions.set(err, question);
+}
+/**
+ * The fingerprint of the question a thrown ModelUnavailable's reconciliation was
+ * sent (reconciliationQuestion), captured before its first model call -- or null
+ * when the throw did not come from a reconciliation that captured one.
+ */
+export function sentQuestionOf(err) {
+    return typeof err === 'object' && err !== null ? sentQuestions.get(err) ?? null : null;
+}
+/**
+ * The fingerprint of a reconciliation's question: the declared future ('' when
+ * none) of exactly the targets it SENDS to the judge -- a target an active
+ * ruling honours is not sent, so it is not part of the question
+ * (verify/effect-reconciliation/judge-question.ts judgedQuestionFingerprint). Pure.
+ */
+export function reconciliationQuestion(targets) {
+    return judgedQuestionFingerprint(Object.fromEntries(targets.map((t) => [t.nodeId, t.statement])));
+}
+/** The targets the reconciliation SENDS to the judge: the arm-held UDEs it targets, less those a ruling honours. Pure. */
+function targetsSentToJudge(injectionNodeId, edges, heldTargets, nodeById, ruledNodeIds) {
+    return edges
+        .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionNodeId && heldTargets.has(e.toNodeId))
+        .map((e) => nodeById.get(e.toNodeId))
+        .filter((t) => !!t && t.nodeType === 'undesired_effect' && !preRuledTarget(t, ruledNodeIds));
+}
+/**
+ * The targets a verify judge would judge for this injection -- the UDEs it
+ * targets that the arm covered, each with whether it declares a future --
+ * by the same tree walk and the same narrowing authorTargetRestatements uses,
+ * and with NO model call. [] when the injection is in no active tree of the focus.
+ */
+export async function listJudgedTargets(injectionNodeId, focusId, deps, deliveryId) {
+    if (!focusId)
+        return [];
+    const coverage = await resolveArmCoverageForDelivery(deliveryId, deps);
+    const treesResp = await deps.callApi('reality_tree_list', { focusId });
+    for (const tree of (treesResp.items ?? []).filter((t) => t.status === 'active')) {
+        const [nodesResp, edgesResp] = await Promise.all([
+            deps.callApi('reality_tree_node_list', { treeId: tree.id, status: 'active' }),
+            deps.callApi('reality_tree_edge_list', { treeId: tree.id }),
+        ]);
+        const nodeById = new Map((nodesResp.items ?? []).map((n) => [n.id, n]));
+        const injection = nodeById.get(injectionNodeId);
+        if (!injection || injection.nodeType !== 'injection')
+            continue;
+        const edges = edgesResp.items ?? [];
+        const held = narrowToArmCoverage(injectionNodeId, edges, coverage, { restatements: [], shortfalls: [] });
+        return edges
+            .filter((e) => e.edgeType === 'targets' && e.fromNodeId === injectionNodeId && held.has(e.toNodeId))
+            .map((e) => nodeById.get(e.toNodeId))
+            .filter((t) => !!t && t.nodeType === 'undesired_effect')
+            .map((t) => ({ nodeId: t.id, declared: (t.frtStatement?.trim() ?? '') !== '', statement: t.frtStatement?.trim() ?? '' }));
+    }
+    return [];
+}
+export async function authorTargetRestatements(injectionNodeId, focusId, evidence, deps, evidenceIncomplete = false, deliveryId, ruledNodeIds) {
+    const { callApi, reconcile } = deps;
+    const result = { restatements: [], shortfalls: [] };
+    if (!focusId)
+        return result;
+    const coverage = await resolveArmCoverageForDelivery(deliveryId, deps);
+    const treesResp = await callApi('reality_tree_list', { focusId });
+    const trees = (treesResp.items ?? []).filter((t) => t.status === 'active');
+    for (const tree of trees) {
+        const [nodesResp, edgesResp] = await Promise.all([
+            callApi('reality_tree_node_list', { treeId: tree.id, status: 'active' }),
+            callApi('reality_tree_edge_list', { treeId: tree.id }),
+        ]);
+        const nodes = nodesResp.items ?? [];
+        const edges = edgesResp.items ?? [];
+        const nodeById = new Map(nodes.map((n) => [n.id, n]));
+        const injection = nodeById.get(injectionNodeId);
+        if (!injection || injection.nodeType !== 'injection')
+            continue; // not in this tree
+        // The injection lives in THIS tree -- record the tree id so the caller can
+        // surface inward drift proposals (which key off the reality_tree id).
+        result.realityTreeId = tree.id;
+        // A GATE MUST NOT REPORT ITS OWN BLINDNESS AS A VERDICT -- nor its
+        // HALF-blindness. Detect an unjudgeable bundle BEFORE classifying: if there
+        // is at least one declared-DE target to judge but the evidence is either
+        // EMPTY (nothing the achieved DE can be authored from) or INCOMPLETE (the
+        // resolved range does not cover the delivery's recorded commits, so a
+        // verdict would judge only part of the work), decline to classify. Return
+        // the instrument-fault signal instead of running the model (which, blind or
+        // half-blind, would manufacture a shortfall). With no targets there is
+        // nothing to judge -- fall through and let the caller flip as before.
+        // Narrow to what the arm covered BEFORE anything is judged; see
+        // splitTargetsByCoverage.
+        const heldTargets = narrowToArmCoverage(injectionNodeId, edges, coverage, result);
+        const sent = targetsSentToJudge(injectionNodeId, edges, heldTargets, nodeById, ruledNodeIds);
+        if (sent.length > 0 && (judgeEvidenceIsEmpty(evidence) || evidenceIncomplete)) {
+            result.evidenceUnavailable = true;
+            return result; // no verdict rendered; caller holds the gate + escalates
+        }
+        // The question as it is about to be sent, captured BEFORE the first call: a judge
+        // that cannot run is held against what it was asked, not a later edit.
+        const question = reconciliationQuestion(sent.map((t) => ({ nodeId: t.id, statement: t.frtStatement?.trim() ?? '' })));
+        for (const e of edges) {
+            if (e.edgeType !== 'targets' || e.fromNodeId !== injectionNodeId)
+                continue;
+            if (!heldTargets.has(e.toNodeId))
+                continue; // recorded after the arm: not judged
+            const target = nodeById.get(e.toNodeId);
+            if (!target || target.nodeType !== 'undesired_effect')
+                continue;
+            const ruled = preRuledTarget(target, ruledNodeIds);
+            if (ruled) {
+                result.shortfalls.push(ruled);
+                continue;
+            }
+            // The DECLARED desired effect is the preserved frt_statement (intent of
+            // record). When none was ever authored there is nothing to fall short of.
+            const declared = target.frtStatement && target.frtStatement.trim() !== ''
+                ? target.frtStatement.trim()
+                : null;
+            // The node's ORIGINAL claim for inward-drift framing: the declared DE if
+            // present, else the UDE statement (the assertion reality would contradict).
+            const originalClaim = declared ?? target.statement;
+            let judgment;
+            try {
+                judgment = await reconcile({
+                    declaredStatement: declared ?? '', evidence, reviewCitations: evidence.reviewCitationsByNode?.[target.id.toLowerCase()],
+                });
+            }
+            catch (err) {
+                result.shortfalls.push(unjudgedTargetShortfall(err, target.id, declared ?? target.statement, question));
+                continue;
+            }
+            const classification = declared
+                ? judgment.classification
+                // No declared intent to measure against -> the evidence-derived outcome
+                // stands on its own as a match (cannot fall short of nothing).
+                : 'match';
+            if (classification === 'shortfall') {
+                result.shortfalls.push({
+                    nodeId: target.id,
+                    declaredStatement: declared ?? target.statement,
+                    achievedStatement: judgment.achievedStatement,
+                    reason: judgment.divergenceReason
+                        ?? 'Achieved outcome falls short of the declared desired effect.',
+                    ...(judgment.diffCitation ? { diffCitation: judgment.diffCitation } : {}),
+                });
+                continue;
+            }
+            const entry = {
+                nodeId: target.id,
+                statement: judgment.achievedStatement,
+                classification,
+                originalClaim,
+            };
+            if (classification === 'legitimate_divergence' && judgment.divergenceReason) {
+                entry.divergenceReason = judgment.divergenceReason;
+            }
+            result.restatements.push(entry);
+        }
+        return result; // injection found and processed
+    }
+    return result;
+}
+//# sourceMappingURL=verify-restatement.js.map

package/dist/verify/effect-reconciliation/verify-restatement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-restatement.js","sourceRoot":"","sources":["../../../src/verify/effect-reconciliation/verify-restatement.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,qIAAqI;AACrI,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EACL,gBAAgB,GAEjB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EACL,oBAAoB,GAKrB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;AAiH3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;;;;;;;;;;GAUG;AACH,KAAK,UAAU,6BAA6B,CAC1C,UAAqC,EACrC,IAAiE;IAEjE,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAC7B,OAAO,MAAM,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAS,mBAAmB,CAC1B,eAAuB,EACvB,KAAgC,EAChC,QAA0C,EAC1C,MAA8B;IAE9B,MAAM,OAAO,GAAG,KAAK;SAClB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,KAAK,eAAe,CAAC;SAC3E,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC1B,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC7E,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,CAAC,qBAAqB,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,qBAAqB,IAAI,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC;IACxF,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,uEAAuE;QACvE,0EAA0E;QAC1E,uEAAuE;QACvE,oEAAoE;QACpE,GAAG,CAAC,IAAI,CACN,0CAA0C,YAAY,CAAC,MAAM,iBAAiB;YAC9E,wBAAwB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,gCAAgC;YAC/E,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;AACvB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,uBAAuB,CAAC,GAAY,EAAE,MAAc,EAAE,iBAAyB,EAAE,QAAgB;IACxG,IAAI,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5B,kBAAkB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAClC,MAAM,GAAG,CAAC;IACZ,CAAC;IACD,OAAO;QACL,MAAM;QACN,iBAAiB;QACjB,iBAAiB,EAAE,yBAAyB;QAC5C,MAAM,EAAE,0BAA2B,GAAa,CAAC,OAAO,EAAE;KAC3D,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,cAAc,CAAC,MAAkC,EAAE,YAA6C;IACvG,MAAM,QAAQ,GAAG,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACpD,IAAI,CAAC,MAAM,IAAI,QAAQ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3F,MAAM,MAAM,GAAG,mFAAmF,CAAC;IACnG,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,iBAAiB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,EAAE,CAAC;AAC9G,CAAC;AAED,0GAA0G;AAC1G,MAAM,aAAa,GAAG,IAAI,OAAO,EAAkB,CAAC;AAEpD,gGAAgG;AAChG,MAAM,UAAU,kBAAkB,CAAC,GAAW,EAAE,QAAgB;IAC9D,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,GAAY;IACzC,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AACzF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAA6D;IAClG,OAAO,yBAAyB,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACpG,CAAC;AAED,0HAA0H;AAC1H,SAAS,kBAAkB,CACzB,eAAuB,EACvB,KAAgC,EAChC,WAAgC,EAChC,QAA6C,EAC7C,YAA6C;IAE7C,OAAO,KAAK;SACT,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,KAAK,eAAe,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;SAC1G,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;SACpC,MAAM,CAAC,CAAC,CAAC,EAAuB,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,kBAAkB,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AACtH,CAAC;AAUD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,eAAuB,EACvB,OAAsB,EACtB,IAA6E,EAC7E,UAA0B;IAE1B,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACxB,MAAM,QAAQ,GAAG,MAAM,6BAA6B,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IACvE,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAA0B,mBAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAChG,KAAK,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,EAAE,CAAC;QAChF,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC/C,IAAI,CAAC,OAAO,CAAmB,wBAAwB,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;YAC/F,IAAI,CAAC,OAAO,CAAmB,wBAAwB,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC;SAC9E,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAyB,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAChG,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,QAAQ,KAAK,WAAW;YAAE,SAAS;QAC/D,MAAM,KAAK,GAAqB,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;QACtD,MAAM,IAAI,GAAG,mBAAmB,CAAC,eAAe,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACzG,OAAO,KAAK;aACT,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,KAAK,eAAe,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;aACnG,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;aACpC,MAAM,CAAC,CAAC,CAAC,EAAuB,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,kBAAkB,CAAC;aAC5E,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;IAC9H,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,eAAuB,EACvB,OAAsB,EACtB,QAAwB,EACxB,IAAkC,EAClC,kBAAkB,GAAG,KAAK,EAC1B,UAA0B,EAC1B,YAAkC;IAElC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IACpC,MAAM,MAAM,GAA2B,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC5E,IAAI,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC;IAC5B,MAAM,QAAQ,GAAG,MAAM,6BAA6B,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAEvE,MAAM,SAAS,GAAG,MAAM,OAAO,CAA0B,mBAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC3F,MAAM,KAAK,GAAG,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;IAE3E,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC/C,OAAO,CAAmB,wBAAwB,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;YAC1F,OAAO,CAAmB,wBAAwB,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC;SACzE,CAAC,CAAC;QACH,MAAM,KAAK,GAAqB,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;QACtD,MAAM,KAAK,GAAqB,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAyB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAE9E,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,QAAQ,KAAK,WAAW;YAAE,SAAS,CAAC,mBAAmB;QAEnF,2EAA2E;QAC3E,sEAAsE;QACtE,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC,EAAE,CAAC;QAE/B,mEAAmE;QACnE,4EAA4E;QAC5E,yEAAyE;QACzE,0EAA0E;QAC1E,sEAAsE;QACtE,0EAA0E;QAC1E,4EAA4E;QAC5E,uEAAuE;QACvE,sEAAsE;QACtE,gEAAgE;QAChE,0BAA0B;QAC1B,MAAM,WAAW,GAAG,mBAAmB,CAAC,eAAe,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAElF,MAAM,IAAI,GAAG,kBAAkB,CAAC,eAAe,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC7F,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,IAAI,kBAAkB,CAAC,EAAE,CAAC;YAC9E,MAAM,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAClC,OAAO,MAAM,CAAC,CAAC,yDAAyD;QAC1E,CAAC;QAED,kFAAkF;QAClF,uEAAuE;QACvE,MAAM,QAAQ,GAAG,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QAEtH,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,KAAK,eAAe;gBAAE,SAAS;YAC3E,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;gBAAE,SAAS,CAAC,qCAAqC;YACjF,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YACxC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,KAAK,kBAAkB;gBAAE,SAAS;YAChE,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YACnD,IAAI,KAAK,EAAE,CAAC;gBAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAAC,SAAS;YAAC,CAAC;YAEvD,wEAAwE;YACxE,0EAA0E;YAC1E,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE;gBACvE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE;gBAC5B,CAAC,CAAC,IAAI,CAAC;YACT,yEAAyE;YACzE,4EAA4E;YAC5E,MAAM,aAAa,GAAG,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC;YAEnD,IAAI,QAA2B,CAAC;YAChC,IAAI,CAAC;gBACH,QAAQ,GAAG,MAAM,SAAS,CAAC;oBACzB,iBAAiB,EAAE,QAAQ,IAAI,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,CAAC,qBAAqB,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;iBACxH,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,QAAQ,IAAI,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;gBACxG,SAAS;YACX,CAAC;YAED,MAAM,cAAc,GAAyB,QAAQ;gBACnD,CAAC,CAAC,QAAQ,CAAC,cAAc;gBACzB,wEAAwE;gBACxE,+DAA+D;gBAC/D,CAAC,CAAC,OAAO,CAAC;YAEZ,IAAI,cAAc,KAAK,WAAW,EAAE,CAAC;gBACnC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC;oBACrB,MAAM,EAAE,MAAM,CAAC,EAAE;oBACjB,iBAAiB,EAAE,QAAQ,IAAI,MAAM,CAAC,SAAS;oBAC/C,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;oBAC7C,MAAM,EAAE,QAAQ,CAAC,gBAAgB;2BAC5B,8DAA8D;oBACnE,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC1E,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YAED,MAAM,KAAK,GAAsB;gBAC/B,MAAM,EAAE,MAAM,CAAC,EAAE;gBACjB,SAAS,EAAE,QAAQ,CAAC,iBAAiB;gBACrC,cAAc;gBACd,aAAa;aACd,CAAC;YACF,IAAI,cAAc,KAAK,uBAAuB,IAAI,QAAQ,CAAC,gBAAgB,EAAE,CAAC;gBAC5E,KAAK,CAAC,gBAAgB,GAAG,QAAQ,CAAC,gBAAgB,CAAC;YACrD,CAAC;YACD,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,MAAM,CAAC,CAAC,gCAAgC;IACjD,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/verify/engine/reconciliation-step.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The reconciliation step of one verify dispatch: judge the injection's targets
+ * against the evidence, unless the outcome is already decided.
+ *
+ * Two things decide it without the model:
+ *   - a target an active ruling honours is not sent to the judge
+ *     (verify/shortfalls/pre-judge-rulings.ts, carried in `preRuled`);
+ *   - a standing hold of a kind retrying cannot cure, judged against the same
+ *     input, is re-held with no call at all
+ *     (verify/outcome-routing/incurable-model-hold.ts).
+ * The judge reads the change from a checkout pinned to the judged commit (or,
+ * with no judged commit, the focus HEAD at dispatch), made here and removed when
+ * the step ends (verify/effect-reconciliation/judge-workspace.ts), and is handed
+ * the approving review's citations per target as starting points. With no
+ * checkout the judge is not called and the dispatch is held.
+ * A judge that could not RUN is returned as an awaited hold -- carrying the input
+ * it was judged against when retrying cannot cure it -- and any other throw is a
+ * whole-injection shortfall (verify/outcome-routing/verification-model-unavailable-hold.ts
+ * classifyReconciliationThrow).
+ *
+ * @module verify/engine/reconciliation-step
+ */
+import type { ModelUnavailableDetail } from '../../queries/delivery-gate-state/verify-own-holds.js';
+import type { PendingVerification } from '../../queries/verification/verification.js';
+import type { TargetRestatement, TargetShortfall } from '../effect-reconciliation/verify-restatement.js';
+import type { VerifyEvidence } from '../effect-reconciliation/verify-reconciliation.js';
+import { type PreJudgeRulings } from '../shortfalls/pre-judge-rulings.js';
+import type { VerificationDeps } from './verification-deps.js';
+/** What the reconciliation left for the engine to route. */
+export interface ReconciliationStep {
+    restatements: TargetRestatement[];
+    shortfalls: TargetShortfall[];
+    realityTreeId: string | undefined;
+    /** The reconciliation declined to judge a blind or half-blind bundle (an instrument fault, not a verdict). */
+    evidenceUnavailable: boolean;
+    /** The targets the arm did not cover; null when no reconciliation rendered. */
+    recordedTargetNodeIds: string[] | null;
+    /** The judge could not run: awaited, not judged. */
+    modelUnavailableHold: ModelUnavailableDetail | null;
+}
+/** The step a dispatch that reused its parked shortfall takes: nothing reconciled. */
+export declare const NOT_RECONCILED: ReconciliationStep;
+/** Reconcile the injection's targets, unless the outcome is already decided (module header). Never throws. */
+export declare function runReconciliationStep(v: PendingVerification, judgedSha: string | null, evidence: VerifyEvidence, evidenceIncomplete: boolean, preRuled: PreJudgeRulings, deps: ReconciliationStepDeps): Promise<ReconciliationStep>;
+/** The collaborators the step reads. */
+export type ReconciliationStepDeps = Pick<VerificationDeps, 'authorTargetRestatements' | 'readDeliveryGateRecord' | 'resolveDeliveryCommitSet' | 'createJudgeWorkspace' | 'resolveVerificationCwd' | 'listJudgedTargets'>;
+//# sourceMappingURL=reconciliation-step.d.ts.map

package/dist/verify/engine/reconciliation-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-step.d.ts","sourceRoot":"","sources":["../../../src/verify/engine/reconciliation-step.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AACpG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mDAAmD,CAAC;AAKxF,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACjG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,4DAA4D;AAC5D,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,8GAA8G;IAC9G,mBAAmB,EAAE,OAAO,CAAC;IAC7B,+EAA+E;IAC/E,qBAAqB,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACvC,oDAAoD;IACpD,oBAAoB,EAAE,sBAAsB,GAAG,IAAI,CAAC;CACrD;AAED,sFAAsF;AACtF,eAAO,MAAM,cAAc,EAAE,kBAG5B,CAAC;AAEF,8GAA8G;AAC9G,wBAAsB,qBAAqB,CACzC,CAAC,EAAE,mBAAmB,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,QAAQ,EAAE,cAAc,EACxB,kBAAkB,EAAE,OAAO,EAC3B,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAgC7B;AAED,wCAAwC;AACxC,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,gBAAgB,EAChB,0BAA0B,GAAG,wBAAwB,GAAG,0BAA0B,GAChF,sBAAsB,GAAG,wBAAwB,GAAG,mBAAmB,CAC1E,CAAC"}

package/dist/verify/engine/reconciliation-step.js

@@ -0,0 +1,70 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/engine/reconciliation-step.test.ts
+// PINNED-BY-END
+import { reconciliationQuestion, sentQuestionOf } from '../effect-reconciliation/verify-restatement.js';
+import { classifyReconciliationThrow } from '../outcome-routing/verification-model-unavailable-hold.js';
+import { readJudgedInput, resolveStandingIncurableHold, withJudgedInput } from '../outcome-routing/incurable-model-hold.js';
+import { reviewCitationsByNode } from '../shortfalls/pre-judge-rulings.js';
+/** The step a dispatch that reused its parked shortfall takes: nothing reconciled. */
+export const NOT_RECONCILED = {
+    restatements: [], shortfalls: [], realityTreeId: undefined, evidenceUnavailable: false,
+    recordedTargetNodeIds: null, modelUnavailableHold: null,
+};
+/** Reconcile the injection's targets, unless the outcome is already decided (module header). Never throws. */
+export async function runReconciliationStep(v, judgedSha, evidence, evidenceIncomplete, preRuled, deps) {
+    const readInput = () => readJudgedInput(v, judgedSha, preRuled.fingerprint, () => readReconciliationQuestion(v, preRuled, deps), deps);
+    const standing = await resolveStandingIncurableHold(v, readInput, deps);
+    if (standing)
+        return { ...NOT_RECONCILED, modelUnavailableHold: standing };
+    const workspace = openJudgeWorkspace(v, judgedSha, evidence.range, deps);
+    try {
+        const judged = {
+            ...evidence,
+            ...(workspace ? { workspace: { checkoutPath: workspace.checkoutPath, basePath: workspace.basePath, sourceRepo: workspace.sourceRepo, sha: workspace.sha, range: workspace.range } } : {}),
+            reviewCitationsByNode: reviewCitationsByNode(preRuled.rulings),
+        };
+        const reconciled = await deps.authorTargetRestatements(v.injectionNodeId, v.focusId, judged, evidenceIncomplete, v.deliveryId, preRuled.ruledNodeIds);
+        return {
+            restatements: reconciled.restatements,
+            shortfalls: reconciled.shortfalls,
+            realityTreeId: reconciled.realityTreeId,
+            evidenceUnavailable: reconciled.evidenceUnavailable === true,
+            recordedTargetNodeIds: reconciled.recordedTargetNodeIds ?? [],
+            modelUnavailableHold: null,
+        };
+    }
+    catch (err) {
+        const failure = classifyReconciliationThrow(err, v.injectionNodeId);
+        // Held against the question the judge was SENT (captured before the call), never one re-read after it.
+        const sent = sentQuestionOf(err);
+        const readSentInput = () => readJudgedInput(v, judgedSha, preRuled.fingerprint, async () => sent, deps);
+        if (failure.hold)
+            return { ...NOT_RECONCILED, modelUnavailableHold: await withJudgedInput(failure.hold, readSentInput) };
+        return { ...NOT_RECONCILED, shortfalls: failure.shortfalls };
+    }
+    finally {
+        workspace?.dispose();
+    }
+}
+/**
+ * The fingerprint of the question the reconciliation would ask NOW: the declared
+ * future of every target it would send -- not those an active ruling honours
+ * (verify-restatement.ts reconciliationQuestion, the same identity the failed call
+ * recorded) -- or null when the targets cannot be read. Never throws.
+ */
+async function readReconciliationQuestion(v, preRuled, deps) {
+    if (!v.injectionNodeId)
+        return reconciliationQuestion([]);
+    try {
+        const targets = await deps.listJudgedTargets(v.injectionNodeId, v.focusId, v.deliveryId);
+        return reconciliationQuestion(targets.filter((t) => !(t.declared && preRuled.ruledNodeIds.has(t.nodeId.toLowerCase()))));
+    }
+    catch {
+        return null;
+    }
+}
+/** The judge's pinned checkout (the judged commit, else the repo HEAD now), or null when none could be made. */
+function openJudgeWorkspace(v, judgedSha, range, deps) {
+    return deps.createJudgeWorkspace(deps.resolveVerificationCwd(v), v.deliveryId, judgedSha, range ?? '');
+}
+//# sourceMappingURL=reconciliation-step.js.map

package/dist/verify/engine/reconciliation-step.js.map

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

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

@@ -0,0 +1,83 @@
+import type { PendingVerification } from '../../queries/verification/verification.js';
+import type { StrategyResult } from '../deterministic-gate/verification-deterministic.js';
+import type { VerificationDeps } from './verification-deps.js';
+import { type GateRunRegistration } from '../gate-verdicts/gate-run-registry.js';
+import { type InstrumentFaultHold } from '../attribution/verification-attribution.js';
+/** How a delivery is judged. */
+export interface JudgeOptions {
+    /** The verdict already recorded for the commit the delivery is judged on: taken instead of running the strategy. */
+    reused?: StrategyResult;
+    /**
+     * Asked once a run's verdict is rendered and recorded: false means the delivery
+     * left verify while the run was in flight, so the verdict routes nothing.
+     */
+    stillInVerify?: () => Promise<boolean>;
+}
+/** What judging rendered, before any per-delivery routing. */
+export interface JudgedDelivery {
+    result: StrategyResult;
+    /** Set when the run rendered no verdict about the work (blind, unattributable, timed out). */
+    evidenceUnavailableHold: InstrumentFaultHold | null;
+    /** False when the delivery left verify while its run was in flight: route nothing for it. */
+    routes: boolean;
+}
+/**
+ * Judge one delivery: run its strategy -- or take the recorded verdict -- then,
+ * for a deterministic run, attribute a failure and record the commit's verdict.
+ *
+ * Attribution (verify/attribution/verification-attribution.ts): a failed HEAD run whose reds
+ * ALL pre-exist on the focus base introduced no regression and is demoted to
+ * 'passed' here, BEFORE the caller's pass path, so the demotion feeds injection
+ * retirement; a blind or timed-out run returns the instrument-fault hold instead,
+ * and no baseline leaves the outcome unchanged (all failures gate).
+ *
+ * The verdict is recorded after attribution and before the per-delivery pass
+ * path can demote it, because the gate verdict belongs to the judged COMMIT, not
+ * to this delivery. A reused verdict is already attributed and already recorded,
+ * so neither step runs for it.
+ */
+export declare function judgeDelivery(v: PendingVerification, deps: VerificationDeps, runStrategy: () => Promise<StrategyResult>, opts?: JudgeOptions): Promise<JudgedDelivery>;
+/** Routes one delivery end to end (verification-engine runVerificationForDelivery). */
+export type DeliveryVerifier = (v: PendingVerification, deps: VerificationDeps, opts: JudgeOptions) => Promise<StrategyResult>;
+/**
+ * Dispatch one DEFAULT-ON candidate (module doc): serialized with every other
+ * candidate on its focus, it starts only when its delivery is still in verify,
+ * takes the verdict recorded for the focus HEAD when one exists, and runs the
+ * gate otherwise; the delivery is routed by `verify` unless it left verify while
+ * the run was in flight. A routed result is noted on the default-on re-run guards
+ * (the commit it was judged on, a failed sha, or an un-mark when no checkout could
+ * be made). Returns null when nothing was routed -- not started, or left verify
+ * mid-run -- and drops the run mark, so a return to verify is selected again.
+ */
+export declare function dispatchDefaultOnCandidate(v: PendingVerification, deps: VerificationDeps, verify: DeliveryVerifier): Promise<StrategyResult | null>;
+/**
+ * Durably remove the verdict each selected EXPLICIT candidate's previous run
+ * recorded (module doc), for every candidate at once and before any of them waits
+ * on the semaphore; returns, per candidate, whether it may start this tick. A
+ * default-on candidate always may. Each removed here is named a fresh run id first, which its verdict is
+ * recorded under (verify/gate-verdicts/explicit-run-ledger.ts). One a recorded verdict already
+ * judges is not removed here: no run replaces its verdict, and its dispatch removes
+ * it -- naming its run then -- only once it is about to route a verdict. One whose
+ * removal did not land may not start: its registration ends now, so it holds no
+ * routing wait, and its re-arm is dropped, so the next tick selects it again.
+ * Meanwhile this process reads "no verdict" for it (its registration forgot the
+ * older one), so routing holds until a run renders one.
+ */
+export declare function invalidateSupersededExplicitVerdicts(selected: readonly PendingVerification[], explicitIds: ReadonlySet<string>, registrations: readonly GateRunRegistration[], deps: VerificationDeps): Promise<boolean[]>;
+/**
+ * Dispatch one EXPLICIT-METHOD row (module doc): it starts only when its delivery
+ * is still in verify, and a delivery that left verify while its run was in flight
+ * is routed nothing -- no outcome recorded, no re-work or shortfall feedback --
+ * though a per-commit verdict its run rendered is still recorded. A deterministic
+ * row is serialized on its focus and takes the verdict recorded for the focus HEAD
+ * under its own gate in place of a run; a failure already fed back at that commit
+ * routes nothing, and a removal deferred at selection is made before a verdict --
+ * that recorded one, or a run's -- is routed.
+ * Returns null when nothing was routed; the row is selected again on a later tick
+ * while it stays pending. A row the explicit re-arm scan selected keeps no durable
+ * pending outcome, so a dispatch that routes nothing (null, or a throw) releases
+ * its re-arm mark: the HEAD it was selected for is still unjudged
+ * (verify/run-selection/explicit-rearm.ts). A reused verdict is a routed result.
+ */
+export declare function dispatchExplicitCandidate(v: PendingVerification, deps: VerificationDeps, verify: DeliveryVerifier): Promise<StrategyResult | null>;
+//# sourceMappingURL=verification-commit-sharing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verification-commit-sharing.d.ts","sourceRoot":"","sources":["../../../src/verify/engine/verification-commit-sharing.ts"],"names":[],"mappings":"AAkHA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAC1F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAqB,KAAK,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAEpG,OAAO,EAAiC,KAAK,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAyBrH,gCAAgC;AAChC,MAAM,WAAW,YAAY;IAC3B,oHAAoH;IACpH,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CACxC;AAED,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,8FAA8F;IAC9F,uBAAuB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACpD,6FAA6F;IAC7F,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CACjC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,gBAAgB,EACtB,WAAW,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,EAC1C,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,cAAc,CAAC,CAoBzB;AAmED,uFAAuF;AACvF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAqN/H;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAC9C,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAmBhC;AAsBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,SAAS,mBAAmB,EAAE,EACxC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,SAAS,mBAAmB,EAAE,EAC7C,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,OAAO,EAAE,CAAC,CAYpB;AAsBD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,yBAAyB,CAC7C,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAiBhC"}