@slicedearth/whoisleuth-cli 2.5.1 → 2.6.0

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

@@ -0,0 +1,119 @@
+// Explicit object scope, not ownership, collection or proof of remediation.
+import { isValidAsciiHostname } from "../contracts/domain-name.mjs";
+import { OBJECT_RESPONSE_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { array, enumeration, exact, text } from "../evidence/artifact-structure.mjs";
+export const CASE_RESPONSE_OBJECT_KINDS = ['domain', 'hostname', 'page', 'redirect', 'advertisement', 'social_account', 'social_post', 'messaging', 'storefront', 'app', 'other'];
+export const CASE_RESPONSE_OBJECT_OUTCOMES = ['removed', 'restricted', 'suspended', 'delisted', 'warning', 'transferred', 'restored', 'disputed'];
+export const MAX_CASE_RESPONSE_OBJECT_IDENTIFIER = 1_979;
+export const MAX_CASE_RESPONSE_OBJECTS = 20;
+export function readCaseResponseObjects(value, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION)
+        throw new TypeError('Object-specific response scope requires Case schema 18 or later.');
+    const objects = array(value, 'Response objects', MAX_CASE_RESPONSE_OBJECTS).map(item => readCaseResponseObject(item, sourceVersion));
+    const keyed = objects.map(object => [JSON.stringify(object), object]);
+    if (new Set(keyed.map(([key]) => key)).size !== keyed.length)
+        throw new TypeError('Response objects must be unique.');
+    return Object.freeze(keyed.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, object]) => object));
+}
+/** Historical absence stays absent; a declared historical format cannot carry new fields. */
+export function readCaseResponseObject(value, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION)
+        throw new TypeError('Object-specific response scope requires Case schema 18 or later.');
+    const item = exact(value, ['kind', 'identifier', 'incidentTargetId'], 'Response object');
+    const kind = enumeration(item.kind, CASE_RESPONSE_OBJECT_KINDS, 'Response object kind');
+    const identifier = text(item.identifier, 'Response object identifier', MAX_CASE_RESPONSE_OBJECT_IDENTIFIER);
+    if (!identifier || identifier.trim() !== identifier || /[\u0000-\u001f\u007f]/u.test(identifier))
+        throw new TypeError('Response object identifier must be a bounded single-line value.');
+    const incidentTargetId = item.incidentTargetId === null ? null : text(item.incidentTargetId, 'Incident object identity', 64);
+    if (incidentTargetId !== null && !/^[A-Za-z0-9_-]{1,64}$/u.test(incidentTargetId))
+        throw new TypeError('Incident object identity is invalid.');
+    if (kind === 'domain' || kind === 'hostname') {
+        if (identifier !== identifier.toLowerCase() || !isValidAsciiHostname(identifier) || incidentTargetId !== null)
+            throw new TypeError('Domain and hostname scope require a normalised hostname and no incident-link identity.');
+    }
+    else {
+        let url;
+        try {
+            url = new URL(identifier);
+        }
+        catch {
+            throw new TypeError('Select an exact retained HTTP(S) incident link for this object.');
+        }
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.toString() !== identifier || !incidentTargetId)
+            throw new TypeError('Select an exact retained HTTP(S) incident link without credentials for this object.');
+    }
+    return Object.freeze({ kind, identifier, incidentTargetId });
+}
+export function readCaseResponseObjectOutcome(value, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION)
+        throw new TypeError('Object-specific outcomes require Case schema 18 or later.');
+    return enumeration(value, CASE_RESPONSE_OBJECT_OUTCOMES, 'Response object outcome');
+}
+export function sameCaseResponseObject(left, right) {
+    return left !== undefined && right !== undefined && left.kind === right.kind && left.identifier === right.identifier && left.incidentTargetId === right.incidentTargetId;
+}
+/** Explicit retained snapshots permit follow-up without retargeting edited links. */
+export function retainedCaseResponseObjects(record) {
+    const objects = [...(record.actions ?? []).flatMap(action => [...action.responseObjects ?? [], ...action.history.flatMap(event => event.responseObjects ?? [])]),
+        ...(record.observedEffects?.reviews ?? []).flatMap(review => review.responseObject ? [review.responseObject] : []),
+        ...(record.evidencePins ?? []).flatMap(pin => pin.responseObject ? [pin.responseObject] : []),
+        ...(record.closures?.records ?? []).flatMap(closure => closure.responseObject ? [closure.responseObject] : []),
+        ...(record.assertions ?? []).flatMap(assertion => assertion.recheck?.responseObject ? [assertion.recheck.responseObject] : [])];
+    return [...new Map(objects.map(object => [JSON.stringify(object), object])).values()];
+}
+/** New identities require current metadata; exact historical identities remain usable. */
+export function assertCaseResponseObject(object, record) {
+    if (!object)
+        return;
+    if (object.kind === 'domain') {
+        if (object.identifier !== record.domain)
+            throw new TypeError('The response domain must match this Case.');
+    }
+    else if (object.kind === 'hostname') {
+        if (object.identifier !== record.domain && !object.identifier.endsWith(`.${record.domain}`))
+            throw new TypeError('The response hostname must belong to this Case domain.');
+    }
+    else if (!record.workflowMetadata?.incidentTargets.some(target => target.id === object.incidentTargetId && target.url === object.identifier)
+        && !retainedCaseResponseObjects(record).some(retained => sameCaseResponseObject(retained, object))) {
+        throw new TypeError('The selected exact incident object changed or is not retained in this Case. Refresh and review it before saving.');
+    }
+}
+export function assertCaseObjectOutcome(outcome, object) {
+    if (!outcome)
+        return;
+    if (!object)
+        throw new TypeError('A typed object outcome requires explicit object scope.');
+    if (outcome === 'suspended' && object.kind !== 'domain')
+        throw new TypeError('Domain suspension requires domain scope.');
+    if (outcome === 'restricted' && object.kind !== 'social_account' && object.kind !== 'app' && object.kind !== 'other')
+        throw new TypeError('Account restriction requires account, app or explicitly other scope.');
+}
+export function caseResponseObjectChoices(record) {
+    const objects = [{ kind: 'domain', identifier: record.domain, incidentTargetId: null }];
+    const hosts = new Set([...(record.evidencePins ?? []).map(pin => pin.observationHostname), ...(record.evidenceHistory ?? []).map(snapshot => snapshot.inputHostname)].filter((value) => Boolean(value)));
+    for (const identifier of hosts)
+        if (identifier === record.domain || identifier.endsWith(`.${record.domain}`))
+            objects.push({ kind: 'hostname', identifier, incidentTargetId: null });
+    for (const target of record.workflowMetadata?.incidentTargets ?? [])
+        for (const kind of CASE_RESPONSE_OBJECT_KINDS.filter(kind => kind !== 'domain' && kind !== 'hostname'))
+            objects.push({ kind, identifier: target.url, incidentTargetId: target.id });
+    objects.push(...retainedCaseResponseObjects(record));
+    return [...new Map(objects.map(object => [JSON.stringify(object), object])).values()].map(object => {
+        const historical = Boolean(object.incidentTargetId && !record.workflowMetadata?.incidentTargets.some(target => target.id === object.incidentTargetId && target.url === object.identifier));
+        return { value: JSON.stringify(object), label: `${object.kind.replaceAll('_', ' ')} · ${object.identifier}${historical ? ' · historical / no current incident link' : ''}`, object };
+    });
+}
+export function selectedCaseResponseObject(record, value) {
+    if (!value)
+        return undefined;
+    const object = caseResponseObjectChoices(record).find(choice => choice.value === value)?.object;
+    if (!object)
+        throw new TypeError('The selected incident object changed. Refresh and review it before saving.');
+    return readCaseResponseObject(object);
+}

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

@@ -1,7 +1,8 @@
 // Independent observed effects, linked closures and lifecycle summaries.
 import { MAX_CASE_CLOSURES, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_RATIONALE_LENGTH, } from "../contracts/case-portability.mjs";
 import { latestObservationCohort, } from "../evidence/latest-observations.mjs";
-import { readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
+import { readCaseRecheckAnswerContext, assertRecheckNonReproduction, COMPARATIVE_CASE_OBJECT_OUTCOMES } from "./case-recheck-model.mjs";
+import { readCaseResponseObject, readCaseResponseObjectOutcome, assertCaseObjectOutcome, sameCaseResponseObject } from "./case-response-object.mjs";
 import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
 import { CASE_CLOSURE_REASONS, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, CASE_OBSERVED_EFFECT_STATES, } from "./case-response-records.mjs";
 import { COMPLETENESS, SAFE_ID_RE, boundedCounter, compareCodeUnits, freshId, iso, lifecycleLimitations, limitations, optionalIso, record, safeId, text, } from "./case-response-values.mjs";
@@ -20,6 +21,16 @@ function normalizeObservedEffectReview(raw, fallback, validPinIds, validSighting
         return null;
     const createdAt = iso(item.createdAt, observedAt || fallback, options);
     const recheck = readCaseRecheckAnswerContext(item.recheck, options.sourceVersion);
+    const responseObject = readCaseResponseObject(item.responseObject, options.sourceVersion);
+    const objectOutcome = readCaseResponseObjectOutcome(item.objectOutcome, options.sourceVersion);
+    assertCaseObjectOutcome(objectOutcome, responseObject);
+    if (objectOutcome && (item.state === 'unavailable' || item.state === 'not_checked'))
+        throw new TypeError('Unavailable or unchecked collection cannot establish an object outcome.');
+    if (objectOutcome && COMPARATIVE_CASE_OBJECT_OUTCOMES.includes(objectOutcome)
+        && (item.completeness !== 'complete' || !recheck?.responseObject || recheck.conditionsMatch !== 'comparable'))
+        throw new TypeError('An independently observed object state change requires complete evidence and comparable exact-object conditions.');
+    if (recheck?.responseObject && !sameCaseResponseObject(recheck.responseObject, responseObject))
+        throw new TypeError('The recheck answer and observation must concern the same exact object.');
     if (recheck && item.state === 'not_reproduced' && (item.completeness !== 'complete' || recheck.conditionsMatch !== 'comparable')) {
         throw new TypeError('A question cannot be marked not reproduced from incomplete evidence or unconfirmed comparison conditions.');
     }
@@ -51,6 +62,8 @@ function normalizeObservedEffectReview(raw, fallback, validPinIds, validSighting
         sightingId,
         followUpAt: optionalIso(item.followUpAt, options),
         ...(recheck ? { recheck } : {}),
+        ...(responseObject ? { responseObject } : {}),
+        ...(objectOutcome ? { objectOutcome } : {}),
         createdAt,
     };
 }
@@ -128,6 +141,7 @@ function normalizeClosure(raw, fallback, validReviewIds, validActionIds, options
     if (!summary)
         return null;
     const createdAt = iso(item.createdAt, fallback, options);
+    const responseObject = readCaseResponseObject(item.responseObject, options.sourceVersion);
     const observedEffectReviewId = typeof item.observedEffectReviewId === 'string'
         && SAFE_ID_RE.test(item.observedEffectReviewId)
         && (!validReviewIds || validReviewIds.has(item.observedEffectReviewId))
@@ -150,7 +164,8 @@ function normalizeClosure(raw, fallback, validReviewIds, validActionIds, options
         return null;
     const linkedProviderEvents = actionId ? linkContext.providerResolutionEvents?.get(actionId) ?? [] : [];
     if (linkContext.providerResolutionEvents && reason === 'provider_reported_resolution_not_independently_checked'
-        && !linkedProviderEvents.some((event) => Date.parse(event.occurredAt) <= Date.parse(createdAt)))
+        && !linkedProviderEvents.some((event) => Date.parse(event.occurredAt) <= Date.parse(createdAt)
+            && (responseObject ? event.responseObjects?.some(object => sameCaseResponseObject(object, responseObject)) : !event.responseObjects?.length)))
         return null;
     const linkLimitations = [
         ...(item.observedEffectReviewId != null && !observedEffectReviewId ? ['A malformed or dangling observed-effect review reference was omitted from this closure.'] : []),
@@ -158,6 +173,7 @@ function normalizeClosure(raw, fallback, validReviewIds, validActionIds, options
     ];
     return {
         id: safeId(item.id, 'case-closure', { reason: item.reason, summary, createdAt }),
+        ...(responseObject === undefined ? {} : { responseObject }),
         reason,
         summary,
         observedEffectReviewId,
@@ -174,8 +190,11 @@ export function buildCaseClosureLinkContext(observedEffects, actions) {
                 createdAt: review.createdAt,
             }])),
         providerResolutionEvents: new Map(actions.map((action) => [action.id, action.history
-                .filter((event) => event.applied && event.providerOutcome === 'provider_reports_resolved')
-                .map((event) => ({ eventId: event.id, occurredAt: event.occurredAt }))])),
+                // Reconciliation can change projection, but not the identity of a retained
+                // typed receipt supporting an already-authored historical decision.
+                .filter((event) => event.providerOutcome === 'provider_reports_resolved')
+                .map((event) => ({ eventId: event.id, occurredAt: event.occurredAt,
+                ...(event.responseObjects === undefined ? {} : { responseObjects: event.responseObjects }) }))])),
     };
 }
 export function normalizeCaseClosureHistory(raw, fallback, validReviewIds, validActionIds, options = {}, linkContext = {}) {
@@ -224,7 +243,9 @@ export function normalizeCaseClosureHistory(raw, fallback, validReviewIds, valid
     };
 }
 /** New-write policy only. Historical normalisation must not re-adjudicate a closure. */
-export function caseClosureReviewBlocker(reason, review, now) {
+export function caseClosureReviewBlocker(reason, review, now, responseObject, evidencePins = []) {
+    if (review?.responseObject && !sameCaseResponseObject(responseObject, review.responseObject))
+        return 'This independent review concerns one object. Select that object for closure; it cannot close the whole Case.';
     if (reason !== 'independently_not_reproduced' && reason !== 'infrastructure_changed')
         return null;
     const expected = reason === 'independently_not_reproduced' ? 'not_reproduced' : 'changed';
@@ -233,6 +254,18 @@ export function caseClosureReviewBlocker(reason, review, now) {
         : 'This closure reason requires a linked independent changed review.';
     if (!review || review.state !== expected)
         return invalidLink;
+    if (responseObject) {
+        if (!sameCaseResponseObject(responseObject, review.responseObject))
+            return 'Object-specific technical closure requires a linked independent review explicitly bound to this exact object; historical missing binding remains unknown.';
+        if (!review.recheck || !sameCaseResponseObject(responseObject, review.recheck.responseObject))
+            return 'Object-specific technical closure requires a complete exact-object baseline and current review under comparable conditions.';
+        try {
+            assertRecheckNonReproduction('not_reproduced', review.recheck, review.completeness, evidencePins, evidencePins.find(pin => pin.id === review.evidencePinId), review.observedAt);
+        }
+        catch (cause) {
+            return cause instanceof Error ? cause.message : 'The exact-object review cannot support technical closure.';
+        }
+    }
     const observedAt = normalizeExplicitIsoTimestamp(review.observedAt);
     const createdAt = normalizeExplicitIsoTimestamp(review.createdAt);
     const closedAt = normalizeExplicitIsoTimestamp(now);
@@ -248,7 +281,43 @@ export function caseClosureReviewBlocker(reason, review, now) {
     }
     return null;
 }
-export function appendCaseClosure(current, raw, now, observedEffects, actions) {
+/** Latest applicable provider cohort, never the action-wide summary or an old receipt. */
+export function caseClosureProviderBlocker(action, responseObject, now) {
+    const blocked = 'This closure reason requires a linked typed provider-reported-resolution outcome for the latest applicable object observation.';
+    const closedAt = normalizeExplicitIsoTimestamp(now);
+    if (!action || !closedAt)
+        return blocked;
+    if (responseObject ? !action.responseObjects?.some(object => sameCaseResponseObject(object, responseObject)) : action.responseObjects?.length)
+        return blocked;
+    // A losing workflow transition is still retained evidence. Select the
+    // exact-object cohort before checking whether its receipts were applied.
+    const events = action.history.filter(event => (event.providerOutcome !== null || event.objectOutcome !== undefined)
+        && Date.parse(event.occurredAt) <= Date.parse(closedAt)
+        && (responseObject ? event.responseObjects?.some(object => sameCaseResponseObject(object, responseObject)) : !event.responseObjects?.length));
+    const cohort = latestObservationCohort(events, event => event.occurredAt);
+    if (!cohort.latest.length || cohort.undated.length || cohort.latest.some(event => !event.applied || event.providerOutcome !== 'provider_reports_resolved'
+        || event.objectOutcome === 'restored' || event.objectOutcome === 'disputed')
+        || new Set(cohort.latest.map(event => event.objectOutcome ?? null)).size !== 1)
+        return blocked;
+    return null;
+}
+export function caseClosureActionBlocker(reason, action, responseObject, now) {
+    if (action?.responseObjects?.length && (!responseObject || !action.responseObjects.some(object => sameCaseResponseObject(object, responseObject))))
+        return 'This action concerns explicitly bound objects. Select one of them for this closure; other objects remain independent.';
+    return reason === 'provider_reported_resolution_not_independently_checked' ? caseClosureProviderBlocker(action, responseObject, now) : null;
+}
+/** Derived presentation only: never rewrite the analyst's summary or limitations. */
+export function caseClosureHistoryQualification(closure, actions) {
+    if (closure.reason !== 'provider_reported_resolution_not_independently_checked')
+        return null;
+    const action = actions.find(candidate => candidate.id === closure.actionId);
+    // Evaluate the retained history, not a wall-clock freshness claim. Future-dated
+    // or conflicting receipts cannot silently make an old decision authoritative.
+    const latestAt = (action?.history ?? []).reduce((latest, event) => Date.parse(event.occurredAt) > Date.parse(latest) ? event.occurredAt : latest, closure.createdAt);
+    return caseClosureProviderBlocker(action, closure.responseObject, latestAt) === null ? null
+        : 'As of the latest retained receipt, provider history does not support a new closure for this scope. This historical analyst decision is preserved; it does not establish current remediation.';
+}
+export function appendCaseClosure(current, raw, now, observedEffects, actions, evidencePins = []) {
     const item = record(raw);
     const reason = typeof item.reason === 'string' && CLOSURE_REASONS.has(item.reason)
         ? item.reason
@@ -259,16 +328,13 @@ export function appendCaseClosure(current, raw, now, observedEffects, actions) {
     const action = typeof item.actionId === 'string'
         ? actions.find((candidate) => candidate.id === item.actionId) ?? null
         : null;
-    const reviewBlocker = caseClosureReviewBlocker(reason, review, now);
+    const responseObject = readCaseResponseObject(item.responseObject);
+    const reviewBlocker = caseClosureReviewBlocker(reason, review, now, responseObject, evidencePins);
     if (reviewBlocker)
         throw new Error(reviewBlocker);
-    if (reason === 'provider_reported_resolution_not_independently_checked'
-        && (action?.providerOutcome !== 'provider_reports_resolved'
-            || !action.history.some((event) => event.applied
-                && event.providerOutcome === 'provider_reports_resolved'
-                && Date.parse(event.occurredAt) <= Date.parse(now)))) {
-        throw new Error('This closure reason requires a linked typed provider-reported-resolution outcome.');
-    }
+    const actionBlocker = caseClosureActionBlocker(reason, action, responseObject, now);
+    if (actionBlocker)
+        throw new Error(actionBlocker);
     const linkContext = buildCaseClosureLinkContext(observedEffects, actions);
     const created = normalizeClosure({ ...item, id: freshId('case-closure'), createdAt: now }, now, new Set(observedEffects.reviews.map((candidate) => candidate.id)), new Set(actions.map((candidate) => candidate.id)), {}, linkContext);
     if (!created || !reason)
@@ -314,6 +380,7 @@ export function buildCaseResponseLifecycleSummary(input) {
         ? 'missing'
         : latestObservedChangeAt ? 'available' : 'ambiguous';
     const latestClosure = [...(input.closures?.records ?? [])]
+        .filter(closure => closure.responseObject === undefined)
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt) || compareCodeUnits(right.id, left.id))[0] ?? null;
     return {
         providerOutcomeState,

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

@@ -3,6 +3,7 @@ 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`,
         '',
@@ -14,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),
         '',
@@ -48,9 +49,14 @@ export function renderCaseResponsePacket(packet) {
                 ...(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)}`,
@@ -86,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}.`,
@@ -93,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',
@@ -117,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.']),
@@ -148,6 +166,7 @@ export function renderCaseResponsePacket(packet) {
             : []),
         '',
         '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

@@ -3,6 +3,9 @@ import { responseContactLabel as contactLabel } from "./case-response-packet-voc
 // Pure abuse-evidence packet builder. It creates local review artifacts only:
 // no network requests, mailto links, submissions, or provider side effects.
 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";
@@ -222,6 +225,9 @@ 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);
@@ -322,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),
@@ -524,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],
@@ -687,6 +694,8 @@ function normalizeActionHistory(caseRecord, input) {
             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),
@@ -701,6 +710,9 @@ function normalizeActionHistory(caseRecord, input) {
             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,
@@ -736,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,
@@ -762,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.'] : []),
         ],
@@ -797,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,
@@ -936,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.'] : []),
     ];