@slicedearth/whoisleuth-cli 2.4.0 → 2.6.0

package/packages/cases/case-response-packet-render.mjs

@@ -1,10 +1,9 @@
 import { RESPONSE_AUTHORISATION_CONFIRMATION_IDS, responseContactLabel as contactLabel } from "./case-response-packet-vocabulary.mjs";
-function escapeMarkdown(value) {
-    return value.replace(/([\\`*_[\]<>|])/gu, '\\$1').replace(/\r?\n/gu, ' ');
-}
+import { escapeCaseMarkdownInline as escapeMarkdown } from "./case-markdown.mjs";
 /** Render only the projected packet, never the source Case or private inputs. */
 export function renderCaseResponsePacket(packet) {
     const { profile, case: caseRecord, incident: { category, affectedParty, abusiveUrls, observedHarm, observedAt }, generatedAt: normalizedGeneratedAt, recipientRoute, escalationHistory, escalationHistoryOmitted, escalationHistoryLimitations, authorisation, readiness, selectedEvidence, artefactReferences, responseLifecycle, preflight, provenance: { limitations, evidencePinCount, decisionCount, assertionCount, observationAge: age }, integrity: { digestSha256 }, } = packet;
+    const selectedCorrection = escalationHistory.find(action => action.actionId === packet.actionBinding.selectedActionId)?.correction;
     const lines = [
         `# ${escapeMarkdown(profile.label)} packet`,
         '',
@@ -16,7 +15,7 @@ export function renderCaseResponsePacket(packet) {
         `**Audience:** ${escapeMarkdown(profile.audience)}`,
         `**Suggested subject:** ${escapeMarkdown(profile.subject)}`,
         '',
-        '## Observed harm',
+        selectedCorrection ? '## Retained incident context (not a renewed allegation)' : '## Observed harm',
         '',
         escapeMarkdown(observedHarm),
         '',
@@ -49,10 +48,21 @@ export function renderCaseResponsePacket(packet) {
                 ...(action.providerOutcome ? [`  - Typed provider outcome: ${escapeMarkdown(action.providerOutcome.replaceAll('_', ' '))}`] : []),
                 ...(action.outcomeDetail ? [`  - Outcome detail: ${escapeMarkdown(action.outcomeDetail)}`] : []),
                 ...(action.originActionId ? [`  - Originating action: ${escapeMarkdown(action.originActionId)}`] : []),
+                ...(action.amendment ? [`  - Amendment of submitted packet SHA-256: ${action.amendment.packetDigestSha256}`, `  - Prepared request events: ${action.amendment.requestEventIds.map(escapeMarkdown).join(', ')}`] : []),
+                ...(action.correction ? [`  - ${action.correction.purpose === 'correction' ? 'Correction request' : 'Retraction request'} for delivery event ${escapeMarkdown(action.correction.deliveryEventId)}; original packet v${action.correction.packetVersion} SHA-256: ${action.correction.packetDigestSha256}`,
+                    `  - Analyst reason: ${escapeMarkdown(action.correction.reason)}`, `  - Previous statement: ${escapeMarkdown(action.correction.previousStatement)}`,
+                    `  - Corrected statement: ${escapeMarkdown(action.correction.correctedStatement || 'Request to retract the previous statement')}`,
+                    `  - Corrected evidence pins: ${action.correction.evidencePinIds.map(escapeMarkdown).join(', ')}`] : []),
                 ...action.transitions.flatMap((event) => [
                     `  - ${event.occurredAt}: ${escapeMarkdown(event.previousState ?? 'none')} → ${escapeMarkdown(event.nextState)} · ${escapeMarkdown(event.sourceClass)} · ${escapeMarkdown(event.provenance)}${event.providerOutcome ? ` · ${escapeMarkdown(event.providerOutcome.replaceAll('_', ' '))}` : ''}${event.applied ? '' : ' · retained conflict'}`,
                     ...(event.reference ? [`    - Reference: ${escapeMarkdown(event.reference)}`] : []),
+                    ...(event.packetReceipt ? [`    - Exact local packet receipt: v${event.packetReceipt.packetVersion} · ${event.packetReceipt.packetDigestSha256} · ${escapeMarkdown(event.packetReceipt.recipient)} · ${escapeMarkdown(event.packetReceipt.profile)} · generated ${event.packetReceipt.packetGeneratedAt}`] : []),
                     ...(event.evidencePinId ? [`    - Evidence pin: ${escapeMarkdown(event.evidencePinId)}`] : []),
+                    ...(event.evidenceRequest ? [
+                        `    - Requested evidence (${event.evidenceRequest.state}): ${escapeMarkdown(event.evidenceRequest.summary)}`,
+                        `    - Original packet SHA-256: ${event.evidenceRequest.packetDigestSha256}; deadline: ${event.evidenceRequest.dueAt ?? 'not provided'}`,
+                        `    - Prepared pins: ${event.evidenceRequest.evidencePinIds.map(escapeMarkdown).join(', ') || 'none'}${event.evidenceRequest.rationale ? `; ${escapeMarkdown(event.evidenceRequest.rationale)}` : ''}`,
+                    ] : []),
                     ...(event.originActionId ? [`    - Originating action: ${escapeMarkdown(event.originActionId)}`] : []),
                     ...event.limitations.map((limitation) => `    - Limitation: ${escapeMarkdown(limitation)}`),
                 ]),
@@ -82,6 +92,10 @@ export function renderCaseResponsePacket(packet) {
         '',
         '## Provider outcome and independent effect',
         '',
+        ...escalationHistory.flatMap(action => [
+            `- Action ${escapeMarkdown(action.actionId)} object scope: ${action.responseObjects?.length ? action.responseObjects.map(object => `${escapeMarkdown(object.kind)} · ${escapeMarkdown(object.identifier)}`).join('; ') : 'unknown; no exact-object coverage inferred'}`,
+            ...action.transitions.filter(event => event.objectOutcome).map(event => `  - ${escapeMarkdown(event.objectOutcome)} · ${escapeMarkdown(event.sourceClass)} · ${event.occurredAt} · affected objects: ${event.responseObjects?.map(object => `${escapeMarkdown(object.kind)} · ${escapeMarkdown(object.identifier)}`).join('; ')}${event.applied ? '' : ' · retained conflict'}`),
+        ]),
         responseLifecycle.latestProviderOutcome
             ? `- Provider outcome time: ${responseLifecycle.latestProviderOutcome.occurredAt} (${escapeMarkdown(responseLifecycle.latestProviderOutcome.outcome.replaceAll('_', ' '))})`
             : `- Provider outcome time: Withheld because the typed event state is ${responseLifecycle.providerOutcomeState}.`,
@@ -89,6 +103,7 @@ export function renderCaseResponsePacket(packet) {
             ? `- Independently observed change time: ${responseLifecycle.latestObservedChangeAt}`
             : `- Independently observed change time: Withheld because the independent change state is ${responseLifecycle.observedChangeState}.`,
         ...(responseLifecycle.latestObservedEffect ? [`- Latest independent review: ${escapeMarkdown(responseLifecycle.latestObservedEffect.state.replaceAll('_', ' '))} · ${responseLifecycle.latestObservedEffect.observedAt} · ${escapeMarkdown(responseLifecycle.latestObservedEffect.source)}`] : []),
+        ...(responseLifecycle.latestObservedEffect?.responseObject ? [`- Reviewed object: ${escapeMarkdown(responseLifecycle.latestObservedEffect.responseObject.kind)} · ${escapeMarkdown(responseLifecycle.latestObservedEffect.responseObject.identifier)}${responseLifecycle.latestObservedEffect.objectOutcome ? ` · ${escapeMarkdown(responseLifecycle.latestObservedEffect.objectOutcome)}` : ''}`] : []),
         ...responseLifecycle.limitations.map((limitation) => `- ${escapeMarkdown(limitation)}`),
         '',
         '## Review and provenance',
@@ -113,22 +128,29 @@ export function renderCaseResponsePacket(packet) {
         ...profile.followUpFields.map((item) => `- Follow-up field: ${escapeMarkdown(item)}`),
     ];
     const markdown = `${lines.join('\n').trim()}\n`;
+    const correction = escalationHistory.find(action => action.actionId === packet.actionBinding.selectedActionId)?.correction;
     const email = [
         `Subject: ${profile.subject}`,
         '',
         'Hello,',
         '',
-        `I am reporting observed ${category} activity involving ${caseRecord.domain}.`,
+        correction ? `I am requesting ${correction.purpose === 'correction' ? 'a correction' : 'retraction or withdrawal'} of a previous statement involving ${caseRecord.domain}.`
+            : `I am reporting observed ${category} activity involving ${caseRecord.domain}.`,
+        ...(correction ? [`Original delivery event: ${correction.deliveryEventId}`, `Original canonical packet v${correction.packetVersion} SHA-256: ${correction.packetDigestSha256}`,
+            `Analyst reason: ${correction.reason}`, `Previous statement: ${correction.previousStatement}`,
+            `Corrected statement: ${correction.correctedStatement || 'Please retract the previous statement.'}`,
+            `Corrected evidence references: ${correction.evidencePinIds.join(', ')}`, 'This new request does not establish delivery, recipient acceptance, reversal, restoration or independent recheck.', ''] : []),
         `Affected party: ${affectedParty}`,
         `Observed at (UTC): ${observedAt}`,
         '',
-        'Observed harm:',
+        correction ? 'Retained incident context (not a renewed allegation):' : 'Observed harm:',
         observedHarm,
         '',
         'Exact URLs:',
         ...abusiveUrls.map((url) => `- ${url}`),
         '',
         'Selected evidence:',
+        ...escalationHistory.flatMap(action => action.responseObjects?.length ? [`Action ${action.actionId} scope: ${action.responseObjects.map(object => `${object.kind} · ${object.identifier}`).join('; ')}`] : []),
         ...(selectedEvidence.length
             ? selectedEvidence.map((item) => `- ${item.label} — ${item.source}${item.observationHostname ? ` for ${item.observationHostname}` : ''}${item.webObservationMode ? ' · selected URL' : ''}, observed ${item.observedAt ?? 'time unavailable'} (${item.completeness})`)
             : ['- No Case evidence pin was selected.']),
@@ -136,14 +158,15 @@ export function renderCaseResponsePacket(packet) {
         `Reviewed packet SHA-256: ${digestSha256}`,
         'Attach the reviewed packet (and any separately reviewed evidence files) through the recipient’s approved submission channel; this message does not embed or transmit attachments.',
         '',
-        responseLifecycle.latestProviderOutcome
-            ? `Provider outcome time: ${responseLifecycle.latestProviderOutcome.occurredAt} (${responseLifecycle.latestProviderOutcome.outcome.replaceAll('_', ' ')})`
-            : `Provider outcome time: Withheld because the typed event state is ${responseLifecycle.providerOutcomeState}.`,
-        responseLifecycle.latestObservedChangeAt
-            ? `Independently observed change time: ${responseLifecycle.latestObservedChangeAt}`
-            : `Independently observed change time: Withheld because the independent change state is ${responseLifecycle.observedChangeState}.`,
+        ...(responseLifecycle.latestProviderOutcome
+            ? [`Provider outcome time: ${responseLifecycle.latestProviderOutcome.occurredAt} (${responseLifecycle.latestProviderOutcome.outcome.replaceAll('_', ' ')})`]
+            : []),
+        ...(responseLifecycle.latestObservedChangeAt
+            ? [`Independently observed change time: ${responseLifecycle.latestObservedChangeAt}`]
+            : []),
         '',
         'Please review this report under the applicable abuse and acceptable-use policies.',
+        ...limitations,
         '',
         authorisation.status === 'authorised'
             ? 'This locally prepared packet is bound to explicit review confirmations. It was not submitted automatically and does not promise any provider outcome.'

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

@@ -2,21 +2,24 @@ import { renderCaseResponsePacket } from "./case-response-packet-render.mjs";
 import { responseContactLabel as contactLabel } from "./case-response-packet-vocabulary.mjs";
 // Pure abuse-evidence packet builder. It creates local review artifacts only:
 // no network requests, mailto links, submissions, or provider side effects.
-import { assertBoundedJsonStructure, } from "../../lib/bounded-json.mjs";
+import { assertPacketAmendmentSelection } from "./case-requested-evidence.mjs";
+import { correctionDelivery, CASE_DELIVERY_RECEIPT_LIMITATION } from "./case-packet-correction.mjs";
+import { caseSelectedEvidenceSourceLimitations } from "./case-evidence-links.mjs";
+import { sameCaseResponseObject } from "./case-response-object.mjs";
+import { assertBoundedJsonStructure, } from "../analysis/bounded-json.mjs";
 import { CASE_RESPONSE_PACKET_SCHEMA, CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSE_CATEGORY_LENGTH, MAX_ABUSIVE_URLS, MAX_AFFECTED_PARTY_LENGTH, MAX_EXACT_URL_LENGTH, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_HARM_LENGTH, MAX_RESPONSE_SELECTED_EVIDENCE, SUPPORTED_CASE_RESPONSE_PACKET_VERSIONS, } from "../contracts/case-portability.mjs";
 import { SORTED_JSON_V2, canonicalArtifactJsonV2, } from "../evidence/artifact-integrity.mjs";
 import { normalizeExplicitIsoTimestamp, } from "../evidence/observation.mjs";
 import { latestCaseEvidence, } from "./case-evidence-model.mjs";
 import {} from "./case-model.mjs";
-import { caseDispositionSupportsDefensiveResponse, } from "./case-record-operations.mjs";
-import { buildCaseActionOutcomeSummary, buildCaseResponseLifecycleSummary, } from "./case-response-model.mjs";
+import { caseDispositionSupportsDefensiveResponse } from "./case-record-decisions.mjs";
+import { buildCaseActionOutcomeSummary, buildCaseResponseLifecycleSummary, caseActionCompletesResponseDecision, countEvidenceLinkedCaseDecisions, } from "./case-response-model.mjs";
 import { RESPONSE_AUTHORISATION_CONFIRMATION_IDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_STATES, } from "./case-response-packet-vocabulary.mjs";
 import { validateCaseResponseReviewInputs, } from "./case-response-review-inputs.mjs";
 import { responseRouteFreshness, } from "./response-route-freshness.mjs";
 export * from "./case-response-packet-vocabulary.mjs";
 export { validateCaseResponseReviewInputs, } from "./case-response-review-inputs.mjs";
-export { CASE_RESPONSE_PACKET_SCHEMA, CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION, PUBLIC_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSE_CATEGORY_LENGTH, MAX_ABUSIVE_URLS, MAX_AFFECTED_PARTY_LENGTH, MAX_EXACT_URL_LENGTH, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_HARM_LENGTH, MAX_RESPONSE_SELECTED_EVIDENCE, RESPONSE_ROUTE_STALE_AFTER_DAYS, SUPPORTED_CASE_RESPONSE_PACKET_VERSIONS, } from "../contracts/case-portability.mjs";
-export { LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION, LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION, } from "../contracts/case-portability.mjs";
+export { CASE_RESPONSE_PACKET_SCHEMA, CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_PACKET_VERSION, PUBLIC_CASE_RESPONSE_PACKET_VERSION, PUBLISHED_V2_CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION, LATEST_PUBLIC_CASE_RESPONSE_PACKET_VERSION, LATEST_PUBLIC_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSE_CATEGORY_LENGTH, MAX_ABUSIVE_URLS, MAX_AFFECTED_PARTY_LENGTH, MAX_EXACT_URL_LENGTH, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_HARM_LENGTH, MAX_RESPONSE_SELECTED_EVIDENCE, RESPONSE_ROUTE_STALE_AFTER_DAYS, SUPPORTED_CASE_RESPONSE_PACKET_VERSIONS, } from "../contracts/case-portability.mjs";
 export const CASE_RESPONSE_PREFLIGHT_EVIDENCE_SCOPE = Object.freeze({
     version: 1,
     owner: 'case',
@@ -218,6 +221,14 @@ function selectedPacketAction(caseRecord, input) {
         : null;
     return actionId ? caseRecord.actions.find((action) => action.id === actionId) ?? null : null;
 }
+function assertAmendmentEvidence(caseRecord, input) {
+    const action = selectedPacketAction(caseRecord, input);
+    const selected = new Set(Array.isArray(input.selectedEvidencePinIds) ? input.selectedEvidencePinIds : []);
+    assertPacketAmendmentSelection(caseRecord.actions, action?.id ?? null, new Set(caseRecord.evidencePins.filter(pin => selected.has(pin.id)).map(pin => pin.id)));
+    if (action?.correction)
+        correctionDelivery(caseRecord.actions, action, { caseId: caseRecord.id, target: caseRecord.domain,
+            profile: responsePacketProfile(input.profile).id, selectedPinIds: new Set(caseRecord.evidencePins.filter(pin => selected.has(pin.id)).map(pin => pin.id)) });
+}
 function packetActionLineage(caseRecord, input) {
     const selected = selectedPacketAction(caseRecord, input);
     if (!selected)
@@ -317,6 +328,7 @@ function normalizeSelectedEvidence(caseRecord, value) {
         label: text(pin.label, 80),
         source: text(pin.source, 120),
         ...(pin.observationHostname ? { observationHostname: pin.observationHostname } : {}),
+        ...(pin.responseObject ? { responseObject: structuredClone(pin.responseObject) } : {}),
         ...(pin.webObservationMode ? { webObservationMode: pin.webObservationMode } : {}),
         observedAt: timestamp(pin.observedAt),
         completeness: text(pin.completeness, 40),
@@ -519,7 +531,7 @@ export function buildResponsePacketProfilePreview(caseRecord, input) {
         id: profile.id,
         label: profile.label,
         audience: profile.audience,
-        subject: `${profile.subjectPrefix}: ${caseRecord.domain} (${category})`,
+        subject: `${selectedPacketAction(caseRecord, input)?.correction ? 'Correction or retraction request' : profile.subjectPrefix}: ${caseRecord.domain} (${category})`,
         checklist: [...profile.checklist],
         evidenceOrder: [...profile.evidenceOrder],
         includedEvidence: [...profile.includedEvidence],
@@ -534,6 +546,13 @@ export function buildCaseResponsePreflight(caseRecord, input, generatedAt = new
     const observedAt = timestamp(input.observedAt);
     const normalizedGeneratedAt = timestamp(generatedAt) || new Date().toISOString();
     const binding = bindPacketRoute(caseRecord, input, normalizedGeneratedAt);
+    let amendmentError = null;
+    try {
+        assertAmendmentEvidence(caseRecord, input);
+    }
+    catch (error) {
+        amendmentError = error instanceof Error ? error.message : 'Review this amendment and its retained evidence.';
+    }
     const urls = normalizeUrls(input.abusiveUrls);
     const selectedEvidence = normalizeSelectedEvidence(caseRecord, input.selectedEvidencePinIds);
     const requiredComplete = Boolean(text(input.category, MAX_ABUSE_CATEGORY_LENGTH)
@@ -546,10 +565,9 @@ export function buildCaseResponsePreflight(caseRecord, input, generatedAt = new
         .filter((item) => item.kind === 'contradiction' && item.state === 'open')
         .length;
     const actionSummary = buildCaseActionOutcomeSummary(caseRecord.actions, normalizedGeneratedAt);
-    const retainedPinIds = new Set(caseRecord.evidencePins.map((pin) => pin.id));
-    const evidenceLinkedDecisionCount = caseRecord.decisions.filter((decision) => decision.evidencePinIds.some((evidencePinId) => retainedPinIds.has(evidencePinId))).length;
+    const evidenceLinkedDecisionCount = countEvidenceLinkedCaseDecisions(caseRecord.decisions, caseRecord.evidencePins);
     const responseDisposition = caseDispositionSupportsDefensiveResponse(caseRecord.disposition);
-    const reviewedActionCount = caseRecord.actions.filter((action) => ['reviewed', 'authorised', 'submitted', 'acknowledged', 'terminal'].includes(action.state)).length;
+    const reviewedActionCount = caseRecord.actions.filter((action) => caseActionCompletesResponseDecision(action.state)).length;
     const profile = responsePacketProfile(input.profile);
     const checks = [
         {
@@ -637,10 +655,10 @@ export function buildCaseResponsePreflight(caseRecord, input, generatedAt = new
         {
             id: 'packet_action',
             label: 'Packet action',
-            state: binding.actionBinding.state === 'selected' ? 'pass' : profile.id === 'internal_soc' ? 'caution' : 'block',
-            detail: binding.actionBinding.state === 'selected'
+            state: amendmentError ? 'block' : binding.actionBinding.state === 'selected' ? 'pass' : profile.id === 'internal_soc' ? 'caution' : 'block',
+            detail: amendmentError ?? (binding.actionBinding.state === 'selected'
                 ? `Action ${binding.actionBinding.selectedActionId} owns this packet and its retained origin lineage.`
-                : 'Select the retained Case action this packet prepares or documents.',
+                : 'Select the retained Case action this packet prepares or documents.'),
         },
         {
             id: 'action_tracking',
@@ -675,6 +693,9 @@ function normalizeActionHistory(caseRecord, input) {
             .map((action) => ({
             actionId: action.id,
             type: text(action.type, 80),
+            ...(action.amendment ? { amendment: structuredClone(action.amendment) } : {}),
+            ...(action.correction ? { correction: structuredClone(action.correction) } : {}),
+            ...(action.responseObjects !== undefined ? { responseObjects: structuredClone(action.responseObjects) } : {}),
             recipient: text(action.recipient, 320),
             contactSource: text(action.contactSource, 120),
             routeObservedAt: timestamp(action.routeObservedAt),
@@ -688,6 +709,10 @@ function normalizeActionHistory(caseRecord, input) {
             historyLimitations: normalizeLimitations(action.historyLimitations),
             transitions: action.history.map((event) => ({
                 id: event.id,
+                ...(event.evidenceRequest ? { evidenceRequest: structuredClone(event.evidenceRequest) } : {}),
+                ...(event.packetReceipt ? { packetReceipt: structuredClone(event.packetReceipt) } : {}),
+                ...(event.responseObjects !== undefined ? { responseObjects: structuredClone(event.responseObjects) } : {}),
+                ...(event.objectOutcome ? { objectOutcome: event.objectOutcome } : {}),
                 previousState: event.previousState,
                 nextState: event.nextState,
                 occurredAt: event.occurredAt,
@@ -723,21 +748,31 @@ function normalizeActionHistory(caseRecord, input) {
 }
 function normalizeResponseLifecycle(caseRecord, actionIds, lineageComplete) {
     const scopedIds = new Set(actionIds);
+    const objects = caseRecord.actions.filter(action => scopedIds.has(action.id)).flatMap(action => action.responseObjects ?? []);
     const scopedRecord = {
         ...caseRecord,
         actions: caseRecord.actions.filter((action) => scopedIds.has(action.id)),
+        observedEffects: {
+            ...caseRecord.observedEffects,
+            reviews: caseRecord.observedEffects.reviews.filter(review => review.responseObject
+                && objects.some(object => sameCaseResponseObject(object, review.responseObject))),
+        },
         closures: {
             ...caseRecord.closures,
             records: caseRecord.closures.records.filter((closure) => closure.actionId !== null && scopedIds.has(closure.actionId)),
         },
     };
     const summary = buildCaseResponseLifecycleSummary(scopedRecord);
+    const latestReview = scopedRecord.observedEffects.reviews.find(review => review.id === summary.latestObservedEffect?.reviewId);
     const providerOutcomeState = lineageComplete ? summary.providerOutcomeState : 'ambiguous';
     return {
         providerOutcomeState,
         latestProviderOutcome: lineageComplete && summary.latestProviderOutcome ? { ...summary.latestProviderOutcome } : null,
         observedChangeState: summary.observedChangeState,
-        latestObservedEffect: summary.latestObservedEffect ? { ...summary.latestObservedEffect } : null,
+        latestObservedEffect: summary.latestObservedEffect ? { ...summary.latestObservedEffect,
+            ...(latestReview?.responseObject ? { responseObject: latestReview.responseObject } : {}),
+            ...(latestReview?.objectOutcome ? { objectOutcome: latestReview.objectOutcome } : {}),
+        } : null,
         latestObservedChangeAt: summary.latestObservedChangeAt,
         closure: summary.latestClosure ? {
             id: summary.latestClosure.id,
@@ -749,6 +784,8 @@ function normalizeResponseLifecycle(caseRecord, actionIds, lineageComplete) {
             'Provider workflow outcomes and independently observed technical effects are separate point-in-time records.',
             'A provider acknowledgement, terminal state, or reported resolution never becomes independently observed remediation, absence, or safety.',
             'Times are withheld when the corresponding typed event is missing or ambiguous.',
+            ...(objects.length ? ['Each explicit object remains independent; a latest review does not adjudicate every object bound to the action.'] : []),
+            ...(caseRecord.observedEffects.reviews.length > scopedRecord.observedEffects.reviews.length ? ['Independent reviews without matching explicit action-object scope were excluded from this packet; their retained Case history is unchanged.'] : []),
             ...(!summary.latestObservedEffect && scopedRecord.observedEffects.reviews.length ? ['A single latest independent review cannot be selected from the retained observation times; all retained reviews remain separately attributed.'] : []),
             ...(!lineageComplete ? ['Provider-outcome time is withheld because the selected action origin lineage is incomplete.'] : []),
         ],
@@ -773,6 +810,7 @@ async function sha256(value) {
     return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
 }
 export function buildCaseResponseReviewInputs(caseRecord, input, generatedAt) {
+    assertAmendmentEvidence(caseRecord, input);
     const profile = buildResponsePacketProfilePreview(caseRecord, input);
     const category = text(input.category, MAX_ABUSE_CATEGORY_LENGTH);
     const selectedEvidence = normalizeSelectedEvidence(caseRecord, input.selectedEvidencePinIds);
@@ -783,6 +821,7 @@ export function buildCaseResponseReviewInputs(caseRecord, input, generatedAt) {
     return {
         contract: CASE_RESPONSE_REVIEW_INPUTS_SCHEMA,
         version: CASE_RESPONSE_REVIEW_INPUTS_VERSION,
+        sourceQualifications: caseSelectedEvidenceSourceLimitations(caseRecord.evidencePins, caseRecord.evidenceLinks, selectedEvidence.map(pin => pin.id)),
         profile: {
             id: profile.id,
             label: profile.label,
@@ -922,6 +961,9 @@ export async function buildCaseResponsePacket(caseRecord, input, generatedAt = n
             ? 'This packet is bound to explicit confirmations for the exact reviewed-input digest. It still requires deliberate manual use.'
             : 'This packet is a local draft with cautions and is not authorised for external use by WHOISleuth.',
         'WHOISleuth did not submit this packet or verify that any listed contact is monitored.',
+        ...reviewMaterial.sourceQualifications,
+        ...(selectedPacketAction(caseRecord, input)?.correction ? [CASE_DELIVERY_RECEIPT_LIMITATION,
+            'This is a new correction or retraction request. It does not undo the original delivery, establish recipient acceptance or restoration, or replace independent recheck.'] : []),
         ...(!contacts.length ? ['No escalation contact was included.'] : []),
         ...(age.refreshRecommended ? ['The selected observation is over seven days old or appears to be in the future. Refresh evidence before submission.'] : []),
     ];

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

@@ -1,4 +1,3 @@
-// Framework-neutral response record types and vocabulary.
 export const CASE_EVIDENCE_RELATION_STANCES = ['supports', 'contradicts', 'unresolved'];
 export const CASE_PIN_COMPLETENESS = ['complete', 'partial', 'inconclusive', 'unknown'];
 export const CASE_TRANSITION_EXPECTATIONS = ['preserve', 'change', 'review'];

package/packages/cases/case-response-review-inputs.mjs

@@ -1,8 +1,12 @@
 // Exact, bounded validation of current and published response-review inputs.
+import { readCaseEvidenceRequest, readCasePacketAmendment, assertEvidenceRequestEvent, assertEvidenceRequestHistory, assertPacketAmendmentSelection } from "./case-requested-evidence.mjs";
+import { readCaseDeliveryPacketReceipt, readCasePacketCorrection, assertDeliveryPacketReceipt, correctionDelivery } from "./case-packet-correction.mjs";
+import { CASE_SELECTED_EVIDENCE_SOURCE_LIMITATION } from "./case-evidence-links.mjs";
 import { CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, MAX_ABUSE_CATEGORY_LENGTH, MAX_ABUSIVE_URLS, MAX_AFFECTED_PARTY_LENGTH, MAX_CASE_ACTIONS, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_EXACT_URL_LENGTH, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_HARM_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_SELECTED_EVIDENCE, MAX_RESPONSE_VALUE_LENGTH, PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION, PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION, SUPPORTED_CASE_RESPONSE_REVIEW_INPUTS_VERSIONS, } from "../contracts/case-portability.mjs";
 import { CASE_ACTION_EVENT_SOURCE_CLASSES, CASE_ACTION_STATES, CASE_ACTION_TYPES, CASE_ASSERTION_STATES, CASE_CLOSURE_REASONS, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, CASE_OBSERVED_EFFECT_STATES, CASE_PIN_COMPLETENESS, CASE_PROVIDER_OUTCOMES, } from "./case-response-records.mjs";
 import { RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_ROW_IDS, RESPONSE_READINESS_STATES, } from "./case-response-packet-vocabulary.mjs";
-import { isValidAsciiHostname } from "../../lib/hostname.mjs";
+import { isValidAsciiHostname } from "../contracts/domain-name.mjs";
+import { readCaseResponseObject, readCaseResponseObjects, readCaseResponseObjectOutcome, assertCaseObjectOutcome } from "./case-response-object.mjs";
 const CONTACT_KINDS = new Set(RESPONSE_CONTACT_KINDS);
 const PRE_PLATFORM_CONTACT_KINDS = new Set(RESPONSE_CONTACT_KINDS.filter((kind) => kind !== 'application_platform'));
 const CONTROL_RE = /[\u0000-\u001f\u007f]/u;
@@ -26,6 +30,7 @@ const CASE_RESPONSE_REVIEW_INPUT_KEYS = Object.freeze([
     'escalationHistoryOmitted',
     'escalationHistoryLimitations',
     'responseLifecycle',
+    'sourceQualifications',
 ]);
 const PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUT_KEYS = Object.freeze(CASE_RESPONSE_REVIEW_INPUT_KEYS.filter((key) => key !== 'recipientRoute' && key !== 'actionBinding'));
 function exactReviewRecord(value, keys, label, optionalKeys = []) {
@@ -87,7 +92,7 @@ function reviewEnum(value, values, label) {
 function reviewNullableEnum(value, values, label) {
     return value === null ? null : reviewEnum(value, values, label);
 }
-function validateReviewLifecycle(value) {
+function validateReviewLifecycle(value, version) {
     const lifecycle = exactReviewRecord(value, [
         'providerOutcomeState', 'latestProviderOutcome', 'observedChangeState',
         'latestObservedEffect', 'latestObservedChangeAt', 'closure', 'limitations',
@@ -109,7 +114,10 @@ function validateReviewLifecycle(value) {
     if (lifecycle.latestObservedEffect !== null) {
         const effect = exactReviewRecord(lifecycle.latestObservedEffect, [
             'reviewId', 'state', 'observedAt', 'sourceClass', 'source',
-        ], 'Case-response latest observed effect');
+        ], 'Case-response latest observed effect', version >= 6 ? ['responseObject', 'objectOutcome'] : []);
+        const responseObject = readCaseResponseObject(effect.responseObject);
+        const objectOutcome = readCaseResponseObjectOutcome(effect.objectOutcome);
+        assertCaseObjectOutcome(objectOutcome, responseObject);
         reviewText(effect.reviewId, 64, 'Case-response observed-effect review id');
         reviewEnum(effect.state, CASE_OBSERVED_EFFECT_STATES, 'Case-response observed-effect state');
         reviewText(effect.observedAt, 64, 'Case-response observed-effect time');
@@ -150,7 +158,12 @@ export function validateCaseResponseReviewInputs(value) {
     }
     const hasPlatformRoutes = version >= PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION;
     const hasActionBinding = version >= PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION;
-    const source = exactReviewRecord(value, hasActionBinding ? CASE_RESPONSE_REVIEW_INPUT_KEYS : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUT_KEYS, 'Case-response review inputs');
+    const source = exactReviewRecord(value, (hasActionBinding ? CASE_RESPONSE_REVIEW_INPUT_KEYS : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUT_KEYS).filter(key => version >= 7 || key !== 'sourceQualifications'), 'Case-response review inputs');
+    if (version >= 7)
+        for (const qualification of boundedReviewArray(source.sourceQualifications, 1, 'Selected evidence source qualifications')) {
+            if (qualification !== CASE_SELECTED_EVIDENCE_SOURCE_LIMITATION)
+                throw new TypeError('Unknown selected-source qualification.');
+        }
     const profile = exactReviewRecord(source.profile, [
         'id', 'label', 'audience', 'subject', 'checklist', 'includedEvidence',
         'excludedEvidence', 'redactions',
@@ -235,7 +248,11 @@ export function validateCaseResponseReviewInputs(value) {
     for (const candidate of boundedReviewArray(source.selectedEvidence, MAX_RESPONSE_SELECTED_EVIDENCE, 'Case-response selected evidence')) {
         const evidence = exactReviewRecord(candidate, [
             'id', 'label', 'source', 'observedAt', 'completeness', 'limitations',
-        ], 'Case-response selected evidence item', version > PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION ? ['observationHostname', 'webObservationMode'] : []);
+        ], 'Case-response selected evidence item', [
+            ...(version > PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION ? ['observationHostname', 'webObservationMode'] : []),
+            ...(version >= 6 ? ['responseObject'] : []),
+        ]);
+        readCaseResponseObject(evidence.responseObject);
         reviewText(evidence.id, 64, 'Case-response evidence id');
         reviewText(evidence.label, 80, 'Case-response evidence label');
         reviewText(evidence.source, 120, 'Case-response evidence source');
@@ -318,7 +335,11 @@ export function validateCaseResponseReviewInputs(value) {
             ...(hasPlatformRoutes ? ['routeReviewAfter'] : []),
             'providerOutcome', 'outcomeDetail', 'originActionId', 'historyOmitted',
             'historyLimitations', 'transitions', 'createdAt', 'updatedAt',
-        ], 'Case-response escalation action');
+        ], 'Case-response escalation action', [...(version >= 5 ? ['amendment'] : []), ...(version >= 6 ? ['responseObjects'] : []), ...(version >= 7 ? ['correction'] : [])]);
+        readCaseResponseObjects(action.responseObjects);
+        readCasePacketAmendment(action.amendment);
+        if (readCasePacketCorrection(action.correction) && action.amendment)
+            throw new TypeError('Correction and provider amendment must remain separate.');
         for (const key of ['actionId', 'recipient', 'contactSource', 'createdAt', 'updatedAt']) {
             reviewText(action[key], MAX_RESPONSE_VALUE_LENGTH, `Case-response action ${key}`);
         }
@@ -338,12 +359,30 @@ export function validateCaseResponseReviewInputs(value) {
         reviewNullableEnum(action.providerOutcome, CASE_PROVIDER_OUTCOMES, 'Case-response action provider outcome');
         reviewCount(action.historyOmitted, MAX_CASE_ACTION_EVENTS_PER_CASE, 'Case-response omitted transition count');
         reviewStrings(action.historyLimitations, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH, 'Case-response action history limitations');
+        const requestEvents = [];
         for (const candidateTransition of boundedReviewArray(action.transitions, MAX_CASE_ACTION_EVENTS_PER_ACTION, 'Case-response transitions')) {
             const transition = exactReviewRecord(candidateTransition, [
                 'id', 'previousState', 'nextState', 'occurredAt', 'sourceClass', 'provenance',
                 'reference', 'evidencePinId', 'limitations', 'providerOutcome', 'outcomeDetail',
                 'originActionId', 'applied',
-            ], 'Case-response transition');
+            ], 'Case-response transition', [...(version >= 5 ? ['evidenceRequest'] : []), ...(version >= 6 ? ['responseObjects', 'objectOutcome'] : []), ...(version >= 7 ? ['packetReceipt'] : [])]);
+            const receipt = readCaseDeliveryPacketReceipt(transition.packetReceipt);
+            assertDeliveryPacketReceipt(receipt, transition, action.actionId);
+            if (receipt && (receipt.caseId !== source.case.id || receipt.target !== source.case.domain
+                || receipt.recipient !== action.recipient))
+                throw new TypeError('The delivery receipt must retain the same Case, target and recipient.');
+            const responseObjects = readCaseResponseObjects(transition.responseObjects);
+            const objectOutcome = readCaseResponseObjectOutcome(transition.objectOutcome);
+            if (objectOutcome) {
+                if (!responseObjects?.length || !['submitted', 'acknowledged', 'terminal'].includes(String(transition.nextState))
+                    || !['analyst', 'provider'].includes(String(transition.sourceClass))
+                    || transition.previousState === 'authorised')
+                    throw new TypeError('Case-response object outcome requires an explicit affected subset after submission.');
+                responseObjects.forEach(object => assertCaseObjectOutcome(objectOutcome, object));
+            }
+            const evidenceRequest = readCaseEvidenceRequest(transition.evidenceRequest);
+            assertEvidenceRequestEvent(evidenceRequest, transition);
+            requestEvents.push({ id: transition.id, ...(evidenceRequest ? { evidenceRequest } : {}) });
             for (const key of ['id', 'occurredAt', 'provenance']) {
                 reviewText(transition[key], MAX_RESPONSE_VALUE_LENGTH, `Case-response transition ${key}`);
             }
@@ -358,6 +397,7 @@ export function validateCaseResponseReviewInputs(value) {
                 throw new TypeError('Case-response transition applied state is invalid.');
             reviewStrings(transition.limitations, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH, 'Case-response transition limitations');
         }
+        assertEvidenceRequestHistory(requestEvents, Number(action.historyOmitted) > 0);
     }
     if (currentLineageActionIds
         && (currentLineageActionIds.length !== escalationActionIds.length
@@ -365,7 +405,19 @@ export function validateCaseResponseReviewInputs(value) {
         throw new TypeError('Case-response escalation history must match the selected action lineage in order.');
     }
     reviewCount(source.escalationHistoryOmitted, MAX_CASE_ACTIONS, 'Case-response omitted action count');
+    if (version >= 5)
+        assertPacketAmendmentSelection(source.escalationHistory.map(action => ({
+            id: action.actionId, history: action.transitions, originActionId: action.originActionId, amendment: action.amendment,
+        })), currentLineageActionIds?.[0] ?? null, new Set(source.selectedEvidence.map(pin => pin.id)));
+    if (version >= 7) {
+        const actions = source.escalationHistory.map(action => ({ ...action, id: action.actionId, history: action.transitions }));
+        const selected = actions.find(action => action.id === currentLineageActionIds?.[0]);
+        if (selected?.correction)
+            correctionDelivery(actions, selected, { caseId: source.case.id,
+                target: source.case.domain, profile: profile.id,
+                selectedPinIds: new Set(source.selectedEvidence.map(pin => pin.id)) });
+    }
     reviewStrings(source.escalationHistoryLimitations, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH, 'Case-response escalation limitations');
-    validateReviewLifecycle(source.responseLifecycle);
+    validateReviewLifecycle(source.responseLifecycle, version);
     return recursivelyFreezeReviewValue(structuredClone(source));
 }

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

@@ -1,4 +1,4 @@
-import { CASE_SCHEMA_VERSION, MAX_CASE_STORE_BYTES, } from "./case-record-model.mjs";
+import { CASE_SCHEMA_VERSION, MAX_CASE_STORE_BYTES } from "../contracts/case-portability.mjs";
 import { normalizeCaseStore } from "./case-migration-model.mjs";
 import { projectCaseForDurableWrite } from "./case-record-projection.mjs";
 /** The exact versioned string persisted by the browser storage adapter. */