@slicedearth/whoisleuth-cli 2.5.1 → 2.7.0

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.'