@telora/daemon 0.24.29 → 0.24.38

package/dist/tower/tower-escalation-shortfall.d.ts

@@ -0,0 +1,158 @@
+import type { ReviewVerdictRecord } from '../queries/focus-review/review-criterion-verdicts.js';
+import type { ShortfallNodeBinding } from '../queries/reality-tree/shortfall-node-bindings.js';
+/** The act the supervisor rules through (telora_agent action). */
+export declare const SHORTFALL_RULING_ACT = "escalation_rule_shortfall";
+/** How many verdict-bearing reviews under the arm the record reads. */
+export declare const SHORTFALL_REVIEWS_READ = 10;
+/** A gate verdict gate_state records. */
+export interface ShortfallGateVerdict {
+    outcome: 'passed' | 'failed';
+    sha: string;
+    failedStage: string | null;
+    /** The gate_state key that carried it. */
+    from: string;
+}
+/** One shortfall node, what names it, and what the tree says binds a verdict to it. */
+export interface ShortfallNode {
+    nodeId: string;
+    /** The outcome the injection declares for it (from the shortfall judgment), when recorded. */
+    declared: string | null;
+    namedBy: string[];
+    /** Whether the tree read found it among the focus's active nodes (false also when the read failed). */
+    inTree: boolean;
+    /** Its declared future (frt_statement) as the tree holds it; null when it declares none or was not found. */
+    future: string | null;
+    /** The active effects it is a `sufficient` cause of (N -> E). */
+    sufficientEffectIds: string[];
+}
+/** How a review verdict binds to a shortfall node (module header, THE BINDING RULE). */
+export type ShortfallBindingVia = 'tree_verdict_on_node' | 'declared_future' | 'sufficient_effect';
+/** One review verdict the record shows. */
+export interface ShortfallReviewVerdict {
+    /** The criterion verbatim, as the review named it: what the act is passed. */
+    criterion: string;
+    nodeId: string | null;
+    /** A tree verdict (keyed to nodeId), or a verdict on one of this delivery's declared criteria. */
+    source: 'tree' | 'delivery_criterion';
+    verdict: 'met' | 'not_met' | 'excused';
+    evidence: string[];
+    /** True when only criterion_verdicts carried it (the summary section did not): no evidence is readable. */
+    storedOnly: boolean;
+    /** True when the stored row and the summary disagree on this verdict. */
+    disagrees: boolean;
+    /** The shortfall nodes it binds to, and how; [] when it binds none (shown, never counted). */
+    binds: Array<{
+        nodeId: string;
+        via: ShortfallBindingVia;
+    }>;
+}
+/** One verdict-bearing review under the arm. */
+export interface ShortfallReview {
+    reviewId: string;
+    completedAt: string;
+    outcome: string;
+    reviewedSha: string | null;
+    verdicts: ShortfallReviewVerdict[];
+}
+/** What the supervisor is shown about a delivery-anchored escalation's shortfall. */
+export interface ShortfallRecord {
+    deliveryId: string;
+    deliveryName: string;
+    judgedCommit: {
+        sha: string;
+        source: 'judged_commit' | 'shortfall_reconciliation';
+    } | null;
+    /** The verdict about the judged commit (a failed one wins); null when none is about it. */
+    gateVerdict: ShortfallGateVerdict | null;
+    /** Verdicts gate_state carries about OTHER commits (shown, never counted). */
+    otherCommitVerdicts: ShortfallGateVerdict[];
+    nodes: ShortfallNode[];
+    /** The delivery's own acceptance criteria, verbatim. */
+    deliveryCriteria: string[];
+    /** Newest first; [] when none (or unreadable: see reviewsReadable). */
+    reviews: ShortfallReview[];
+    reviewsReadable: boolean;
+    /** False when the tree read that binds verdicts to the nodes failed. */
+    bindingsReadable: boolean;
+}
+/** One node the standing supports ruling met, on the ONE verdict bound to it. */
+export interface ShortfallRuling {
+    nodeId: string;
+    criterion: string;
+    reviewId: string;
+    evidence: string[];
+    via: ShortfallBindingVia;
+    /** The tree node the bound verdict is keyed to (the node itself, or the effect it sustains); null for a declared criterion. */
+    verdictNodeId: string | null;
+}
+/** What the standing says, and on what. */
+export type ShortfallStanding = {
+    standing: 'rule';
+    rulings: ShortfallRuling[];
+    unasked: string[];
+} | {
+    standing: 'defer';
+    reasons: string[];
+    unasked: string[];
+};
+/** Pure: the judged commit and the verdicts about it (module header). */
+export declare function judgedGateOf(gateState: unknown): Pick<ShortfallRecord, 'judgedCommit' | 'gateVerdict' | 'otherCommitVerdicts'>;
+/** Pure: the node ids a filing's structured shortfall-ruling ask names (metadata.human_act.shortfall_ruling.node_ids), tolerantly. */
+export declare function filingShortfallNodeIds(metadata: Record<string, unknown>): string[];
+/** How a node the filing's structured ask names is labelled in namedBy. */
+export declare const NAMED_BY_FILING = "the filing";
+/** Pure: the shortfall nodes gate_state and the filing name, each with what names it. */
+export declare function shortfallNodesOf(gateState: unknown, metadata: Record<string, unknown>): ShortfallNode[];
+/** Pure: the shortfall nodes a verdict binds to, by THE BINDING RULE (module header). */
+export declare function bindsOf(v: {
+    criterion: string;
+    nodeId: string | null;
+}, nodes: readonly ShortfallNode[]): ShortfallReviewVerdict['binds'];
+/**
+ * Pure: one review's verdicts the record shows -- tree verdicts that bind a
+ * shortfall node, and verdicts on this delivery's declared criteria (each
+ * carrying the nodes it binds, possibly none).
+ */
+export declare function shortfallReviewOf(r: ReviewVerdictRecord, nodes: readonly ShortfallNode[], deliveryKeys: ReadonlySet<string>): ShortfallReview;
+/** What the record is built from. */
+export interface ShortfallRecordInput {
+    delivery: {
+        id: string;
+        name: string;
+        gateState: unknown;
+        acceptanceCriteria: string | null;
+    };
+    metadata: Record<string, unknown>;
+    /** The focus's verdict-bearing reviews under the arm, newest first; null when the read failed. */
+    reviews: readonly ReviewVerdictRecord[] | null;
+    /** The tree's bindings of the shortfall nodes (queries/reality-tree/shortfall-node-bindings.ts); null when the read failed. */
+    bindings: readonly ShortfallNodeBinding[] | null;
+}
+/** Pure: the shortfall nodes with what the tree read says binds a verdict to each. */
+export declare function withBindings(nodes: readonly ShortfallNode[], bindings: readonly ShortfallNodeBinding[] | null): ShortfallNode[];
+/** Pure: the shortfall record. */
+export declare function buildShortfallRecord(input: ShortfallRecordInput): ShortfallRecord;
+/** Pure: the act text a filing's structured human act names (metadata.human_act.act), or null. */
+export declare function filingActOf(metadata: Record<string, unknown>): string | null;
+/** What the excusal check reads: the ask (helpNeeded) and the filing's structured act. */
+export interface ShortfallAsk {
+    helpNeeded: string | null;
+    /** metadata.human_act.act (filingActOf); null or absent when the filing names no structured act. */
+    act?: string | null;
+}
+/** Pure: whether the text asks to EXCUSE or waive a criterion (module header, DECISION). */
+export declare function askExcuses(helpNeeded: string | null): boolean;
+/**
+ * Pure: the nodes this ask is a ruling on (module header, THE RULING SCOPE) --
+ * the filing's structured nodes when it names any, else every recorded node --
+ * and the recorded nodes outside that scope (shown, never counted).
+ */
+export declare function rulingScopeOf(record: ShortfallRecord): {
+    scope: ShortfallNode[];
+    unasked: string[];
+};
+/** Pure: whether the record supports the supervisor's shortfall ruling (module header). */
+export declare function computeShortfallStanding(record: ShortfallRecord, ask: ShortfallAsk): ShortfallStanding;
+/** Pure: the shortfall section of the escalation prompt. */
+export declare function renderShortfallSection(record: ShortfallRecord, standing: ShortfallStanding): string[];
+//# sourceMappingURL=tower-escalation-shortfall.d.ts.map

package/dist/tower/tower-escalation-shortfall.d.ts.map

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

package/dist/tower/tower-escalation-shortfall.js

@@ -0,0 +1,452 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/state-cascade/failed-verdict-stranded-filing.test.ts,
+//   packages/daemon/src/tower/tower-escalation-gather.test.ts,
+//   packages/daemon/src/tower/tower-escalation-io-cases.test.ts,
+//   packages/daemon/src/tower/tower-escalation-prompt.test.ts,
+//   packages/daemon/src/verify/shortfalls/shortfall-park-escalation.test.ts
+// PINNED-BY-END
+/**
+ * THE SHORTFALL RECORD the Tower supervisor's escalation prompt shows for a
+ * delivery-anchored escalation, and the STANDING it computes from it: whether
+ * the record supports the supervisor ruling the delivery's verify-shortfall
+ * nodes met (telora_agent action "escalation_rule_shortfall") or does not, so
+ * it defers.
+ *
+ * WHY. A delivery can sit parked on a verify shortfall whose node a review
+ * under the current arm has already judged met, with evidence, at a commit the
+ * gate passed -- waiting on an operator to write down what the record already
+ * says (the shape of the io case cd32119b; fixture
+ * testing/fixtures/tower-shortfall-cd32119b.ts). A ruling admitted only on a
+ * passing gate verdict and a met-with-evidence review does not lower the bar;
+ * this module puts that record in front of the supervisor and says, definitely,
+ * whether it holds.
+ *
+ * THE RECORD (pure, from what the gathering read; tower-escalation-gather.ts):
+ *   - the JUDGED COMMIT: gate_state.verificationHistory.judgedCommit.sha, or --
+ *     only when no judged commit is stamped at all -- the live
+ *     shortfallReconciliation's gate-verdict sha (the server gate's fallback,
+ *     product-api supervisor-shortfall-ruling-evidence.ts evaluateGateEvidence);
+ *   - its GATE VERDICT: every verdict gate_state carries about exactly that sha
+ *     (judgedCommit, shortfallReconciliation, verification,
+ *     evidenceUnavailable); any failed one wins over a passed one;
+ *   - the SHORTFALL NODES: the standing park, the last (or live) shortfall
+ *     judgment, and the filing's structured metadata.human_act.shortfall_ruling
+ *     .node_ids (read tolerantly: absent on most filings);
+ *   - per shortfall node, what the reality tree says binds a verdict to it: its
+ *     declared future (frt_statement) and the effects it is an ACTIVE
+ *     `sufficient` cause of (queries/reality-tree/shortfall-node-bindings.ts);
+ *   - the REVIEW VERDICTS under the current arm, newest first, that are tree
+ *     verdicts on those nodes or on those effects, or verdicts on this
+ *     delivery's own acceptance criteria, each with its verdict, evidence
+ *     references, criterion text verbatim and the shortfall node(s) it BINDS to
+ *     -- evidence read from the summary's verdict section, the only place it
+ *     lives.
+ *
+ * THE BINDING RULE (the server enforces the same one; keep them identical). A
+ * review verdict V binds to shortfall node N only when:
+ *   (a) V is a TREE verdict keyed to N itself; or
+ *   (b) V is a verdict on one of THIS delivery's declared criteria (as
+ *       enumerateCriteria segments them: list numbering such as "3. "
+ *       stripped) whose text, normalized (normalizeCriterion), EQUALS N's
+ *       declared future normalized the same way; or
+ *   (c) V is a TREE verdict keyed to an effect E with an active `sufficient`
+ *       edge N -> E: an effect sustained by sufficient causes clears only when
+ *       every one of them holds, so E judged met is evidence N holds.
+ * Nothing else binds -- not an `and`, derived_from or targets edge, not a
+ * delivery criterion that paraphrases the future, not a met criterion that is
+ * merely the delivery's. A node with no bound met-with-evidence verdict
+ * defers. The LATEST review carrying a bound verdict decides (a later not_met
+ * or excused withdraws an earlier met), and the ruling line proposes the BOUND
+ * verdict's criterion verbatim, since the server refuses any other.
+ *
+ * THE STANDING mirrors the server's admission rules so the prompt never tells
+ * the supervisor to make an act the server would refuse. A record it cannot
+ * read (the reviews, or the tree that binds them) never rules. The server
+ * remains the authority: a refused act names why, and the supervisor then
+ * defers.
+ *
+ * THE RULING SCOPE is what the filing asks for. When the filing names nodes
+ * structurally (metadata.human_act.shortfall_ruling.node_ids), only those are
+ * ruled and only those must carry evidence: another node on the delivery's
+ * shortfall record that the filing does not ask about is shown, never counted,
+ * so an unrequested, unevidenced node does not send an evidenced ask to the
+ * operator. A filing that names none (the cd32119b shape: a team reporting a
+ * re-held shortfall in prose) is scoped to every node the record holds.
+ *
+ * DECISION (reversible) -- an ask to EXCUSE. No structured field says a filing
+ * asks for an excusal, so it is read from the ask's text -- helpNeeded AND the
+ * structured act itself (metadata.human_act.act, filingActOf): ANY excuse
+ * or waiver word is an excuse ask, including a team's own "met or excused" --
+ * the alternative is explicit and the supervisor never takes it, so the ask
+ * defers. The only text stripped first is the daemon's OWN ruling offer, by its
+ * exact shape: "met or excused" followed by a parenthetical naming the
+ * shortfall_rule action (verify/shortfalls/shortfall-park-escalation.ts and
+ * completion/state-cascade/failed-verdict-stranded-filing.ts write it; their
+ * tests pin that it is recognised). It errs toward deferring, the safe direction.
+ *
+ * @module tower/tower-escalation-shortfall
+ */
+import { readLastShortfallJudgment, readShortfallPark } from '../queries/delivery-gate-state/delivery-gate-state.js';
+import { enumerateCriteria, normalizeCriterion, parseSummaryVerdicts } from '../queries/focus-review/review-summary-verdicts.js';
+/** The act the supervisor rules through (telora_agent action). */
+export const SHORTFALL_RULING_ACT = 'escalation_rule_shortfall';
+/** How many verdict-bearing reviews under the arm the record reads. */
+export const SHORTFALL_REVIEWS_READ = 10;
+const FULL_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function fullSha(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const sha = raw.trim().toLowerCase();
+    return FULL_SHA_RE.test(sha) ? sha : null;
+}
+function short(sha) {
+    return sha.slice(0, 12);
+}
+function parseVerdict(raw, from) {
+    const r = asObject(raw);
+    const sha = fullSha(r?.sha);
+    if (!r || sha === null || (r.outcome !== 'passed' && r.outcome !== 'failed'))
+        return null;
+    return { outcome: r.outcome, sha, failedStage: typeof r.failedStage === 'string' && r.failedStage !== '' ? r.failedStage : null, from };
+}
+/** Pure: the judged commit and the verdicts about it (module header). */
+export function judgedGateOf(gateState) {
+    const gate = asObject(gateState);
+    const judgedRaw = asObject(asObject(gate?.verificationHistory)?.judgedCommit);
+    const sha = judgedRaw !== null ? fullSha(judgedRaw.sha) : fullSha(asObject(asObject(gate?.shortfallReconciliation)?.gateVerdict)?.sha);
+    const judgedCommit = sha === null ? null : { sha, source: judgedRaw !== null ? 'judged_commit' : 'shortfall_reconciliation' };
+    const verdicts = [
+        [judgedRaw?.gateVerdict, 'verificationHistory.judgedCommit'],
+        [asObject(gate?.shortfallReconciliation)?.gateVerdict, 'shortfallReconciliation'],
+        [asObject(gate?.verification)?.gateVerdict, 'verification'],
+        [asObject(gate?.evidenceUnavailable)?.gateVerdict, 'evidenceUnavailable'],
+    ].flatMap(([raw, from]) => parseVerdict(raw, from) ?? []);
+    const onJudged = verdicts.filter((v) => v.sha === sha);
+    const gateVerdict = onJudged.find((v) => v.outcome === 'failed') ?? onJudged.find((v) => v.outcome === 'passed') ?? null;
+    return { judgedCommit, gateVerdict, otherCommitVerdicts: verdicts.filter((v) => v.sha !== sha) };
+}
+/** Pure: the node ids a filing's structured shortfall-ruling ask names (metadata.human_act.shortfall_ruling.node_ids), tolerantly. */
+export function filingShortfallNodeIds(metadata) {
+    const ids = asObject(asObject(asObject(metadata.human_act)?.shortfall_ruling))?.node_ids;
+    return Array.isArray(ids) ? ids.filter((id) => typeof id === 'string' && id.trim() !== '').map((id) => id.trim().toLowerCase()) : [];
+}
+/** How a node the filing's structured ask names is labelled in namedBy. */
+export const NAMED_BY_FILING = 'the filing';
+/** Pure: the shortfall nodes gate_state and the filing name, each with what names it. */
+export function shortfallNodesOf(gateState, metadata) {
+    const nodes = new Map();
+    const add = (rawId, by, declared = null) => {
+        const nodeId = rawId.trim().toLowerCase();
+        const n = nodes.get(nodeId) ?? { nodeId, declared: null, namedBy: [], inTree: false, future: null, sufficientEffectIds: [] };
+        if (!n.namedBy.includes(by))
+            n.namedBy.push(by);
+        if (n.declared === null && declared)
+            n.declared = declared;
+        nodes.set(nodeId, n);
+    };
+    const live = asObject(asObject(gateState)?.shortfallReconciliation) !== null;
+    for (const n of readLastShortfallJudgment(gateState)?.nodes ?? []) {
+        add(n.nodeId, live ? 'the live shortfall hold' : 'the last shortfall judgment', n.declared);
+    }
+    for (const id of readShortfallPark(gateState)?.nodeIds ?? [])
+        add(id, 'the shortfall park');
+    for (const id of filingShortfallNodeIds(metadata))
+        add(id, NAMED_BY_FILING);
+    return [...nodes.values()];
+}
+function keyOf(criterion, nodeId) {
+    return nodeId ? `node:${nodeId.toLowerCase()}` : `text:${normalizeCriterion(criterion)}`;
+}
+/** Pure: the shortfall nodes a verdict binds to, by THE BINDING RULE (module header). */
+export function bindsOf(v, nodes) {
+    if (v.nodeId) {
+        const id = v.nodeId.toLowerCase();
+        return nodes.flatMap((n) => {
+            if (n.nodeId === id)
+                return [{ nodeId: n.nodeId, via: 'tree_verdict_on_node' }];
+            if (n.sufficientEffectIds.includes(id))
+                return [{ nodeId: n.nodeId, via: 'sufficient_effect' }];
+            return [];
+        });
+    }
+    const text = normalizeCriterion(v.criterion);
+    return nodes.filter((n) => n.future !== null && normalizeCriterion(n.future) === text).map((n) => ({ nodeId: n.nodeId, via: 'declared_future' }));
+}
+/**
+ * Pure: one review's verdicts the record shows -- tree verdicts that bind a
+ * shortfall node, and verdicts on this delivery's declared criteria (each
+ * carrying the nodes it binds, possibly none).
+ */
+export function shortfallReviewOf(r, nodes, deliveryKeys) {
+    const shown = (criterion, nodeId) => {
+        const binds = bindsOf({ criterion, nodeId }, nodes);
+        if (nodeId)
+            return binds.length > 0 ? { source: 'tree', binds } : null;
+        return deliveryKeys.has(normalizeCriterion(criterion)) ? { source: 'delivery_criterion', binds } : null;
+    };
+    const stored = new Map(r.criterionVerdicts.map((v) => [keyOf(v.criterion, v.nodeId), v]));
+    const verdicts = [];
+    const seen = new Set();
+    for (const v of parseSummaryVerdicts(r.summary) ?? []) {
+        const key = keyOf(v.criterion, v.nodeId);
+        const how = shown(v.criterion, v.nodeId);
+        if (how === null || seen.has(key))
+            continue;
+        seen.add(key);
+        const s = stored.get(key);
+        verdicts.push({ ...v, ...how, storedOnly: false, disagrees: s !== undefined && s.verdict !== v.verdict });
+    }
+    for (const [key, v] of stored) {
+        const how = shown(v.criterion, v.nodeId);
+        if (how === null || seen.has(key))
+            continue;
+        seen.add(key);
+        verdicts.push({ criterion: v.criterion, nodeId: v.nodeId, ...how, verdict: v.verdict, evidence: [], storedOnly: true, disagrees: false });
+    }
+    return { reviewId: r.reviewId, completedAt: r.completedAt, outcome: r.outcome, reviewedSha: r.reviewedSha ?? null, verdicts };
+}
+/** Pure: the shortfall nodes with what the tree read says binds a verdict to each. */
+export function withBindings(nodes, bindings) {
+    const byId = new Map((bindings ?? []).map((b) => [b.nodeId.toLowerCase(), b]));
+    return nodes.map((n) => {
+        const b = byId.get(n.nodeId);
+        return b ? { ...n, inTree: true, future: b.frtStatement, sufficientEffectIds: b.sufficientEffectIds.map((id) => id.toLowerCase()) } : n;
+    });
+}
+/** Pure: the shortfall record. */
+export function buildShortfallRecord(input) {
+    const { delivery } = input;
+    const nodes = withBindings(shortfallNodesOf(delivery.gateState, input.metadata), input.bindings);
+    const deliveryCriteria = enumerateCriteria(delivery.acceptanceCriteria);
+    const deliveryKeys = new Set(deliveryCriteria.map(normalizeCriterion));
+    return {
+        deliveryId: delivery.id,
+        deliveryName: delivery.name,
+        ...judgedGateOf(delivery.gateState),
+        nodes,
+        deliveryCriteria,
+        reviews: (input.reviews ?? []).map((r) => shortfallReviewOf(r, nodes, deliveryKeys)),
+        reviewsReadable: input.reviews !== null,
+        bindingsReadable: input.bindings !== null,
+    };
+}
+// ─── Standing ─────────────────────────────────────────────────────
+/**
+ * The daemon's OWN ruling offer, by its exact shape (module header, DECISION):
+ * "met or excused", optionally "on the delivery" / "with a rationale", then a
+ * parenthetical that names the shortfall_rule action. A team's own "met or
+ * excused" is not followed by one, so it stays an excuse ask.
+ */
+const DAEMON_RULING_OFFER_RE = /\bmet or excused(?: on the delivery)?(?: with a rationale)? \((?:[a-z_]+ action )?shortfall_rule\b[^)]*\)/gi;
+/** Pure: the act text a filing's structured human act names (metadata.human_act.act), or null. */
+export function filingActOf(metadata) {
+    const act = asObject(metadata.human_act)?.act;
+    return typeof act === 'string' && act.trim() !== '' ? act : null;
+}
+/** Pure: whether the text asks to EXCUSE or waive a criterion (module header, DECISION). */
+export function askExcuses(helpNeeded) {
+    if (!helpNeeded)
+        return false;
+    const stripped = helpNeeded.replace(DAEMON_RULING_OFFER_RE, '');
+    return /\b(?:excus\w*|waiv\w*)\b/i.test(stripped);
+}
+/**
+ * Pure: the nodes this ask is a ruling on (module header, THE RULING SCOPE) --
+ * the filing's structured nodes when it names any, else every recorded node --
+ * and the recorded nodes outside that scope (shown, never counted).
+ */
+export function rulingScopeOf(record) {
+    const asked = record.nodes.filter((n) => n.namedBy.includes(NAMED_BY_FILING));
+    if (asked.length === 0)
+        return { scope: record.nodes, unasked: [] };
+    return { scope: asked, unasked: record.nodes.filter((n) => !asked.includes(n)).map((n) => n.nodeId) };
+}
+function unmetReason(review, v) {
+    const what = `criterion "${v.criterion}" (review ${review.reviewId})`;
+    if (v.disagrees)
+        return `${what}: the stored verdict and the summary disagree`;
+    if (v.verdict === 'not_met')
+        return `${what}: the latest review verdict is not_met`;
+    if (v.verdict === 'excused')
+        return `${what}: the latest review verdict is excused, which is not evidence it was met`;
+    if (v.evidence.length === 0)
+        return `${what}: judged met with no evidence reference${v.storedOnly ? ' readable' : ''}`;
+    return null;
+}
+/** Which bound verdict a node's ruling line proposes when one review binds several: the node's own first. */
+const VIA_ORDER = ['tree_verdict_on_node', 'declared_future', 'sufficient_effect'];
+function nodeStanding(record, node) {
+    const label = `node ${node.nodeId}`;
+    if (!node.inTree) {
+        return { ok: false, reasons: [`${label}: it is not among the focus's active reality-tree nodes, so no review verdict can be bound to it`] };
+    }
+    // The LATEST review that carries a verdict bound to this node decides.
+    for (const review of record.reviews) {
+        const bound = review.verdicts.flatMap((verdict) => verdict.binds.filter((b) => b.nodeId === node.nodeId).map((b) => ({ verdict, via: b.via })));
+        if (bound.length === 0)
+            continue;
+        const reasons = bound.flatMap((b) => unmetReason(review, b.verdict) ?? []).map((r) => `${label}: ${r}`);
+        if (reasons.length > 0)
+            return { ok: false, reasons };
+        const pick = [...bound].sort((a, b) => VIA_ORDER.indexOf(a.via) - VIA_ORDER.indexOf(b.via))[0];
+        return {
+            ok: true,
+            ruling: {
+                nodeId: node.nodeId, criterion: pick.verdict.criterion, reviewId: review.reviewId, evidence: pick.verdict.evidence,
+                via: pick.via, verdictNodeId: pick.verdict.nodeId,
+            },
+        };
+    }
+    return {
+        ok: false,
+        reasons: [
+            `${label}: no review verdict identifies this node's criterion (none under the arm is a tree verdict on the node, ` +
+                `this delivery's criterion stating its declared future${node.future === null ? ' (it declares none)' : ''}, ` +
+                'or a tree verdict on an effect it is a sufficient cause of)',
+        ],
+    };
+}
+function gateReasons(record) {
+    if (record.judgedCommit === null)
+        return ['no judged commit is recorded on the delivery, so no gate verdict can be about it'];
+    const sha = short(record.judgedCommit.sha);
+    if (record.gateVerdict === null)
+        return [`no gate verdict is recorded for the judged commit ${sha}`];
+    if (record.gateVerdict.outcome === 'failed') {
+        return [`the gate verdict for the judged commit ${sha} is failed${record.gateVerdict.failedStage ? ` (stage ${record.gateVerdict.failedStage})` : ''}`];
+    }
+    return [];
+}
+/** Pure: whether the record supports the supervisor's shortfall ruling (module header). */
+export function computeShortfallStanding(record, ask) {
+    const reasons = [];
+    if (askExcuses(ask.helpNeeded) || askExcuses(ask.act ?? null)) {
+        reasons.push('the ask would excuse a criterion; an excuse is never a supervisor act');
+    }
+    reasons.push(...gateReasons(record));
+    const { scope, unasked } = rulingScopeOf(record);
+    if (scope.length === 0)
+        reasons.push('no verify shortfall node is recorded on this delivery');
+    if (!record.reviewsReadable)
+        reasons.push('the review verdicts under the arm could not be read');
+    if (!record.bindingsReadable)
+        reasons.push('the reality tree that binds review verdicts to the shortfall nodes could not be read');
+    const rulings = [];
+    for (const node of record.reviewsReadable && record.bindingsReadable ? scope : []) {
+        const s = nodeStanding(record, node);
+        if (s.ok)
+            rulings.push(s.ruling);
+        else
+            reasons.push(...s.reasons);
+    }
+    return reasons.length > 0 ? { standing: 'defer', reasons, unasked } : { standing: 'rule', rulings, unasked };
+}
+// ─── Rendering ────────────────────────────────────────────────────
+function gateLines(record) {
+    const out = [];
+    const jc = record.judgedCommit;
+    out.push(jc === null
+        ? '- Judged commit: none recorded.'
+        : `- Judged commit: ${jc.sha} (from ${jc.source === 'judged_commit' ? 'verificationHistory.judgedCommit' : 'the live shortfall hold\'s gate verdict'}).`);
+    const gv = record.gateVerdict;
+    out.push(gv === null
+        ? '- Gate verdict for the judged commit: NONE recorded.'
+        : `- Gate verdict for the judged commit: ${gv.outcome.toUpperCase()}${gv.failedStage ? ` at stage ${gv.failedStage}` : ''} (${gv.from}).`);
+    for (const o of record.otherCommitVerdicts)
+        out.push(`  - (about another commit, not counted: ${o.outcome} at ${short(o.sha)}, ${o.from})`);
+    return out;
+}
+function reviewLines(record) {
+    if (!record.reviewsReadable)
+        return ['(The review verdicts could not be read.)'];
+    const withVerdicts = record.reviews.filter((r) => r.verdicts.length > 0);
+    if (withVerdicts.length === 0)
+        return ['(No review under the arm rendered a verdict bound to these nodes or on this delivery\'s criteria.)'];
+    const out = [];
+    for (const r of withVerdicts) {
+        out.push(`- review ${r.reviewId} (${r.outcome}, completed ${r.completedAt}${r.reviewedSha ? `, at ${r.reviewedSha}` : ''}):`);
+        for (const v of r.verdicts) {
+            const on = v.source === 'tree' ? `tree node ${v.nodeId}` : 'delivery criterion';
+            const binds = v.binds.length === 0
+                ? 'binds NO shortfall node'
+                : v.binds.map((b) => `binds node ${b.nodeId} as ${VIA_LABEL[b.via]}`).join(', ');
+            const flags = [binds, v.storedOnly ? 'stored only, no summary entry' : '', v.disagrees ? 'stored row DISAGREES with the summary' : ''].filter(Boolean);
+            out.push(`  - ${v.verdict} (${on}; ${flags.join('; ')}): criterion (verbatim, as a JSON string): ${JSON.stringify(v.criterion)}`);
+            out.push(`    evidence: ${v.evidence.length > 0 ? v.evidence.join(' | ') : '(none)'}`);
+        }
+    }
+    return out;
+}
+/** How each binding reads in the prompt. */
+const VIA_LABEL = {
+    tree_verdict_on_node: 'a tree verdict on the node itself',
+    declared_future: 'this delivery\'s criterion stating the node\'s declared future',
+    sufficient_effect: 'a tree verdict on an effect the node is a sufficient cause of',
+};
+function unaskedLines(standing) {
+    if (standing.unasked.length === 0)
+        return [];
+    return [
+        `Recorded on the delivery but NOT asked for by the filing (not ruled, and not counted for or against this ask): ` +
+            `node(s) ${standing.unasked.join(', ')}.`,
+    ];
+}
+function standingLines(standing) {
+    if (standing.standing === 'defer') {
+        return [
+            `**The record does NOT support a ruling: ${standing.reasons.join('; ')}. DEFER.**`,
+            `Do not call ${SHORTFALL_RULING_ACT}: an ask for a shortfall ruling on this delivery is deferred. ` +
+                '(An ask for anything else is judged by the answer-or-defer steps.)',
+            ...unaskedLines(standing),
+        ];
+    }
+    const out = [
+        '**The record SUPPORTS ruling these node(s) met**: the judged commit\'s gate verdict passed and the latest review under',
+        'the arm that judged each node\'s criterion -- by a verdict BOUND to that node -- judged it met with evidence.',
+        `If the ask is a shortfall ruling, RULE with ${SHORTFALL_RULING_ACT}, one ruling per node, passing exactly this criterion:`,
+    ];
+    for (const r of standing.rulings) {
+        out.push(`- nodeId "${r.nodeId}", criterion ${JSON.stringify(r.criterion)} (bound as ${VIA_LABEL[r.via]}` +
+            `${r.via === 'sufficient_effect' && r.verdictNodeId ? ` ${r.verdictNodeId}` : ''}; review ${r.reviewId}; evidence ${r.evidence.join(' | ')})`);
+    }
+    out.push('The server refuses any other criterion for that node: a verdict not bound to the node is not evidence it holds.');
+    out.push(...unaskedLines(standing));
+    return out;
+}
+function nodeLine(n) {
+    const parts = [`- node ${n.nodeId} (named by ${n.namedBy.join(', ')})`];
+    if (n.declared)
+        parts.push(`declared outcome: ${JSON.stringify(n.declared)}`);
+    if (!n.inTree)
+        parts.push('NOT found among the focus\'s active reality-tree nodes');
+    else {
+        parts.push(n.future === null ? 'declares no future (frt_statement)' : `declared future (frt_statement): ${JSON.stringify(n.future)}`);
+        parts.push(n.sufficientEffectIds.length === 0
+            ? 'a sufficient cause of no active effect'
+            : `a sufficient cause of effect(s) ${n.sufficientEffectIds.join(', ')}`);
+    }
+    return parts.join('; ');
+}
+/** Pure: the shortfall section of the escalation prompt. */
+export function renderShortfallSection(record, standing) {
+    const out = [
+        `## The verify shortfall record of "${record.deliveryName}" (deliveryId ${record.deliveryId})`,
+        '',
+        ...gateLines(record),
+        '',
+        'Shortfall nodes:',
+    ];
+    if (record.nodes.length === 0)
+        out.push('(none recorded)');
+    if (!record.bindingsReadable)
+        out.push('(The reality tree that binds review verdicts to these nodes could not be read.)');
+    for (const n of record.nodes)
+        out.push(nodeLine(n));
+    out.push('', 'Review verdicts under the current arm bound to these nodes, and on this delivery\'s criteria (newest first). A verdict', 'binds a node only as a tree verdict on the node itself, as this delivery\'s criterion whose text IS the node\'s declared', 'future, or as a tree verdict on an effect the node is a sufficient cause of; nothing else is evidence the node holds:', ...reviewLines(record));
+    out.push('', ...standingLines(standing), '');
+    return out;
+}
+//# sourceMappingURL=tower-escalation-shortfall.js.map