@telora/daemon 0.22.104 → 0.22.132

package/dist/verify/gate-verdict-source.js.map

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

package/dist/verify/judged-commit-gate.d.ts

@@ -0,0 +1,11 @@
+import { type VerificationConfigScope } from './verification-config.js';
+import { type VerifyManifestReader } from './verification-manifest.js';
+import type { CommitVerdictGate } from './commit-verdict-record.js';
+import type { JudgedCommitManifest } from './verification-default-on.js';
+/**
+ * The gate a default-on run applies at the judged commit `read` names (see the
+ * module header), or null when that run would record no verdict. `source` is the
+ * candidate's default-on source (its operator block and the product repoPath).
+ */
+export declare function judgedCommitGate(source: VerificationConfigScope, read: JudgedCommitManifest, env?: NodeJS.ProcessEnv, readManifest?: VerifyManifestReader): CommitVerdictGate | null;
+//# sourceMappingURL=judged-commit-gate.d.ts.map

package/dist/verify/judged-commit-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judged-commit-gate.d.ts","sourceRoot":"","sources":["../../src/verify/judged-commit-gate.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAoC,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAC1G,OAAO,EAAiD,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACtH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,IAAI,EAAE,oBAAoB,EAC1B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,YAAY,GAAE,oBAAyC,GACtD,iBAAiB,GAAG,IAAI,CAW1B"}

package/dist/verify/judged-commit-gate.js

@@ -0,0 +1,48 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/judged-commit-gate.test.ts
+// PINNED-BY-END
+/**
+ * The gate a default-on run of a focus's judged commit actually APPLIES, resolved
+ * without a checkout -- the ONE derivation the per-commit verdict reuse read
+ * (verify/verification-commit-sharing.ts) and verify routing
+ * (verify/commit-gate-configured.ts) key a default-on verdict by.
+ *
+ * A default-on candidate is selected with a command + timeout resolved against
+ * the product repoPath, but its run re-resolves both from the detached checkout
+ * of the judged commit (verify/verification-checkout.ts) and records its verdict
+ * under the config it APPLIED (commit-verdict-record.ts recordCommitVerdictFor).
+ * A branch whose telora.verify.json overrides the repoPath gate therefore runs --
+ * and records -- gate B while it was selected under gate A. A read keyed by A
+ * would reuse a verdict of a gate that never ran on that commit, and miss the one
+ * that did. So this resolves the same layers the run does -- env > operator block
+ * > the manifest the judged commit ships (read from git at that sha) > the
+ * repoPath manifest as fallback -- through resolveAppliedVerificationConfig itself.
+ *
+ * No gate (null) where the run renders no verdict to key: a malformed committed
+ * manifest or a resolution that throws (the run refuses both as unresolvable), or
+ * no command at all.
+ *
+ * @module verify/judged-commit-gate
+ */
+import { dirname } from 'node:path';
+import { resolveAppliedVerificationConfig } from './verification-config.js';
+import { readVerifyManifest, resolveVerifyManifestPath } from './verification-manifest.js';
+/**
+ * The gate a default-on run applies at the judged commit `read` names (see the
+ * module header), or null when that run would record no verdict. `source` is the
+ * candidate's default-on source (its operator block and the product repoPath).
+ */
+export function judgedCommitGate(source, read, env = process.env, readManifest = readVerifyManifest) {
+    if (read.malformed !== undefined)
+        return null;
+    // The judged commit's manifest answers for the worktree path; every other path (the fallback) is read as the run reads it.
+    const atJudgedCommit = (repoPath, fs) => (repoPath !== undefined && resolveVerifyManifestPath(repoPath) === read.manifestPath ? read.manifest : readManifest(repoPath, fs));
+    try {
+        const applied = resolveAppliedVerificationConfig(source, dirname(read.manifestPath), env, atJudgedCommit);
+        return applied.command.trim() === '' ? null : { command: applied.command, timeoutMs: applied.timeoutMs };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=judged-commit-gate.js.map

package/dist/verify/judged-commit-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"judged-commit-gate.js","sourceRoot":"","sources":["../../src/verify/judged-commit-gate.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,mEAAmE;AACnE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,gCAAgC,EAAgC,MAAM,0BAA0B,CAAC;AAC1G,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAA6B,MAAM,4BAA4B,CAAC;AAItH;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAA+B,EAC/B,IAA0B,EAC1B,MAAyB,OAAO,CAAC,GAAG,EACpC,eAAqC,kBAAkB;IAEvD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC9C,2HAA2H;IAC3H,MAAM,cAAc,GAAyB,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,CAC5D,CAAC,QAAQ,KAAK,SAAS,IAAI,yBAAyB,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC;IACrI,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,gCAAgC,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC;QAC1G,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;IAC3G,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/verify/rework-judgment.d.ts

@@ -0,0 +1,58 @@
+/**
+ * What a verification re-work stamps as the delivery's judged commit: the commit
+ * its run judged, and THAT run's own verdict persisted beside it.
+ *
+ * A run is selected under the delivery's own gate, so the verdict it rendered
+ * (gateVerdictFromRun, by the rule the durable per-commit record uses) is the
+ * delivery's own-gate verdict for the commit. Persisting it beside the sha is what
+ * lets the resume (spawn/prompt-assembly.ts) show it without reading any record.
+ * A stamp that carries none -- the run rendered no verdict (a timeout, an
+ * unavailable checkout, an instrument fault), or a legacy stamp -- is resolved
+ * there under the delivery's own gate, never by a gate-less record read.
+ *
+ * The deterministic-failure, shortfall and evidence-unavailable re-work writers
+ * share it (verify/verification-feedback.ts,
+ * verify/verification-evidence-unavailable-feedback.ts); extracted so
+ * verification-feedback.ts stays under the daemon 800-line cap.
+ *
+ * @module verify/rework-judgment
+ */
+import { type DeliveryGateState, type GateVerdictSummary } from '../queries/delivery-gate-state.js';
+import { type GateRunVerdictSource, type JudgedCommitTarget } from './gate-verdict-source.js';
+/** The run a re-work feeds back, as its writer is handed it. */
+export interface ReworkRunJudgment {
+    /** The commit the run judged; null or absent when it judged none. */
+    judgedSha?: string | null;
+    /**
+     * The verdict that run rendered for `judgedSha` (runVerdictOf); null when it
+     * rendered none. Absent only where the writer was not handed the run at all.
+     */
+    runVerdict?: GateVerdictSummary | null;
+}
+/**
+ * The verdict a finished run rendered for its commit, or null when it rendered
+ * none. `instrumentFault` is true when attribution routed the run to
+ * instrument-fault re-work, which records no verdict for the commit
+ * (commit-verdict-record.buildCommitVerdict), so none is shown for it either. Pure.
+ */
+export declare function runVerdictOf(run: GateRunVerdictSource, instrumentFault: boolean): GateVerdictSummary | null;
+/**
+ * `gateState` with its judged commit replaced by the run's, and the run's own
+ * verdict persisted beside it when it is a verdict for that commit
+ * (stampJudgedCommit). Never a record read. Pure.
+ */
+export declare function stampReworkJudgment(gateState: DeliveryGateState, judgment: ReworkRunJudgment, judgedAt: string): DeliveryGateState;
+/**
+ * The verdict a re-work DETAIL carries (the live inject, and the listing a
+ * respawned team reads): the run's own verdict whenever the writer was handed the
+ * run -- null included, since a run that rendered none has none to show -- else
+ * the recorded verdict for exactly the judged commit through the writer's reader.
+ * No judged sha asks nothing.
+ */
+export declare function reworkDetailVerdict(d: {
+    readGateVerdict: (target: JudgedCommitTarget) => GateVerdictSummary | null;
+}, v: {
+    productId?: string | null;
+    focusId?: string | null;
+}, judgment: ReworkRunJudgment): GateVerdictSummary | null;
+//# sourceMappingURL=rework-judgment.d.ts.map

package/dist/verify/rework-judgment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rework-judgment.d.ts","sourceRoot":"","sources":["../../src/verify/rework-judgment.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvH,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAElC,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,UAAU,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,oBAAoB,EAAE,eAAe,EAAE,OAAO,GAAG,kBAAkB,GAAG,IAAI,CAE3G;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,iBAAiB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAElI;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE;IAAE,eAAe,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,kBAAkB,GAAG,IAAI,CAAA;CAAE,EACjF,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACzD,QAAQ,EAAE,iBAAiB,GAC1B,kBAAkB,GAAG,IAAI,CAG3B"}

package/dist/verify/rework-judgment.js

@@ -0,0 +1,54 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/rework-judgment.test.ts
+// PINNED-BY-END
+/**
+ * What a verification re-work stamps as the delivery's judged commit: the commit
+ * its run judged, and THAT run's own verdict persisted beside it.
+ *
+ * A run is selected under the delivery's own gate, so the verdict it rendered
+ * (gateVerdictFromRun, by the rule the durable per-commit record uses) is the
+ * delivery's own-gate verdict for the commit. Persisting it beside the sha is what
+ * lets the resume (spawn/prompt-assembly.ts) show it without reading any record.
+ * A stamp that carries none -- the run rendered no verdict (a timeout, an
+ * unavailable checkout, an instrument fault), or a legacy stamp -- is resolved
+ * there under the delivery's own gate, never by a gate-less record read.
+ *
+ * The deterministic-failure, shortfall and evidence-unavailable re-work writers
+ * share it (verify/verification-feedback.ts,
+ * verify/verification-evidence-unavailable-feedback.ts); extracted so
+ * verification-feedback.ts stays under the daemon 800-line cap.
+ *
+ * @module verify/rework-judgment
+ */
+import { stampJudgedCommit } from '../queries/delivery-gate-state.js';
+import { gateVerdictFromRun, readJudgedVerdictFor, } from './gate-verdict-source.js';
+/**
+ * The verdict a finished run rendered for its commit, or null when it rendered
+ * none. `instrumentFault` is true when attribution routed the run to
+ * instrument-fault re-work, which records no verdict for the commit
+ * (commit-verdict-record.buildCommitVerdict), so none is shown for it either. Pure.
+ */
+export function runVerdictOf(run, instrumentFault) {
+    return instrumentFault ? null : gateVerdictFromRun(run);
+}
+/**
+ * `gateState` with its judged commit replaced by the run's, and the run's own
+ * verdict persisted beside it when it is a verdict for that commit
+ * (stampJudgedCommit). Never a record read. Pure.
+ */
+export function stampReworkJudgment(gateState, judgment, judgedAt) {
+    return stampJudgedCommit(gateState, judgment.judgedSha ?? null, judgedAt, judgment.runVerdict ?? null);
+}
+/**
+ * The verdict a re-work DETAIL carries (the live inject, and the listing a
+ * respawned team reads): the run's own verdict whenever the writer was handed the
+ * run -- null included, since a run that rendered none has none to show -- else
+ * the recorded verdict for exactly the judged commit through the writer's reader.
+ * No judged sha asks nothing.
+ */
+export function reworkDetailVerdict(d, v, judgment) {
+    if (judgment.runVerdict !== undefined)
+        return judgment.runVerdict;
+    return readJudgedVerdictFor(d, v, judgment.judgedSha ?? null);
+}
+//# sourceMappingURL=rework-judgment.js.map

package/dist/verify/rework-judgment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rework-judgment.js","sourceRoot":"","sources":["../../src/verify/rework-judgment.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,gEAAgE;AAChE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,iBAAiB,EAAmD,MAAM,mCAAmC,CAAC;AACvH,OAAO,EACL,kBAAkB,EAClB,oBAAoB,GAGrB,MAAM,0BAA0B,CAAC;AAalC;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,GAAyB,EAAE,eAAwB;IAC9E,OAAO,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAA4B,EAAE,QAA2B,EAAE,QAAgB;IAC7G,OAAO,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,IAAI,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC;AACzG,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,CAAiF,EACjF,CAAyD,EACzD,QAA2B;IAE3B,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,UAAU,CAAC;IAClE,OAAO,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAChE,CAAC"}

package/dist/verify/verification-attribution.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Attribution of a FAILED deterministic verify run: which red is the delivery's
+ * own, and which was already on the focus base.
+ *
+ * Extracted from verification-engine.ts (runVerificationForDelivery calls
+ * attributeDeterministicFailure for every failed deterministic run and routes the
+ * instrument-fault hold it returns). Shapes, in order:
+ *
+ *   1. TIMED OUT -- never attributed. A killed run's output parses to nothing
+ *      meaningful, so it routes to bounded instrument-fault re-work: a timeout is
+ *      never a verdict about the work.
+ *   2. BASE UNAVAILABLE -- the focus base resolved but could not be measured this
+ *      tick (verify/verification-baseline-run.ts: an unprovisioned worktree, no
+ *      checkout, dependencies moved). No verdict: pending, retried.
+ *   2a. BASE INCOMPARABLE -- the focus changed its dependency install inputs since
+ *      the base (lockfiles, manifest install fields, install lifecycle scripts), so
+ *      the base could only be measured under installs made from the focus's
+ *      inputs, where a red those installs cause would pass as the
+ *      base's. A retry would refuse the same way, so this IS a verdict: nothing is
+ *      demoted and every red is charged (naming the HEAD red stage when located).
+ *   3. STAGE-AWARE -- the HEAD log vouches for its gate stages
+ *      (verify/verification-gate-stages.ts). The red stage is judged against the
+ *      focus base's reds (judgeFailedStage): pre-existing only when the base failed
+ *      that very stage AND reports everything this run reports there -- the same
+ *      failing tests, or for a non-test red every diagnostic signature
+ *      (verify/verification-diagnostics.ts). A red the base shares is RECORDED
+ *      (preExistingStages), but the stages after it never ran at HEAD, and a stage
+ *      that did not run is never counted as passing: they are run as a
+ *      CONTINUATION at the same judged commit and judged in turn before any pass.
+ *      A red the base does not share fails the delivery naming the stage
+ *      (failedStage) and what is new in it. A continuation that times out, cannot
+ *      run, or runs at a different commit yields no pass.
+ *   4. FAILING-TEST IDS ONLY -- the gate's shape is unknown (no stage outcomes),
+ *      so attribution behaves exactly as before stages existed: all-pre-existing
+ *      ids demote to a pass, zero parsed ids are blind.
+ *
+ * Why a continuation rather than running every stage on its own: it costs nothing
+ * unless a pre-existing red actually occurred (a green run or a red of the
+ * delivery's own stays one gate run), it goes through the unchanged fixed-commit
+ * checkout path, and the base is still measured at most once per (base sha,
+ * gate) -- the base measurement continues past each of ITS reds the same way, so
+ * a second, third... inherited red has a base outcome to be judged against. A
+ * stage the base never ran stays "did not run" there: its red at HEAD is charged,
+ * erring toward re-work, never toward a pass.
+ *
+ * @module verify/verification-attribution
+ */
+import type { PendingVerification } from '../queries/verification.js';
+import type { EvidenceUnavailableDetail } from '../queries/delivery-gate-state.js';
+import { type StrategyResult } from './verification-deterministic.js';
+import type { StageContinuationRunner, VerificationDeps } from './verification-deps.js';
+import type { BaseStageRecord } from './verification-baseline-run.js';
+import { type FixedCommitVerifyDeps, type VerifyCheckout } from './verification-checkout.js';
+/** An instrument-fault hold, minus the `heldAt` stamp the requeue path adds. */
+export type InstrumentFaultHold = Omit<EvidenceUnavailableDetail, 'heldAt'>;
+/**
+ * Attribute a FAILED deterministic run in place (outcome, rationale and the
+ * attribution fields of `result`) and return the instrument-fault hold it must
+ * route to, if any. An attribution that could not run leaves the run failed.
+ */
+export declare function attributeDeterministicFailure(v: PendingVerification, result: StrategyResult, deps: VerificationDeps): Promise<InstrumentFaultHold | null>;
+/** What a run reports for one red stage: its failing-test ids and its diagnostic signatures. */
+export interface StageEvidence {
+    failing: ReadonlySet<string>;
+    diagnostics: readonly string[];
+}
+/** The verdict on one red stage. */
+export type StageJudgment = {
+    kind: 'pre_existing';
+    preExisting: string[];
+} | {
+    kind: 'charged';
+    newFailures: string[];
+    preExisting: string[];
+    newDiagnostics: string[];
+    baseStatus: string;
+};
+/**
+ * Judge one red stage against the focus base. PRE-EXISTING only when the base
+ * failed that very stage AND reports everything this run reports there: with
+ * failing tests, every id this run parsed the base's red parsed too; without,
+ * the base's red parsed none either and covers every diagnostic signature this
+ * run's stage output carries, counted as a multiset. A red whose output yields no
+ * signature at all is charged (module doc of verify/verification-diagnostics.ts).
+ * A base with no stage outcomes matches nothing. Anything else is charged, saying
+ * why. Pure.
+ */
+export declare function judgeFailedStage(stage: string, head: StageEvidence, base: BaseStageRecord | null, baseFailing: ReadonlySet<string>): StageJudgment;
+/** Seams of the default continuation runner (tests drive it without a real checkout). */
+export interface StageContinuationSeams {
+    runAtFixedCommit?: (deps: FixedCommitVerifyDeps, v: PendingVerification) => Promise<StrategyResult>;
+    createPinnedCheckout?: (focusWorktreePath: string, checkoutKey: string, sha: string) => VerifyCheckout | null;
+}
+/**
+ * The real continuation: the never-run segments, chained as the gate chained them,
+ * run through the same fixed-commit strategy as the HEAD run -- a detached checkout
+ * pinned to the HEAD run's verifiedSha (createPinnedVerifyCheckout), under the
+ * focus worktree's verify hold, with the timeout the HEAD run applied. The command
+ * is the gate's own steps, so it is never re-resolved from a manifest (the row
+ * carries no default-on source). The judge loop still requires the continuation's
+ * verifiedSha to equal the judged sha, so a checkout that stopped honouring the
+ * pin yields no verdict, never a verdict about another commit.
+ */
+export declare function buildDefaultStageContinuation(deps: VerificationDeps, seams?: StageContinuationSeams): StageContinuationRunner;
+//# sourceMappingURL=verification-attribution.d.ts.map

package/dist/verify/verification-attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-attribution.d.ts","sourceRoot":"","sources":["../../src/verify/verification-attribution.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAmC,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACvG,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAQxF,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,gCAAgC,CAAC;AAYpF,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACpB,MAAM,4BAA4B,CAAC;AAKpC,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC;AAE5E;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,CAAC,EAAE,mBAAmB,EACtB,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAuBrC;AA+DD,gGAAgG;AAChG,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,oCAAoC;AACpC,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAIpH;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,eAAe,GAAG,IAAI,EAC5B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,aAAa,CAQf;AAuND,yFAAyF;AACzF,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,qBAAqB,EAAE,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACpG,oBAAoB,CAAC,EAAE,CAAC,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,cAAc,GAAG,IAAI,CAAC;CAC/G;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,GAAE,sBAA2B,GAAG,uBAAuB,CAqBjI"}

package/dist/verify/verification-attribution.js

@@ -0,0 +1,322 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/verification-attribution.test.ts
+// PINNED-BY-END
+import { DEFAULT_VERIFICATION_TIMEOUT_MS } from './verification-deterministic.js';
+import { applyAttribution, classifyFailures, readHeadOutputDefault, } from './verification-baseline.js';
+import { parseFailingTests } from './verification-failure-parser.js';
+import { MAX_STAGE_ROUNDS, continuationCommand, hasStageToContinue, parseContinuationStages, } from './verification-gate-stages.js';
+import { describeDiagnostics, diagnosticSignatures, logCwdRoots, uncoveredDiagnostics } from './verification-diagnostics.js';
+import { buildTimeoutFaultHold } from './verification-timeout-fault.js';
+import { createPinnedVerifyCheckout, runDeterministicAtFixedCommit, } from './verification-checkout.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'verification' });
+/**
+ * Attribute a FAILED deterministic run in place (outcome, rationale and the
+ * attribution fields of `result`) and return the instrument-fault hold it must
+ * route to, if any. An attribution that could not run leaves the run failed.
+ */
+export async function attributeDeterministicFailure(v, result, deps) {
+    if (result.timedOut) {
+        log.warn(`[verification] deterministic run timed out for delivery ${v.deliveryId} -- ` +
+            `routing to bounded instrument-fault re-work (not a pass)`);
+        return buildTimeoutFaultHold(result);
+    }
+    if (!deps.attributeFailures)
+        return null;
+    try {
+        const classification = await deps.attributeFailures(v, result);
+        if (!classification)
+            return null; // no baseline resolvable: every HEAD red gates
+        if (classification.baseUnavailable !== undefined)
+            return deferForUnavailableBase(v, result, classification.baseUnavailable);
+        if (classification.baseIncomparable !== undefined)
+            return chargeIncomparableBase(v, result, classification, classification.baseIncomparable);
+        const staged = classification.stages;
+        if (staged?.head && staged.head.failedStage !== null) {
+            return await judgeStagedFailure(v, result, classification, { ...staged, head: staged.head }, deps);
+        }
+        return applyIdAttribution(v, result, classification);
+    }
+    catch (err) {
+        log.warn(`[verification] baseline attribution failed for delivery ${v.deliveryId}:`, err.message);
+        return null;
+    }
+}
+/** Failing-test-id attribution (the gate's stages unknown): the behaviour before stages existed. */
+function applyIdAttribution(v, result, classification) {
+    const attributed = applyAttribution(v.deliveryId, classification);
+    result.newFailures = attributed.newFailures;
+    result.preExisting = attributed.preExisting;
+    result.rationale = attributed.rationale;
+    if (attributed.outcome === 'blind') {
+        // Exited non-zero but zero parseable failing ids: the gate cannot attribute
+        // the failure. Keep the run FAILED (never a differential pass) and route it
+        // to the bounded instrument-fault re-work path.
+        result.outcome = 'failed';
+        log.warn(`[verification] ${attributed.rationale} (delivery ${v.deliveryId}) -- routing to bounded instrument-fault re-work`);
+        return blindHold(result.exitCode);
+    }
+    result.outcome = attributed.outcome;
+    if (attributed.log)
+        log.info(attributed.log);
+    return null;
+}
+function blindHold(exitCode) {
+    return {
+        missing: ['attributable failing-test ids (deterministic run exited non-zero, parsed zero)'],
+        commitsAhead: 0,
+        deterministicFault: { kind: 'blind_zero_parse', exitCode: exitCode ?? null },
+    };
+}
+/** The base could not be measured this tick: no verdict either way, retried. */
+function deferForUnavailableBase(v, result, reason) {
+    result.outcome = 'pending';
+    result.checkoutUnavailable = true;
+    result.rationale =
+        `the deterministic check failed at ${shortSha(result.verifiedSha)}, but the focus base could not be measured to ` +
+            `attribute the red (${reason}) -- base evidence unavailable, not a verdict; retried next tick`;
+    log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId})`);
+    return null;
+}
+/**
+ * The base can never be measured comparably with the installs at hand (the focus
+ * changed its dependency install inputs): a verdict, not a deferral -- a retry
+ * would refuse the same way. Nothing is demoted; every red is charged, naming the
+ * HEAD red stage when the log located one.
+ */
+function chargeIncomparableBase(v, result, classification, reason) {
+    const stage = classification.stages?.head?.failedStage ?? null;
+    result.outcome = 'failed';
+    if (stage !== null)
+        result.failedStage = stage;
+    result.newFailures = [...classification.newFailures, ...classification.preExisting].sort();
+    result.preExisting = [];
+    result.rationale =
+        `deterministic check failed${stage !== null ? ` at stage "${stage}"` : ''} at ${shortSha(result.verifiedSha)}, and no red ` +
+            `can be attributed to the focus base: ${reason} -- every red is charged to the delivery`;
+    log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId})`);
+    return null;
+}
+/**
+ * Judge one red stage against the focus base. PRE-EXISTING only when the base
+ * failed that very stage AND reports everything this run reports there: with
+ * failing tests, every id this run parsed the base's red parsed too; without,
+ * the base's red parsed none either and covers every diagnostic signature this
+ * run's stage output carries, counted as a multiset. A red whose output yields no
+ * signature at all is charged (module doc of verify/verification-diagnostics.ts).
+ * A base with no stage outcomes matches nothing. Anything else is charged, saying
+ * why. Pure.
+ */
+export function judgeFailedStage(stage, head, base, baseFailing) {
+    const red = base?.failed.find((candidate) => candidate.stage === stage) ?? null;
+    const { newFailures, preExisting } = classifyFailures(head.failing, red ? new Set(red.failingTests) : baseFailing);
+    const verdict = red
+        ? judgeSharedRed(red, head, newFailures.length)
+        : { kind: 'charged', newDiagnostics: [], baseStatus: describeUnsharedStage(stage, base) };
+    if (verdict.kind === 'pre_existing')
+        return { kind: 'pre_existing', preExisting };
+    return { kind: 'charged', newFailures, preExisting, newDiagnostics: verdict.newDiagnostics, baseStatus: verdict.baseStatus };
+}
+const ALSO_FAILS = 'the stage also fails on the focus base';
+function judgeSharedRed(red, head, newCount) {
+    const charged = (baseStatus, newDiagnostics = []) => ({ kind: 'charged', newDiagnostics, baseStatus });
+    if (head.failing.size > 0) {
+        return newCount === 0 ? { kind: 'pre_existing' } : charged(`${ALSO_FAILS}, but not with these failing tests`);
+    }
+    if (red.failingTests.length > 0)
+        return charged(`${ALSO_FAILS}, but with failing tests this run did not report`);
+    if (head.diagnostics.length === 0) {
+        return charged(`${ALSO_FAILS}, but this run's stage output carries no diagnostic to compare with the base's, so the red cannot be shown to be the base's`);
+    }
+    const uncovered = uncoveredDiagnostics(head.diagnostics, red.diagnostics);
+    if (uncovered.length === 0)
+        return { kind: 'pre_existing' };
+    return charged(`${ALSO_FAILS}, but this run reports ${uncovered.length} diagnostic(s) the base does not: ${describeDiagnostics(uncovered)}`, uncovered);
+}
+function describeUnsharedStage(stage, base) {
+    if (base === null)
+        return 'the focus base run yielded no stage outcomes to compare against, so the red is charged';
+    if (base.ran.includes(stage))
+        return 'the stage passes on the focus base';
+    if (base.notRun.includes(stage)) {
+        const lastRed = base.failed[base.failed.length - 1]?.stage ?? 'an earlier stage';
+        return `the stage never ran on the focus base (it could not be measured past its red at "${lastRed}")`;
+    }
+    return 'the stage does not run on the focus base';
+}
+async function judgeStagedFailure(v, result, classification, staged, deps) {
+    const runContinuation = deps.runStageContinuation ?? buildDefaultStageContinuation(deps);
+    const baseFailing = new Set(staged.baseFailingTests);
+    const record = { stages: [], tests: new Set() };
+    let run = staged.head;
+    let evidence = {
+        failing: new Set([...classification.newFailures, ...classification.preExisting]),
+        diagnostics: staged.headDiagnostics,
+    };
+    for (let round = 0; round < MAX_STAGE_ROUNDS && run.failedStage !== null; round++) {
+        const stage = run.failedStage;
+        const judged = judgeFailedStage(stage, evidence, staged.base, baseFailing);
+        if (judged.kind === 'charged')
+            return chargeStage(result, stage, judged, record);
+        record.stages.push(stage);
+        for (const id of judged.preExisting)
+            record.tests.add(id);
+        if (!hasStageToContinue(run))
+            return passDifferentially(v, result, record, 'no gate stage follows them');
+        if (!result.verifiedSha)
+            return unjudgeableRemainder(v, result, record, 'the run recorded no judged commit');
+        const continued = await runContinuationSafely(runContinuation, v, run.continuation, result);
+        const step = settleContinuation(v, result, continued, run, record);
+        if (step.kind === 'settled')
+            return step.hold;
+        run = step.run;
+        evidence = step.evidence;
+    }
+    return unjudgeableRemainder(v, result, record, 'the continuation did not settle');
+}
+/** Read a continuation's result: a terminal verdict, or its own red stage to judge next. */
+function settleContinuation(v, result, continued, from, record) {
+    const sameCommit = continued.verifiedSha !== undefined && continued.verifiedSha === result.verifiedSha;
+    if (continued.outcome === 'passed' && sameCommit) {
+        return settled(passDifferentially(v, result, record, `every gate stage after them ran green at ${shortSha(result.verifiedSha)}`));
+    }
+    if (continued.timedOut) {
+        adoptEvidence(result, continued);
+        result.outcome = 'failed';
+        result.timedOut = true;
+        recordPreExisting(result, record);
+        result.rationale = `${continued.rationale ?? 'the continuation timed out'} -- the gate stages after the pre-existing ` +
+            `red(s) in ${quoteStages(record.stages)} were killed before completing, so they were never judged (not a pass)`;
+        log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId})`);
+        return settled(buildTimeoutFaultHold(continued));
+    }
+    if (continued.outcome !== 'failed' || !sameCommit)
+        return settled(deferRemainder(v, result, record, continued));
+    adoptEvidence(result, continued);
+    const text = readHeadOutputDefault(continued);
+    const failing = parseFailingTests(text);
+    const next = parseContinuationStages(text, continued.exitCode, from.continuation, from.package);
+    if (next && next.failedStage !== null) {
+        return { kind: 'staged', run: next, evidence: { failing, diagnostics: diagnosticSignatures(next.failedStageOutput, logCwdRoots(text)) } };
+    }
+    return settled(chargeUnlocated(v, result, record, failing));
+}
+const settled = (hold) => ({ kind: 'settled', hold });
+async function runContinuationSafely(run, v, segments, head) {
+    try {
+        return await run(v, segments, head);
+    }
+    catch (err) {
+        return { outcome: 'pending', rationale: `the continuation run threw: ${err.message}`, checkoutUnavailable: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// Terminal verdicts (each writes the result it names)
+// ---------------------------------------------------------------------------
+function chargeStage(result, stage, judged, record) {
+    result.outcome = 'failed';
+    result.failedStage = stage;
+    result.newFailures = judged.newFailures;
+    result.preExisting = [...new Set([...record.tests, ...judged.preExisting])].sort();
+    if (record.stages.length > 0)
+        result.preExistingStages = [...record.stages];
+    result.rationale =
+        `deterministic check failed at stage "${stage}": ${judged.baseStatus}` +
+            (judged.newFailures.length > 0 ? `; ${judged.newFailures.length} NEW failing test(s) vs focus base` : '') +
+            (record.stages.length > 0 ? `; pre-existing base red(s) recorded, non-blocking: ${quoteStages(record.stages)}` : '');
+    return null;
+}
+function passDifferentially(v, result, record, after) {
+    result.outcome = 'passed';
+    delete result.failedStage;
+    result.newFailures = [];
+    recordPreExisting(result, record);
+    result.rationale =
+        `deterministic check exited non-zero only on red(s) that fail the same way on the focus base -- ` +
+            `${quoteStages(record.stages)} (recorded, non-blocking); ${after} (differential pass)`;
+    log.info(`[verification] delivery ${v.deliveryId}: pre-existing base red(s) in ${quoteStages(record.stages)} ` +
+        `recorded, non-blocking; ${after} (differential pass)`);
+    return null;
+}
+/** The continuation failed at a stage its log does not identify: charged, or blind when it parsed no ids. */
+function chargeUnlocated(v, result, record, failing) {
+    result.outcome = 'failed';
+    recordPreExisting(result, record);
+    const after = `the gate stages run after the pre-existing red(s) in ${quoteStages(record.stages)}`;
+    if (failing.size === 0) {
+        result.rationale = `${after} exited non-zero at a stage the log does not identify and parsed zero failing-test ids -- ` +
+            'the gate cannot attribute the failure (instrument fault, not a differential pass)';
+        log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId}) -- routing to bounded instrument-fault re-work`);
+        return blindHold(result.exitCode);
+    }
+    // No base red is located for these tests, so none of them can be excused by it.
+    result.newFailures = [...failing].sort();
+    result.rationale = `deterministic check failed: ${after} report ${failing.size} failing test(s) at a stage the log does not identify`;
+    return null;
+}
+/** The stages after a pre-existing red could not be run at the judged commit this tick: no verdict, retried. */
+function deferRemainder(v, result, record, continued) {
+    result.outcome = 'pending';
+    result.checkoutUnavailable = true;
+    recordPreExisting(result, record);
+    result.rationale =
+        `the red(s) in ${quoteStages(record.stages)} fail the same way on the focus base, but the gate stages after them ` +
+            `could not be run at ${shortSha(result.verifiedSha)} (${continued.rationale ?? continued.outcome}) -- not a pass; retried next tick`;
+    log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId})`);
+    return null;
+}
+/** The stages after a pre-existing red can never be run for this result: the gate is blind to them. */
+function unjudgeableRemainder(v, result, record, why) {
+    result.outcome = 'failed';
+    recordPreExisting(result, record);
+    result.rationale =
+        `the red(s) in ${quoteStages(record.stages)} fail the same way on the focus base, but the gate stages after them ` +
+            `cannot be judged (${why}) -- the gate is blind to them, not the work passing`;
+    log.warn(`[verification] ${result.rationale} (delivery ${v.deliveryId}) -- routing to bounded instrument-fault re-work`);
+    return { missing: [`the gate stages after the pre-existing red(s) in ${quoteStages(record.stages)} (${why})`], commitsAhead: 0 };
+}
+function recordPreExisting(result, record) {
+    result.preExistingStages = [...record.stages];
+    result.preExisting = [...record.tests].sort();
+}
+/** The continuation rendered the verdict, so its log, tails and exit status are the evidence feedback points at. */
+function adoptEvidence(result, continued) {
+    result.logPath = continued.logPath;
+    result.stdoutTail = continued.stdoutTail;
+    result.stderrTail = continued.stderrTail;
+    result.exitCode = continued.exitCode;
+    result.runnerSummary = continued.runnerSummary;
+}
+const quoteStages = (stages) => stages.map((stage) => `"${stage}"`).join(', ');
+const shortSha = (sha) => (sha ? sha.slice(0, 8) : 'the judged commit');
+/**
+ * The real continuation: the never-run segments, chained as the gate chained them,
+ * run through the same fixed-commit strategy as the HEAD run -- a detached checkout
+ * pinned to the HEAD run's verifiedSha (createPinnedVerifyCheckout), under the
+ * focus worktree's verify hold, with the timeout the HEAD run applied. The command
+ * is the gate's own steps, so it is never re-resolved from a manifest (the row
+ * carries no default-on source). The judge loop still requires the continuation's
+ * verifiedSha to equal the judged sha, so a checkout that stopped honouring the
+ * pin yields no verdict, never a verdict about another commit.
+ */
+export function buildDefaultStageContinuation(deps, seams = {}) {
+    const runAtFixedCommit = seams.runAtFixedCommit ?? runDeterministicAtFixedCommit;
+    const createPinned = seams.createPinnedCheckout ?? createPinnedVerifyCheckout;
+    return async (v, segments, head) => {
+        const sha = head.verifiedSha;
+        if (!sha)
+            return { outcome: 'pending', rationale: 'no judged commit to continue the gate at', checkoutUnavailable: true };
+        const applied = head.appliedConfig;
+        const row = {
+            ...v,
+            verificationConfig: {
+                command: continuationCommand(segments),
+                timeoutMs: applied?.timeoutMs ?? DEFAULT_VERIFICATION_TIMEOUT_MS,
+                ...(applied ? { timeoutSource: applied.timeoutSource } : {}),
+            },
+        };
+        delete row.defaultOnSource;
+        return runAtFixedCommit({ ...deps, createVerifyCheckout: (worktreePath, key) => createPinned(worktreePath, `${key}-continuation`, sha) }, row);
+    };
+}
+//# sourceMappingURL=verification-attribution.js.map