@slicedearth/whoisleuth-cli 2.5.1 → 2.6.0

package/packages/cases/case-record-operations.mjs

@@ -3,6 +3,8 @@
 import { normalizeCaseObjective, parseIncidentUrlContext, } from "./case-incident-context.mjs";
 import { selectExistingCase } from "./case-selection.mjs";
 import { emptyCaseWorkflowMetadata, updateCaseWorkflowMetadata } from "./case-workflow-metadata.mjs";
+import { assertCaseResponseObject, readCaseResponseObject, readCaseResponseObjects, sameCaseResponseObject } from "./case-response-object.mjs";
+import { correctionDelivery, readCasePacketCorrection, readCaseDeliveryPacketReceipt } from "./case-packet-correction.mjs";
 import { readCaseWorkflowFields } from "./case-workflow-migration.mjs";
 import { appendCaseAction, appendCaseAssertion, appendCaseClosure, appendCaseDecision, appendCaseEvidencePin, appendCaseEvidencePins, appendCaseManualTrailEvent, appendCaseObservedEffectReview, appendCaseSighting, buildCaseClosureLinkContext, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, updateCaseAction, updateCaseAssertion, } from "./case-response-model.mjs";
 import { MAX_CASES, MAX_NOTES_PER_CASE, } from "./case-record-contracts.mjs";
@@ -10,7 +12,7 @@ import { MAX_CASE_OBJECTIVE_LENGTH, MAX_RESPONSE_VALUE_LENGTH } from "../contrac
 import { caseRecordVersionInput } from "./case-record-version-input.mjs";
 import { readCaseAttachments } from "./case-attachment-model.mjs";
 import { readCaseEvidenceLinks, appendCaseEvidenceLink, withdrawCaseEvidenceLink } from "./case-evidence-links.mjs";
-import { assertCurrentRecheckQuestion, assertRecheckNonReproduction, readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
+import { assertCurrentRecheckQuestion, assertRecheckNonReproduction, assertCaseObjectObservationOutcome, readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
 import { caseDispositionSupportsDefensiveResponse, caseStatusIsClosed, caseStatusOptionsForDirectEdit, caseStatusRequiresClosure, isReviewedCaseDisposition, } from "./case-record-decisions.mjs";
 import { DEFAULT_EVIDENCE_SOURCE, EVIDENCE_SOURCE_SET, caseTimestampOrNull, deterministicId, makeId, normalizeDisposition, normalizeDomain, normalizeNoteBody, normalizeReviewReasonCode, normalizeNotes, normalizeSource, normalizeStatus, normalizeTags, objectRecord, safeId, } from "./case-record-core.mjs";
 import { assertCaseBrandProfileIds, normalizeCaseBrandProfileIds, } from "./case-brand-profile-references.mjs";
@@ -66,6 +68,11 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
     const evidencePins = normalizeCaseEvidencePins(record.evidencePins, updatedAt, timestampOptions);
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = normalizeCaseActions(record.actions, updatedAt, { ...timestampOptions, validEvidencePinIds: pinIds });
+    for (const action of actions)
+        for (const event of action.history)
+            if (event.packetReceipt
+                && (event.packetReceipt.caseId !== record.id || event.packetReceipt.target !== domain))
+                throw new TypeError('The packet receipt belongs to a different Case or target.');
     const assertions = normalizeCaseAssertions(record.assertions, updatedAt, pinIds, timestampOptions);
     const sightings = normalizeCaseSightings(record.sightings, updatedAt, pinIds, timestampOptions);
     const sightingIds = new Set(sightings.map((item) => item.id));
@@ -80,7 +87,7 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
         domain,
         title: normalizeCaseObjective(record.title),
         status: caseStatusRequiresClosure(normalizedStatus)
-            && closures.records.length === 0 && !closures.preV13HistoryUnavailable
+            && !closures.records.some(closure => closure.responseObject === undefined) && !closures.preV13HistoryUnavailable
             ? 'reviewing'
             : normalizedStatus,
         disposition: normalizeDisposition(record.disposition),
@@ -117,6 +124,13 @@ export function createCase(input, nowIso) {
         throw new Error('A valid domain is required to open a case.');
     const noteBody = normalizeNoteBody(input.note);
     const source = normalizeSource(input.source);
+    const workflowMetadata = updateCaseWorkflowMetadata(emptyCaseWorkflowMetadata(), input, domain, now);
+    const scopedCase = { domain, workflowMetadata };
+    for (const raw of [input.evidencePin, ...(Array.isArray(input.evidencePins) ? input.evidencePins : []), input.observedEffectReview, input.closure])
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(raw).responseObject), scopedCase);
+    for (const object of readCaseResponseObjects(objectRecord(input.action).responseObjects) ?? [])
+        assertCaseResponseObject(object, scopedCase);
+    assertCaseResponseObject(readCaseResponseObject(objectRecord(objectRecord(input.assertion).recheck).responseObject), scopedCase);
     const evidencePins = input.evidencePins !== undefined
         ? appendCaseEvidencePins([], input.evidencePins, now)
         : input.evidencePin !== undefined
@@ -137,13 +151,19 @@ export function createCase(input, nowIso) {
         ? appendCaseObservedEffectReview(normalizeCaseObservedEffectHistory(undefined, now), input.observedEffectReview, now, pinIds, new Set(sightings.map((item) => item.id)))
         : normalizeCaseObservedEffectHistory(undefined, now);
     for (const review of observedEffects.reviews) {
+        const pin = evidencePins.find(item => item.id === review.evidencePinId);
+        if (review.responseObject && pin && !sameCaseResponseObject(review.responseObject, pin.responseObject))
+            throw new TypeError('The selected observation evidence does not explicitly concern this exact object.');
+        if (review.responseObject && review.state === 'not_reproduced' && !review.recheck)
+            throw new TypeError('Object-specific non-reproduction requires a saved baseline question and comparable evidence.');
+        assertCaseObjectObservationOutcome(review.objectOutcome, review.recheck, review.completeness, evidencePins, pin, review.observedAt);
         if (!review.recheck)
             continue;
         assertCurrentRecheckQuestion(review.recheck, assertions);
         assertRecheckNonReproduction(review.state, review.recheck, review.completeness, evidencePins, evidencePins.find(pin => pin.id === review.evidencePinId), review.observedAt);
     }
     const closures = input.closure !== undefined
-        ? appendCaseClosure(normalizeCaseClosureHistory(undefined, now), input.closure, now, observedEffects, actions)
+        ? appendCaseClosure(normalizeCaseClosureHistory(undefined, now), input.closure, now, observedEffects, actions, evidencePins)
         : normalizeCaseClosureHistory(undefined, now);
     if (caseStatusRequiresClosure(normalizeStatus(input.status)) && input.closure === undefined) {
         throw new Error('Opening a resolved case requires a deliberate closure reason and its linked review context.');
@@ -152,12 +172,12 @@ export function createCase(input, nowIso) {
         id: makeId(),
         domain,
         title: normalizeCaseObjective(input.title),
-        status: input.closure !== undefined ? 'resolved' : normalizeStatus(input.status),
+        status: input.closure !== undefined && objectRecord(input.closure).responseObject === undefined ? 'resolved' : normalizeStatus(input.status),
         disposition: normalizeDisposition(input.disposition),
         reviewReasonCode: normalizeReviewReasonCode(input.reviewReasonCode),
         brandProfileIds: input.brandProfileIds === undefined ? [] : assertCaseBrandProfileIds(input.brandProfileIds),
         tags: normalizeTags(input.tags),
-        workflowMetadata: updateCaseWorkflowMetadata(emptyCaseWorkflowMetadata(), input, domain, now),
+        workflowMetadata,
         notes: noteBody ? [{ id: makeId(), body: noteBody, createdAt: now }] : [],
         source,
         evidenceHistory: normalizeEvidenceHistory(input.evidence ? [input.evidence] : [], {
@@ -246,6 +266,21 @@ export function updateCase(cases, id, patch, nowIso) {
     const current = cases[index];
     if (!current)
         throw new Error('That case no longer exists.');
+    if (patch.expectedResponseContext !== undefined && patch.expectedResponseContext !== JSON.stringify(current))
+        throw new TypeError('The Case response context changed after preview. Review the current delivery, scope and evidence before creating this draft.');
+    const workflowMetadata = updateCaseWorkflowMetadata(current.workflowMetadata
+        ?? readCaseWorkflowFields(current, current.domain, current.assertions).workflowMetadata, patch, current.domain, now);
+    const scopedCase = { ...current, workflowMetadata };
+    for (const raw of [patch.evidencePin, ...(Array.isArray(patch.evidencePins) ? patch.evidencePins : []), patch.observedEffectReview, patch.closure]) {
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(raw).responseObject), scopedCase);
+    }
+    for (const raw of [patch.action, patch.actionUpdate, objectRecord(patch.actionUpdate).transition]) {
+        for (const object of readCaseResponseObjects(objectRecord(raw).responseObjects) ?? [])
+            assertCaseResponseObject(object, scopedCase);
+    }
+    for (const raw of [patch.assertion, patch.assertionUpdate, patch.observedEffectReview]) {
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(objectRecord(raw).recheck).responseObject), scopedCase);
+    }
     if (patch.evidenceLink !== undefined && patch.evidenceLinkWithdrawal !== undefined)
         throw new TypeError('Record or withdraw one evidence relationship at a time.');
     if (patch.title !== undefined && patch.expectedTitle !== undefined && patch.expectedTitle !== (current.title ?? '')) {
@@ -284,6 +319,17 @@ export function updateCase(cases, id, patch, nowIso) {
         evidencePins = appendCaseEvidencePin(evidencePins, patch.evidencePin, now);
     }
     const pinIds = new Set(evidencePins.map((item) => item.id));
+    const correctionInput = patch.action !== undefined ? objectRecord(patch.action) : patch.actionUpdate !== undefined
+        ? { ...current.actions.find(action => action.id === objectRecord(patch.actionUpdate).id), ...objectRecord(patch.actionUpdate) } : null;
+    if (correctionInput?.correction !== undefined)
+        correctionDelivery(current.actions, {
+            originActionId: typeof correctionInput.originActionId === 'string' ? correctionInput.originActionId : null,
+            recipient: typeof correctionInput.recipient === 'string' ? correctionInput.recipient : '',
+            responseObjects: readCaseResponseObjects(correctionInput.responseObjects), correction: readCasePacketCorrection(correctionInput.correction),
+        }, { caseId: current.id, target: current.domain, selectedPinIds: pinIds });
+    const transitionReceipt = readCaseDeliveryPacketReceipt(objectRecord(objectRecord(patch.actionUpdate).transition).packetReceipt);
+    if (transitionReceipt && (transitionReceipt.caseId !== current.id || transitionReceipt.target !== current.domain))
+        throw new TypeError('The packet receipt belongs to a different Case or target.');
     let decisions = current.decisions;
     if (patch.decision !== undefined) {
         decisions = appendCaseDecision(current.decisions, patch.decision, now, pinIds);
@@ -295,6 +341,16 @@ export function updateCase(cases, id, patch, nowIso) {
     if (patch.actionUpdate !== undefined) {
         actions = updateCaseAction(actions, patch.actionUpdate, now, pinIds);
     }
+    if (correctionInput?.correction !== undefined || transitionReceipt) {
+        for (const original of current.actions) {
+            const retained = actions.find(action => action.id === original.id);
+            if (!retained || original.history.some(event => !retained.history.some(next => JSON.stringify(next) === JSON.stringify(event)))
+                || (patch.action !== undefined && JSON.stringify(retained) !== JSON.stringify(original)))
+                throw new TypeError('This linked operation would omit or change historical delivery records within the Case bounds. No correction or receipt was retained.');
+        }
+        if (transitionReceipt && !actions.find(action => action.id === transitionReceipt.actionId)?.history.some(event => JSON.stringify(event.packetReceipt) === JSON.stringify(transitionReceipt)))
+            throw new TypeError('The exact delivery receipt exceeds the retained history bounds. No delivery was recorded.');
+    }
     let assertions = current.assertions;
     if (patch.assertion !== undefined) {
         assertions = appendCaseAssertion(current.assertions, patch.assertion, now, pinIds);
@@ -326,22 +382,28 @@ export function updateCase(cases, id, patch, nowIso) {
             assertCurrentRecheckQuestion(context, assertions);
             assertRecheckNonReproduction(review.state, context, String(review.completeness), evidencePins, evidencePins.find(pin => pin.id === review.evidencePinId), typeof review.observedAt === 'string' ? review.observedAt : null);
         }
+        const responseObject = readCaseResponseObject(review.responseObject);
+        const pin = evidencePins.find(item => item.id === review.evidencePinId);
+        assertCaseObjectObservationOutcome(review.objectOutcome, context, String(review.completeness), evidencePins, pin, typeof review.observedAt === 'string' ? review.observedAt : null);
+        if (responseObject && pin && !sameCaseResponseObject(responseObject, pin.responseObject))
+            throw new TypeError('The selected observation evidence does not explicitly concern this exact object.');
+        if (responseObject && review.state === 'not_reproduced' && !context)
+            throw new TypeError('Object-specific non-reproduction requires a saved baseline question and comparable evidence.');
         observedEffects = appendCaseObservedEffectReview(observedEffects, patch.observedEffectReview, now, pinIds, new Set(sightings.map((item) => item.id)));
     }
     let closures = normalizeCaseClosureHistory(current.closures, current.updatedAt, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), {}, buildCaseClosureLinkContext(observedEffects, actions));
     if (patch.closure !== undefined) {
-        closures = appendCaseClosure(closures, patch.closure, now, observedEffects, actions);
+        closures = appendCaseClosure(closures, patch.closure, now, observedEffects, actions, evidencePins);
     }
     if (caseStatusRequiresClosure(patch.status) && patch.closure === undefined) {
         throw new Error('Resolve this case through the deliberate closure review so the reason and evidence state remain explicit.');
     }
     const record = {
         ...current,
-        workflowMetadata: updateCaseWorkflowMetadata(current.workflowMetadata
-            ?? readCaseWorkflowFields(current, current.domain, current.assertions).workflowMetadata, patch, current.domain, now),
+        workflowMetadata,
         title: patch.title === undefined ? current.title ?? '' : normalizeCaseObjective(patch.title),
         status: patch.closure !== undefined
-            ? 'resolved'
+            ? objectRecord(patch.closure).responseObject !== undefined ? current.status : 'resolved'
             : patch.status !== undefined ? normalizeStatus(patch.status) : current.status,
         disposition: patch.disposition !== undefined ? normalizeDisposition(patch.disposition) : current.disposition,
         reviewReasonCode: patch.reviewReasonCode !== undefined
@@ -504,6 +566,7 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             observedAt: input.observedAt,
             collectionDepth: input.collectionDepth,
             observationHostname: input.observationHostname,
+            ...(input.responseObject ? { responseObject: input.responseObject } : {}),
             completeness: input.completeness,
             truncated: input.comparisonTruncated === true
                 || (typeof input.comparisonSummary === 'string' && input.comparisonSummary.length > MAX_RESPONSE_VALUE_LENGTH),
@@ -524,6 +587,8 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             followUpAt: input.followUpAt,
             limitations: input.limitations,
             ...(input.recheck ? { recheck: input.recheck } : {}),
+            ...(input.responseObject ? { responseObject: input.responseObject } : {}),
+            ...(input.objectOutcome ? { objectOutcome: input.objectOutcome } : {}),
         },
     }, now);
 }

package/packages/cases/case-record-projection.mjs

@@ -102,15 +102,26 @@ const CASE_FIELD_RULES = Object.freeze({
     }),
     source: preservedField('source'),
     evidenceHistory: fieldRule('evidenceHistory', PRESERVE, (record) => structuredClone(record.evidenceHistory)),
-    evidencePins: fieldRule('evidencePins', PRESERVE, (record) => structuredClone(record.evidencePins)),
+    evidencePins: fieldRule('evidencePins', PUBLIC_REDACT, (record, profile) => structuredClone(record.evidencePins).map(pin => {
+        if (profile !== 'public')
+            return pin;
+        const { responseObject: _scope, infrastructureObservation: _infrastructure, ...publicPin } = pin;
+        return publicPin;
+    }), { nestedSensitiveFields: ['responseObject', 'infrastructureObservation'], audienceExclusions: { public: { label: 'Exact-object evidence scope and infrastructure observations', order: 4, sinceVersion: 18 } } }),
     evidenceLinks: fieldRule('evidenceLinks', PUBLIC_EXCLUDE, (record, profile) => (profile === 'public' ? undefined : structuredClone(record.evidenceLinks)), { audienceExclusions: { public: { label: 'Analyst evidence relationships', order: 4, sinceVersion: EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION } } }),
     decisions: fieldRule('decisions', PRESERVE, (record) => structuredClone(record.decisions)),
     actions: fieldRule('actions', TRUSTED_REDACT_PUBLIC_EXCLUDE, (record, profile) => (profile === 'public'
         ? []
         : profile === 'trusted'
-            ? structuredClone(record.actions).map((item) => ({ ...item, recipient: '[redacted]' }))
+            ? structuredClone(record.actions).map((item) => {
+                const { correction: _privateCorrection, ...shared } = item;
+                return { ...shared, recipient: '[redacted]', history: shared.history.map(event => {
+                        const { packetReceipt: _privateReceipt, ...sharedEvent } = event;
+                        return sharedEvent;
+                    }) };
+            })
             : structuredClone(record.actions)), {
-        nestedSensitiveFields: ['recipient'],
+        nestedSensitiveFields: ['recipient', 'responseObjects', 'correction', 'packetReceipt'],
         audienceExclusions: {
             trusted: { label: 'Recipient values', order: 2 },
             public: { label: 'Actions and recipient values', order: 3 },
@@ -191,6 +202,7 @@ const OUTSIDE_SCHEMA_EXCLUSIONS = Object.freeze({
 });
 function currentAudienceExclusions(audience, caseVersion) {
     const entries = [
+        ...(audience === 'trusted' && caseVersion >= 19 ? [{ label: 'Private correction content and exact delivery receipts', order: 2 }] : []),
         ...Object.values(CASE_FIELD_RULES).flatMap((rule) => (rule.audienceExclusions[audience] ? [rule.audienceExclusions[audience]] : [])),
         OUTSIDE_SCHEMA_EXCLUSIONS[audience],
     ];

package/packages/cases/case-record-version-input.mjs

@@ -1,7 +1,29 @@
-import { EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, PUBLISHED_V2_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
+import { EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, PUBLISHED_V2_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION, OBJECT_RESPONSE_CASE_SCHEMA_VERSION, DELIVERY_CORRECTION_CASE_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
 /** Adapt declared historical fields before ordinary current-record recovery. */
 export function caseRecordVersionInput(record, sourceVersion) {
     const declared = sourceVersion != null;
+    if (declared && sourceVersion < DELIVERY_CORRECTION_CASE_SCHEMA_VERSION && Array.isArray(record.actions)
+        && record.actions.some(action => action && typeof action === 'object' && (action.correction !== undefined
+            || Array.isArray(action.history) && action.history.some((event) => event?.packetReceipt !== undefined)))) {
+        throw new TypeError('Delivery receipts and corrections require Case schema 19; historical deliveries were not reinterpreted.');
+    }
+    if (declared && sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION) {
+        const items = (value) => Array.isArray(value) ? value.filter((item) => !!item && typeof item === 'object' && !Array.isArray(item)) : [];
+        const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        const pins = items(record.evidencePins);
+        const actions = items(record.actions);
+        const reviews = items(object(record.observedEffects).reviews);
+        const closures = items(object(record.closures).records);
+        const questions = [...items(record.assertions), ...reviews].map(item => object(item.recheck));
+        const events = actions.flatMap(action => items(action.history));
+        if (pins.some(pin => pin.responseObject !== undefined || pin.infrastructureObservation !== undefined)
+            || actions.some(action => action.responseObjects !== undefined)
+            || events.some(event => event.responseObjects !== undefined || event.objectOutcome !== undefined)
+            || [...reviews, ...closures, ...questions].some(item => item.responseObject !== undefined || item.objectOutcome !== undefined)
+            || [...items(record.evidenceHistory), object(record.evidence)].some(snapshot => snapshot.hasExternalPasswordForm !== undefined)) {
+            throw new TypeError('Object response and password-form attribution fields require Case schema 18; historical evidence was not reinterpreted.');
+        }
+    }
     if (record.evidenceLinks !== undefined && declared && sourceVersion < EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION) {
         throw new TypeError('Evidence relationships require the current Case schema.');
     }

package/packages/cases/case-report.mjs

@@ -14,9 +14,13 @@ import { webCollectionScoreLimitation } from "../evidence/collection-quality.mjs
 import { analystInteroperabilityTags } from "../analysis/analyst-taxonomy.mjs";
 import { caseEvidenceLinkIssues } from "./case-evidence-links.mjs";
 import { caseTypeSummary } from "./case-workflow-metadata.mjs";
+import { caseClosureHistoryQualification } from "./case-response-outcomes.mjs";
 import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "../analysis/portable-generator.mjs";
 import { buildCaseResponseLifecycleSummary, CASE_EVIDENCE_RELATION_STANCES } from "./case-response-model.mjs";
 import { normalizeCaseBrandProfileIds } from "./case-brand-profile-references.mjs";
+import { EVIDENCE_FOLLOW_UP_CASE_REPORT_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { OBJECT_RESPONSE_CASE_REPORT_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { CASE_DELIVERY_RECEIPT_LIMITATION } from "./case-packet-correction.mjs";
 import { CASE_RECHECK_CONDITIONS } from "./case-recheck-model.mjs";
 import { escapeCaseMarkdownInline as escapeMarkdownInline } from "./case-markdown.mjs";
 import { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION, LATEST_PUBLIC_CASE_REPORT_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
@@ -145,6 +149,7 @@ function pickKnownSnapshotFields(snapshot) {
         reusesOfficialAssets: snapshot.reusesOfficialAssets,
         hasPasswordField: snapshot.hasPasswordField,
         hasExternalFormAction: snapshot.hasExternalFormAction,
+        ...(snapshot.hasExternalPasswordForm === undefined ? {} : { hasExternalPasswordForm: snapshot.hasExternalPasswordForm }),
         phishingLanguageMatch: snapshot.phishingLanguageMatch,
         privacyProtected: snapshot.privacyProtected ?? null,
         idnReferenceMatch: snapshot.idnReferenceMatch ?? null,
@@ -279,6 +284,10 @@ export function buildCaseReportVerificationProjection(caseRecord, options, schem
     const generated = buildCaseReport(caseRecord, options).json;
     if (schemaVersion === CASE_REPORT_SCHEMA_VERSION)
         return generated;
+    if (schemaVersion === OBJECT_RESPONSE_CASE_REPORT_SCHEMA_VERSION)
+        return { ...generated, schemaVersion };
+    if (schemaVersion === EVIDENCE_FOLLOW_UP_CASE_REPORT_SCHEMA_VERSION)
+        return { ...generated, schemaVersion };
     if (caseRecord.evidenceHistory.some(snapshot => snapshot.webCollectionQuality !== undefined)) {
         throw new TypeError('Published report formats cannot declare newer collection-quality fields.');
     }
@@ -499,6 +508,8 @@ function buildMarkdown(report, includeAttribution) {
         for (const pin of response.evidencePins) {
             lines.push(`- **${escapeMarkdownInline(pin.label)}:** ${escapeMarkdownInline(pin.value)}`);
             lines.push(`  Source: ${escapeMarkdownInline(pin.source)}; observed ${escapeMarkdownInline(pin.observedAt ?? 'Time unavailable')}; completeness ${escapeMarkdownInline(pin.completeness)}.`);
+            if (pin.responseObject)
+                lines.push(`  Exact object: ${escapeMarkdownInline(pin.responseObject.kind)} · ${escapeMarkdownInline(pin.responseObject.identifier)}`);
             if (pin.limitations.length)
                 lines.push(`  Limitations: ${escapeMarkdownInline(pin.limitations.join('; '))}`);
         }
@@ -587,6 +598,7 @@ function buildMarkdown(report, includeAttribution) {
         for (const action of response.actions) {
             lines.push(`- **${escapeMarkdownInline(action.type.replaceAll('_', ' '))}:** ${escapeMarkdownInline(action.recipient)} (${escapeMarkdownInline(action.state)})`);
             lines.push(`  Contact source: ${escapeMarkdownInline(action.contactSource)}; updated ${escapeMarkdownInline(action.updatedAt)}.`);
+            lines.push(`  Object binding: ${action.responseObjects?.length ? action.responseObjects.map(object => `${escapeMarkdownInline(object.kind)} · ${escapeMarkdownInline(object.identifier)}`).join('; ') : 'Unknown; historical or unbound actions do not establish exact-object coverage.'}`);
             if (action.routeObservedAt)
                 lines.push(`  Route reviewed: ${escapeMarkdownInline(action.routeObservedAt)}`);
             if (action.routeReviewAfter)
@@ -595,6 +607,8 @@ function buildMarkdown(report, includeAttribution) {
                 lines.push(`  Originating action: ${escapeMarkdownInline(action.originActionId)}`);
             if (action.amendment)
                 lines.push(`  Amendment of submitted packet SHA-256: ${action.amendment.packetDigestSha256}; request events: ${action.amendment.requestEventIds.map(escapeMarkdownInline).join(', ')}`);
+            if (action.correction)
+                lines.push(`  ${action.correction.purpose === 'correction' ? 'Correction request' : 'Retraction request'} for delivery event ${escapeMarkdownInline(action.correction.deliveryEventId)}; packet v${action.correction.packetVersion} SHA-256: ${action.correction.packetDigestSha256}`, `  Reason: ${escapeMarkdownInline(action.correction.reason)}`, `  Previous statement: ${escapeMarkdownInline(action.correction.previousStatement)}`, `  Corrected statement: ${escapeMarkdownInline(action.correction.correctedStatement || 'Request to retract the previous statement')}`, `  Corrected evidence pins: ${action.correction.evidencePinIds.map(escapeMarkdownInline).join(', ')}`, '  Preparation is not delivery, recipient acceptance, restoration or independent recheck.');
             for (const event of action.history)
                 if (event.evidenceRequest) {
                     const request = event.evidenceRequest;
@@ -616,8 +630,14 @@ function buildMarkdown(report, includeAttribution) {
                 lines.push(`  - ${escapeMarkdownInline(event.occurredAt)} · ${escapeMarkdownInline(event.previousState ?? 'none')} → ${escapeMarkdownInline(event.nextState)} · ${escapeMarkdownInline(event.sourceClass)} · ${event.applied ? 'applied' : 'retained conflict'}`);
                 if (event.providerOutcome)
                     lines.push(`    Provider outcome at this time: ${escapeMarkdownInline(event.providerOutcome.replaceAll('_', ' '))}`);
+                if (event.responseObjects?.length)
+                    lines.push(`    Objects at this event: ${event.responseObjects.map(object => `${escapeMarkdownInline(object.kind)} · ${escapeMarkdownInline(object.identifier)}`).join('; ')}`);
+                if (event.objectOutcome)
+                    lines.push(`    Source-reported object outcome: ${escapeMarkdownInline(event.objectOutcome)}; not independent verification or causation.`);
                 if (event.reference)
                     lines.push(`    Event reference: ${escapeMarkdownInline(event.reference)}`);
+                if (event.packetReceipt)
+                    lines.push(`    Retained packet v${event.packetReceipt.packetVersion}: ${event.packetReceipt.packetDigestSha256}; recipient ${escapeMarkdownInline(event.packetReceipt.recipient)}; audience ${escapeMarkdownInline(event.packetReceipt.profile)}; generated ${event.packetReceipt.packetGeneratedAt}`, `    ${CASE_DELIVERY_RECEIPT_LIMITATION}`);
                 if (event.evidencePinId)
                     lines.push(`    Evidence pin: ${escapeMarkdownInline(event.evidencePinId)}`);
                 if (event.limitations.length)
@@ -667,6 +687,10 @@ function buildMarkdown(report, includeAttribution) {
         lines.push('- No independent observed-effect review recorded.');
     for (const review of response.observedEffects.reviews) {
         lines.push(`- **${escapeMarkdownInline(review.state.replaceAll('_', ' '))}** (${escapeMarkdownInline(review.observedAt)}): ${escapeMarkdownInline(review.source)}; class ${escapeMarkdownInline(review.sourceClass)}; completeness ${escapeMarkdownInline(review.completeness)}.`);
+        if (review.responseObject)
+            lines.push(`  Exact object: ${escapeMarkdownInline(review.responseObject.kind)} · ${escapeMarkdownInline(review.responseObject.identifier)}`);
+        if (review.objectOutcome)
+            lines.push(`  Independently recorded object outcome: ${escapeMarkdownInline(review.objectOutcome)}; point-in-time observation, not report causation or recurrence.`);
         if (review.recheck) {
             lines.push(`  Question ${escapeMarkdownInline(review.recheck.questionId)}: ${escapeMarkdownInline(review.recheck.question)}`);
             lines.push(`  Recheck target: ${escapeMarkdownInline(review.recheck.targetHostname)}; retained comparison conditions: ${escapeMarkdownInline(review.recheck.conditions)}`);
@@ -689,13 +713,19 @@ function buildMarkdown(report, includeAttribution) {
         lines.push('- No deliberate analyst closure recorded.');
     for (const closure of response.closures.records) {
         lines.push(`- **Closure · ${escapeMarkdownInline(closure.reason.replaceAll('_', ' '))}** (${escapeMarkdownInline(closure.createdAt)}): ${escapeMarkdownInline(closure.summary)}`);
+        lines.push(`  Scope: ${closure.responseObject ? `${escapeMarkdownInline(closure.responseObject.kind)} · ${escapeMarkdownInline(closure.responseObject.identifier)}; other objects and the Case remain independent.` : 'Whole Case analyst decision.'}`);
         if (closure.observedEffectReviewId)
             lines.push(`  Independent review: ${escapeMarkdownInline(closure.observedEffectReviewId)}`);
         if (closure.actionId)
             lines.push(`  Provider action: ${escapeMarkdownInline(closure.actionId)}`);
+        const qualification = caseClosureHistoryQualification(closure, response.actions);
+        if (qualification)
+            lines.push(`  History qualification: ${escapeMarkdownInline(qualification)}`);
         if (closure.limitations.length)
             lines.push(`  Limitations: ${escapeMarkdownInline(closure.limitations.join('; '))}`);
     }
+    if (response.closures.omitted)
+        lines.push(`- Closure records not retained: ${response.closures.omitted}. ${escapeMarkdownInline(response.closures.limitations.join('; '))}`);
     lines.push('');
     // Analyst notes (only when included)
     if (report.case.notesIncluded && Array.isArray(report.case.notes) && report.case.notes.length > 0) {

package/packages/cases/case-requested-evidence.mjs

@@ -57,7 +57,7 @@ export function assertEvidenceRequestEvent(request, event) {
 export function submittedPacketReceipts(action) {
     return action.history.flatMap(event => {
         const match = /^response-packet-sha256:([a-f0-9]{64})$/u.exec(event.reference ?? '');
-        return event.applied && event.previousState === 'authorised' && event.nextState === 'submitted'
+        return event.applied && ['authorised', 'submitted'].includes(event.previousState ?? '') && event.nextState === 'submitted'
             && event.sourceClass === 'analyst' && match
             ? [{ eventId: event.id, digestSha256: match[1], occurredAt: event.occurredAt }] : [];
     });

package/packages/cases/case-response-actions.mjs

@@ -1,8 +1,10 @@
 // Append-only response actions: transitions, reconciliation and bounded history.
 import { readCaseEvidenceRequest, readCasePacketAmendment, assertEvidenceRequestEvent, assertEvidenceRequestHistory, assertEvidenceRequestTransition, assertPacketAmendment } from "./case-requested-evidence.mjs";
+import { readCaseDeliveryPacketReceipt, readCasePacketCorrection, assertDeliveryPacketReceipt, correctionDelivery } from "./case-packet-correction.mjs";
 import { MAX_INTAKE_LINKS, MAX_MESSAGE_PARTS } from "../contracts/message-intake.mjs";
 import { emailRecipient } from "../evidence/email-recipient.mjs";
 import { responseRouteFreshness } from "./response-route-freshness.mjs";
+import { readCaseResponseObjects, readCaseResponseObjectOutcome, assertCaseObjectOutcome, sameCaseResponseObject } from "./case-response-object.mjs";
 import { CASE_SCHEMA_VERSION, MAX_CASE_ACTIONS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, } from "../contracts/case-portability.mjs";
 import { normalizeExplicitIsoTimestamp, } from "../evidence/observation.mjs";
 import { CASE_ACTION_EVENT_SOURCE_CLASSES, CASE_ACTION_STATES, CASE_ACTION_TYPES, CASE_PROVIDER_OUTCOMES, } from "./case-response-records.mjs";
@@ -160,6 +162,12 @@ function normalizeActionEvent(raw, actionId, options = {}) {
     if (item.evidenceRequest !== undefined && options.sourceVersion != null && options.sourceVersion < 17)
         throw new Error('Requested evidence requires Case schema 17.');
     const evidenceRequest = readCaseEvidenceRequest(item.evidenceRequest);
+    if (item.packetReceipt !== undefined && options.sourceVersion != null && options.sourceVersion < 19)
+        throw new TypeError('Delivery receipts require Case schema 19.');
+    const packetReceipt = readCaseDeliveryPacketReceipt(item.packetReceipt);
+    assertDeliveryPacketReceipt(packetReceipt, { previousState, nextState, sourceClass, occurredAt,
+        reference: typeof item.reference === 'string' ? item.reference : null,
+        responseObjects: readCaseResponseObjects(item.responseObjects, options.sourceVersion) }, actionId);
     assertEvidenceRequestEvent(evidenceRequest, { previousState, nextState, sourceClass, providerOutcome: item.providerOutcome });
     const providerOutcome = typeof item.providerOutcome === 'string' && PROVIDER_OUTCOMES.has(item.providerOutcome)
         ? item.providerOutcome
@@ -189,7 +197,10 @@ function normalizeActionEvent(raw, actionId, options = {}) {
         : null;
     const eventMaterial = {
         previousState,
+        ...(item.responseObjects === undefined ? {} : { responseObjects: readCaseResponseObjects(item.responseObjects, options.sourceVersion) }),
+        ...(item.objectOutcome === undefined ? {} : { objectOutcome: readCaseResponseObjectOutcome(item.objectOutcome, options.sourceVersion) }),
         ...(evidenceRequest ? { evidenceRequest } : {}),
+        ...(packetReceipt ? { packetReceipt } : {}),
         nextState,
         occurredAt,
         sourceClass,
@@ -206,6 +217,16 @@ function normalizeActionEvent(raw, actionId, options = {}) {
             ? item.originActionId
             : null,
     };
+    if (eventMaterial.objectOutcome) {
+        if (!['submitted', 'acknowledged', 'terminal'].includes(nextState) || previousState === 'authorised')
+            throw new TypeError('Object outcomes require a separate attributed event after submission.');
+        if (sourceClass !== 'provider' && sourceClass !== 'analyst')
+            throw new TypeError('Object outcomes require an attributed provider or analyst event.');
+        if (!eventMaterial.responseObjects?.length)
+            throw new TypeError('Select the objects concerned by this provider outcome; no complete-action resolution is inferred.');
+        for (const object of eventMaterial.responseObjects)
+            assertCaseObjectOutcome(eventMaterial.objectOutcome, object);
+    }
     return {
         id: safeId(item.id, 'action-event', { actionId, ...eventMaterial }),
         ...eventMaterial,
@@ -373,6 +394,11 @@ function normalizeAction(raw, fallback, options = {}) {
     if (item.amendment !== undefined && options.sourceVersion != null && options.sourceVersion < 17)
         throw new Error('Packet amendments require Case schema 17.');
     const amendment = readCasePacketAmendment(item.amendment);
+    if (item.correction !== undefined && options.sourceVersion != null && options.sourceVersion < 19)
+        throw new TypeError('Packet corrections require Case schema 19.');
+    const correction = readCasePacketCorrection(item.correction);
+    if (correction && amendment)
+        throw new TypeError('Self-initiated correction and provider-request amendment are separate purposes.');
     const applied = history.history.filter((event) => event.applied);
     const latestReference = [...applied].reverse().find((event) => event.reference)?.reference ?? null;
     const latestProviderOutcome = [...applied].reverse().find((event) => event.providerOutcome) ?? null;
@@ -387,7 +413,9 @@ function normalizeAction(raw, fallback, options = {}) {
         : null;
     return {
         id: actionId,
+        ...(item.responseObjects === undefined ? {} : { responseObjects: readCaseResponseObjects(item.responseObjects, options.sourceVersion) }),
         ...(amendment ? { amendment } : {}),
+        ...(correction ? { correction } : {}),
         type: legacyPlatformReview
             ? 'platform_report'
             : typeof item.type === 'string' && ACTION_TYPES.has(item.type)
@@ -575,9 +603,14 @@ export function appendCaseAction(current, raw, now) {
     const amendment = readCasePacketAmendment(item.amendment);
     if (amendment)
         assertPacketAmendment(current, originActionId, amendment);
+    const correction = readCasePacketCorrection(item.correction);
+    if (correction)
+        correctionDelivery(current, { originActionId, correction,
+            recipient: text(item.recipient, MAX_RESPONSE_RECIPIENT_LENGTH), responseObjects: readCaseResponseObjects(item.responseObjects) });
     const history = [{
             id: freshId('action-event'),
             previousState: null,
+            ...(item.responseObjects === undefined ? {} : { responseObjects: readCaseResponseObjects(item.responseObjects) }),
             nextState: 'drafting',
             occurredAt: now,
             sourceClass: 'analyst',
@@ -602,11 +635,22 @@ export function appendCaseAction(current, raw, now) {
         throw new Error('An action requires a recipient or internal owner.');
     return normalizeCaseActions([...current, created], now, { sourceVersion: CASE_SCHEMA_VERSION });
 }
+export function providerOutcomeRequiresObjectScope(outcome) {
+    return outcome === 'provider_reports_resolved' || outcome === 'partially_remediated';
+}
 export function appendCaseActionTransition(current, actionId, raw, now, validPinIds) {
     const action = current.find((item) => item.id === actionId);
     if (!action)
         throw new Error('That case action no longer exists.');
     const item = record(raw);
+    const selectedObjects = readCaseResponseObjects(item.responseObjects);
+    const outcome = readCaseResponseObjectOutcome(item.objectOutcome);
+    if (selectedObjects?.some(object => !action.responseObjects?.some(bound => sameCaseResponseObject(bound, object))))
+        throw new TypeError('A transition may concern only objects explicitly bound to its action.');
+    if (outcome && !selectedObjects?.length)
+        throw new TypeError('Explicitly select the affected objects for this outcome; it is not applied to every action object.');
+    if (action.responseObjects?.length && providerOutcomeRequiresObjectScope(item.providerOutcome) && !selectedObjects?.length)
+        throw new TypeError('Explicitly select the objects covered by this provider-reported outcome; other action objects remain unchecked.');
     const nextState = typeof item.nextState === 'string' && ACTION_STATES.has(item.nextState)
         ? item.nextState
         : null;
@@ -637,9 +681,18 @@ export function appendCaseActionTransition(current, actionId, raw, now, validPin
     if (action.amendment && ['ready_for_review', 'reviewed', 'authorised', 'submitted'].includes(nextState)) {
         assertPacketAmendment(current, action.originActionId, action.amendment);
     }
+    if (action.correction && ['ready_for_review', 'reviewed', 'authorised', 'submitted'].includes(nextState))
+        correctionDelivery(current, action);
+    const packetReceipt = readCaseDeliveryPacketReceipt(item.packetReceipt);
+    if (packetReceipt && (packetReceipt.recipient !== action.recipient
+        || JSON.stringify(packetReceipt.responseObjects) !== JSON.stringify(action.responseObjects ?? [])))
+        throw new TypeError('The delivered packet receipt no longer matches this action recipient or scope.');
+    if (action.correction && nextState === 'submitted' && !packetReceipt)
+        throw new TypeError('Record the separately prepared correction packet receipt only after actual delivery.');
     const occurredAt = optionalIso(item.occurredAt) ?? now;
     const event = normalizeActionEvent({
         ...item,
+        ...(selectedObjects !== undefined ? { responseObjects: selectedObjects } : action.responseObjects === undefined ? {} : { responseObjects: action.responseObjects }),
         id: freshId('action-event'),
         previousState: action.state,
         nextState,
@@ -658,7 +711,7 @@ export function appendCaseActionTransition(current, actionId, raw, now, validPin
     return normalizeCaseActions(current.map((candidate) => candidate.id === actionId ? updated : candidate), now, currentActionNormalizationOptions(validPinIds));
 }
 const ACTION_REVIEW_MATERIAL_FIELDS = [
-    'type', 'recipient', 'contactSource', 'routeObservedAt', 'routeReviewAfter', 'contactLimitations', 'originActionId', 'amendment',
+    'type', 'recipient', 'contactSource', 'routeObservedAt', 'routeReviewAfter', 'contactLimitations', 'originActionId', 'amendment', 'correction', 'responseObjects',
 ];
 export function updateCaseAction(current, raw, now, validPinIds) {
     const patch = record(raw);
@@ -689,6 +742,8 @@ export function updateCaseAction(current, raw, now, validPinIds) {
         .some((key) => Object.hasOwn(patch, key) && JSON.stringify(record(existing)[key]) !== JSON.stringify(record(updated)[key]));
     if (materialChanged && updated.amendment)
         assertPacketAmendment(current, updated.originActionId, updated.amendment);
+    if (materialChanged && updated.correction)
+        correctionDelivery(current, updated);
     if (materialChanged && ['submitted', 'acknowledged', 'terminal'].includes(existing.state)) {
         throw new Error('Submitted or terminal action identity and recipient metadata cannot be rewritten; create a linked follow-on action instead.');
     }
@@ -702,6 +757,7 @@ export function updateCaseAction(current, raw, now, validPinIds) {
                     occurredAt: now,
                     sourceClass: 'browser_local',
                     provenance: 'material_action_change',
+                    ...(updated.responseObjects === undefined ? {} : { responseObjects: updated.responseObjects }),
                     reference: null,
                     evidencePinId: null,
                     limitations: ['Material action inputs changed after review; prior readiness, review, or authorisation no longer applies.'],

package/packages/cases/case-response-model.mjs

@@ -7,9 +7,12 @@ import { CASE_ASSERTION_EXTERNAL_ENTITY_TYPES, CASE_ASSERTION_EXTERNAL_FORMATS,
 import { COMPLETENESS, SAFE_ID_RE, compareCodeUnits, freshId, iso, limitations, optionalIso, record, safeId, text, uniqueIds, } from "./case-response-values.mjs";
 import { isValidAsciiHostname } from "../contracts/domain-name.mjs";
 import { readCaseRecheckContext } from "./case-recheck-model.mjs";
+import { readCaseResponseObject } from "./case-response-object.mjs";
+import { normalizeInfrastructureObservation } from "../investigation/infrastructure-observation.mjs";
 export * from "./case-response-records.mjs";
 export * from "./case-response-actions.mjs";
 export * from "./case-response-outcomes.mjs";
+export * from "./case-response-object.mjs";
 export { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, } from "../contracts/case-portability.mjs";
 const TRANSITION_EXPECTATIONS = new Set(CASE_TRANSITION_EXPECTATIONS);
 const DECISION_CONFIDENCE_LEVELS = new Set(CASE_DECISION_CONFIDENCE_LEVELS);
@@ -108,6 +111,8 @@ function normalizeEvidenceRelations(value, legacyIds, validIds) {
 }
 function normalizePin(raw, fallback, options = {}) {
     const item = record(raw);
+    if (item.infrastructureObservation !== undefined && options.sourceVersion != null && options.sourceVersion < 18)
+        throw new TypeError('Infrastructure observations require Case schema 18 or later.');
     const label = text(item.label, MAX_RESPONSE_LABEL_LENGTH);
     const value = text(item.value, MAX_RESPONSE_VALUE_LENGTH);
     if (!label || !value)
@@ -141,6 +146,8 @@ function normalizePin(raw, fallback, options = {}) {
             : null,
         limitations: limitations(item.limitations),
         createdAt,
+        ...(item.responseObject === undefined ? {} : { responseObject: readCaseResponseObject(item.responseObject, options.sourceVersion) }),
+        ...(item.infrastructureObservation === undefined ? {} : { infrastructureObservation: normalizeInfrastructureObservation(item.infrastructureObservation) }),
     };
     normalized.certificateObservation = options.allowCertificateObservation === false
         ? null