@telora/daemon 0.22.239 → 0.22.289

package/dist/verify/run-selection/explicit-rearm.js

@@ -0,0 +1,165 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/integration/explicit-verdict-departure-during-removal.test.ts,
+//   packages/daemon/src/integration/explicit-verdict-invalidation-restart.test.ts,
+//   packages/daemon/src/integration/explicit-verdict-reuse.test.ts,
+//   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/engine/verification-commit-sharing.test.ts
+// PINNED-BY-END
+/**
+ * Re-arm an explicit-method verification whose recorded pass does not cover the
+ * focus HEAD under the gate its row names now.
+ *
+ * daemon_get_pending_verifications lists an explicit-method row only while its
+ * verification_outcome is null or pending: the edge keeps a pass (and nulls a
+ * failure, which re-admits it). The default-on scan skips every row that names a
+ * method (verify/run-selection/verification-default-on.ts). So without this scan, once an
+ * explicit row passes at commit A, nothing runs its gate again: a team commit B is
+ * never judged, and the review exit either holds for a verdict no run will render
+ * or -- through a commit-less row pass -- takes A's pass for B. The same holds for
+ * the gate: the edge lets an operator change a row's method or config without
+ * resetting its outcome, so a new gate at an unchanged commit would never run
+ * either.
+ *
+ * Each tick, for a delivery still in verify whose durable row names a method that
+ * renders verdicts (not the always-pending behavioral scaffold) and records a pass,
+ * this reads the verdict its run is known to have rendered -- this process's record
+ * of the run, else the one on the delivery's gate_state
+ * (verify/gate-verdicts/explicit-gate-outcome.ts) -- and selects the row again, built from its
+ * durable columns, as an explicit candidate unless that verdict was rendered under
+ * the gate the row names now (explicitGateKeyOf) for the focus HEAD or for no commit:
+ *   - only at a readable HEAD: an unreadable one re-arms nothing;
+ *   - a verdict that judged NO commit (an in-place run, an ai_inspection) under the
+ *     row's gate applies to the delivery, not to a commit: not re-armed;
+ *   - a pass with no record of its run (a gate_state write that never landed), or
+ *     one rendered under another gate, stands in for nothing, so it is re-armed;
+ *   - not while a run for the delivery is selected or in flight, and at most once
+ *     per (delivery, HEAD, gate) in this process once that run has routed a result:
+ *     a routed result either moves the row off its pass (the edge records a
+ *     pending, nulls a failure -- the pending queue takes it from there) or records
+ *     the verdict this scan reads; a per-commit verdict a deterministic row's
+ *     dispatch takes in place of a run is a routed result too.
+ * A re-armed run that routes NOTHING -- never started (the verdict its previous run
+ * recorded could not be durably removed, its delivery left verify, or its status
+ * could not be re-read), left verify mid-run, or threw -- judged nothing for the
+ * delivery, so the tick releases the mark (releaseExplicitRearm,
+ * verify/engine/verification-commit-sharing.ts) and a later tick selects the unjudged HEAD
+ * again, rather than leaving it unjudged, and review held, until a restart or
+ * another commit.
+ * The explicit gate therefore runs once per new commit or gate, across ticks and a
+ * restart. Never throws.
+ *
+ * @module verify/run-selection/explicit-rearm
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { isGateRunSelected } from '../gate-verdicts/gate-run-registry.js';
+import { readExplicitGateOutcomeRecord } from '../gate-verdicts/explicit-gate-outcome.js';
+import { explicitGateKeyOf } from '../gate-verdicts/commit-verdict-record.js';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'verification' });
+/** The (HEAD, gate) each delivery was last re-armed at in this process. */
+const rearmedAt = new Map();
+/** The mark each re-armed candidate set, so its dispatch releases exactly that mark. */
+const candidateMarks = new WeakMap();
+/** A method whose run renders a verdict (the behavioral scaffold always returns pending). */
+function rendersVerdict(method) {
+    return method === 'deterministic' || method === 'ai_inspection';
+}
+function configRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : null;
+}
+/** Why the recorded verdict does not cover `sha` under `gateKey`, or null when it does. */
+function uncoveredBecause(recorded, sha, gateKey) {
+    if (recorded === null)
+        return 'there is no record of its run';
+    if (recorded.gateKey !== gateKey)
+        return 'its recorded verdict was rendered under another gate';
+    if (recorded.sha === null || recorded.sha === sha)
+        return null;
+    return `its recorded verdict judged ${recorded.sha.slice(0, 8)}`;
+}
+/**
+ * The explicit-method rows of the product to select again this tick (see the
+ * module header). `pendingIds` are the rows daemon_get_pending_verifications
+ * already listed. Never throws: an unreadable focus list or delivery list re-arms
+ * nothing for it, and the next tick asks again.
+ */
+export async function collectRearmedExplicitVerifications(config, pendingIds, deps) {
+    const candidates = [];
+    let focuses;
+    try {
+        focuses = await deps.getActiveFocuses(config.organizationId, config.productId);
+    }
+    catch (err) {
+        log.warn(`[verification] explicit re-arm: failed to list focuses for product ${config.productId}:`, err.message);
+        return candidates;
+    }
+    for (const focus of focuses) {
+        if (focus.read_only === true)
+            continue;
+        let deliveries;
+        try {
+            deliveries = await deps.getFocusDeliveries(focus.focus_id);
+        }
+        catch (err) {
+            log.warn(`[verification] explicit re-arm: failed to fetch deliveries for focus ${focus.focus_id.slice(0, 8)}:`, err.message);
+            continue;
+        }
+        let head;
+        const readHead = () => (head ??= { sha: deps.resolveFocusHeadSha(focus.focus_id) }).sha;
+        for (const d of deliveries) {
+            const method = d.verificationMethod;
+            if (d.executionStatus !== DELIVERY_STATUS.VERIFY || !d.injectionId || !rendersVerdict(method))
+                continue;
+            if (d.verificationOutcome !== 'passed' || pendingIds.has(d.id) || isGateRunSelected(d.id))
+                continue;
+            const sha = readHead();
+            if (sha === null)
+                continue;
+            const verificationConfig = configRecord(d.verificationConfig);
+            const gateKey = explicitGateKeyOf(method, verificationConfig);
+            const mark = `${sha}:${gateKey}`;
+            if (rearmedAt.get(d.id) === mark)
+                continue;
+            const why = uncoveredBecause(readExplicitGateOutcomeRecord(d.id, d.gateState), sha, gateKey);
+            if (why === null)
+                continue;
+            rearmedAt.set(d.id, mark);
+            log.info(`[verification] explicit: re-arming delivery "${d.name}" (${d.id}) at focus HEAD ${sha.slice(0, 8)} -- ${why}`);
+            const candidate = {
+                deliveryId: d.id,
+                deliveryName: d.name,
+                productId: config.productId,
+                focusId: focus.focus_id,
+                injectionNodeId: d.injectionId,
+                verificationMethod: method,
+                verificationConfig,
+                verificationOutcome: null,
+                verificationLastRunAt: null,
+                gitState: d.gitState,
+                mergeCommitSha: d.mergeCommitSha,
+            };
+            candidateMarks.set(candidate, mark);
+            candidates.push(candidate);
+        }
+    }
+    return candidates;
+}
+/**
+ * Release the re-arm mark `candidate` set, when its run never judged its commit
+ * (see the module header), so the scan selects the delivery again at the same HEAD
+ * and gate. A no-op for a candidate this scan did not build, or once a later re-arm
+ * replaced its mark.
+ */
+export function releaseExplicitRearm(candidate) {
+    const mark = candidateMarks.get(candidate);
+    if (mark !== undefined && rearmedAt.get(candidate.deliveryId) === mark)
+        rearmedAt.delete(candidate.deliveryId);
+}
+/** Test seam: forget every re-arm this process made. */
+export function __resetExplicitRearmForTests() {
+    rearmedAt.clear();
+}
+//# sourceMappingURL=explicit-rearm.js.map

package/dist/verify/run-selection/explicit-rearm.js.map

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

package/dist/verify/run-selection/explicit-row-selection.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Which explicit-method rows a verification tick may dispatch.
+ *
+ * THE EDGE RE-LISTS a pending or failed explicit row EVERY TICK, and nothing on
+ * that path consults a run mark -- the default-on scan's guards do not cover it.
+ * Without this filter a parked explicit row would be dispatched every tick at an
+ * unchanged HEAD forever (verify/shortfalls/shortfall-rulings.ts carries the closed list of
+ * paths that may re-select a parked delivery).
+ *
+ * A re-listing is neither a new ruling nor a new commit, so it is not one of the
+ * two things the declared rule lets re-select a parked delivery. A row whose
+ * shortfall park stands on an unchanged commit set and unchanged rulings is
+ * therefore DROPPED here, and says so in its own re-selection line -- a declined
+ * re-selection is as diagnosable from the log as a taken one.
+ *
+ * WHAT IS STILL DISPATCHED, unchanged: a row whose facts MOVED (a new commit, a
+ * new ruling) and a row any of whose facts is UNKNOWN. This only ever removes a
+ * dispatch it can PROVE is pointless; an unreadable gate_state, commit set or
+ * rulings read dispatches exactly as before. The park read costs one gate_state
+ * read per listed row and stops at "no park" for the ordinary case
+ * (verify/shortfalls/parked-shortfall-reuse.ts).
+ *
+ * ONE LINE PER RE-SELECTION, not per listing. A listing is not a re-selection:
+ * the edge lists the row every tick whether or not anything happens to it, and
+ * its dispatch starts nothing for a delivery that left verify meanwhile. What
+ * re-selects a delivery IN VERIFY is a dispatch that ROUTES a verdict for it, so
+ * that is where the line is written (noteRelistedDispatch, called by the tick
+ * after each dispatch) -- once per routed dispatch, never de-duplicated, so a row
+ * re-dispatched every tick writes a line every tick. A declined listing still
+ * writes its own line, de-duplicated per (outcome, last run): it re-selects
+ * nothing, and repeating it would say nothing new.
+ *
+ * History: docs/daemon/history-verify.md (verify/run-selection/explicit-row-selection.ts).
+ *
+ * @module verify/run-selection/explicit-row-selection
+ */
+import type { PendingVerification } from '../../queries/verification/verification.js';
+import type { StrategyResult } from '../deterministic-gate/verification-deterministic.js';
+import { type ParkedShortfallReuseDeps } from '../shortfalls/parked-shortfall-reuse.js';
+export declare function selectDispatchableExplicitRows(pending: readonly PendingVerification[], deps: ParkedShortfallReuseDeps): Promise<PendingVerification[]>;
+/**
+ * The re-selection line for a row the listing passed on: written when its
+ * dispatch ROUTED a verdict (the delivery was in verify and was judged again),
+ * once per dispatch. A dispatch that routed nothing re-selected nothing and
+ * writes nothing; a row that did not come from the listing is not this path's.
+ */
+export declare function noteRelistedDispatch(row: PendingVerification, routed: StrategyResult | null): void;
+//# sourceMappingURL=explicit-row-selection.d.ts.map

package/dist/verify/run-selection/explicit-row-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-row-selection.d.ts","sourceRoot":"","sources":["../../../src/verify/run-selection/explicit-row-selection.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAC1F,OAAO,EAA6B,KAAK,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAGnH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAmBhC;AAKD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAQlG"}

package/dist/verify/run-selection/explicit-row-selection.js

@@ -0,0 +1,37 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/run-selection/explicit-row-selection.test.ts
+// PINNED-BY-END
+import { parkHoldsOnUnchangedFacts } from '../shortfalls/parked-shortfall-reuse.js';
+import { logReselection } from './reselection-log-line.js';
+export async function selectDispatchableExplicitRows(pending, deps) {
+    const out = [];
+    for (const row of pending) {
+        const outcome = row.verificationOutcome ?? 'none';
+        const lastRun = row.verificationLastRunAt ?? 'never';
+        if (await parkHoldsOnUnchangedFacts(row, null, deps)) {
+            logReselection('pending-relisting', row.deliveryId, `DECLINED: the pending-verifications queue lists its explicit ${row.verificationMethod} row `
+                + `(outcome ${outcome}, last run ${lastRun}), but its shortfall park stands on an unchanged commit `
+                + 'set and unchanged rulings -- a re-listing is neither a new ruling nor a new commit, so it is not dispatched', `park-declined@${outcome}@${lastRun}`);
+            continue;
+        }
+        relisted.add(row);
+        out.push(row);
+    }
+    return out;
+}
+/** The rows this tick's listing passed on to dispatch (identity, so a re-armed copy of a row is not one). */
+const relisted = new WeakSet();
+/**
+ * The re-selection line for a row the listing passed on: written when its
+ * dispatch ROUTED a verdict (the delivery was in verify and was judged again),
+ * once per dispatch. A dispatch that routed nothing re-selected nothing and
+ * writes nothing; a row that did not come from the listing is not this path's.
+ */
+export function noteRelistedDispatch(row, routed) {
+    if (!routed || !relisted.has(row))
+        return;
+    logReselection('pending-relisting', row.deliveryId, `the pending-verifications queue re-listed its explicit ${row.verificationMethod} row `
+        + `(outcome ${row.verificationOutcome ?? 'none'}, last run ${row.verificationLastRunAt ?? 'never'}) `
+        + `and its dispatch routed '${routed.outcome}'`);
+}
+//# sourceMappingURL=explicit-row-selection.js.map

package/dist/verify/run-selection/explicit-row-selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-row-selection.js","sourceRoot":"","sources":["../../../src/verify/run-selection/explicit-row-selection.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,qFAAqF;AACrF,gBAAgB;AAyChB,OAAO,EAAE,yBAAyB,EAAiC,MAAM,yCAAyC,CAAC;AACnH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAClD,OAAuC,EACvC,IAA8B;IAE9B,MAAM,GAAG,GAA0B,EAAE,CAAC;IACtC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,GAAG,CAAC,mBAAmB,IAAI,MAAM,CAAC;QAClD,MAAM,OAAO,GAAG,GAAG,CAAC,qBAAqB,IAAI,OAAO,CAAC;QACrD,IAAI,MAAM,yBAAyB,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACrD,cAAc,CACZ,mBAAmB,EAAE,GAAG,CAAC,UAAU,EACnC,gEAAgE,GAAG,CAAC,kBAAkB,OAAO;kBAC3F,YAAY,OAAO,cAAc,OAAO,0DAA0D;kBAClG,6GAA6G,EAC/G,iBAAiB,OAAO,IAAI,OAAO,EAAE,CACtC,CAAC;YACF,SAAS;QACX,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,6GAA6G;AAC7G,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAuB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAwB,EAAE,MAA6B;IAC1F,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAC1C,cAAc,CACZ,mBAAmB,EAAE,GAAG,CAAC,UAAU,EACnC,0DAA0D,GAAG,CAAC,kBAAkB,OAAO;UACrF,YAAY,GAAG,CAAC,mBAAmB,IAAI,MAAM,cAAc,GAAG,CAAC,qBAAqB,IAAI,OAAO,IAAI;UACnG,4BAA4B,MAAM,CAAC,OAAO,GAAG,CAChD,CAAC;AACJ,CAAC"}

package/dist/verify/run-selection/reselection-log-line.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Every path that can re-select a delivery already sitting in verify. A new path
+ * belongs here AND at a `logReselection` call site; the enumeration test fails
+ * on a member with no driver.
+ */
+export declare const RESELECTION_PATHS: readonly ["run-mark-prune", "run-mark-release", "commit-verdict-pull", "credit-rearm", "ruling-rearm", "pending-relisting", "model-unavailable-unmark", "checkout-unavailable-unmark"];
+/** One of {@link RESELECTION_PATHS}. */
+export type ReselectionPath = (typeof RESELECTION_PATHS)[number];
+/** Test-only: forget every de-duplicated line written so far. */
+export declare function __resetReselectionLogForTests(): void;
+/**
+ * Write the one line for this re-selection.
+ *
+ * `dedupeKey` is for a line that fires REPEATEDLY for the same (delivery,
+ * reason) WITHOUT re-selecting anything -- a DECLINED re-selection, e.g. a parked
+ * row the edge re-lists every tick. Pass it and the line is written once per
+ * (path, delivery, key). A line for a re-selection that happens -- a dispatch
+ * follows -- is never de-duplicated: the repetition IS the information (the
+ * incident's ~30 re-dispatches should have produced ~30 lines, not one).
+ */
+export declare function logReselection(path: ReselectionPath, deliveryId: string, detail: string, dedupeKey?: string): void;
+//# sourceMappingURL=reselection-log-line.d.ts.map

package/dist/verify/run-selection/reselection-log-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reselection-log-line.d.ts","sourceRoot":"","sources":["../../../src/verify/run-selection/reselection-log-line.ts"],"names":[],"mappings":"AAwCA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,wLAiBpB,CAAC;AAEX,wCAAwC;AACxC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAKjE,iEAAiE;AACjE,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAON"}

package/dist/verify/run-selection/reselection-log-line.js

@@ -0,0 +1,85 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/run-selection/explicit-row-selection.test.ts,
+//   packages/daemon/src/verify/run-selection/reselection-log-line.test.ts,
+//   packages/daemon/src/verify/run-selection/verification-default-on.test.ts
+// PINNED-BY-END
+/**
+ * ONE daemon-log line (~/.telora/daemon.log) per re-selection of a delivery sitting in verify, naming the PATH
+ * that re-selected it.
+ *
+ * Why this module exists: a re-dispatch of a delivery sitting in verify must be
+ * attributable from ~/.telora/daemon.log alone. The dispatch and its outcome are
+ * logged where they happen, but not WHY the delivery was selected again, and
+ * without this module the paths that re-arm a delivery log per FOCUS, log
+ * nothing, or log in their own private shape.
+ *
+ * History: docs/daemon/history-verify.md (verify/run-selection/reselection-log-line.ts).
+ *
+ * The rule: a delivery whose guards are dropped is a delivery that WILL be
+ * selected again, and exactly one line says which path dropped them. The path
+ * names are an exported const union, so the shape cannot drift and a path added
+ * later without a log line is a visible hole (verify/run-selection/reselection-log-line.test.ts
+ * enumerates the union).
+ *
+ * WHO LOGS. Each path logs at its OWN call site, because only there is the
+ * reason known. The guard mutators in verify/run-selection/default-on-guards.ts are the
+ * fallback, not a second voice: `releaseDefaultOnMark(id)` called with no path
+ * logs 'run-mark-release', and called WITH a path stays silent so the caller's
+ * own richer line stands alone.
+ *
+ * A line is only written when something was actually dropped -- a release that
+ * found no mark suppressed nothing and re-selected nothing.
+ *
+ * @module verify/run-selection/reselection-log-line
+ */
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'verification' });
+/**
+ * Every path that can re-select a delivery already sitting in verify. A new path
+ * belongs here AND at a `logReselection` call site; the enumeration test fails
+ * on a member with no driver.
+ */
+export const RESELECTION_PATHS = [
+    /** The default-on scan no longer observed the delivery in verify (default-on-guards.ts pruneGuardsOutsideVerify). */
+    'run-mark-prune',
+    /** The run mark was dropped by a caller that named no path of its own (default-on-guards.ts releaseDefaultOnMark). */
+    'run-mark-release',
+    /** A route held for a verdict on the current HEAD pulled the run (commit-verdict-pull.ts). */
+    'commit-verdict-pull',
+    /** The focus's commit-credit set changed, so the same commit is judged again (credit-rearm.ts). */
+    'credit-rearm',
+    /** An operator ruling released a shortfall park (shortfall-rulings.ts rearmRuledShortfallParks). */
+    'ruling-rearm',
+    /** The edge re-listed an explicit-method row in the pending queue (verification-engine.ts). */
+    'pending-relisting',
+    /** The reconciliation's model could not be reached: no verdict to guard (default-on-guards.ts noteDefaultOnResult). */
+    'model-unavailable-unmark',
+    /** No checkout could be made, or the verdict was discarded mid-run (default-on-guards.ts noteDefaultOnResult). */
+    'checkout-unavailable-unmark',
+];
+/** `${path}@${deliveryId}@${dedupeKey}` triples already written. */
+const written = new Set();
+/** Test-only: forget every de-duplicated line written so far. */
+export function __resetReselectionLogForTests() {
+    written.clear();
+}
+/**
+ * Write the one line for this re-selection.
+ *
+ * `dedupeKey` is for a line that fires REPEATEDLY for the same (delivery,
+ * reason) WITHOUT re-selecting anything -- a DECLINED re-selection, e.g. a parked
+ * row the edge re-lists every tick. Pass it and the line is written once per
+ * (path, delivery, key). A line for a re-selection that happens -- a dispatch
+ * follows -- is never de-duplicated: the repetition IS the information (the
+ * incident's ~30 re-dispatches should have produced ~30 lines, not one).
+ */
+export function logReselection(path, deliveryId, detail, dedupeKey) {
+    if (dedupeKey !== undefined) {
+        const key = `${path}@${deliveryId}@${dedupeKey}`;
+        if (written.has(key))
+            return;
+        written.add(key);
+    }
+    log.info(`[verification] re-selection (${path}): delivery ${deliveryId} -- ${detail}`);
+}
+//# sourceMappingURL=reselection-log-line.js.map

package/dist/verify/run-selection/reselection-log-line.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reselection-log-line.js","sourceRoot":"","sources":["../../../src/verify/run-selection/reselection-log-line.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sFAAsF;AACtF,2EAA2E;AAC3E,6EAA6E;AAC7E,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,qHAAqH;IACrH,gBAAgB;IAChB,sHAAsH;IACtH,kBAAkB;IAClB,8FAA8F;IAC9F,qBAAqB;IACrB,mGAAmG;IACnG,cAAc;IACd,oGAAoG;IACpG,cAAc;IACd,+FAA+F;IAC/F,mBAAmB;IACnB,uHAAuH;IACvH,0BAA0B;IAC1B,kHAAkH;IAClH,6BAA6B;CACrB,CAAC;AAKX,oEAAoE;AACpE,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;AAElC,iEAAiE;AACjE,MAAM,UAAU,6BAA6B;IAC3C,OAAO,CAAC,KAAK,EAAE,CAAC;AAClB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAqB,EACrB,UAAkB,EAClB,MAAc,EACd,SAAkB;IAElB,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,UAAU,IAAI,SAAS,EAAE,CAAC;QACjD,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO;QAC7B,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IACD,GAAG,CAAC,IAAI,CAAC,gCAAgC,IAAI,eAAe,UAAU,OAAO,MAAM,EAAE,CAAC,CAAC;AACzF,CAAC"}

package/dist/verify/run-selection/verification-default-on.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Default-on deterministic verification: selection + concurrency cap.
+ *
+ * This module makes the deterministic verification method the DEFAULT for every
+ * delivery entering verify, not only one carrying an explicit
+ * verification_method: it discovers verify-status
+ * deliveries with no explicit method and synthesizes a `deterministic`
+ * PendingVerification carrying the config-default command, and it caps
+ * concurrent daemon-side runs so a burst cannot spawn N whole-repo suites.
+ *
+ * The dispatch (runVerificationForDelivery / runVerificationTick) lives in
+ * verification-engine.ts and imports from here.
+ *
+ * History: docs/daemon/history-verify.md (verify/run-selection/verification-default-on.ts).
+ *
+ * @module verification-default-on
+ */
+import { type ProductEntry } from '@telora/daemon-core';
+import type { DaemonConfig } from '../../types/index.js';
+import type { PendingVerification } from '../../queries/verification/verification.js';
+import { type DefaultVerificationResolver, type ResolvedDefaultVerification } from '../gate-config/verification-config.js';
+import { type VerifyManifest } from '../gate-config/verification-manifest.js';
+import type { getActiveFocuses } from '../../queries/focuses/focus-discovery.js';
+import type { getFocusDeliveries } from '../../queries/focuses/focuses.js';
+import type { OwedReworkRetry } from '../outcome-routing/verification-rework-issue.js';
+/** Default HEAD reader: the registered focus worktree's HEAD, or null when unreadable. */
+export declare function defaultResolveFocusHeadSha(focusId: string): string | null;
+/**
+ * The subset of verification dependencies the default-on scan needs. Kept as a
+ * narrow structural type (rather than importing the full VerificationDeps) so
+ * there is no runtime import cycle with verification-engine.ts.
+ */
+export interface DefaultOnScanDeps {
+    getActiveFocuses: typeof getActiveFocuses;
+    getFocusDeliveries: typeof getFocusDeliveries;
+    /**
+     * The focus worktree's current HEAD sha, read to keep a delivery whose verify
+     * FAILED or PASSED from re-running on the same unchanged commit. A null read
+     * keeps a recorded failure suppressed (only a KNOWN different commit re-arms
+     * it) but does not suppress a recorded pass (a pass holds nothing back).
+     */
+    resolveFocusHeadSha: (focusId: string) => string | null;
+    /**
+     * The telora.verify.json the focus's judged commit (its worktree HEAD) ships,
+     * read when the product repoPath resolves no command; null when the focus has
+     * no worktree, `unreadable` when git could not answer. Production reads that
+     * commit with git (buildJudgedCommitManifestReader).
+     */
+    readJudgedCommitManifest: (focusId: string) => JudgedCommitRead | null;
+    /** Retries a rework-Bug filing a failure left owed at the failed HEAD (verify/outcome-routing/verification-rework-issue.ts). */
+    retryOwedReworkIssue: OwedReworkRetry;
+}
+/**
+ * Counting semaphore capping concurrent daemon-side verification runs.
+ *
+ * A default-on deterministic run is a full build+test sweep (minutes). The
+ * verification tick passes `skipIfRunning`, so ticks themselves no longer
+ * overlap; the cap guards the remaining fan-out (multiple products within one
+ * tick, and any future callers outside the latched tick). The module-level
+ * singleton below is shared across every invocation, so the cap holds
+ * globally, not just within one call.
+ *
+ * A dedicated semaphore (rather than the shared ResourceGovernor) because the
+ * governor's per-engine slots model agent-team spawns and are wired through
+ * the governor-construction path; runVerificationTick is invoked with only
+ * `config` and has no governor handle. The cap value comes from
+ * resolveDefaultVerification (maxConcurrent).
+ */
+export declare class VerificationSemaphore {
+    private permits;
+    private limit;
+    private readonly waiters;
+    constructor(limit: number);
+    /** Adjust the cap (config change between ticks). Only frees waiters on a raise. */
+    setLimit(limit: number): void;
+    acquire(): Promise<void>;
+    release(): void;
+    /** Test-only: how many permits are currently available. */
+    availablePermits(): number;
+}
+/** Shared cap across all tick invocations. Sized from config at each tick. */
+export declare const verificationSemaphore: VerificationSemaphore;
+/** Test-only: inspect the concurrency semaphore. */
+export declare function __getVerificationSemaphoreForTests(): {
+    availablePermits(): number;
+    setLimit(n: number): void;
+};
+/**
+ * One product's verification scope for a tick: its product-scoped config and
+ * the default-on config resolved FROM that scoped config.
+ */
+export interface ProductVerificationScope {
+    product: ProductEntry;
+    /** Product-scoped config (`configForProduct`): productId + repoPath are this product's. */
+    productConfig: DaemonConfig;
+    /**
+     * The resolved default-on config, or `undefined` when resolution FAILED (a
+     * malformed repo manifest). Undefined means "the repoPath gate is off this
+     * tick" -- never "verification is disabled here", which is what a silent
+     * degrade to '' would have said.
+     */
+    resolved: ResolvedDefaultVerification | undefined;
+    /**
+     * Present only beside an undefined `resolved`: what the default-on scan runs
+     * with instead -- no command, so each delivery is armed by its judged commit
+     * alone. Absent when even that resolution failed.
+     */
+    judgedCommitOnly?: ResolvedDefaultVerification;
+}
+/**
+ * Resolve the default-on verification config for every product, from each
+ * product's OWN scoped config.
+ *
+ * WHY per-product (this is the whole point): the repo-manifest layer is read
+ * from `config.repoPath`, so resolution is only meaningful on a product-scoped
+ * config. A multi-product `daemon.json` (products[] each with their own
+ * repoPath) carries no meaningful TOP-LEVEL repoPath -- `config.ts:158` falls
+ * back to `process.cwd()`, the daemon's LAUNCH DIRECTORY. Resolving once from
+ * the un-scoped config therefore made every product's gate a function of where
+ * the daemon happened to be started: launched outside a repo -> no manifest ->
+ * silently inert; launched inside one product's repo -> that repo's command
+ * applied to every OTHER product's deliveries. Neither is a gate.
+ *
+ * Error containment: `resolveDefaultVerification` THROWS on a malformed
+ * manifest by design (verification-manifest.ts -- a typo must never silently
+ * un-arm the gate). Per-product, an uncaught throw would kill the tick for every
+ * product including healthy ones, so it is contained HERE: logged at ERROR
+ * naming the product and the manifest path (every tick -- a persistent,
+ * operator-visible state, never a debug line), and that product's `resolved`
+ * comes back `undefined`: it contributes no cap while other products keep
+ * gating. The product's EXPLICIT-method deliveries still verify: they carry
+ * their own command on the delivery row, so a repo-root manifest typo has no
+ * bearing on them and must not disarm them.
+ *
+ * Nor does the typo disarm a branch that ships a working gate. repoPath is the
+ * operator's checkout, which may lag the code under verification, so the product
+ * is resolved again with that manifest set aside (`judgedCommitOnly`) and its
+ * scan still arms each delivery from the manifest its judged commit ships. That
+ * resolution carries no command even when env or daemon.json declare one: a
+ * delivery whose commit ships no manifest would fall back at dispatch to the
+ * broken repoPath file and fail on it, so until the file is fixed only
+ * branch-declared gates arm.
+ */
+export declare function resolveProductVerificationScopes(config: DaemonConfig, resolve: DefaultVerificationResolver): ProductVerificationScope[];
+/**
+ * Resolve the ONE daemon-wide concurrency cap for the shared semaphore.
+ *
+ * The cap is DAEMON-WIDE, not per-product, and deliberately so: the semaphore is
+ * a module-level singleton and the resource it protects is the daemon's HOST
+ * (CPU/RAM/disk for a minutes-long build+test sweep), which every product shares.
+ * Three products each declaring `maxConcurrent: 3` must not mean 9 concurrent
+ * suites on one box. So a single value must be chosen -- and simply calling
+ * `setLimit` inside the per-product loop would be incoherent: the LAST product
+ * iterated would silently win for the rest of the tick.
+ *
+ * RULE: the minimum across the products that resolved one. Chosen because:
+ *  - it is order-independent (min is commutative), so no "last product wins";
+ *  - it is fail-safe -- the cap never exceeds any declaration, and over-capping
+ *    only slows a tick where under-capping can thrash the host;
+ *  - it keeps every layer's declaration live rather than silently dropping the
+ *    manifest's `maxConcurrent`. Each product still resolves through the full
+ *    env > operator file > manifest chain, so an operator setting the env var or
+ *    the global block pins EVERY product's value and therefore the min: the
+ *    operator, who alone knows the box, always has the last word. A repo can
+ *    only make the daemon more conservative than the operator's setting, never
+ *    less.
+ * Stated plainly: the daemon runs at most as many concurrent suites as the most
+ * conservative managed repo allows.
+ *
+ * No resolved values at all (every product's manifest malformed) => the
+ * conservative floor, not a stale limit from a previous tick.
+ */
+export declare function resolveDaemonWideVerifyCap(scopes: readonly ProductVerificationScope[]): number;
+/**
+ * What the commit a delivery is judged on declares in telora.verify.json, read
+ * from git AT that sha -- never the worktree's files, which may hold edits the
+ * verify never sees. No `manifest` and no `malformed` means the commit ships none.
+ */
+export interface JudgedCommitManifest {
+    sha: string;
+    /** Where the manifest sits in the focus worktree (the path a source label names). */
+    manifestPath: string;
+    manifest?: VerifyManifest;
+    /** The reader's error when the committed file exists but cannot be used. */
+    malformed?: string;
+}
+/**
+ * Git could not say what the judged commit ships (a failed rev-parse, ls-tree or
+ * show). That is neither "ships none" nor malformed -- it is no answer -- so it
+ * is never remembered: the next tick asks again.
+ */
+export interface JudgedCommitUnreadable {
+    unreadable: string;
+}
+export type JudgedCommitRead = JudgedCommitManifest | JudgedCommitUnreadable;
+type GitRun = (args: string[], cwd: string) => {
+    success: boolean;
+    output: string;
+    error?: string;
+};
+/**
+ * Build the judged-commit manifest reader over a focus -> worktree lookup. A file
+ * is immutable at a sha, so each worktree's last read is reused while its HEAD
+ * is unchanged rather than re-running git every tick. Only reads git answered
+ * are kept; an unreadable one is retried on the next call.
+ */
+export declare function buildJudgedCommitManifestReader(resolveWorktreePath: (focusId: string) => string | null, runGit: GitRun): (focusId: string) => JudgedCommitRead | null;
+/**
+ * The run config a judged commit's telora.verify.json arms: its command, and its
+ * timeout unless an operator layer outranks it. The ONE derivation both the scan
+ * and the commit-gate predicate (verify/gate-config/commit-gate-configured.ts) key a verdict by. Pure.
+ */
+export declare function judgedCommitVerificationConfig(read: JudgedCommitManifest, resolved: ResolvedDefaultVerification): Record<string, unknown>;
+/**
+ * Discover deliveries that should receive a DEFAULT-ON deterministic run: in
+ * `verify` status, anchored to an injection, with no explicit verification
+ * method (so not already returned by getPendingVerifications), not in a
+ * read-only audit focus (those are discovery-only and never run a suite), not
+ * already run this verify-entry (steady-state guard), and not already failed or
+ * passed on the focus's unchanged HEAD (HEAD-keyed guards).
+ *
+ * Synthesizes a `deterministic` PendingVerification carrying the resolved
+ * config-default command + timeout and a `defaultOnSource` marker. Those values
+ * are PROVISIONAL -- resolved against the product repoPath, which may lag the
+ * branch -- and a run on a detached checkout re-resolves both from the verified
+ * code (verify/deterministic-gate/verification-checkout.ts).
+ *
+ * Arming does not wait on repoPath either. When no command resolves there, each
+ * delivery is armed from the telora.verify.json its judged commit ships
+ * (armFromJudgedCommit), so a branch that introduces the gate is verified on its
+ * next run. An operator's `declined` marker is the exception: it suppresses the
+ * repo manifest, and no branch overturns it. With no command anywhere the
+ * feature stays inert.
+ *
+ * `config` must be product-scoped (config.productId identifies the product), and
+ * that is now load-bearing rather than conventional: the guard prune at the end is
+ * SCOPED to config.productId, because a scan of one product observes none of
+ * another's deliveries and must conclude nothing about them (pruneProductGuards).
+ */
+export declare function collectDefaultOnVerifications(config: DaemonConfig, resolved: ResolvedDefaultVerification, explicitDeliveryIds: ReadonlySet<string>, deps: DefaultOnScanDeps): Promise<PendingVerification[]>;
+export {};
+//# sourceMappingURL=verification-default-on.d.ts.map

package/dist/verify/run-selection/verification-default-on.d.ts.map

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