@dsh-enhanced/assistant-evaluation 0.1.65 → 0.1.66

package/lib/intake-attention-agreement.d.ts

@@ -0,0 +1,63 @@
+import type { NotificationOutcome, NotificationOutcomeRecord } from './types.js';
+export declare const INTAKE_ATTENTION_AGREEMENT_PROTOCOL: "assistant-evaluation/intake-attention-agreement/v1";
+/** Notifications with a work item scanned per call; more is reported as `truncated`. */
+export declare const INTAKE_ATTENTION_AGREEMENT_SCAN_LIMIT = 1000;
+/** Structural mirror of WorkItems' `inspectIntakeProvenance`; Evaluation keeps no runtime dependency on WorkItems. */
+export interface IntakeProvenanceSource {
+    inspectIntakeProvenance(itemId: string): unknown;
+}
+export declare function isIntakeProvenanceSource(value: unknown): value is IntakeProvenanceSource;
+declare const LEVELS: readonly ["ignore", "digest", "notify", "accept"];
+type IntakeLevel = typeof LEVELS[number];
+export interface IntakeAttentionAgreementCell {
+    readonly notifications: number;
+    readonly items: number;
+    readonly outcomes: Readonly<Record<NotificationOutcome, number>>;
+    /** accepted + reacted */
+    readonly agreed: number;
+    /** rejected + expired-unhandled */
+    readonly disagreed: number;
+    /** agreed / (agreed + disagreed) in ppm; null without any decided notification. */
+    readonly agreementPpm: number | null;
+}
+export interface IntakeAttentionAgreement {
+    readonly protocol: typeof INTAKE_ATTENTION_AGREEMENT_PROTOCOL;
+    readonly causal: false;
+    readonly scope: Readonly<{
+        workspace: string;
+        preset: string;
+    }>;
+    readonly fromNotifiedAt: number;
+    readonly toNotifiedAt: number;
+    /** Current notification heads in the window that name a work item, at most the scan limit. */
+    readonly scanned: number;
+    readonly truncated: boolean;
+    /** No WorkItems peer exposes `inspectIntakeProvenance`: every item is unresolved. */
+    readonly provenanceAvailable: boolean;
+    /** Notifications whose item was not admitted from intake (explicit decisions, continuations). */
+    readonly notIntake: number;
+    /** Notifications whose provenance read threw (WorkItems unavailable or intake ledger off) or was malformed. */
+    readonly unresolved: number;
+    /** Notifications naming a work item of another owner scope; never attributed to this one. */
+    readonly foreign: number;
+    readonly intake: IntakeAttentionAgreementCell;
+    readonly byLevel: Readonly<Partial<Record<IntakeLevel, IntakeAttentionAgreementCell>>>;
+}
+/**
+ * Aggregate `records` (current heads, each naming a work item) by the intake
+ * judgment behind its item. Provenance is read once per item; a throwing or
+ * malformed answer leaves that item unresolved.
+ */
+export declare function computeIntakeAttentionAgreement(input: Readonly<{
+    scope: Readonly<{
+        workspace: string;
+        preset: string;
+    }>;
+    fromNotifiedAt: number;
+    toNotifiedAt: number;
+    records: readonly NotificationOutcomeRecord[];
+    truncated: boolean;
+    source: IntakeProvenanceSource | undefined;
+}>): IntakeAttentionAgreement;
+export {};
+//# sourceMappingURL=intake-attention-agreement.d.ts.map

package/lib/intake-attention-agreement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intake-attention-agreement.d.ts","sourceRoot":"","sources":["../src/intake-attention-agreement.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAGhF,eAAO,MAAM,mCAAmC,EAAG,oDAA6D,CAAA;AAChH,wFAAwF;AACxF,eAAO,MAAM,qCAAqC,OAAQ,CAAA;AAE1D,sHAAsH;AACtH,MAAM,WAAW,sBAAsB;IACrC,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;CACjD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAGxF;AAED,QAAA,MAAM,MAAM,mDAAoD,CAAA;AAChE,KAAK,WAAW,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAA;AA4BxC,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC,CAAA;IAChE,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mCAAmC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,mFAAmF;IACnF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CACrC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE,OAAO,mCAAmC,CAAA;IAC7D,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC/D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,8FAA8F;IAC9F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,qFAAqF;IACrF,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAA;IACrC,iGAAiG;IACjG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,+GAA+G;IAC/G,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,6FAA6F;IAC7F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,4BAA4B,CAAC,CAAC,CAAC,CAAA;CACvF;AA6BD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,QAAQ,CAAC;IAC9D,KAAK,EAAE,QAAQ,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACtD,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,SAAS,yBAAyB,EAAE,CAAA;IAC7C,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,sBAAsB,GAAG,SAAS,CAAA;CAC3C,CAAC,GAAG,wBAAwB,CA8C5B"}

package/lib/intake-attention-agreement.js

@@ -0,0 +1,146 @@
+/**
+ * WP22: read-only agreement between WP20 intake judgments and the attention
+ * outcome ledger.
+ *
+ * The only join that exists is intake admission → work item → result
+ * notification (`workItemId` on the outcome record) → owner outcome. An
+ * observe-mode `would-admit` never creates an item, so it never reaches a
+ * notification and cannot be measured here; only auto-admitted items are.
+ * Nothing is written, adopted or sent; the result is observational.
+ */
+import { canonicalEvaluationScope } from './store.js';
+import { notificationOutcomes } from './types.js';
+export const INTAKE_ATTENTION_AGREEMENT_PROTOCOL = 'assistant-evaluation/intake-attention-agreement/v1';
+/** Notifications with a work item scanned per call; more is reported as `truncated`. */
+export const INTAKE_ATTENTION_AGREEMENT_SCAN_LIMIT = 1_000;
+export function isIntakeProvenanceSource(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.inspectIntakeProvenance === 'function';
+}
+const LEVELS = ['ignore', 'digest', 'notify', 'accept'];
+/**
+ * Validate one peer answer; anything malformed, or an item of another owner
+ * scope, counts as unresolved, never as a match. A notification sender may
+ * name any work item id, so the item's own scope must equal the metric's.
+ */
+function provenance(value, itemId, scopeKey) {
+    if (value === undefined)
+        return null;
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return 'invalid';
+    const item = value;
+    if (item.protocol !== 'work-items/intake-provenance/v1' || item.itemId !== itemId || item.wouldAccept !== true
+        || !LEVELS.includes(item.level) || (item.mode !== 'observe' && item.mode !== 'auto'))
+        return 'invalid';
+    const scope = item.scope;
+    let key;
+    try {
+        key = canonicalEvaluationScope({ workspace: scope?.workspace, preset: scope?.preset }).scopeKey;
+    }
+    catch {
+        return 'invalid';
+    }
+    if (key !== scopeKey)
+        return 'foreign';
+    return { itemId, level: item.level, mode: item.mode };
+}
+/** Owner outcomes that confirm the intake judgment, that contradict it, and that decide nothing yet. */
+const POSITIVE = new Set(['accepted', 'reacted']);
+const NEGATIVE = new Set(['rejected', 'expired-unhandled']);
+class Cell {
+    notifications = 0;
+    items = new Set();
+    outcomes = Object.fromEntries(notificationOutcomes.map(outcome => [outcome, 0]));
+    add(itemId, outcome) {
+        this.notifications += 1;
+        this.items.add(itemId);
+        this.outcomes[outcome] += 1;
+    }
+    freeze() {
+        let agreed = 0, disagreed = 0;
+        for (const outcome of notificationOutcomes) {
+            if (POSITIVE.has(outcome))
+                agreed += this.outcomes[outcome];
+            if (NEGATIVE.has(outcome))
+                disagreed += this.outcomes[outcome];
+        }
+        const decided = agreed + disagreed;
+        return Object.freeze({
+            notifications: this.notifications,
+            items: this.items.size,
+            outcomes: Object.freeze({ ...this.outcomes }),
+            agreed,
+            disagreed,
+            agreementPpm: decided === 0 ? null : Math.round(agreed * 1_000_000 / decided),
+        });
+    }
+}
+/**
+ * Aggregate `records` (current heads, each naming a work item) by the intake
+ * judgment behind its item. Provenance is read once per item; a throwing or
+ * malformed answer leaves that item unresolved.
+ */
+export function computeIntakeAttentionAgreement(input) {
+    const { scopeKey } = canonicalEvaluationScope(input.scope);
+    const resolved = new Map();
+    const resolve = (itemId) => {
+        if (!resolved.has(itemId)) {
+            let value = 'invalid';
+            if (input.source !== undefined) {
+                try {
+                    value = provenance(input.source.inspectIntakeProvenance(itemId), itemId, scopeKey);
+                }
+                catch {
+                    value = 'invalid';
+                }
+            }
+            resolved.set(itemId, value);
+        }
+        return resolved.get(itemId);
+    };
+    const intake = new Cell();
+    const byLevel = new Map();
+    let notIntake = 0, unresolved = 0, foreign = 0;
+    for (const record of input.records) {
+        const itemId = record.workItemId;
+        if (itemId === undefined)
+            continue;
+        const found = resolve(itemId);
+        if (found === 'invalid') {
+            unresolved += 1;
+            continue;
+        }
+        if (found === 'foreign') {
+            foreign += 1;
+            continue;
+        }
+        if (found === null) {
+            notIntake += 1;
+            continue;
+        }
+        intake.add(itemId, record.outcome);
+        let cell = byLevel.get(found.level);
+        if (cell === undefined)
+            byLevel.set(found.level, cell = new Cell());
+        cell.add(itemId, record.outcome);
+    }
+    return Object.freeze({
+        protocol: INTAKE_ATTENTION_AGREEMENT_PROTOCOL,
+        causal: false,
+        scope: Object.freeze({ workspace: input.scope.workspace, preset: input.scope.preset }),
+        fromNotifiedAt: input.fromNotifiedAt,
+        toNotifiedAt: input.toNotifiedAt,
+        scanned: input.records.length,
+        truncated: input.truncated,
+        provenanceAvailable: input.source !== undefined,
+        notIntake,
+        unresolved,
+        foreign,
+        intake: intake.freeze(),
+        byLevel: Object.freeze(Object.fromEntries(LEVELS.flatMap(level => {
+            const cell = byLevel.get(level);
+            return cell === undefined ? [] : [[level, cell.freeze()]];
+        }))),
+    });
+}
+//# sourceMappingURL=intake-attention-agreement.js.map

package/lib/intake-attention-agreement.js.map

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

package/lib/notification-outcomes.d.ts

@@ -0,0 +1,56 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type EvaluationScope, type NotificationOutcomeFactInput, type NotificationOutcomeFeedPage, type NotificationOutcomeHistory, type NotificationOutcomeRecord, type NotificationOutcomeSummary, type StoredNotificationOutcome } from './types.js';
+/** Strict shape check: Delivery facts are trusted Host data, but never trusted to be well-formed. */
+export declare function normalizeNotificationOutcomeFact(input: unknown): NotificationOutcomeFactInput;
+/**
+ * Deterministic `notification-outcome/v1` classifier. Precedence: an owner
+ * judgement (rejected, accepted) beats a reply (reacted), which beats transport
+ * state. A withdrawn judgement (`unknown`) contributes nothing. Expiry depends
+ * only on `now`, the earliest sent timestamp and the configured window. An
+ * optional linked route is carried verbatim and never affects the outcome, so
+ * the classifier stays at version 1 and route-free records keep their digests.
+ */
+export declare function classifyNotificationOutcome(fact: NotificationOutcomeFactInput, now: number, responseWindowMs: number): NotificationOutcomeRecord;
+export declare function notificationOutcomeDigest(record: NotificationOutcomeRecord): string;
+/**
+ * Evaluation-owned revisable ledger keyed by notification (Delivery Outbox id).
+ * Each changed classification appends an immutable revision and advances the
+ * scope's notification watermark in one writer transaction; an unchanged
+ * digest only refreshes the check time. Nothing here touches task projections,
+ * the Evolution outbox or any parameter.
+ */
+export declare class NotificationOutcomeLedger {
+    #private;
+    constructor(database: DatabaseSync, now: () => number);
+    /** Apply one fact; returns whether a new revision was appended. */
+    apply(factInput: unknown, responseWindowMs: number): Readonly<{
+        revised: boolean;
+        head: StoredNotificationOutcome;
+    }>;
+    /** Mark a head as checked without a fact (e.g. Delivery no longer reports it). */
+    touch(notificationId: string): void;
+    syncCursor(): number;
+    advanceSyncCursor(afterSequence: number): void;
+    /** Heads notified at or after `notifiedSince`, least recently checked first. */
+    dueForRefresh(notifiedSince: number, limit: number): readonly string[];
+    history(scopeInput: EvaluationScope, notificationId: string): NotificationOutcomeHistory | undefined;
+    feed(scopeInput: EvaluationScope, afterInput: Readonly<{
+        scopeKey: string;
+        watermark: number;
+    }> | undefined, limit: number): NotificationOutcomeFeedPage;
+    summary(scopeInput: EvaluationScope, fromNotifiedAt: number, toNotifiedAt: number): NotificationOutcomeSummary;
+    /**
+     * Current heads in `[from, to)` notification time whose record names a work
+     * item, oldest first, at most `limit` (plus whether more exist). Read-only;
+     * a scan of the scope's heads in the window (no index on the work item).
+     */
+    workItemHeads(scopeInput: EvaluationScope, fromNotifiedAt: number, toNotifiedAt: number, limit: number): Readonly<{
+        records: readonly NotificationOutcomeRecord[];
+        truncated: boolean;
+    }>;
+    counts(): Readonly<{
+        notifications: number;
+        revisions: number;
+    }>;
+}
+//# sourceMappingURL=notification-outcomes.d.ts.map

package/lib/notification-outcomes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-outcomes.d.ts","sourceRoot":"","sources":["../src/notification-outcomes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,EAIL,KAAK,eAAe,EAEpB,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC/B,MAAM,YAAY,CAAA;AA0CnB,qGAAqG;AACrG,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,OAAO,GAAG,4BAA4B,CAkD7F;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,4BAA4B,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,yBAAyB,CA0ChJ;AAUD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,MAAM,CAEnF;AAyBD;;;;;;GAMG;AACH,qBAAa,yBAAyB;;gBAIxB,QAAQ,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,MAAM;IAiBrD,mEAAmE;IACnE,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,GAAG,QAAQ,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,yBAAyB,CAAA;KAAE,CAAC;IAqCpH,kFAAkF;IAClF,KAAK,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAKnC,UAAU,IAAI,MAAM;IAKpB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAM9C,gFAAgF;IAChF,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE;IAYtE,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS;IASpG,IAAI,CAAC,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,2BAA2B;IA2BxJ,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,0BAA0B;IAkB9G;;;;OAIG;IACH,aAAa,CAAC,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GACpG,QAAQ,CAAC;QAAE,OAAO,EAAE,SAAS,yBAAyB,EAAE,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAWjF,MAAM,IAAI,QAAQ,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAKjE"}

package/lib/notification-outcomes.js

@@ -0,0 +1,348 @@
+import { createHash } from 'node:crypto';
+import { canonicalEvaluationScope, EvaluationStoreError } from './store.js';
+import { NOTIFICATION_OUTCOME_RECORD_PROTOCOL, notificationOutcomes, objectiveStatuses, } from './types.js';
+const purposes = ['result', 'attention', 'answer'];
+const purposeSources = ['declared', 'lane', 'default'];
+const verdicts = ['would-accept', 'would-attach', 'would-reject'];
+const transportStatuses = ['pending', 'attempting', 'accepted', 'delivered', 'read', 'retry_wait', 'dead', 'unknown_after_send'];
+const judgementSources = ['owner-objective', 'work-item-feedback'];
+function invalid(message) {
+    throw new EvaluationStoreError('invalid-input', `notification outcome fact: ${message}`);
+}
+function plain(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        invalid(`${label} must be an object`);
+    return value;
+}
+function text(value, label, max = 256) {
+    if (typeof value !== 'string' || value.length < 1 || value.length > max || value.trim() !== value || /\p{Cc}/u.test(value)) {
+        invalid(`${label} must be a bounded identifier`);
+    }
+    return value;
+}
+function optionalText(value, label) {
+    return value === undefined ? undefined : text(value, label);
+}
+function time(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        invalid(`${label} must be a non-negative safe integer`);
+    return value;
+}
+function optionalTime(value, label) {
+    return value === undefined ? undefined : time(value, label);
+}
+function member(value, allowed, label) {
+    if (typeof value !== 'string' || !allowed.includes(value))
+        invalid(`${label} is not recognised`);
+    return value;
+}
+/** Strict shape check: Delivery facts are trusted Host data, but never trusted to be well-formed. */
+export function normalizeNotificationOutcomeFact(input) {
+    const fact = plain(input, 'fact');
+    const transport = plain(fact.transport, 'transport');
+    const reasons = fact.reasons;
+    if (!Array.isArray(reasons) || reasons.length > 32)
+        invalid('reasons must be a bounded array');
+    const scope = plain(fact.scope, 'scope');
+    const reaction = fact.reaction === undefined ? undefined : plain(fact.reaction, 'reaction');
+    const judgement = fact.judgement === undefined ? undefined : plain(fact.judgement, 'judgement');
+    if (judgement !== undefined && (!Number.isSafeInteger(judgement.version) || judgement.version < 1)) {
+        invalid('judgement.version must be a positive integer');
+    }
+    const route = fact.route === undefined ? undefined : plain(fact.route, 'route');
+    if (route !== undefined && (Object.keys(route).length !== 2 || route.kind !== 'linked'))
+        invalid('route must be a linked route');
+    const originBindingId = route === undefined ? undefined : text(route.originBindingId, 'route.originBindingId');
+    if (originBindingId !== undefined && originBindingId === fact.bindingId)
+        invalid('route.originBindingId must differ from bindingId');
+    const workItemId = optionalText(fact.workItemId, 'workItemId');
+    const questionId = optionalText(fact.questionId, 'questionId');
+    const answersQuestionId = optionalText(fact.answersQuestionId, 'answersQuestionId');
+    const acceptedAt = optionalTime(transport.acceptedAt, 'transport.acceptedAt');
+    const deliveredAt = optionalTime(transport.deliveredAt, 'transport.deliveredAt');
+    const readAt = optionalTime(transport.readAt, 'transport.readAt');
+    return {
+        auditSequence: time(fact.auditSequence, 'auditSequence'),
+        outboxId: text(fact.outboxId, 'outboxId'),
+        bindingId: text(fact.bindingId, 'bindingId'),
+        scope: canonicalEvaluationScope({ workspace: scope.workspace, preset: scope.preset }).scope,
+        lane: text(fact.lane, 'lane', 64),
+        sourceId: text(fact.sourceId, 'sourceId'),
+        purpose: member(fact.purpose, purposes, 'purpose'),
+        purposeSource: member(fact.purposeSource, purposeSources, 'purposeSource'),
+        ...(workItemId === undefined ? {} : { workItemId }),
+        ...(questionId === undefined ? {} : { questionId }),
+        ...(answersQuestionId === undefined ? {} : { answersQuestionId }),
+        verdict: member(fact.verdict, verdicts, 'verdict'),
+        reasons: reasons.map((reason, index) => text(reason, `reasons[${index}]`, 64)),
+        auditedAt: time(fact.auditedAt, 'auditedAt'),
+        transport: {
+            status: member(transport.status, transportStatuses, 'transport.status'),
+            ...(acceptedAt === undefined ? {} : { acceptedAt }),
+            ...(deliveredAt === undefined ? {} : { deliveredAt }),
+            ...(readAt === undefined ? {} : { readAt }),
+        },
+        ...(reaction === undefined ? {} : { reaction: { firstAt: time(reaction.firstAt, 'reaction.firstAt') } }),
+        ...(judgement === undefined ? {} : { judgement: {
+                source: member(judgement.source, judgementSources, 'judgement.source'),
+                version: judgement.version,
+                objectiveStatus: member(judgement.objectiveStatus, objectiveStatuses, 'judgement.objectiveStatus'),
+            } }),
+        ...(originBindingId === undefined ? {} : { route: { kind: 'linked', originBindingId } }),
+    };
+}
+/**
+ * Deterministic `notification-outcome/v1` classifier. Precedence: an owner
+ * judgement (rejected, accepted) beats a reply (reacted), which beats transport
+ * state. A withdrawn judgement (`unknown`) contributes nothing. Expiry depends
+ * only on `now`, the earliest sent timestamp and the configured window. An
+ * optional linked route is carried verbatim and never affects the outcome, so
+ * the classifier stays at version 1 and route-free records keep their digests.
+ */
+export function classifyNotificationOutcome(fact, now, responseWindowMs) {
+    const judgement = fact.judgement !== undefined && fact.judgement.objectiveStatus !== 'unknown'
+        ? { source: fact.judgement.source, version: fact.judgement.version, objectiveStatus: fact.judgement.objectiveStatus }
+        : undefined;
+    const sentTimes = [fact.transport.acceptedAt, fact.transport.deliveredAt, fact.transport.readAt].filter(value => value !== undefined);
+    const sentAt = sentTimes.length === 0 ? undefined : Math.min(...sentTimes);
+    let outcome;
+    let expiry;
+    if (judgement?.objectiveStatus === 'not-achieved')
+        outcome = 'rejected';
+    else if (judgement?.objectiveStatus === 'achieved')
+        outcome = 'accepted';
+    else if (fact.reaction !== undefined || judgement?.objectiveStatus === 'partial')
+        outcome = 'reacted';
+    else if (fact.transport.status === 'dead')
+        outcome = 'failed';
+    else if (sentAt !== undefined) {
+        if (now >= sentAt + responseWindowMs) {
+            outcome = 'expired-unhandled';
+            expiry = { at: sentAt + responseWindowMs, responseWindowMs };
+        }
+        else
+            outcome = 'delivered';
+    }
+    else
+        outcome = 'pending';
+    return {
+        protocol: NOTIFICATION_OUTCOME_RECORD_PROTOCOL,
+        classifier: { id: 'notification-outcome', version: 1 },
+        notificationId: fact.outboxId,
+        scope: { workspace: fact.scope.workspace, preset: fact.scope.preset },
+        bindingId: fact.bindingId,
+        lane: fact.lane,
+        sourceId: fact.sourceId,
+        purpose: fact.purpose,
+        purposeSource: fact.purposeSource,
+        ...(fact.workItemId === undefined ? {} : { workItemId: fact.workItemId }),
+        ...(fact.questionId === undefined ? {} : { questionId: fact.questionId }),
+        ...(fact.answersQuestionId === undefined ? {} : { answersQuestionId: fact.answersQuestionId }),
+        verdict: fact.verdict,
+        reasons: [...fact.reasons],
+        notifiedAt: fact.auditedAt,
+        outcome,
+        transport: { ...fact.transport },
+        ...(fact.reaction === undefined ? {} : { reaction: { firstAt: fact.reaction.firstAt } }),
+        ...(judgement === undefined ? {} : { judgement }),
+        ...(fact.route === undefined ? {} : { route: { kind: fact.route.kind, originBindingId: fact.route.originBindingId } }),
+        ...(expiry === undefined ? {} : { expiry }),
+    };
+}
+function stable(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).filter(key => record[key] !== undefined).sort()
+        .map(key => `${JSON.stringify(key)}:${stable(record[key])}`).join(',')}}`;
+}
+export function notificationOutcomeDigest(record) {
+    return createHash('sha256').update(stable(record)).digest('hex');
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const entry of Object.values(value))
+            deepFreeze(entry);
+        Object.freeze(value);
+    }
+    return value;
+}
+function stored(row) {
+    return deepFreeze({
+        notificationId: row.notification_id, scopeKey: row.scope_key, version: row.version, digest: row.digest,
+        watermark: row.watermark, recordedAt: row.recorded_at, record: JSON.parse(row.record_json),
+    });
+}
+function emptyCounts() {
+    return Object.fromEntries(notificationOutcomes.map(outcome => [outcome, 0]));
+}
+/**
+ * Evaluation-owned revisable ledger keyed by notification (Delivery Outbox id).
+ * Each changed classification appends an immutable revision and advances the
+ * scope's notification watermark in one writer transaction; an unchanged
+ * digest only refreshes the check time. Nothing here touches task projections,
+ * the Evolution outbox or any parameter.
+ */
+export class NotificationOutcomeLedger {
+    #database;
+    #now;
+    constructor(database, now) {
+        this.#database = database;
+        this.#now = now;
+    }
+    #transaction(fn) {
+        this.#database.exec('BEGIN IMMEDIATE');
+        try {
+            const value = fn();
+            this.#database.exec('COMMIT');
+            return value;
+        }
+        catch (error) {
+            this.#database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    /** Apply one fact; returns whether a new revision was appended. */
+    apply(factInput, responseWindowMs) {
+        const fact = normalizeNotificationOutcomeFact(factInput);
+        const { scopeKey } = canonicalEvaluationScope(fact.scope);
+        return this.#transaction(() => {
+            const now = this.#now();
+            const record = classifyNotificationOutcome(fact, now, responseWindowMs);
+            const digest = notificationOutcomeDigest(record);
+            const head = this.#database.prepare('SELECT scope_key, version, digest FROM evaluation_notification_outcome_heads WHERE notification_id=?')
+                .get(fact.outboxId);
+            if (head !== undefined && head.scope_key !== scopeKey) {
+                throw new EvaluationStoreError('version-conflict', 'notification outcome scope changed');
+            }
+            if (head?.digest === digest) {
+                this.#database.prepare('UPDATE evaluation_notification_outcome_heads SET last_checked_at=? WHERE notification_id=?').run(now, fact.outboxId);
+                return { revised: false, head: this.#get(fact.outboxId, head.version) };
+            }
+            const version = (head?.version ?? 0) + 1;
+            this.#database.prepare(`INSERT INTO evaluation_notification_watermarks(scope_key, watermark) VALUES (?, 1)
+        ON CONFLICT(scope_key) DO UPDATE SET watermark = watermark + 1`).run(scopeKey);
+            const watermark = this.#database.prepare('SELECT watermark FROM evaluation_notification_watermarks WHERE scope_key=?')
+                .get(scopeKey).watermark;
+            this.#database.prepare(`INSERT INTO evaluation_notification_outcome_revisions
+        (notification_id, version, scope_key, outcome, record_json, digest, watermark, recorded_at) VALUES (?,?,?,?,?,?,?,?)`)
+                .run(fact.outboxId, version, scopeKey, record.outcome, stable(record), digest, watermark, now);
+            if (head === undefined) {
+                this.#database.prepare(`INSERT INTO evaluation_notification_outcome_heads
+          (notification_id, scope_key, version, digest, outcome, occurred_at, watermark, last_checked_at) VALUES (?,?,?,?,?,?,?,?)`)
+                    .run(fact.outboxId, scopeKey, version, digest, record.outcome, record.notifiedAt, watermark, now);
+            }
+            else {
+                this.#database.prepare(`UPDATE evaluation_notification_outcome_heads
+          SET version=?, digest=?, outcome=?, watermark=?, last_checked_at=? WHERE notification_id=?`)
+                    .run(version, digest, record.outcome, watermark, now, fact.outboxId);
+            }
+            return { revised: true, head: this.#get(fact.outboxId, version) };
+        });
+    }
+    /** Mark a head as checked without a fact (e.g. Delivery no longer reports it). */
+    touch(notificationId) {
+        this.#database.prepare('UPDATE evaluation_notification_outcome_heads SET last_checked_at=? WHERE notification_id=?')
+            .run(this.#now(), notificationId);
+    }
+    syncCursor() {
+        return this.#database.prepare('SELECT after_sequence FROM evaluation_notification_sync_cursor WHERE id=1')
+            .get()?.after_sequence ?? 0;
+    }
+    advanceSyncCursor(afterSequence) {
+        this.#database.prepare(`INSERT INTO evaluation_notification_sync_cursor(id, after_sequence, updated_at) VALUES (1, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET after_sequence=max(after_sequence, excluded.after_sequence), updated_at=excluded.updated_at`)
+            .run(afterSequence, this.#now());
+    }
+    /** Heads notified at or after `notifiedSince`, least recently checked first. */
+    dueForRefresh(notifiedSince, limit) {
+        return this.#database.prepare(`SELECT notification_id FROM evaluation_notification_outcome_heads
+      WHERE occurred_at >= ? ORDER BY last_checked_at, notification_id LIMIT ?`).all(notifiedSince, limit)
+            .map(row => row.notification_id);
+    }
+    #get(notificationId, version) {
+        const row = this.#database.prepare('SELECT * FROM evaluation_notification_outcome_revisions WHERE notification_id=? AND version=?')
+            .get(notificationId, version);
+        return row === undefined ? undefined : stored(row);
+    }
+    history(scopeInput, notificationId) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        const rows = this.#database.prepare(`SELECT r.* FROM evaluation_notification_outcome_revisions r
+      WHERE r.notification_id=? AND r.scope_key=? ORDER BY r.version`).all(notificationId, scopeKey);
+        if (rows.length === 0)
+            return undefined;
+        const revisions = rows.map(stored);
+        return Object.freeze({ head: revisions.at(-1), revisions: Object.freeze(revisions) });
+    }
+    feed(scopeInput, afterInput, limit) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            invalid('feed limit must be between 1 and 100');
+        if (afterInput !== undefined && (afterInput === null || typeof afterInput !== 'object' || Array.isArray(afterInput)
+            || Object.keys(afterInput).length !== 2 || afterInput.scopeKey !== scopeKey
+            || !Number.isSafeInteger(afterInput.watermark) || afterInput.watermark < 0))
+            invalid('feed cursor is invalid');
+        const after = afterInput?.watermark ?? 0;
+        this.#database.exec('BEGIN');
+        try {
+            const scopeWatermark = this.#database.prepare('SELECT watermark FROM evaluation_notification_watermarks WHERE scope_key=?')
+                .get(scopeKey)?.watermark ?? 0;
+            if (after > scopeWatermark)
+                invalid('feed cursor is ahead of scope');
+            const rows = this.#database.prepare(`SELECT r.* FROM evaluation_notification_outcome_heads h
+        JOIN evaluation_notification_outcome_revisions r ON r.notification_id=h.notification_id AND r.version=h.version
+        WHERE h.scope_key=? AND h.watermark>? ORDER BY h.watermark LIMIT ?`).all(scopeKey, after, limit + 1);
+            const items = rows.slice(0, limit).map(stored);
+            return Object.freeze({
+                items: Object.freeze(items),
+                nextCursor: Object.freeze({ scopeKey, watermark: items.at(-1)?.watermark ?? after }),
+                scopeWatermark,
+                hasMore: rows.length > limit,
+            });
+        }
+        finally {
+            this.#database.exec('COMMIT');
+        }
+    }
+    summary(scopeInput, fromNotifiedAt, toNotifiedAt) {
+        const { scope, scopeKey } = canonicalEvaluationScope(scopeInput);
+        const rows = this.#database.prepare(`SELECT h.outcome AS outcome, json_extract(r.record_json, '$.verdict') AS verdict, COUNT(*) AS count
+      FROM evaluation_notification_outcome_heads h
+      JOIN evaluation_notification_outcome_revisions r ON r.notification_id=h.notification_id AND r.version=h.version
+      WHERE h.scope_key=? AND h.occurred_at>=? AND h.occurred_at<? GROUP BY h.outcome, verdict`)
+            .all(scopeKey, fromNotifiedAt, toNotifiedAt);
+        const outcomes = emptyCounts();
+        const byVerdict = Object.fromEntries(verdicts.map(verdict => [verdict, emptyCounts()]));
+        let total = 0;
+        for (const row of rows) {
+            outcomes[row.outcome] += row.count;
+            byVerdict[row.verdict][row.outcome] += row.count;
+            total += row.count;
+        }
+        return deepFreeze({ scope, scopeKey, fromNotifiedAt, toNotifiedAt, total, outcomes, byVerdict });
+    }
+    /**
+     * Current heads in `[from, to)` notification time whose record names a work
+     * item, oldest first, at most `limit` (plus whether more exist). Read-only;
+     * a scan of the scope's heads in the window (no index on the work item).
+     */
+    workItemHeads(scopeInput, fromNotifiedAt, toNotifiedAt, limit) {
+        const { scopeKey } = canonicalEvaluationScope(scopeInput);
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000)
+            invalid('work item head limit is invalid');
+        const rows = this.#database.prepare(`SELECT r.* FROM evaluation_notification_outcome_heads h
+      JOIN evaluation_notification_outcome_revisions r ON r.notification_id=h.notification_id AND r.version=h.version
+      WHERE h.scope_key=? AND h.occurred_at>=? AND h.occurred_at<?
+        AND json_extract(r.record_json, '$.workItemId') IS NOT NULL
+      ORDER BY h.occurred_at, h.notification_id LIMIT ?`).all(scopeKey, fromNotifiedAt, toNotifiedAt, limit + 1);
+        return Object.freeze({ records: Object.freeze(rows.slice(0, limit).map(row => stored(row).record)), truncated: rows.length > limit });
+    }
+    counts() {
+        const heads = this.#database.prepare('SELECT COUNT(*) AS count FROM evaluation_notification_outcome_heads').get();
+        const revisions = this.#database.prepare('SELECT COUNT(*) AS count FROM evaluation_notification_outcome_revisions').get();
+        return { notifications: heads.count, revisions: revisions.count };
+    }
+}
+//# sourceMappingURL=notification-outcomes.js.map