@telora/daemon 0.22.132 → 0.22.136

package/dist/verify/shortfall-park.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortfall-park.d.ts","sourceRoot":"","sources":["../../src/verify/shortfall-park.ts"],"names":[],"mappings":"AAuDA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAE3B,MAAM,mCAAmC,CAAC;AAO3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAK/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AACpE,YAAY,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAInE;AAED,4GAA4G;AAC5G,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAE1E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE;IAAE,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,aAAa,GAAG,IAAI,CAEpI;AAED,mEAAmE;AACnE,MAAM,WAAW,yBAAyB;IACxC,qFAAqF;IACrF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAIxG;AAED,0DAA0D;AAC1D,MAAM,WAAW,2BAA2B;IAC1C,mGAAmG;IACnG,MAAM,EAAE,qBAAqB,CAAC;IAC9B,kFAAkF;IAClF,MAAM,EAAE,OAAO,CAAC;IAChB,sGAAsG;IACtG,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;CAC5B;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACpD,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,KAAK,GAAE,MAAoC,EAC3C,GAAG,GAAE,MAAiC,EACtC,kBAAkB,GAAE,MAAM,GAAG,IAAW,GACvC,2BAA2B,CAiC7B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,iBAAiB,CAO7G"}

package/dist/verify/shortfall-park.js

@@ -0,0 +1,208 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/review-approved-head-gate.test.ts,
+//   packages/daemon/src/completion/review-exit-shortfall-park.test.ts,
+//   packages/daemon/src/completion/standing-approval-convergence.test.ts,
+//   packages/daemon/src/focus/parked-shortfall-spawn.test.ts,
+//   packages/daemon/src/focus/verify-routing-passes.test.ts,
+//   packages/daemon/src/integration/shortfall-park-incident-regression.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/prompt/prompt-listing.test.ts,
+//   packages/daemon/src/spawn/review-hold-park-shortfall.test.ts,
+//   packages/daemon/src/verify/delivery-commit-set.test.ts,
+//   packages/daemon/src/verify/shortfall-park-escalation.test.ts,
+//   packages/daemon/src/verify/shortfall-park.test.ts, packages/daemon/src/verify/shortfall-routing.test.ts,
+//   packages/daemon/src/verify/shortfall-rulings.test.ts
+// PINNED-BY-END
+/**
+ * The SHORTFALL PARK: a delivery whose identical verify shortfall re-holds on an
+ * UNCHANGED delivery-trailered commit set is parked, not sent back to coding.
+ *
+ * Why (reality tree injection #13): the repetition discriminator
+ * (verify/shortfall-repeat.ts) counted identical shortfalls, but its at-limit
+ * outcome was a live gate_state hold nothing else honoured -- the review exit
+ * rewrote the gate and routed verify_failed, a coding team respawned with nothing
+ * truthful to commit, stamped the work done, and fed the next identical verdict.
+ * One delivery reached iterationCount 23 and stopped only when an operator
+ * disarmed the focus. Re-judging the SAME commits cannot change the verdict, so
+ * once the identical judgement has stood SHORTFALL_PARK_REPEAT_LIMIT times on an
+ * unchanged commit set the delivery is parked: a DURABLE record in the
+ * verification history (queries/shortfall-park-record.ts) that every carrying
+ * gate_state writer keeps and only a verify pass drops. Readers that must refuse
+ * to send a parked delivery to coding read it through readShortfallPark and
+ * isShortfallParkReleased.
+ *
+ * The count is keyed on (signature, commit set):
+ *   - identical signature AND unchanged commit set -> the count climbs;
+ *   - a CHANGED commit set -> the team produced new work; it restarts at 1 and is
+ *     judged fresh (a producing team is never cut short);
+ *   - a changed signature (a different node or declared claim; a reworded,
+ *     model-authored reason is NOT a change -- see shortfallSignature) ->
+ *     restarts at 1 (a genuine, moving shortfall);
+ *   - an UNKNOWN commit set (the read failed, or a legacy record carries none) ->
+ *     exactly the signature-only count that predates the park. A read failure
+ *     therefore never resets a real loop, and never manufactures a park either:
+ *     a park still needs the limit's worth of identical judgements.
+ *
+ * SELF-CONTAINED and mock-safe like shortfall-repeat.ts: node:crypto plus the
+ * gate-state vocabulary, NO daemon-core value import. Pure and deterministic.
+ *
+ * @module verify/shortfall-park
+ */
+import { createHash } from 'node:crypto';
+import { readVerificationHistory, } from '../queries/delivery-gate-state.js';
+import { readPriorRepeat, sameShortfallSignature, shortfallSignature, SHORTFALL_PARK_REPEAT_LIMIT, } from './shortfall-repeat.js';
+/** The delivery status a park refuses re-work in. Daemon-local literal (mock-safe: no daemon-core value import). */
+const VERIFY_STATUS = 'verify';
+export { SHORTFALL_PARK_REPEAT_LIMIT } from './shortfall-repeat.js';
+/**
+ * Order-independent fingerprint of a delivery's commit set. The input is the set
+ * of commit IDENTITIES the resolver read (verify/delivery-commit-set.ts: patch ids,
+ * so a rebase that re-shas unchanged commits is not "new work"); trimmed,
+ * lowercased, deduped and sorted before hashing, so the same set in any order or
+ * with repeats fingerprints identically. The empty set has a fingerprint too: a
+ * delivery with no commits of its own is a known, unchanging set. Pure.
+ */
+export function commitSetFingerprint(ids) {
+    const unique = [...new Set(ids.map((id) => id.trim().toLowerCase()).filter((id) => id !== ''))].sort();
+    const digest = createHash('sha256').update(unique.join('\n')).digest('hex');
+    return `${unique.length}:${digest}`;
+}
+/** The standing park a gate_state carries, or null (none, malformed, or a verify pass dropped it). Pure. */
+export function readShortfallPark(gateState) {
+    return readVerificationHistory(gateState).shortfallPark ?? null;
+}
+/**
+ * The park that makes a delivery NON-REWORKABLE: a standing park on a delivery
+ * that sits in verify, or null. The ONE predicate every daemon writer and spawn
+ * gate reads before sending a verify delivery back to coding (the review exit's
+ * verify_failed route, the live open-issues pass, the review-next-step decision,
+ * the review park), so none of them can disagree about a parked delivery.
+ *
+ * The park is AUTHORITATIVE in those readers: they neither release nor replace
+ * it. VERIFY is its single releaser -- a verify re-judgement on a changed
+ * delivery commit set (a new focus HEAD re-arms every delivery in verify) routes
+ * the delivery to re-work and drops the park (routeShortfallOutcome ->
+ * withShortfallPark(..., null)); a pass drops it (clearVerificationHistory); an
+ * operator ruling releases it through isShortfallParkReleased, which re-arms that
+ * re-judgement at an unchanged focus HEAD (verify/shortfall-rulings.ts). A reader that cannot know the current commit set therefore holds.
+ *
+ * Only a delivery IN VERIFY is refused: a park carried onto another status (the
+ * Nexus hand-back of a declined request moves a verify delivery to re-plan on a
+ * new external fact, once) is not a verify re-judgement loop, and the park still
+ * re-holds at its first unchanged re-judgement. Literal 'verify' (mock-safe). Pure.
+ */
+export function shortfallParkRefusingRework(delivery) {
+    return delivery.executionStatus === VERIFY_STATUS ? readShortfallPark(delivery.gateState) : null;
+}
+/**
+ * Whether a standing park is RELEASED -- the delivery may be judged and sent to
+ * coding again. Released when:
+ *   - a KNOWN current commit set differs from the park's known set (someone
+ *     committed new delivery work since the park); or
+ *   - a non-empty current rulings fingerprint differs from the park's (a ruling
+ *     was recorded since the park; verify/shortfall-rulings.ts re-arms verify on
+ *     it at an unchanged focus HEAD).
+ * An unreadable current set, or a park recorded without one, releases nothing by
+ * commit set: a read failure must not respawn a parked loop. Pure.
+ */
+export function isShortfallParkReleased(park, current) {
+    if (current.commitSet !== null && park.commitSet !== null && current.commitSet !== park.commitSet)
+        return true;
+    const rulings = current.rulingsFingerprint;
+    return typeof rulings === 'string' && rulings !== '' && rulings !== (park.rulingsFingerprint ?? '');
+}
+function sortedNodeIds(shortfalls) {
+    return [...new Set(shortfalls.map((s) => s.nodeId))].sort();
+}
+/**
+ * Whether a NEW ruling (a non-empty fingerprint the park has not applied) left a
+ * strict, non-empty subset of the park's nodes short (see classifyShortfallPark).
+ * Node ids compare case-insensitively (the edge stores ruled ids lowercased). Pure.
+ */
+function narrowedByRuling(standing, shortfalls, rulingsFingerprint) {
+    if (rulingsFingerprint === null || !isShortfallParkReleased(standing, { commitSet: null, rulingsFingerprint }))
+        return false;
+    const parked = new Set(standing.nodeIds.map((id) => id.toLowerCase()));
+    const remaining = new Set(shortfalls.map((s) => s.nodeId.toLowerCase()));
+    return remaining.size > 0 && remaining.size < parked.size && [...remaining].every((id) => parked.has(id));
+}
+/**
+ * Classify this judgement's shortfall set against the delivery's prior gate_state
+ * and the commit set it was judged on (see the module header for the count rule).
+ *
+ * A standing, unreleased park for the SAME signature keeps the delivery parked
+ * even when the live repeat record was displaced by another writer: the count
+ * continues from the larger of the two, and the park keeps its original parkedAt.
+ * The count keeps climbing on every re-hold (it reports how many identical
+ * judgements the park has absorbed; it is never used as a cap). When the current
+ * set is unknown, the last KNOWN set is carried forward, so the next readable
+ * judgement still compares against real history.
+ *
+ * OPERATOR RULINGS (verify/shortfall-rulings.ts) are applied before this runs: a
+ * ruled node is no longer in `shortfalls`. `rulingsFingerprint` is the fingerprint
+ * of the rulings that judgement applied (null when they could not be read). Two
+ * rules follow:
+ *   - the park records it (null keeps the standing park's), so a park re-held by
+ *     the judgement a ruling re-armed is no longer released by that ruling -- the
+ *     re-judgement happens once per new ruling, not on every tick;
+ *   - a NEW ruling that disposed of SOME of the parked nodes on an unchanged
+ *     commit set narrows the park to the rest instead of ending it: those nodes
+ *     already repeated unchanged, so sending them back to coding would restart the
+ *     loop the park stopped. The narrowed park keeps its parkedAt; its changed
+ *     signature files its own escalation naming the nodes still held.
+ * A ruling that disposes of every node leaves no shortfall to classify: the
+ * verify passes and the pass reset drops the park.
+ *
+ * Pure -- the caller supplies the prior gate_state (read once), the current commit
+ * fingerprint (or null), `now` for a first park's parkedAt, and the applied
+ * rulings fingerprint (or null).
+ */
+export function classifyShortfallPark(priorGateState, shortfalls, commitSet, limit = SHORTFALL_PARK_REPEAT_LIMIT, now = new Date().toISOString(), rulingsFingerprint = null) {
+    const signature = shortfallSignature(shortfalls);
+    const prior = readPriorRepeat(priorGateState);
+    const priorSet = prior?.commitSet ?? null;
+    // New work is only ever evidenced by two KNOWN, differing sets.
+    const setChanged = commitSet !== null && priorSet !== null && commitSet !== priorSet;
+    const continues = prior !== null && sameShortfallSignature(prior.signature, signature) && !setChanged;
+    let count = continues ? prior.count + 1 : 1;
+    let knownSet = commitSet ?? (continues ? priorSet : null);
+    const standing = readShortfallPark(priorGateState);
+    const sameAsStanding = standing !== null && sameShortfallSignature(standing.signature, signature);
+    const holding = standing !== null && !setChanged && !isShortfallParkReleased(standing, { commitSet })
+        && (sameAsStanding || narrowedByRuling(standing, shortfalls, rulingsFingerprint));
+    if (holding) {
+        count = Math.max(count, standing.count + 1);
+        knownSet = knownSet ?? standing.commitSet;
+    }
+    const repeat = { signature, count, ...(knownSet !== null ? { commitSet: knownSet } : {}) };
+    if (count < limit)
+        return { repeat, parked: false, park: null };
+    const applied = rulingsFingerprint ?? (holding ? standing.rulingsFingerprint : undefined);
+    const park = {
+        // A re-hold of the same shortfall keeps the standing park's signature text, so
+        // a park persisted in a legacy signature form keeps its escalation cause key.
+        signature: holding && sameAsStanding ? standing.signature : signature,
+        commitSet: knownSet,
+        nodeIds: sortedNodeIds(shortfalls),
+        count,
+        parkedAt: holding ? standing.parkedAt : now,
+        ...(applied ? { rulingsFingerprint: applied } : {}),
+    };
+    return { repeat, parked: true, park };
+}
+/**
+ * `gateState` with its shortfall park REPLACED: set to `park`, or removed when
+ * null (a shortfall routed back to re-work is not parked). The rest of the
+ * history is untouched; an emptied history key is dropped. Pure.
+ */
+export function withShortfallPark(gateState, park) {
+    const history = { ...(gateState.verificationHistory ?? {}) };
+    delete history.shortfallPark;
+    if (park)
+        history.shortfallPark = park;
+    const next = { ...gateState };
+    delete next.verificationHistory;
+    return Object.keys(history).length > 0 ? { ...next, verificationHistory: history } : next;
+}
+//# sourceMappingURL=shortfall-park.js.map

package/dist/verify/shortfall-park.js.map

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

package/dist/verify/shortfall-repeat.d.ts

@@ -33,39 +33,70 @@ export interface ShortfallRepeat {
     signature: string;
     /** How many CONSECUTIVE iterations this exact signature has stood. >= 1. */
     count: number;
+    /** Fingerprint of the delivery-trailered commit set it was judged on (verify/shortfall-park.ts); absent when unread or legacy. */
+    commitSet?: string;
 }
 /**
- * How many consecutive identical shortfall iterations mark a claim as unclearable.
+ * How many consecutive identical shortfall judgements PARK a delivery -- the
+ * stated limit of the shortfall park (verify/shortfall-park.ts), re-exported
+ * there. One constant: the park REPLACES the old unclearable-claim hold as the
+ * at-limit outcome, so the two can never disagree.
  *
  * JUDGMENT CALL (recorded here rather than defaulted silently): too LOW and a team
  * legitimately re-attempting the same area gets cut off before it can respond; too
- * HIGH and the loop stays expensive. The Tinker Tailor case ran to iteration 10
- * and the Telora case to 6, so the current iteration cap is far too high to catch
- * this early. 3 identical occurrences -- i.e. the shortfall survived TWO re-work
+ * HIGH and the loop stays expensive. The Tinker Tailor case ran to iteration 10,
+ * the Telora case to 6, and the 2026-09 incident this park answers ran to
+ * iterationCount 23 -- a coding team respawned each time with nothing truthful to
+ * commit. 3 identical occurrences -- i.e. the shortfall survived TWO re-work
  * responses unchanged -- is strong evidence the diff cannot move it, while still
- * giving a responding team two full cycles to change something. Reversible: it is
- * a single constant, tunable later, and overridable per-call for tests. Kept a
+ * giving a responding team two full cycles to change something. And the park
+ * counts only on an UNCHANGED delivery commit set: a team that commits new work
+ * restarts the count, so the limit never cuts short a team that is still
+ * producing. Reversible: a single constant, overridable per-call for tests. Kept a
  * daemon-local constant (not a TELORA_* env var) deliberately -- adding an env var
  * would require a daemon-core publish; promote it there only if operators need to
  * tune it live.
  */
+export declare const SHORTFALL_PARK_REPEAT_LIMIT = 3;
+/** The former name of SHORTFALL_PARK_REPEAT_LIMIT, kept for existing importers. */
 export declare const UNCLEARABLE_SHORTFALL_REPEAT_THRESHOLD = 3;
 /**
  * Compute a stable, order-independent signature of a shortfall set.
  *
- * Keyed on (nodeId, declaredStatement, reason) per targeted node, sorted by
- * nodeId -- the fields that define "the same shortfall". DELIBERATELY EXCLUDES:
- *   - achievedStatement: the authored-from-evidence side can vary in wording
- *     across iterations while the underlying gap is identical;
+ * Keyed on (nodeId, declaredStatement) per targeted node -- the fields that
+ * define "the same gap" -- deduped and sorted. Both are STABLE across verify
+ * passes: nodeId is the tree node, and declaredStatement is read off that node
+ * (its preserved frt_statement, else its UDE statement: verify/verify-restatement.ts),
+ * so it changes only when someone edits the tree -- a genuine change of claim.
+ * DELIBERATELY EXCLUDES every MODEL-AUTHORED field, which the reconciler writes
+ * afresh on each pass:
+ *   - reason: the divergence explanation. Kept on the shortfall as display detail
+ *     only. When it was part of the key, an identical gap whose reason was merely
+ *     reworded on a later pass reset the count to 1, so a park never came (or a
+ *     standing park was dropped) and the coding loop resumed (injection #13, root
+ *     cause #15);
+ *   - achievedStatement: the authored-from-evidence side, reworded the same way;
  *   - diffCitation: cites the specific changed hunk, which churns every time the
- *     team edits ANYTHING, so including it would make an unclearable shortfall
- *     look "changed" and defeat the discriminator.
- * So a team that genuinely changed its approach (different node targeted, or a
- * different reason the gap stands) produces a different signature and keeps
- * routing as ordinary re-work; a team stuck against an impossible claim produces
- * the same signature every time.
+ *     team edits ANYTHING.
+ * So a genuinely different gap (a different node, or a different declared claim)
+ * produces a different signature and keeps routing as ordinary re-work; a team
+ * stuck against an impossible claim produces the same signature every time,
+ * however the model phrases it. A team that produces new work is still judged
+ * fresh: the park also keys on the delivery commit set (verify/shortfall-park.ts).
  */
 export declare function shortfallSignature(shortfalls: readonly TargetShortfall[]): string;
+/**
+ * A persisted signature in the CURRENT canonical form, for comparison. A record
+ * written before the reason was dropped from the key (a JSON array of
+ * {nodeId, declared, reason}) re-keys to the form shortfallSignature produces
+ * now, so a repeat count or standing park persisted before this change continues
+ * instead of resetting once on deploy (which would release a standing park back
+ * to coding). A current-form signature is returned unchanged; anything
+ * unparseable is returned as-is and so matches only itself. Pure.
+ */
+export declare function normalizeShortfallSignature(signature: string): string;
+/** Whether two persisted signatures name the same shortfall set (legacy forms normalized). Pure. */
+export declare function sameShortfallSignature(a: string, b: string): boolean;
 /**
  * Read the repeat state the previous shortfall iteration left on a delivery's
  * gate_state. It is either LIVE (`shortfallReconciliation.repeat`, the gate is

package/dist/verify/shortfall-repeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shortfall-repeat.d.ts","sourceRoot":"","sources":["../../src/verify/shortfall-repeat.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACpG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,yFAAyF;AACzF,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sCAAsC,IAAI,CAAC;AAMxD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,CAKjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,GAAG,IAAI,CAE5G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACpD,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,SAAS,GAAE,MAA+C,GACzD;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAKnD"}
+{"version":3,"file":"shortfall-repeat.d.ts","sourceRoot":"","sources":["../../src/verify/shortfall-repeat.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACpG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,yFAAyF;AACzF,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,kIAAkI;IAClI,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,mFAAmF;AACnF,eAAO,MAAM,sCAAsC,IAA8B,CAAC;AAmBlF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,CAEjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAerE;AAED,oGAAoG;AACpG,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,GAAG,IAAI,CAE5G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACpD,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,SAAS,GAAE,MAAoC,GAC9C;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAKnD"}

package/dist/verify/shortfall-repeat.js

@@ -1,5 +1,6 @@
 // PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
 // Pinned by: packages/daemon/src/integration/verification-history-round-trip.test.ts,
+//   packages/daemon/src/verify/misattributed-hold.test.ts, packages/daemon/src/verify/shortfall-park.test.ts,
 //   packages/daemon/src/verify/shortfall-repeat.test.ts, packages/daemon/src/verify/shortfall-routing.test.ts
 // PINNED-BY-END
 /**
@@ -31,44 +32,97 @@
  */
 import { readVerificationHistory } from '../queries/delivery-gate-state.js';
 /**
- * How many consecutive identical shortfall iterations mark a claim as unclearable.
+ * How many consecutive identical shortfall judgements PARK a delivery -- the
+ * stated limit of the shortfall park (verify/shortfall-park.ts), re-exported
+ * there. One constant: the park REPLACES the old unclearable-claim hold as the
+ * at-limit outcome, so the two can never disagree.
  *
  * JUDGMENT CALL (recorded here rather than defaulted silently): too LOW and a team
  * legitimately re-attempting the same area gets cut off before it can respond; too
- * HIGH and the loop stays expensive. The Tinker Tailor case ran to iteration 10
- * and the Telora case to 6, so the current iteration cap is far too high to catch
- * this early. 3 identical occurrences -- i.e. the shortfall survived TWO re-work
+ * HIGH and the loop stays expensive. The Tinker Tailor case ran to iteration 10,
+ * the Telora case to 6, and the 2026-09 incident this park answers ran to
+ * iterationCount 23 -- a coding team respawned each time with nothing truthful to
+ * commit. 3 identical occurrences -- i.e. the shortfall survived TWO re-work
  * responses unchanged -- is strong evidence the diff cannot move it, while still
- * giving a responding team two full cycles to change something. Reversible: it is
- * a single constant, tunable later, and overridable per-call for tests. Kept a
+ * giving a responding team two full cycles to change something. And the park
+ * counts only on an UNCHANGED delivery commit set: a team that commits new work
+ * restarts the count, so the limit never cuts short a team that is still
+ * producing. Reversible: a single constant, overridable per-call for tests. Kept a
  * daemon-local constant (not a TELORA_* env var) deliberately -- adding an env var
  * would require a daemon-core publish; promote it there only if operators need to
  * tune it live.
  */
-export const UNCLEARABLE_SHORTFALL_REPEAT_THRESHOLD = 3;
+export const SHORTFALL_PARK_REPEAT_LIMIT = 3;
+/** The former name of SHORTFALL_PARK_REPEAT_LIMIT, kept for existing importers. */
+export const UNCLEARABLE_SHORTFALL_REPEAT_THRESHOLD = SHORTFALL_PARK_REPEAT_LIMIT;
 function byId(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
+function canonicalSignature(identities) {
+    const unique = new Map();
+    for (const i of identities)
+        unique.set(JSON.stringify([i.nodeId, i.declared]), { nodeId: i.nodeId, declared: i.declared });
+    const key = [...unique.values()].sort((a, b) => byId(a.nodeId, b.nodeId) || byId(a.declared, b.declared));
+    return JSON.stringify(key);
+}
 /**
  * Compute a stable, order-independent signature of a shortfall set.
  *
- * Keyed on (nodeId, declaredStatement, reason) per targeted node, sorted by
- * nodeId -- the fields that define "the same shortfall". DELIBERATELY EXCLUDES:
- *   - achievedStatement: the authored-from-evidence side can vary in wording
- *     across iterations while the underlying gap is identical;
+ * Keyed on (nodeId, declaredStatement) per targeted node -- the fields that
+ * define "the same gap" -- deduped and sorted. Both are STABLE across verify
+ * passes: nodeId is the tree node, and declaredStatement is read off that node
+ * (its preserved frt_statement, else its UDE statement: verify/verify-restatement.ts),
+ * so it changes only when someone edits the tree -- a genuine change of claim.
+ * DELIBERATELY EXCLUDES every MODEL-AUTHORED field, which the reconciler writes
+ * afresh on each pass:
+ *   - reason: the divergence explanation. Kept on the shortfall as display detail
+ *     only. When it was part of the key, an identical gap whose reason was merely
+ *     reworded on a later pass reset the count to 1, so a park never came (or a
+ *     standing park was dropped) and the coding loop resumed (injection #13, root
+ *     cause #15);
+ *   - achievedStatement: the authored-from-evidence side, reworded the same way;
  *   - diffCitation: cites the specific changed hunk, which churns every time the
- *     team edits ANYTHING, so including it would make an unclearable shortfall
- *     look "changed" and defeat the discriminator.
- * So a team that genuinely changed its approach (different node targeted, or a
- * different reason the gap stands) produces a different signature and keeps
- * routing as ordinary re-work; a team stuck against an impossible claim produces
- * the same signature every time.
+ *     team edits ANYTHING.
+ * So a genuinely different gap (a different node, or a different declared claim)
+ * produces a different signature and keeps routing as ordinary re-work; a team
+ * stuck against an impossible claim produces the same signature every time,
+ * however the model phrases it. A team that produces new work is still judged
+ * fresh: the park also keys on the delivery commit set (verify/shortfall-park.ts).
  */
 export function shortfallSignature(shortfalls) {
-    const key = [...shortfalls]
-        .map((s) => ({ nodeId: s.nodeId, declared: s.declaredStatement, reason: s.reason }))
-        .sort((a, b) => byId(a.nodeId, b.nodeId));
-    return JSON.stringify(key);
+    return canonicalSignature(shortfalls.map((s) => ({ nodeId: s.nodeId, declared: s.declaredStatement })));
+}
+/**
+ * A persisted signature in the CURRENT canonical form, for comparison. A record
+ * written before the reason was dropped from the key (a JSON array of
+ * {nodeId, declared, reason}) re-keys to the form shortfallSignature produces
+ * now, so a repeat count or standing park persisted before this change continues
+ * instead of resetting once on deploy (which would release a standing park back
+ * to coding). A current-form signature is returned unchanged; anything
+ * unparseable is returned as-is and so matches only itself. Pure.
+ */
+export function normalizeShortfallSignature(signature) {
+    let parsed;
+    try {
+        parsed = JSON.parse(signature);
+    }
+    catch {
+        return signature;
+    }
+    if (!Array.isArray(parsed))
+        return signature;
+    const identities = [];
+    for (const entry of parsed) {
+        const e = entry;
+        if (!e || typeof e.nodeId !== 'string' || typeof e.declared !== 'string')
+            return signature;
+        identities.push({ nodeId: e.nodeId, declared: e.declared });
+    }
+    return canonicalSignature(identities);
+}
+/** Whether two persisted signatures name the same shortfall set (legacy forms normalized). Pure. */
+export function sameShortfallSignature(a, b) {
+    return a === b || normalizeShortfallSignature(a) === normalizeShortfallSignature(b);
 }
 /**
  * Read the repeat state the previous shortfall iteration left on a delivery's
@@ -94,10 +148,10 @@ export function readPriorRepeat(priorGateState) {
  * returned `repeat` back into the new gate_state so the next iteration compares
  * against it.
  */
-export function classifyShortfallRepeat(priorGateState, shortfalls, threshold = UNCLEARABLE_SHORTFALL_REPEAT_THRESHOLD) {
+export function classifyShortfallRepeat(priorGateState, shortfalls, threshold = SHORTFALL_PARK_REPEAT_LIMIT) {
     const signature = shortfallSignature(shortfalls);
     const prior = readPriorRepeat(priorGateState);
-    const count = prior && prior.signature === signature ? prior.count + 1 : 1;
+    const count = prior && sameShortfallSignature(prior.signature, signature) ? prior.count + 1 : 1;
     return { repeat: { signature, count }, unclearable: count >= threshold };
 }
 //# sourceMappingURL=shortfall-repeat.js.map

package/dist/verify/shortfall-repeat.js.map

@@ -1 +1 @@
-{"version":3,"file":"shortfall-repeat.js","sourceRoot":"","sources":["../../src/verify/shortfall-repeat.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sFAAsF;AACtF,8GAA8G;AAC9G,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,uBAAuB,EAA0B,MAAM,mCAAmC,CAAC;AAWpG;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,CAAC;AAExD,SAAS,IAAI,CAAC,CAAS,EAAE,CAAS;IAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAsC;IACvE,MAAM,GAAG,GAAG,CAAC,GAAG,UAAU,CAAC;SACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;SACnF,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,cAAoD;IAClF,OAAO,uBAAuB,CAAC,cAAc,CAAC,CAAC,eAAe,IAAI,IAAI,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CACrC,cAAoD,EACpD,UAAsC,EACtC,YAAoB,sCAAsC;IAE1D,MAAM,SAAS,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,KAAK,GAAG,eAAe,CAAC,cAAc,CAAC,CAAC;IAC9C,MAAM,KAAK,GAAG,KAAK,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,IAAI,SAAS,EAAE,CAAC;AAC3E,CAAC"}
+{"version":3,"file":"shortfall-repeat.js","sourceRoot":"","sources":["../../src/verify/shortfall-repeat.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,106 @@
+/**
+ * Verify honors OPERATOR SHORTFALL RULINGS: a node an operator ruled MET or
+ * EXCUSED on a delivery (queries/shortfall-rulings.ts) no longer holds its verify
+ * gate, and a ruling recorded since a shortfall park is a change verify re-judges.
+ *
+ * Why: before rulings were read, an operator's "these nodes are met, re-verify"
+ * lived only in an escalation's resolution notes. The next verify pass re-judged
+ * the same nodes short and re-held the delivery, and a delivery parked for a
+ * repeating shortfall (verify/shortfall-park.ts) stayed parked: nothing but a new
+ * commit re-armed its verify.
+ *
+ * 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.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 read only when the reconciliation found a shortfall: with none,
+ * there is nothing to rule and no park to record a fingerprint on.
+ *
+ * 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/verification-default-on.ts), and a parked delivery stays in
+ * verify, so with no new commit verify never re-judged it -- a ruling alone could
+ * not 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/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.
+ *
+ * @module verify/shortfall-rulings
+ */
+import type { getFocusDeliveries } from '../queries/focuses.js';
+import type { DeliveryShortfallRulings, ShortfallRuling } from '../queries/shortfall-rulings.js';
+import type { PendingVerification } from '../queries/verification.js';
+import type { TargetRestatement, TargetShortfall } from './verify-restatement.js';
+/** Read a delivery's active shortfall rulings (queries/shortfall-rulings.ts getDeliveryShortfallRulings). */
+export type ShortfallRulingsReader = (deliveryId: string) => Promise<DeliveryShortfallRulings>;
+/** A ruling that cleared one of this judgement's shortfalls. */
+export type HonoredRuling = Pick<ShortfallRuling, 'nodeId' | 'verdict' | 'rationale'>;
+/** 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[];
+}
+/**
+ * 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 | undefined): Promise<RuledReconciliation>;
+/** The injection evidence with the honored rulings appended (unchanged when none were honored). Pure. */
+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).
+ * Unchanged when the deps carry no rulings reader.
+ */
+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/shortfall-rulings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortfall-rulings.d.ts","sourceRoot":"","sources":["../../src/verify/shortfall-rulings.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACjG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAQlF,6GAA6G;AAC7G,MAAM,MAAM,sBAAsB,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAE/F,gEAAgE;AAChE,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC,CAAC;AAEtF,4DAA4D;AAC5D,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,mEAAmE;IACnE,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,iHAAiH;IACjH,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,iGAAiG;IACjG,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iEAAiE;IACjE,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,YAAY,GAAG,cAAc,CAAC,EAC3D,UAAU,EAAE;IAAE,YAAY,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,EAClG,IAAI,EAAE,sBAAsB,GAAG,SAAS,GACvC,OAAO,CAAC,mBAAmB,CAAC,CA0C9B;AAED,yGAAyG;AACzG,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAK9F;AAMD,4CAA4C;AAC5C,KAAK,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,iBAAiB,GAAG,WAAW,GAAG,oBAAoB,CAAC,CAAC;AAK5J;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,MAAM,EAAE,CAAC,CAuBnB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;IAAC,oBAAoB,CAAC,EAAE,sBAAsB,CAAA;CAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAS/J;AAED,wDAAwD;AACxD,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D"}