@slicedearth/whoisleuth-cli 2.5.1 → 2.6.0

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 { 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');
@@ -151,7 +158,12 @@ export function validateCaseResponseReviewInputs(value) {
     }
     const hasPlatformRoutes = version >= PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION;
     const hasActionBinding = version >= PUBLISHED_V2_2_CASE_RESPONSE_REVIEW_INPUTS_VERSION;
-    const source = exactReviewRecord(value, hasActionBinding ? CASE_RESPONSE_REVIEW_INPUT_KEYS : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUT_KEYS, 'Case-response review inputs');
+    const source = exactReviewRecord(value, (hasActionBinding ? CASE_RESPONSE_REVIEW_INPUT_KEYS : PUBLISHED_V2_CASE_RESPONSE_REVIEW_INPUT_KEYS).filter(key => version >= 7 || key !== 'sourceQualifications'), 'Case-response review inputs');
+    if (version >= 7)
+        for (const qualification of boundedReviewArray(source.sourceQualifications, 1, 'Selected evidence source qualifications')) {
+            if (qualification !== CASE_SELECTED_EVIDENCE_SOURCE_LIMITATION)
+                throw new TypeError('Unknown selected-source qualification.');
+        }
     const profile = exactReviewRecord(source.profile, [
         'id', 'label', 'audience', 'subject', 'checklist', 'includedEvidence',
         'excludedEvidence', 'redactions',
@@ -236,7 +248,11 @@ export function validateCaseResponseReviewInputs(value) {
     for (const candidate of boundedReviewArray(source.selectedEvidence, MAX_RESPONSE_SELECTED_EVIDENCE, 'Case-response selected evidence')) {
         const evidence = exactReviewRecord(candidate, [
             'id', 'label', 'source', 'observedAt', 'completeness', 'limitations',
-        ], 'Case-response selected evidence item', version > PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION ? ['observationHostname', 'webObservationMode'] : []);
+        ], 'Case-response selected evidence item', [
+            ...(version > PUBLISHED_V2_3_CASE_RESPONSE_REVIEW_INPUTS_VERSION ? ['observationHostname', 'webObservationMode'] : []),
+            ...(version >= 6 ? ['responseObject'] : []),
+        ]);
+        readCaseResponseObject(evidence.responseObject);
         reviewText(evidence.id, 64, 'Case-response evidence id');
         reviewText(evidence.label, 80, 'Case-response evidence label');
         reviewText(evidence.source, 120, 'Case-response evidence source');
@@ -319,8 +335,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 +365,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 } : {}) });
@@ -376,7 +409,15 @@ export function validateCaseResponseReviewInputs(value) {
         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-workflow-metadata.mjs

@@ -102,15 +102,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/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/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,
+                },
+            ],
+        },
+    ],
+}));