@slicedearth/whoisleuth-cli 2.5.1 → 2.7.0

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

@@ -1,4 +1,3 @@
-// Response packet vocabulary shared by construction and independent validation.
 export const RESPONSE_CONTACT_KINDS = [
     'registrar',
     'registry',
@@ -6,6 +5,18 @@ export const RESPONSE_CONTACT_KINDS = [
     'security_txt',
     'application_platform',
 ];
+const ACTION_CONTACT_KINDS = {
+    registrar_report: 'registrar',
+    registry_report: 'registry',
+    network_hosting_report: 'network_hosting',
+    security_contact_report: 'security_txt',
+    platform_report: 'application_platform',
+    defensive_control: 'manual',
+    internal_review: 'manual',
+};
+export function responseActionContactKind(type) {
+    return ACTION_CONTACT_KINDS[type];
+}
 export const RESPONSE_PACKET_PROFILE_IDS = [
     'registrar',
     'registry',

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

@@ -1,8 +1,11 @@
 import { renderCaseResponsePacket } from "./case-response-packet-render.mjs";
-import { responseContactLabel as contactLabel } from "./case-response-packet-vocabulary.mjs";
+import { responseActionContactKind, 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 { 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";
@@ -199,19 +202,6 @@ function normalizeLimitations(value) {
     }
     return [...unique];
 }
-function actionContactKind(type) {
-    if (type === 'registrar_report')
-        return 'registrar';
-    if (type === 'registry_report')
-        return 'registry';
-    if (type === 'network_hosting_report')
-        return 'network_hosting';
-    if (type === 'security_contact_report')
-        return 'security_txt';
-    if (type === 'platform_report')
-        return 'application_platform';
-    return 'manual';
-}
 function selectedPacketAction(caseRecord, input) {
     const actionId = typeof input.actionId === 'string' && /^[A-Za-z0-9_-]{1,64}$/u.test(input.actionId)
         ? input.actionId
@@ -222,6 +212,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);
@@ -258,7 +251,7 @@ function bindPacketRoute(caseRecord, input, generatedAt) {
             contacts: [],
         };
     }
-    const kind = actionContactKind(action.type);
+    const kind = responseActionContactKind(action.type);
     const compatible = profile.requiredContactKind
         ? kind === profile.requiredContactKind
         : profile.id === 'browser_blocklist'
@@ -322,6 +315,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 +518,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 +681,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 +697,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 +735,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 +771,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 +808,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 +948,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-review-inputs.mjs

@@ -1,9 +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 { RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_ROW_IDS, RESPONSE_READINESS_STATES, responseActionContactKind, } from "./case-response-packet-vocabulary.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;
@@ -27,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 = []) {
@@ -88,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',
@@ -110,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');
@@ -135,6 +142,21 @@ function recursivelyFreezeReviewValue(value) {
     }
     return Object.freeze(value);
 }
+/** Compare already shape-validated route and action records without rebuilding
+ * or normalising the retained evidence. Older formats omit the review deadline. */
+export function assertCaseResponseRecipientAction(route, actions, hasReviewAfter) {
+    if (!route)
+        return;
+    const action = actions.find(candidate => candidate.actionId === route.actionId);
+    if (!action
+        || route.kind !== responseActionContactKind(action.type)
+        || route.contact !== action.recipient
+        || route.source !== (action.contactSource || 'analyst supplied')
+        || route.observedAt !== action.routeObservedAt
+        || (hasReviewAfter && route.reviewAfter !== action.routeReviewAfter)) {
+        throw new TypeError('Case-response recipient route must match its selected action.');
+    }
+}
 export function validateCaseResponseReviewInputs(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new TypeError('Case-response review inputs must be an exact object.');
@@ -151,7 +173,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',
@@ -236,7 +263,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');
@@ -319,8 +350,11 @@ export function validateCaseResponseReviewInputs(value) {
             ...(hasPlatformRoutes ? ['routeReviewAfter'] : []),
             'providerOutcome', 'outcomeDetail', 'originActionId', 'historyOmitted',
             'historyLimitations', 'transitions', 'createdAt', 'updatedAt',
-        ], 'Case-response escalation action', version >= 5 ? ['amendment'] : []);
+        ], '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}`);
         }
@@ -346,7 +380,21 @@ export function validateCaseResponseReviewInputs(value) {
                 'id', 'previousState', 'nextState', 'occurredAt', 'sourceClass', 'provenance',
                 'reference', 'evidencePinId', 'limitations', 'providerOutcome', 'outcomeDetail',
                 'originActionId', 'applied',
-            ], 'Case-response transition', version >= 5 ? ['evidenceRequest'] : []);
+            ], '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 } : {}) });
@@ -371,12 +419,22 @@ export function validateCaseResponseReviewInputs(value) {
             || escalationActionIds.some((id, index) => currentLineageActionIds?.[index] !== id))) {
         throw new TypeError('Case-response escalation history must match the selected action lineage in order.');
     }
+    if (hasActionBinding)
+        assertCaseResponseRecipientAction(source.recipientRoute, source.escalationHistory, hasPlatformRoutes);
     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-type-presentation.mjs

@@ -0,0 +1,10 @@
+import { caseTypeRecords } from "./case-workflow-metadata.mjs";
+/** Display text for declared Case types; admission and mutation remain separate. */
+export function caseTypeSummary(record) {
+    const labels = caseTypeRecords(record).map((item) => item.label);
+    if (!labels.length)
+        return '';
+    if (labels.length <= 2)
+        return labels.join(' and ');
+    return `${labels.slice(0, 2).join(', ')} and ${labels.length - 2} more`;
+}

package/packages/cases/case-workflow-metadata.mjs

@@ -44,14 +44,6 @@ export function caseTypeRecords(record) {
     const selected = new Set(caseTypeIds(record));
     return CASE_TYPES.filter((item) => selected.has(item.id));
 }
-export function caseTypeSummary(record) {
-    const labels = caseTypeRecords(record).map((item) => item.label);
-    if (!labels.length)
-        return '';
-    if (labels.length <= 2)
-        return labels.join(' and ');
-    return `${labels.slice(0, 2).join(', ')} and ${labels.length - 2} more`;
-}
 function encodeCaseReference(value, minimumLength) {
     let remainder = value;
     let encoded = '';
@@ -102,15 +94,7 @@ export function normalizeCaseIncidentTargetUrl(value) {
     const normalized = parsed.toString();
     return normalized.length <= MAX_CASE_INCIDENT_TARGET_URL_LENGTH ? normalized : null;
 }
-/** Local review only: analyst link state is not independent observed coverage. */
-export function buildCaseIncidentCoverage(record) {
-    return caseIncidentTargets(record, { includeResolved: true }).map(target => ({
-        target,
-        hostname: new URL(target.url).hostname,
-        actionCoverage: 'unknown',
-        observationCoverage: 'unknown',
-    }));
-}
+export { buildCaseIncidentCoverage } from "./case-object-coverage.mjs";
 export function emptyCaseWorkflowMetadata() {
     return { types: [], incidentTargets: [], investigationContext: null };
 }

package/packages/comparison/capture-context.mjs

@@ -1,6 +1,7 @@
 import { exact, text } from "../evidence/artifact-structure.mjs";
 import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
 import { readEvidenceImageDimensions } from "../evidence/image-regions.mjs";
+export const MAX_CAPTURE_COMPARISON_CONTEXTS = 20;
 /** Optional declarations remain unknown for existing manifests; no inference from image dimensions. */
 export function readCaptureConditions(raw) {
     if (raw === undefined || raw === null)
@@ -23,8 +24,8 @@ export function readObservationLabel(raw) {
     return text(raw, 'Observation label', 80);
 }
 export function compareObservationContexts(input) {
-    if (!Array.isArray(input) || input.length < 2 || input.length > 20)
-        throw new TypeError('Compare between 2 and 20 observation contexts.');
+    if (!Array.isArray(input) || input.length < 2 || input.length > MAX_CAPTURE_COMPARISON_CONTEXTS)
+        throw new TypeError(`Compare between 2 and ${MAX_CAPTURE_COMPARISON_CONTEXTS} observation contexts.`);
     const observations = input.map(value => {
         const observedAt = value.observedAt === null ? null : normalizeExplicitIsoTimestamp(value.observedAt);
         if (value.observedAt !== null && !observedAt)

package/packages/contracts/analyst-interchange.mjs

@@ -33,7 +33,8 @@ export const MAIL_REPORT_CANONICALIZATION_ROUTES = Object.freeze([
 export const REGISTRATION_DISCLOSURE_PLAN_SCHEMA = 'whoisleuth.registration-disclosure-plan';
 export const REGISTRATION_DISCLOSURE_PLAN_VERSION = 2;
 export const STATIC_PAGE_PATTERN_PACK_SCHEMA = 'whoisleuth.static-page-pattern-pack';
-export const STATIC_PAGE_PATTERN_PACK_VERSION = 2;
+export const STATIC_PAGE_PATTERN_PACK_VERSION = 3;
+export const STATIC_PAGE_PATTERN_PACK_SUPPORTED_VERSIONS = [2, STATIC_PAGE_PATTERN_PACK_VERSION];
 export const MAX_STATIC_PAGE_PATTERN_PACK_BYTES = 256 * 1024;
 export const WEB_CAPTURE_SUMMARY_SCHEMA = 'whoisleuth.web-capture-summary';
 export const WEB_CAPTURE_SUMMARY_VERSION = 1;
@@ -136,11 +137,11 @@ const REGISTRATION_DISCLOSURE_COMPATIBILITY = defineSchemaCompatibility({
 });
 const STATIC_PATTERN_PACK_COMPATIBILITY = defineSchemaCompatibility({
     id: 'export.static-page-pattern-pack', kind: 'export', schema: STATIC_PAGE_PATTERN_PACK_SCHEMA,
-    currentVersion: STATIC_PAGE_PATTERN_PACK_VERSION, supportedVersions: [STATIC_PAGE_PATTERN_PACK_VERSION],
-    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'exact_current_only',
+    currentVersion: STATIC_PAGE_PATTERN_PACK_VERSION, supportedVersions: STATIC_PAGE_PATTERN_PACK_SUPPORTED_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only',
     writeSemantics: 'non_destructive_merge', byteBudget: MAX_STATIC_PAGE_PATTERN_PACK_BYTES,
     owner: ANALYST_INTERCHANGE_CONTRACT_OWNER,
-    note: 'Exact-current bounded page-pattern pack imported by explicit analyst action and merged without executing code or starting collection.',
+    note: 'Versions 2 and 3 remain readable. Version 3 can use attributed password-form destinations; older rules retain their declared meaning. Import remains explicit and does not execute code or start collection.',
 });
 export function serialiseAnalystInterchangeJson(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
@@ -229,6 +230,7 @@ export const ANALYST_INTERCHANGE_LIFECYCLE_FAMILY = defineSchemaLifecycleFamily(
         { descriptor: STATIC_PATTERN_PACK_COMPATIBILITY, lifecycleSchema: STATIC_PAGE_PATTERN_PACK_SCHEMA,
             requiredKeys: ['schema', 'version', 'id', 'label', 'description', 'evidenceBoundary', 'relationship', 'confidence', 'rules'], optionalKeys: [],
             hook: { module: 'packages/interchange/static-page-pattern-packs.mts', exportName: 'validateStaticPagePatternPack', role: 'structure_validator', runtime: 'shared' },
-            fixtures: [{ id: 'static-page-pattern-pack-v2', path: `${F}static-page-pattern-pack-v2.json`, bytes: 1_094, sha256: 'c409e527850bcb924f5be0708a58c5e2c32d98947c42150f6a79765991c0eb6f', version: STATIC_PAGE_PATTERN_PACK_VERSION }] },
+            fixtures: [{ id: 'static-page-pattern-pack-v2', path: `${F}static-page-pattern-pack-v2.json`, bytes: 1_094, sha256: 'c409e527850bcb924f5be0708a58c5e2c32d98947c42150f6a79765991c0eb6f', version: 2 },
+                { id: 'static-page-pattern-pack-v3', path: `${F}static-page-pattern-pack-v3.json`, bytes: 746, sha256: '5be19b621ad604de8c430191a34fcd2d624b22b8bdf9a5cb2653ef7d1b86c71a', version: 3 }] },
     ],
 }));

package/packages/contracts/analyst-review-state-contract.mjs

@@ -59,7 +59,7 @@ export const ANALYST_REVIEW_NEXT_ACTIONS = ['review', 'refresh', 'follow_up', 'r
 export const ANALYST_REVIEW_LIFECYCLE_STATES = ['open', 'expected', 'suppressed', 'resolved', 'expired', 'invalidated', 'recurred', 'orphaned'];
 export const ANALYST_REVIEW_QUEUE_OPTIONS = [
     { value: 'needs_action', label: 'Needs action' },
-    { value: 'waiting', label: 'Waiting / follow-up' },
+    { value: 'waiting', label: 'Waiting on' },
     { value: 'changed', label: 'Changed since review' },
     { value: 'reviewed', label: 'Reviewed' },
     { value: 'all', label: 'Everything' },

package/packages/contracts/candidate-watch-review.mjs

@@ -0,0 +1,54 @@
+import { defineSchemaCompatibility } from "./schema-compatibility.mjs";
+import { defineSchemaLifecycleFamily } from "./schema-lifecycle.mjs";
+import { buildExtractedLifecycleFamily } from "./extracted-domain-lifecycle.mjs";
+import { MAX_WATCHLIST_IMPORT_BYTES } from "./workspace-portability.mjs";
+export const CANDIDATE_WATCH_INPUT_SCHEMA = 'whoisleuth.candidate-watch-input';
+export const CANDIDATE_WATCH_INPUT_VERSION = 1;
+export const CANDIDATE_WATCH_INPUT_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'cli.candidate-watch-input',
+    kind: 'cli_document',
+    schema: CANDIDATE_WATCH_INPUT_SCHEMA,
+    currentVersion: 1,
+    supportedVersions: [1],
+    acceptsUnversionedLegacy: false,
+    futureVersionBehavior: 'reject',
+    migration: 'exact_current_only',
+    writeSemantics: 'read_only',
+    byteBudget: MAX_WATCHLIST_IMPORT_BYTES,
+    owner: 'packages/contracts/candidate-watch-review.mts',
+    note: 'Bounded offline analyst selection and optional portable Watchlist document; no collection or schedule authority.',
+});
+export const CANDIDATE_WATCH_REVIEW_LIFECYCLE_FAMILY = defineSchemaLifecycleFamily(buildExtractedLifecycleFamily({
+    id: 'candidate-watch-review',
+    owner: 'packages/contracts/candidate-watch-review.mts',
+    plane: 'node',
+    projection: 'review_output',
+    retention: 'transient_report',
+    serializerModule: 'cli/formatters/json.mts',
+    serializerExportName: 'formatJsonDocument',
+    includedCategories: ['candidate-provenance', 'analyst-watch-reasons', 'review-priorities'],
+    excludedCategories: ['raw-upstream-payloads', 'credentials', 'cookies', 'query-bearing-urls'],
+    formats: [
+        {
+            descriptor: CANDIDATE_WATCH_INPUT_COMPATIBILITY,
+            lifecycleSchema: CANDIDATE_WATCH_INPUT_SCHEMA,
+            requiredKeys: ['schema', 'version', 'watchlists', 'selection'],
+            optionalKeys: [],
+            hook: {
+                module: 'cli/watchlist-review.mts',
+                exportName: 'parseCandidateWatchInput',
+                role: 'structure_validator',
+                runtime: 'node',
+            },
+            fixtures: [
+                {
+                    id: 'candidate-watch-input-v1',
+                    path: 'test/fixtures/brand-candidate-workflow/candidate-watch-input-v1.json',
+                    bytes: 895,
+                    sha256: '40a0d73e5aa3afc3b6836bb289c79cf9556dd755a5086a9666506b31468b5d3d',
+                    version: 1,
+                },
+            ],
+        },
+    ],
+}));