@dsh-enhanced/plugin-control-plane 0.1.64 → 0.1.66

package/lib/creation-capability-feedback.js

@@ -1,10 +1,16 @@
 import { controlPlaneDigest } from './store.js';
+/** Below this many samples a measure is marked insufficient; latency percentiles are withheld, quality counts stay exact. */
+export const DEFAULT_MINIMUM_SAMPLES = 5;
 const same = (a, b) => controlPlaneDigest(a) === controlPlaneDigest(b);
 /** Read the current canonical head and the corresponding authenticated Delivery source. */
 function readTask(input, inboxId) {
-    const { owner, evaluation, delivery } = input;
+    const { owner, evaluation } = input;
     const scope = evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
-    const canonical = evaluation.getTrustedForegroundLearningProjection({ scope, inboxId });
+    return certifiedTask(input, evaluation.getTrustedForegroundLearningProjection({ scope, inboxId }), inboxId);
+}
+/** The authenticated Delivery source of one current certified foreground head, or undefined. */
+function certifiedTask(input, canonical, inboxId) {
+    const { owner, delivery } = input;
     if (!canonical || canonical.projection.subjectKind !== 'foreground-turn'
         || canonical.projection.subjectRef !== inboxId || canonical.projection.disposition !== 'upsert')
         return undefined;
@@ -23,14 +29,20 @@ function readTask(input, inboxId) {
         return undefined;
     return source;
 }
-/** No cache: every result is checked against the current canonical writer and owner route. */
-export function inspectCreationCapabilityTaskAssociations(input) {
-    const { record, calls, owner, delivery, evaluation } = input;
-    const receipt = record.receipt;
-    if (!receipt || receipt.planId !== record.planId || input.triggerInboxId.length === 0)
-        return [];
-    const now = input.now ?? Date.now();
-    const receiptDigest = controlPlaneDigest(receipt);
+function taskModel(source) {
+    const selection = source.modelSelection;
+    if (source.modelSelectionState === 'missing')
+        return { state: 'missing' };
+    if (source.modelSelectionState !== 'frozen' || !selection || typeof selection.provider !== 'string'
+        || typeof selection.model !== 'string' || (selection.reasoningEffort !== undefined
+        && typeof selection.reasoningEffort !== 'string'))
+        return { state: 'inconsistent' };
+    return { state: 'frozen', provider: selection.provider, model: selection.model,
+        ...(selection.reasoningEffort === undefined ? {} : { reasoningEffort: selection.reasoningEffort }) };
+}
+/** Completed foreground calls of this exact adoption grouped by Inbox; undefined for a mixed-session Inbox. */
+function eligibleCalls(input, receipt, receiptDigest, now) {
+    const { record, calls, owner } = input;
     const grouped = new Map();
     for (const call of calls) {
         const proof = call.foreground;
@@ -51,14 +63,54 @@ export function inspectCreationCapabilityTaskAssociations(input) {
             continue;
         const prior = grouped.get(proof.task.inboxId);
         if (prior && prior.sessionId !== proof.task.sessionId)
-            return [];
+            return undefined;
         if (prior)
             prior.calls.push(call);
         else
             grouped.set(proof.task.inboxId, { sessionId: proof.task.sessionId, calls: [call] });
     }
-    if (grouped.size === 0)
-        return [];
+    return grouped;
+}
+/** Owner-fenced original task source whose binding matches the current learning head. */
+function originalTaskSource(input, source, inboxId) {
+    const { owner, delivery } = input;
+    const originalSource = delivery.inspectOwnerForegroundTaskSource({ authorityId: owner.authorityId,
+        principalId: owner.principalId, workspace: owner.workspace, agentPreset: owner.agentPreset,
+        expectedOwner: { authorityHash: owner.authorityHash, principalRecordId: owner.principalRecordId,
+            principalVersion: owner.principalVersion }, inboxId });
+    if (!originalSource || source.source.sessionId !== originalSource.binding.sessionId
+        || source.owner.bindingVersion !== originalSource.binding.version
+        || source.owner.generation !== originalSource.binding.generation
+        || originalSource.authorityId !== owner.authorityId || originalSource.authorityHash !== owner.authorityHash
+        || originalSource.principalId !== owner.principalId
+        || originalSource.owner.principalRecordId !== owner.principalRecordId
+        || originalSource.owner.principalVersion !== owner.principalVersion)
+        return undefined;
+    return originalSource;
+}
+const sameBinding = (call, binding) => {
+    const task = call.foreground.task;
+    return task.binding.id === binding.id && task.binding.version === binding.version && task.binding.generation === binding.generation;
+};
+const taskLatencyMs = (execution) => execution?.quiescent && Number.isSafeInteger(execution.completedAt)
+    && Number.isSafeInteger(execution.dispatchedAt) && execution.completedAt >= execution.dispatchedAt
+    ? execution.completedAt - execution.dispatchedAt : undefined;
+/**
+ * One fenced read of grouped candidate Inboxes into current association rows. Undefined means no receipt, a mixed
+ * session Inbox, a stale or changed fence, or a throw; `fenceEmpty` still checks the original task with no candidates.
+ */
+function readAssociationRows(input, fenceEmpty) {
+    const { record, owner, evaluation } = input;
+    const receipt = record.receipt;
+    if (!receipt || receipt.planId !== record.planId || input.triggerInboxId.length === 0)
+        return undefined;
+    const now = input.now ?? Date.now();
+    const receiptDigest = controlPlaneDigest(receipt);
+    const grouped = eligibleCalls(input, receipt, receiptDigest, now);
+    if (!grouped)
+        return undefined;
+    if (grouped.size === 0 && !fenceEmpty)
+        return { rows: [], candidates: 0, receiptDigest, now };
     const scope = evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
     const read = () => {
         const original = input.readSourceCurrent();
@@ -67,49 +119,38 @@ export function inspectCreationCapabilityTaskAssociations(input) {
             throw new Error('created capability original task is no longer current');
         }
         const evidence = [original.projection];
-        const items = [];
+        const rows = [];
         let watermark = original.scopeWatermark;
         for (const [inboxId, group] of grouped) {
             const source = readTask(input, inboxId);
             if (!source)
                 continue;
-            const originalSource = delivery.inspectOwnerForegroundTaskSource({ authorityId: owner.authorityId,
-                principalId: owner.principalId, workspace: owner.workspace, agentPreset: owner.agentPreset,
-                expectedOwner: { authorityHash: owner.authorityHash, principalRecordId: owner.principalRecordId,
-                    principalVersion: owner.principalVersion }, inboxId });
-            if (!originalSource || originalSource.binding.sessionId !== group.sessionId
-                || source.source.sessionId !== group.sessionId
-                || source.owner.bindingVersion !== originalSource.binding.version
-                || source.owner.generation !== originalSource.binding.generation
-                || originalSource.authorityId !== owner.authorityId || originalSource.authorityHash !== owner.authorityHash
-                || originalSource.principalId !== owner.principalId
-                || originalSource.owner.principalRecordId !== owner.principalRecordId
-                || originalSource.owner.principalVersion !== owner.principalVersion)
+            const originalSource = originalTaskSource(input, source, inboxId);
+            if (!originalSource || originalSource.binding.sessionId !== group.sessionId)
                 continue;
-            const valid = group.calls.filter(call => {
-                const task = call.foreground.task;
-                return task.binding.id === originalSource.binding.id && task.binding.version === originalSource.binding.version
-                    && task.binding.generation === originalSource.binding.generation;
-            });
+            const valid = group.calls.filter(call => sameBinding(call, originalSource.binding));
             if (valid.length === 0)
                 continue;
             evidence.push(source.canonical.projection);
             watermark = Math.max(watermark, source.canonical.scopeWatermark);
             const projection = source.canonical.projection;
-            items.push({ protocol: 'dsh-created-capability-task-association/v1', planId: record.planId,
-                inboxId, sessionId: group.sessionId, callKeys: valid.map(call => call.key).sort(),
-                receiptDigest, artifactSha256: receipt.artifactSha256, schemaDigest: receipt.schemaDigest,
-                adoptionStatus: record.status,
-                withinSignedUseWindow: now >= receipt.adoptedAt && now < receipt.expiresAt,
-                task: { projection: { subjectKind: 'foreground-turn', subjectRef: inboxId, version: projection.version,
-                        digest: projection.digest, disposition: 'upsert' }, scopeWatermark: source.canonical.scopeWatermark,
-                    outcomeId: source.canonical.triggerOutcomeId,
-                    judgement: source.judgement,
-                    status: source.canonical.objective.status,
-                    sourceDigest: controlPlaneDigest({ protocol: source.protocol, source: source.source,
-                        judgement: source.judgement, ownerRevision: source.ownerRevision }) } });
+            const latencyMs = taskLatencyMs(originalSource.execution);
+            rows.push({ association: { protocol: 'dsh-created-capability-task-association/v1', planId: record.planId,
+                    inboxId, sessionId: group.sessionId, callKeys: valid.map(call => call.key).sort(),
+                    receiptDigest, artifactSha256: receipt.artifactSha256, schemaDigest: receipt.schemaDigest,
+                    adoptionStatus: record.status,
+                    withinSignedUseWindow: now >= receipt.adoptedAt && now < receipt.expiresAt,
+                    task: { projection: { subjectKind: 'foreground-turn', subjectRef: inboxId, version: projection.version,
+                            digest: projection.digest, disposition: 'upsert' }, scopeWatermark: source.canonical.scopeWatermark,
+                        outcomeId: source.canonical.triggerOutcomeId,
+                        judgement: source.judgement,
+                        status: source.canonical.objective.status,
+                        sourceDigest: controlPlaneDigest({ protocol: source.protocol, source: source.source,
+                            judgement: source.judgement, ownerRevision: source.ownerRevision }) } },
+                model: taskModel(source.source), callLatencyMs: valid.map(call => call.settledAt - call.claimedAt),
+                ...(latencyMs === undefined ? {} : { taskLatencyMs: latencyMs }) });
         }
-        return { original, items, evidence, watermark };
+        return { original, rows, evidence, watermark };
     };
     try {
         const before = read();
@@ -118,15 +159,456 @@ export function inspectCreationCapabilityTaskAssociations(input) {
             const during = read();
             if (!same(during, before))
                 throw new Error('created capability task association source changed');
-            return during.items;
+            return during.rows;
+        });
+        return result.matched ? { rows: result.value, candidates: grouped.size, receiptDigest, now } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** No cache: every result is checked against the current canonical writer and owner route. */
+export function inspectCreationCapabilityTaskAssociations(input) {
+    const rows = readAssociationRows(input, false)?.rows ?? [];
+    return rows.length === 0 ? [] : Object.freeze(rows.map(({ association: item }) => Object.freeze({ ...item,
+        callKeys: Object.freeze([...item.callKeys]),
+        task: Object.freeze({ ...item.task, projection: Object.freeze({ ...item.task.projection }) }),
+    })));
+}
+const modelKey = (model) => model.state === 'frozen'
+    ? JSON.stringify([model.state, model.provider, model.model, model.reasoningEffort ?? null]) : JSON.stringify([model.state]);
+function latency(values, minimumSamples) {
+    if (values.length === 0)
+        return { status: 'unmeasured', samples: 0 };
+    if (values.length < minimumSamples)
+        return { status: 'insufficient', samples: values.length };
+    const sorted = [...values].sort((a, b) => a - b);
+    return { status: 'measured', samples: sorted.length, p50Ms: sorted[Math.ceil(sorted.length / 2) - 1],
+        maxMs: sorted[sorted.length - 1] };
+}
+function measures(rows, minimumSamples) {
+    const achieved = rows.filter(row => row.association.task.status === 'achieved').length;
+    return { quality: { status: rows.length < minimumSamples ? 'insufficient' : 'measured', samples: rows.length,
+            achieved, notAchieved: rows.length - achieved },
+        callLatency: latency(rows.flatMap(row => row.callLatencyMs), minimumSamples),
+        taskLatency: latency(rows.flatMap(row => row.taskLatencyMs === undefined ? [] : [row.taskLatencyMs]), minimumSamples) };
+}
+function deepFreeze(value) {
+    if (typeof value === 'object' && value !== null) {
+        for (const item of Object.values(value))
+            deepFreeze(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+/**
+ * Descriptive, non-causal counts over the same fenced current associations: one latest-revision quality sample per
+ * Inbox, strata by frozen task model only. Undefined only for a missing receipt, a failed fence or a throw.
+ */
+export function inspectCreationCapabilityOrdinaryUseReport(input) {
+    const minimumSamples = input.minimumSamples ?? DEFAULT_MINIMUM_SAMPLES;
+    if (!Number.isSafeInteger(minimumSamples) || minimumSamples < 1) {
+        throw new TypeError('created capability ordinary-use minimumSamples must be a positive safe integer');
+    }
+    const read = readAssociationRows(input, true);
+    const receipt = input.record.receipt;
+    if (!read || !receipt)
+        return undefined;
+    const rows = [...read.rows].sort((a, b) => a.association.inboxId < b.association.inboxId ? -1
+        : a.association.inboxId > b.association.inboxId ? 1 : 0);
+    const buckets = new Map();
+    for (const row of rows) {
+        const key = modelKey(row.model);
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.rows.push(row);
+        else
+            buckets.set(key, { model: row.model, rows: [row] });
+    }
+    const strata = [...buckets].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+        .map(([, bucket]) => ({ model: bucket.model, ...measures(bucket.rows, minimumSamples) }));
+    return deepFreeze({ protocol: 'dsh-created-capability-ordinary-use-report/v1', causal: false,
+        planId: input.record.planId, receiptDigest: read.receiptDigest, artifactSha256: receipt.artifactSha256,
+        schemaDigest: receipt.schemaDigest, adoptionStatus: input.record.status,
+        withinSignedUseWindow: read.now >= receipt.adoptedAt && read.now < receipt.expiresAt, minimumSamples,
+        associationsDigest: controlPlaneDigest(rows.map(row => row.association)),
+        unknown: { inboxes: read.candidates - rows.length }, overall: measures(rows, minimumSamples), strata,
+        regressions: { status: 'unmeasured' }, cost: { status: 'unmeasured' } });
+}
+export const DEFAULT_MAX_SCANNED_HEADS = 5_000;
+/** Every current canonical head of the scope under one unchanged scope watermark; throws when it moves or overflows. */
+function scanScope(evaluation, scope, maxScannedHeads) {
+    const heads = [];
+    let after;
+    let scopeWatermark;
+    for (;;) {
+        const page = evaluation.listTrustedTaskLearningProjections({ scope, ...(after ? { after } : {}), limit: 100 });
+        if (scopeWatermark !== undefined && page.scopeWatermark !== scopeWatermark) {
+            throw new Error('created capability attribution scope changed during scan');
+        }
+        scopeWatermark = page.scopeWatermark;
+        heads.push(...page.items.map(item => item.receipt));
+        if (heads.length > maxScannedHeads)
+            throw new Error('created capability attribution scope is too large');
+        if (!page.hasMore)
+            return { heads, scopeWatermark: page.scopeWatermark };
+        after = page.nextCursor;
+    }
+}
+function arm(rows, minimumSamples) {
+    const achieved = rows.filter(row => row.status === 'achieved').length;
+    return { quality: { status: rows.length < minimumSamples ? 'insufficient' : 'measured', samples: rows.length,
+            achieved, notAchieved: rows.length - achieved },
+        taskLatency: latency(rows.flatMap(row => row.taskLatencyMs === undefined ? [] : [row.taskLatencyMs]), minimumSamples) };
+}
+/** a1/n1 - a0/n0 = (a1*n0 - a0*n1) / (n0*n1), exact and unreduced. */
+function delta(before, after) {
+    if (before.quality.status !== 'measured' || after.quality.status !== 'measured')
+        return { status: 'insufficient' };
+    const numerator = after.quality.achieved * before.quality.samples - before.quality.achieved * after.quality.samples;
+    return { status: 'paired', numerator, denominator: before.quality.samples * after.quality.samples,
+        sign: numerator > 0 ? 1 : numerator < 0 ? -1 : 0 };
+}
+/**
+ * Intention-to-treat before/after attribution of one adoption: every certified current owner foreground task (one
+ * latest-revision head per Inbox; corrections replace, withdrawals retract) in equal windows around adoption, by
+ * frozen task model. Read once, then reread under an unchanged Evaluation scope watermark. Undefined for a missing
+ * receipt, an oversized scope, a changed source, scope or fence, or a throw. Observational, never causal.
+ */
+export function inspectCreationCapabilityAvailabilityAttribution(input) {
+    const minimumSamples = input.minimumSamples ?? DEFAULT_MINIMUM_SAMPLES;
+    const maxScannedHeads = input.maxScannedHeads ?? DEFAULT_MAX_SCANNED_HEADS;
+    for (const [name, value] of [['minimumSamples', minimumSamples], ['maxScannedHeads', maxScannedHeads]]) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new TypeError(`created capability attribution ${name} must be a positive safe integer`);
+        }
+    }
+    if (input.windowMs !== undefined && (!Number.isSafeInteger(input.windowMs) || input.windowMs < 1)) {
+        throw new TypeError('created capability attribution windowMs must be a positive safe integer');
+    }
+    const { record, owner, evaluation } = input;
+    const receipt = record.receipt;
+    if (!receipt || receipt.planId !== record.planId || input.triggerInboxId.length === 0)
+        return undefined;
+    const now = input.now ?? Date.now();
+    const receiptDigest = controlPlaneDigest(receipt);
+    const elapsed = Math.max(0, Math.min(now, receipt.expiresAt) - receipt.adoptedAt);
+    const windowMs = Math.min(input.windowMs ?? elapsed, elapsed);
+    const grouped = eligibleCalls(input, receipt, receiptDigest, now);
+    if (!grouped)
+        return undefined;
+    const scope = evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
+    const scan = () => scanScope(evaluation, scope, maxScannedHeads);
+    const read = (heads) => {
+        const original = input.readSourceCurrent();
+        if (original.projection.subjectKind !== 'foreground-turn'
+            || original.projection.subjectRef !== input.triggerInboxId || original.projection.disposition !== 'upsert') {
+            throw new Error('created capability original task is no longer current');
+        }
+        const excluded = { nonForeground: 0, trigger: 0, retracted: 0, unverified: 0, outsideWindow: 0 };
+        const rows = [];
+        for (const head of heads) {
+            const inboxId = head.projection.subjectRef;
+            if (head.projection.subjectKind !== 'foreground-turn') {
+                excluded.nonForeground++;
+                continue;
+            }
+            if (inboxId === input.triggerInboxId) {
+                excluded.trigger++;
+                continue;
+            }
+            if (head.projection.disposition !== 'upsert') {
+                excluded.retracted++;
+                continue;
+            }
+            const source = certifiedTask(input, head, inboxId);
+            const originalSource = source && originalTaskSource(input, source, inboxId);
+            const dispatchedAt = originalSource?.execution?.dispatchedAt;
+            if (!source || !originalSource || !Number.isSafeInteger(dispatchedAt)) {
+                excluded.unverified++;
+                continue;
+            }
+            const at = dispatchedAt;
+            const side = windowMs > 0 && at >= receipt.adoptedAt - windowMs && at <= receipt.adoptedAt ? 'before'
+                : windowMs > 0 && at > receipt.adoptedAt && at <= receipt.adoptedAt + windowMs ? 'after' : undefined;
+            if (!side) {
+                excluded.outsideWindow++;
+                continue;
+            }
+            const group = grouped.get(inboxId);
+            const latencyMs = taskLatencyMs(originalSource.execution);
+            rows.push({ arm: side, inboxId, model: taskModel(source.source),
+                status: source.canonical.objective.status,
+                projection: { version: head.projection.version, digest: head.projection.digest },
+                outcomeId: head.triggerOutcomeId,
+                sourceDigest: controlPlaneDigest({ protocol: source.protocol, source: source.source,
+                    judgement: source.judgement, ownerRevision: source.ownerRevision }),
+                exposed: side === 'after' && group !== undefined && group.sessionId === originalSource.binding.sessionId
+                    && group.calls.some(call => sameBinding(call, originalSource.binding)),
+                ...(latencyMs === undefined ? {} : { taskLatencyMs: latencyMs }) });
+        }
+        rows.sort((a, b) => a.inboxId < b.inboxId ? -1 : a.inboxId > b.inboxId ? 1 : 0);
+        return { original, rows, excluded };
+    };
+    let result;
+    try {
+        const scanned = scan();
+        const before = read(scanned.heads);
+        // An unchanged scope watermark means an unchanged feed; Delivery and the original source are reread inside.
+        const fenced = evaluation.withTrustedCanonicalScopeWriterFence({ scope, scopeWatermark: scanned.scopeWatermark }, () => {
+            const during = read(scanned.heads);
+            if (!same(during, before))
+                throw new Error('created capability attribution source changed');
+            return during;
+        });
+        if (!fenced.matched)
+            return undefined;
+        result = { ...scanned, read: fenced.value };
+    }
+    catch {
+        return undefined;
+    }
+    const { rows, excluded } = result.read;
+    const buckets = new Map();
+    for (const row of rows) {
+        const key = modelKey(row.model);
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.rows.push(row);
+        else
+            buckets.set(key, { model: row.model, rows: [row] });
+    }
+    const strata = [...buckets].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+        .map(([, bucket]) => {
+        const beforeArm = arm(bucket.rows.filter(row => row.arm === 'before'), minimumSamples);
+        const afterArm = arm(bucket.rows.filter(row => row.arm === 'after'), minimumSamples);
+        return { model: bucket.model, before: beforeArm, after: afterArm, achievedRateDelta: delta(beforeArm, afterArm) };
+    });
+    const signs = new Set(strata.flatMap(stratum => stratum.achievedRateDelta.status === 'paired'
+        ? [stratum.achievedRateDelta.sign] : []));
+    const direction = signs.size === 0 ? 'insufficient' : signs.size > 1 ? 'mixed'
+        : signs.has(1) ? 'improved' : signs.has(-1) ? 'regressed' : 'unchanged';
+    const concurrent = windowMs === 0 ? 0 : (input.otherAdoptedAt ?? []).filter(at => Number.isFinite(at)
+        && at >= receipt.adoptedAt - windowMs && at <= receipt.adoptedAt + windowMs).length;
+    const afterRows = rows.filter(row => row.arm === 'after');
+    return deepFreeze({ protocol: 'dsh-created-capability-availability-attribution/v1', causal: false,
+        design: 'adoption-before-after-itt-model-stratified', planId: record.planId, receiptDigest,
+        artifactSha256: receipt.artifactSha256, schemaDigest: receipt.schemaDigest, adoptionStatus: record.status,
+        withinSignedUseWindow: now >= receipt.adoptedAt && now < receipt.expiresAt, minimumSamples, windowMs,
+        scopeWatermark: result.scopeWatermark, rowsDigest: controlPlaneDigest(rows),
+        population: { scanned: result.heads.length, counted: rows.length, excluded },
+        exposure: { afterTasks: afterRows.length, exposedTasks: afterRows.filter(row => row.exposed).length },
+        concurrentAdoptions: { status: concurrent === 0 ? 'none' : 'flagged', count: concurrent },
+        strata, direction, regressions: { status: 'unmeasured' }, cost: { status: 'unmeasured' } });
+}
+export const TREND_DEFAULT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+export const TREND_WINDOW_MS_BOUNDS = { min: 60 * 60 * 1000, max: 90 * 24 * 60 * 60 * 1000 };
+export const TREND_DEFAULT_PRE_WINDOWS = 4;
+export const TREND_DEFAULT_MAX_POST_WINDOWS = 12;
+export const TREND_WINDOW_COUNT_MAX = 52;
+export const TREND_DEFAULT_PARALLEL_TREND_THRESHOLD = 0.2;
+/** Fixed, machine-readable statement of what the estimate assumes; it is never a causal claim. */
+export const TREND_ASSUMPTIONS = Object.freeze([
+    'parallel-trends: without this adoption the treated and control session cohorts would change achieved rate equally',
+    'session-cohort: a session is treated when a counted after-window task in it has an exact call of this adoption; membership is chosen after adoption, so selection on post-adoption use is not removed',
+    'no-spillover: control sessions are assumed unaffected although the capability is available to them',
+    'independent-tasks: the 95% interval is a four-cell Price-Bonett adjusted Wald interval (each cell (y+0.5)/(n+1)), centered on the adjusted estimate, over independent task outcomes',
+    'session-rotation: after an owner DM /new rotation the earlier session is a time-split control of the same owner, not a parallel one',
+    'availability: after windows end at min(now, expiresAt) only; a non-active adoption record (closed, rejected, unknown) is still treated as available and flagged adoption-not-active',
+]);
+const quality = (rows, minimumSamples) => {
+    const achieved = rows.filter(row => row.status === 'achieved').length;
+    return { status: rows.length < minimumSamples ? 'insufficient' : 'measured', samples: rows.length,
+        achieved, notAchieved: rows.length - achieved };
+};
+const rate = (cell) => cell.achieved / cell.samples;
+function differenceInDifferences(cells) {
+    if (cells.some(cell => cell.status !== 'measured'))
+        return { status: 'insufficient' };
+    const [t0, t1, c0, c1] = cells;
+    const estimate = (rate(t1) - rate(t0)) - (rate(c1) - rate(c0));
+    // Price-Bonett: half a success and half a failure per cell, interval centered on the adjusted contrast.
+    const adjusted = (cell) => (cell.achieved + 0.5) / (cell.samples + 1);
+    const adjustedEstimate = (adjusted(t1) - adjusted(t0)) - (adjusted(c1) - adjusted(c0));
+    const standardError = Math.sqrt(cells.reduce((sum, cell) => {
+        const p = adjusted(cell);
+        return sum + p * (1 - p) / (cell.samples + 1);
+    }, 0));
+    return { status: 'estimated', estimate, adjustedEstimate, standardError, interval95: {
+            low: Math.max(-2, adjustedEstimate - 1.96 * standardError), high: Math.min(2, adjustedEstimate + 1.96 * standardError)
+        } };
+}
+function parallelTrend(cells, threshold) {
+    const tested = cells.filter(cell => cell.index < 0 && cell.treated.status === 'measured' && cell.control.status === 'measured');
+    if (tested.length < 2)
+        return { status: 'untestable', testedWindows: tested.length };
+    const gap = (cell) => rate(cell.treated) - rate(cell.control);
+    const gapChange = gap(tested[tested.length - 1]) - gap(tested[0]);
+    return { status: Math.abs(gapChange) > threshold ? 'parallel-trend-suspect' : 'not-flagged',
+        testedWindows: tested.length, gapChange };
+}
+function boundedInteger(name, value, min, max) {
+    if (!Number.isSafeInteger(value) || value < min || value > max) {
+        throw new TypeError(`created capability ordinary-use trend ${name} must be an integer in [${min}, ${max}]`);
+    }
+    return value;
+}
+/**
+ * Longitudinal ordinary-use series of one adoption in fixed windows around adoption, by frozen task model, with a
+ * same-scope session-cohort control and a pooled difference-in-differences estimate. Every certified current owner
+ * foreground task counts once by its latest revision (corrections replace, withdrawals retract). Read once, then
+ * reread under an unchanged Evaluation scope watermark. Undefined for a missing receipt, an oversized scope, a changed
+ * source, scope or fence, or a throw. Pure read; observational, never causal.
+ */
+export function inspectCreationCapabilityOrdinaryUseTrend(input) {
+    const minimumSamples = boundedInteger('minimumSamples', input.minimumSamples ?? DEFAULT_MINIMUM_SAMPLES, 1, Number.MAX_SAFE_INTEGER);
+    const maxScannedHeads = boundedInteger('maxScannedHeads', input.maxScannedHeads ?? DEFAULT_MAX_SCANNED_HEADS, 1, Number.MAX_SAFE_INTEGER);
+    const windowMs = boundedInteger('windowMs', input.windowMs ?? TREND_DEFAULT_WINDOW_MS, TREND_WINDOW_MS_BOUNDS.min, TREND_WINDOW_MS_BOUNDS.max);
+    const preWindows = boundedInteger('preWindows', input.preWindows ?? TREND_DEFAULT_PRE_WINDOWS, 2, TREND_WINDOW_COUNT_MAX);
+    const maxPostWindows = boundedInteger('maxPostWindows', input.maxPostWindows ?? TREND_DEFAULT_MAX_POST_WINDOWS, 1, TREND_WINDOW_COUNT_MAX);
+    const threshold = input.parallelTrendThreshold ?? TREND_DEFAULT_PARALLEL_TREND_THRESHOLD;
+    if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 1) {
+        throw new TypeError('created capability ordinary-use trend parallelTrendThreshold must be in (0, 1]');
+    }
+    const { record, owner, evaluation } = input;
+    const receipt = record.receipt;
+    if (!receipt || receipt.planId !== record.planId || input.triggerInboxId.length === 0)
+        return undefined;
+    const now = input.now ?? Date.now();
+    const receiptDigest = controlPlaneDigest(receipt);
+    const observedUntil = Math.max(receipt.adoptedAt, Math.min(now, receipt.expiresAt));
+    const postWindows = Math.min(maxPostWindows, Math.ceil((observedUntil - receipt.adoptedAt) / windowMs));
+    const windows = [];
+    for (let index = -preWindows; index < postWindows; index++) {
+        const fullEnd = receipt.adoptedAt + (index + 1) * windowMs;
+        // After windows never extend past min(now, expiresAt); the latest one is clipped there and marked incomplete.
+        windows.push({ index, startExclusive: fullEnd - windowMs,
+            endInclusive: index < 0 ? fullEnd : Math.min(fullEnd, observedUntil), complete: index < 0 || fullEnd <= observedUntil });
+    }
+    const first = windows[0].startExclusive;
+    const last = Math.min(windows[windows.length - 1].endInclusive, observedUntil);
+    // A dispatch exactly at adoption precedes it, matching the strict call admission rule. Dispatches after
+    // min(now, expiresAt) are outside every window, so an expired adoption stops accruing after tasks.
+    const windowOf = (at) => at <= first || at > last ? undefined
+        : Math.ceil((at - receipt.adoptedAt) / windowMs) - 1;
+    const grouped = eligibleCalls(input, receipt, receiptDigest, now);
+    if (!grouped)
+        return undefined;
+    const scope = evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
+    const read = (heads) => {
+        const original = input.readSourceCurrent();
+        if (original.projection.subjectKind !== 'foreground-turn'
+            || original.projection.subjectRef !== input.triggerInboxId || original.projection.disposition !== 'upsert') {
+            throw new Error('created capability original task is no longer current');
+        }
+        const excluded = { nonForeground: 0, trigger: 0, retracted: 0, unverified: 0, outsideWindow: 0 };
+        const rows = [];
+        for (const head of heads) {
+            const inboxId = head.projection.subjectRef;
+            if (head.projection.subjectKind !== 'foreground-turn') {
+                excluded.nonForeground++;
+                continue;
+            }
+            if (inboxId === input.triggerInboxId) {
+                excluded.trigger++;
+                continue;
+            }
+            if (head.projection.disposition !== 'upsert') {
+                excluded.retracted++;
+                continue;
+            }
+            const source = certifiedTask(input, head, inboxId);
+            const originalSource = source && originalTaskSource(input, source, inboxId);
+            const dispatchedAt = originalSource?.execution?.dispatchedAt;
+            if (!source || !originalSource || !Number.isSafeInteger(dispatchedAt)) {
+                excluded.unverified++;
+                continue;
+            }
+            const index = windowOf(dispatchedAt);
+            if (index === undefined) {
+                excluded.outsideWindow++;
+                continue;
+            }
+            const group = grouped.get(inboxId);
+            const calls = index >= 0 && group && group.sessionId === originalSource.binding.sessionId
+                ? group.calls.filter(call => sameBinding(call, originalSource.binding)).length : 0;
+            rows.push({ index, inboxId, sessionId: originalSource.binding.sessionId, model: taskModel(source.source),
+                status: source.canonical.objective.status,
+                projection: { version: head.projection.version, digest: head.projection.digest },
+                outcomeId: head.triggerOutcomeId,
+                sourceDigest: controlPlaneDigest({ protocol: source.protocol, source: source.source,
+                    judgement: source.judgement, ownerRevision: source.ownerRevision }), calls });
+        }
+        rows.sort((a, b) => a.inboxId < b.inboxId ? -1 : a.inboxId > b.inboxId ? 1 : 0);
+        return { original, rows, excluded };
+    };
+    let result;
+    try {
+        const scanned = scanScope(evaluation, scope, maxScannedHeads);
+        const before = read(scanned.heads);
+        const fenced = evaluation.withTrustedCanonicalScopeWriterFence({ scope, scopeWatermark: scanned.scopeWatermark }, () => {
+            const during = read(scanned.heads);
+            if (!same(during, before))
+                throw new Error('created capability ordinary-use trend source changed');
+            return during;
         });
-        return result.matched ? Object.freeze(result.value.map(item => Object.freeze({ ...item,
-            callKeys: Object.freeze([...item.callKeys]),
-            task: Object.freeze({ ...item.task, projection: Object.freeze({ ...item.task.projection }) }),
-        }))) : [];
+        if (!fenced.matched)
+            return undefined;
+        result = { ...scanned, read: fenced.value };
     }
     catch {
-        return [];
+        return undefined;
     }
+    const { rows, excluded } = result.read;
+    const treatedSessions = new Set(rows.filter(row => row.calls > 0).map(row => row.sessionId));
+    const controlSessions = new Set(rows.filter(row => !treatedSessions.has(row.sessionId)).map(row => row.sessionId));
+    const buckets = new Map();
+    for (const row of rows) {
+        const key = modelKey(row.model);
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.rows.push(row);
+        else
+            buckets.set(key, { model: row.model, rows: [row] });
+    }
+    const strata = [...buckets].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+        .map(([, bucket]) => {
+        const treated = bucket.rows.filter(row => treatedSessions.has(row.sessionId));
+        const control = bucket.rows.filter(row => !treatedSessions.has(row.sessionId));
+        const cells = windows.map(({ index }) => {
+            const inWindow = bucket.rows.filter(row => row.index === index);
+            return { index, treated: quality(treated.filter(row => row.index === index), minimumSamples),
+                control: quality(control.filter(row => row.index === index), minimumSamples),
+                calls: inWindow.reduce((sum, row) => sum + row.calls, 0),
+                exposedTasks: inWindow.filter(row => row.calls > 0).length };
+        });
+        const pooled = (rows, after) => quality(rows.filter(row => (row.index >= 0) === after), minimumSamples);
+        return { model: bucket.model, cells,
+            differenceInDifferences: differenceInDifferences([pooled(treated, false), pooled(treated, true),
+                pooled(control, false), pooled(control, true)]),
+            parallelTrend: parallelTrend(cells, threshold) };
+    });
+    const concurrent = (input.otherAdoptedAt ?? []).filter(at => Number.isFinite(at) && at > first && at <= last).length;
+    const flags = [];
+    if (strata.some(stratum => stratum.parallelTrend.status === 'parallel-trend-suspect'))
+        flags.push('parallel-trend-suspect');
+    if (controlSessions.size === 0)
+        flags.push('no-control-cohort');
+    if (concurrent > 0)
+        flags.push('concurrent-adoptions');
+    if (windows.some(window => !window.complete))
+        flags.push('partial-window');
+    if (record.status !== 'active')
+        flags.push('adoption-not-active');
+    return deepFreeze({ protocol: 'dsh-created-capability-ordinary-use-trend/v1', causal: false,
+        design: 'session-cohort-difference-in-differences-model-stratified', planId: record.planId, receiptDigest,
+        artifactSha256: receipt.artifactSha256, schemaDigest: receipt.schemaDigest, adoptionStatus: record.status,
+        withinSignedUseWindow: now >= receipt.adoptedAt && now < receipt.expiresAt, minimumSamples, windowMs,
+        parallelTrendThreshold: threshold, scopeWatermark: result.scopeWatermark,
+        rowsDigest: controlPlaneDigest(rows.map(({ sessionId: _sessionId, ...row }) => row)), windows,
+        population: { scanned: result.heads.length, counted: rows.length, excluded },
+        cohorts: { treatedSessions: treatedSessions.size, controlSessions: controlSessions.size },
+        concurrentAdoptions: { status: concurrent === 0 ? 'none' : 'flagged', count: concurrent },
+        strata, flags, assumptions: [...TREND_ASSUMPTIONS], regressions: { status: 'unmeasured' }, cost: { status: 'unmeasured' } });
 }
 //# sourceMappingURL=creation-capability-feedback.js.map