@telora/daemon 0.22.245 → 0.22.290

package/dist/verify/shortfalls/shortfall-rulings.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Verify honors SHORTFALL RULINGS: a node ruled MET or EXCUSED on a delivery
+ * (queries/verification/shortfall-rulings.ts) no longer holds its verify gate, and a ruling
+ * recorded since a shortfall park is a change verify re-judges.
+ *
+ * Why: a ruling verify does not read changes nothing -- the next verify pass
+ * re-judges the same nodes short and re-holds the delivery, and a delivery parked
+ * for a repeating shortfall (verify/shortfalls/shortfall-park.ts) stays parked until a new
+ * commit.
+ *
+ * TWO SOURCES OF A RULING, one read. The edge (`daemon_get_delivery_shortfall_-
+ * rulings`) returns the union of:
+ *   - an OPERATOR row on `delivery_shortfall_rulings` (`ruledByKind` = the
+ *     recording credential's kind, `user` / `ai_tracker`), and
+ *   - a node verdict of the focus's latest APPROVING focus_review
+ *     (`ruledByKind: 'review'`, `focusReviewId` naming the review row).
+ * An OPERATOR ruling on a node WINS -- the edge emits a review verdict only for
+ * a node no operator ruled -- so nothing here has to break a tie. A `not_met`
+ * verdict rules NOTHING and never reaches this module: a node review called
+ * not_met and verify judges short is the two channels AGREEING, and the gate
+ * holding it is correct.
+ *
+ * Why this module treats both identically: the review verdict is the SAME
+ * judgement an operator would otherwise transcribe by hand, so a node a review
+ * ruled must not keep failing verify, bouncing the delivery verify ->
+ * verify_failed -> coding with nothing to change. The only asymmetry kept is
+ * in the RECORD: `withRulingEvidence` names which source ruled, so the injection
+ * evidence says whether a human recorded it or a review ruled it, and which
+ * review.
+ *
+ * A REVIEW MET RULES ONLY WHERE ITS EVIDENCE RESOLVES. A review-sourced `met`
+ * does more than stop holding the gate: it records the node's declared future as
+ * LANDED reality. So it is honored only when every evidence reference the
+ * verdict names (`path`, `path::test name`, `path:LINE`) resolves at the commit
+ * this verify judged (verify/shortfalls/ruling-evidence-resolution.ts: existence only, no
+ * model call). Otherwise it rules NOTHING: the node stays in `shortfalls` exactly
+ * as verify's own reconciliation judged it, and the failed references are logged,
+ * returned (`unresolvedReviewRulings`) and appended to that shortfall's `reason`
+ * -- which the shortfall routing persists into gate_state, the park, its
+ * escalation and the re-work feedback, so the record says which reference failed
+ * without a second read. A met naming NO evidence (a review that predates
+ * evidence) is unresolvable by the same rule. When it IS honored, the injection
+ * evidence names the resolved references. Operator rulings and `excused`
+ * rulings are untouched: neither is checked, and neither names evidence. Deploy
+ * order: edge before daemon is the natural one; a daemon ahead of the edge sees
+ * no evidence on any review met, so verify judges those nodes itself -- the
+ * behaviour with no ruling, safe -- and an operator can still rule a node with
+ * `shortfall_rule`.
+ *
+ * A review-sourced ruling feeds the same FINGERPRINT (its id is
+ * `review:<focusReviewId>:<nodeId>` -- stable across re-reads, new per approving
+ * review), so `withShortfallRulingRearm` re-judges a park exactly once when a
+ * review lands, by the same mechanism a recorded row uses.
+ *
+ * APPLYING rulings (applyShortfallRulings, called by the verification engine
+ * between the reconciliation and the shortfall routing):
+ *   - MET: the node counts as achieved. It leaves the shortfall set and joins the
+ *     restatements the injection flip carries, as a `match` whose statement is the
+ *     DECLARED desired effect -- the operator ruled that intent realized, and a
+ *     match carries the declared effect forward unchanged. The ruling's rationale
+ *     is stamped into the injection's evidence (withRulingEvidence), the only
+ *     place a match's reason can land (the edge persists a reason only on a
+ *     legitimate_divergence, and a divergence would also file inward drift
+ *     against a claim the operator just upheld).
+ *   - EXCUSED: the node stops holding, but it was NOT achieved, so the flip must
+ *     not promote it as reality. It is WITHHELD from the flip (withheldNodeIds):
+ *     queries/verification/verification.ts sends it to reality_tree_verify_injection as a
+ *     shortfall-classified entry, which the edge skips entirely -- no node_type
+ *     flip, no statement, no classification -- so it stays an undesired effect
+ *     the tree can target again. The declared effect is never softened.
+ *   - Neither files inward shortfall drift: a ruled node leaves the shortfall set
+ *     before the engine emits it.
+ *   - A read FAILURE fails closed: no ruling is applied, the shortfalls stand as
+ *     judged, and the fingerprint is unknown (null), so a park re-held on it keeps
+ *     the fingerprint it had.
+ * Rulings are APPLIED only when the reconciliation found a shortfall: with none,
+ * there is nothing to rule and no park to record a fingerprint on. The engine
+ * READS them once before the judge is called (verify/shortfalls/pre-judge-rulings.ts),
+ * so a target a ruling honours by `rulingHonours` is never sent to the model: it
+ * reaches this pass as an unjudged shortfall and is honoured here, over the same
+ * read and the same evidence resolution.
+ *
+ * RE-JUDGING a park at an unchanged focus HEAD (withShortfallRulingRearm): a
+ * default-on verify is not re-selected while its run mark stands for the focus
+ * HEAD (verify/run-selection/verification-default-on.ts), and a parked delivery stays in
+ * verify, so with no new commit verify never re-judges it -- a ruling alone
+ * cannot release the park. The default-on scan therefore reads its deliveries
+ * through a reader that, for each delivery in verify carrying a park, reads its
+ * rulings and, when the fingerprint releases the park (isShortfallParkReleased),
+ * drops the delivery's run mark, so the same scan selects it again. Once per
+ * (delivery, fingerprint) in this process; durably, the re-judgement records the
+ * fingerprint it applied on any park it re-holds, so the ruling releases nothing
+ * further, even after a restart. The re-judgement runs no gate: the dispatch takes
+ * the verdict already recorded for that commit (verify/engine/verification-commit-sharing.ts
+ * readReusableVerdict), and only the reconciliation runs again -- a focus commit
+ * is still run through the gate at most once. A read failure re-arms nothing.
+ * EXPLICIT-method rows need no re-arm: a shortfall records a failed outcome, which
+ * the edge nulls, so daemon_get_pending_verifications lists a parked explicit row
+ * again every tick and its next dispatch applies the rulings.
+ *
+ * WHAT ELSE MAY RE-SELECT A PARKED DELIVERY AT AN UNCHANGED HEAD: nothing but a
+ * new commit, and this re-arm. The rule is pinned from two sides: the run-mark
+ * prune is scoped per product (verify/run-selection/default-on-guards.ts), and EVERY path that
+ * re-selects a delivery in verify writes one line naming itself
+ * (verify/run-selection/reselection-log-line.ts, whose exported path union a test enumerates -- this
+ * module's re-arm logs 'ruling-rearm'). The cost of any re-dispatch that does
+ * reach a parked delivery is bounded independently: a dispatch whose park
+ * matches the current commit set and rulings fingerprint reuses the parked
+ * shortfall and makes NO model call (verify/shortfalls/parked-shortfall-reuse.ts), so a
+ * ruling landing here is what re-judges it -- once -- rather than every tick
+ * paying a reconciliation to re-derive a shortfall the park already records.
+ *
+ * THE CLOSED LIST, stated once and pinned through the real tick composition
+ * (verification-default-on.test.ts, commit-verdict-pull.test.ts). Of the eight
+ * declared re-selection paths, a parked delivery at an unchanged HEAD is
+ * re-selected by exactly two, and both ARE the rule: 'ruling-rearm' (this
+ * module -- a new ruling) and a genuinely new commit, which reaches it as
+ * 'credit-rearm' (a commit credited to THIS delivery; a sibling's credit does
+ * not re-arm it) or as a changed commit set at dispatch. Three paths CANNOT fire
+ * on a parked delivery: 'run-mark-prune' (a parked delivery is in verify, and a
+ * partial scan prunes nothing), 'run-mark-release' (not a path of its own -- the
+ * silent fallback when a caller names itself) and 'pending-relisting' (which
+ * drops a parked explicit row, verify/run-selection/explicit-row-selection.ts, and writes
+ * its re-selection line once per dispatch that routes a verdict). The remaining
+ * three DECLINE while the park's facts are unchanged, each saying so in its own
+ * line: 'checkout-unavailable-unmark', 'model-unavailable-unmark'
+ * (verify/run-selection/default-on-guards.ts noteDefaultOnResult) and 'commit-verdict-pull'
+ * (verify/run-selection/commit-verdict-pull.ts).
+ *
+ * NONE OF THE THREE CAN WEDGE, and each reason is a STATE, not an exemption. A
+ * model-unavailable hold that landed on gate_state refuses the park
+ * ('awaiting-model'), so the retry proceeds; the decline fires only where a real
+ * judgement on these same facts still stands. The pull declines only where this
+ * process judged the held commit itself AND the release pass's own read finds
+ * that commit's verdict 'passed' -- a park is written only after the gate passed
+ * there, but the record write is best-effort, so the park alone does not prove
+ * the verdict persisted -- and a commit it already pulled for is pulled again
+ * while that read stays 'pending' (verify/run-selection/commit-verdict-pull.ts). And every
+ * UNKNOWN fact re-selects.
+ *
+ * History: docs/daemon/history-verify.md (verify/shortfalls/shortfall-rulings.ts).
+ *
+ * @module verify/shortfalls/shortfall-rulings
+ */
+import type { getFocusDeliveries } from '../../queries/focuses/focuses.js';
+import type { DeliveryShortfallRulings, ShortfallRuling } from '../../queries/verification/shortfall-rulings.js';
+import type { PendingVerification } from '../../queries/verification/verification.js';
+import type { TargetRestatement, TargetShortfall } from '../effect-reconciliation/verify-restatement.js';
+import { type RulingEvidenceCheck, type UnresolvedEvidenceRef } from './ruling-evidence-resolution.js';
+/** Read a delivery's active shortfall rulings (queries/verification/shortfall-rulings.ts getDeliveryShortfallRulings). */
+export type ShortfallRulingsReader = (deliveryId: string) => Promise<DeliveryShortfallRulings>;
+/**
+ * A ruling that cleared one of this judgement's shortfalls, carrying WHO ruled:
+ * a reader of the injection evidence or the log must be able to tell an operator
+ * row from a review verdict without a second query.
+ */
+export type HonoredRuling = Pick<ShortfallRuling, 'nodeId' | 'verdict' | 'rationale' | 'ruledByKind' | 'ruledSessionId' | 'focusReviewId' | 'evidence'>;
+/** A review met that ruled NOTHING because its evidence did not resolve at the judged commit. */
+export interface UnresolvedReviewRuling {
+    nodeId: string;
+    focusReviewId: string | null;
+    unresolved: UnresolvedEvidenceRef[];
+}
+/**
+ * Would this ruling clear a shortfall on its node at the judged commit? The ONE
+ * rule, read by applyShortfallRulings and by the pre-judge check
+ * (verify/shortfalls/pre-judge-rulings.ts), so a target skipped before the judge
+ * is always honoured after it: an operator ruling always; a review met only when
+ * its evidence resolves.
+ */
+export declare function rulingHonours(ruling: ShortfallRuling, evidenceCheck?: RulingEvidenceCheck): Promise<boolean>;
+/** A reconciliation with the delivery's rulings applied. */
+export interface RuledReconciliation {
+    restatements: TargetRestatement[];
+    /** The shortfalls no ruling cleared: these still hold the gate. */
+    shortfalls: TargetShortfall[];
+    /** The fingerprint of the rulings read; null when none were read (no shortfall, no reader, or a failed read). */
+    rulingsFingerprint: string | null;
+    /** EXCUSED nodes: cleared, but withheld from the injection flip (never promoted as achieved). */
+    withheldNodeIds: string[];
+    /** Every ruling that cleared a shortfall, in shortfall order. */
+    honored: HonoredRuling[];
+    /** Review mets that ruled nothing: their evidence did not resolve (module header). */
+    unresolvedReviewRulings: UnresolvedReviewRuling[];
+}
+/**
+ * Apply the delivery's active rulings to this judgement's reconciliation (see the
+ * module header). Never throws: a failed read applies nothing.
+ */
+export declare function applyShortfallRulings(v: Pick<PendingVerification, 'deliveryId' | 'deliveryName'>, reconciled: {
+    restatements: readonly TargetRestatement[];
+    shortfalls: readonly TargetShortfall[];
+}, read: ShortfallRulingsReader, evidenceCheck?: RulingEvidenceCheck): Promise<RuledReconciliation>;
+/**
+ * The injection evidence with the honored rulings appended, each NAMING ITS
+ * SOURCE -- an operator row by the credential kind that recorded it, a review
+ * verdict by the focus_review that ruled and the session that rendered it.
+ * Unchanged when none were honored. Pure.
+ *
+ * Why the source is in the evidence: this note is the only durable place a
+ * `match` carried by a ruling can state its reason (the injection edge persists a
+ * reason only on a legitimate_divergence), so "who lowered the bar on this node"
+ * has to be legible there or it is legible nowhere.
+ */
+export declare function withRulingEvidence(evidence: string, honored: readonly HonoredRuling[]): string;
+/** The delivery fields the re-arm reads. */
+type ParkedCandidate = Pick<Awaited<ReturnType<typeof getFocusDeliveries>>[number], 'id' | 'name' | 'executionStatus' | 'gateState' | 'verificationMethod'>;
+/**
+ * For each delivery in verify carrying a shortfall park, drop its default-on run
+ * mark when its rulings release the park and it was not already re-armed on that
+ * fingerprint (module header). Returns the re-armed delivery ids. Never throws.
+ */
+export declare function rearmRuledShortfallParks(deliveries: readonly ParkedCandidate[], read: ShortfallRulingsReader): Promise<string[]>;
+/**
+ * The scan deps with a delivery reader that re-arms ruling-released parks before
+ * the default-on scan selects from the deliveries it returns (module header).
+ */
+export declare function withShortfallRulingRearm<D extends {
+    getFocusDeliveries: typeof getFocusDeliveries;
+    readShortfallRulings: ShortfallRulingsReader;
+}>(deps: D): D;
+/** Test seam: forget every re-arm this process made. */
+export declare function __resetShortfallRulingRearmForTests(): void;
+export {};
+//# sourceMappingURL=shortfall-rulings.d.ts.map

package/dist/verify/shortfalls/shortfall-rulings.d.ts.map

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

package/dist/verify/shortfalls/shortfall-rulings.js

@@ -0,0 +1,218 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/integration/held-route-pull-dispatch.test.ts,
+//   packages/daemon/src/integration/review-verdict-ruling-release.test.ts,
+//   packages/daemon/src/integration/shortfall-ruling-disposes-proposals-regression.test.ts,
+//   packages/daemon/src/integration/shortfall-ruling-release.test.ts,
+//   packages/daemon/src/verify/run-selection/reselection-log-line.test.ts,
+//   packages/daemon/src/verify/run-selection/verification-default-on.test.ts,
+//   packages/daemon/src/verify/shortfalls/pre-judge-rulings.test.ts,
+//   packages/daemon/src/verify/shortfalls/ruling-evidence-resolution.test.ts,
+//   packages/daemon/src/verify/shortfalls/shortfall-rulings.test.ts
+// PINNED-BY-END
+import { isShortfallParkReleased, shortfallParkRefusingRework } from './shortfall-park.js';
+import { releaseDefaultOnMark } from '../run-selection/default-on-guards.js';
+import { logReselection } from '../run-selection/reselection-log-line.js';
+import { isGateRunSelected } from '../gate-verdicts/gate-run-registry.js';
+import { createLogger } from '../../log/daemon-log.js';
+import { unresolvedRulingEvidence } from './ruling-evidence-resolution.js';
+const log = createLogger({ module: 'verification' });
+/** Is this ruling a review verdict rather than a recorded operator row? */
+function isReviewSourced(h) {
+    return h.ruledByKind === 'review' || (typeof h.focusReviewId === 'string' && h.focusReviewId !== '');
+}
+/**
+ * Would this ruling clear a shortfall on its node at the judged commit? The ONE
+ * rule, read by applyShortfallRulings and by the pre-judge check
+ * (verify/shortfalls/pre-judge-rulings.ts), so a target skipped before the judge
+ * is always honoured after it: an operator ruling always; a review met only when
+ * its evidence resolves.
+ */
+export async function rulingHonours(ruling, evidenceCheck) {
+    if (!(ruling.verdict === 'met' && isReviewSourced(ruling)))
+        return true;
+    return (await unresolvedRulingEvidence(ruling.evidence, evidenceCheck)).length === 0;
+}
+/**
+ * Apply the delivery's active rulings to this judgement's reconciliation (see the
+ * module header). Never throws: a failed read applies nothing.
+ */
+export async function applyShortfallRulings(v, reconciled, read, evidenceCheck) {
+    const unruled = {
+        restatements: [...reconciled.restatements],
+        shortfalls: [...reconciled.shortfalls],
+        rulingsFingerprint: null,
+        withheldNodeIds: [],
+        honored: [],
+        unresolvedReviewRulings: [],
+    };
+    if (reconciled.shortfalls.length === 0)
+        return unruled;
+    let rulings;
+    try {
+        rulings = await read(v.deliveryId);
+    }
+    catch (err) {
+        log.warn(`[verification] shortfall rulings for delivery "${v.deliveryName}" (${v.deliveryId}) could not be read -- `
+            + `no ruling is applied; its ${reconciled.shortfalls.length} shortfall(s) stand as judged: ${err.message}`);
+        return unruled;
+    }
+    const byNode = new Map(rulings.rulings.map((r) => [r.nodeId.toLowerCase(), r]));
+    const ruled = { ...unruled, shortfalls: [], rulingsFingerprint: rulings.fingerprint };
+    for (const s of reconciled.shortfalls) {
+        const ruling = byNode.get(s.nodeId.toLowerCase());
+        if (!ruling) {
+            ruled.shortfalls.push(s);
+            continue;
+        }
+        const reviewMet = ruling.verdict === 'met' && isReviewSourced(ruling);
+        if (reviewMet) {
+            const unresolved = await unresolvedRulingEvidence(ruling.evidence, evidenceCheck);
+            if (unresolved.length > 0) {
+                ruled.shortfalls.push(recordUnresolvedReviewMet(v, s, ruling, unresolved, evidenceCheck?.judgedSha ?? null, ruled));
+                continue;
+            }
+        }
+        ruled.honored.push({
+            nodeId: s.nodeId,
+            verdict: ruling.verdict,
+            rationale: ruling.rationale,
+            ruledByKind: ruling.ruledByKind,
+            ruledSessionId: ruling.ruledSessionId,
+            focusReviewId: ruling.focusReviewId ?? null,
+            ...(reviewMet ? { evidence: [...(ruling.evidence ?? [])] } : {}),
+        });
+        if (ruling.verdict === 'met') {
+            ruled.restatements.push({ nodeId: s.nodeId, statement: s.declaredStatement, classification: 'match', originalClaim: s.declaredStatement });
+        }
+        else {
+            ruled.withheldNodeIds.push(s.nodeId);
+        }
+    }
+    if (ruled.honored.length > 0) {
+        const reviewCount = ruled.honored.filter(isReviewSourced).length;
+        const sources = reviewCount === 0
+            ? 'operator rulings'
+            : reviewCount === ruled.honored.length
+                ? 'approving-review verdicts'
+                : `rulings (${ruled.honored.length - reviewCount} operator, ${reviewCount} review-sourced)`;
+        log.info(`[verification] delivery "${v.deliveryName}" (${v.deliveryId}): ${sources} cleared ${ruled.honored.length} `
+            + `shortfall node(s) -- ${ruled.honored.map((h) => `${h.nodeId} ${h.verdict} (${rulingSourceLabel(h)})`).join(', ')}; `
+            + `${ruled.shortfalls.length} shortfall(s) still hold`);
+    }
+    return ruled;
+}
+/**
+ * A review met whose evidence did not resolve: it rules nothing, so the
+ * shortfall verify judged STANDS -- returned with the failed references appended
+ * to its reason (the durable record: the shortfall routing persists the reason),
+ * and logged and listed on the reconciliation. Mutates only `ruled`.
+ */
+function recordUnresolvedReviewMet(v, s, ruling, unresolved, judgedSha, ruled) {
+    const review = ruling.focusReviewId ?? 'unknown';
+    const at = judgedSha !== null ? judgedSha.slice(0, 12) : 'no judged commit';
+    const refs = unresolved.map((u) => `${u.ref} (${u.reason})`).join('; ');
+    ruled.unresolvedReviewRulings.push({ nodeId: s.nodeId, focusReviewId: ruling.focusReviewId ?? null, unresolved });
+    log.warn(`[verification] delivery "${v.deliveryName}" (${v.deliveryId}): approving review ${review} ruled node ${s.nodeId} met, `
+        + `but its evidence did not resolve at ${at} -- the ruling clears nothing and verify's own shortfall stands: ${refs}`);
+    const note = `The approving review ${review} ruled this node met, but its evidence did not resolve at ${at}, so the ruling was not honored: ${refs}.`;
+    return { ...s, reason: s.reason.trim() === '' ? note : `${s.reason} ${note}` };
+}
+/** How one honored ruling names its source, in a log line or a line of evidence. */
+function rulingSourceLabel(h) {
+    if (!isReviewSourced(h))
+        return `operator ruling, ${h.ruledByKind}`;
+    const session = h.ruledSessionId !== null ? `, review session ${h.ruledSessionId}` : '';
+    return `approving review ${h.focusReviewId ?? 'unknown'}${session}`;
+}
+/**
+ * The injection evidence with the honored rulings appended, each NAMING ITS
+ * SOURCE -- an operator row by the credential kind that recorded it, a review
+ * verdict by the focus_review that ruled and the session that rendered it.
+ * Unchanged when none were honored. Pure.
+ *
+ * Why the source is in the evidence: this note is the only durable place a
+ * `match` carried by a ruling can state its reason (the injection edge persists a
+ * reason only on a legitimate_divergence), so "who lowered the bar on this node"
+ * has to be legible there or it is legible nowhere.
+ */
+export function withRulingEvidence(evidence, honored) {
+    if (honored.length === 0)
+        return evidence;
+    const lines = honored.map((h) => {
+        const proof = Array.isArray(h.evidence) && h.evidence.length > 0 ? ` [evidence: ${h.evidence.join(', ')}]` : '';
+        return `- node ${h.nodeId} ruled ${h.verdict} by ${rulingSourceLabel(h)}: ${h.rationale}${proof}`;
+    });
+    const note = `Shortfall rulings honored:\n${lines.join('\n')}`;
+    return evidence.trim() === '' ? note : `${evidence}\n${note}`;
+}
+/** The rulings fingerprint each delivery was last re-armed on in this process. */
+const rearmedOn = new Map();
+/**
+ * What CHANGED, worded by what the reader actually knows. The re-arm decides on a
+ * fingerprint, which says only "the ruling set differs"; it must not claim "an
+ * operator ruling was recorded" when the change was a review verdict landing, or
+ * a revocation removing one. So the wording is derived from the rulings the read
+ * returned, and says the neutral thing when they name nothing.
+ */
+function describeRulingSources(rulings) {
+    if (rulings.length === 0)
+        return 'the rulings on it changed';
+    const review = rulings.filter((r) => r.ruledByKind === 'review').length;
+    if (review === 0)
+        return 'an operator ruling was recorded';
+    if (review === rulings.length)
+        return "an approving review's verdict ruled its nodes";
+    return 'an operator ruling and an approving review verdict are in force';
+}
+/**
+ * For each delivery in verify carrying a shortfall park, drop its default-on run
+ * mark when its rulings release the park and it was not already re-armed on that
+ * fingerprint (module header). Returns the re-armed delivery ids. Never throws.
+ */
+export async function rearmRuledShortfallParks(deliveries, read) {
+    const rearmed = [];
+    for (const d of deliveries) {
+        const park = shortfallParkRefusingRework(d);
+        if (park === null || (typeof d.verificationMethod === 'string' && d.verificationMethod !== ''))
+            continue;
+        if (isGateRunSelected(d.id))
+            continue;
+        let read_;
+        try {
+            read_ = await read(d.id);
+        }
+        catch (err) {
+            log.warn(`[verification] shortfall rulings for parked delivery "${d.name}" (${d.id}) could not be read -- its park is not re-judged this tick: ${err.message}`);
+            continue;
+        }
+        const fingerprint = read_.fingerprint;
+        if (!isShortfallParkReleased(park, { commitSet: null, rulingsFingerprint: fingerprint }) || rearmedOn.get(d.id) === fingerprint)
+            continue;
+        rearmedOn.set(d.id, fingerprint);
+        // Named path, so releaseDefaultOnMark stays silent and this richer line
+        // stands alone (verify/run-selection/reselection-log-line.ts: one line per re-selection).
+        releaseDefaultOnMark(d.id, 'ruling-rearm');
+        rearmed.push(d.id);
+        logReselection('ruling-rearm', d.id, `parked delivery "${d.name}" re-armed at the unchanged focus HEAD -- `
+            + `${describeRulingSources(read_.rulings)} since its park (nodes ${park.nodeIds.join(', ')}); verify re-judges it`);
+    }
+    return rearmed;
+}
+/**
+ * The scan deps with a delivery reader that re-arms ruling-released parks before
+ * the default-on scan selects from the deliveries it returns (module header).
+ */
+export function withShortfallRulingRearm(deps) {
+    const read = deps.readShortfallRulings;
+    const getFocusDeliveriesRearming = async (focusId) => {
+        const deliveries = await deps.getFocusDeliveries(focusId);
+        await rearmRuledShortfallParks(deliveries, read);
+        return deliveries;
+    };
+    return { ...deps, getFocusDeliveries: getFocusDeliveriesRearming };
+}
+/** Test seam: forget every re-arm this process made. */
+export function __resetShortfallRulingRearmForTests() {
+    rearmedOn.clear();
+}
+//# sourceMappingURL=shortfall-rulings.js.map

package/dist/verify/shortfalls/shortfall-rulings.js.map

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

package/dist/workflow/gate-failure-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-failure-policy.d.ts","sourceRoot":"","sources":["../../src/workflow/gate-failure-policy.ts"],"names":[],"mappings":"AAwCA,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,QAAQ,CAAC;AAErD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAO1F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAMrF"}
+{"version":3,"file":"gate-failure-policy.d.ts","sourceRoot":"","sources":["../../src/workflow/gate-failure-policy.ts"],"names":[],"mappings":"AA0CA,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,QAAQ,CAAC;AAErD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAO1F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAMrF"}

package/dist/workflow/gate-failure-policy.js

@@ -3,7 +3,7 @@
 // PINNED-BY-END
 /**
  * Fail-open vs fail-closed is a STATED PER-CLASS policy, not a per-call-site
- * choice (delivery 6 TEL-4). A read that feeds a gate can fail -- a Supabase
+ * choice. A read that feeds a gate can fail -- a Supabase
  * timeout, a partial API outage -- and what the daemon does with that failure
  * decides whether a healthy focus is silently blocked or unsafe work slips
  * through. Left to each call site, the choice drifts: two reads of the same class
@@ -15,24 +15,26 @@
  *
  *   ADVANCEMENT / LIVENESS read -- a read that decides whether a focus or
  *   delivery may SPAWN or ADVANCE (the respawn precondition, non-advanceable
- *   detection, the review-iteration count, focus ratification). On an unreadable
- *   input, FAIL OPEN: proceed as if permissive. A transient read error must not
- *   silently block a healthy focus -- a spurious spawn/advance is recoverable and
- *   cheap; a silent block is exactly the absorbing state this focus exists to
- *   remove. Liveness beats a momentarily-stale read.
+ *   detection, the review-iteration count, focus ratification). On an
+ *   unreadable input, FAIL OPEN: proceed as if permissive. A transient read
+ *   error must not silently block a healthy focus -- a spurious spawn/advance
+ *   is recoverable and cheap; a silent block is an absorbing state. Liveness
+ *   beats a momentarily-stale read.
  *
  *   SAFETY GATE -- a read whose whole job is to STOP work: a guard verdict, a
  *   verify/external hold, the sandbox wrap. On an unreadable input, FAIL CLOSED:
- *   hold. A missed block lets externally-blocked or unsafe work reach done -- the
- *   failure this focus fights harder than a spurious hold. Safety beats liveness
- *   HERE, and only here, because the cost is asymmetric the other way.
+ *   hold. A missed block lets externally-blocked or unsafe work reach done -- a
+ *   worse failure than a spurious hold. Safety beats liveness HERE, and only
+ *   here, because the cost is asymmetric the other way.
  *
  * The helpers are intentionally thin (they return the caller's value): the value
  * is the NAME + the single consistent log line, so each site's error branch reads
  * `return advancementReadFailsOpen(...)` / `return safetyGateFailsClosed(...)` and
  * the class -- and therefore the degradation -- is explicit and uniform.
+ *
+ * History: docs/daemon/history-platform.md (workflow/gate-failure-policy.ts).
  */
-import { createLogger } from '../shell/log.js';
+import { createLogger } from '../log/daemon-log.js';
 const log = createLogger({ module: 'gate-failure-policy' });
 /**
  * An ADVANCEMENT / LIVENESS read failed to resolve its input. FAIL OPEN: return

package/dist/workflow/gate-failure-policy.js.map

@@ -1 +1 @@
-{"version":3,"file":"gate-failure-policy.js","sourceRoot":"","sources":["../../src/workflow/gate-failure-policy.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sEAAsE;AACtE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC,CAAC;AAK5D;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAI,IAAY,EAAE,KAAc,EAAE,UAAa;IACrF,GAAG,CAAC,IAAI,CACN,yBAAyB,IAAI,gEAAgE;QAC7F,+EAA+E;QAC/E,GAAI,KAAe,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAChD,CAAC;IACF,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAI,IAAY,EAAE,KAAc,EAAE,QAAW;IAChF,GAAG,CAAC,IAAI,CACN,yBAAyB,IAAI,yDAAyD;QACtF,wDAAyD,KAAe,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CACrG,CAAC;IACF,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"gate-failure-policy.js","sourceRoot":"","sources":["../../src/workflow/gate-failure-policy.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sEAAsE;AACtE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC,CAAC;AAK5D;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAI,IAAY,EAAE,KAAc,EAAE,UAAa;IACrF,GAAG,CAAC,IAAI,CACN,yBAAyB,IAAI,gEAAgE;QAC7F,+EAA+E;QAC/E,GAAI,KAAe,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAChD,CAAC;IACF,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAI,IAAY,EAAE,KAAc,EAAE,QAAW;IAChF,GAAG,CAAC,IAAI,CACN,yBAAyB,IAAI,yDAAyD;QACtF,wDAAyD,KAAe,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CACrG,CAAC;IACF,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/workflow/pipeline-config.d.ts

@@ -13,7 +13,10 @@
  *    happen by accident.
  */
 import type { PipelineConfig } from '../types/focus.js';
+import type { DeepReadonly } from '../types/focus-team-state.js';
 import type { MergeStrategy } from '../git/index.js';
+/** The readers take the config readonly: a team's pipelineConfig is readonly all the way down. */
+type PipelineConfigView = DeepReadonly<PipelineConfig> | null | undefined;
 /**
  * Resolved CI/CD merge decision derived from a focus's pipelineConfig.
  * `shouldMerge` directly determines whether mergeIntegrationToMain is called.
@@ -31,13 +34,13 @@ export interface CiDecision {
  * merge proceed. Only an explicit `ci.enabled === false` skips. Null /
  * missing config defaults to enabled (backward compatibility).
  */
-export declare function isCiEnabled(pc: PipelineConfig | null | undefined): boolean;
+export declare function isCiEnabled(pc: PipelineConfigView): boolean;
 /**
  * Returns true only when the focus has explicitly opted in to pushing
  * main to the remote after a successful CI merge. Strict-true semantics:
  * any other value (false / undefined / null pc) returns false.
  */
-export declare function isCdEnabled(pc: PipelineConfig | null | undefined): boolean;
+export declare function isCdEnabled(pc: PipelineConfigView): boolean;
 /**
  * Returns true when the focus's auto-review gate should let the daemon
  * advance `verify -> review`. Mirrors `isCiEnabled`: only an explicit
@@ -50,13 +53,13 @@ export declare function isCdEnabled(pc: PipelineConfig | null | undefined): bool
  * for the daemon's sole auto-review gate, `state-cascade.checkAutoReview`
  * (the duplicate stage='review' auto-advance was removed in TEL-6).
  */
-export declare function isReviewEnabled(pc: PipelineConfig | null | undefined): boolean;
+export declare function isReviewEnabled(pc: PipelineConfigView): boolean;
 /**
  * Return the configured merge strategy, falling back to the system default
  * when the field is missing. Defaulting is centralized here so the merge
  * call site doesn't need its own fallback.
  */
-export declare function getMergeStrategy(pc: PipelineConfig | null | undefined): MergeStrategy;
+export declare function getMergeStrategy(pc: PipelineConfigView): MergeStrategy;
 /**
  * Resolve the full CI/CD merge decision from a focus's pipelineConfig.
  *
@@ -68,5 +71,6 @@ export declare function getMergeStrategy(pc: PipelineConfig | null | undefined):
  * skipped" invariant: tests assert `shouldMerge` to verify gate behavior
  * without requiring the full call-site stack to be mocked.
  */
-export declare function resolveCiDecision(pc: PipelineConfig | null | undefined): CiDecision;
+export declare function resolveCiDecision(pc: PipelineConfigView): CiDecision;
+export {};
 //# sourceMappingURL=pipeline-config.d.ts.map

package/dist/workflow/pipeline-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-config.d.ts","sourceRoot":"","sources":["../../src/workflow/pipeline-config.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,4DAA4D;IAC5D,WAAW,EAAE,OAAO,CAAC;IACrB,mEAAmE;IACnE,YAAY,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,aAAa,CAErF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,CAOnF"}
+{"version":3,"file":"pipeline-config.d.ts","sourceRoot":"","sources":["../../src/workflow/pipeline-config.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD,kGAAkG;AAClG,KAAK,kBAAkB,GAAG,YAAY,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAE1E;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,4DAA4D;IAC5D,WAAW,EAAE,OAAO,CAAC;IACrB,mEAAmE;IACnE,YAAY,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,kBAAkB,GAAG,aAAa,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,kBAAkB,GAAG,UAAU,CAOpE"}

package/dist/workflow/pipeline-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-config.js","sourceRoot":"","sources":["../../src/workflow/pipeline-config.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,kEAAkE;AAClE,gBAAgB;AAoBhB,MAAM,sBAAsB,GAAkB,cAAc,CAAC;AAe7D;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAqC;IAC/D,OAAO,EAAE,EAAE,EAAE,EAAE,OAAO,KAAK,KAAK,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAqC;IAC/D,OAAO,EAAE,EAAE,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,EAAqC;IACnE,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,KAAK,KAAK,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAqC;IACpE,OAAO,EAAE,EAAE,EAAE,EAAE,aAAa,IAAI,sBAAsB,CAAC;AACzD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAAqC;IACrE,MAAM,WAAW,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;IACpC,OAAO;QACL,WAAW;QACX,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK;QACnD,aAAa,EAAE,gBAAgB,CAAC,EAAE,CAAC;KACpC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"pipeline-config.js","sourceRoot":"","sources":["../../src/workflow/pipeline-config.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,kEAAkE;AAClE,gBAAgB;AAqBhB,MAAM,sBAAsB,GAAkB,cAAc,CAAC;AAkB7D;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAsB;IAChD,OAAO,EAAE,EAAE,EAAE,EAAE,OAAO,KAAK,KAAK,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAsB;IAChD,OAAO,EAAE,EAAE,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,EAAsB;IACpD,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,KAAK,KAAK,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAsB;IACrD,OAAO,EAAE,EAAE,EAAE,EAAE,aAAa,IAAI,sBAAsB,CAAC;AACzD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAAsB;IACtD,MAAM,WAAW,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;IACpC,OAAO;QACL,WAAW;QACX,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK;QACnD,aAAa,EAAE,gBAAgB,CAAC,EAAE,CAAC;KACpC,CAAC;AACJ,CAAC"}

package/dist/workflow/stage-classifier.d.ts

@@ -1,4 +1,5 @@
-import type { WorkflowStage, Workflow } from '../types/index.js';
+import type { WorkflowStage } from '@telora/daemon-core';
+import type { Workflow } from '../types/index.js';
 /** Stage where agent team has work to do (e.g., queued, coding, verify_failed). */
 export declare function isAgentActionable(stage: WorkflowStage): boolean;
 /** Truly terminal — no more work ever (e.g., done, cancelled). */

package/dist/workflow/stage-classifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stage-classifier.d.ts","sourceRoot":"","sources":["../../src/workflow/stage-classifier.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIjE,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAG/D;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAGxD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAS1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAUxD;AAED,sEAAsE;AACtE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEnE;AAUD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAMpF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM7E;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM/E;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM7E;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAMxF"}
+{"version":3,"file":"stage-classifier.d.ts","sourceRoot":"","sources":["../../src/workflow/stage-classifier.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIlD,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAG/D;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAGxD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAS1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAUxD;AAED,sEAAsE;AACtE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEnE;AAUD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAMpF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM7E;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM/E;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM7E;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAMxF"}

package/dist/workflow/stage-classifier.js

@@ -1,5 +1,5 @@
 // PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
-// Pinned by: packages/daemon/src/completion/no-progress-watchdog-characterization.test.ts,
+// Pinned by: packages/daemon/src/completion/completion-event/no-progress-watchdog-characterization.test.ts,
 //   packages/daemon/src/workflow/stage-classifier.test.ts
 // PINNED-BY-END
 /**